diff options
Diffstat (limited to 'fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/app-framework/sensor/native')
6 files changed, 707 insertions, 0 deletions
diff --git a/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/app-framework/sensor/native/runtime_sensor.c b/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/app-framework/sensor/native/runtime_sensor.c new file mode 100644 index 000000000..ad7a3fbf5 --- /dev/null +++ b/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/app-framework/sensor/native/runtime_sensor.c @@ -0,0 +1,434 @@ +/* + * Copyright (C) 2019 Intel Corporation. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "runtime_sensor.h" +#include "app_manager_export.h" +#include "module_wasm_app.h" +#include "bh_platform.h" + +static sys_sensor_t *g_sys_sensors = NULL; +static uint32 g_sensor_id_max = 0; + +static sensor_client_t * +find_sensor_client(sys_sensor_t *sensor, unsigned int client_id, + bool remove_if_found); + +void (*rechedule_sensor_callback)() = NULL; + +/* + * API for the applications to call - don't call it from the runtime + * + */ + +static void +sensor_event_cleaner(sensor_event_data_t *sensor_event) +{ + if (sensor_event->data != NULL) { + if (sensor_event->data_fmt == FMT_ATTR_CONTAINER) + attr_container_destroy(sensor_event->data); + else + wasm_runtime_free(sensor_event->data); + } + + wasm_runtime_free(sensor_event); +} + +static void +wasm_sensor_callback(void *client, uint32 sensor_id, void *user_data) +{ + attr_container_t *sensor_data = (attr_container_t *)user_data; + attr_container_t *sensor_data_clone; + int sensor_data_len; + sensor_event_data_t *sensor_event; + bh_message_t msg; + sensor_client_t *c = (sensor_client_t *)client; + + module_data *module = module_data_list_lookup_id(c->client_id); + if (module == NULL) + return; + + if (sensor_data == NULL) + return; + + sensor_data_len = attr_container_get_serialize_length(sensor_data); + sensor_data_clone = + (attr_container_t *)wasm_runtime_malloc(sensor_data_len); + if (sensor_data_clone == NULL) + return; + + /* multiple sensor clients may use/free the sensor data, so make a copy */ + bh_memcpy_s(sensor_data_clone, sensor_data_len, sensor_data, + sensor_data_len); + + sensor_event = + (sensor_event_data_t *)wasm_runtime_malloc(sizeof(*sensor_event)); + if (sensor_event == NULL) { + wasm_runtime_free(sensor_data_clone); + return; + } + + memset(sensor_event, 0, sizeof(*sensor_event)); + sensor_event->sensor_id = sensor_id; + sensor_event->data = sensor_data_clone; + sensor_event->data_fmt = FMT_ATTR_CONTAINER; + + msg = bh_new_msg(SENSOR_EVENT_WASM, sensor_event, sizeof(*sensor_event), + sensor_event_cleaner); + if (!msg) { + sensor_event_cleaner(sensor_event); + return; + } + + bh_post_msg2(module->queue, msg); +} + +bool +wasm_sensor_config(wasm_exec_env_t exec_env, uint32 sensor, uint32 interval, + int bit_cfg, uint32 delay) +{ + wasm_module_inst_t module_inst = get_module_inst(exec_env); + attr_container_t *attr_cont; + sensor_client_t *c; + sensor_obj_t s = find_sys_sensor_id(sensor); + if (s == NULL) + return false; + + unsigned int mod_id = + app_manager_get_module_id(Module_WASM_App, module_inst); + bh_assert(mod_id != ID_NONE); + + os_mutex_lock(&s->lock); + + c = find_sensor_client(s, mod_id, false); + if (c == NULL) { + os_mutex_unlock(&s->lock); + return false; + } + + c->interval = interval; + c->bit_cfg = bit_cfg; + c->delay = delay; + + os_mutex_unlock(&s->lock); + + if (s->config != NULL) { + attr_cont = attr_container_create("config sensor"); + attr_container_set_int(&attr_cont, "interval", (int)interval); + attr_container_set_int(&attr_cont, "bit_cfg", bit_cfg); + attr_container_set_int(&attr_cont, "delay", (int)delay); + s->config(s, attr_cont); + attr_container_destroy(attr_cont); + } + + refresh_read_interval(s); + + reschedule_sensor_read(); + + return true; +} + +uint32 +wasm_sensor_open(wasm_exec_env_t exec_env, char *name, int instance) +{ + wasm_module_inst_t module_inst = get_module_inst(exec_env); + + if (name != NULL) { + sensor_client_t *c; + sys_sensor_t *s = find_sys_sensor(name, instance); + if (s == NULL) + return (uint32)-1; + + unsigned int mod_id = + app_manager_get_module_id(Module_WASM_App, module_inst); + bh_assert(mod_id != ID_NONE); + + os_mutex_lock(&s->lock); + + c = find_sensor_client(s, mod_id, false); + if (c) { + // the app already opened this sensor + os_mutex_unlock(&s->lock); + return (uint32)-1; + } + + sensor_client_t *client = + (sensor_client_t *)wasm_runtime_malloc(sizeof(sensor_client_t)); + if (client == NULL) { + os_mutex_unlock(&s->lock); + return (uint32)-1; + } + + memset(client, 0, sizeof(sensor_client_t)); + client->client_id = mod_id; + client->client_callback = (void *)wasm_sensor_callback; + client->interval = s->default_interval; + client->next = s->clients; + s->clients = client; + + os_mutex_unlock(&s->lock); + + refresh_read_interval(s); + + reschedule_sensor_read(); + + return s->sensor_id; + } + + return (uint32)-1; +} + +bool +wasm_sensor_config_with_attr_container(wasm_exec_env_t exec_env, uint32 sensor, + char *buffer, int len) +{ + if (buffer != NULL) { + attr_container_t *cfg = (attr_container_t *)buffer; + sensor_obj_t s = find_sys_sensor_id(sensor); + if (s == NULL) + return false; + + if (s->config == NULL) + return false; + + return s->config(s, cfg); + } + + return false; +} + +bool +wasm_sensor_close(wasm_exec_env_t exec_env, uint32 sensor) +{ + wasm_module_inst_t module_inst = get_module_inst(exec_env); + unsigned int mod_id = + app_manager_get_module_id(Module_WASM_App, module_inst); + unsigned int client_id = mod_id; + sensor_obj_t s = find_sys_sensor_id(sensor); + sensor_client_t *c; + + bh_assert(mod_id != ID_NONE); + + if (s == NULL) + return false; + + os_mutex_lock(&s->lock); + if ((c = find_sensor_client(s, client_id, true)) != NULL) + wasm_runtime_free(c); + os_mutex_unlock(&s->lock); + + refresh_read_interval(s); + + reschedule_sensor_read(); + + return true; +} + +/* + * + * sensor framework API - don't expose to the applications + * + */ +void +set_sensor_reshceduler(void (*callback)()) +{ + rechedule_sensor_callback = callback; +} + +// used for other threads to wakeup the sensor read thread +void +reschedule_sensor_read() +{ + if (rechedule_sensor_callback) + rechedule_sensor_callback(); +} + +void +refresh_read_interval(sensor_obj_t sensor) +{ + sensor_client_t *c; + uint32 interval = sensor->default_interval; + os_mutex_lock(&sensor->lock); + + c = sensor->clients; + if (c) + interval = c->interval; + + while (c) { + if (c->interval < interval) + interval = c->interval; + c = c->next; + } + + os_mutex_unlock(&sensor->lock); + + sensor->read_interval = interval; +} + +sensor_obj_t +add_sys_sensor(char *name, char *description, int instance, + uint32 default_interval, void *read_func, void *config_func) +{ + sys_sensor_t *s = (sys_sensor_t *)wasm_runtime_malloc(sizeof(sys_sensor_t)); + if (s == NULL) + return NULL; + + memset(s, 0, sizeof(*s)); + s->name = bh_strdup(name); + s->sensor_instance = instance; + s->default_interval = default_interval; + + if (!s->name) { + wasm_runtime_free(s); + return NULL; + } + + if (description) { + s->description = bh_strdup(description); + if (!s->description) { + wasm_runtime_free(s->name); + wasm_runtime_free(s); + return NULL; + } + } + + g_sensor_id_max++; + if (g_sensor_id_max == UINT32_MAX) + g_sensor_id_max++; + s->sensor_id = g_sensor_id_max; + + s->read = read_func; + s->config = config_func; + + if (g_sys_sensors == NULL) { + g_sys_sensors = s; + } + else { + s->next = g_sys_sensors; + g_sys_sensors = s; + } + + if (os_mutex_init(&s->lock) != 0) { + if (s->description) { + wasm_runtime_free(s->description); + } + wasm_runtime_free(s->name); + wasm_runtime_free(s); + } + + return s; +} + +sensor_obj_t +find_sys_sensor(const char *name, int instance) +{ + sys_sensor_t *s = g_sys_sensors; + while (s) { + if (strcmp(s->name, name) == 0 && s->sensor_instance == instance) + return s; + + s = s->next; + } + return NULL; +} + +sensor_obj_t +find_sys_sensor_id(uint32 sensor_id) +{ + sys_sensor_t *s = g_sys_sensors; + while (s) { + if (s->sensor_id == sensor_id) + return s; + + s = s->next; + } + return NULL; +} + +sensor_client_t * +find_sensor_client(sys_sensor_t *sensor, unsigned int client_id, + bool remove_if_found) +{ + sensor_client_t *prev = NULL, *c = sensor->clients; + + while (c) { + sensor_client_t *next = c->next; + if (c->client_id == client_id) { + if (remove_if_found) { + if (prev) + prev->next = next; + else + sensor->clients = next; + } + return c; + } + else { + prev = c; + c = c->next; + } + } + + return NULL; +} + +// return the milliseconds to next check +uint32 +check_sensor_timers() +{ + uint32 ms_to_next_check = UINT32_MAX; + uint32 now = (uint32)bh_get_tick_ms(); + + sys_sensor_t *s = g_sys_sensors; + while (s) { + uint32 last_read = s->last_read; + uint32 elpased_ms = bh_get_elpased_ms(&last_read); + + if (s->read_interval <= 0 || s->clients == NULL) { + s = s->next; + continue; + } + + if (elpased_ms >= s->read_interval) { + attr_container_t *data = s->read(s); + if (data) { + sensor_client_t *client = s->clients; + while (client) { + client->client_callback(client, s->sensor_id, data); + client = client->next; + } + attr_container_destroy(data); + } + + s->last_read = now; + + if (s->read_interval < ms_to_next_check) + ms_to_next_check = s->read_interval; + } + else { + uint32 remaining = s->read_interval - elpased_ms; + if (remaining < ms_to_next_check) + ms_to_next_check = remaining; + } + + s = s->next; + } + + return ms_to_next_check; +} + +void +sensor_cleanup_callback(uint32 module_id) +{ + sys_sensor_t *s = g_sys_sensors; + + while (s) { + sensor_client_t *c; + os_mutex_lock(&s->lock); + if ((c = find_sensor_client(s, module_id, true)) != NULL) { + wasm_runtime_free(c); + } + os_mutex_unlock(&s->lock); + s = s->next; + } +} diff --git a/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/app-framework/sensor/native/runtime_sensor.h b/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/app-framework/sensor/native/runtime_sensor.h new file mode 100644 index 000000000..d7c893111 --- /dev/null +++ b/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/app-framework/sensor/native/runtime_sensor.h @@ -0,0 +1,69 @@ +/* + * Copyright (C) 2019 Intel Corporation. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#ifndef LIB_EXTENSION_RUNTIME_SENSOR_H_ +#define LIB_EXTENSION_RUNTIME_SENSOR_H_ + +#include "bh_platform.h" +#include "bi-inc/attr_container.h" +#include "wasm_export.h" +#include "sensor_native_api.h" + +struct _sys_sensor; +typedef struct _sys_sensor *sensor_obj_t; + +typedef struct _sensor_client { + struct _sensor_client *next; + unsigned int client_id; // the app id + uint32 interval; + int bit_cfg; + uint32 delay; + void (*client_callback)(void *client, uint32, attr_container_t *); +} sensor_client_t; + +typedef struct _sys_sensor { + struct _sys_sensor *next; + char *name; + int sensor_instance; + char *description; + uint32 sensor_id; + sensor_client_t *clients; + /* app, sensor mgr and app mgr may access the clients at the same time, + so need a lock to protect the clients */ + korp_mutex lock; + uint32 last_read; + uint32 read_interval; + uint32 default_interval; + + /* TODO: may support other type return value, such as 'cbor' */ + attr_container_t *(*read)(void *); + bool (*config)(void *, void *); + +} sys_sensor_t; + +sensor_obj_t +add_sys_sensor(char *name, char *description, int instance, + uint32 default_interval, void *read_func, void *config_func); +sensor_obj_t +find_sys_sensor(const char *name, int instance); +sensor_obj_t +find_sys_sensor_id(uint32 sensor_id); +void +refresh_read_interval(sensor_obj_t sensor); +void +sensor_cleanup_callback(uint32 module_id); +uint32 +check_sensor_timers(); +void +reschedule_sensor_read(); + +bool +init_sensor_framework(); +void +start_sensor_framework(); +void +exit_sensor_framework(); + +#endif /* LIB_EXTENSION_RUNTIME_SENSOR_H_ */ diff --git a/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/app-framework/sensor/native/runtime_sensor.inl b/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/app-framework/sensor/native/runtime_sensor.inl new file mode 100644 index 000000000..a7b9f4778 --- /dev/null +++ b/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/app-framework/sensor/native/runtime_sensor.inl @@ -0,0 +1,9 @@ +/* + * Copyright (C) 2019 Intel Corporation. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +EXPORT_WASM_API_WITH_SIG(wasm_sensor_open, "($i)i"), +EXPORT_WASM_API_WITH_SIG(wasm_sensor_config, "(iiii)i"), +EXPORT_WASM_API_WITH_SIG(wasm_sensor_config_with_attr_container, "(i*~)i"), +EXPORT_WASM_API_WITH_SIG(wasm_sensor_close, "(i)i"), diff --git a/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/app-framework/sensor/native/sensor_mgr_ref.c b/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/app-framework/sensor/native/sensor_mgr_ref.c new file mode 100644 index 000000000..474ec738d --- /dev/null +++ b/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/app-framework/sensor/native/sensor_mgr_ref.c @@ -0,0 +1,148 @@ +/* + * Copyright (C) 2019 Intel Corporation. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "bh_platform.h" +#include "runtime_sensor.h" +#include "bi-inc/attr_container.h" +#include "module_wasm_app.h" +#include "wasm_export.h" + +/* + * + * One reference implementation for sensor manager + * + * + */ +static korp_cond cond; +static korp_mutex mutex; +static bool sensor_check_thread_run = true; + +void +app_mgr_sensor_event_callback(module_data *m_data, bh_message_t msg) +{ + uint32 argv[3]; + wasm_function_inst_t func_onSensorEvent; + + bh_assert(SENSOR_EVENT_WASM == bh_message_type(msg)); + wasm_data *wasm_app_data = (wasm_data *)m_data->internal_data; + wasm_module_inst_t inst = wasm_app_data->wasm_module_inst; + + sensor_event_data_t *payload = + (sensor_event_data_t *)bh_message_payload(msg); + if (payload == NULL) + return; + + func_onSensorEvent = + wasm_runtime_lookup_function(inst, "_on_sensor_event", "(i32i32i32)"); + if (!func_onSensorEvent) + func_onSensorEvent = wasm_runtime_lookup_function( + inst, "on_sensor_event", "(i32i32i32)"); + if (!func_onSensorEvent) { + printf("Cannot find function on_sensor_event\n"); + } + else { + int32 sensor_data_offset; + uint32 sensor_data_len; + + if (payload->data_fmt == FMT_ATTR_CONTAINER) { + sensor_data_len = + attr_container_get_serialize_length(payload->data); + } + else { + printf("Unsupported sensor data format: %d\n", payload->data_fmt); + return; + } + + sensor_data_offset = + wasm_runtime_module_dup_data(inst, payload->data, sensor_data_len); + if (sensor_data_offset == 0) { + const char *exception = wasm_runtime_get_exception(inst); + if (exception) { + printf("Got exception running wasm code: %s\n", exception); + wasm_runtime_clear_exception(inst); + } + return; + } + + argv[0] = payload->sensor_id; + argv[1] = (uint32)sensor_data_offset; + argv[2] = sensor_data_len; + + if (!wasm_runtime_call_wasm(wasm_app_data->exec_env, func_onSensorEvent, + 3, argv)) { + const char *exception = wasm_runtime_get_exception(inst); + bh_assert(exception); + printf(":Got exception running wasm code: %s\n", exception); + wasm_runtime_clear_exception(inst); + wasm_runtime_module_free(inst, sensor_data_offset); + return; + } + + wasm_runtime_module_free(inst, sensor_data_offset); + } +} + +static void +thread_sensor_check(void *arg) +{ + while (sensor_check_thread_run) { + uint32 ms_to_expiry = check_sensor_timers(); + if (ms_to_expiry == UINT32_MAX) + ms_to_expiry = 5000; + os_mutex_lock(&mutex); + os_cond_reltimedwait(&cond, &mutex, ms_to_expiry * 1000); + os_mutex_unlock(&mutex); + } +} + +static void +cb_wakeup_thread() +{ + os_cond_signal(&cond); +} + +void +set_sensor_reshceduler(void (*callback)()); + +bool +init_sensor_framework() +{ + /* init the mutext and conditions */ + if (os_cond_init(&cond) != 0) { + return false; + } + + if (os_mutex_init(&mutex) != 0) { + os_cond_destroy(&cond); + return false; + } + + set_sensor_reshceduler(cb_wakeup_thread); + + wasm_register_msg_callback(SENSOR_EVENT_WASM, + app_mgr_sensor_event_callback); + + wasm_register_cleanup_callback(sensor_cleanup_callback); + + return true; +} + +void +start_sensor_framework() +{ + korp_tid tid; + + os_thread_create(&tid, (void *)thread_sensor_check, NULL, + BH_APPLET_PRESERVED_STACK_SIZE); +} + +void +exit_sensor_framework() +{ + sensor_check_thread_run = false; + reschedule_sensor_read(); + + // todo: wait the sensor thread termination +} diff --git a/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/app-framework/sensor/native/sensor_native_api.h b/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/app-framework/sensor/native/sensor_native_api.h new file mode 100644 index 000000000..0bbb315ca --- /dev/null +++ b/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/app-framework/sensor/native/sensor_native_api.h @@ -0,0 +1,33 @@ +/* + * Copyright (C) 2019 Intel Corporation. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#ifndef _SENSOR_NATIVE_API_H_ +#define _SENSOR_NATIVE_API_H_ + +#include "bh_platform.h" +#include "wasm_export.h" + +#ifdef __cplusplus +extern "C" { +#endif + +bool +wasm_sensor_config(wasm_exec_env_t exec_env, uint32 sensor, uint32 interval, + int bit_cfg, uint32 delay); +uint32 +wasm_sensor_open(wasm_exec_env_t exec_env, char *name, int instance); + +bool +wasm_sensor_config_with_attr_container(wasm_exec_env_t exec_env, uint32 sensor, + char *buffer, int len); + +bool +wasm_sensor_close(wasm_exec_env_t exec_env, uint32 sensor); + +#ifdef __cplusplus +} +#endif + +#endif /* end of _SENSOR_NATIVE_API_H_ */ diff --git a/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/app-framework/sensor/native/wasm_lib.cmake b/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/app-framework/sensor/native/wasm_lib.cmake new file mode 100644 index 000000000..65a83ba59 --- /dev/null +++ b/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/app-framework/sensor/native/wasm_lib.cmake @@ -0,0 +1,14 @@ +# Copyright (C) 2019 Intel Corporation. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +set (WASM_LIB_SENSOR_DIR ${CMAKE_CURRENT_LIST_DIR}) + +add_definitions (-DAPP_FRAMEWORK_SENSOR) + +include_directories(${WASM_LIB_SENSOR_DIR}) + + +file (GLOB_RECURSE source_all ${WASM_LIB_SENSOR_DIR}/*.c) + +set (WASM_APP_LIB_CURRENT_SOURCE ${source_all}) + |