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

chore: cleanup sandbox logic

Browse Source
sledge_graph
Sean McBride 5 years ago
parent ebfe8856bc
commit b8a0e28d11
5 changed files with 127 additions and 213 deletions
Show Stats Download Patch File Download Diff File

8
runtime/include/current_sandbox.h
Unescape View File

@ -6,18 +6,10 @@
void current_sandbox_close_file_descriptor(int io_handle_index); void current_sandbox_close_file_descriptor(int io_handle_index);
struct sandbox * current_sandbox_get(void); struct sandbox * current_sandbox_get(void);
char * current_sandbox_get_arguments(void);
int current_sandbox_get_file_descriptor(int io_handle_index); int current_sandbox_get_file_descriptor(int io_handle_index);
int current_sandbox_get_http_request_body(char **body);
union uv_any_handle *current_sandbox_get_libuv_handle(int io_handle_index); union uv_any_handle *current_sandbox_get_libuv_handle(int io_handle_index);
int current_sandbox_initialize_io_handle(void); int current_sandbox_initialize_io_handle(void);
int current_sandbox_initialize_io_handle_and_set_file_descriptor(int file_descriptor);
int current_sandbox_parse_http_request(size_t length);
void current_sandbox_set(struct sandbox *sandbox); void current_sandbox_set(struct sandbox *sandbox);
int current_sandbox_set_file_descriptor(int io_handle_index, int file_descriptor); int current_sandbox_set_file_descriptor(int io_handle_index, int file_descriptor);
int current_sandbox_set_http_response_header(char *header, int length);
int current_sandbox_set_http_response_body(char *body, int length);
int current_sandbox_set_http_response_status(char *status, int length);
int current_sandbox_vectorize_http_response(void);
#endif /* SFRT_CURRENT_SANDBOX_H */ #endif /* SFRT_CURRENT_SANDBOX_H */

4
runtime/include/sandbox.h
Unescape View File

@ -31,7 +31,6 @@ typedef enum
RETURNED RETURNED
} sandbox_state_t; } sandbox_state_t;
struct sandbox { struct sandbox {
sandbox_state_t state; sandbox_state_t state;
@ -87,7 +86,7 @@ typedef struct sandbox sandbox_t;
extern __thread arch_context_t *worker_thread_next_context; extern __thread arch_context_t *worker_thread_next_context;
extern void worker_thread_block_current_sandbox(void); extern void worker_thread_block_current_sandbox(void);
extern void worker_thread_exit_current_sandbox(void); extern void worker_thread_on_sandbox_exit(sandbox_t *sandbox);
extern void worker_thread_process_io(void); extern void worker_thread_process_io(void);
extern void __attribute__((noreturn)) worker_thread_sandbox_switch_preempt(void); extern void __attribute__((noreturn)) worker_thread_sandbox_switch_preempt(void);
extern void worker_thread_wakeup_sandbox(sandbox_t *sandbox); extern void worker_thread_wakeup_sandbox(sandbox_t *sandbox);
@ -98,6 +97,7 @@ extern void worker_thread_wakeup_sandbox(sandbox_t *sandbox);
struct sandbox *sandbox_allocate(sandbox_request_t *sandbox_request); struct sandbox *sandbox_allocate(sandbox_request_t *sandbox_request);
void sandbox_free(struct sandbox *sandbox); void sandbox_free(struct sandbox *sandbox);
void sandbox_main(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);

92
runtime/src/current_sandbox.c
Unescape View File

@ -34,17 +34,6 @@ current_sandbox_set(struct sandbox *sandbox)
} }
} }
/**
* Getter for the arguments of the current sandbox
* @return the arguments of the current sandbox
*/
char *
current_sandbox_get_arguments(void)
{
struct sandbox *sandbox = current_sandbox_get();
return sandbox_get_arguments(sandbox);
}
/** /**
* Initializes and returns an IO handle on the current sandbox ready for use * Initializes and returns an IO handle on the current sandbox ready for use
* @return index of handle we preopened or -1 if all io_handles are exhausted * @return index of handle we preopened or -1 if all io_handles are exhausted
@ -56,31 +45,8 @@ current_sandbox_initialize_io_handle(void)
return sandbox_initialize_io_handle(sandbox); return sandbox_initialize_io_handle(sandbox);
} }
/**
* Initializes and returns an IO handle on the current sandbox ready for use
* @param file_descriptor what we'll set on the IO handle after initialization
* @return index of handle we preopened or -1 if all io_handles are exhausted
**/
int
current_sandbox_initialize_io_handle_and_set_file_descriptor(int file_descriptor)
{
struct sandbox *sandbox = current_sandbox_get();
return sandbox_initialize_io_handle_and_set_file_descriptor(sandbox, file_descriptor);
}
int sandbox_parse_http_request(struct sandbox *sandbox, size_t l); int sandbox_parse_http_request(struct sandbox *sandbox, size_t l);
/**
* Parse the current sandbox's request_response_data up to length
* @param length
* @returns 0
**/
int
current_sandbox_parse_http_request(size_t length)
{
return sandbox_parse_http_request(current_sandbox_get(), length);
}
/** /**
* Sets the file descriptor of the sandbox's ith io_handle * Sets the file descriptor of the sandbox's ith io_handle
* Returns error condition if the file_descriptor to set does not contain sandbox preopen magin * Returns error condition if the file_descriptor to set does not contain sandbox preopen magin
@ -129,61 +95,3 @@ current_sandbox_get_libuv_handle(int io_handle_index)
struct sandbox *sandbox = current_sandbox_get(); struct sandbox *sandbox = current_sandbox_get();
return sandbox_get_libuv_handle(sandbox, io_handle_index); return sandbox_get_libuv_handle(sandbox, io_handle_index);
} }
/**
* Gets the HTTP Request body from the current sandbox
* @param body pointer that we'll assign to the http_request body
* @returns the length of the http_request's body
**/
int
current_sandbox_get_http_request_body(char **body)
{
return http_request_get_body(&current_sandbox_get()->http_request, body);
}
/**
* Set an HTTP Response Header on the current sandbox
* @param header string of the header that we want to set
* @param length the length of the header string
* @returns 0 (abends program in case of error)
**/
int
current_sandbox_set_http_response_header(char *header, int length)
{
return http_response_set_header(&current_sandbox_get()->http_response, header, length);
}
/**
* Set an HTTP Response Body on the current sandbox
* @param body string of the body that we want to set
* @param length the length of the body string
* @returns 0 (abends program in case of error)
**/
int
current_sandbox_set_http_response_body(char *body, int length)
{
return http_response_set_body(&current_sandbox_get()->http_response, body, length);
}
/**
* Set an HTTP Response Status on the current sandbox
* @param status string of the status we want to set
* @param length the length of the status
* @returns 0 (abends program in case of error)
**/
int
current_sandbox_set_http_response_status(char *status, int length)
{
return http_response_set_status(&current_sandbox_get()->http_response, status, length);
}
/**
* Encode the current sandbox's HTTP Response as an array of buffers
* @returns the number of buffers used to store the HTTP Response
**/
int
current_sandbox_vectorize_http_response(void)
{
return http_response_encode_as_vector(&current_sandbox_get()->http_response);
}

231
runtime/src/sandbox.c
Unescape View File

@ -12,22 +12,21 @@
/** /**
* Takes the arguments from the sandbox struct and writes them into the WebAssembly linear memory * Takes the arguments from the sandbox struct and writes them into the WebAssembly linear memory
* TODO: why do we have to pass argument count explicitly? Can't we just get this off the sandbox?
* @param argument_count
**/ **/
static inline void static inline void
current_sandbox_setup_arguments(i32 argument_count) sandbox_setup_arguments(struct sandbox *sandbox)
{ {
struct sandbox *curr = current_sandbox_get(); assert(sandbox != NULL);
char * arguments = current_sandbox_get_arguments(); char *arguments = sandbox_get_arguments(sandbox);
i32 argument_count = module_get_argument_count(sandbox->module);
// whatever gregor has, to be able to pass arguments to a module! // whatever gregor has, to be able to pass arguments to a module!
curr->arguments_offset = sandbox_lmbound; sandbox->arguments_offset = sandbox_lmbound;
assert(sandbox_lmbase == curr->linear_memory_start); assert(sandbox_lmbase == sandbox->linear_memory_start);
expand_memory(); expand_memory();
i32 *array_ptr = worker_thread_get_memory_ptr_void(curr->arguments_offset, argument_count * sizeof(i32)); i32 *array_ptr = worker_thread_get_memory_ptr_void(sandbox->arguments_offset, argument_count * sizeof(i32));
i32 string_off = curr->arguments_offset + (argument_count * sizeof(i32)); i32 string_off = sandbox->arguments_offset + (argument_count * sizeof(i32));
for (int i = 0; i < argument_count; i++) { for (int i = 0; i < argument_count; i++) {
char * arg = arguments + (i * MODULE_MAX_ARGUMENT_SIZE); char * arg = arguments + (i * MODULE_MAX_ARGUMENT_SIZE);
@ -52,6 +51,8 @@ current_sandbox_setup_arguments(i32 argument_count)
int int
sandbox_parse_http_request(struct sandbox *sandbox, size_t length) sandbox_parse_http_request(struct sandbox *sandbox, size_t length)
{ {
assert(sandbox != NULL);
assert(length > 0);
// Why is our start address sandbox->request_response_data + sandbox->request_response_data_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 // it's like a cursor to keep track of what we've read so far
http_parser_execute(&sandbox->http_parser, http_parser_settings_get(), http_parser_execute(&sandbox->http_parser, http_parser_settings_get(),
@ -59,43 +60,44 @@ sandbox_parse_http_request(struct sandbox *sandbox, size_t length)
return 0; return 0;
} }
/** /**
* Receive and Parse the Request for the current sandbox * 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 static inline int
current_sandbox_receive_and_parse_client_request(void) sandbox_receive_and_parse_client_request(struct sandbox *sandbox)
{ {
struct sandbox *curr = current_sandbox_get(); assert(sandbox != NULL);
curr->request_response_data_length = 0;
sandbox->request_response_data_length = 0;
#ifndef USE_HTTP_UVIO #ifndef USE_HTTP_UVIO
int r = 0; int r = 0;
r = recv(curr->client_socket_descriptor, (curr->request_response_data), curr->module->max_request_size, 0); r = recv(sandbox->client_socket_descriptor, (sandbox->request_response_data), sandbox->module->max_request_size,
0);
if (r <= 0) { if (r <= 0) {
if (r < 0) perror("recv1"); if (r < 0) perror("recv1");
return r; return r;
} }
while (r > 0) { while (r > 0) {
if (current_sandbox_parse_http_request(r) != 0) return -1; if (sandbox_parse_http_request(sandbox, r) != 0) return -1;
curr->request_response_data_length += r; sandbox->request_response_data_length += r;
struct http_request *rh = &curr->http_request; struct http_request *rh = &sandbox->http_request;
if (rh->message_end) break; if (rh->message_end) break;
r = recv(curr->client_socket_descriptor, r = recv(sandbox->client_socket_descriptor,
(curr->request_response_data + curr->request_response_data_length), (sandbox->request_response_data + sandbox->request_response_data_length),
curr->module->max_request_size - curr->request_response_data_length, 0); sandbox->module->max_request_size - sandbox->request_response_data_length, 0);
if (r < 0) { if (r < 0) {
perror("recv2"); perror("recv2");
return r; return r;
} }
} }
#else #else
int r = uv_read_start((uv_stream_t *)&curr->client_libuv_stream, int r = uv_read_start((uv_stream_t *)&sandbox->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 (sandbox->request_response_data_length == 0) return 0;
#endif #endif
return 1; return 1;
} }
@ -105,54 +107,55 @@ current_sandbox_receive_and_parse_client_request(void)
* @return RC. -1 on Failure * @return RC. -1 on Failure
**/ **/
static inline int static inline int
current_sandbox_build_and_send_client_response(void) sandbox_build_and_send_client_response(struct sandbox *sandbox)
{ {
int sndsz = 0; assert(sandbox != NULL);
struct sandbox *curr = current_sandbox_get();
int response_header_length = strlen(HTTP_RESPONSE_200_OK) + strlen(HTTP_RESPONSE_CONTENT_TYPE) int sndsz = 0;
int response_header_length = strlen(HTTP_RESPONSE_200_OK) + strlen(HTTP_RESPONSE_CONTENT_TYPE)
+ strlen(HTTP_RESPONSE_CONTENT_LENGTH); + strlen(HTTP_RESPONSE_CONTENT_LENGTH);
int body_length = curr->request_response_data_length - response_header_length; int body_length = sandbox->request_response_data_length - response_header_length;
memset(curr->request_response_data, 0, memset(sandbox->request_response_data, 0,
strlen(HTTP_RESPONSE_200_OK) + strlen(HTTP_RESPONSE_CONTENT_TYPE) strlen(HTTP_RESPONSE_200_OK) + strlen(HTTP_RESPONSE_CONTENT_TYPE)
+ strlen(HTTP_RESPONSE_CONTENT_LENGTH)); + strlen(HTTP_RESPONSE_CONTENT_LENGTH));
strncpy(curr->request_response_data, HTTP_RESPONSE_200_OK, strlen(HTTP_RESPONSE_200_OK)); strncpy(sandbox->request_response_data, HTTP_RESPONSE_200_OK, strlen(HTTP_RESPONSE_200_OK));
sndsz += strlen(HTTP_RESPONSE_200_OK); sndsz += strlen(HTTP_RESPONSE_200_OK);
if (body_length == 0) goto done; if (body_length == 0) goto done;
strncpy(curr->request_response_data + sndsz, HTTP_RESPONSE_CONTENT_TYPE, strlen(HTTP_RESPONSE_CONTENT_TYPE)); strncpy(sandbox->request_response_data + sndsz, HTTP_RESPONSE_CONTENT_TYPE, strlen(HTTP_RESPONSE_CONTENT_TYPE));
if (strlen(curr->module->response_content_type) <= 0) { if (strlen(sandbox->module->response_content_type) <= 0) {
strncpy(curr->request_response_data + sndsz + strlen("Content-type: "), strncpy(sandbox->request_response_data + sndsz + strlen("Content-type: "),
HTTP_RESPONSE_CONTENT_TYPE_PLAIN, strlen(HTTP_RESPONSE_CONTENT_TYPE_PLAIN)); HTTP_RESPONSE_CONTENT_TYPE_PLAIN, strlen(HTTP_RESPONSE_CONTENT_TYPE_PLAIN));
} else { } else {
strncpy(curr->request_response_data + sndsz + strlen("Content-type: "), strncpy(sandbox->request_response_data + sndsz + strlen("Content-type: "),
curr->module->response_content_type, strlen(curr->module->response_content_type)); sandbox->module->response_content_type, strlen(sandbox->module->response_content_type));
} }
sndsz += strlen(HTTP_RESPONSE_CONTENT_TYPE); sndsz += strlen(HTTP_RESPONSE_CONTENT_TYPE);
char len[10] = { 0 }; char len[10] = { 0 };
sprintf(len, "%d", body_length); sprintf(len, "%d", body_length);
strncpy(curr->request_response_data + sndsz, HTTP_RESPONSE_CONTENT_LENGTH, strncpy(sandbox->request_response_data + sndsz, HTTP_RESPONSE_CONTENT_LENGTH,
strlen(HTTP_RESPONSE_CONTENT_LENGTH)); strlen(HTTP_RESPONSE_CONTENT_LENGTH));
strncpy(curr->request_response_data + sndsz + strlen("Content-length: "), len, strlen(len)); strncpy(sandbox->request_response_data + sndsz + strlen("Content-length: "), len, strlen(len));
sndsz += strlen(HTTP_RESPONSE_CONTENT_LENGTH); sndsz += strlen(HTTP_RESPONSE_CONTENT_LENGTH);
sndsz += body_length; sndsz += body_length;
done: done:
assert(sndsz == curr->request_response_data_length); assert(sndsz == sandbox->request_response_data_length);
curr->total_time = __getcycles() - curr->start_time; sandbox->total_time = __getcycles() - sandbox->start_time;
uint64_t total_time_us = curr->total_time / runtime_processor_speed_MHz; uint64_t total_time_us = sandbox->total_time / runtime_processor_speed_MHz;
printf("%s():%d, %d, %lu\n", curr->module->name, curr->module->port, curr->module->relative_deadline_us, printf("%s():%d, %d, %lu\n", sandbox->module->name, sandbox->module->port,
total_time_us); sandbox->module->relative_deadline_us, total_time_us);
#ifndef USE_HTTP_UVIO #ifndef USE_HTTP_UVIO
int r = send(curr->client_socket_descriptor, curr->request_response_data, sndsz, 0); int r = send(sandbox->client_socket_descriptor, sandbox->request_response_data, sndsz, 0);
if (r < 0) { if (r < 0) {
perror("send"); perror("send");
return -1; return -1;
} }
while (r < sndsz) { while (r < sndsz) {
int s = send(curr->client_socket_descriptor, curr->request_response_data + r, sndsz - r, 0); int s = send(sandbox->client_socket_descriptor, sandbox->request_response_data + r, sndsz - r, 0);
if (s < 0) { if (s < 0) {
perror("send"); perror("send");
return -1; return -1;
@ -161,101 +164,113 @@ done:
} }
#else #else
uv_write_t req = { uv_write_t req = {
.data = curr, .data = sandbox,
}; };
uv_buf_t bufv = uv_buf_init(curr->request_response_data, sndsz); uv_buf_t bufv = uv_buf_init(sandbox->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 *)&sandbox->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;
} }
/** static inline void
* Sandbox execution logic sandbox_close_http(struct sandbox *sandbox)
* Handles setup, request parsing, WebAssembly initialization, function execution, response building and sending, and
*cleanup
**/
void
current_sandbox_main(void)
{ {
struct sandbox *current_sandbox = current_sandbox_get(); assert(sandbox != NULL);
// 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 (software_interrupt_is_enabled() == false) {
arch_context_init(&current_sandbox->ctxt, 0, 0);
worker_thread_next_context = NULL;
software_interrupt_enable();
}
struct module *current_module = sandbox_get_module(current_sandbox);
int argument_count = module_get_argument_count(current_module);
// for stdio
// Try to initialize file descriptors 0, 1, and 2 as io handles 0, 1, 2 #ifdef USE_HTTP_UVIO
// We need to check that we get what we expect, as these IO handles may theoretically have been taken uv_close((uv_handle_t *)&sandbox->client_libuv_stream, libuv_callbacks_on_close_wakeup_sakebox);
// TODO: why do the file descriptors have to match the io handles? worker_thread_process_io();
int f = current_sandbox_initialize_io_handle_and_set_file_descriptor(0); #else
assert(f == 0); close(sandbox->client_socket_descriptor);
f = current_sandbox_initialize_io_handle_and_set_file_descriptor(1); #endif
assert(f == 1); }
f = current_sandbox_initialize_io_handle_and_set_file_descriptor(2);
assert(f == 2);
// Initialize the HTTP-Parser for a request static inline void
http_parser_init(&current_sandbox->http_parser, HTTP_REQUEST); sandbox_open_http(struct sandbox *sandbox)
{
assert(sandbox != NULL);
// Set the current_sandbox as the data the http-parser has access to http_parser_init(&sandbox->http_parser, HTTP_REQUEST);
current_sandbox->http_parser.data = current_sandbox;
// NOTE: if more headers, do offset by that! // Set the sandbox as the data the http-parser has access to
int response_header_length = strlen(HTTP_RESPONSE_200_OK) + strlen(HTTP_RESPONSE_CONTENT_TYPE) sandbox->http_parser.data = sandbox;
+ strlen(HTTP_RESPONSE_CONTENT_LENGTH);
#ifdef USE_HTTP_UVIO #ifdef USE_HTTP_UVIO
// Initialize libuv TCP stream // Initialize libuv TCP stream
int r = uv_tcp_init(worker_thread_get_libuv_handle(), (uv_tcp_t *)&current_sandbox->client_libuv_stream); int r = uv_tcp_init(worker_thread_get_libuv_handle(), (uv_tcp_t *)&sandbox->client_libuv_stream);
assert(r == 0); assert(r == 0);
// Set the current sandbox as the data the libuv callbacks have access to // Set the current sandbox as the data the libuv callbacks have access to
current_sandbox->client_libuv_stream.data = current_sandbox; sandbox->client_libuv_stream.data = sandbox;
// Open the libuv TCP stream // Open the libuv TCP stream
r = uv_tcp_open((uv_tcp_t *)&current_sandbox->client_libuv_stream, current_sandbox->client_socket_descriptor); r = uv_tcp_open((uv_tcp_t *)&sandbox->client_libuv_stream, sandbox->client_socket_descriptor);
assert(r == 0); assert(r == 0);
#endif #endif
}
// If the HTTP Request returns 1, we've successfully received and parsed the HTTP request, so execute it! // Initialize file descriptors 0, 1, and 2 as io handles 0, 1, 2
if (current_sandbox_receive_and_parse_client_request() > 0) { static inline void
// sandbox_initialize_io_handles_and_file_descriptors(struct sandbox *sandbox)
current_sandbox->request_response_data_length = response_header_length; {
int f = sandbox_initialize_io_handle_and_set_file_descriptor(sandbox, 0);
assert(f == 0);
f = sandbox_initialize_io_handle_and_set_file_descriptor(sandbox, 1);
assert(f == 1);
f = sandbox_initialize_io_handle_and_set_file_descriptor(sandbox, 2);
assert(f == 2);
}
// Allocate the WebAssembly Sandbox /**
alloc_linear_memory(); * Sandbox execution logic
module_initialize_globals(current_module); * Handles setup, request parsing, WebAssembly initialization, function execution, response building and sending, and
module_initialize_memory(current_module); *cleanup
**/
void
current_sandbox_main(void)
{
struct sandbox *sandbox = current_sandbox_get();
// assert(sandbox != NULL);
assert(sandbox->state == RUNNABLE);
// Copy the arguments into the WebAssembly sandbox assert(!software_interrupt_is_enabled());
current_sandbox_setup_arguments(argument_count); arch_context_init(&sandbox->ctxt, 0, 0);
worker_thread_next_context = NULL;
software_interrupt_enable();
// Executing the function within the WebAssembly sandbox sandbox_initialize_io_handles_and_file_descriptors(sandbox);
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 sandbox_open_http(sandbox);
current_sandbox_build_and_send_client_response();
}
// Cleanup connection and exit sandbox // Parse the request. 1 = Success
int rc = sandbox_receive_and_parse_client_request(sandbox);
if (rc != 1) goto err;
#ifdef USE_HTTP_UVIO // Initialize the module
uv_close((uv_handle_t *)&current_sandbox->client_libuv_stream, libuv_callbacks_on_close_wakeup_sakebox); struct module *current_module = sandbox_get_module(sandbox);
worker_thread_process_io(); int argument_count = module_get_argument_count(current_module);
#else // alloc_linear_memory();
close(current_sandbox->client_socket_descriptor); module_initialize_globals(current_module);
#endif module_initialize_memory(current_module);
worker_thread_exit_current_sandbox();
// Copy the arguments into the WebAssembly sandbox
sandbox_setup_arguments(sandbox);
// Executing the function
sandbox->return_value = module_main(current_module, argument_count, sandbox->arguments_offset);
// Retrieve the result, construct the HTTP response, and send to client
sandbox_build_and_send_client_response(sandbox);
done:
// Cleanup connection and exit sandbox
sandbox_close_http(sandbox);
worker_thread_on_sandbox_exit(sandbox);
err:
goto done;
} }
/** /**

5
runtime/src/worker_thread.c
Unescape View File

@ -220,9 +220,8 @@ worker_thread_main(void *return_code)
* TODO: Consider moving this to a future current_sandbox file. This has thus far proven difficult to move * TODO: Consider moving this to a future current_sandbox file. This has thus far proven difficult to move
**/ **/
void void
worker_thread_exit_current_sandbox(void) worker_thread_on_sandbox_exit(sandbox_t *exiting_sandbox)
{ {
struct sandbox *exiting_sandbox = current_sandbox_get();
assert(exiting_sandbox); assert(exiting_sandbox);
// TODO: I do not understand when software interrupts must be disabled? // TODO: I do not understand when software interrupts must be disabled?
@ -235,7 +234,7 @@ worker_thread_exit_current_sandbox(void)
// function execution" // function execution"
int rc = munmap(exiting_sandbox->linear_memory_start, SBOX_MAX_MEM + PAGE_SIZE); int rc = munmap(exiting_sandbox->linear_memory_start, SBOX_MAX_MEM + PAGE_SIZE);
if (rc == -1) { if (rc == -1) {
perror("worker_thread_exit_current_sandbox - munmap failed"); perror("worker_thread_on_sandbox_exit - munmap failed");
assert(0); assert(0);
} }

Write Preview
Loading…
Cancel
Save