sleela_os_support.c
lib/os-level-support/src/sleela_os_support.c · 141 line(s) · c
#include "sleela_os_support.h"
#include <stdlib.h>
#include <string.h>
typedef struct hook_slot {
slosh_token token;
slosh_event_kind kind;
slosh_event_fn callback;
void *user_data;
int active;
} hook_slot;
typedef struct task_slot {
slosh_task_fn callback;
void *user_data;
} task_slot;
struct slosh_runtime {
hook_slot hooks[SLOSH_MAX_HOOKS];
task_slot tasks[SLOSH_MAX_TASKS];
size_t task_head;
size_t task_count;
uint64_t next_token;
uint64_t event_sequence;
unsigned dispatch_depth;
int task_running;
};
slosh_status slosh_runtime_create(slosh_runtime **out) {
slosh_runtime *r;
if (!out) return SLOSH_INVALID_ARGUMENT;
*out = NULL;
r = (slosh_runtime *)calloc(1, sizeof(*r));
if (!r) return SLOSH_OUT_OF_MEMORY;
r->next_token = 1;
*out = r;
return SLOSH_OK;
}
void slosh_runtime_destroy(slosh_runtime *r) {
if (!r) return;
memset(r, 0, sizeof(*r));
free(r);
}
slosh_status slosh_subscribe(slosh_runtime *r, slosh_event_kind kind,
slosh_event_fn callback, void *user, slosh_token *out_token) {
size_t i;
if (!r || !callback || !out_token || kind < SLOSH_EVENT_USER || kind > SLOSH_EVENT_TASK_FINISHED)
return SLOSH_INVALID_ARGUMENT;
if (r->dispatch_depth) return SLOSH_BUSY;
for (i = 0; i < SLOSH_MAX_HOOKS; ++i) {
if (!r->hooks[i].active) {
slosh_token t = r->next_token++;
if (!t) t = r->next_token++;
r->hooks[i].token = t;
r->hooks[i].kind = kind;
r->hooks[i].callback = callback;
r->hooks[i].user_data = user;
r->hooks[i].active = 1;
*out_token = t;
return SLOSH_OK;
}
}
return SLOSH_CAPACITY;
}
slosh_status slosh_unsubscribe(slosh_runtime *r, slosh_token token) {
size_t i;
if (!r || !token) return SLOSH_INVALID_ARGUMENT;
if (r->dispatch_depth) return SLOSH_BUSY;
for (i = 0; i < SLOSH_MAX_HOOKS; ++i) {
if (r->hooks[i].active && r->hooks[i].token == token) {
memset(&r->hooks[i], 0, sizeof(r->hooks[i]));
return SLOSH_OK;
}
}
return SLOSH_NOT_FOUND;
}
static slosh_status emit_internal(slosh_runtime *r, slosh_event_kind kind,
const void *payload, size_t payload_size) {
slosh_event e;
size_t i;
slosh_status result = SLOSH_OK;
e.kind = kind;
e.sequence = ++r->event_sequence;
e.payload = payload;
e.payload_size = payload_size;
++r->dispatch_depth;
for (i = 0; i < SLOSH_MAX_HOOKS; ++i) {
hook_slot *h = &r->hooks[i];
if (h->active && h->kind == kind) {
result = h->callback(r, &e, h->user_data);
if (result != SLOSH_OK) break;
}
}
--r->dispatch_depth;
return result;
}
slosh_status slosh_emit(slosh_runtime *r, slosh_event_kind kind,
const void *payload, size_t payload_size) {
if (!r || kind < SLOSH_EVENT_USER || kind > SLOSH_EVENT_TASK_FINISHED ||
(!payload && payload_size)) return SLOSH_INVALID_ARGUMENT;
return emit_internal(r, kind, payload, payload_size);
}
slosh_status slosh_post(slosh_runtime *r, slosh_task_fn callback, void *user) {
size_t tail;
if (!r || !callback) return SLOSH_INVALID_ARGUMENT;
if (r->task_count == SLOSH_MAX_TASKS) return SLOSH_CAPACITY;
tail = (r->task_head + r->task_count) % SLOSH_MAX_TASKS;
r->tasks[tail].callback = callback;
r->tasks[tail].user_data = user;
++r->task_count;
return emit_internal(r, SLOSH_EVENT_TASK_QUEUED, NULL, 0);
}
slosh_status slosh_run_one(slosh_runtime *r, int *out_ran) {
task_slot task;
slosh_status result;
if (!r || !out_ran) return SLOSH_INVALID_ARGUMENT;
*out_ran = 0;
if (r->task_running || r->dispatch_depth) return SLOSH_BUSY;
if (!r->task_count) return SLOSH_OK;
task = r->tasks[r->task_head];
memset(&r->tasks[r->task_head], 0, sizeof(r->tasks[0]));
r->task_head = (r->task_head + 1) % SLOSH_MAX_TASKS;
--r->task_count;
r->task_running = 1;
*out_ran = 1;
result = task.callback(r, task.user_data);
r->task_running = 0;
if (result != SLOSH_OK) return result;
return emit_internal(r, SLOSH_EVENT_TASK_FINISHED, NULL, 0);
}
size_t slosh_pending(const slosh_runtime *r) { return r ? r->task_count : 0; }