nijinlong1
/
sledge
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix: namespace sandbox states

Browse Source
sledge_graph
Sean McBride 5 years ago
parent b4fe9a537e
commit 47f24b6952
6 changed files with 23 additions and 23 deletions
Show Stats Download Patch File Download Diff File

8
runtime/include/sandbox.h
Unescape View File

@ -24,10 +24,10 @@ struct sandbox_io_handle {
typedef enum typedef enum
{ {
INITIALIZING, SANDBOX_INITIALIZING,
RUNNABLE, SANDBOX_RUNNABLE,
BLOCKED, SANDBOX_BLOCKED,
RETURNED SANDBOX_RETURNED
} sandbox_state_t; } sandbox_state_t;
struct sandbox { struct sandbox {

4
runtime/src/local_runqueue_list.c
Unescape View File

@ -56,14 +56,14 @@ local_runqueue_list_get_next()
struct sandbox *sandbox = sandbox_allocate(sandbox_request); struct sandbox *sandbox = sandbox_allocate(sandbox_request);
assert(sandbox); assert(sandbox);
free(sandbox_request); free(sandbox_request);
sandbox->state = RUNNABLE; sandbox->state = SANDBOX_RUNNABLE;
local_runqueue_add(sandbox); local_runqueue_add(sandbox);
return sandbox; return sandbox;
} }
/* Execute Round Robin Scheduling Logic */ /* Execute Round Robin Scheduling Logic */
struct sandbox *next_sandbox = local_runqueue_list_remove_and_return(); struct sandbox *next_sandbox = local_runqueue_list_remove_and_return();
assert(next_sandbox->state != RETURNED); assert(next_sandbox->state != SANDBOX_RETURNED);
local_runqueue_add(next_sandbox); local_runqueue_add(next_sandbox);
debuglog("[%p: %s]\n", next_sandbox, next_sandbox->module->name); debuglog("[%p: %s]\n", next_sandbox, next_sandbox->module->name);

4
runtime/src/local_runqueue_minheap.c
Unescape View File

@ -89,7 +89,7 @@ local_runqueue_minheap_get_next()
sandbox = sandbox_allocate(sandbox_request); sandbox = sandbox_allocate(sandbox_request);
assert(sandbox); assert(sandbox);
free(sandbox_request); free(sandbox_request);
sandbox->state = RUNNABLE; sandbox->state = SANDBOX_RUNNABLE;
local_runqueue_minheap_add(sandbox); local_runqueue_minheap_add(sandbox);
} else if (sandbox_rc == -2) { } else if (sandbox_rc == -2) {
/* Unable to take lock, so just return NULL and try later */ /* Unable to take lock, so just return NULL and try later */
@ -143,7 +143,7 @@ local_runqueue_minheap_preempt(ucontext_t *user_context)
struct sandbox *next_sandbox = sandbox_allocate(sandbox_request); struct sandbox *next_sandbox = sandbox_allocate(sandbox_request);
assert(next_sandbox); assert(next_sandbox);
free(sandbox_request); free(sandbox_request);
next_sandbox->state = RUNNABLE; next_sandbox->state = SANDBOX_RUNNABLE;
/* Add it to the runqueue */ /* Add it to the runqueue */
local_runqueue_add(next_sandbox); local_runqueue_add(next_sandbox);

6
runtime/src/sandbox.c
Unescape View File

@ -241,7 +241,7 @@ current_sandbox_main(void)
{ {
struct sandbox *sandbox = current_sandbox_get(); struct sandbox *sandbox = current_sandbox_get();
assert(sandbox != NULL); assert(sandbox != NULL);
assert(sandbox->state == RUNNABLE); assert(sandbox->state == SANDBOX_RUNNABLE);
assert(!software_interrupt_is_enabled()); assert(!software_interrupt_is_enabled());
arch_context_init(&sandbox->ctxt, 0, 0); arch_context_init(&sandbox->ctxt, 0, 0);
@ -375,7 +375,7 @@ sandbox_allocate(sandbox_request_t *sandbox_request)
if (!sandbox) goto err_memory_allocation_failed; if (!sandbox) goto err_memory_allocation_failed;
/* Set state to initializing */ /* Set state to initializing */
sandbox->state = INITIALIZING; sandbox->state = SANDBOX_INITIALIZING;
/* Allocate the Stack */ /* Allocate the Stack */
rc = sandbox_allocate_stack(sandbox); rc = sandbox_allocate_stack(sandbox);
@ -421,7 +421,7 @@ sandbox_free(struct sandbox *sandbox)
{ {
assert(sandbox != NULL); assert(sandbox != NULL);
assert(sandbox != current_sandbox_get()); assert(sandbox != current_sandbox_get());
assert(sandbox->state == INITIALIZING || sandbox->state == RETURNED); assert(sandbox->state == SANDBOX_INITIALIZING || sandbox->state == SANDBOX_RETURNED);
char *error_message = NULL; char *error_message = NULL;
int rc; int rc;

4
runtime/src/software_interrupt.c
Unescape View File

@ -78,8 +78,8 @@ software_interrupt_handle_signals(int signal_type, siginfo_t *signal_info, void
software_interrupt_SIGALRM_count++; software_interrupt_SIGALRM_count++;
/* if the current sandbox is NULL or not in a RETURNED state */ /* if the current sandbox is NULL or not in a returned state */
if (current_sandbox && current_sandbox->state == RETURNED) return; if (current_sandbox && current_sandbox->state == SANDBOX_RETURNED) return;
/* and the next context is NULL */ /* and the next context is NULL */
if (worker_thread_next_context) return; if (worker_thread_next_context) return;
/* and software interrupts are not disabled */ /* and software interrupts are not disabled */

20
runtime/src/worker_thread.c
Unescape View File

@ -37,7 +37,7 @@ static __thread bool worker_thread_is_in_callback;
**********************/ **********************/
/** /**
* @brief Switches to the next sandbox, placing the current sandbox on the completion queue if in RETURNED state * @brief Switches to the next sandbox, placing the current sandbox on the completion queue if in SANDBOX_RETURNED state
* @param next_sandbox The Sandbox Context to switch to or NULL, which forces return to base context * @param next_sandbox The Sandbox Context to switch to or NULL, which forces return to base context
* @return void * @return void
*/ */
@ -62,11 +62,11 @@ worker_thread_switch_to_sandbox(struct sandbox *next_sandbox)
worker_thread_next_context = next_register_context; worker_thread_next_context = next_register_context;
arch_context_switch(previous_register_context, next_register_context); arch_context_switch(previous_register_context, next_register_context);
assert(previous_sandbox == NULL || previous_sandbox->state == RUNNABLE || previous_sandbox->state == BLOCKED assert(previous_sandbox == NULL || previous_sandbox->state == SANDBOX_RUNNABLE
|| previous_sandbox->state == RETURNED); || previous_sandbox->state == SANDBOX_BLOCKED || previous_sandbox->state == SANDBOX_RETURNED);
/* If the current sandbox we're switching from is in a RETURNED state, add to completion queue */ /* If the current sandbox we're switching from is in a SANDBOX_RETURNED state, add to completion queue */
if (previous_sandbox != NULL && previous_sandbox->state == RETURNED) { if (previous_sandbox != NULL && previous_sandbox->state == SANDBOX_RETURNED) {
local_completion_queue_add(previous_sandbox); local_completion_queue_add(previous_sandbox);
} else if (previous_sandbox != NULL) { } else if (previous_sandbox != NULL) {
debuglog("Switched away from sandbox is state %d\n", previous_sandbox->state); debuglog("Switched away from sandbox is state %d\n", previous_sandbox->state);
@ -83,9 +83,9 @@ void
worker_thread_wakeup_sandbox(sandbox_t *sandbox) worker_thread_wakeup_sandbox(sandbox_t *sandbox)
{ {
software_interrupt_disable(); software_interrupt_disable();
if (sandbox->state != BLOCKED) goto done; if (sandbox->state != SANDBOX_BLOCKED) goto done;
sandbox->state = RUNNABLE; sandbox->state = SANDBOX_RUNNABLE;
debuglog("Marking blocked sandbox as runnable\n"); debuglog("Marking blocked sandbox as runnable\n");
local_runqueue_add(sandbox); local_runqueue_add(sandbox);
@ -107,7 +107,7 @@ worker_thread_block_current_sandbox(void)
/* Remove the sandbox we were just executing from the runqueue and mark as blocked */ /* Remove the sandbox we were just executing from the runqueue and mark as blocked */
struct sandbox *previous_sandbox = current_sandbox_get(); struct sandbox *previous_sandbox = current_sandbox_get();
local_runqueue_delete(previous_sandbox); local_runqueue_delete(previous_sandbox);
previous_sandbox->state = BLOCKED; previous_sandbox->state = SANDBOX_BLOCKED;
/* Switch to the next sandbox */ /* Switch to the next sandbox */
struct sandbox *next_sandbox = local_runqueue_get_next(); struct sandbox *next_sandbox = local_runqueue_get_next();
@ -211,7 +211,7 @@ worker_thread_main(void *return_code)
/** /**
* Called when the function in the sandbox exits * Called when the function in the sandbox exits
* Removes the standbox from the thread-local runqueue, sets its state to RETURNED, * Removes the standbox from the thread-local runqueue, sets its state to SANDBOX_RETURNED,
* releases the linear memory, and then switches to the sandbox at the head of the runqueue * releases the linear memory, and then switches to the sandbox at the head of the runqueue
* TODO: Consider moving this to a future current_sandbox file. This has thus far proven difficult to move * TODO: Consider moving this to a future current_sandbox file. This has thus far proven difficult to move
*/ */
@ -223,7 +223,7 @@ worker_thread_on_sandbox_exit(sandbox_t *exiting_sandbox)
/* TODO: I do not understand when software interrupts must be disabled? */ /* TODO: I do not understand when software interrupts must be disabled? */
software_interrupt_disable(); software_interrupt_disable();
local_runqueue_delete(exiting_sandbox); local_runqueue_delete(exiting_sandbox);
exiting_sandbox->state = RETURNED; exiting_sandbox->state = SANDBOX_RETURNED;
software_interrupt_enable(); software_interrupt_enable();
/* Because the stack is still in use, only unmap linear memory and defer free resources until "main /* Because the stack is still in use, only unmap linear memory and defer free resources until "main

Write Preview
Loading…
Cancel
Save