WebAssembly Micro Runtime first version

core/iwasm/lib/native/extension/sensor/runtime_sensor.c

@@ -0,0 +1,425 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "runtime_sensor.h"
+#include "app-manager-export.h"
+#include "module_wasm_app.h"
+#include "bh_thread.h"
+#include "bh_time.h"
+
+static sys_sensor_t * g_sys_sensors = NULL;
+static int 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
+            bh_free(sensor_event->data);
+    }
+
+    bh_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 *)bh_malloc(sensor_data_len);
+    if (sensor_data_clone == NULL)
+        return;
+
+    /* multiple sensor clients may use/free the sensor data, so make a copy */
+    memcpy(sensor_data_clone, sensor_data, sensor_data_len);
+
+    sensor_event = (sensor_event_data_t *)bh_malloc(sizeof(*sensor_event));
+    if (sensor_event == NULL) {
+        bh_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(uint32 sensor, int interval, int bit_cfg, int delay)
+{
+    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);
+
+    vm_mutex_lock(&s->lock);
+
+    c = find_sensor_client(s, mod_id, false);
+    if (c == NULL) {
+        vm_mutex_unlock(&s->lock);
+        return false;
+    }
+
+    c->interval = interval;
+    c->bit_cfg = bit_cfg;
+    c->delay = delay;
+
+    vm_mutex_unlock(&s->lock);
+
+    if (s->config != NULL) {
+        attr_cont = attr_container_create("config sensor");
+        attr_container_set_int(&attr_cont, "interval", interval);
+        attr_container_set_int(&attr_cont, "bit_cfg", bit_cfg);
+        attr_container_set_int(&attr_cont, "delay", delay);
+        s->config(s, attr_cont);
+        attr_container_destroy(attr_cont);
+    }
+
+    refresh_read_interval(s);
+
+    reschedule_sensor_read();
+
+    return true;
+}
+
+uint32 wasm_sensor_open(int32 name_offset, int instance)
+{
+    wasm_module_inst_t module_inst = get_module_inst();
+    char *name = NULL;
+
+    if (!validate_app_addr(name_offset, 1))
+        return -1;
+
+    name = addr_app_to_native(name_offset);
+
+    if (name != NULL) {
+        sensor_client_t *c;
+        sys_sensor_t *s = find_sys_sensor(name, instance);
+        if (s == NULL)
+            return -1;
+
+        unsigned int mod_id = app_manager_get_module_id(Module_WASM_App);
+
+        vm_mutex_lock(&s->lock);
+
+        c = find_sensor_client(s, mod_id, false);
+        if (c) {
+            // the app already opened this sensor
+            vm_mutex_unlock(&s->lock);
+            return -1;
+        }
+
+        sensor_client_t * client = (sensor_client_t*) bh_malloc(
+                sizeof(sensor_client_t));
+        if (client == NULL) {
+            vm_mutex_unlock(&s->lock);
+            return -1;
+        }
+
+        memset(client, 0, sizeof(sensor_client_t));
+        client->client_id = mod_id;
+        client->client_callback = wasm_sensor_callback;
+        client->interval = s->default_interval;
+        client->next = s->clients;
+        s->clients = client;
+
+        vm_mutex_unlock(&s->lock);
+
+        refresh_read_interval(s);
+
+        reschedule_sensor_read();
+
+        return s->sensor_id;
+    }
+
+    return -1;
+}
+
+bool wasm_sensor_config_with_attr_container(uint32 sensor, int32 buffer_offset,
+        int len)
+{
+    wasm_module_inst_t module_inst = get_module_inst();
+    char *buffer = NULL;
+
+    if (!validate_app_addr(buffer_offset, len))
+        return false;
+
+    buffer = addr_app_to_native(buffer_offset);
+
+    if (buffer != NULL) {
+        attr_container_t * cfg;
+
+        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(uint32 sensor)
+{
+    unsigned int mod_id = app_manager_get_module_id(Module_WASM_App);
+    unsigned int client_id = mod_id;
+    sensor_obj_t s = find_sys_sensor_id(sensor);
+    sensor_client_t *c;
+
+    if (s == NULL)
+        return false;
+
+    vm_mutex_lock(&s->lock);
+    if ((c = find_sensor_client(s, client_id, true)) != NULL)
+        bh_free(c);
+    vm_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;
+    vm_mutex_lock(&sensor->lock);
+
+    c = sensor->clients;
+    if (c)
+        interval = c->interval;
+
+    while (c) {
+        if (c->interval < interval)
+            interval = c->interval;
+        c = c->next;
+    }
+
+    vm_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 *) bh_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) {
+        bh_free(s);
+        return NULL;
+    }
+
+    if (description) {
+        s->description = bh_strdup(description);
+        if (!s->description) {
+            bh_free(s->name);
+            bh_free(s);
+            return NULL;
+        }
+    }
+
+    g_sensor_id_max++;
+    if (g_sensor_id_max == -1)
+        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;
+    }
+
+    vm_mutex_init(&s->lock);
+
+    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 {
+            c = c->next;
+        }
+    }
+
+    return NULL;
+}
+
+// return the milliseconds to next check
+int check_sensor_timers()
+{
+    int ms_to_next_check = -1;
+    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 (ms_to_next_check == -1 || (ms_to_next_check < s->read_interval))
+                ms_to_next_check = s->read_interval;
+        } else {
+            int remaining = s->read_interval - elpased_ms;
+            if (ms_to_next_check == -1 || (ms_to_next_check < remaining))
+                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;
+        vm_mutex_lock(&s->lock);
+        if ((c = find_sensor_client(s, module_id, true)) != NULL) {
+            bh_free(c);
+        }
+        vm_mutex_unlock(&s->lock);
+        s = s->next;
+    }
+}

core/iwasm/lib/native/extension/sensor/runtime_sensor.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef LIB_EXTENSION_RUNTIME_SENSOR_H_
+#define LIB_EXTENSION_RUNTIME_SENSOR_H_
+
+#include "bh_platform.h"
+#include "attr-container.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
+    int interval;
+    int bit_cfg;
+    int 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;
+
+    attr_container_t * (*read)(void *); /* TODO: may support other type return value, such as 'cbor' */
+    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);
+int check_sensor_timers();
+void reschedule_sensor_read();
+
+uint32
+wasm_sensor_open(int32 name_offset, int instance);
+
+bool
+wasm_sensor_config(uint32 sensor, int interval, int bit_cfg, int delay);
+
+bool
+wasm_sensor_config_with_attr_container(uint32 sensor, int32 buffer_offset,
+        int len);
+
+bool
+wasm_sensor_close(uint32 sensor);
+
+#endif /* LIB_EXTENSION_RUNTIME_SENSOR_H_ */

core/iwasm/lib/native/extension/sensor/runtime_sensor.inl

@@ -0,0 +1,20 @@
+/*
+* Copyright (C) 2019 Intel Corporation.  All rights reserved.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+EXPORT_WASM_API(wasm_sensor_open),
+EXPORT_WASM_API(wasm_sensor_config),
+EXPORT_WASM_API(wasm_sensor_config_with_attr_container),
+EXPORT_WASM_API(wasm_sensor_close),

core/iwasm/lib/native/extension/sensor/sensor_mgr_ref.c

@@ -0,0 +1,145 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "bh_common.h"
+#include "bh_queue.h"
+#include "bh_thread.h"
+#include "runtime_sensor.h"
+#include "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;
+
+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) {
+        printf("Cannot find function onRequest\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) {
+            printf("Got exception running wasm code: %s\n",
+                    wasm_runtime_get_exception(inst));
+            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(inst, NULL, func_onSensorEvent, 3, argv)) {
+            printf(":Got exception running wasm code: %s\n",
+                    wasm_runtime_get_exception(inst));
+            wasm_runtime_clear_exception(inst);
+            wasm_runtime_module_free(inst, sensor_data_offset);
+            return;
+        }
+
+        wasm_runtime_module_free(inst, sensor_data_offset);
+    }
+}
+
+static attr_container_t * read_test_sensor(void * sensor)
+{
+    //luc: for test
+    attr_container_t *attr_obj = attr_container_create("read test sensor data");
+    if (attr_obj) {
+        attr_container_set_string(&attr_obj, "name", "read test sensor");
+        return attr_obj;
+    }
+    return NULL;
+}
+
+static bool config_test_sensor(void * s, void * config)
+{
+
+    return false;
+}
+
+static void * thread_sensor_check(void * arg)
+{
+    while (1) {
+        int ms_to_expiry = check_sensor_timers();
+        if (ms_to_expiry == -1)
+            ms_to_expiry = 5000;
+        vm_mutex_lock(&mutex);
+        vm_cond_reltimedwait(&cond, &mutex, ms_to_expiry);
+        vm_mutex_unlock(&mutex);
+    }
+}
+
+static void cb_wakeup_thread()
+{
+    vm_cond_signal(&cond);
+}
+
+void init_sensor_framework()
+{
+    // init the mutext and conditions
+    korp_thread tid;
+    vm_cond_init(&cond);
+    vm_mutex_init(&mutex);
+
+    // add the sys sensor objects
+    add_sys_sensor("sensor_test", "This is a sensor for test", 0, 1000,
+            read_test_sensor, config_test_sensor);
+
+    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);
+
+    vm_thread_create(&tid, thread_sensor_check, NULL,
+    BH_APPLET_PRESERVED_STACK_SIZE);
+
+}
+

core/iwasm/lib/native/extension/sensor/wasm_lib_sensor.cmake

@@ -0,0 +1,23 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set (WASM_LIB_SENSOR_DIR ${CMAKE_CURRENT_LIST_DIR})
+
+include_directories(${WASM_LIB_SENSOR_DIR})
+
+
+file (GLOB_RECURSE source_all ${WASM_LIB_SENSOR_DIR}/*.c)
+
+set (WASM_LIB_SENSOR_SOURCE ${source_all})
+

core/iwasm/lib/native/extension/template/lib-export-template.c

@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "lib-export.h"
+
+/* TODO: use macro EXPORT_WASM_API() or EXPORT_WASM_API2() to add functions to register. */
+
+NativeSymbol extended_native_symbol_defs[] = {
+
+/*EXPORT_WASM_API(publish_event)*/
+
+};