1 files changed, 434 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;
+    }
+}