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

chore: de-dunder listener thrd, module, libuv cbs

Browse Source
master
Sean McBride 5 years ago
parent 3e90b26243
commit 4d660e666b
8 changed files with 52 additions and 52 deletions
Show Stats Download Patch File Download Diff File

12
runtime/include/libuv_callbacks.h
Unescape View File

@ -21,7 +21,7 @@
* @param buffer unused * @param buffer unused
**/ **/
static inline void static inline void
libuv_callbacks__on_read_parse_http_request(uv_stream_t *stream, ssize_t number_read, const uv_buf_t *buffer) libuv_callbacks_on_read_parse_http_request(uv_stream_t *stream, ssize_t number_read, const uv_buf_t *buffer)
{ {
struct sandbox *sandbox = stream->data; struct sandbox *sandbox = stream->data;
@ -43,7 +43,7 @@ libuv_callbacks__on_read_parse_http_request(uv_stream_t *stream, ssize_t number_
* @param stream * @param stream
**/ **/
static inline void static inline void
libuv_callbacks__on_close_wakeup_sakebox(uv_handle_t *stream) libuv_callbacks_on_close_wakeup_sakebox(uv_handle_t *stream)
{ {
struct sandbox *sandbox = stream->data; struct sandbox *sandbox = stream->data;
worker_thread__wakeup_sandbox(sandbox); worker_thread__wakeup_sandbox(sandbox);
@ -55,7 +55,7 @@ libuv_callbacks__on_close_wakeup_sakebox(uv_handle_t *stream)
* @param status unused in callback * @param status unused in callback
**/ **/
static inline void static inline void
libuv_callbacks__on_shutdown_wakeup_sakebox(uv_shutdown_t *req, int status) libuv_callbacks_on_shutdown_wakeup_sakebox(uv_shutdown_t *req, int status)
{ {
struct sandbox *sandbox = req->data; struct sandbox *sandbox = req->data;
worker_thread__wakeup_sandbox(sandbox); worker_thread__wakeup_sandbox(sandbox);
@ -68,20 +68,20 @@ libuv_callbacks__on_shutdown_wakeup_sakebox(uv_shutdown_t *req, int status)
* @param status status code * @param status status code
**/ **/
static inline void static inline void
libuv_callbacks__on_write_wakeup_sandbox(uv_write_t *write, int status) libuv_callbacks_on_write_wakeup_sandbox(uv_write_t *write, int status)
{ {
struct sandbox *sandbox = write->data; struct sandbox *sandbox = write->data;
if (status < 0) { if (status < 0) {
sandbox->client_libuv_shutdown_request.data = sandbox; sandbox->client_libuv_shutdown_request.data = sandbox;
uv_shutdown(&sandbox->client_libuv_shutdown_request, (uv_stream_t *)&sandbox->client_libuv_stream, uv_shutdown(&sandbox->client_libuv_shutdown_request, (uv_stream_t *)&sandbox->client_libuv_stream,
libuv_callbacks__on_shutdown_wakeup_sakebox); libuv_callbacks_on_shutdown_wakeup_sakebox);
return; return;
} }
worker_thread__wakeup_sandbox(sandbox); worker_thread__wakeup_sandbox(sandbox);
} }
static inline void static inline void
libuv_callbacks__on_allocate_setup_request_response_data(uv_handle_t *h, size_t suggested, uv_buf_t *buf) libuv_callbacks_on_allocate_setup_request_response_data(uv_handle_t *h, size_t suggested, uv_buf_t *buf)
{ {
struct sandbox *sandbox = h->data; struct sandbox *sandbox = h->data;
size_t l = (sandbox->module->max_request_or_response_size - sandbox->request_response_data_length); size_t l = (sandbox->module->max_request_or_response_size - sandbox->request_response_data_length);

30
runtime/include/module.h
Unescape View File

@ -59,7 +59,7 @@ struct module {
* @param module * @param module
**/ **/
static inline void static inline void
module__acquire(struct module *module) module_acquire(struct module *module)
{ {
module->reference_count++; module->reference_count++;
} }
@ -70,7 +70,7 @@ module__acquire(struct module *module)
* @returns the number of arguments * @returns the number of arguments
**/ **/
static inline i32 static inline i32
module__get_argument_count(struct module *module) module_get_argument_count(struct module *module)
{ {
return module->argument_count; return module->argument_count;
} }
@ -80,7 +80,7 @@ module__get_argument_count(struct module *module)
* @param module * @param module
**/ **/
static inline void static inline void
module__initialize_globals(struct module *module) module_initialize_globals(struct module *module)
{ {
// called in a sandbox. // called in a sandbox.
module->initialize_globals(); module->initialize_globals();
@ -91,7 +91,7 @@ module__initialize_globals(struct module *module)
* @param module * @param module
**/ **/
static inline void static inline void
module__initialize_table(struct module *module) module_initialize_table(struct module *module)
{ {
// called at module creation time (once only per module). // called at module creation time (once only per module).
module->initialize_tables(); module->initialize_tables();
@ -104,7 +104,7 @@ module__initialize_table(struct module *module)
* @param arguments * @param arguments
**/ **/
static inline void static inline void
module__initialize_libc(struct module *module, i32 env, i32 arguments) module_initialize_libc(struct module *module, i32 env, i32 arguments)
{ {
// called in a sandbox. // called in a sandbox.
module->initialize_libc(env, arguments); module->initialize_libc(env, arguments);
@ -115,7 +115,7 @@ module__initialize_libc(struct module *module, i32 env, i32 arguments)
* @param module * @param module
**/ **/
static inline void static inline void
module__initialize_memory(struct module *module) module_initialize_memory(struct module *module)
{ {
// called in a sandbox. // called in a sandbox.
module->initialize_memory(); module->initialize_memory();
@ -127,7 +127,7 @@ module__initialize_memory(struct module *module)
* @return 1 if valid. 0 if invalid * @return 1 if valid. 0 if invalid
**/ **/
static inline int static inline int
module__is_valid(struct module *module) module_is_valid(struct module *module)
{ {
if (module && module->dynamic_library_handle && module->main) return 1; if (module && module->dynamic_library_handle && module->main) return 1;
return 0; return 0;
@ -140,7 +140,7 @@ module__is_valid(struct module *module)
* @param argv standard UNIX vector of arguments * @param argv standard UNIX vector of arguments
**/ **/
static inline i32 static inline i32
module__main(struct module *module, i32 argc, i32 argv) module_main(struct module *module, i32 argc, i32 argv)
{ {
return module->main(argc, argv); return module->main(argc, argv);
} }
@ -150,7 +150,7 @@ module__main(struct module *module, i32 argc, i32 argv)
* @param module * @param module
**/ **/
static inline void static inline void
module__release(struct module *module) module_release(struct module *module)
{ {
module->reference_count--; module->reference_count--;
} }
@ -166,8 +166,8 @@ module__release(struct module *module)
* @param response_content_type * @param response_content_type
**/ **/
static inline void static inline void
module__set_http_info(struct module *module, int request_count, char *request_headers, char request_content_type[], 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); assert(module);
module->request_header_count = request_count; module->request_header_count = request_count;
@ -182,9 +182,9 @@ module__set_http_info(struct module *module, int request_count, char *request_he
* Public Methods from module.c * Public Methods from module.c
***************************************/ ***************************************/
void module__free(struct module *module); 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, 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 port, int req_sz, int resp_sz);
int module__new_from_json(char *filename); int module_new_from_json(char *filename);
#endif /* SFRT_MODULE_H */ #endif /* SFRT_MODULE_H */

2
runtime/include/runtime.h
Unescape View File

@ -19,7 +19,7 @@ void free_linear_memory(void *base, u32 bound, u32 max);
INLINE char *get_function_from_table(u32 idx, u32 type_id); INLINE char *get_function_from_table(u32 idx, u32 type_id);
INLINE char *get_memory_ptr_for_runtime(u32 offset, u32 bounds_check); 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 listener_thread_initialize(void);
void stub_init(i32 offset); void stub_init(i32 offset);
void * worker_thread__main(void *return_code); void * worker_thread__main(void *return_code);

2
runtime/src/libc/uvio.c
Unescape View File

@ -65,7 +65,7 @@ stub_init(i32 offset)
i32 env_vec_offset = offset; i32 env_vec_offset = offset;
memcpy(get_memory_ptr_for_runtime(env_vec_offset, sizeof(env_vec)), env_vec, sizeof(env_vec)); memcpy(get_memory_ptr_for_runtime(env_vec_offset, sizeof(env_vec)), env_vec, sizeof(env_vec));
module__initialize_libc(current_sandbox_get()->module, env_vec_offset, program_name_offset); module_initialize_libc(current_sandbox_get()->module, env_vec_offset, program_name_offset);
} }
// Emulated syscall implementations // Emulated syscall implementations

4
runtime/src/main.c
Unescape View File

@ -172,11 +172,11 @@ main(int argc, char **argv)
runtime__initialize(); runtime__initialize();
debuglog("Parsing modules file [%s]\n", argv[1]); debuglog("Parsing modules file [%s]\n", argv[1]);
if (module__new_from_json(argv[1])) { if (module_new_from_json(argv[1])) {
printf("failed to parse modules file[%s]\n", argv[1]); printf("failed to parse modules file[%s]\n", argv[1]);
exit(-1); exit(-1);
} }
listener_thread__initialize(); listener_thread_initialize();
runtime__start_runtime__worker_threads(); runtime__start_runtime__worker_threads();
} }

24
runtime/src/module.c
Unescape View File

@ -18,7 +18,7 @@
* @param module * @param module
**/ **/
static inline void static inline void
module__initialize_as_server(struct module *module) module_initialize_as_server(struct module *module)
{ {
// Allocate a new socket // Allocate a new socket
int socket_descriptor = socket(AF_INET, SOCK_STREAM, 0); int socket_descriptor = socket(AF_INET, SOCK_STREAM, 0);
@ -67,7 +67,7 @@ module__initialize_as_server(struct module *module)
* @param module - the module to teardown * @param module - the module to teardown
**/ **/
void void
module__free(struct module *module) module_free(struct module *module)
{ {
if (module == NULL) return; if (module == NULL) return;
if (module->dynamic_library_handle == NULL) return; if (module->dynamic_library_handle == NULL) return;
@ -99,8 +99,8 @@ module__free(struct module *module)
* @returns A new module or NULL in case of failure * @returns A new module or NULL in case of failure
**/ **/
struct module * struct module *
module__new(char *name, char *path, i32 argument_count, u32 stack_size, u32 max_memory, u32 timeout, int port, 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)); struct module *module = (struct module *)malloc(sizeof(struct module));
if (!module) return NULL; if (!module) return NULL;
@ -149,21 +149,21 @@ 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 // 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 // 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 // yet preempting If we want to be able to do this later, we can possibly defer module_initialize_table until
// the first invocation // the first invocation
assert(cache_tbl == NULL); assert(cache_tbl == NULL);
// TODO: determine why we have to set the module_indirect_table state before calling table init and then restore // TODO: determine why we have to set the module_indirect_table state before calling table init and then restore
// the existing value What is the relationship between these things? // the existing value What is the relationship between these things?
module_indirect_table = module->indirect_table; module_indirect_table = module->indirect_table;
module__initialize_table(module); module_initialize_table(module);
module_indirect_table = cache_tbl; module_indirect_table = cache_tbl;
// Add the module to the in-memory module DB // Add the module to the in-memory module DB
module_database__add(module); module_database__add(module);
// Start listening for requests // Start listening for requests
module__initialize_as_server(module); module_initialize_as_server(module);
return module; return module;
@ -182,7 +182,7 @@ dl_open_error:
* @return RC 0 on Success. -1 on Error * @return RC 0 on Success. -1 on Error
*/ */
int int
module__new_from_json(char *file_name) module_new_from_json(char *file_name)
{ {
// Use stat to get file attributes and make sure file is there and OK // Use stat to get file attributes and make sure file is there and OK
struct stat stat_buffer; struct stat stat_buffer;
@ -310,11 +310,11 @@ module__new_from_json(char *file_name)
if (is_active == 0) continue; if (is_active == 0) continue;
// Allocate a module based on the values from the JSON // 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, 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); assert(module);
module__set_http_info(module, request_count, request_headers, request_content_type, response_count, 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++; module_count++;
free(request_headers); free(request_headers);
free(reponse_headers); free(reponse_headers);

6
runtime/src/runtime.c
Unescape View File

@ -75,7 +75,7 @@ runtime__initialize(void)
* *
*/ */
void * void *
listener_thread__main(void *dummy) listener_thread_main(void *dummy)
{ {
struct epoll_event *epoll_events = (struct epoll_event *)malloc(LISTENER_THREAD__MAX_EPOLL_EVENTS struct epoll_event *epoll_events = (struct epoll_event *)malloc(LISTENER_THREAD__MAX_EPOLL_EVENTS
* sizeof(struct epoll_event)); * sizeof(struct epoll_event));
@ -122,7 +122,7 @@ listener_thread__main(void *dummy)
* Initializes the listener thread, pinned to core 0, and starts to listen for requests * Initializes the listener thread, pinned to core 0, and starts to listen for requests
*/ */
void void
listener_thread__initialize(void) listener_thread_initialize(void)
{ {
cpu_set_t cs; cpu_set_t cs;
@ -130,7 +130,7 @@ listener_thread__initialize(void)
CPU_SET(LISTENER_THREAD__CORE_ID, &cs); CPU_SET(LISTENER_THREAD__CORE_ID, &cs);
pthread_t listener_thread; pthread_t listener_thread;
int ret = pthread_create(&listener_thread, NULL, listener_thread__main, NULL); int ret = pthread_create(&listener_thread, NULL, listener_thread_main, NULL);
assert(ret == 0); assert(ret == 0);
ret = pthread_setaffinity_np(listener_thread, sizeof(cpu_set_t), &cs); ret = pthread_setaffinity_np(listener_thread, sizeof(cpu_set_t), &cs);
assert(ret == 0); assert(ret == 0);

24
runtime/src/sandbox.c
Unescape View File

@ -92,8 +92,8 @@ current_sandbox_receive_and_parse_client_request(void)
} }
#else #else
int r = uv_read_start((uv_stream_t *)&curr->client_libuv_stream, int r = uv_read_start((uv_stream_t *)&curr->client_libuv_stream,
libuv_callbacks__on_allocate_setup_request_response_data, libuv_callbacks_on_allocate_setup_request_response_data,
libuv_callbacks__on_read_parse_http_request); libuv_callbacks_on_read_parse_http_request);
worker_thread__process_io(); worker_thread__process_io();
if (curr->request_response_data_length == 0) return 0; if (curr->request_response_data_length == 0) return 0;
#endif #endif
@ -163,7 +163,7 @@ done:
}; };
uv_buf_t bufv = uv_buf_init(curr->request_response_data, sndsz); 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, int r = uv_write(&req, (uv_stream_t *)&curr->client_libuv_stream, &bufv, 1,
libuv_callbacks__on_write_wakeup_sandbox); libuv_callbacks_on_write_wakeup_sandbox);
worker_thread__process_io(); worker_thread__process_io();
#endif #endif
return 0; return 0;
@ -187,7 +187,7 @@ current_sandbox_main(void)
software_interrupt__enable(); software_interrupt__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); int argument_count = module_get_argument_count(current_module);
// for stdio // for stdio
// Try to initialize file descriptors 0, 1, and 2 as io handles 0, 1, 2 // Try to initialize file descriptors 0, 1, and 2 as io handles 0, 1, 2
@ -232,15 +232,15 @@ current_sandbox_main(void)
// Allocate the WebAssembly Sandbox // Allocate the WebAssembly Sandbox
alloc_linear_memory(); alloc_linear_memory();
module__initialize_globals(current_module); module_initialize_globals(current_module);
module__initialize_memory(current_module); module_initialize_memory(current_module);
// Copy the arguments into the WebAssembly sandbox // Copy the arguments into the WebAssembly sandbox
current_sandbox_setup_arguments(argument_count); current_sandbox_setup_arguments(argument_count);
// Executing the function within the WebAssembly sandbox // Executing the function within the WebAssembly sandbox
current_sandbox->return_value = module__main(current_module, argument_count, current_sandbox->return_value = module_main(current_module, argument_count,
current_sandbox->arguments_offset); current_sandbox->arguments_offset);
// Retrieve the result from the WebAssembly sandbox, construct the HTTP response, and send to client // Retrieve the result from the WebAssembly sandbox, construct the HTTP response, and send to client
current_sandbox_build_and_send_client_response(); current_sandbox_build_and_send_client_response();
@ -249,7 +249,7 @@ current_sandbox_main(void)
// Cleanup connection and exit sandbox // Cleanup connection and exit sandbox
#ifdef USE_HTTP_UVIO #ifdef USE_HTTP_UVIO
uv_close((uv_handle_t *)&current_sandbox->client_libuv_stream, libuv_callbacks__on_close_wakeup_sakebox); uv_close((uv_handle_t *)&current_sandbox->client_libuv_stream, libuv_callbacks_on_close_wakeup_sakebox);
worker_thread__process_io(); worker_thread__process_io();
#else #else
close(current_sandbox->client_socket_descriptor); close(current_sandbox->client_socket_descriptor);
@ -292,7 +292,7 @@ sandbox__allocate_memory(struct module *module)
sandbox->linear_memory_size = linear_memory_size; sandbox->linear_memory_size = linear_memory_size;
sandbox->module = module; sandbox->module = module;
sandbox->sandbox_size = sandbox_size; sandbox->sandbox_size = sandbox_size;
module__acquire(module); module_acquire(module);
return sandbox; return sandbox;
} }
@ -301,7 +301,7 @@ struct sandbox *
sandbox__allocate(struct module *module, char *arguments, int socket_descriptor, const struct sockaddr *socket_address, sandbox__allocate(struct module *module, char *arguments, int socket_descriptor, const struct sockaddr *socket_address,
u64 start_time) u64 start_time)
{ {
if (!module__is_valid(module)) return NULL; if (!module_is_valid(module)) return NULL;
// FIXME: don't use malloc. huge security problem! // FIXME: don't use malloc. huge security problem!
// perhaps, main should be in its own sandbox, when it is not running any sandbox. // perhaps, main should be in its own sandbox, when it is not running any sandbox.
@ -347,7 +347,7 @@ sandbox__free(struct sandbox *sandbox)
int sz = sizeof(struct sandbox); int sz = sizeof(struct sandbox);
sz += sandbox->module->max_request_or_response_size; sz += sandbox->module->max_request_or_response_size;
module__release(sandbox->module); module_release(sandbox->module);
void * stkaddr = sandbox->stack_start; void * stkaddr = sandbox->stack_start;
size_t stksz = sandbox->stack_size; size_t stksz = sandbox->stack_size;

Write Preview
Loading…
Cancel
Save