gnh1201/wasm-micro-runtime
1
0
Fork 0
mirror of https://github.com/bytecodealliance/wasm-micro-runtime.git synced 2025-02-06 23:15:16 +00:00
Code Issues Actions 9 Packages Projects Releases Wiki Activity
4ce675aacd
wasm-micro-runtime/core/app-mgr/app-manager/module_wasm_app.c

1744 lines
58 KiB
C
Raw Blame History

/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#include "module_wasm_app.h"
#include "native_interface.h" /* for request_t type */
#include "app_manager_host.h"
#include "bh_platform.h"
#include "bi-inc/attr_container.h"
#include "coap_ext.h"
#include "event.h"
#include "watchdog.h"
#include "runtime_lib.h"
#if WASM_ENABLE_INTERP != 0
#include "wasm.h"
#endif
#if WASM_ENABLE_AOT != 0
#include "aot_export.h"
#endif
/* clang-format off */
#if WASM_ENABLE_INTERP != 0 || WASM_ENABLE_JIT != 0
/* Wasm bytecode file 4 version bytes */
static uint8 wasm_bytecode_version[4] = {
(uint8)0x01,
(uint8)0x00,
(uint8)0x00,
(uint8)0x00
};
#endif
#if WASM_ENABLE_AOT != 0
/* Wasm aot file 4 version bytes */
static uint8 wasm_aot_version[4] = {
(uint8)0x02,
(uint8)0x00,
(uint8)0x00,
(uint8)0x00
};
#endif
/* clang-format on */
static union {
int a;
char b;
} __ue = { .a = 1 };
#define is_little_endian() (__ue.b == 1)
/* Wasm App Install Request Receiving Phase */
typedef enum wasm_app_install_req_recv_phase_t {
Phase_Req_Ver,
Phase_Req_Action,
Phase_Req_Fmt,
Phase_Req_Mid,
Phase_Req_Sender,
Phase_Req_Url_Len,
Phase_Req_Payload_Len, /* payload is wasm app binary */
Phase_Req_Url,
/* Magic phase */
Phase_App_Magic,
#if WASM_ENABLE_INTERP != 0 || WASM_ENABLE_JIT != 0
/* Phases of wasm bytecode file */
Phase_Wasm_Version,
Phase_Wasm_Section_Type,
Phase_Wasm_Section_Size,
Phase_Wasm_Section_Content,
#endif
#if WASM_ENABLE_AOT != 0
/* Phases of wasm AOT file */
Phase_AOT_Version,
Phase_AOT_Section_ID,
Phase_AOT_Section_Size,
Phase_AOT_Section_Content
#endif
} wasm_app_install_req_recv_phase_t;
/* Message for insall wasm app */
typedef struct install_wasm_app_msg_t {
uint8 request_version;
uint8 request_action;
uint16 request_fmt;
uint32 request_mid;
uint32 request_sender;
uint16 request_url_len;
uint32 wasm_app_size; /* payload size is just wasm app binary size */
char *request_url;
wasm_app_file_t app_file;
int app_file_magic;
} install_wasm_app_msg_t;
/* Wasm App Install Request Receive Context */
typedef struct wasm_app_install_req_recv_ctx_t {
wasm_app_install_req_recv_phase_t phase;
int size_in_phase;
install_wasm_app_msg_t message;
int total_received_size;
} wasm_app_install_req_recv_ctx_t;
/* Current wasm app install request receive context */
static wasm_app_install_req_recv_ctx_t recv_ctx;
static bool
wasm_app_module_init(void);
static bool
wasm_app_module_install(request_t *msg);
static bool
wasm_app_module_uninstall(request_t *msg);
static void
wasm_app_module_watchdog_kill(module_data *module_data);
static bool
wasm_app_module_handle_host_url(void *queue_msg);
static module_data *
wasm_app_module_get_module_data(void *inst);
static bool
wasm_app_module_on_install_request_byte_arrive(uint8 ch, int request_total_size,
int *received_size);
static bool
module_wasm_app_handle_install_msg(install_wasm_app_msg_t *message);
#if WASM_ENABLE_INTERP != 0 || WASM_ENABLE_JIT != 0
static void
destroy_all_wasm_sections(wasm_section_list_t sections);
static void
destroy_part_wasm_sections(wasm_section_list_t *p_sections,
uint8 *section_types, int section_cnt);
#endif
#if WASM_ENABLE_AOT != 0
static void
destroy_all_aot_sections(aot_section_list_t sections);
static void
destroy_part_aot_sections(aot_section_list_t *p_sections, uint8 *section_types,
int section_cnt);
#endif
#define Max_Msg_Callback 10
int g_msg_type[Max_Msg_Callback] = { 0 };
message_type_handler_t g_msg_callbacks[Max_Msg_Callback] = { 0 };
#define Max_Cleanup_Callback 10
static resource_cleanup_handler_t g_cleanup_callbacks[Max_Cleanup_Callback] = {
0
};
module_interface wasm_app_module_interface = {
wasm_app_module_init,
wasm_app_module_install,
wasm_app_module_uninstall,
wasm_app_module_watchdog_kill,
wasm_app_module_handle_host_url,
wasm_app_module_get_module_data,
wasm_app_module_on_install_request_byte_arrive
};
#if WASM_ENABLE_INTERP == 0
static unsigned
align_uint(unsigned v, unsigned b)
{
unsigned m = b - 1;
return (v + m) & ~m;
}
#endif
static void
exchange_uint32(uint8 *p_data)
{
uint8 value = *p_data;
*p_data = *(p_data + 3);
*(p_data + 3) = value;
value = *(p_data + 1);
*(p_data + 1) = *(p_data + 2);
*(p_data + 2) = value;
}
static wasm_function_inst_t
app_manager_lookup_function(const wasm_module_inst_t module_inst,
const char *name, const char *signature)
{
wasm_function_inst_t func;
func = wasm_runtime_lookup_function(module_inst, name, signature);
if (!func && name[0] == '_')
func = wasm_runtime_lookup_function(module_inst, name + 1, signature);
return func;
}
static void
app_instance_queue_callback(void *queue_msg, void *arg)
{
uint32 argv[2];
wasm_function_inst_t func_onRequest, func_onTimer;
wasm_module_inst_t inst = (wasm_module_inst_t)arg;
module_data *m_data = app_manager_get_module_data(Module_WASM_App, inst);
wasm_data *wasm_app_data;
int message_type;
bh_assert(m_data);
wasm_app_data = (wasm_data *)m_data->internal_data;
message_type = bh_message_type(queue_msg);
if (message_type < BASE_EVENT_MAX) {
switch (message_type) {
case RESTFUL_REQUEST:
{
request_t *request = (request_t *)bh_message_payload(queue_msg);
int size;
char *buffer;
int32 buffer_offset;
app_manager_printf("App %s got request, url %s, action %d\n",
m_data->module_name, request->url,
request->action);
func_onRequest = app_manager_lookup_function(
inst, "_on_request", "(i32i32)");
if (!func_onRequest) {
app_manager_printf("Cannot find function onRequest\n");
break;
}
buffer = pack_request(request, &size);
if (buffer == NULL)
break;
buffer_offset =
wasm_runtime_module_dup_data(inst, buffer, size);
if (buffer_offset == 0) {
const char *exception = wasm_runtime_get_exception(inst);
if (exception) {
app_manager_printf(
"Got exception running wasm code: %s\n", exception);
wasm_runtime_clear_exception(inst);
}
free_req_resp_packet(buffer);
break;
}
free_req_resp_packet(buffer);
argv[0] = (uint32)buffer_offset;
argv[1] = (uint32)size;
if (!wasm_runtime_call_wasm(wasm_app_data->exec_env,
func_onRequest, 2, argv)) {
const char *exception = wasm_runtime_get_exception(inst);
bh_assert(exception);
app_manager_printf("Got exception running wasm code: %s\n",
exception);
wasm_runtime_clear_exception(inst);
wasm_runtime_module_free(inst, buffer_offset);
break;
}
wasm_runtime_module_free(inst, buffer_offset);
app_manager_printf("Wasm app process request success.\n");
break;
}
case RESTFUL_RESPONSE:
{
wasm_function_inst_t func_onResponse;
response_t *response =
(response_t *)bh_message_payload(queue_msg);
int size;
char *buffer;
int32 buffer_offset;
app_manager_printf("App %s got response_t,status %d\n",
m_data->module_name, response->status);
func_onResponse = app_manager_lookup_function(
inst, "_on_response", "(i32i32)");
if (!func_onResponse) {
app_manager_printf("Cannot find function on_response\n");
break;
}
buffer = pack_response(response, &size);
if (buffer == NULL)
break;
buffer_offset =
wasm_runtime_module_dup_data(inst, buffer, size);
if (buffer_offset == 0) {
const char *exception = wasm_runtime_get_exception(inst);
if (exception) {
app_manager_printf(
"Got exception running wasm code: %s\n", exception);
wasm_runtime_clear_exception(inst);
}
free_req_resp_packet(buffer);
break;
}
free_req_resp_packet(buffer);
argv[0] = (uint32)buffer_offset;
argv[1] = (uint32)size;
if (!wasm_runtime_call_wasm(wasm_app_data->exec_env,
func_onResponse, 2, argv)) {
const char *exception = wasm_runtime_get_exception(inst);
bh_assert(exception);
app_manager_printf("Got exception running wasm code: %s\n",
exception);
wasm_runtime_clear_exception(inst);
wasm_runtime_module_free(inst, buffer_offset);
break;
}
wasm_runtime_module_free(inst, buffer_offset);
app_manager_printf("Wasm app process response success.\n");
break;
}
default:
{
for (int i = 0; i < Max_Msg_Callback; i++) {
if (g_msg_type[i] == message_type) {
g_msg_callbacks[i](m_data, queue_msg);
return;
}
}
app_manager_printf(
"Invalid message type of WASM app queue message.\n");
break;
}
}
}
else {
switch (message_type) {
case TIMER_EVENT_WASM:
{
unsigned int timer_id;
if (bh_message_payload(queue_msg)) {
/* Call Timer.callOnTimer() method */
func_onTimer = app_manager_lookup_function(
inst, "_on_timer_callback", "(i32)");
if (!func_onTimer) {
app_manager_printf(
"Cannot find function _on_timer_callback\n");
break;
}
timer_id =
(unsigned int)(uintptr_t)bh_message_payload(queue_msg);
argv[0] = timer_id;
if (!wasm_runtime_call_wasm(wasm_app_data->exec_env,
func_onTimer, 1, argv)) {
const char *exception =
wasm_runtime_get_exception(inst);
bh_assert(exception);
app_manager_printf(
"Got exception running wasm code: %s\n", exception);
wasm_runtime_clear_exception(inst);
}
}
break;
}
default:
{
for (int i = 0; i < Max_Msg_Callback; i++) {
if (g_msg_type[i] == message_type) {
g_msg_callbacks[i](m_data, queue_msg);
return;
}
}
app_manager_printf(
"Invalid message type of WASM app queue message.\n");
break;
}
}
}
}
#if WASM_ENABLE_LIBC_WASI != 0
static bool
wasm_app_prepare_wasi_dir(wasm_module_t module, const char *module_name,
char *wasi_dir_buf, uint32 buf_size)
{
const char *wasi_root = wasm_get_wasi_root_dir();
char *p = wasi_dir_buf;
uint32 module_name_len = strlen(module_name);
uint32 wasi_root_len = strlen(wasi_root);
uint32 total_size;
struct stat st = { 0 };
bh_assert(wasi_root);
/* wasi_dir: wasi_root/module_name */
total_size = wasi_root_len + 1 + module_name_len + 1;
if (total_size > buf_size)
return false;
memcpy(p, wasi_root, wasi_root_len);
p += wasi_root_len;
*p++ = '/';
memcpy(p, module_name, module_name_len);
p += module_name_len;
*p++ = '\0';
if (mkdir(wasi_dir_buf, 0777) != 0) {
if (errno == EEXIST) {
/* Failed due to dir already exist */
if ((stat(wasi_dir_buf, &st) == 0) && (st.st_mode & S_IFDIR)) {
return true;
}
}
return false;
}
return true;
}
#endif
/* WASM app thread main routine */
static void *
wasm_app_routine(void *arg)
{
wasm_function_inst_t func_onInit;
wasm_function_inst_t func_onDestroy;
module_data *m_data = (module_data *)arg;
wasm_data *wasm_app_data = (wasm_data *)m_data->internal_data;
wasm_module_inst_t inst = wasm_app_data->wasm_module_inst;
/* Set m_data to the VM managed instance's custom data */
wasm_runtime_set_custom_data(inst, m_data);
app_manager_printf("WASM app '%s' started\n", m_data->module_name);
#if WASM_ENABLE_LIBC_WASI != 0
if (wasm_runtime_is_wasi_mode(inst)) {
wasm_function_inst_t func_start;
/* In wasi mode, we should call function named "_start"
which initializes the wasi envrionment. The "_start" function
will call "main" function */
if ((func_start = wasm_runtime_lookup_wasi_start_function(inst))) {
if (!wasm_runtime_call_wasm(wasm_app_data->exec_env, func_start, 0,
NULL)) {
const char *exception = wasm_runtime_get_exception(inst);
bh_assert(exception);
app_manager_printf(
"Got exception running wasi start function: %s\n",
exception);
wasm_runtime_clear_exception(inst);
goto fail1;
}
}
/* if no start function is found, we execute
the _on_init function as normal */
}
#endif
/* Call app's onInit() method */
func_onInit = app_manager_lookup_function(inst, "_on_init", "()");
if (!func_onInit) {
app_manager_printf("Cannot find function on_init().\n");
goto fail1;
}
if (!wasm_runtime_call_wasm(wasm_app_data->exec_env, func_onInit, 0,
NULL)) {
const char *exception = wasm_runtime_get_exception(inst);
bh_assert(exception);
app_manager_printf("Got exception running WASM code: %s\n", exception);
wasm_runtime_clear_exception(inst);
/* call on_destroy() in case some resources are opened in on_init()
* and then exception thrown */
goto fail2;
}
/* Enter queue loop run to receive and process applet queue message */
bh_queue_enter_loop_run(m_data->queue, app_instance_queue_callback, inst);
app_manager_printf("App instance main thread exit.\n");
fail2:
/* Call WASM app onDestroy() method if there is */
func_onDestroy = app_manager_lookup_function(inst, "_on_destroy", "()");
if (func_onDestroy) {
if (!wasm_runtime_call_wasm(wasm_app_data->exec_env, func_onDestroy, 0,
NULL)) {
const char *exception = wasm_runtime_get_exception(inst);
bh_assert(exception);
app_manager_printf("Got exception running WASM code: %s\n",
exception);
wasm_runtime_clear_exception(inst);
}
}
fail1:
return NULL;
}
static void
cleanup_app_resource(module_data *m_data)
{
int i;
wasm_data *wasm_app_data = (wasm_data *)m_data->internal_data;
bool is_bytecode = wasm_app_data->is_bytecode;
am_cleanup_registeration(m_data->id);
am_unregister_event(NULL, m_data->id);
for (i = 0; i < Max_Cleanup_Callback; i++) {
if (g_cleanup_callbacks[i] != NULL)
g_cleanup_callbacks[i](m_data->id);
else
break;
}
wasm_runtime_deinstantiate(wasm_app_data->wasm_module_inst);
/* Destroy remain sections (i.e. data segment section for bytecode file
* or text section of aot file) from app file's section list. */
if (is_bytecode) {
#if WASM_ENABLE_INTERP != 0 || WASM_ENABLE_JIT != 0
destroy_all_wasm_sections(
(wasm_section_list_t)(wasm_app_data->sections));
#else
bh_assert(0);
#endif
}
else {
#if WASM_ENABLE_AOT != 0
destroy_all_aot_sections((aot_section_list_t)(wasm_app_data->sections));
#else
bh_assert(0);
#endif
}
if (wasm_app_data->wasm_module)
wasm_runtime_unload(wasm_app_data->wasm_module);
if (wasm_app_data->exec_env)
wasm_runtime_destroy_exec_env(wasm_app_data->exec_env);
/* Destroy watchdog timer */
watchdog_timer_destroy(&m_data->wd_timer);
/* Remove module data from module data list and free it */
app_manager_del_module_data(m_data);
}
/************************************************************/
/* Module specific functions implementation */
/************************************************************/
static bool
wasm_app_module_init(void)
{
uint32 version;
#if WASM_ENABLE_INTERP != 0 || WASM_ENABLE_JIT != 0
version = WASM_CURRENT_VERSION;
if (!is_little_endian())
exchange_uint32((uint8 *)&version);
bh_memcpy_s(wasm_bytecode_version, 4, &version, 4);
#endif
#if WASM_ENABLE_AOT != 0
version = AOT_CURRENT_VERSION;
if (!is_little_endian())
exchange_uint32((uint8 *)&version);
bh_memcpy_s(wasm_aot_version, 4, &version, 4);
#endif
return true;
}
#define APP_NAME_MAX_LEN 128
#define MAX_INT_STR_LEN 11
static bool
wasm_app_module_install(request_t *msg)
{
unsigned int m_data_size, heap_size, stack_size;
unsigned int timeout, timers, err_size;
char *properties;
int properties_offset;
wasm_app_file_t *wasm_app_file;
wasm_data *wasm_app_data;
package_type_t package_type;
module_data *m_data = NULL;
wasm_module_t module = NULL;
wasm_module_inst_t inst = NULL;
wasm_exec_env_t exec_env = NULL;
char m_name[APP_NAME_MAX_LEN] = { 0 };
char timeout_str[MAX_INT_STR_LEN] = { 0 };
char heap_size_str[MAX_INT_STR_LEN] = { 0 };
char timers_str[MAX_INT_STR_LEN] = { 0 }, err[128], err_resp[256];
#if WASM_ENABLE_LIBC_WASI != 0
char wasi_dir_buf[PATH_MAX] = { 0 };
const char *wasi_dir_list[] = { wasi_dir_buf };
#endif
err_size = sizeof(err);
/* Check payload */
if (!msg->payload || msg->payload_len == 0) {
SEND_ERR_RESPONSE(msg->mid,
"Install WASM app failed: invalid wasm file.");
return false;
}
/* Judge the app type is AOTed or not */
package_type = get_package_type((uint8 *)msg->payload, msg->payload_len);
wasm_app_file = (wasm_app_file_t *)msg->payload;
/* Check app name */
properties_offset = check_url_start(msg->url, strlen(msg->url), "/applet");
bh_assert(properties_offset > 0);
if (properties_offset <= 0) {
SEND_ERR_RESPONSE(msg->mid,
"Install WASM app failed: invalid app name.");
goto fail;
}
properties = msg->url + properties_offset;
find_key_value(properties, strlen(properties), "name", m_name,
sizeof(m_name) - 1, '&');
if (strlen(m_name) == 0) {
SEND_ERR_RESPONSE(msg->mid,
"Install WASM app failed: invalid app name.");
goto fail;
}
if (app_manager_lookup_module_data(m_name)) {
SEND_ERR_RESPONSE(msg->mid,
"Install WASM app failed: app already installed.");
goto fail;
}
/* Parse heap size */
heap_size = APP_HEAP_SIZE_DEFAULT;
find_key_value(properties, strlen(properties), "heap", heap_size_str,
sizeof(heap_size_str) - 1, '&');
if (strlen(heap_size_str) > 0) {
heap_size = atoi(heap_size_str);
if (heap_size < APP_HEAP_SIZE_MIN)
heap_size = APP_HEAP_SIZE_MIN;
else if (heap_size > APP_HEAP_SIZE_MAX)
heap_size = APP_HEAP_SIZE_MAX;
}
/* Load WASM file and instantiate*/
switch (package_type) {
#if WASM_ENABLE_AOT != 0
case Wasm_Module_AoT:
{
wasm_aot_file_t *aot_file;
/* clang-format off */
/* Sections to be released after loading */
uint8 sections1[] = {
AOT_SECTION_TYPE_TARGET_INFO,
AOT_SECTION_TYPE_INIT_DATA,
AOT_SECTION_TYPE_FUNCTION,
AOT_SECTION_TYPE_EXPORT,
AOT_SECTION_TYPE_RELOCATION,
AOT_SECTION_TYPE_SIGANATURE,
AOT_SECTION_TYPE_CUSTOM,
};
/* clang-format on */
aot_file = &wasm_app_file->u.aot;
/* Load AOT module from sections */
module = wasm_runtime_load_from_sections(aot_file->sections, true,
err, err_size);
if (!module) {
snprintf(err_resp, sizeof(err_resp),
"Install WASM app failed: %s", err);
SEND_ERR_RESPONSE(msg->mid, err_resp);
goto fail;
}
/* Destroy useless sections from list after load */
destroy_part_aot_sections(&aot_file->sections, sections1,
sizeof(sections1) / sizeof(uint8));
#if WASM_ENABLE_LIBC_WASI != 0
if (!wasm_app_prepare_wasi_dir(module, m_name, wasi_dir_buf,
sizeof(wasi_dir_buf))) {
SEND_ERR_RESPONSE(
msg->mid,
"Install WASM app failed: prepare wasi env failed.");
goto fail;
}
wasm_runtime_set_wasi_args(module, wasi_dir_list, 1, NULL, 0, NULL,
0, NULL, 0);
#endif
/* Instantiate the AOT module */
inst =
wasm_runtime_instantiate(module, 0, heap_size, err, err_size);
if (!inst) {
snprintf(err_resp, sizeof(err_resp),
"Install WASM app failed: %s", err);
SEND_ERR_RESPONSE(msg->mid, err);
goto fail;
}
break;
}
#endif /* endof WASM_ENABLE_AOT != 0 */
#if WASM_ENABLE_INTERP != 0 || WASM_ENABLE_JIT != 0
case Wasm_Module_Bytecode:
{
wasm_bytecode_file_t *bytecode_file;
/* Sections to be released after loading */
uint8 sections1[] = {
SECTION_TYPE_USER,
SECTION_TYPE_TYPE,
SECTION_TYPE_IMPORT,
SECTION_TYPE_FUNC,
SECTION_TYPE_TABLE,
SECTION_TYPE_MEMORY,
SECTION_TYPE_GLOBAL,
SECTION_TYPE_EXPORT,
SECTION_TYPE_START,
SECTION_TYPE_ELEM,
#if WASM_ENABLE_BULK_MEMORY != 0
SECTION_TYPE_DATACOUNT
#endif
};
/* Sections to be released after instantiating */
uint8 sections2[] = { SECTION_TYPE_DATA };
bytecode_file = &wasm_app_file->u.bytecode;
/* Load wasm module from sections */
module = wasm_runtime_load_from_sections(bytecode_file->sections,
false, err, err_size);
if (!module) {
snprintf(err_resp, sizeof(err_resp),
"Install WASM app failed: %s", err);
SEND_ERR_RESPONSE(msg->mid, err_resp);
goto fail;
}
/* Destroy useless sections from list after load */
destroy_part_wasm_sections(&bytecode_file->sections, sections1,
sizeof(sections1) / sizeof(uint8));
#if WASM_ENABLE_LIBC_WASI != 0
if (!wasm_app_prepare_wasi_dir(module, m_name, wasi_dir_buf,
sizeof(wasi_dir_buf))) {
SEND_ERR_RESPONSE(
msg->mid,
"Install WASM app failed: prepare wasi env failed.");
goto fail;
}
wasm_runtime_set_wasi_args(module, wasi_dir_list, 1, NULL, 0, NULL,
0, NULL, 0);
#endif
/* Instantiate the wasm module */
inst =
wasm_runtime_instantiate(module, 0, heap_size, err, err_size);
if (!inst) {
snprintf(err_resp, sizeof(err_resp),
"Install WASM app failed: %s", err);
SEND_ERR_RESPONSE(msg->mid, err_resp);
goto fail;
}
/* Destroy useless sections from list after instantiate */
destroy_part_wasm_sections(&bytecode_file->sections, sections2,
sizeof(sections2) / sizeof(uint8));
break;
}
#endif /* endof WASM_ENALBE_INTERP != 0 || WASM_ENABLE_JIT != 0 */
default:
SEND_ERR_RESPONSE(
msg->mid,
"Install WASM app failed: invalid wasm package type.");
goto fail;
}
/* Create module data including the wasm_app_data as its internal_data*/
m_data_size = offsetof(module_data, module_name) + strlen(m_name) + 1;
m_data_size = align_uint(m_data_size, 4);
m_data = APP_MGR_MALLOC(m_data_size + sizeof(wasm_data));
if (!m_data) {
SEND_ERR_RESPONSE(msg->mid,
"Install WASM app failed: allocate memory failed.");
goto fail;
}
memset(m_data, 0, m_data_size + sizeof(wasm_data));
m_data->module_type = Module_WASM_App;
m_data->internal_data = (uint8 *)m_data + m_data_size;
wasm_app_data = (wasm_data *)m_data->internal_data;
wasm_app_data->wasm_module_inst = inst;
wasm_app_data->wasm_module = module;
wasm_app_data->m_data = m_data;
if (package_type == Wasm_Module_Bytecode) {
wasm_app_data->is_bytecode = true;
wasm_app_data->sections = wasm_app_file->u.bytecode.sections;
}
else {
wasm_app_data->is_bytecode = false;
wasm_app_data->sections = wasm_app_file->u.aot.sections;
}
if (!(wasm_app_data->exec_env = exec_env =
wasm_runtime_create_exec_env(inst, DEFAULT_WASM_STACK_SIZE))) {
SEND_ERR_RESPONSE(msg->mid,
"Install WASM app failed: create exec env failed.");
goto fail;
}
/* Set module data - name and module type */
bh_strcpy_s(m_data->module_name, strlen(m_name) + 1, m_name);
/* Set module data - execution timeout */
timeout = DEFAULT_WATCHDOG_INTERVAL;
find_key_value(properties, strlen(properties), "wd", timeout_str,
sizeof(timeout_str) - 1, '&');
if (strlen(timeout_str) > 0)
timeout = atoi(timeout_str);
m_data->timeout = timeout;
/* Set module data - create queue */
m_data->queue = bh_queue_create();
if (!m_data->queue) {
SEND_ERR_RESPONSE(msg->mid,
"Install WASM app failed: create app queue failed.");
goto fail;
}
/* Set heap size */
m_data->heap_size = heap_size;
/* Set module data - timers number */
timers = DEFAULT_TIMERS_PER_APP;
find_key_value(properties, strlen(properties), "timers", timers_str,
sizeof(timers_str) - 1, '&');
if (strlen(timers_str) > 0) {
timers = atoi(timers_str);
if (timers > MAX_TIMERS_PER_APP)
timers = MAX_TIMERS_PER_APP;
}
/* Attention: must add the module before start the thread! */
app_manager_add_module_data(m_data);
m_data->timer_ctx = create_wasm_timer_ctx(m_data->id, timers);
if (!m_data->timer_ctx) {
SEND_ERR_RESPONSE(msg->mid,
"Install WASM app failed: create app timers failed.");
goto fail;
}
/* Initialize watchdog timer */
if (!watchdog_timer_init(m_data)) {
SEND_ERR_RESPONSE(
msg->mid,
"Install WASM app failed: create app watchdog timer failed.");
goto fail;
}
stack_size = APP_THREAD_STACK_SIZE_DEFAULT;
#ifdef OS_ENABLE_HW_BOUND_CHECK
stack_size += 4 * BH_KB;
#endif
/* Create WASM app thread. */
if (os_thread_create(&wasm_app_data->thread_id, wasm_app_routine,
(void *)m_data, stack_size)
!= 0) {
module_data_list_remove(m_data);
SEND_ERR_RESPONSE(msg->mid,
"Install WASM app failed: create app thread failed.");
goto fail;
}
/* only when thread is created it is the flag of installation success */
app_manager_post_applets_update_event();
app_manager_printf("Install WASM app success!\n");
send_error_response_to_host(msg->mid, CREATED_2_01, NULL); /* CREATED */
return true;
fail:
if (m_data)
release_module(m_data);
if (inst)
wasm_runtime_deinstantiate(inst);
if (module)
wasm_runtime_unload(module);
if (exec_env)
wasm_runtime_destroy_exec_env(exec_env);
switch (package_type) {
#if WASM_ENABLE_INTERP != 0 || WASM_ENABLE_JIT != 0
case Wasm_Module_Bytecode:
destroy_all_wasm_sections(wasm_app_file->u.bytecode.sections);
break;
#endif
#if WASM_ENABLE_AOT != 0
case Wasm_Module_AoT:
destroy_all_aot_sections(wasm_app_file->u.aot.sections);
break;
#endif
default:
break;
}
return false;
}
/* For internal use: if defined to 1, the process will
* exit when wasm app is uninstalled. Hence valgrind can
* print memory leak report. */
#ifndef VALGRIND_CHECK
#define VALGRIND_CHECK 0
#endif
/* Uninstall WASM app */
static bool
wasm_app_module_uninstall(request_t *msg)
{
module_data *m_data;
wasm_data *wasm_app_data;
char m_name[APP_NAME_MAX_LEN] = { 0 };
char *properties;
int properties_offset;
properties_offset = check_url_start(msg->url, strlen(msg->url), "/applet");
/* TODO: assert(properties_offset > 0) */
if (properties_offset <= 0)
return false;
properties = msg->url + properties_offset;
find_key_value(properties, strlen(properties), "name", m_name,
sizeof(m_name) - 1, '&');
if (strlen(m_name) == 0) {
SEND_ERR_RESPONSE(msg->mid,
"Uninstall WASM app failed: invalid app name.");
return false;
}
m_data = app_manager_lookup_module_data(m_name);
if (!m_data) {
SEND_ERR_RESPONSE(msg->mid, "Uninstall WASM app failed: no app found.");
return false;
}
if (m_data->module_type != Module_WASM_App) {
SEND_ERR_RESPONSE(msg->mid,
"Uninstall WASM app failed: invalid module type.");
return false;
}
if (m_data->wd_timer.is_interrupting) {
SEND_ERR_RESPONSE(
msg->mid,
"Uninstall WASM app failed: app is being interrupted by watchdog.");
return false;
}
/* Exit app queue loop run */
bh_queue_exit_loop_run(m_data->queue);
/* Wait for wasm app thread to exit */
wasm_app_data = (wasm_data *)m_data->internal_data;
os_thread_join(wasm_app_data->thread_id, NULL);
cleanup_app_resource(m_data);
app_manager_post_applets_update_event();
app_manager_printf("Uninstall WASM app successful!\n");
#ifdef COLLECT_CODE_COVERAGE
/* Exit app manager so as to collect code coverage data */
if (!strcmp(m_name, "__exit_app_manager__")) {
app_manager_printf("Exit app manager\n");
bh_queue_exit_loop_run(get_app_manager_queue());
}
#endif
#if VALGRIND_CHECK != 0
bh_queue_exit_loop_run(get_app_manager_queue());
#endif
send_error_response_to_host(msg->mid, DELETED_2_02, NULL); /* DELETED */
return true;
}
static bool
wasm_app_module_handle_host_url(void *queue_msg)
{
/* TODO: implement in future */
app_manager_printf("App handles host url address %d\n",
(int)(uintptr_t)queue_msg);
return false;
}
static module_data *
wasm_app_module_get_module_data(void *inst)
{
wasm_module_inst_t module_inst = (wasm_module_inst_t)inst;
return (module_data *)wasm_runtime_get_custom_data(module_inst);
}
static void
wasm_app_module_watchdog_kill(module_data *m_data)
{
/* TODO: implement in future */
app_manager_printf("Watchdog kills app: %s\n", m_data->module_name);
return;
}
bool
wasm_register_msg_callback(int message_type,
message_type_handler_t message_handler)
{
int i;
int freeslot = -1;
for (i = 0; i < Max_Msg_Callback; i++) {
/* replace handler for the same event registered */
if (g_msg_type[i] == message_type)
break;
if (g_msg_callbacks[i] == NULL && freeslot == -1)
freeslot = i;
}
if (i != Max_Msg_Callback)
g_msg_callbacks[i] = message_handler;
else if (freeslot != -1) {
g_msg_callbacks[freeslot] = message_handler;
g_msg_type[freeslot] = message_type;
}
else
return false;
return true;
}
bool
wasm_register_cleanup_callback(resource_cleanup_handler_t handler)
{
int i;
for (i = 0; i < Max_Cleanup_Callback; i++) {
if (g_cleanup_callbacks[i] == NULL) {
g_cleanup_callbacks[i] = handler;
return true;
}
}
return false;
}
#define RECV_INTEGER(value, next_phase) \
do { \
uint8 *p = (uint8 *)&value; \
p[recv_ctx.size_in_phase++] = ch; \
if (recv_ctx.size_in_phase == sizeof(value)) { \
if (sizeof(value) == 4) \
value = ntohl(value); \
else if (sizeof(value) == 2) \
value = ntohs(value); \
recv_ctx.phase = next_phase; \
recv_ctx.size_in_phase = 0; \
} \
} while (0)
/* return:
* 1: whole wasm app arrived
* 0: one valid byte arrived
* -1: fail to process the byte arrived, e.g. allocate memory fail
*/
static bool
wasm_app_module_on_install_request_byte_arrive(uint8 ch, int request_total_size,
int *received_size)
{
uint8 *p;
int magic;
package_type_t package_type = Package_Type_Unknown;
if (recv_ctx.phase == Phase_Req_Ver) {
recv_ctx.phase = Phase_Req_Ver;
recv_ctx.size_in_phase = 0;
recv_ctx.total_received_size = 0;
}
recv_ctx.total_received_size++;
*received_size = recv_ctx.total_received_size;
if (recv_ctx.phase == Phase_Req_Ver) {
if (ch != 1 /* REQUES_PACKET_VER from restful_utils.c */)
return false;
recv_ctx.phase = Phase_Req_Action;
return true;
}
else if (recv_ctx.phase == Phase_Req_Action) {
recv_ctx.message.request_action = ch;
recv_ctx.phase = Phase_Req_Fmt;
recv_ctx.size_in_phase = 0;
return true;
}
else if (recv_ctx.phase == Phase_Req_Fmt) {
RECV_INTEGER(recv_ctx.message.request_fmt, Phase_Req_Mid);
return true;
}
else if (recv_ctx.phase == Phase_Req_Mid) {
RECV_INTEGER(recv_ctx.message.request_mid, Phase_Req_Sender);
return true;
}
else if (recv_ctx.phase == Phase_Req_Sender) {
RECV_INTEGER(recv_ctx.message.request_sender, Phase_Req_Url_Len);
return true;
}
else if (recv_ctx.phase == Phase_Req_Url_Len) {
p = (uint8 *)&recv_ctx.message.request_url_len;
p[recv_ctx.size_in_phase++] = ch;
if (recv_ctx.size_in_phase
== sizeof(recv_ctx.message.request_url_len)) {
recv_ctx.message.request_url_len =
ntohs(recv_ctx.message.request_url_len);
recv_ctx.message.request_url =
APP_MGR_MALLOC(recv_ctx.message.request_url_len + 1);
if (NULL == recv_ctx.message.request_url) {
app_manager_printf("Allocate memory failed!\n");
SEND_ERR_RESPONSE(recv_ctx.message.request_mid,
"Install WASM app failed: "
"allocate memory failed.");
goto fail;
}
memset(recv_ctx.message.request_url, 0,
recv_ctx.message.request_url_len + 1);
recv_ctx.phase = Phase_Req_Payload_Len;
recv_ctx.size_in_phase = 0;
}
return true;
}
else if (recv_ctx.phase == Phase_Req_Payload_Len) {
RECV_INTEGER(recv_ctx.message.wasm_app_size, Phase_Req_Url);
return true;
}
else if (recv_ctx.phase == Phase_Req_Url) {
recv_ctx.message.request_url[recv_ctx.size_in_phase++] = ch;
if (recv_ctx.size_in_phase == recv_ctx.message.request_url_len) {
recv_ctx.phase = Phase_App_Magic;
recv_ctx.size_in_phase = 0;
}
return true;
}
else if (recv_ctx.phase == Phase_App_Magic) {
/* start to receive wasm app magic: bytecode or aot */
p = (uint8 *)&recv_ctx.message.app_file_magic;
p[recv_ctx.size_in_phase++] = ch;
if (recv_ctx.size_in_phase == sizeof(recv_ctx.message.app_file_magic)) {
magic = recv_ctx.message.app_file_magic;
package_type = get_package_type((uint8 *)&magic, sizeof(magic) + 1);
switch (package_type) {
#if WASM_ENABLE_INTERP != 0 || WASM_ENABLE_JIT != 0
case Wasm_Module_Bytecode:
recv_ctx.message.app_file.u.bytecode.magic =
recv_ctx.message.app_file_magic;
recv_ctx.phase = Phase_Wasm_Version;
recv_ctx.size_in_phase = 0;
break;
#endif
#if WASM_ENABLE_AOT != 0
case Wasm_Module_AoT:
recv_ctx.message.app_file.u.aot.magic =
recv_ctx.message.app_file_magic;
recv_ctx.phase = Phase_AOT_Version;
recv_ctx.size_in_phase = 0;
break;
#endif
default:
SEND_ERR_RESPONSE(recv_ctx.message.request_mid,
"Install WASM app failed: "
"invalid file format.");
goto fail;
}
}
return true;
}
#if WASM_ENABLE_INTERP != 0 || WASM_ENABLE_JIT != 0
else if (recv_ctx.phase == Phase_Wasm_Version) {
p = (uint8 *)&recv_ctx.message.app_file.u.bytecode.version;
if (ch == wasm_bytecode_version[recv_ctx.size_in_phase])
p[recv_ctx.size_in_phase++] = ch;
else {
app_manager_printf("Invalid WASM version!\n");
SEND_ERR_RESPONSE(recv_ctx.message.request_mid,
"Install WASM app failed: invalid WASM version.");
goto fail;
}
if (recv_ctx.size_in_phase
== sizeof(recv_ctx.message.app_file.u.bytecode.version)) {
recv_ctx.phase = Phase_Wasm_Section_Type;
recv_ctx.size_in_phase = 0;
}
return true;
}
else if (recv_ctx.phase == Phase_Wasm_Section_Type) {
uint8 section_type = ch;
#if WASM_ENABLE_BULK_MEMORY == 0
uint8 section_type_max = SECTION_TYPE_DATA;
#else
uint8 section_type_max = SECTION_TYPE_DATACOUNT;
#endif
if (section_type <= section_type_max) {
wasm_section_t *new_section;
if (!(new_section = (wasm_section_t *)APP_MGR_MALLOC(
sizeof(wasm_section_t)))) {
app_manager_printf("Allocate memory failed!\n");
SEND_ERR_RESPONSE(recv_ctx.message.request_mid,
"Install WASM app failed: "
"allocate memory failed.");
goto fail;
}
memset(new_section, 0, sizeof(wasm_section_t));
new_section->section_type = section_type;
new_section->next = NULL;
/* add the section to tail of link list */
if (NULL == recv_ctx.message.app_file.u.bytecode.sections) {
recv_ctx.message.app_file.u.bytecode.sections = new_section;
recv_ctx.message.app_file.u.bytecode.section_end = new_section;
}
else {
recv_ctx.message.app_file.u.bytecode.section_end->next =
new_section;
recv_ctx.message.app_file.u.bytecode.section_end = new_section;
}
recv_ctx.phase = Phase_Wasm_Section_Size;
recv_ctx.size_in_phase = 0;
return true;
}
else {
char error_buf[128];
app_manager_printf("Invalid wasm section type: %d\n", section_type);
snprintf(error_buf, sizeof(error_buf),
"Install WASM app failed: invalid wasm section type %d",
section_type);
SEND_ERR_RESPONSE(recv_ctx.message.request_mid, error_buf);
goto fail;
}
}
else if (recv_ctx.phase == Phase_Wasm_Section_Size) {
/* the last section is the current receiving one */
wasm_section_t *section =
recv_ctx.message.app_file.u.bytecode.section_end;
uint32 byte;
bh_assert(section);
byte = ch;
section->section_body_size |=
((byte & 0x7f) << recv_ctx.size_in_phase * 7);
recv_ctx.size_in_phase++;
/* check leab128 overflow for uint32 value */
if (recv_ctx.size_in_phase
> (sizeof(section->section_body_size) * 8 + 7 - 1) / 7) {
app_manager_printf("LEB overflow when parsing section size\n");
SEND_ERR_RESPONSE(recv_ctx.message.request_mid,
"Install WASM app failed: "
"LEB overflow when parsing section size");
goto fail;
}
if ((byte & 0x80) == 0) {
/* leb128 encoded section size parsed done */
if (!(section->section_body =
APP_MGR_MALLOC(section->section_body_size))) {
app_manager_printf("Allocate memory failed!\n");
SEND_ERR_RESPONSE(
recv_ctx.message.request_mid,
"Install WASM app failed: allocate memory failed");
goto fail;
}
recv_ctx.phase = Phase_Wasm_Section_Content;
recv_ctx.size_in_phase = 0;
}
return true;
}
else if (recv_ctx.phase == Phase_Wasm_Section_Content) {
/* the last section is the current receiving one */
wasm_section_t *section =
recv_ctx.message.app_file.u.bytecode.section_end;
bh_assert(section);
section->section_body[recv_ctx.size_in_phase++] = ch;
if (recv_ctx.size_in_phase == section->section_body_size) {
if (recv_ctx.total_received_size == request_total_size) {
/* whole wasm app received */
if (module_wasm_app_handle_install_msg(&recv_ctx.message)) {
APP_MGR_FREE(recv_ctx.message.request_url);
recv_ctx.message.request_url = NULL;
memset(&recv_ctx, 0, sizeof(recv_ctx));
return true;
}
else {
app_manager_printf("Handle install message failed!\n");
SEND_ERR_RESPONSE(recv_ctx.message.request_mid,
"Install WASM app failed: "
"handle install message failed");
/**
* The sections were destroyed inside
* module_wasm_app_handle_install_msg(),
* no need to destroy again.
*/
return false;
}
}
else {
recv_ctx.phase = Phase_Wasm_Section_Type;
recv_ctx.size_in_phase = 0;
return true;
}
}
return true;
}
#endif /* end of WASM_ENABLE_INTERP != 0 || WASM_ENABLE_JIT != 0 */
#if WASM_ENABLE_AOT != 0
else if (recv_ctx.phase == Phase_AOT_Version) {
p = (uint8 *)&recv_ctx.message.app_file.u.aot.version;
if (ch == wasm_aot_version[recv_ctx.size_in_phase])
p[recv_ctx.size_in_phase++] = ch;
else {
app_manager_printf("Invalid AOT version!\n");
SEND_ERR_RESPONSE(recv_ctx.message.request_mid,
"Install WASM app failed: invalid AOT version");
goto fail;
}
if (recv_ctx.size_in_phase
== sizeof(recv_ctx.message.app_file.u.aot.version)) {
recv_ctx.phase = Phase_AOT_Section_ID;
recv_ctx.size_in_phase = 0;
}
return true;
}
else if (recv_ctx.phase == Phase_AOT_Section_ID) {
aot_section_t *cur_section;
uint32 aot_file_cur_offset =
recv_ctx.total_received_size - 1
- 18 /* Request fixed part */ - recv_ctx.message.request_url_len;
if (recv_ctx.size_in_phase == 0) {
/* Skip paddings */
if (aot_file_cur_offset % 4)
return true;
if (!(cur_section =
(aot_section_t *)APP_MGR_MALLOC(sizeof(aot_section_t)))) {
app_manager_printf("Allocate memory failed!\n");
SEND_ERR_RESPONSE(recv_ctx.message.request_mid,
"Install WASM app failed: "
"allocate memory failed");
goto fail;
}
memset(cur_section, 0, sizeof(aot_section_t));
/* add the section to tail of link list */
if (NULL == recv_ctx.message.app_file.u.aot.sections) {
recv_ctx.message.app_file.u.aot.sections = cur_section;
recv_ctx.message.app_file.u.aot.section_end = cur_section;
}
else {
recv_ctx.message.app_file.u.aot.section_end->next = cur_section;
recv_ctx.message.app_file.u.aot.section_end = cur_section;
}
}
else {
cur_section = recv_ctx.message.app_file.u.aot.section_end;
bh_assert(cur_section);
}
p = (uint8 *)&cur_section->section_type;
p[recv_ctx.size_in_phase++] = ch;
if (recv_ctx.size_in_phase == sizeof(cur_section->section_type)) {
/* Notes: integers are always little endian encoded in AOT file */
if (!is_little_endian())
exchange_uint32(p);
if (cur_section->section_type < AOT_SECTION_TYPE_SIGANATURE
|| cur_section->section_type == AOT_SECTION_TYPE_CUSTOM) {
recv_ctx.phase = Phase_AOT_Section_Size;
recv_ctx.size_in_phase = 0;
}
else {
char error_buf[128];
app_manager_printf("Invalid AOT section id: %d\n",
cur_section->section_type);
snprintf(error_buf, sizeof(error_buf),
"Install WASM app failed: invalid AOT section id %d",
cur_section->section_type);
SEND_ERR_RESPONSE(recv_ctx.message.request_mid, error_buf);
goto fail;
}
}
return true;
}
else if (recv_ctx.phase == Phase_AOT_Section_Size) {
/* the last section is the current receiving one */
aot_section_t *section = recv_ctx.message.app_file.u.aot.section_end;
bh_assert(section);
p = (uint8 *)&section->section_body_size;
p[recv_ctx.size_in_phase++] = ch;
if (recv_ctx.size_in_phase == sizeof(section->section_body_size)) {
/* Notes: integers are always little endian encoded in AOT file */
if (!is_little_endian())
exchange_uint32(p);
/* Allocate memory for section body */
if (section->section_body_size > 0) {
if (section->section_type == AOT_SECTION_TYPE_TEXT) {
int map_prot =
MMAP_PROT_READ | MMAP_PROT_WRITE | MMAP_PROT_EXEC;
#if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64) \
|| defined(BUILD_TARGET_RISCV64_LP64D) \
|| defined(BUILD_TARGET_RISCV64_LP64)
/* aot code and data in x86_64 must be in range 0 to 2G due
to relocation for R_X86_64_32/32S/PC32 */
int map_flags = MMAP_MAP_32BIT;
#else
int map_flags = MMAP_MAP_NONE;
#endif
uint64 total_size = (uint64)section->section_body_size
+ aot_get_plt_table_size();
total_size = (total_size + 3) & ~((uint64)3);
if (total_size >= UINT32_MAX
|| !(section->section_body =
os_mmap(NULL, (uint32)total_size, map_prot,
map_flags))) {
app_manager_printf(
"Allocate executable memory failed!\n");
SEND_ERR_RESPONSE(recv_ctx.message.request_mid,
"Install WASM app failed: "
"allocate memory failed");
goto fail;
}
#if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64)
/* address must be in the first 2 Gigabytes of
the process address space */
bh_assert((uintptr_t)section->section_body < INT32_MAX);
#endif
}
else {
if (!(section->section_body =
APP_MGR_MALLOC(section->section_body_size))) {
app_manager_printf("Allocate memory failed!\n");
SEND_ERR_RESPONSE(recv_ctx.message.request_mid,
"Install WASM app failed: "
"allocate memory failed");
goto fail;
}
}
}
recv_ctx.phase = Phase_AOT_Section_Content;
recv_ctx.size_in_phase = 0;
}
return true;
}
else if (recv_ctx.phase == Phase_AOT_Section_Content) {
/* the last section is the current receiving one */
aot_section_t *section = recv_ctx.message.app_file.u.aot.section_end;
bh_assert(section && section->section_body);
section->section_body[recv_ctx.size_in_phase++] = ch;
if (recv_ctx.size_in_phase == section->section_body_size) {
if (section->section_type == AOT_SECTION_TYPE_TEXT) {
uint32 total_size =
section->section_body_size + aot_get_plt_table_size();
total_size = (total_size + 3) & ~3;
if (total_size > section->section_body_size) {
memset(section->section_body + section->section_body_size,
0, total_size - section->section_body_size);
section->section_body_size = total_size;
}
}
if (recv_ctx.total_received_size == request_total_size) {
/* whole aot file received */
if (module_wasm_app_handle_install_msg(&recv_ctx.message)) {
APP_MGR_FREE(recv_ctx.message.request_url);
recv_ctx.message.request_url = NULL;
memset(&recv_ctx, 0, sizeof(recv_ctx));
return true;
}
else {
app_manager_printf("Handle install message failed!\n");
SEND_ERR_RESPONSE(recv_ctx.message.request_mid,
"Install WASM app failed: "
"handle install message failed");
/**
* The sections were destroyed inside
* module_wasm_app_handle_install_msg(),
* no need to destroy again.
*/
return false;
}
}
else {
recv_ctx.phase = Phase_AOT_Section_ID;
recv_ctx.size_in_phase = 0;
return true;
}
}
return true;
}
#endif /* end of WASM_ENABLE_AOT != 0 */
fail:
/* Restore the package type */
magic = recv_ctx.message.app_file_magic;
package_type = get_package_type((uint8 *)&magic, sizeof(magic) + 1);
switch (package_type) {
#if WASM_ENABLE_INTERP != 0 || WASM_ENABLE_JIT != 0
case Wasm_Module_Bytecode:
destroy_all_wasm_sections(
recv_ctx.message.app_file.u.bytecode.sections);
break;
#endif
#if WASM_ENABLE_AOT != 0
case Wasm_Module_AoT:
destroy_all_aot_sections(recv_ctx.message.app_file.u.aot.sections);
break;
#endif
default:
break;
}
if (recv_ctx.message.request_url != NULL) {
APP_MGR_FREE(recv_ctx.message.request_url);
recv_ctx.message.request_url = NULL;
}
memset(&recv_ctx, 0, sizeof(recv_ctx));
return false;
}
static bool
module_wasm_app_handle_install_msg(install_wasm_app_msg_t *message)
{
request_t *request = NULL;
bh_message_t msg;
request = (request_t *)APP_MGR_MALLOC(sizeof(request_t));
if (request == NULL)
return false;
memset(request, 0, sizeof(*request));
request->action = message->request_action;
request->fmt = message->request_fmt;
request->url = bh_strdup(message->request_url);
request->sender = ID_HOST;
request->mid = message->request_mid;
request->payload_len = sizeof(message->app_file);
request->payload = APP_MGR_MALLOC(request->payload_len);
if (request->url == NULL || request->payload == NULL) {
request_cleaner(request);
return false;
}
/* Request payload is set to wasm_app_file_t struct,
* but not whole app buffer */
bh_memcpy_s(request->payload, request->payload_len, &message->app_file,
request->payload_len);
/* Since it's a wasm app install request, so directly post to app-mgr's
* queue. The benefit is that section list can be freed when the msg
* failed to post to app-mgr's queue. The defect is missing url check. */
if (!(msg = bh_new_msg(RESTFUL_REQUEST, request, sizeof(*request),
request_cleaner))) {
request_cleaner(request);
return false;
}
if (!bh_post_msg2(get_app_manager_queue(), msg))
return false;
return true;
}
#if WASM_ENABLE_INTERP != 0 || WASM_ENABLE_JIT != 0
static void
destroy_all_wasm_sections(wasm_section_list_t sections)
{
wasm_section_t *cur = sections;
while (cur) {
wasm_section_t *next = cur->next;
if (cur->section_body != NULL)
APP_MGR_FREE(cur->section_body);
APP_MGR_FREE(cur);
cur = next;
}
}
static void
destroy_part_wasm_sections(wasm_section_list_t *p_sections,
uint8 *section_types, int section_cnt)
{
int i;
for (i = 0; i < section_cnt; i++) {
uint8 section_type = section_types[i];
wasm_section_t *cur = *p_sections, *prev = NULL;
while (cur) {
wasm_section_t *next = cur->next;
if (cur->section_type == section_type) {
if (prev)
prev->next = next;
else
*p_sections = next;
if (cur->section_body != NULL)
APP_MGR_FREE(cur->section_body);
APP_MGR_FREE(cur);
break;
}
else {
prev = cur;
cur = next;
}
}
}
}
#endif
#if WASM_ENABLE_AOT != 0
static void
destroy_all_aot_sections(aot_section_list_t sections)
{
aot_section_t *cur = sections;
while (cur) {
aot_section_t *next = cur->next;
if (cur->section_body != NULL) {
if (cur->section_type == AOT_SECTION_TYPE_TEXT)
os_munmap(cur->section_body, cur->section_body_size);
else
APP_MGR_FREE(cur->section_body);
}
APP_MGR_FREE(cur);
cur = next;
}
}
static void
destroy_part_aot_sections(aot_section_list_t *p_sections, uint8 *section_types,
int section_cnt)
{
int i;
for (i = 0; i < section_cnt; i++) {
uint8 section_type = section_types[i];
aot_section_t *cur = *p_sections, *prev = NULL;
while (cur) {
aot_section_t *next = cur->next;
if (cur->section_type == section_type) {
if (prev)
prev->next = next;
else
*p_sections = next;
if (cur->section_body != NULL) {
if (cur->section_type == AOT_SECTION_TYPE_TEXT)
os_munmap(cur->section_body, cur->section_body_size);
else
APP_MGR_FREE(cur->section_body);
}
APP_MGR_FREE(cur);
break;
}
else {
prev = cur;
cur = next;
}
}
}
}
#endif
#if WASM_ENABLE_LIBC_WASI != 0
static char wasi_root_dir[PATH_MAX] = { '.' };
bool
wasm_set_wasi_root_dir(const char *root_dir)
{
char *path, resolved_path[PATH_MAX];
if (!(path = realpath(root_dir, resolved_path)))
return false;
snprintf(wasi_root_dir, sizeof(wasi_root_dir), "%s", path);
return true;
}
const char *
wasm_get_wasi_root_dir()
{
return wasi_root_dir;
}
#endif
Reference in New Issue View Git Blame Copy Permalink