diff --git a/runtime/include/current_sandbox.h b/runtime/include/current_sandbox.h index 48676fd..3f10268 100644 --- a/runtime/include/current_sandbox.h +++ b/runtime/include/current_sandbox.h @@ -4,7 +4,7 @@ #include "sandbox.h" #include "types.h" -extern http_parser_settings runtime__http_parser_settings; +extern http_parser_settings runtime_http_parser_settings; /** * Getter for the current sandbox executing on this thread diff --git a/runtime/include/runtime.h b/runtime/include/runtime.h index b45a6b5..19ab397 100644 --- a/runtime/include/runtime.h +++ b/runtime/include/runtime.h @@ -8,9 +8,9 @@ #include "sandbox.h" #include "types.h" -extern int runtime__epoll_file_descriptor; -extern struct deque_sandbox *runtime__global_deque; -extern pthread_mutex_t runtime__global_deque_mutex; +extern int runtime_epoll_file_descriptor; +extern struct deque_sandbox *runtime_global_deque; +extern pthread_mutex_t runtime_global_deque_mutex; extern __thread uv_loop_t worker_thread__uvio_handle; void alloc_linear_memory(void); @@ -18,7 +18,7 @@ void expand_memory(void); void free_linear_memory(void *base, u32 bound, u32 max); INLINE char *get_function_from_table(u32 idx, u32 type_id); INLINE char *get_memory_ptr_for_runtime(u32 offset, u32 bounds_check); -void runtime__initialize(void); +void runtime_initialize(void); void listener_thread_initialize(void); void stub_init(i32 offset); void * worker_thread__main(void *return_code); diff --git a/runtime/include/sandbox_request.h b/runtime/include/sandbox_request.h index 0a90875..bba5ca1 100644 --- a/runtime/include/sandbox_request.h +++ b/runtime/include/sandbox_request.h @@ -28,11 +28,11 @@ sandbox_request__push_to_dequeue(sandbox_request_t *sandbox_request) // TODO: Running the runtime and listener cores on a single shared core is untested // We are unsure if the locking behavior is correct, so there may be deadlocks #if NCORES == 1 - pthread_mutex_lock(&runtime__global_deque_mutex); + pthread_mutex_lock(&runtime_global_deque_mutex); #endif - return_code = deque_push_sandbox(runtime__global_deque, &sandbox_request); + return_code = deque_push_sandbox(runtime_global_deque, &sandbox_request); #if NCORES == 1 - pthread_mutex_unlock(&runtime__global_deque_mutex); + pthread_mutex_unlock(&runtime_global_deque_mutex); #endif return return_code; @@ -76,11 +76,11 @@ sandbox_request__pop_from_dequeue(sandbox_request_t **sandbox_request) // TODO: Running the runtime and listener cores on a single shared core is untested // We are unsure if the locking behavior is correct, so there may be deadlocks #if NCORES == 1 - pthread_mutex_lock(&runtime__global_deque_mutex); + pthread_mutex_lock(&runtime_global_deque_mutex); #endif - return_code = deque_pop_sandbox(runtime__global_deque, sandbox_request); + return_code = deque_pop_sandbox(runtime_global_deque, sandbox_request); #if NCORES == 1 - pthread_mutex_unlock(&runtime__global_deque_mutex); + pthread_mutex_unlock(&runtime_global_deque_mutex); #endif return return_code; } @@ -107,7 +107,7 @@ sandbox_request__steal_from_dequeue(void) #if NCORES == 1 sandbox_request__pop_from_dequeue(&sandbox_request); #else - int r = deque_steal_sandbox(runtime__global_deque, &sandbox_request); + int r = deque_steal_sandbox(runtime_global_deque, &sandbox_request); if (r) sandbox_request = NULL; #endif diff --git a/runtime/include/types.h b/runtime/include/types.h index c9a21be..f3cdf2c 100644 --- a/runtime/include/types.h +++ b/runtime/include/types.h @@ -81,7 +81,7 @@ extern __thread struct indirect_table_entry *module_indirect_table; // for sandbox linear memory isolation extern __thread void *sandbox_lmbase; extern __thread u32 sandbox_lmbound; -extern i32 runtime__log_file_descriptor; // TODO: LOG_TO_FILE logic is untested +extern i32 runtime_log_file_descriptor; // TODO: LOG_TO_FILE logic is untested // functions in the module to lookup and call per sandbox. typedef i32 (*mod_main_fn_t)(i32 a, i32 b); @@ -102,13 +102,13 @@ typedef enum /** * debuglog is a macro that behaves based on the macros DEBUG and LOG_TO_FILE * If DEBUG is not set, debuglog does nothing - * If DEBUG is set and LOG_TO_FILE is set, debuglog prints to the logfile defined in runtime__log_file_descriptor + * If DEBUG is set and LOG_TO_FILE is set, debuglog prints to the logfile defined in runtime_log_file_descriptor * If DEBUG is set adn LOG_TO_FILE is not set, debuglog prints to STDOUT **/ #ifdef DEBUG #ifdef LOG_TO_FILE -#define debuglog(fmt, ...) \ - dprintf(runtime__log_file_descriptor, "(%d,%lu) %s: " fmt, sched_getcpu(), pthread_self(), __func__, \ +#define debuglog(fmt, ...) \ + dprintf(runtime_log_file_descriptor, "(%d,%lu) %s: " fmt, sched_getcpu(), pthread_self(), __func__, \ ##__VA_ARGS__) #else // !LOG_TO_FILE #define debuglog(fmt, ...) printf("(%d,%lu) %s: " fmt, sched_getcpu(), pthread_self(), __func__, ##__VA_ARGS__) diff --git a/runtime/src/main.c b/runtime/src/main.c index 8be4eee..6719e42 100644 --- a/runtime/src/main.c +++ b/runtime/src/main.c @@ -15,14 +15,14 @@ // Conditionally used by debuglog when DEBUG is set #ifdef DEBUG -i32 runtime__log_file_descriptor = -1; +i32 runtime_log_file_descriptor = -1; #endif -u32 runtime__total_online_processors = 0; -u32 runtime__total_worker_processors = 0; -u32 runtime__first_worker_processor = 0; -int runtime__worker_threads_argument[WORKER_THREAD__CORE_COUNT] = { 0 }; // The worker sets its argument to -1 on error -pthread_t runtime__worker_threads[WORKER_THREAD__CORE_COUNT]; +u32 runtime_total_online_processors = 0; +u32 runtime_total_worker_processors = 0; +u32 runtime_first_worker_processor = 0; +int runtime_worker_threads_argument[WORKER_THREAD__CORE_COUNT] = { 0 }; // The worker sets its argument to -1 on error +pthread_t runtime_worker_threads[WORKER_THREAD__CORE_COUNT]; /** @@ -30,7 +30,7 @@ pthread_t runtime__worker_threads[WORKER_THREAD__CORE_COUNT]; * @param cmd - The command the user entered **/ static void -runtime__usage(char *cmd) +runtime_usage(char *cmd) { printf("%s \n", cmd); debuglog("%s \n", cmd); @@ -41,7 +41,7 @@ runtime__usage(char *cmd) * (RLIMIT_NOFILE) soft limit to its hard limit (see man getrlimit) **/ void -runtime__set_resource_limits_to_max() +runtime_set_resource_limits_to_max() { struct rlimit resource_limit; if (getrlimit(RLIMIT_DATA, &resource_limit) < 0) { @@ -68,27 +68,27 @@ runtime__set_resource_limits_to_max() * Check the number of cores and the compiler flags and allocate available cores **/ void -runtime__allocate_available_cores() +runtime_allocate_available_cores() { // Find the number of processors currently online - runtime__total_online_processors = sysconf(_SC_NPROCESSORS_ONLN); + runtime_total_online_processors = sysconf(_SC_NPROCESSORS_ONLN); // If multicore, we'll pin one core as a listener and run sandbox threads on all others - if (runtime__total_online_processors > 1) { - runtime__first_worker_processor = 1; + if (runtime_total_online_processors > 1) { + runtime_first_worker_processor = 1; // WORKER_THREAD__CORE_COUNT can be used as a cap on the number of cores to use // But if there are few cores that WORKER_THREAD__CORE_COUNT, just use what is available - u32 max_possible_workers = runtime__total_online_processors - 1; - runtime__total_worker_processors = (max_possible_workers >= WORKER_THREAD__CORE_COUNT) - ? WORKER_THREAD__CORE_COUNT - : max_possible_workers; + u32 max_possible_workers = runtime_total_online_processors - 1; + runtime_total_worker_processors = (max_possible_workers >= WORKER_THREAD__CORE_COUNT) + ? WORKER_THREAD__CORE_COUNT + : max_possible_workers; } else { // If single core, we'll do everything on CPUID 0 - runtime__first_worker_processor = 0; - runtime__total_worker_processors = 1; + runtime_first_worker_processor = 0; + runtime_total_worker_processors = 1; } debuglog("Number of cores %u, sandboxing cores %u (start: %u) and module reqs %u\n", - runtime__total_online_processors, runtime__total_worker_processors, runtime__first_worker_processor, + runtime_total_online_processors, runtime_total_worker_processors, runtime_first_worker_processor, LISTENER_THREAD__CORE_ID); } @@ -99,19 +99,19 @@ runtime__allocate_available_cores() * Otherwise, it writes to STDOUT **/ void -runtime__process_debug_log_behavior() +runtime_process_debug_log_behavior() { #ifdef LOG_TO_FILE fclose(stdout); fclose(stderr); fclose(stdin); - runtime__log_file_descriptor = open(RUNTIME__LOG_FILE, O_CREAT | O_TRUNC | O_WRONLY, S_IRWXU | S_IRWXG); - if (runtime__log_file_descriptor < 0) { + runtime_log_file_descriptor = open(RUNTIME__LOG_FILE, O_CREAT | O_TRUNC | O_WRONLY, S_IRWXU | S_IRWXG); + if (runtime_log_file_descriptor < 0) { perror("open"); exit(-1); } #else - runtime__log_file_descriptor = 1; + runtime_log_file_descriptor = 1; #endif // LOG_TO_FILE } #endif // DEBUG @@ -120,11 +120,11 @@ runtime__process_debug_log_behavior() * Starts all worker threads and sleeps forever on pthread_join, which should never return **/ void -runtime__start_runtime__worker_threads() +runtime_start_runtime_worker_threads() { - for (int i = 0; i < runtime__total_worker_processors; i++) { - int ret = pthread_create(&runtime__worker_threads[i], NULL, worker_thread__main, - (void *)&runtime__worker_threads_argument[i]); + for (int i = 0; i < runtime_total_worker_processors; i++) { + int ret = pthread_create(&runtime_worker_threads[i], NULL, worker_thread__main, + (void *)&runtime_worker_threads_argument[i]); if (ret) { errno = ret; perror("pthread_create"); @@ -133,14 +133,14 @@ runtime__start_runtime__worker_threads() cpu_set_t cs; CPU_ZERO(&cs); - CPU_SET(runtime__first_worker_processor + i, &cs); - ret = pthread_setaffinity_np(runtime__worker_threads[i], sizeof(cs), &cs); + CPU_SET(runtime_first_worker_processor + i, &cs); + ret = pthread_setaffinity_np(runtime_worker_threads[i], sizeof(cs), &cs); assert(ret == 0); } debuglog("Sandboxing environment ready!\n"); - for (int i = 0; i < runtime__total_worker_processors; i++) { - int ret = pthread_join(runtime__worker_threads[i], NULL); + for (int i = 0; i < runtime_total_worker_processors; i++) { + int ret = pthread_join(runtime_worker_threads[i], NULL); if (ret) { errno = ret; perror("pthread_join"); @@ -156,20 +156,20 @@ int main(int argc, char **argv) { #ifdef DEBUG - runtime__process_debug_log_behavior(); + runtime_process_debug_log_behavior(); #endif printf("Starting Awsm\n"); if (argc != 2) { - runtime__usage(argv[0]); + runtime_usage(argv[0]); exit(-1); } - memset(runtime__worker_threads, 0, sizeof(pthread_t) * WORKER_THREAD__CORE_COUNT); + memset(runtime_worker_threads, 0, sizeof(pthread_t) * WORKER_THREAD__CORE_COUNT); - runtime__set_resource_limits_to_max(); - runtime__allocate_available_cores(); - runtime__initialize(); + runtime_set_resource_limits_to_max(); + runtime_allocate_available_cores(); + runtime_initialize(); debuglog("Parsing modules file [%s]\n", argv[1]); if (module_new_from_json(argv[1])) { @@ -178,5 +178,5 @@ main(int argc, char **argv) } listener_thread_initialize(); - runtime__start_runtime__worker_threads(); + runtime_start_runtime_worker_threads(); } diff --git a/runtime/src/module.c b/runtime/src/module.c index 2a97f93..0bd28cc 100644 --- a/runtime/src/module.c +++ b/runtime/src/module.c @@ -50,7 +50,7 @@ module_initialize_as_server(struct module *module) struct epoll_event accept_evt; accept_evt.data.ptr = (void *)module; accept_evt.events = EPOLLIN; - if (epoll_ctl(runtime__epoll_file_descriptor, EPOLL_CTL_ADD, module->socket_descriptor, &accept_evt) < 0) + if (epoll_ctl(runtime_epoll_file_descriptor, EPOLL_CTL_ADD, module->socket_descriptor, &accept_evt) < 0) assert(0); } diff --git a/runtime/src/runtime.c b/runtime/src/runtime.c index d5aeded..c33c266 100644 --- a/runtime/src/runtime.c +++ b/runtime/src/runtime.c @@ -28,10 +28,10 @@ * Shared Process State * **************************/ -struct deque_sandbox *runtime__global_deque; -pthread_mutex_t runtime__global_deque_mutex = PTHREAD_MUTEX_INITIALIZER; -int runtime__epoll_file_descriptor; -http_parser_settings runtime__http_parser_settings; +struct deque_sandbox *runtime_global_deque; +pthread_mutex_t runtime_global_deque_mutex = PTHREAD_MUTEX_INITIALIZER; +int runtime_epoll_file_descriptor; +http_parser_settings runtime_http_parser_settings; /****************************************** * Shared Process / Listener Thread Logic * @@ -41,23 +41,23 @@ http_parser_settings runtime__http_parser_settings; * Initialize runtime global state, mask signals, and init http parser */ void -runtime__initialize(void) +runtime_initialize(void) { - runtime__epoll_file_descriptor = epoll_create1(0); - assert(runtime__epoll_file_descriptor >= 0); + runtime_epoll_file_descriptor = epoll_create1(0); + assert(runtime_epoll_file_descriptor >= 0); // Allocate and Initialize the global deque - runtime__global_deque = (struct deque_sandbox *)malloc(sizeof(struct deque_sandbox)); - assert(runtime__global_deque); + runtime_global_deque = (struct deque_sandbox *)malloc(sizeof(struct deque_sandbox)); + assert(runtime_global_deque); // Note: Below is a Macro - deque_init_sandbox(runtime__global_deque, RUNTIME__MAX_SANDBOX_REQUEST_COUNT); + deque_init_sandbox(runtime_global_deque, RUNTIME__MAX_SANDBOX_REQUEST_COUNT); // Mask Signals software_interrupt__mask_signal(SIGUSR1); software_interrupt__mask_signal(SIGALRM); // Initialize http_parser_settings global - http_parser_settings_initialize(&runtime__http_parser_settings); + http_parser_settings_initialize(&runtime_http_parser_settings); } /******************************** @@ -71,7 +71,7 @@ runtime__initialize(void) * @return NULL * * Used Globals: - * runtime__epoll_file_descriptor - the epoll file descriptor + * runtime_epoll_file_descriptor - the epoll file descriptor * */ void * @@ -82,7 +82,7 @@ listener_thread_main(void *dummy) int total_requests = 0; while (true) { - int request_count = epoll_wait(runtime__epoll_file_descriptor, epoll_events, + int request_count = epoll_wait(runtime_epoll_file_descriptor, epoll_events, LISTENER_THREAD__MAX_EPOLL_EVENTS, -1); u64 start_time = util__rdtsc(); for (int i = 0; i < request_count; i++) { diff --git a/runtime/src/sandbox.c b/runtime/src/sandbox.c index bf2a8df..5ff9f92 100644 --- a/runtime/src/sandbox.c +++ b/runtime/src/sandbox.c @@ -47,14 +47,14 @@ current_sandbox_setup_arguments(i32 argument_count) * @param length The size of the request_response_data that we want to parse * @returns 0 * - * Globals: runtime__http_parser_settings + * Globals: runtime_http_parser_settings **/ int sandbox__parse_http_request(struct sandbox *sandbox, size_t length) { // Why is our start address sandbox->request_response_data + sandbox->request_response_data_length? // it's like a cursor to keep track of what we've read so far - http_parser_execute(&sandbox->http_parser, &runtime__http_parser_settings, + http_parser_execute(&sandbox->http_parser, &runtime_http_parser_settings, sandbox->request_response_data + sandbox->request_response_data_length, length); return 0; } diff --git a/runtime/src/software_interrupt.c b/runtime/src/software_interrupt.c index d8899f5..98f826a 100644 --- a/runtime/src/software_interrupt.c +++ b/runtime/src/software_interrupt.c @@ -32,7 +32,7 @@ __thread volatile sig_atomic_t software_interrupt__is_disabled = 0; * Externs ***************************************/ -extern pthread_t runtime__worker_threads[]; +extern pthread_t runtime_worker_threads[]; /*************************************** * Private Static Inlines @@ -65,11 +65,11 @@ software_interrupt__handle_signals(int signal_type, siginfo_t *signal_info, void int rt = 0; // deliver signal to all other runtime threads.. for (int i = 0; i < WORKER_THREAD__CORE_COUNT; i++) { - if (pthread_self() == runtime__worker_threads[i]) { + if (pthread_self() == runtime_worker_threads[i]) { rt = 1; continue; } - pthread_kill(runtime__worker_threads[i], SIGALRM); + pthread_kill(runtime_worker_threads[i], SIGALRM); } assert(rt == 1); } else {