/* * 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 *)§ion->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