From c9b9a6553ebddca0b229f2e9c851c1b3d9dc8d11 Mon Sep 17 00:00:00 2001 From: Sean McBride Date: Tue, 17 Mar 2020 16:02:22 -0400 Subject: [PATCH] chore: run clang-format --- .clang-format | 1 - runtime/include/arch/aarch64/context.h | 2 +- runtime/include/current_sandbox.h | 4 +- runtime/include/http/http_parser_settings.h | 32 +++--- runtime/include/http/http_request.h | 5 +- runtime/include/libuv_callbacks.h | 13 +-- runtime/include/module.h | 31 +++--- runtime/include/module_database.h | 2 +- runtime/include/runtime.h | 2 +- runtime/include/sandbox.h | 43 ++++---- runtime/include/sandbox_request.h | 15 +-- runtime/include/types.h | 69 ++++++------- runtime/src/http/http_request.c | 1 - runtime/src/http/http_response.c | 7 +- runtime/src/libc/uvio.c | 105 ++++++++++---------- runtime/src/module.c | 17 ++-- runtime/src/module_database.c | 2 +- runtime/src/runtime.c | 52 +++++----- runtime/src/sandbox.c | 63 +++++++----- runtime/src/softint.c | 3 +- 20 files changed, 247 insertions(+), 222 deletions(-) diff --git a/.clang-format b/.clang-format index b10603d..80b850d 100644 --- a/.clang-format +++ b/.clang-format @@ -6,7 +6,6 @@ Language: Cpp AlignAfterOpenBracket: Align AlignConsecutiveAssignments: true AlignConsecutiveDeclarations: true -AlignConsecutiveMacros: true AlignEscapedNewlines: Left AlignTrailingComments: true diff --git a/runtime/include/arch/aarch64/context.h b/runtime/include/arch/aarch64/context.h index dc05c58..b789034 100644 --- a/runtime/include/arch/aarch64/context.h +++ b/runtime/include/arch/aarch64/context.h @@ -17,7 +17,7 @@ struct arch_context { mcontext_t mctx; }; -typedef struct arch_context arch_context_t; +typedef struct arch_context arch_context_t; extern void __attribute__((noreturn)) worker_thread__sandbox_switch_preempt(void); extern __thread arch_context_t worker_thread__base_context; diff --git a/runtime/include/current_sandbox.h b/runtime/include/current_sandbox.h index 8f72ef5..10393be 100644 --- a/runtime/include/current_sandbox.h +++ b/runtime/include/current_sandbox.h @@ -28,8 +28,8 @@ current_sandbox__set(struct sandbox *sandbox) if (sandbox == NULL) return; // Thread Local State about the Current Sandbox - sandbox_lmbase = sandbox->linear_memory_start; - sandbox_lmbound = sandbox->linear_memory_size; + sandbox_lmbase = sandbox->linear_memory_start; + sandbox_lmbound = sandbox->linear_memory_size; module_indirect_table = sandbox->module->indirect_table; } diff --git a/runtime/include/http/http_parser_settings.h b/runtime/include/http/http_parser_settings.h index fed0bb3..f833332 100644 --- a/runtime/include/http/http_parser_settings.h +++ b/runtime/include/http/http_parser_settings.h @@ -13,7 +13,8 @@ /** * http-parser data callback called when a URL is called * Sanity check to make sure that the path matches the name of the module - * TODO: Why does this not fail this assertion? To execute fibonacci, I just request localhost:10000, not localhost:10000/fibonacci + * TODO: Why does this not fail this assertion? To execute fibonacci, I just request localhost:10000, not + *localhost:10000/fibonacci * @param parser * @param at the start of the URL * @param length the length of the URL @@ -22,7 +23,7 @@ static inline int http_parser_settings__on_url(http_parser *parser, const char *at, size_t length) { - struct sandbox *sandbox = (struct sandbox *) parser->data; + struct sandbox *sandbox = (struct sandbox *)parser->data; assert(strncmp(sandbox->module->name, (at + 1), length - 1) == 0); return 0; @@ -36,7 +37,7 @@ http_parser_settings__on_url(http_parser *parser, const char *at, size_t length) static inline int http_parser_settings__on_message_begin(http_parser *parser) { - struct sandbox * sandbox = (struct sandbox *) parser->data; + struct sandbox * sandbox = (struct sandbox *)parser->data; struct http_request *http_request = &sandbox->http_request; http_request->message_begin = 1; @@ -49,7 +50,8 @@ http_parser_settings__on_message_begin(http_parser *parser) * Sets the key value of the latest header * on a new header if last_was_value is true * updating an existing header if last_was_value is false - * TODO: Is this logic correct? What is the relationship between fields and values? Is overwrite the correct logic if on_header executes twice in a row? + * TODO: Is this logic correct? What is the relationship between fields and values? Is overwrite the correct logic if + *on_header executes twice in a row? * @param parser * @param at start address of the header field * @param length length of the header field @@ -58,15 +60,16 @@ http_parser_settings__on_message_begin(http_parser *parser) static inline int http_parser_settings__on_header_field(http_parser *parser, const char *at, size_t length) { - struct sandbox * sandbox = (struct sandbox *) parser->data; + struct sandbox * sandbox = (struct sandbox *)parser->data; struct http_request *http_request = &sandbox->http_request; if (http_request->last_was_value) http_request->header_count++; assert(http_request->header_count <= HTTP_HEADERS_MAX); assert(length < HTTP_HEADER_MAXSZ); - http_request->last_was_value = 0; - http_request->headers[http_request->header_count - 1].key = (char *)at; // it is from the sandbox's request_response_data, should persist. + http_request->last_was_value = 0; + http_request->headers[http_request->header_count - 1].key = (char *) + at; // it is from the sandbox's request_response_data, should persist. return 0; } @@ -82,14 +85,15 @@ http_parser_settings__on_header_field(http_parser *parser, const char *at, size_ static inline int http_parser_settings__on_header_value(http_parser *parser, const char *at, size_t length) { - struct sandbox * sandbox = (struct sandbox *) parser->data; + struct sandbox * sandbox = (struct sandbox *)parser->data; struct http_request *http_request = &sandbox->http_request; http_request->last_was_value = 1; assert(http_request->header_count <= HTTP_HEADERS_MAX); assert(length < HTTP_HEADERVAL_MAXSZ); - http_request->headers[http_request->header_count - 1].value = (char *)at; // it is from the sandbox's request_response_data, should persist. + http_request->headers[http_request->header_count - 1].value = (char *) + at; // it is from the sandbox's request_response_data, should persist. return 0; } @@ -102,7 +106,7 @@ http_parser_settings__on_header_value(http_parser *parser, const char *at, size_ static inline int http_parser_settings__on_header_end(http_parser *parser) { - struct sandbox * sandbox = (struct sandbox *) parser->data; + struct sandbox * sandbox = (struct sandbox *)parser->data; struct http_request *http_request = &sandbox->http_request; http_request->header_end = 1; @@ -120,7 +124,7 @@ http_parser_settings__on_header_end(http_parser *parser) static inline int http_parser_settings__on_body(http_parser *parser, const char *at, size_t length) { - struct sandbox * sandbox = (struct sandbox *) parser->data; + struct sandbox * sandbox = (struct sandbox *)parser->data; struct http_request *http_request = &sandbox->http_request; assert(http_request->body_length + length <= sandbox->module->max_request_size); @@ -141,7 +145,7 @@ http_parser_settings__on_body(http_parser *parser, const char *at, size_t length static inline int http_parser_settings__on_msg_end(http_parser *parser) { - struct sandbox * sandbox = (struct sandbox *) parser->data; + struct sandbox * sandbox = (struct sandbox *)parser->data; struct http_request *http_request = &sandbox->http_request; http_request->message_end = 1; @@ -173,8 +177,8 @@ http_parser_settings__register_callbacks(http_parser_settings *settings) void http_parser_settings__initialize(http_parser_settings *settings) { - http_parser_settings_init(settings); - http_parser_settings__register_callbacks(settings); + http_parser_settings_init(settings); + http_parser_settings__register_callbacks(settings); } #endif /* SRFT_HTTP_PARSER_SETTINGS_H */ diff --git a/runtime/include/http/http_request.h b/runtime/include/http/http_request.h index 4343850..3483252 100644 --- a/runtime/include/http/http_request.h +++ b/runtime/include/http/http_request.h @@ -14,9 +14,10 @@ struct http_request { int header_count; char * body; int body_length; - int body_read_length; // How far we've read + int body_read_length; // How far we've read // additional for http-parser - int last_was_value; // http-parser flag used to help the http-parser callbacks differentiate between header fields and values to know when to allocate a new header + int last_was_value; // http-parser flag used to help the http-parser callbacks differentiate between header + // fields and values to know when to allocate a new header int header_end; // boolean flag set when header processing is complete int message_begin; // boolean flag set when body processing begins int message_end; // boolean flag set when body processing is complete diff --git a/runtime/include/libuv_callbacks.h b/runtime/include/libuv_callbacks.h index 8c17e06..42ded7d 100644 --- a/runtime/include/libuv_callbacks.h +++ b/runtime/include/libuv_callbacks.h @@ -32,14 +32,14 @@ libuv_callbacks__on_read_parse_http_request(uv_stream_t *stream, ssize_t number_ struct http_request *rh = &sandbox->http_request; if (!rh->message_end) return; } - + // When the entire message has been read, stop the stream and wakeup the sandbox uv_read_stop(stream); worker_thread__wakeup_sandbox(sandbox); } /** - * On libuv close, executes this callback to wake the blocked sandbox back up + * On libuv close, executes this callback to wake the blocked sandbox back up * @param stream **/ static inline void @@ -73,7 +73,8 @@ libuv_callbacks__on_write_wakeup_sandbox(uv_write_t *write, int status) struct sandbox *sandbox = write->data; if (status < 0) { sandbox->client_libuv_shutdown_request.data = sandbox; - uv_shutdown(&sandbox->client_libuv_shutdown_request, (uv_stream_t *)&sandbox->client_libuv_stream, libuv_callbacks__on_shutdown_wakeup_sakebox); + uv_shutdown(&sandbox->client_libuv_shutdown_request, (uv_stream_t *)&sandbox->client_libuv_stream, + libuv_callbacks__on_shutdown_wakeup_sakebox); return; } worker_thread__wakeup_sandbox(sandbox); @@ -83,9 +84,9 @@ static inline void libuv_callbacks__on_allocate_setup_request_response_data(uv_handle_t *h, size_t suggested, uv_buf_t *buf) { struct sandbox *sandbox = h->data; - size_t l = (sandbox->module->max_request_or_response_size - sandbox->request_response_data_length); - buf->base = (sandbox->request_response_data + sandbox->request_response_data_length); - buf->len = l > suggested ? suggested : l; + size_t l = (sandbox->module->max_request_or_response_size - sandbox->request_response_data_length); + buf->base = (sandbox->request_response_data + sandbox->request_response_data_length); + buf->len = l > suggested ? suggested : l; } #endif /* SFRT_SANDBOX_H */ diff --git a/runtime/include/module.h b/runtime/include/module.h index 292e2a8..400e3f0 100644 --- a/runtime/include/module.h +++ b/runtime/include/module.h @@ -6,18 +6,18 @@ #include struct module { - char name[MOD_NAME_MAX]; - char path[MOD_PATH_MAX]; - void *dynamic_library_handle; // Handle to the *.so of the serverless function - i32 argument_count; - u32 stack_size; // a specification? - u64 max_memory; // perhaps a specification of the module. (max 4GB) - u32 timeout; // again part of the module specification. - u32 reference_count; // ref count how many instances exist here. + char name[MOD_NAME_MAX]; + char path[MOD_PATH_MAX]; + void * dynamic_library_handle; // Handle to the *.so of the serverless function + i32 argument_count; + u32 stack_size; // a specification? + u64 max_memory; // perhaps a specification of the module. (max 4GB) + u32 timeout; // again part of the module specification. + u32 reference_count; // ref count how many instances exist here. struct indirect_table_entry indirect_table[INDIRECT_TABLE_SIZE]; - struct sockaddr_in socket_address; - int socket_descriptor; - int port; + struct sockaddr_in socket_address; + int socket_descriptor; + int port; // unfortunately, using UV for accepting connections is not great! // on_connection, to create a new accepted connection, will have to @@ -36,7 +36,7 @@ struct module { int response_header_count; char response_content_type[HTTP_HEADERVAL_MAXSZ]; char response_headers[HTTP_HEADERS_MAX][HTTP_HEADER_MAXSZ]; - + // Equals the largest of either max_request_size or max_response_size unsigned long max_request_or_response_size; @@ -165,7 +165,7 @@ module__release(struct module *module) **/ static inline void module__set_http_info(struct module *module, int request_count, char *request_headers, char request_content_type[], - int response_count, char *response_headers, char response_content_type[]) + int response_count, char *response_headers, char response_content_type[]) { assert(module); module->request_header_count = request_count; @@ -181,7 +181,8 @@ module__set_http_info(struct module *module, int request_count, char *request_he ***************************************/ void module__free(struct module *module); -struct module *module__new(char *mod_name, char *mod_path, i32 argument_count, u32 stack_sz, u32 max_heap, u32 timeout, int port, int req_sz, int resp_sz); -int module__new_from_json(char *filename); +struct module *module__new(char *mod_name, char *mod_path, i32 argument_count, u32 stack_sz, u32 max_heap, u32 timeout, + int port, int req_sz, int resp_sz); +int module__new_from_json(char *filename); #endif /* SFRT_MODULE_H */ diff --git a/runtime/include/module_database.h b/runtime/include/module_database.h index 48521cd..f38736a 100644 --- a/runtime/include/module_database.h +++ b/runtime/include/module_database.h @@ -6,7 +6,7 @@ struct module *module_database__find_by_name(char *name); struct module *module_database__find_by_socket_descriptor(int socket_descriptor); -extern struct module *module_database[]; +extern struct module *module_database[]; extern int module_database_free_offset; /** diff --git a/runtime/include/runtime.h b/runtime/include/runtime.h index 790b24b..415883b 100644 --- a/runtime/include/runtime.h +++ b/runtime/include/runtime.h @@ -21,7 +21,7 @@ INLINE char *get_memory_ptr_for_runtime(u32 offset, u32 bounds_check); void runtime__initialize(void); void listener_thread__initialize(void); void stub_init(i32 offset); -void *worker_thread__main(void *return_code); +void * worker_thread__main(void *return_code); /** * TODO: ??? diff --git a/runtime/include/sandbox.h b/runtime/include/sandbox.h index b4b58a4..750f409 100644 --- a/runtime/include/sandbox.h +++ b/runtime/include/sandbox.h @@ -33,8 +33,8 @@ typedef enum struct sandbox { sandbox__state_t state; - u32 sandbox_size; // The struct plus enough buffer to hold the request or response (sized off largest) - + u32 sandbox_size; // The struct plus enough buffer to hold the request or response (sized off largest) + void *linear_memory_start; // after sandbox struct u32 linear_memory_size; // from after sandbox struct u32 linear_memory_max_size; @@ -57,11 +57,11 @@ struct sandbox { void *arguments; // arguments from request, must be of module->argument_count size. i32 return_value; - struct sandbox__io_handle handles[SBOX_MAX_OPEN]; - struct sockaddr client_address; // client requesting connection! - int client_socket_descriptor; - uv_tcp_t client_libuv_stream; - uv_shutdown_t client_libuv_shutdown_request; + struct sandbox__io_handle handles[SBOX_MAX_OPEN]; + struct sockaddr client_address; // client requesting connection! + int client_socket_descriptor; + uv_tcp_t client_libuv_stream; + uv_shutdown_t client_libuv_shutdown_request; http_parser http_parser; struct http_request http_request; @@ -73,8 +73,8 @@ struct sandbox { // Used by the ps_list macro struct ps_list list; - ssize_t request_response_data_length; // <= max(module->max_request_or_response_size) - char request_response_data[1]; // of rr_data_sz, following sandbox mem.. + ssize_t request_response_data_length; // <= max(module->max_request_or_response_size) + char request_response_data[1]; // of rr_data_sz, following sandbox mem.. } PAGE_ALIGNED; typedef struct sandbox sandbox_t; @@ -87,21 +87,22 @@ typedef struct sandbox sandbox_t; extern __thread struct sandbox *worker_thread__current_sandbox; extern __thread arch_context_t *worker_thread__next_context; -extern void worker_thread__block_current_sandbox(void); -extern void worker_thread__completion_queue__add_sandbox(struct sandbox *sandbox); -extern void worker_thread__current_sandbox__exit(void); -extern struct sandbox * worker_thread__get_next_sandbox(int interrupt); -extern void worker_thread__process_io(void); +extern void worker_thread__block_current_sandbox(void); +extern void worker_thread__completion_queue__add_sandbox(struct sandbox *sandbox); +extern void worker_thread__current_sandbox__exit(void); +extern struct sandbox *worker_thread__get_next_sandbox(int interrupt); +extern void worker_thread__process_io(void); extern void __attribute__((noreturn)) worker_thread__sandbox_switch_preempt(void); -extern void worker_thread__wakeup_sandbox(sandbox_t *sb); +extern void worker_thread__wakeup_sandbox(sandbox_t *sb); /*************************** * Public API * **************************/ -struct sandbox *sandbox__allocate(struct module *module, char *arguments, int socket_descriptor, const struct sockaddr *socket_address, u64 start_time); +struct sandbox *sandbox__allocate(struct module *module, char *arguments, int socket_descriptor, + const struct sockaddr *socket_address, u64 start_time); void sandbox__free(struct sandbox *sandbox); -int sandbox__parse_http_request(struct sandbox *sandbox, size_t length); +int sandbox__parse_http_request(struct sandbox *sandbox, size_t length); /** @@ -137,7 +138,7 @@ static inline int sandbox__initialize_io_handle(struct sandbox *sandbox) { if (!sandbox) return -1; - int handle_index; + int handle_index; for (handle_index = 0; handle_index < SBOX_MAX_OPEN; handle_index++) { if (sandbox->handles[handle_index].file_descriptor < 0) break; } @@ -159,8 +160,10 @@ sandbox__initialize_io_handle_and_set_file_descriptor(struct sandbox *sandbox, i { if (!sandbox) return -1; if (file_descriptor < 0) return file_descriptor; - int handle_index = sandbox__initialize_io_handle(sandbox); - if (handle_index != -1) sandbox->handles[handle_index].file_descriptor = file_descriptor; // well, per sandbox.. so synchronization necessary! + int handle_index = sandbox__initialize_io_handle(sandbox); + if (handle_index != -1) + sandbox->handles[handle_index].file_descriptor = + file_descriptor; // well, per sandbox.. so synchronization necessary! return handle_index; } diff --git a/runtime/include/sandbox_request.h b/runtime/include/sandbox_request.h index 03ab66c..31158a5 100644 --- a/runtime/include/sandbox_request.h +++ b/runtime/include/sandbox_request.h @@ -20,7 +20,7 @@ DEQUE_PROTOTYPE(sandbox, sandbox_request_t *); /** * Pushes a sandbox request to the global deque - * @param sandbox_request + * @param sandbox_request **/ static inline int sandbox_request__add_to_global_dequeue(sandbox_request_t *sandbox_request) @@ -48,15 +48,16 @@ sandbox_request__add_to_global_dequeue(sandbox_request_t *sandbox_request) * @return the new sandbox request **/ static inline sandbox_request_t * -sandbox_request__allocate(struct module *module, char *arguments, int socket_descriptor, const struct sockaddr *socket_address, u64 start_time) +sandbox_request__allocate(struct module *module, char *arguments, int socket_descriptor, + const struct sockaddr *socket_address, u64 start_time) { sandbox_request_t *sandbox_request = (sandbox_request_t *)malloc(sizeof(sandbox_request_t)); assert(sandbox_request); - sandbox_request->module = module; - sandbox_request->arguments = arguments; - sandbox_request->socket_descriptor = socket_descriptor; - sandbox_request->socket_address = (struct sockaddr *)socket_address; - sandbox_request->start_time = start_time; + sandbox_request->module = module; + sandbox_request->arguments = arguments; + sandbox_request->socket_descriptor = socket_descriptor; + sandbox_request->socket_address = (struct sockaddr *)socket_address; + sandbox_request->start_time = start_time; debuglog("[%p: %s]\n", sandbox_request, sandbox_request->module->name); sandbox_request__add_to_global_dequeue(sandbox_request); diff --git a/runtime/include/types.h b/runtime/include/types.h index e9a227f..4687b42 100644 --- a/runtime/include/types.h +++ b/runtime/include/types.h @@ -21,7 +21,7 @@ #define IMPORT __attribute__((visibility("default"))) #define INLINE __attribute__((always_inline)) -#define WEAK __attribute__((weak)) +#define WEAK __attribute__((weak)) #ifndef CACHELINE_SIZE #define CACHELINE_SIZE 32 @@ -32,13 +32,13 @@ #endif #define CACHE_ALIGNED __attribute__((aligned(CACHELINE_SIZE))) -#define PAGE_ALIGNED __attribute__((aligned(PAGE_SIZE))) +#define PAGE_ALIGNED __attribute__((aligned(PAGE_SIZE))) /* For this family of macros, do NOT pass zero as the pow2 */ -#define round_to_pow2(x, pow2) (((unsigned long)(x)) & (~((pow2)-1))) +#define round_to_pow2(x, pow2) (((unsigned long)(x)) & (~((pow2)-1))) #define round_up_to_pow2(x, pow2) (round_to_pow2(((unsigned long)x) + (pow2)-1, (pow2))) -#define round_to_page(x) round_to_pow2(x, PAGE_SIZE) +#define round_to_page(x) round_to_pow2(x, PAGE_SIZE) #define round_up_to_page(x) round_up_to_pow2(x, PAGE_SIZE) // Type alias's so I don't have to write uint32_t a million times @@ -52,11 +52,11 @@ typedef int64_t i64; typedef uint64_t u64; // FIXME: per-module configuration? -#define WASM_PAGE_SIZE (1024 * 64) // 64KB -#define WASM_START_PAGES (1 << 8) // 16MB -#define WASM_MAX_PAGES (1 << 15) // 4GB -#define WASM_STACK_SIZE (1 << 19) // 512KB. -#define SBOX_MAX_MEM (1L << 32) // 4GB +#define WASM_PAGE_SIZE (1024 * 64) // 64KB +#define WASM_START_PAGES (1 << 8) // 16MB +#define WASM_MAX_PAGES (1 << 15) // 4GB +#define WASM_STACK_SIZE (1 << 19) // 512KB. +#define SBOX_MAX_MEM (1L << 32) // 4GB // These are per module symbols and I'd need to dlsym for each module. instead just use global constants, see above // macros. The code generator compiles in the starting number of wasm pages, and the maximum number of pages If we try @@ -100,30 +100,31 @@ typedef enum } mod_argindex_t; #define MOD_MAIN_FN "wasmf_main" -#define MOD_GLB_FN "populate_globals" -#define MOD_MEM_FN "populate_memory" -#define MOD_TBL_FN "populate_table" +#define MOD_GLB_FN "populate_globals" +#define MOD_MEM_FN "populate_memory" +#define MOD_TBL_FN "populate_table" #define MOD_LIBC_FN "wasmf___init_libc" -#define MOD_MAX_ARGS 16 // Max number of arguments -#define MOD_ARG_MAX_SZ 64 // Max size of a single argument -#define MOD_MAX 1024 // Max size of a single module in JSON -#define MOD_NAME_MAX 32 // Max module name length -#define MOD_PATH_MAX 256 // Max module path length -#define JSON_ELE_MAX 16 // Max number of elements defined in JSON +#define MOD_MAX_ARGS 16 // Max number of arguments +#define MOD_ARG_MAX_SZ 64 // Max size of a single argument +#define MOD_MAX 1024 // Max size of a single module in JSON +#define MOD_NAME_MAX 32 // Max module name length +#define MOD_PATH_MAX 256 // Max module path length +#define JSON_ELE_MAX 16 // Max number of elements defined in JSON // This is the max number of standboxes that get pulled onto the local runqueue in a single batch #define SBOX_PULL_MAX 1 -#define SBOX_MAX_OPEN 32 +#define SBOX_MAX_OPEN 32 #define SBOX_PREOPEN_MAGIC (707707707) // reads lol lol lol upside down -#define SOFTINT_TIMER_START_USEC (10 * 1000) // start timers 10 ms from now. -#define SOFTINT_TIMER_PERIOD_USEC (1000 * 5) // 5ms timer.. +#define SOFTINT_TIMER_START_USEC (10 * 1000) // start timers 10 ms from now. +#define SOFTINT_TIMER_PERIOD_USEC (1000 * 5) // 5ms timer.. #ifdef DEBUG #ifdef NOSTDIO -#define debuglog(fmt, ...) dprintf(log_file_descriptor, "(%d,%lu) %s: " fmt, sched_getcpu(), pthread_self(), __func__, ##__VA_ARGS__) +#define debuglog(fmt, ...) \ + dprintf(log_file_descriptor, "(%d,%lu) %s: " fmt, sched_getcpu(), pthread_self(), __func__, ##__VA_ARGS__) #else #define debuglog(fmt, ...) printf("(%d,%lu) %s: " fmt, sched_getcpu(), pthread_self(), __func__, ##__VA_ARGS__) #endif @@ -133,33 +134,33 @@ typedef enum #define GLB_STDOUT "/dev/null" #define GLB_STDERR "/dev/null" -#define GLB_STDIN "/dev/zero" +#define GLB_STDIN "/dev/zero" #define LOGFILE "awesome.log" #define RDWR_VEC_MAX 16 -#define MOD_REQ_CORE 0 // Dedicated Listener Core +#define MOD_REQ_CORE 0 // Dedicated Listener Core // If multicore, use all but the dedicated listener core // If there are fewer cores than this, main dynamically overrides this and uses all available -#define SBOX_NCORES (NCORES > 1 ? NCORES - 1 : NCORES) -#define SBOX_MAX_REQS (1 << 19) // random! +#define SBOX_NCORES (NCORES > 1 ? NCORES - 1 : NCORES) +#define SBOX_MAX_REQS (1 << 19) // random! #define SBOX_RESP_STRSZ 32 -#define MOD_BACKLOG 1000 -#define EPOLL_MAX 1024 +#define MOD_BACKLOG 1000 +#define EPOLL_MAX 1024 #define MOD_REQ_RESP_DEFAULT (PAGE_SIZE) -#define QUIESCENSE_TIME (1 << 20) // cycles! +#define QUIESCENSE_TIME (1 << 20) // cycles! -#define HTTP_HEADERS_MAX 16 -#define HTTP_HEADER_MAXSZ 32 +#define HTTP_HEADERS_MAX 16 +#define HTTP_HEADER_MAXSZ 32 #define HTTP_HEADERVAL_MAXSZ 64 -#define HTTP_RESP_200OK "HTTP/1.1 200 OK\r\n" -#define HTTP_RESP_CONTTYPE "Content-type: \r\n" -#define HTTP_RESP_CONTLEN "Content-length: \r\n\r\n" // content body follows this +#define HTTP_RESP_200OK "HTTP/1.1 200 OK\r\n" +#define HTTP_RESP_CONTTYPE "Content-type: \r\n" +#define HTTP_RESP_CONTLEN "Content-length: \r\n\r\n" // content body follows this #define HTTP_RESP_CONTTYPE_PLAIN "text/plain" #endif /* SFRT_TYPES_H */ diff --git a/runtime/src/http/http_request.c b/runtime/src/http/http_request.c index ecf5653..88f7124 100644 --- a/runtime/src/http/http_request.c +++ b/runtime/src/http/http_request.c @@ -16,4 +16,3 @@ http_request__get_body(struct http_request *http_request, char **body) *body = http_request->body; return http_request->body_length; } - diff --git a/runtime/src/http/http_response.c b/runtime/src/http/http_response.c index f2b9c65..d589546 100644 --- a/runtime/src/http/http_response.c +++ b/runtime/src/http/http_response.c @@ -23,14 +23,17 @@ http_response__encode_as_vector(struct http_response *http_response) http_response->bufs[buffer_count] = uv_buf_init(http_response->status, http_response->status_length); buffer_count++; for (int i = 0; i < http_response->header_count; i++) { - http_response->bufs[buffer_count] = uv_buf_init(http_response->headers[i].header, http_response->headers[i].length); + http_response->bufs[buffer_count] = uv_buf_init(http_response->headers[i].header, + http_response->headers[i].length); buffer_count++; } if (http_response->body) { http_response->bufs[buffer_count] = uv_buf_init(http_response->body, http_response->body_length); buffer_count++; - http_response->bufs[buffer_count] = uv_buf_init(http_response->status + http_response->status_length - 2, 2); // for crlf + http_response->bufs[buffer_count] = uv_buf_init(http_response->status + http_response->status_length + - 2, + 2); // for crlf buffer_count++; } #else diff --git a/runtime/src/libc/uvio.c b/runtime/src/libc/uvio.c index 3882b59..e89430a 100644 --- a/runtime/src/libc/uvio.c +++ b/runtime/src/libc/uvio.c @@ -9,25 +9,25 @@ #define GID 0xFE // Elf auxilary vector values (see google for what those are) -#define AT_NULL 0 -#define AT_IGNORE 1 -#define AT_EXECFD 2 -#define AT_PHDR 3 -#define AT_PHENT 4 -#define AT_PHNUM 5 -#define AT_PAGESZ 6 -#define AT_BASE 7 -#define AT_FLAGS 8 -#define AT_ENTRY 9 -#define AT_NOTELF 10 -#define AT_UID 11 -#define AT_EUID 12 -#define AT_GID 13 -#define AT_EGID 14 -#define AT_CLKTCK 17 -#define AT_SECURE 23 +#define AT_NULL 0 +#define AT_IGNORE 1 +#define AT_EXECFD 2 +#define AT_PHDR 3 +#define AT_PHENT 4 +#define AT_PHNUM 5 +#define AT_PAGESZ 6 +#define AT_BASE 7 +#define AT_FLAGS 8 +#define AT_ENTRY 9 +#define AT_NOTELF 10 +#define AT_UID 11 +#define AT_EUID 12 +#define AT_GID 13 +#define AT_EGID 14 +#define AT_CLKTCK 17 +#define AT_SECURE 23 #define AT_BASE_PLATFORM 24 -#define AT_RANDOM 25 +#define AT_RANDOM 25 // offset = a WASM ptr to memory the runtime can use void @@ -87,8 +87,8 @@ uv_fs_get_type(uv_fs_t *req) return req->fs_type; } -#define UV_FS_REQ_INIT() \ - { \ +#define UV_FS_REQ_INIT() \ + { \ .data = current_sandbox__get(), .result = 0 \ } @@ -162,21 +162,21 @@ wasm_write(i32 file_descriptor, i32 buf_offset, i32 buf_size) return ret; } -#define WO_RDONLY 00 -#define WO_WRONLY 01 -#define WO_RDWR 02 -#define WO_CREAT 0100 -#define WO_EXCL 0200 -#define WO_NOCTTY 0400 -#define WO_TRUNC 01000 -#define WO_APPEND 02000 -#define WO_NONBLOCK 04000 -#define WO_DSYNC 010000 -#define WO_SYNC 04010000 -#define WO_RSYNC 04010000 +#define WO_RDONLY 00 +#define WO_WRONLY 01 +#define WO_RDWR 02 +#define WO_CREAT 0100 +#define WO_EXCL 0200 +#define WO_NOCTTY 0400 +#define WO_TRUNC 01000 +#define WO_APPEND 02000 +#define WO_NONBLOCK 04000 +#define WO_DSYNC 010000 +#define WO_SYNC 04010000 +#define WO_RSYNC 04010000 #define WO_DIRECTORY 0200000 -#define WO_NOFOLLOW 0400000 -#define WO_CLOEXEC 02000000 +#define WO_NOFOLLOW 0400000 +#define WO_CLOEXEC 02000000 #define SYS_OPEN 2 i32 @@ -612,8 +612,8 @@ wasm_getpid() #define WF_SETSIG 10 #define WF_GETSIG 11 -#define WF_GETLK 5 -#define WF_SETLK 6 +#define WF_GETLK 5 +#define WF_SETLK 6 #define WF_SETLKW 7 #define SYS_FCNTL 72 @@ -750,11 +750,11 @@ wasm_fchown(i32 file_descriptor, u32 owner, u32 group) } // networking syscalls -#define SYS_SOCKET 41 +#define SYS_SOCKET 41 #define SYS_CONNECT 42 -#define SYS_ACCEPT 43 -#define SYS_BIND 49 -#define SYS_LISTEN 50 +#define SYS_ACCEPT 43 +#define SYS_BIND 49 +#define SYS_LISTEN 50 static void wasm_connection_callback(uv_stream_t *srv, int status) @@ -805,7 +805,7 @@ wasm_socket(i32 domain, i32 type, i32 protocol) i32 wasm_connect(i32 sockfd, i32 sockaddr_offset, i32 addrlen) { - struct sandbox *c = current_sandbox__get(); + struct sandbox *c = current_sandbox__get(); int file_descriptor = current_sandbox__get_file_descriptor(sockfd); debuglog("[%p] [%d, %d]\n", c, sockfd, file_descriptor); union uv_any_handle *h = current_sandbox__get_libuv_handle(sockfd); @@ -834,10 +834,10 @@ i32 wasm_accept(i32 sockfd, i32 sockaddr_offset, i32 addrlen_offset) { // what do we do with the sockaddr TODO: ???? - socklen_t * addrlen = get_memory_ptr_void(addrlen_offset, sizeof(socklen_t)); - struct sockaddr * socket_address = get_memory_ptr_void(sockaddr_offset, *addrlen); - union uv_any_handle *s = current_sandbox__get_libuv_handle(sockfd); - int cfd = current_sandbox__initialize_io_handle(); + socklen_t * addrlen = get_memory_ptr_void(addrlen_offset, sizeof(socklen_t)); + struct sockaddr * socket_address = get_memory_ptr_void(sockaddr_offset, *addrlen); + union uv_any_handle *s = current_sandbox__get_libuv_handle(sockfd); + int cfd = current_sandbox__initialize_io_handle(); if (cfd < 0) return -1; struct sandbox *c = current_sandbox__get(); debuglog("[%p] [%d, %d]\n", c, sockfd, current_sandbox__get_file_descriptor(sockfd)); @@ -865,7 +865,7 @@ wasm_accept(i32 sockfd, i32 sockaddr_offset, i32 addrlen_offset) i32 wasm_bind(i32 sockfd, i32 sockaddr_offset, i32 addrlen) { - struct sandbox *c = current_sandbox__get(); + struct sandbox *c = current_sandbox__get(); int file_descriptor = current_sandbox__get_file_descriptor(sockfd); debuglog("[%p] [%d,%d]\n", c, sockfd, file_descriptor); union uv_any_handle *h = current_sandbox__get_libuv_handle(sockfd); @@ -916,7 +916,7 @@ wasm_listen(i32 sockfd, i32 backlog) return c->return_value; } -#define SYS_SENDTO 44 +#define SYS_SENDTO 44 #define SYS_RECVFROM 45 void @@ -936,14 +936,15 @@ void wasm_write_callback(uv_write_t *req, int status) { struct sandbox *c = req->data; - c->return_value = status; + c->return_value = status; debuglog("[%p] %d\n", c, status); worker_thread__wakeup_sandbox(c); } void -wasm_udp_recv_callback(uv_udp_t *h, ssize_t nread, const uv_buf_t *buffer, const struct sockaddr *socket_address, unsigned flags) +wasm_udp_recv_callback(uv_udp_t *h, ssize_t nread, const uv_buf_t *buffer, const struct sockaddr *socket_address, + unsigned flags) { struct sandbox *c = h->data; @@ -959,7 +960,7 @@ void wasm_udp_send_callback(uv_udp_send_t *req, int status) { struct sandbox *c = req->data; - c->return_value = status; + c->return_value = status; debuglog("[%p] %d\n", c, status); worker_thread__wakeup_sandbox(c); @@ -1032,9 +1033,9 @@ wasm_recvfrom(i32 file_descriptor, i32 buff_offset, i32 size, i32 flags, i32 soc // so we keep the read buffer pointers in sandbox structure.. // for use in the callbacks.. c->read_buffer = buffer; - c->read_size = size; + c->read_size = size; c->read_length = 0; - c->return_value = 0; + c->return_value = 0; // TODO: what if stream read more than what "size" is here?? if (t == UV_TCP) { diff --git a/runtime/src/module.c b/runtime/src/module.c index 606e420..ef190b2 100644 --- a/runtime/src/module.c +++ b/runtime/src/module.c @@ -50,7 +50,8 @@ 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) assert(0); + if (epoll_ctl(runtime__epoll_file_descriptor, EPOLL_CTL_ADD, module->socket_descriptor, &accept_evt) < 0) + assert(0); } /*************************************** @@ -82,8 +83,8 @@ module__free(struct module *module) /** * Module Contructor - * Creates a new module, invokes initialize_tables to initialize the indirect table, adds it to the module DB, and starts - *listening for HTTP Requests + * Creates a new module, invokes initialize_tables to initialize the indirect table, adds it to the module DB, and + *starts listening for HTTP Requests * * @param name * @param path @@ -97,7 +98,7 @@ module__free(struct module *module) **/ struct module * module__new(char *name, char *path, i32 argument_count, u32 stack_size, u32 max_memory, u32 timeout, int port, - int request_size, int response_size) + int request_size, int response_size) { struct module *module = (struct module *)malloc(sizeof(struct module)); if (!module) return NULL; @@ -146,8 +147,8 @@ module__new(char *name, char *path, i32 argument_count, u32 stack_size, u32 max_ // assumption: All modules are created at program start before we enable preemption or enable the execution of // any worker threads We are checking that thread-local module_indirect_table is NULL to prove that we aren't - // yet preempting If we want to be able to do this later, we can possibly defer module__initialize_table until the - // first invocation + // yet preempting If we want to be able to do this later, we can possibly defer module__initialize_table until + // the first invocation assert(cache_tbl == NULL); // TODO: determine why we have to set the module_indirect_table state before calling table init and then restore @@ -308,10 +309,10 @@ module__new_from_json(char *file_name) // Allocate a module based on the values from the JSON struct module *module = module__new(module_name, module_path, argument_count, 0, 0, 0, port, - request_size, response_size); + request_size, response_size); assert(module); module__set_http_info(module, request_count, request_headers, request_content_type, response_count, - reponse_headers, response_content_type); + reponse_headers, response_content_type); module_count++; free(request_headers); free(reponse_headers); diff --git a/runtime/src/module_database.c b/runtime/src/module_database.c index a55f224..5a0b157 100644 --- a/runtime/src/module_database.c +++ b/runtime/src/module_database.c @@ -8,7 +8,7 @@ // In-memory representation of all active modules struct module *module_database[MOD_MAX] = { NULL }; // First free in module -int module_database_free_offset = 0; +int module_database_free_offset = 0; /** * Given a name, find the associated module diff --git a/runtime/src/runtime.c b/runtime/src/runtime.c index a770f89..10b9d41 100644 --- a/runtime/src/runtime.c +++ b/runtime/src/runtime.c @@ -72,8 +72,8 @@ listener_thread__main(void *dummy) int total_requests = 0; while (true) { - int request_count = epoll_wait(runtime__epoll_file_descriptor, epoll_events, EPOLL_MAX, -1); - u64 start_time = util__rdtsc(); + int request_count = epoll_wait(runtime__epoll_file_descriptor, epoll_events, EPOLL_MAX, -1); + u64 start_time = util__rdtsc(); for (int i = 0; i < request_count; i++) { if (epoll_events[i].events & EPOLLERR) { perror("epoll_wait"); @@ -82,10 +82,10 @@ listener_thread__main(void *dummy) struct sockaddr_in client_address; socklen_t client_length = sizeof(client_address); - struct module * module = (struct module *)epoll_events[i].data.ptr; + struct module * module = (struct module *)epoll_events[i].data.ptr; assert(module); - int es = module->socket_descriptor; - int socket_descriptor = accept(es, (struct sockaddr *)&client_address, &client_length); + int es = module->socket_descriptor; + int socket_descriptor = accept(es, (struct sockaddr *)&client_address, &client_length); if (socket_descriptor < 0) { perror("accept"); assert(0); @@ -93,12 +93,9 @@ listener_thread__main(void *dummy) total_requests++; printf("Received Request %d at %lu\n", total_requests, start_time); - sandbox_request_t *sandbox_request = sandbox_request__allocate( - module, - module->name, - socket_descriptor, - (const struct sockaddr *)&client_address, - start_time); + sandbox_request_t *sandbox_request = + sandbox_request__allocate(module, module->name, socket_descriptor, + (const struct sockaddr *)&client_address, start_time); assert(sandbox_request); // TODO: Refactor sandbox_request__allocate to not add to global request queue and do this here @@ -176,7 +173,8 @@ worker_thread__switch_to_sandbox(struct sandbox *next_sandbox) arch_context_t *current_register_context = current_sandbox == NULL ? NULL : ¤t_sandbox->ctxt; current_sandbox__set(next_sandbox); // If the current sandbox we're switching from is in a RETURNED state, add to completion queue - if (current_sandbox && current_sandbox->state == RETURNED) worker_thread__completion_queue__add_sandbox(current_sandbox); + if (current_sandbox && current_sandbox->state == RETURNED) + 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(); @@ -202,7 +200,8 @@ done: /** - * Mark the currently executing sandbox as blocked, remove it from the local runqueue, and pull the sandbox at the head of the runqueue + * Mark the currently executing sandbox as blocked, remove it from the local runqueue, and pull the sandbox at the head + *of the runqueue **/ void worker_thread__block_current_sandbox(void) @@ -211,9 +210,10 @@ worker_thread__block_current_sandbox(void) softint__disable(); struct sandbox *current_sandbox = current_sandbox__get(); ps_list_rem_d(current_sandbox); - current_sandbox->state = BLOCKED; + 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 : ""); + debuglog("[%p: %next_sandbox, %p: %next_sandbox]\n", current_sandbox, current_sandbox->module->name, + next_sandbox, next_sandbox ? next_sandbox->module->name : ""); softint__enable(); worker_thread__switch_to_sandbox(next_sandbox); } @@ -231,7 +231,7 @@ worker_thread__process_io(void) // great! if there is a way (TODO), perhaps RUN_ONCE and check if your I/O is processed, if yes, return else do // async block! uv_run(get_thread_libuv_handle(), UV_RUN_DEFAULT); -#else /* USE_HTTP_SYNC */ +#else /* USE_HTTP_SYNC */ worker_thread__block_current_sandbox(); #endif /* USE_HTTP_UVIO */ #else @@ -267,8 +267,9 @@ worker_thread__pull_and_process_sandbox_requests(void) if ((sandbox_request = sandbox_request__steal_from_global_dequeue()) == NULL) break; // Actually allocate the sandbox for the requests that we've pulled struct sandbox *sandbox = sandbox__allocate(sandbox_request->module, sandbox_request->arguments, - sandbox_request->socket_descriptor, sandbox_request->socket_address, - sandbox_request->start_time); + sandbox_request->socket_descriptor, + sandbox_request->socket_address, + sandbox_request->start_time); assert(sandbox); free(sandbox_request); // Set the sandbox as runnable and place on the local runqueue @@ -303,7 +304,7 @@ static inline void worker_thread__run_queue__add_sandbox(struct sandbox *sandbox) { assert(ps_list_singleton_d(sandbox)); - // fprintf(stderr, "(%d,%lu) %s: run %p, %s\n", sched_getcpu(), pthread_self(), __func__, s, + // fprintf(stderr, "(%d,%lu) %s: run %p, %s\n", sched_getcpu(), pthread_self(), __func__, s, // s->module->name); ps_list_head_append_d(&worker_thread__run_queue, sandbox); } @@ -327,8 +328,8 @@ worker_thread__run_queue__remove_sandbox(struct sandbox *sandbox) struct sandbox * worker_thread__get_next_sandbox(int in_interrupt) { - // If the thread local runqueue is empty and we're not running in the context of an interupt, - // pull a fresh batch of sandbox requests from the global queue + // If the thread local runqueue is empty and we're not running in the context of an interupt, + // pull a fresh batch of sandbox requests from the global queue if (ps_list_head_empty(&worker_thread__run_queue)) { // this is in an interrupt context, don't steal work here! if (in_interrupt) return NULL; @@ -341,7 +342,8 @@ worker_thread__get_next_sandbox(int in_interrupt) // Execute Round Robin Scheduling Logic // Grab the sandbox at the head of the thread local runqueue, add it to the end, and return it struct sandbox *sandbox = ps_list_head_first_d(&worker_thread__run_queue, struct sandbox); - // We are assuming that any sandboxed in the RETURNED state should have been pulled from the local runqueue by now! + // We are assuming that any sandboxed in the RETURNED state should have been pulled from the local runqueue by + // now! assert(sandbox->state != RETURNED); ps_list_rem_d(sandbox); ps_list_head_append_d(&worker_thread__run_queue, sandbox); @@ -379,7 +381,7 @@ worker_thread__completion_queue__free_sandboxes(unsigned int number_to_free) } /** - * Tries to free a completed request, executes libuv callbacks, and then gets + * Tries to free a completed request, executes libuv callbacks, and then gets * and returns the standbox at the head of the thread-local runqueue * @return sandbox or NULL **/ @@ -402,7 +404,7 @@ worker_thread__single_loop(void) /** * The entry function for sandbox worker threads - * Initializes thread-local state, unmasks signals, sets up libuv loop and + * Initializes thread-local state, unmasks signals, sets up libuv loop and * @param return_code - argument provided by pthread API. We set to -1 on error **/ void * @@ -412,7 +414,7 @@ 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; + softint__is_disabled = 0; worker_thread__next_context = NULL; #ifndef PREEMPT_DISABLE softint__unmask(SIGALRM); diff --git a/runtime/src/sandbox.c b/runtime/src/sandbox.c index da25923..07e6dcd 100644 --- a/runtime/src/sandbox.c +++ b/runtime/src/sandbox.c @@ -17,7 +17,7 @@ static inline void current_sandbox__setup_arguments(i32 argument_count) { - struct sandbox *curr = current_sandbox__get(); + struct sandbox *curr = current_sandbox__get(); char * arguments = current_sandbox__get_arguments(); // whatever gregor has, to be able to pass arguments to a module! @@ -46,7 +46,7 @@ current_sandbox__setup_arguments(i32 argument_count) * @param sandbox the sandbox containing the req_resp data that we want to parse * @param length The size of the request_response_data that we want to parse * @returns 0 - * + * * Globals: runtime__http_parser_settings **/ int @@ -54,20 +54,21 @@ 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, sandbox->request_response_data + sandbox->request_response_data_length, length); + http_parser_execute(&sandbox->http_parser, &runtime__http_parser_settings, + sandbox->request_response_data + sandbox->request_response_data_length, length); return 0; } /** * Receive and Parse the Request for the current sandbox - * @return 1 on success, 0 if no context, < 0 on failure. + * @return 1 on success, 0 if no context, < 0 on failure. **/ static inline int current_sandbox__receive_and_parse_client_request(void) { - struct sandbox *curr = current_sandbox__get(); - curr->request_response_data_length = 0; + struct sandbox *curr = current_sandbox__get(); + curr->request_response_data_length = 0; #ifndef USE_HTTP_UVIO int r = 0; r = recv(curr->client_socket_descriptor, (curr->request_response_data), curr->module->max_request_size, 0); @@ -81,7 +82,8 @@ current_sandbox__receive_and_parse_client_request(void) struct http_request *rh = &curr->http_request; if (rh->message_end) break; - r = recv(curr->client_socket_descriptor, (curr->request_response_data + curr->request_response_data_length), + r = recv(curr->client_socket_descriptor, + (curr->request_response_data + curr->request_response_data_length), curr->module->max_request_size - curr->request_response_data_length, 0); if (r < 0) { perror("recv2"); @@ -89,7 +91,9 @@ current_sandbox__receive_and_parse_client_request(void) } } #else - int r = uv_read_start((uv_stream_t *)&curr->client_libuv_stream, libuv_callbacks__on_allocate_setup_request_response_data, libuv_callbacks__on_read_parse_http_request); + int r = uv_read_start((uv_stream_t *)&curr->client_libuv_stream, + libuv_callbacks__on_allocate_setup_request_response_data, + libuv_callbacks__on_read_parse_http_request); worker_thread__process_io(); if (curr->request_response_data_length == 0) return 0; #endif @@ -103,10 +107,10 @@ current_sandbox__receive_and_parse_client_request(void) static inline int current_sandbox__build_and_send_client_response(void) { - int sndsz = 0; - struct sandbox *curr = current_sandbox__get(); - int response_header_length = strlen(HTTP_RESP_200OK) + strlen(HTTP_RESP_CONTTYPE) + strlen(HTTP_RESP_CONTLEN); - int body_length = curr->request_response_data_length - response_header_length; + int sndsz = 0; + struct sandbox *curr = current_sandbox__get(); + int response_header_length = strlen(HTTP_RESP_200OK) + strlen(HTTP_RESP_CONTTYPE) + strlen(HTTP_RESP_CONTLEN); + int body_length = curr->request_response_data_length - response_header_length; memset(curr->request_response_data, 0, strlen(HTTP_RESP_200OK) + strlen(HTTP_RESP_CONTTYPE) + strlen(HTTP_RESP_CONTLEN)); @@ -119,8 +123,8 @@ current_sandbox__build_and_send_client_response(void) strncpy(curr->request_response_data + sndsz + strlen("Content-type: "), HTTP_RESP_CONTTYPE_PLAIN, strlen(HTTP_RESP_CONTTYPE_PLAIN)); } else { - strncpy(curr->request_response_data + sndsz + strlen("Content-type: "), curr->module->response_content_type, - strlen(curr->module->response_content_type)); + strncpy(curr->request_response_data + sndsz + strlen("Content-type: "), + curr->module->response_content_type, strlen(curr->module->response_content_type)); } sndsz += strlen(HTTP_RESP_CONTTYPE); char len[10] = { 0 }; @@ -155,7 +159,8 @@ done: .data = curr, }; uv_buf_t bufv = uv_buf_init(curr->request_response_data, sndsz); - int r = uv_write(&req, (uv_stream_t *)&curr->client_libuv_stream, &bufv, 1, libuv_callbacks__on_write_wakeup_sandbox); + int r = uv_write(&req, (uv_stream_t *)&curr->client_libuv_stream, &bufv, 1, + libuv_callbacks__on_write_wakeup_sandbox); worker_thread__process_io(); #endif return 0; @@ -163,7 +168,8 @@ done: /** * Sandbox execution logic - * Handles setup, request parsing, WebAssembly initialization, function execution, response building and sending, and cleanup + * Handles setup, request parsing, WebAssembly initialization, function execution, response building and sending, and + *cleanup **/ void current_sandbox__main(void) @@ -177,7 +183,7 @@ current_sandbox__main(void) worker_thread__next_context = NULL; softint__enable(); } - struct module *current_module = sandbox__get_module(current_sandbox); + struct module *current_module = sandbox__get_module(current_sandbox); int argument_count = module__get_argument_count(current_module); // for stdio @@ -196,7 +202,7 @@ current_sandbox__main(void) // Set the current_sandbox as the data the http-parser has access to current_sandbox->http_parser.data = current_sandbox; - + // NOTE: if more headers, do offset by that! int response_header_length = strlen(HTTP_RESP_200OK) + strlen(HTTP_RESP_CONTTYPE) + strlen(HTTP_RESP_CONTLEN); @@ -210,13 +216,12 @@ current_sandbox__main(void) current_sandbox->client_libuv_stream.data = current_sandbox; // Open the libuv TCP stream - r = uv_tcp_open((uv_tcp_t *)¤t_sandbox->client_libuv_stream, current_sandbox->client_socket_descriptor); + r = uv_tcp_open((uv_tcp_t *)¤t_sandbox->client_libuv_stream, current_sandbox->client_socket_descriptor); assert(r == 0); #endif // If the HTTP Request returns 1, we've successfully received and parsed the HTTP request, so execute it! if (current_sandbox__receive_and_parse_client_request() > 0) { - // current_sandbox->request_response_data_length = response_header_length; @@ -229,7 +234,8 @@ current_sandbox__main(void) current_sandbox__setup_arguments(argument_count); // Executing the function within the WebAssembly sandbox - current_sandbox->return_value = module__main(current_module, argument_count, current_sandbox->arguments_offset); + current_sandbox->return_value = module__main(current_module, argument_count, + current_sandbox->arguments_offset); // Retrieve the result from the WebAssembly sandbox, construct the HTTP response, and send to client current_sandbox__build_and_send_client_response(); @@ -279,15 +285,16 @@ sandbox__allocate_memory(struct module *module) // can it include sandbox as well? sandbox->linear_memory_start = (char *)addr + sandbox_size; sandbox->linear_memory_size = linear_memory_size; - sandbox->module = module; - sandbox->sandbox_size = sandbox_size; + sandbox->module = module; + sandbox->sandbox_size = sandbox_size; module__acquire(module); return sandbox; } struct sandbox * -sandbox__allocate(struct module *module, char *arguments, int socket_descriptor, const struct sockaddr *socket_address, u64 start_time) +sandbox__allocate(struct module *module, char *arguments, int socket_descriptor, const struct sockaddr *socket_address, + u64 start_time) { if (!module__is_valid(module)) return NULL; @@ -300,7 +307,7 @@ sandbox__allocate(struct module *module, char *arguments, int socket_descriptor, sandbox->start_time = start_time; // actual module instantiation! - sandbox->arguments = (void *)arguments; + sandbox->arguments = (void *)arguments; sandbox->stack_size = module->stack_size; sandbox->stack_start = mmap(NULL, sandbox->stack_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_GROWSDOWN, -1, 0); @@ -314,7 +321,8 @@ sandbox__allocate(struct module *module, char *arguments, int socket_descriptor, ps_list_init_d(sandbox); // Setup the sandbox's context, stack, and instruction pointer - arch_context_init(&sandbox->ctxt, (reg_t)current_sandbox__main, (reg_t)(sandbox->stack_start + sandbox->stack_size)); + arch_context_init(&sandbox->ctxt, (reg_t)current_sandbox__main, + (reg_t)(sandbox->stack_start + sandbox->stack_size)); return sandbox; } @@ -340,7 +348,8 @@ sandbox__free(struct sandbox *sandbox) size_t stksz = sandbox->stack_size; // depending on the memory type - // free_linear_memory(sandbox->linear_memory_start, sandbox->linear_memory_size, sandbox->linear_memory_max_size); + // free_linear_memory(sandbox->linear_memory_start, sandbox->linear_memory_size, + // sandbox->linear_memory_max_size); int ret; // mmaped memory includes sandbox structure in there. diff --git a/runtime/src/softint.c b/runtime/src/softint.c index 4222a91..95ecca1 100644 --- a/runtime/src/softint.c +++ b/runtime/src/softint.c @@ -26,7 +26,7 @@ static const int softint__supported_signals[] = { SIGALRM, SIGUSR1 }; __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 volatile sig_atomic_t softint__is_disabled = 0; /*************************************** * Externs @@ -192,7 +192,6 @@ softint__disarm_timer(void) } - /** * Initialize software Interrupts * Register sonftint_handler to execute on SIGALRM and SIGUSR1