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

fix: correct http-parser bug

Browse Source
sledge_graph
Sean McBride 5 years ago
parent 046433dc3d
commit 46f597a78c
10 changed files with 150 additions and 156 deletions
Show Stats Download Patch File Download Diff File

21
runtime/experiments/applications/client1.sh
Unescape View File

@ -1,6 +1,23 @@
#!/bin/bash #!/bin/bash
for i in {1..10000}; do expected_result="This is q handw__tten
examp(e for _0CR,
Write as good as yo_ c4n."
success_count=0
total_count=1000
for ((i = 0; i < total_count; i++)); do
echo "$i" echo "$i"
curl -H 'Expect:' -H "Content-Type: text/plain" --data-binary "@handwrt1.pnm" localhost:10000 result=$(curl -H 'Expect:' -H "Content-Type: text/plain" --data-binary "@handwrt1.pnm" localhost:10000 2>/dev/null)
# echo "$result"
if [[ "$result" == "$expected_result" ]]; then
success_count=$((success_count + 1))
else
echo "FAIL"
echo "Expected $expected_result"
echo "Was $result"
fi
done done
echo "$success_count / $total_count"

2
runtime/include/http_request.h
Unescape View File

@ -6,7 +6,9 @@
/* all in-memory ptrs.. don't mess around with that! */ /* all in-memory ptrs.. don't mess around with that! */
struct http_header { struct http_header {
char *key; char *key;
int key_length;
char *value; char *value;
int value_length;
}; };
struct http_request { struct http_request {

7
runtime/include/runtime.h
Unescape View File

@ -35,12 +35,15 @@ extern pthread_t runtime_worker_threads[];
extern uint32_t runtime_worker_threads_count; extern uint32_t runtime_worker_threads_count;
extern uint64_t runtime_admissions_capacity; extern uint64_t runtime_admissions_capacity;
/* Listener Core Counts */
extern _Atomic uint32_t runtime_total_requests;
extern _Atomic uint32_t runtime_total_sandbox_requests;
extern _Atomic uint32_t runtime_total_5XX_responses;
#ifdef LOG_TOTAL_REQS_RESPS #ifdef LOG_TOTAL_REQS_RESPS
/* Counts to track requests and responses */ /* Counts to track requests and responses */
extern _Atomic uint32_t runtime_total_requests;
extern _Atomic uint32_t runtime_total_2XX_responses; extern _Atomic uint32_t runtime_total_2XX_responses;
extern _Atomic uint32_t runtime_total_4XX_responses; extern _Atomic uint32_t runtime_total_4XX_responses;
extern _Atomic uint32_t runtime_total_5XX_responses;
#endif #endif
#ifdef LOG_SANDBOX_TOTALS #ifdef LOG_SANDBOX_TOTALS

7
runtime/include/sandbox.h
Unescape View File

@ -51,6 +51,7 @@ typedef enum
} sandbox_state_t; } sandbox_state_t;
struct sandbox { struct sandbox {
uint64_t id;
sandbox_state_t state; sandbox_state_t state;
uint32_t sandbox_size; /* The struct plus enough buffer to hold the request or response (sized off largest) */ uint32_t sandbox_size; /* The struct plus enough buffer to hold the request or response (sized off largest) */
@ -331,9 +332,9 @@ sandbox_print_perf(struct sandbox *sandbox)
"running: %u, " "running: %u, "
"blocked: %u, " "blocked: %u, "
"returned: %u\n", "returned: %u\n",
sandbox->request_arrival_timestamp, sandbox->module->name, sandbox->module->port, sandbox->id, sandbox->module->name, sandbox->module->port, sandbox_state_stringify(sandbox->state),
sandbox_state_stringify(sandbox->state), sandbox->module->relative_deadline_us, total_time_us, sandbox->module->relative_deadline_us, total_time_us, queued_us, initializing_us, runnable_us,
queued_us, initializing_us, runnable_us, running_us, blocked_us, returned_us); running_us, blocked_us, returned_us);
} }
static inline void static inline void

6
runtime/include/sandbox_request.h
Unescape View File

@ -8,6 +8,7 @@
#include "runtime.h" #include "runtime.h"
struct sandbox_request { struct sandbox_request {
uint64_t id;
struct module * module; struct module * module;
char * arguments; char * arguments;
int socket_descriptor; int socket_descriptor;
@ -40,6 +41,11 @@ sandbox_request_allocate(struct module *module, char *arguments, int socket_desc
{ {
struct sandbox_request *sandbox_request = (struct sandbox_request *)malloc(sizeof(struct sandbox_request)); struct sandbox_request *sandbox_request = (struct sandbox_request *)malloc(sizeof(struct sandbox_request));
assert(sandbox_request); assert(sandbox_request);
/* Sets the ID to the value before the increment */
sandbox_request->id = atomic_fetch_add(&runtime_total_sandbox_requests, 1);
assert(runtime_total_sandbox_requests + runtime_total_5XX_responses <= runtime_total_requests);
sandbox_request->module = module; sandbox_request->module = module;
sandbox_request->arguments = arguments; sandbox_request->arguments = arguments;
sandbox_request->socket_descriptor = socket_descriptor; sandbox_request->socket_descriptor = socket_descriptor;

125
runtime/src/http_parser_settings.c
Unescape View File

@ -24,10 +24,12 @@ int
http_parser_settings_on_url(http_parser *parser, const char *at, size_t length) 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;
if (sandbox->http_request.message_end || sandbox->http_request.header_end) return 0;
assert(!sandbox->http_request.message_end);
assert(!sandbox->http_request.header_end);
#ifdef LOG_HTTP_PARSER #ifdef LOG_HTTP_PARSER
debuglog("sandbox: %lu\n", sandbox->request_arrival_timestamp); debuglog("sandbox: %lu, length: %zu, Content \"%.*s\"\n", sandbox->id, length, (int)length, at);
assert(strncmp(sandbox->module->name, (at + 1), length - 1) == 0); assert(strncmp(sandbox->module->name, (at + 1), length - 1) == 0);
#endif #endif
@ -45,15 +47,16 @@ 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; struct http_request *http_request = &sandbox->http_request;
if (sandbox->http_request.message_end || sandbox->http_request.header_end) return 0; assert(!sandbox->http_request.message_end);
assert(!sandbox->http_request.header_end);
#ifdef LOG_HTTP_PARSER #ifdef LOG_HTTP_PARSER
debuglog("sandbox: %lu\n", sandbox->request_arrival_timestamp); debuglog("sandbox: %lu\n", sandbox->id);
#endif #endif
http_request->message_begin = true; http_request->message_begin = true;
http_request->last_was_value = true; /* should always start with a header */ http_request->last_was_value = true; /* should always start with a header */
sandbox->is_repeat_header = false;
return 0; return 0;
} }
@ -72,43 +75,30 @@ http_parser_settings_on_header_field(http_parser *parser, const char *at, size_t
struct sandbox * sandbox = (struct sandbox *)parser->data; struct sandbox * sandbox = (struct sandbox *)parser->data;
struct http_request *http_request = &sandbox->http_request; struct http_request *http_request = &sandbox->http_request;
if (sandbox->http_request.message_end || sandbox->http_request.header_end) return 0;
#ifdef LOG_HTTP_PARSER #ifdef LOG_HTTP_PARSER
debuglog("sandbox: %lu\n", sandbox->request_arrival_timestamp); debuglog("sandbox: %lu, length: %zu, Content \"%.*s\"\n", sandbox->id, length, (int)length, at);
#endif #endif
/* Previous name continues */ assert(!sandbox->http_request.message_end);
assert(!sandbox->http_request.header_end);
if (http_request->last_was_value == false) { if (http_request->last_was_value == false) {
/* Previous key continues */
assert(http_request->header_count > 0); assert(http_request->header_count > 0);
strncat(http_request->headers[http_request->header_count].key, at, length); if (unlikely(http_request->headers[http_request->header_count].key_length + length
return 0; > HTTP_MAX_HEADER_LENGTH)) {
} return -1;
/*
* We receive repeat headers for an unknown reason, so we need to ignore repeat headers
* This probably means that the headers are getting reparsed, so for the sake of performance
* this should be fixed upstream
*/
#ifdef LOG_HTTP_PARSER
for (int i = 0; i < http_request->header_count; i++) {
if (strncmp(http_request->headers[i].key, at, length) == 0) {
debuglog("Repeat header!\n");
assert(0);
sandbox->is_repeat_header = true;
break;
} }
} http_request->headers[http_request->header_count].key_length += length;
#endif return 0;
} else {
if (!sandbox->is_repeat_header) { /* Start of new key */
if (unlikely(http_request->header_count >= HTTP_MAX_HEADER_COUNT)) { return -1; } if (unlikely(http_request->header_count >= HTTP_MAX_HEADER_COUNT)) return -1;
if (unlikely(length > HTTP_MAX_HEADER_LENGTH)) { return -1; } if (unlikely(length > HTTP_MAX_HEADER_LENGTH)) return -1;
http_request->headers[http_request->header_count++].key = (char *)at; http_request->header_count++;
http_request->last_was_value = false; http_request->headers[http_request->header_count - 1].key = (char *)at;
sandbox->is_repeat_header = false; http_request->headers[http_request->header_count - 1].key_length = length;
http_request->last_was_value = false;
} }
return 0; return 0;
@ -128,21 +118,24 @@ http_parser_settings_on_header_value(http_parser *parser, const char *at, size_t
struct sandbox * sandbox = (struct sandbox *)parser->data; struct sandbox * sandbox = (struct sandbox *)parser->data;
struct http_request *http_request = &sandbox->http_request; struct http_request *http_request = &sandbox->http_request;
if (http_request->message_end || http_request->header_end) return 0;
#ifdef LOG_HTTP_PARSER #ifdef LOG_HTTP_PARSER
debuglog("sandbox: %lu\n", sandbox->request_arrival_timestamp); debuglog("sandbox: %lu, length: %zu, Content \"%.*s\"\n", sandbox->id, length, (int)length, at);
#endif #endif
// TODO: If last_was_value is already true, we might need to append to value assert(!sandbox->http_request.message_end);
assert(!sandbox->http_request.header_end);
/* it is from the sandbox's request_response_data, should persist. */ if (!http_request->last_was_value) {
if (!sandbox->is_repeat_header) {
if (unlikely(length >= HTTP_MAX_HEADER_VALUE_LENGTH)) return -1; if (unlikely(length >= HTTP_MAX_HEADER_VALUE_LENGTH)) return -1;
http_request->headers[http_request->header_count - 1].value = (char *)at; http_request->headers[http_request->header_count - 1].value = (char *)at;
http_request->last_was_value = true; http_request->headers[http_request->header_count - 1].value_length = length;
} else {
assert(http_request->headers[http_request->header_count - 1].value_length > 0);
http_request->headers[http_request->header_count - 1].value_length += length;
} }
http_request->last_was_value = true;
return 0; return 0;
} }
@ -156,16 +149,21 @@ 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; struct http_request *http_request = &sandbox->http_request;
if (http_request->message_end || http_request->header_end) return 0;
assert(!sandbox->http_request.message_end);
assert(!sandbox->http_request.header_end);
#ifdef LOG_HTTP_PARSER #ifdef LOG_HTTP_PARSER
debuglog("sandbox: %lu\n", sandbox->request_arrival_timestamp); debuglog("sandbox: %lu\n", sandbox->id);
#endif #endif
http_request->header_end = true; http_request->header_end = true;
return 0; return 0;
} }
const size_t http_methods_len = 8;
const char * http_methods[http_methods_len] = { "OPTIONS", "GET", "HEAD", "POST", "PUT", "DELETE", "TRACE", "CONNECT" };
/** /**
* http-parser callback called for HTTP Bodies * http-parser callback called for HTTP Bodies
* Assigns the parsed data to the http_request body of the sandbox struct * Assigns the parsed data to the http_request body of the sandbox struct
@ -181,38 +179,34 @@ 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; struct http_request *http_request = &sandbox->http_request;
if (http_request->message_end) return 0; assert(sandbox->http_request.header_end);
assert(!sandbox->http_request.message_end);
#ifdef LOG_HTTP_PARSER
debuglog("sandbox: %lu\n", sandbox->request_arrival_timestamp);
#endif
/* Assumption: We should never exceed the buffer we're reusing */ /* Assumption: We should never exceed the buffer we're reusing */
assert(http_request->body_length + length <= sandbox->module->max_request_size); assert(http_request->body_length + length <= sandbox->module->max_request_size);
if (!http_request->body) { if (!http_request->body) {
#ifdef LOG_HTTP_PARSER
debuglog("Setting start of body!\n");
#endif
/* If this is the first invocation of the callback, just set */ /* If this is the first invocation of the callback, just set */
http_request->body = (char *)at; http_request->body = (char *)at;
http_request->body_length = length; http_request->body_length = length;
} else { } else {
#ifdef LOG_HTTP_PARSER #ifdef LOG_HTTP_PARSER
debuglog("Body: %p, Existing Length: %d\n", http_request->body, http_request->body_length); debuglog("Appending to existing body!\n");
debuglog("Expected Offset %d, Actual Offset: %lu\n", http_request->body_length,
at - http_request->body);
/* Attempt to copy and print the entire body */
uint64_t possible_body_len = at - http_request->body;
char test_buffer[possible_body_len + length + 1];
strncpy(test_buffer, http_request->body, possible_body_len);
test_buffer[length] = '\0';
debuglog("http_parser_settings_on_body: len %lu, content: %s\n", possible_body_len, test_buffer);
#endif #endif
http_request->body_length += length; http_request->body_length += length;
} }
#ifdef LOG_HTTP_PARSER
int capped_len = length > 1000 ? 1000 : length;
debuglog("sandbox: %lu, length: %zu, Content(up to 1000 chars) \"%.*s\"\n", sandbox->id, length,
(int)capped_len, at);
#endif
return 0; return 0;
} }
@ -227,12 +221,15 @@ 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; struct http_request *http_request = &sandbox->http_request;
if (http_request->message_end) return 0; assert(sandbox->http_request.header_end);
assert(!sandbox->http_request.message_end);
#ifdef LOG_HTTP_PARSER #ifdef LOG_HTTP_PARSER
debuglog("sandbox: %lu\n", sandbox->request_arrival_timestamp); debuglog("sandbox: %lu\n", sandbox->id);
#endif #endif
http_request->message_end = true; http_request->message_end = true;
return 0; return 0;
} }

7
runtime/src/local_runqueue_minheap.c
Unescape View File

@ -59,10 +59,7 @@ local_runqueue_minheap_delete(struct sandbox *sandbox)
assert(sandbox != NULL); assert(sandbox != NULL);
int rc = priority_queue_delete(&local_runqueue_minheap, sandbox); int rc = priority_queue_delete(&local_runqueue_minheap, sandbox);
if (rc == -1) { if (rc == -1) panic("Tried to delete sandbox %lu from runqueue, but was not present\n", sandbox->id);
panic("Tried to delete sandbox %lu from runqueue, but was not present\n",
sandbox->request_arrival_timestamp);
}
} }
/** /**
@ -143,7 +140,7 @@ local_runqueue_minheap_preempt(ucontext_t *user_context)
if (global_deadline < local_deadline) { if (global_deadline < local_deadline) {
#ifdef LOG_PREEMPTION #ifdef LOG_PREEMPTION
debuglog("Sandbox %lu has deadline of %lu. Trying to preempt for request with %lu\n", debuglog("Sandbox %lu has deadline of %lu. Trying to preempt for request with %lu\n",
current_sandbox->request_arrival_timestamp, local_deadline, global_deadline); current_sandbox->id, local_deadline, global_deadline);
#endif #endif
int return_code = global_request_scheduler_remove_if_earlier(&sandbox_request, local_deadline); int return_code = global_request_scheduler_remove_if_earlier(&sandbox_request, local_deadline);

20
runtime/src/runtime.c
Unescape View File

@ -22,11 +22,17 @@ int runtime_epoll_file_descriptor;
_Atomic uint64_t runtime_admitted; _Atomic uint64_t runtime_admitted;
uint64_t runtime_admissions_capacity; uint64_t runtime_admissions_capacity;
/* Listener Core Bookkeeping */
_Atomic uint32_t runtime_total_requests = 0;
/* Sandbox Requests + 5XX Responses (Rejections) should always equal total requests */
_Atomic uint32_t runtime_total_sandbox_requests = 0;
_Atomic uint32_t runtime_total_5XX_responses = 0;
#ifdef LOG_TOTAL_REQS_RESPS #ifdef LOG_TOTAL_REQS_RESPS
_Atomic uint32_t runtime_total_requests = 0; /* 2XX + 4XX should equal sandboxes */
_Atomic uint32_t runtime_total_2XX_responses = 0; _Atomic uint32_t runtime_total_2XX_responses = 0;
_Atomic uint32_t runtime_total_4XX_responses = 0; _Atomic uint32_t runtime_total_4XX_responses = 0;
_Atomic uint32_t runtime_total_5XX_responses = 0;
void void
runtime_log_requests_responses() runtime_log_requests_responses()
@ -89,11 +95,13 @@ runtime_log_sandbox_states()
void void
runtime_initialize(void) runtime_initialize(void)
{ {
#ifdef LOG_TOTAL_REQS_RESPS
atomic_init(&runtime_total_requests, 0); atomic_init(&runtime_total_requests, 0);
atomic_init(&runtime_total_sandbox_requests, 0);
atomic_init(&runtime_total_5XX_responses, 0);
#ifdef LOG_TOTAL_REQS_RESPS
atomic_init(&runtime_total_2XX_responses, 0); atomic_init(&runtime_total_2XX_responses, 0);
atomic_init(&runtime_total_4XX_responses, 0); atomic_init(&runtime_total_4XX_responses, 0);
atomic_init(&runtime_total_5XX_responses, 0);
#endif #endif
#ifdef LOG_SANDBOX_TOTALS #ifdef LOG_SANDBOX_TOTALS
atomic_init(&runtime_total_freed_requests, 0); atomic_init(&runtime_total_freed_requests, 0);
@ -157,9 +165,7 @@ listener_thread_reject(int client_socket)
sent += rc; sent += rc;
}; };
#ifdef LOG_TOTAL_REQS_RESPS
atomic_fetch_add(&runtime_total_5XX_responses, 1); atomic_fetch_add(&runtime_total_5XX_responses, 1);
#endif
close: close:
if (close(client_socket) < 0) panic("Error closing client socket - %s", strerror(errno)); if (close(client_socket) < 0) panic("Error closing client socket - %s", strerror(errno));
@ -255,9 +261,7 @@ listener_thread_main(void *dummy)
module->name); module->name);
} }
#ifdef LOG_TOTAL_REQS_RESPS
atomic_fetch_add(&runtime_total_requests, 1); atomic_fetch_add(&runtime_total_requests, 1);
#endif
/* Perform Admission Control */ /* Perform Admission Control */

102
runtime/src/sandbox.c
Unescape View File

@ -64,18 +64,18 @@ sandbox_receive_and_parse_client_request(struct sandbox *sandbox)
while (!sandbox->http_request.message_end) { while (!sandbox->http_request.message_end) {
/* Read from the Socket */ /* Read from the Socket */
ssize_t length_read = recv(sandbox->client_socket_descriptor,
&sandbox->request_response_data[sandbox->request_response_data_length],
sandbox->module->max_request_size - sandbox->request_response_data_length,
0);
/* Unexpected client shutdown.. or is this just EOF */
if (length_read == 0 && !sandbox->http_request.message_end) {
debuglog("Client Shutdown Socket\n");
goto err;
}
if (length_read < 0) { /* Structured to closely follow usage example at https://github.com/nodejs/http-parser */
http_parser * parser = &sandbox->http_parser;
const http_parser_settings *settings = http_parser_settings_get();
int fd = sandbox->client_socket_descriptor;
char * buf = &sandbox->request_response_data[sandbox->request_response_data_length];
size_t len = sandbox->module->max_request_size - sandbox->request_response_data_length;
ssize_t recved = recv(fd, buf, len, 0);
if (recved < 0) {
if (errno == EAGAIN) { if (errno == EAGAIN) {
worker_thread_block_current_sandbox(); worker_thread_block_current_sandbox();
continue; continue;
@ -87,46 +87,20 @@ sandbox_receive_and_parse_client_request(struct sandbox *sandbox)
} }
} }
if (sandbox->http_request.message_end) {
sandbox->request_response_data_length += length_read;
break;
};
#ifdef LOG_HTTP_PARSER #ifdef LOG_HTTP_PARSER
debuglog("http_parser_execute(%p, %p, %p, %lu)", &sandbox->http_parser, http_parser_settings_get(), debuglog("Sandbox: %lu http_parser_execute(%p, %p, %p, %lu)", sandbox->id, parser, settings, buf, len);
&sandbox->request_response_data[sandbox->request_response_data_length], length_read);
#endif #endif
size_t nparsed = http_parser_execute(parser, settings, buf, recved);
http_parser_execute(&sandbox->http_parser, http_parser_settings_get(), if (nparsed != recved) {
&sandbox->request_response_data[sandbox->request_response_data_length],
length_read);
/* Try to parse what we've read */
/* TODO: Consider 0 as EOF? */
size_t length_parsed =
http_parser_execute(&sandbox->http_parser, http_parser_settings_get(),
&sandbox->request_response_data[sandbox->request_response_data_length],
length_read);
if (sandbox->http_request.message_end) {
sandbox->request_response_data_length += length_read;
break;
};
// size_t length_parsed = sandbox_parse_http_request(sandbox, length_read);
if (length_parsed != length_read) {
debuglog("Error: %s, Description: %s\n", http_errno_name(sandbox->http_parser.status_code), debuglog("Error: %s, Description: %s\n", http_errno_name(sandbox->http_parser.status_code),
http_errno_description(sandbox->http_parser.status_code)); http_errno_description(sandbox->http_parser.status_code));
debuglog("Length Parsed %zu, Length Read %zu\n", length_parsed, length_read); debuglog("Length Parsed %zu, Length Read %zu\n", nparsed, recved);
debuglog("Error parsing socket %d\n", sandbox->client_socket_descriptor); debuglog("Error parsing socket %d\n", sandbox->client_socket_descriptor);
goto err; goto err;
} }
sandbox->request_response_data_length += length_read; sandbox->request_response_data_length += nparsed;
debuglog("After Read: %lu", sandbox->request_response_data_length);
} }
@ -405,7 +379,7 @@ err:
#ifdef LOG_TOTAL_REQS_RESPS #ifdef LOG_TOTAL_REQS_RESPS
if (rc >= 0) { if (rc >= 0) {
atomic_fetch_add(&runtime_total_4XX_responses, 1); atomic_fetch_add(&runtime_total_4XX_responses, 1);
debuglog("At %llu, Sandbox %lu - 4XX\n", __getcycles(), sandbox->request_arrival_timestamp); debuglog("At %llu, Sandbox %lu - 4XX\n", __getcycles(), sandbox->id);
} }
#endif #endif
@ -523,6 +497,7 @@ sandbox_set_as_initialized(struct sandbox *sandbox, struct sandbox_request *sand
#ifdef LOG_STATE_CHANGES #ifdef LOG_STATE_CHANGES
debuglog("Sandbox %lu | Uninitialized => Initialized\n", sandbox_request->request_arrival_timestamp); debuglog("Sandbox %lu | Uninitialized => Initialized\n", sandbox_request->request_arrival_timestamp);
#endif #endif
sandbox->id = sandbox_request->id;
sandbox->admissions_estimate = sandbox_request->admissions_estimate; sandbox->admissions_estimate = sandbox_request->admissions_estimate;
sandbox->request_arrival_timestamp = sandbox_request->request_arrival_timestamp; sandbox->request_arrival_timestamp = sandbox_request->request_arrival_timestamp;
@ -575,8 +550,7 @@ sandbox_set_as_runnable(struct sandbox *sandbox, sandbox_state_t last_state)
sandbox->state = SANDBOX_SET_AS_RUNNABLE; sandbox->state = SANDBOX_SET_AS_RUNNABLE;
#ifdef LOG_STATE_CHANGES #ifdef LOG_STATE_CHANGES
debuglog("Sandbox %lu | %s => Runnable\n", sandbox->request_arrival_timestamp, debuglog("Sandbox %lu | %s => Runnable\n", sandbox->id, sandbox_state_stringify(last_state));
sandbox_state_stringify(last_state));
#endif #endif
switch (last_state) { switch (last_state) {
@ -597,7 +571,7 @@ sandbox_set_as_runnable(struct sandbox *sandbox, sandbox_state_t last_state)
break; break;
} }
default: { default: {
panic("Sandbox %lu | Illegal transition from %s to Runnable\n", sandbox->request_arrival_timestamp, panic("Sandbox %lu | Illegal transition from %s to Runnable\n", sandbox->id,
sandbox_state_stringify(last_state)); sandbox_state_stringify(last_state));
} }
} }
@ -631,8 +605,7 @@ sandbox_set_as_running(struct sandbox *sandbox, sandbox_state_t last_state)
sandbox->state = SANDBOX_SET_AS_RUNNING; sandbox->state = SANDBOX_SET_AS_RUNNING;
#ifdef LOG_STATE_CHANGES #ifdef LOG_STATE_CHANGES
debuglog("Sandbox %lu | %s => Running\n", sandbox->request_arrival_timestamp, debuglog("Sandbox %lu | %s => Running\n", sandbox->id, sandbox_state_stringify(last_state));
sandbox_state_stringify(last_state));
#endif #endif
switch (last_state) { switch (last_state) {
@ -653,7 +626,7 @@ sandbox_set_as_running(struct sandbox *sandbox, sandbox_state_t last_state)
break; break;
} }
default: { default: {
panic("Sandbox %lu | Illegal transition from %s to Running\n", sandbox->request_arrival_timestamp, panic("Sandbox %lu | Illegal transition from %s to Running\n", sandbox->id,
sandbox_state_stringify(last_state)); sandbox_state_stringify(last_state));
} }
} }
@ -684,8 +657,7 @@ sandbox_set_as_preempted(struct sandbox *sandbox, sandbox_state_t last_state)
sandbox->state = SANDBOX_SET_AS_PREEMPTED; sandbox->state = SANDBOX_SET_AS_PREEMPTED;
#ifdef LOG_STATE_CHANGES #ifdef LOG_STATE_CHANGES
debuglog("Sandbox %lu | %s => Preempted\n", sandbox->request_arrival_timestamp, debuglog("Sandbox %lu | %s => Preempted\n", sandbox->id, sandbox_state_stringify(last_state));
sandbox_state_stringify(last_state));
#endif #endif
switch (last_state) { switch (last_state) {
@ -698,7 +670,7 @@ sandbox_set_as_preempted(struct sandbox *sandbox, sandbox_state_t last_state)
break; break;
} }
default: { default: {
panic("Sandbox %lu | Illegal transition from %s to Preempted\n", sandbox->request_arrival_timestamp, panic("Sandbox %lu | Illegal transition from %s to Preempted\n", sandbox->id,
sandbox_state_stringify(last_state)); sandbox_state_stringify(last_state));
} }
} }
@ -726,8 +698,7 @@ sandbox_set_as_blocked(struct sandbox *sandbox, sandbox_state_t last_state)
sandbox->state = SANDBOX_SET_AS_BLOCKED; sandbox->state = SANDBOX_SET_AS_BLOCKED;
#ifdef LOG_STATE_CHANGES #ifdef LOG_STATE_CHANGES
debuglog("Sandbox %lu | %s => Blocked\n", sandbox->request_arrival_timestamp, debuglog("Sandbox %lu | %s => Blocked\n", sandbox->id, sandbox_state_stringify(last_state));
sandbox_state_stringify(last_state));
#endif #endif
switch (last_state) { switch (last_state) {
@ -741,7 +712,7 @@ sandbox_set_as_blocked(struct sandbox *sandbox, sandbox_state_t last_state)
break; break;
} }
default: { default: {
panic("Sandbox %lu | Illegal transition from %s to Blocked\n", sandbox->request_arrival_timestamp, panic("Sandbox %lu | Illegal transition from %s to Blocked\n", sandbox->id,
sandbox_state_stringify(last_state)); sandbox_state_stringify(last_state));
} }
} }
@ -770,8 +741,7 @@ sandbox_set_as_returned(struct sandbox *sandbox, sandbox_state_t last_state)
sandbox->state = SANDBOX_SET_AS_RETURNED; sandbox->state = SANDBOX_SET_AS_RETURNED;
#ifdef LOG_STATE_CHANGES #ifdef LOG_STATE_CHANGES
debuglog("Sandbox %lu | %s => Returned\n", sandbox->request_arrival_timestamp, debuglog("Sandbox %lu | %s => Returned\n", sandbox->id, sandbox_state_stringify(last_state));
sandbox_state_stringify(last_state));
#endif #endif
switch (last_state) { switch (last_state) {
@ -788,7 +758,7 @@ sandbox_set_as_returned(struct sandbox *sandbox, sandbox_state_t last_state)
break; break;
} }
default: { default: {
panic("Sandbox %lu | Illegal transition from %s to Returned\n", sandbox->request_arrival_timestamp, panic("Sandbox %lu | Illegal transition from %s to Returned\n", sandbox->id,
sandbox_state_stringify(last_state)); sandbox_state_stringify(last_state));
} }
} }
@ -819,8 +789,7 @@ sandbox_set_as_error(struct sandbox *sandbox, sandbox_state_t last_state)
sandbox->state = SANDBOX_SET_AS_ERROR; sandbox->state = SANDBOX_SET_AS_ERROR;
#ifdef LOG_STATE_CHANGES #ifdef LOG_STATE_CHANGES
debuglog("Sandbox %lu | %s => Error\n", sandbox->request_arrival_timestamp, debuglog("Sandbox %lu | %s => Error\n", sandbox->id, sandbox_state_stringify(last_state));
sandbox_state_stringify(last_state));
#endif #endif
switch (last_state) { switch (last_state) {
@ -842,7 +811,7 @@ sandbox_set_as_error(struct sandbox *sandbox, sandbox_state_t last_state)
break; break;
} }
default: { default: {
panic("Sandbox %lu | Illegal transition from %s to Error\n", sandbox->request_arrival_timestamp, panic("Sandbox %lu | Illegal transition from %s to Error\n", sandbox->id,
sandbox_state_stringify(last_state)); sandbox_state_stringify(last_state));
} }
} }
@ -885,8 +854,7 @@ sandbox_set_as_complete(struct sandbox *sandbox, sandbox_state_t last_state)
sandbox->state = SANDBOX_SET_AS_COMPLETE; sandbox->state = SANDBOX_SET_AS_COMPLETE;
#ifdef LOG_STATE_CHANGES #ifdef LOG_STATE_CHANGES
debuglog("Sandbox %lu | %s => Complete\n", sandbox->request_arrival_timestamp, debuglog("Sandbox %lu | %s => Complete\n", sandbox->id, sandbox_state_stringify(last_state));
sandbox_state_stringify(last_state));
#endif #endif
switch (last_state) { switch (last_state) {
@ -900,7 +868,7 @@ sandbox_set_as_complete(struct sandbox *sandbox, sandbox_state_t last_state)
break; break;
} }
default: { default: {
panic("Sandbox %lu | Illegal transition from %s to Error\n", sandbox->request_arrival_timestamp, panic("Sandbox %lu | Illegal transition from %s to Error\n", sandbox->id,
sandbox_state_stringify(last_state)); sandbox_state_stringify(last_state));
} }
} }
@ -1025,7 +993,7 @@ sandbox_free(struct sandbox *sandbox)
errno = 0; errno = 0;
rc = munmap(stkaddr, stksz); rc = munmap(stkaddr, stksz);
if (rc == -1) { if (rc == -1) {
debuglog("Failed to unmap stack of Sandbox %lu\n", sandbox->request_arrival_timestamp); debuglog("Failed to unmap stack of Sandbox %lu\n", sandbox->id);
goto err_free_stack_failed; goto err_free_stack_failed;
}; };
@ -1039,7 +1007,7 @@ sandbox_free(struct sandbox *sandbox)
errno = 0; errno = 0;
rc = munmap(sandbox, sandbox_address_space_size); rc = munmap(sandbox, sandbox_address_space_size);
if (rc == -1) { if (rc == -1) {
debuglog("Failed to unmap Sandbox %lu\n", sandbox->request_arrival_timestamp); debuglog("Failed to unmap Sandbox %lu\n", sandbox->id);
goto err_free_sandbox_failed; goto err_free_sandbox_failed;
}; };
@ -1049,5 +1017,5 @@ err_free_sandbox_failed:
err_free_stack_failed: err_free_stack_failed:
err: err:
/* Errors freeing memory is a fatal error */ /* Errors freeing memory is a fatal error */
panic("Failed to free Sandbox %lu\n", sandbox->request_arrival_timestamp); panic("Failed to free Sandbox %lu\n", sandbox->id);
} }

9
runtime/src/worker_thread.c
Unescape View File

@ -111,8 +111,8 @@ worker_thread_switch_to_sandbox(struct sandbox *next_sandbox)
#ifdef LOG_CONTEXT_SWITCHES #ifdef LOG_CONTEXT_SWITCHES
debuglog("Base Context (%s) > Sandbox %lu (%s)\n", debuglog("Base Context (%s) > Sandbox %lu (%s)\n",
arch_context_variant_print(worker_thread_base_context.variant), arch_context_variant_print(worker_thread_base_context.variant), next_sandbox->id,
next_sandbox->request_arrival_timestamp, arch_context_variant_print(next_context->variant)); arch_context_variant_print(next_context->variant));
#endif #endif
arch_context_switch(NULL, next_context); arch_context_switch(NULL, next_context);
@ -127,8 +127,7 @@ worker_thread_switch_to_sandbox(struct sandbox *next_sandbox)
struct arch_context *current_context = &current_sandbox->ctxt; struct arch_context *current_context = &current_sandbox->ctxt;
#ifdef LOG_CONTEXT_SWITCHES #ifdef LOG_CONTEXT_SWITCHES
debuglog("Sandbox %lu > Sandbox %lu\n", current_sandbox->request_arrival_timestamp, debuglog("Sandbox %lu > Sandbox %lu\n", current_sandbox->id, next_sandbox->id);
next_sandbox->request_arrival_timestamp);
#endif #endif
/* Switch to the associated context. */ /* Switch to the associated context. */
@ -157,7 +156,7 @@ worker_thread_switch_to_base_context()
current_sandbox_set(NULL); current_sandbox_set(NULL);
#ifdef LOG_CONTEXT_SWITCHES #ifdef LOG_CONTEXT_SWITCHES
debuglog("Sandbox %lu (%s) > Base Context (%s)\n", current_sandbox->request_arrival_timestamp, debuglog("Sandbox %lu (%s) > Base Context (%s)\n", current_sandbox->id,
arch_context_variant_print(current_sandbox->ctxt.variant), arch_context_variant_print(current_sandbox->ctxt.variant),
arch_context_variant_print(worker_thread_base_context.variant)); arch_context_variant_print(worker_thread_base_context.variant));
#endif #endif

Write Preview
Loading…
Cancel
Save