From 7ba5a3acbec43f8d3ca4f703190a5232723f4f47 Mon Sep 17 00:00:00 2001 From: Sean McBride Date: Wed, 18 Mar 2020 16:23:11 -0400 Subject: [PATCH] chore: rename softint to software_interrupt --- runtime/include/softint.h | 24 +++++++++--------- runtime/src/module.c | 2 ++ runtime/src/runtime.c | 36 +++++++++++++-------------- runtime/src/sandbox.c | 4 +-- runtime/src/softint.c | 52 ++++++++++++++++++++------------------- 5 files changed, 61 insertions(+), 57 deletions(-) diff --git a/runtime/include/softint.h b/runtime/include/softint.h index 1e72cac..75b953c 100644 --- a/runtime/include/softint.h +++ b/runtime/include/softint.h @@ -9,16 +9,16 @@ * Externs ***************************************/ -extern __thread volatile sig_atomic_t softint__is_disabled; +extern __thread volatile sig_atomic_t software_interrupt__is_disabled; /*************************************** * Public Static Inlines ***************************************/ static inline void -softint__disable(void) +software_interrupt__disable(void) { - while (__sync_bool_compare_and_swap(&softint__is_disabled, 0, 1) == false) + while (__sync_bool_compare_and_swap(&software_interrupt__is_disabled, 0, 1) == false) ; } @@ -27,18 +27,18 @@ softint__disable(void) * Enables signals */ static inline void -softint__enable(void) +software_interrupt__enable(void) { - if (__sync_bool_compare_and_swap(&softint__is_disabled, 1, 0) == false) assert(0); + if (__sync_bool_compare_and_swap(&software_interrupt__is_disabled, 1, 0) == false) assert(0); } /** * @returns boolean if signals are enabled */ static inline int -softint__is_enabled(void) +software_interrupt__is_enabled(void) { - return (softint__is_disabled == 0); + return (software_interrupt__is_disabled == 0); } /** @@ -47,7 +47,7 @@ softint__is_enabled(void) * @return 0 on success. Exits program otherwise **/ static inline int -softint__mask(int signal) +software_interrupt__mask(int signal) { sigset_t set; int return_code; @@ -72,7 +72,7 @@ softint__mask(int signal) * @return 0 on success. Exits program otherwise **/ static inline int -softint__unmask(int signal) +software_interrupt__unmask(int signal) { sigset_t set; int return_code; @@ -95,8 +95,8 @@ softint__unmask(int signal) * Exports from module.c ***************************************/ -void softint__initialize(void); -void softint__arm_timer(void); -void softint__disarm_timer(void); +void software_interrupt__initialize(void); +void software_interrupt__arm_timer(void); +void software_interrupt__disarm_timer(void); #endif /* SFRT_SOFTINT_H */ diff --git a/runtime/src/module.c b/runtime/src/module.c index ef190b2..f02faa4 100644 --- a/runtime/src/module.c +++ b/runtime/src/module.c @@ -62,6 +62,8 @@ module__initialize_as_server(struct module *module) * Module Mega Teardown Function * Closes the socket and dynamic library, and then frees the module * Returns harmlessly if there are outstanding references + * + * TODO: Untested Functionality. Unsure if this will work * @param module - the module to teardown **/ void diff --git a/runtime/src/runtime.c b/runtime/src/runtime.c index e5f82d1..b6e8228 100644 --- a/runtime/src/runtime.c +++ b/runtime/src/runtime.c @@ -44,8 +44,8 @@ runtime__initialize(void) deque_init_sandbox(runtime__global_deque, SBOX_MAX_REQS); // Mask Signals - softint__mask(SIGUSR1); - softint__mask(SIGALRM); + software_interrupt__mask(SIGUSR1); + software_interrupt__mask(SIGALRM); // Initialize http_parser_settings global http_parser_settings__initialize(&runtime__http_parser_settings); @@ -126,8 +126,8 @@ listener_thread__initialize(void) ret = pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cs); assert(ret == 0); - softint__initialize(); - softint__arm_timer(); + software_interrupt__initialize(); + software_interrupt__arm_timer(); } /*************************** @@ -168,7 +168,7 @@ static inline void worker_thread__switch_to_sandbox(struct sandbox *next_sandbox) { arch_context_t *next_register_context = next_sandbox == NULL ? NULL : &next_sandbox->ctxt; - softint__disable(); + software_interrupt__disable(); struct sandbox *current_sandbox = current_sandbox__get(); arch_context_t *current_register_context = current_sandbox == NULL ? NULL : ¤t_sandbox->ctxt; current_sandbox__set(next_sandbox); @@ -177,7 +177,7 @@ worker_thread__switch_to_sandbox(struct sandbox *next_sandbox) worker_thread__completion_queue__add_sandbox(current_sandbox); worker_thread__next_context = next_register_context; arch_context_switch(current_register_context, next_register_context); - softint__enable(); + software_interrupt__enable(); } /** @@ -187,7 +187,7 @@ worker_thread__switch_to_sandbox(struct sandbox *next_sandbox) void worker_thread__wakeup_sandbox(sandbox_t *sandbox) { - softint__disable(); + software_interrupt__disable(); debuglog("[%p: %s]\n", sandbox, sandbox->module->name); if (sandbox->state != BLOCKED) goto done; assert(sandbox->state == BLOCKED); @@ -195,7 +195,7 @@ worker_thread__wakeup_sandbox(sandbox_t *sandbox) sandbox->state = RUNNABLE; ps_list_head_append_d(&worker_thread__run_queue, sandbox); done: - softint__enable(); + software_interrupt__enable(); } @@ -207,14 +207,14 @@ void worker_thread__block_current_sandbox(void) { assert(worker_thread__is_in_callback == 0); - softint__disable(); + software_interrupt__disable(); struct sandbox *current_sandbox = current_sandbox__get(); ps_list_rem_d(current_sandbox); current_sandbox->state = BLOCKED; struct sandbox *next_sandbox = worker_thread__get_next_sandbox(0); debuglog("[%p: %next_sandbox, %p: %next_sandbox]\n", current_sandbox, current_sandbox->module->name, next_sandbox, next_sandbox ? next_sandbox->module->name : ""); - softint__enable(); + software_interrupt__enable(); worker_thread__switch_to_sandbox(next_sandbox); } @@ -395,9 +395,9 @@ worker_thread__single_loop(void) if (!worker_thread__is_in_callback) worker_thread__execute_libuv_event_loop(); // Get and return the sandbox at the head of the thread local runqueue - softint__disable(); + software_interrupt__disable(); struct sandbox *sandbox = worker_thread__get_next_sandbox(0); - softint__enable(); + software_interrupt__enable(); assert(sandbox == NULL || sandbox->state == RUNNABLE); return sandbox; } @@ -414,11 +414,11 @@ worker_thread__main(void *return_code) ps_list_head_init(&worker_thread__run_queue); ps_list_head_init(&worker_thread__completion_queue); - softint__is_disabled = 0; - worker_thread__next_context = NULL; + software_interrupt__is_disabled = 0; + worker_thread__next_context = NULL; #ifndef PREEMPT_DISABLE - softint__unmask(SIGALRM); - softint__unmask(SIGUSR1); + software_interrupt__unmask(SIGALRM); + software_interrupt__unmask(SIGUSR1); #endif uv_loop_init(&worker_thread__uvio_handle); worker_thread__is_in_callback = 0; @@ -446,13 +446,13 @@ worker_thread__current_sandbox__exit(void) { struct sandbox *current_sandbox = current_sandbox__get(); assert(current_sandbox); - softint__disable(); + software_interrupt__disable(); worker_thread__run_queue__remove_sandbox(current_sandbox); current_sandbox->state = RETURNED; struct sandbox *next_sandbox = worker_thread__get_next_sandbox(0); assert(next_sandbox != current_sandbox); - softint__enable(); + software_interrupt__enable(); // free resources from "main function execution", as stack still in use. // unmap linear memory only! munmap(current_sandbox->linear_memory_start, SBOX_MAX_MEM + PAGE_SIZE); diff --git a/runtime/src/sandbox.c b/runtime/src/sandbox.c index 33bd0e6..3608804 100644 --- a/runtime/src/sandbox.c +++ b/runtime/src/sandbox.c @@ -178,10 +178,10 @@ current_sandbox__main(void) // FIXME: is this right? this is the first time this sandbox is running.. so it wont // return to worker_thread__switch_to_sandbox() api.. // we'd potentially do what we'd in worker_thread__switch_to_sandbox() api here for cleanup.. - if (!softint__is_enabled()) { + if (!software_interrupt__is_enabled()) { arch_context_init(¤t_sandbox->ctxt, 0, 0); worker_thread__next_context = NULL; - softint__enable(); + software_interrupt__enable(); } struct module *current_module = sandbox__get_module(current_sandbox); int argument_count = module__get_argument_count(current_module); diff --git a/runtime/src/softint.c b/runtime/src/softint.c index 95ecca1..f4cb05e 100644 --- a/runtime/src/softint.c +++ b/runtime/src/softint.c @@ -18,15 +18,15 @@ * Process Globals ***************************************/ -static const int softint__supported_signals[] = { SIGALRM, SIGUSR1 }; +static const int software_interrupt__supported_signals[] = { SIGALRM, SIGUSR1 }; /*************************************** * Thread Globals ***************************************/ -__thread static volatile sig_atomic_t softint__SIGALRM_count = 0; -__thread static volatile sig_atomic_t softint__SIGUSR_count = 0; -__thread volatile sig_atomic_t softint__is_disabled = 0; +__thread static volatile sig_atomic_t software_interrupt__SIGALRM_count = 0; +__thread static volatile sig_atomic_t software_interrupt__SIGUSR_count = 0; +__thread volatile sig_atomic_t software_interrupt__is_disabled = 0; /*************************************** * Externs @@ -38,8 +38,8 @@ extern pthread_t worker_threads[]; * Private Static Inlines ***************************************/ -static inline void softint__handle_signals(int signal_type, siginfo_t *signal_info, void *user_context_raw); -static inline void softint__schedule_alarm(void *user_context_raw); +static inline void software_interrupt__handle_signals(int signal_type, siginfo_t *signal_info, void *user_context_raw); +static inline void software_interrupt__schedule_alarm(void *user_context_raw); /** * The handler function for Software Interrupts (signals) @@ -50,7 +50,7 @@ static inline void softint__schedule_alarm(void *user_context_raw); * @param user_context_raw void* to a user_context struct **/ static inline void -softint__handle_signals(int signal_type, siginfo_t *signal_info, void *user_context_raw) +software_interrupt__handle_signals(int signal_type, siginfo_t *signal_info, void *user_context_raw) { #ifdef PREEMPT_DISABLE assert(0); @@ -75,33 +75,33 @@ softint__handle_signals(int signal_type, siginfo_t *signal_info, void *user_cont } else { assert(signal_info->si_code == SI_TKILL); } - // debuglog("alrm:%d\n", softint__SIGALRM_count); + // debuglog("alrm:%d\n", software_interrupt__SIGALRM_count); - softint__SIGALRM_count++; - // softint__supported_signals per-core.. + software_interrupt__SIGALRM_count++; + // software_interrupt__supported_signals per-core.. if (curr && curr->state == RETURNED) return; if (worker_thread__next_context) return; - if (!softint__is_enabled()) return; - softint__schedule_alarm(user_context_raw); + if (!software_interrupt__is_enabled()) return; + software_interrupt__schedule_alarm(user_context_raw); break; } case SIGUSR1: { // make sure sigalrm doesn't mess this up if nested.. - assert(!softint__is_enabled()); + assert(!software_interrupt__is_enabled()); /* we set current before calling pthread_kill! */ assert(worker_thread__next_context && (&curr->ctxt == worker_thread__next_context)); assert(signal_info->si_code == SI_TKILL); - // debuglog("usr1:%d\n", softint__SIGUSR_count); + // debuglog("usr1:%d\n", software_interrupt__SIGUSR_count); - softint__SIGUSR_count++; + software_interrupt__SIGUSR_count++; // do not save current sandbox.. it is in co-operative switch.. // pick the next from "worker_thread__next_context".. // assert its "sp" to be zero in regs.. // memcpy from next context.. arch_mcontext_restore(&user_context->uc_mcontext, &curr->ctxt); worker_thread__next_context = NULL; - softint__enable(); + software_interrupt__enable(); break; } default: @@ -115,9 +115,9 @@ softint__handle_signals(int signal_type, siginfo_t *signal_info, void *user_cont * @param user_context_raw void* to a user_context struct **/ static inline void -softint__schedule_alarm(void *user_context_raw) +software_interrupt__schedule_alarm(void *user_context_raw) { - softint__disable(); // no nesting! + software_interrupt__disable(); // no nesting! struct sandbox *curr = current_sandbox__get(); ucontext_t * user_context = (ucontext_t *)user_context_raw; @@ -142,7 +142,7 @@ softint__schedule_alarm(void *user_context_raw) // worker_thread__next_context = NULL; done: - softint__enable(); + software_interrupt__enable(); skip: return; } @@ -155,7 +155,7 @@ skip: * Arms the Interval Timer to start in 10ms and then trigger a SIGALRM every 5ms **/ void -softint__arm_timer(void) +software_interrupt__arm_timer(void) { #ifndef PREEMPT_DISABLE struct itimerval interval_timer; @@ -176,7 +176,7 @@ softint__arm_timer(void) * Disarm the Interval Timer **/ void -softint__disarm_timer(void) +software_interrupt__disarm_timer(void) { struct itimerval interval_timer; @@ -197,15 +197,17 @@ softint__disarm_timer(void) * Register sonftint_handler to execute on SIGALRM and SIGUSR1 **/ void -softint__initialize(void) +software_interrupt__initialize(void) { struct sigaction signal_action; memset(&signal_action, 0, sizeof(struct sigaction)); - signal_action.sa_sigaction = softint__handle_signals; + signal_action.sa_sigaction = software_interrupt__handle_signals; signal_action.sa_flags = SA_SIGINFO | SA_RESTART; - for (int i = 0; i < (sizeof(softint__supported_signals) / sizeof(softint__supported_signals[0])); i++) { - int return_code = sigaction(softint__supported_signals[i], &signal_action, NULL); + for (int i = 0; + i < (sizeof(software_interrupt__supported_signals) / sizeof(software_interrupt__supported_signals[0])); + i++) { + int return_code = sigaction(software_interrupt__supported_signals[i], &signal_action, NULL); if (return_code) { perror("sigaction"); exit(1);