gnh1201/wasm-micro-runtime
1
0
Fork 0
mirror of https://github.com/bytecodealliance/wasm-micro-runtime.git synced 2024-11-26 15:32:05 +00:00
Code Issues Actions 14 Packages Projects Releases Wiki Activity

Apply clang-format for core/shared and product-mini files (#785)

Browse Source 
Apply clang-format for core/shared and product-mini files
This commit is contained in:
Wenyong Huang 2021-10-14 09:12:07 +08:00 committed by GitHub
parent fb4afc7ca4
commit 17f62ad472
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
107 changed files with 3436 additions and 2898 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
core/shared/coap/er-coap/coap-constants.h
View File

@ -44,6 +44,7 @@
#ifndef COAP_CONSTANTS_H_
#define COAP_CONSTANTS_H_
/* clang-format off */
#define COAP_DEFAULT_PORT 5683
#define COAP_DEFAULT_SECURE_PORT 5684
@ -65,6 +66,7 @@
#define COAP_HEADER_OPTION_DELTA_MASK 0xF0
#define COAP_HEADER_OPTION_SHORT_LENGTH_MASK 0x0F
/* clang-format on */
/* CoAP message types */
typedef enum {
@ -74,13 +76,14 @@ typedef enum {
COAP_TYPE_RST /* reset */
} coap_message_type_t;
/* clang-format off */
/* CoAP request method codes */
typedef enum {
COAP_GET = 1,
COAP_POST,
COAP_PUT,
COAP_POST, COAP_PUT,
COAP_DELETE
} coap_method_t;
/* clang-format on */
/* CoAP response codes */
typedef enum {
@ -189,4 +192,3 @@ typedef enum {
} coap_resource_flags_t;
#endif /* COAP_CONSTANTS_H_ */
/** @} */

120
core/shared/mem-alloc/ems/ems_alloc.c
View File

@ -5,15 +5,11 @@
#include "ems_gc_internal.h"
static inline bool
hmu_is_in_heap(void *hmu,
gc_uint8 *heap_base_addr,
gc_uint8 *heap_end_addr)
hmu_is_in_heap(void *hmu, gc_uint8 *heap_base_addr, gc_uint8 *heap_end_addr)
{
gc_uint8 *addr = (gc_uint8 *)hmu;
return (addr >= heap_base_addr && addr < heap_end_addr)
? true : false;
return (addr >= heap_base_addr && addr < heap_end_addr) ? true : false;
}
/**
@ -38,8 +34,7 @@ remove_tree_node(gc_heap_t *heap, hmu_tree_node_t *p)
parent = p->parent;
if (!parent || p == root /* p can not be the ROOT node */
|| !hmu_is_in_heap(p, base_addr, end_addr)
|| (parent != root
&& !hmu_is_in_heap(parent, base_addr, end_addr))) {
|| (parent != root && !hmu_is_in_heap(parent, base_addr, end_addr))) {
goto fail;
}
@ -139,8 +134,8 @@ unlink_hmu(gc_heap_t *heap, hmu_t *hmu)
gc_size_t size;
bh_assert(gci_is_heap_valid(heap));
bh_assert(hmu && (gc_uint8*) hmu >= heap->base_addr
&& (gc_uint8*) hmu < heap->base_addr + heap->current_size);
bh_assert(hmu && (gc_uint8 *)hmu >= heap->base_addr
&& (gc_uint8 *)hmu < heap->base_addr + heap->current_size);
if (hmu_get_ut(hmu) != HMU_FC) {
heap->is_heap_corrupted = true;
@ -162,7 +157,7 @@ unlink_hmu(gc_heap_t *heap, hmu_t *hmu)
return false;
}
node_next = get_hmu_normal_node_next(node);
if ((hmu_t*)node == hmu) {
if ((hmu_t *)node == hmu) {
if (!node_prev) /* list head */
heap->kfc_normal_list[node_idx].next = node_next;
else
@ -191,15 +186,15 @@ hmu_set_free_size(hmu_t *hmu)
bh_assert(hmu && hmu_get_ut(hmu) == HMU_FC);
size = hmu_get_size(hmu);
*((uint32*)((char*) hmu + size) - 1) = size;
*((uint32 *)((char *)hmu + size) - 1) = size;
}
/**
* Add free chunk back to KFC
*
* @param heap should not be NULL and it should be a valid heap
* @param hmu should not be NULL and it should be a HMU of length @size inside @heap
* hmu should be 8-bytes aligned
* @param hmu should not be NULL and it should be a HMU of length @size inside
* @heap hmu should be 8-bytes aligned
* @param size should be positive and multiple of 8
* hmu with size @size will be added into KFC as a new FC.
*/
@ -212,11 +207,12 @@ gci_add_fc(gc_heap_t *heap, hmu_t *hmu, gc_size_t size)
uint32 node_idx;
bh_assert(gci_is_heap_valid(heap));
bh_assert(hmu && (gc_uint8*)hmu >= heap->base_addr
&& (gc_uint8*)hmu < heap->base_addr + heap->current_size);
bh_assert(hmu && (gc_uint8 *)hmu >= heap->base_addr
&& (gc_uint8 *)hmu < heap->base_addr + heap->current_size);
bh_assert(((gc_uint32)(uintptr_t)hmu_to_obj(hmu) & 7) == 0);
bh_assert(size > 0
&& ((gc_uint8*)hmu) + size <= heap->base_addr + heap->current_size);
&& ((gc_uint8 *)hmu) + size
<= heap->base_addr + heap->current_size);
bh_assert(!(size & 7));
base_addr = heap->base_addr;
@ -227,7 +223,7 @@ gci_add_fc(gc_heap_t *heap, hmu_t *hmu, gc_size_t size)
hmu_set_free_size(hmu);
if (HMU_IS_FC_NORMAL(size)) {
np = (hmu_normal_node_t*)hmu;
np = (hmu_normal_node_t *)hmu;
if (!hmu_is_in_heap(np, base_addr, end_addr)) {
heap->is_heap_corrupted = true;
return false;
@ -240,7 +236,7 @@ gci_add_fc(gc_heap_t *heap, hmu_t *hmu, gc_size_t size)
}
/* big block*/
node = (hmu_tree_node_t*)hmu;
node = (hmu_tree_node_t *)hmu;
node->size = size;
node->left = node->right = node->parent = NULL;
@ -333,7 +329,7 @@ alloc_hmu(gc_heap_t *heap, gc_size_t size)
if ((gc_size_t)node_idx != (uint32)init_node_idx
/* with bigger size*/
&& ((gc_size_t)node_idx << 3) >= size + GC_SMALLEST_SIZE) {
rest = (hmu_t*) (((char *) p) + size);
rest = (hmu_t *)(((char *)p) + size);
if (!gci_add_fc(heap, rest, (node_idx << 3) - size)) {
return NULL;
}
@ -341,7 +337,7 @@ alloc_hmu(gc_heap_t *heap, gc_size_t size)
}
else {
size = node_idx << 3;
next = (hmu_t*) ((char*) p + size);
next = (hmu_t *)((char *)p + size);
if (hmu_is_in_heap(next, base_addr, end_addr))
hmu_mark_pinuse(next);
}
@ -349,11 +345,11 @@ alloc_hmu(gc_heap_t *heap, gc_size_t size)
heap->total_free_size -= size;
if ((heap->current_size - heap->total_free_size)
> heap->highmark_size)
heap->highmark_size = heap->current_size
- heap->total_free_size;
heap->highmark_size =
heap->current_size - heap->total_free_size;
hmu_set_size((hmu_t* )p, size);
return (hmu_t*)p;
hmu_set_size((hmu_t *)p, size);
return (hmu_t *)p;
}
}
@ -389,14 +385,14 @@ alloc_hmu(gc_heap_t *heap, gc_size_t size)
return NULL;
if (last_tp->size >= size + GC_SMALLEST_SIZE) {
rest = (hmu_t*)((char*)last_tp + size);
rest = (hmu_t *)((char *)last_tp + size);
if (!gci_add_fc(heap, rest, last_tp->size - size))
return NULL;
hmu_mark_pinuse(rest);
}
else {
size = last_tp->size;
next = (hmu_t*)((char*)last_tp + size);
next = (hmu_t *)((char *)last_tp + size);
if (hmu_is_in_heap(next, base_addr, end_addr))
hmu_mark_pinuse(next);
}
@ -405,8 +401,8 @@ alloc_hmu(gc_heap_t *heap, gc_size_t size)
if ((heap->current_size - heap->total_free_size) > heap->highmark_size)
heap->highmark_size = heap->current_size - heap->total_free_size;
hmu_set_size((hmu_t*)last_tp, size);
return (hmu_t*)last_tp;
hmu_set_size((hmu_t *)last_tp, size);
return (hmu_t *)last_tp;
}
return NULL;
@ -444,13 +440,12 @@ gc_object_t
gc_alloc_vo(void *vheap, gc_size_t size)
#else
gc_object_t
gc_alloc_vo_internal(void *vheap, gc_size_t size,
const char *file, int line)
gc_alloc_vo_internal(void *vheap, gc_size_t size, const char *file, int line)
#endif
{
gc_heap_t* heap = (gc_heap_t*) vheap;
gc_heap_t *heap = (gc_heap_t *)vheap;
hmu_t *hmu = NULL;
gc_object_t ret = (gc_object_t) NULL;
gc_object_t ret = (gc_object_t)NULL;
gc_size_t tot_size = 0, tot_size_unaligned;
/* hmu header + prefix + obj + suffix */
@ -489,7 +484,7 @@ gc_alloc_vo_internal(void *vheap, gc_size_t size,
ret = hmu_to_obj(hmu);
if (tot_size > tot_size_unaligned)
/* clear buffer appended by GC_ALIGN_8() */
memset((uint8*)ret + size, 0, tot_size - tot_size_unaligned);
memset((uint8 *)ret + size, 0, tot_size - tot_size_unaligned);
finish:
os_mutex_unlock(&heap->lock);
@ -501,13 +496,13 @@ gc_object_t
gc_realloc_vo(void *vheap, void *ptr, gc_size_t size)
#else
gc_object_t
gc_realloc_vo_internal(void *vheap, void *ptr, gc_size_t size,
const char *file, int line)
gc_realloc_vo_internal(void *vheap, void *ptr, gc_size_t size, const char *file,
int line)
#endif
{
gc_heap_t* heap = (gc_heap_t*) vheap;
gc_heap_t *heap = (gc_heap_t *)vheap;
hmu_t *hmu = NULL, *hmu_old = NULL, *hmu_next;
gc_object_t ret = (gc_object_t) NULL, obj_old = (gc_object_t)ptr;
gc_object_t ret = (gc_object_t)NULL, obj_old = (gc_object_t)ptr;
gc_size_t tot_size, tot_size_unaligned, tot_size_old = 0, tot_size_next;
gc_size_t obj_size, obj_size_old;
gc_uint8 *base_addr, *end_addr;
@ -540,24 +535,24 @@ gc_realloc_vo_internal(void *vheap, void *ptr, gc_size_t size,
os_mutex_lock(&heap->lock);
if (hmu_old) {
hmu_next = (hmu_t*)((char *)hmu_old + tot_size_old);
hmu_next = (hmu_t *)((char *)hmu_old + tot_size_old);
if (hmu_is_in_heap(hmu_next, base_addr, end_addr)) {
ut = hmu_get_ut(hmu_next);
tot_size_next = hmu_get_size(hmu_next);
if (ut == HMU_FC
&& tot_size <= tot_size_old + tot_size_next) {
if (ut == HMU_FC && tot_size <= tot_size_old + tot_size_next) {
/* current node and next node meets requirement */
if (!unlink_hmu(heap, hmu_next)) {
os_mutex_unlock(&heap->lock);
return NULL;
}
hmu_set_size(hmu_old, tot_size);
memset((char*)hmu_old + tot_size_old, 0, tot_size - tot_size_old);
memset((char *)hmu_old + tot_size_old, 0,
tot_size - tot_size_old);
#if BH_ENABLE_GC_VERIFY != 0
hmu_init_prefix_and_suffix(hmu_old, tot_size, file, line);
#endif
if (tot_size < tot_size_old + tot_size_next) {
hmu_next = (hmu_t*)((char*)hmu_old + tot_size);
hmu_next = (hmu_t *)((char *)hmu_old + tot_size);
tot_size_next = tot_size_old + tot_size_next - tot_size;
if (!gci_add_fc(heap, hmu_next, tot_size_next)) {
os_mutex_unlock(&heap->lock);
@ -570,7 +565,6 @@ gc_realloc_vo_internal(void *vheap, void *ptr, gc_size_t size,
}
}
hmu = alloc_hmu_ex(heap, tot_size);
if (!hmu)
goto finish;
@ -596,8 +590,8 @@ finish:
obj_size = tot_size - HMU_SIZE - OBJ_PREFIX_SIZE - OBJ_SUFFIX_SIZE;
memset(ret, 0, obj_size);
if (obj_old) {
obj_size_old = tot_size_old - HMU_SIZE
- OBJ_PREFIX_SIZE - OBJ_SUFFIX_SIZE;
obj_size_old =
tot_size_old - HMU_SIZE - OBJ_PREFIX_SIZE - OBJ_SUFFIX_SIZE;
bh_memcpy_s(ret, obj_size, obj_old, obj_size_old);
}
}
@ -619,7 +613,7 @@ gci_is_heap_valid(gc_heap_t *heap)
{
if (!heap)
return GC_FALSE;
if (heap->heap_id != (gc_handle_t) heap)
if (heap->heap_id != (gc_handle_t)heap)
return GC_FALSE;
return GC_TRUE;
@ -630,11 +624,10 @@ int
gc_free_vo(void *vheap, gc_object_t obj)
#else
int
gc_free_vo_internal(void *vheap, gc_object_t obj,
const char *file, int line)
gc_free_vo_internal(void *vheap, gc_object_t obj, const char *file, int line)
#endif
{
gc_heap_t* heap = (gc_heap_t*) vheap;
gc_heap_t *heap = (gc_heap_t *)vheap;
gc_uint8 *base_addr, *end_addr;
hmu_t *hmu = NULL;
hmu_t *prev = NULL;
@ -678,7 +671,7 @@ gc_free_vo_internal(void *vheap, gc_object_t obj,
heap->total_free_size += size;
if (!hmu_get_pinuse(hmu)) {
prev = (hmu_t*) ((char*) hmu - *((int*) hmu - 1));
prev = (hmu_t *)((char *)hmu - *((int *)hmu - 1));
if (hmu_is_in_heap(prev, base_addr, end_addr)
&& hmu_get_ut(prev) == HMU_FC) {
@ -691,7 +684,7 @@ gc_free_vo_internal(void *vheap, gc_object_t obj,
}
}
next = (hmu_t*) ((char*) hmu + size);
next = (hmu_t *)((char *)hmu + size);
if (hmu_is_in_heap(next, base_addr, end_addr)) {
if (hmu_get_ut(next) == HMU_FC) {
size += hmu_get_size(next);
@ -699,7 +692,7 @@ gc_free_vo_internal(void *vheap, gc_object_t obj,
ret = GC_ERROR;
goto out;
}
next = (hmu_t*)((char*) hmu + size);
next = (hmu_t *)((char *)hmu + size);
}
}
@ -711,8 +704,8 @@ gc_free_vo_internal(void *vheap, gc_object_t obj,
if (hmu_is_in_heap(next, base_addr, end_addr)) {
hmu_unmark_pinuse(next);
}
} else {
}
else {
ret = GC_ERROR;
goto out;
}
@ -750,14 +743,14 @@ gci_dump(gc_heap_t *heap)
int i = 0, p, mark;
char inuse = 'U';
cur = (hmu_t*)heap->base_addr;
end = (hmu_t*)((char*)heap->base_addr + heap->current_size);
cur = (hmu_t *)heap->base_addr;
end = (hmu_t *)((char *)heap->base_addr + heap->current_size);
while(cur < end) {
while (cur < end) {
ut = hmu_get_ut(cur);
size = hmu_get_size(cur);
p = hmu_get_pinuse(cur);
mark = hmu_is_jo_marked (cur);
mark = hmu_is_jo_marked(cur);
if (ut == HMU_VO)
inuse = 'V';
@ -772,9 +765,9 @@ gci_dump(gc_heap_t *heap)
return;
}
os_printf("#%d %08x %x %x %d %c %d\n",
i, (int32)((char*) cur - (char*) heap->base_addr),
ut, p, mark, inuse, (int32)hmu_obj_size(size));
os_printf("#%d %08x %x %x %d %c %d\n", i,
(int32)((char *)cur - (char *)heap->base_addr), ut, p, mark,
inuse, (int32)hmu_obj_size(size));
#if BH_ENABLE_GC_VERIFY != 0
if (inuse == 'V') {
gc_object_prefix_t *prefix = (gc_object_prefix_t *)(cur + 1);
@ -782,10 +775,9 @@ gci_dump(gc_heap_t *heap)
}
#endif
cur = (hmu_t*)((char *)cur + size);
cur = (hmu_t *)((char *)cur + size);
i++;
}
bh_assert(cur == end);
}

24
core/shared/mem-alloc/ems/ems_gc.h
View File

@ -8,8 +8,6 @@
* @date Wed Aug 3 10:46:38 2011
*
* @brief This file defines GC modules types and interfaces.
*
*
*/
#ifndef _EMS_GC_H
@ -33,8 +31,8 @@ extern "C" {
#define GC_MAX_HEAP_SIZE (256 * BH_KB)
typedef void * gc_handle_t;
typedef void * gc_object_t;
typedef void *gc_handle_t;
typedef void *gc_object_t;
typedef int64 gc_int64;
typedef uint32 gc_uint32;
typedef int32 gc_int32;
@ -105,8 +103,7 @@ gc_get_heap_struct_size(void);
* @return GC_SUCCESS if success, GC_ERROR otherwise
*/
int
gc_migrate(gc_handle_t handle,
char *pool_buf_new, gc_size_t pool_buf_size);
gc_migrate(gc_handle_t handle, char *pool_buf_new, gc_size_t pool_buf_size);
/**
* Check whether the heap is corrupted
@ -126,7 +123,7 @@ gc_is_heap_corrupted(gc_handle_t handle);
* @param mmt [in] type of heap, MMT_SHARED or MMT_INSTANCE
*/
void *
gc_heap_stats(void *heap, uint32* stats, int size);
gc_heap_stats(void *heap, uint32 *stats, int size);
#if BH_ENABLE_GC_VERIFY == 0
@ -142,17 +139,16 @@ gc_free_vo(void *heap, gc_object_t obj);
#else /* else of BH_ENABLE_GC_VERIFY */
gc_object_t
gc_alloc_vo_internal(void *heap, gc_size_t size,
const char *file, int line);
gc_alloc_vo_internal(void *heap, gc_size_t size, const char *file, int line);
gc_object_t
gc_realloc_vo_internal(void *heap, void *ptr, gc_size_t size,
const char *file, int line);
gc_realloc_vo_internal(void *heap, void *ptr, gc_size_t size, const char *file,
int line);
int
gc_free_vo_internal(void *heap, gc_object_t obj,
const char *file, int line);
gc_free_vo_internal(void *heap, gc_object_t obj, const char *file, int line);
/* clang-format off */
#define gc_alloc_vo(heap, size) \
gc_alloc_vo_internal(heap, size, __FILE__, __LINE__)
@ -161,6 +157,7 @@ gc_free_vo_internal(void *heap, gc_object_t obj,
#define gc_free_vo(heap, obj) \
gc_free_vo_internal(heap, obj, __FILE__, __LINE__)
/* clang-format on */
#endif /* end of BH_ENABLE_GC_VERIFY */
@ -169,4 +166,3 @@ gc_free_vo_internal(void *heap, gc_object_t obj,
#endif
#endif

74
core/shared/mem-alloc/ems/ems_gc_internal.h
View File

@ -60,8 +60,8 @@ hmu_init_prefix_and_suffix(hmu_t *hmu, gc_size_t tot_size,
void
hmu_verify(void *vheap, hmu_t *hmu);
#define SKIP_OBJ_PREFIX(p) ((void*)((gc_uint8*)(p) + OBJ_PREFIX_SIZE))
#define SKIP_OBJ_SUFFIX(p) ((void*)((gc_uint8*)(p) + OBJ_SUFFIX_SIZE))
#define SKIP_OBJ_PREFIX(p) ((void *)((gc_uint8 *)(p) + OBJ_PREFIX_SIZE))
#define SKIP_OBJ_SUFFIX(p) ((void *)((gc_uint8 *)(p) + OBJ_SUFFIX_SIZE))
#define OBJ_EXTRA_SIZE (HMU_SIZE + OBJ_PREFIX_SIZE + OBJ_SUFFIX_SIZE)
@ -70,8 +70,8 @@ hmu_verify(void *vheap, hmu_t *hmu);
#define OBJ_PREFIX_SIZE 0
#define OBJ_SUFFIX_SIZE 0
#define SKIP_OBJ_PREFIX(p) ((void*)((gc_uint8*)(p) + OBJ_PREFIX_SIZE))
#define SKIP_OBJ_SUFFIX(p) ((void*)((gc_uint8*)(p) + OBJ_SUFFIX_SIZE))
#define SKIP_OBJ_PREFIX(p) ((void *)((gc_uint8 *)(p) + OBJ_PREFIX_SIZE))
#define SKIP_OBJ_SUFFIX(p) ((void *)((gc_uint8 *)(p) + OBJ_SUFFIX_SIZE))
#define OBJ_EXTRA_SIZE (HMU_SIZE + OBJ_PREFIX_SIZE + OBJ_SUFFIX_SIZE)
@ -81,8 +81,11 @@ hmu_verify(void *vheap, hmu_t *hmu);
#define GC_ALIGN_8(s) (((uint32)(s) + 7) & (uint32)~7)
#define GC_SMALLEST_SIZE GC_ALIGN_8(HMU_SIZE + OBJ_PREFIX_SIZE + OBJ_SUFFIX_SIZE + 8)
#define GC_GET_REAL_SIZE(x) GC_ALIGN_8(HMU_SIZE + OBJ_PREFIX_SIZE + OBJ_SUFFIX_SIZE + (((x) > 8) ? (x): 8))
#define GC_SMALLEST_SIZE \
GC_ALIGN_8(HMU_SIZE + OBJ_PREFIX_SIZE + OBJ_SUFFIX_SIZE + 8)
#define GC_GET_REAL_SIZE(x) \
GC_ALIGN_8(HMU_SIZE + OBJ_PREFIX_SIZE + OBJ_SUFFIX_SIZE \
+ (((x) > 8) ? (x) : 8))
/**
* hmu bit operation
@ -92,12 +95,17 @@ hmu_verify(void *vheap, hmu_t *hmu);
#define GETBIT(v, offset) ((v) & ((uint32)1 << (offset)) ? 1 : 0)
#define CLRBIT(v, offset) (v) &= (~((uint32)1 << (offset)))
#define SETBITS(v, offset, size, value) do { \
/* clang-format off */
#define SETBITS(v, offset, size, value) \
do { \
(v) &= ~((((uint32)1 << size) - 1) << offset); \
(v) |= ((uint32)value << offset); \
} while(0)
#define CLRBITS(v, offset, size) (v) &= ~((((uint32)1 << size) - 1) << offset)
#define GETBITS(v, offset, size) (((v) & (((((uint32)1 << size) - 1) << offset))) >> offset)
} while (0)
#define CLRBITS(v, offset, size) \
(v) &= ~((((uint32)1 << size) - 1) << offset)
#define GETBITS(v, offset, size) \
(((v) & (((((uint32)1 << size) - 1) << offset))) >> offset)
/* clang-format on */
/**
* gc object layout definition
@ -105,30 +113,35 @@ hmu_verify(void *vheap, hmu_t *hmu);
#define HMU_SIZE (sizeof(hmu_t))
#define hmu_to_obj(hmu) (gc_object_t)(SKIP_OBJ_PREFIX((hmu_t*) (hmu) + 1))
#define obj_to_hmu(obj) ((hmu_t *)((gc_uint8*)(obj) - OBJ_PREFIX_SIZE) - 1)
#define hmu_to_obj(hmu) (gc_object_t)(SKIP_OBJ_PREFIX((hmu_t *)(hmu) + 1))
#define obj_to_hmu(obj) ((hmu_t *)((gc_uint8 *)(obj)-OBJ_PREFIX_SIZE) - 1)
#define HMU_UT_SIZE 2
#define HMU_UT_OFFSET 30
#define hmu_get_ut(hmu) GETBITS ((hmu)->header, HMU_UT_OFFSET, HMU_UT_SIZE)
#define hmu_set_ut(hmu, type) SETBITS ((hmu)->header, HMU_UT_OFFSET, HMU_UT_SIZE, type)
#define hmu_is_ut_valid(tp) (tp >= HMU_TYPE_MIN && tp <= HMU_TYPE_MAX)
/* clang-format off */
#define hmu_get_ut(hmu) \
GETBITS((hmu)->header, HMU_UT_OFFSET, HMU_UT_SIZE)
#define hmu_set_ut(hmu, type) \
SETBITS((hmu)->header, HMU_UT_OFFSET, HMU_UT_SIZE, type)
#define hmu_is_ut_valid(tp) \
(tp >= HMU_TYPE_MIN && tp <= HMU_TYPE_MAX)
/* clang-format on */
/* P in use bit means the previous chunk is in use */
#define HMU_P_OFFSET 29
#define hmu_mark_pinuse(hmu) SETBIT ((hmu)->header, HMU_P_OFFSET)
#define hmu_unmark_pinuse(hmu) CLRBIT ((hmu)->header, HMU_P_OFFSET)
#define hmu_get_pinuse(hmu) GETBIT ((hmu)->header, HMU_P_OFFSET)
#define hmu_mark_pinuse(hmu) SETBIT((hmu)->header, HMU_P_OFFSET)
#define hmu_unmark_pinuse(hmu) CLRBIT((hmu)->header, HMU_P_OFFSET)
#define hmu_get_pinuse(hmu) GETBIT((hmu)->header, HMU_P_OFFSET)
#define HMU_JO_VT_SIZE 27
#define HMU_JO_VT_OFFSET 0
#define HMU_JO_MB_OFFSET 28
#define hmu_mark_jo(hmu) SETBIT ((hmu)->header, HMU_JO_MB_OFFSET)
#define hmu_unmark_jo(hmu) CLRBIT ((hmu)->header, HMU_JO_MB_OFFSET)
#define hmu_is_jo_marked(hmu) GETBIT ((hmu)->header, HMU_JO_MB_OFFSET)
#define hmu_mark_jo(hmu) SETBIT((hmu)->header, HMU_JO_MB_OFFSET)
#define hmu_unmark_jo(hmu) CLRBIT((hmu)->header, HMU_JO_MB_OFFSET)
#define hmu_is_jo_marked(hmu) GETBIT((hmu)->header, HMU_JO_MB_OFFSET)
/**
* The hmu size is divisible by 8, its lowest 3 bits are 0, so we only
@ -141,11 +154,13 @@ hmu_verify(void *vheap, hmu_t *hmu);
#define HMU_VO_FB_OFFSET 28
#define hmu_is_vo_freed(hmu) GETBIT ((hmu)->header, HMU_VO_FB_OFFSET)
#define hmu_unfree_vo(hmu) CLRBIT ((hmu)->header, HMU_VO_FB_OFFSET)
#define hmu_is_vo_freed(hmu) GETBIT((hmu)->header, HMU_VO_FB_OFFSET)
#define hmu_unfree_vo(hmu) CLRBIT((hmu)->header, HMU_VO_FB_OFFSET)
#define hmu_get_size(hmu) (GETBITS ((hmu)->header, HMU_SIZE_OFFSET, HMU_SIZE_SIZE) << 3)
#define hmu_set_size(hmu, size) SETBITS ((hmu)->header, HMU_SIZE_OFFSET, HMU_SIZE_SIZE, ((size) >> 3))
#define hmu_get_size(hmu) \
(GETBITS((hmu)->header, HMU_SIZE_OFFSET, HMU_SIZE_SIZE) << 3)
#define hmu_set_size(hmu, size) \
SETBITS((hmu)->header, HMU_SIZE_OFFSET, HMU_SIZE_SIZE, ((size) >> 3))
/**
* HMU free chunk management
@ -173,7 +188,7 @@ static inline hmu_normal_node_t *
get_hmu_normal_node_next(hmu_normal_node_t *node)
{
return node->next_offset
? (hmu_normal_node_t *)((uint8*)node + node->next_offset)
? (hmu_normal_node_t *)((uint8 *)node + node->next_offset)
: NULL;
}
@ -181,9 +196,8 @@ static inline void
set_hmu_normal_node_next(hmu_normal_node_t *node, hmu_normal_node_t *next)
{
if (next) {
bh_assert((uint8*)next - (uint8*)node < INT32_MAX);
node->next_offset = (gc_int32)(intptr_t)
((uint8*)next - (uint8*)node);
bh_assert((uint8 *)next - (uint8 *)node < INT32_MAX);
node->next_offset = (gc_int32)(intptr_t)((uint8 *)next - (uint8 *)node);
}
else {
node->next_offset = 0;
@ -247,4 +261,4 @@ gci_dump(gc_heap_t *heap);
}
#endif
#endif
#endif /* end of _EMS_GC_INTERNAL_H */

18
core/shared/mem-alloc/ems/ems_hmu.c
View File

@ -11,8 +11,8 @@
* Set default value to prefix and suffix
* @param hmu should not be NULL and should have been correctly initilized
* (except prefix and suffix part)
* @param tot_size is offered here because hmu_get_size can not be used till now.
* tot_size should not be smaller than OBJ_EXTRA_SIZE.
* @param tot_size is offered here because hmu_get_size can not be used
* till now. tot_size should not be smaller than OBJ_EXTRA_SIZE.
* For VO, tot_size should be equal to object total size.
*/
void
@ -30,16 +30,17 @@ hmu_init_prefix_and_suffix(hmu_t *hmu, gc_size_t tot_size,
bh_assert(hmu_get_ut(hmu) != HMU_VO || hmu_get_size(hmu) >= tot_size);
prefix = (gc_object_prefix_t *)(hmu + 1);
suffix = (gc_object_suffix_t *)((gc_uint8*)hmu + tot_size - OBJ_SUFFIX_SIZE);
suffix =
(gc_object_suffix_t *)((gc_uint8 *)hmu + tot_size - OBJ_SUFFIX_SIZE);
prefix->file_name = file_name;
prefix->line_no = line_no;
prefix->size = tot_size;
for(i = 0;i < GC_OBJECT_PREFIX_PADDING_CNT;i++) {
for (i = 0; i < GC_OBJECT_PREFIX_PADDING_CNT; i++) {
prefix->padding[i] = GC_OBJECT_PADDING_VALUE;
}
for(i = 0;i < GC_OBJECT_SUFFIX_PADDING_CNT;i++) {
for (i = 0; i < GC_OBJECT_SUFFIX_PADDING_CNT; i++) {
suffix->padding[i] = GC_OBJECT_PADDING_VALUE;
}
}
@ -61,17 +62,17 @@ hmu_verify(void *vheap, hmu_t *hmu)
prefix = (gc_object_prefix_t *)(hmu + 1);
size = prefix->size;
suffix = (gc_object_suffix_t *)((gc_uint8*)hmu + size - OBJ_SUFFIX_SIZE);
suffix = (gc_object_suffix_t *)((gc_uint8 *)hmu + size - OBJ_SUFFIX_SIZE);
if (ut == HMU_VO || ut == HMU_JO) {
/* check padding*/
for (i = 0;i < GC_OBJECT_PREFIX_PADDING_CNT;i++) {
for (i = 0; i < GC_OBJECT_PREFIX_PADDING_CNT; i++) {
if (prefix->padding[i] != GC_OBJECT_PADDING_VALUE) {
is_padding_ok = 0;
break;
}
}
for (i = 0;i < GC_OBJECT_SUFFIX_PADDING_CNT;i++) {
for (i = 0; i < GC_OBJECT_SUFFIX_PADDING_CNT; i++) {
if (suffix->padding[i] != GC_OBJECT_PADDING_VALUE) {
is_padding_ok = 0;
break;
@ -88,4 +89,3 @@ hmu_verify(void *vheap, hmu_t *hmu)
}
#endif /* end of BH_ENABLE_GC_VERIFY */

72
core/shared/mem-alloc/ems/ems_kfc.c
View File

@ -22,7 +22,7 @@ gc_init_internal(gc_heap_t *heap, char *base_addr, gc_size_t heap_max_size)
/* init all data structures*/
heap->current_size = heap_max_size;
heap->base_addr = (gc_uint8*)base_addr;
heap->base_addr = (gc_uint8 *)base_addr;
heap->heap_id = (gc_handle_t)heap;
heap->total_free_size = heap->current_size;
@ -34,7 +34,7 @@ gc_init_internal(gc_heap_t *heap, char *base_addr, gc_size_t heap_max_size)
hmu_set_ut(&root->hmu_header, HMU_FC);
hmu_set_size(&root->hmu_header, sizeof *root);
q = (hmu_tree_node_t *) heap->base_addr;
q = (hmu_tree_node_t *)heap->base_addr;
memset(q, 0, sizeof *q);
hmu_set_ut(&q->hmu_header, HMU_FC);
hmu_set_size(&q->hmu_header, heap->current_size);
@ -53,18 +53,19 @@ gc_handle_t
gc_init_with_pool(char *buf, gc_size_t buf_size)
{
char *buf_end = buf + buf_size;
char *buf_aligned = (char*)(((uintptr_t) buf + 7) & (uintptr_t)~7);
char *buf_aligned = (char *)(((uintptr_t)buf + 7) & (uintptr_t)~7);
char *base_addr = buf_aligned + sizeof(gc_heap_t);
gc_heap_t *heap = (gc_heap_t*)buf_aligned;
gc_heap_t *heap = (gc_heap_t *)buf_aligned;
gc_size_t heap_max_size;
if (buf_size < APP_HEAP_SIZE_MIN) {
os_printf("[GC_ERROR]heap init buf size (%u) < %u\n",
buf_size, APP_HEAP_SIZE_MIN);
os_printf("[GC_ERROR]heap init buf size (%u) < %u\n", buf_size,
APP_HEAP_SIZE_MIN);
return NULL;
}
base_addr = (char*) (((uintptr_t) base_addr + 7) & (uintptr_t)~7) + GC_HEAD_PADDING;
base_addr =
(char *)(((uintptr_t)base_addr + 7) & (uintptr_t)~7) + GC_HEAD_PADDING;
heap_max_size = (uint32)(buf_end - base_addr) & (uint32)~7;
#if WASM_ENABLE_MEMORY_TRACING != 0
@ -81,7 +82,7 @@ gc_handle_t
gc_init_with_struct_and_pool(char *struct_buf, gc_size_t struct_buf_size,
char *pool_buf, gc_size_t pool_buf_size)
{
gc_heap_t *heap = (gc_heap_t*)struct_buf;
gc_heap_t *heap = (gc_heap_t *)struct_buf;
char *base_addr = pool_buf + GC_HEAD_PADDING;
char *pool_buf_end = pool_buf + pool_buf_size;
gc_size_t heap_max_size;
@ -103,8 +104,8 @@ gc_init_with_struct_and_pool(char *struct_buf, gc_size_t struct_buf_size,
}
if (pool_buf_size < APP_HEAP_SIZE_MIN) {
os_printf("[GC_ERROR]heap init buf size (%u) < %u\n",
pool_buf_size, APP_HEAP_SIZE_MIN);
os_printf("[GC_ERROR]heap init buf size (%u) < %u\n", pool_buf_size,
APP_HEAP_SIZE_MIN);
return NULL;
}
@ -115,8 +116,7 @@ gc_init_with_struct_and_pool(char *struct_buf, gc_size_t struct_buf_size,
struct_buf_size + pool_buf_size);
os_printf(" heap struct size: %u\n", sizeof(gc_heap_t));
os_printf(" actual heap size: %u\n", heap_max_size);
os_printf(" padding bytes: %u\n",
pool_buf_size - heap_max_size);
os_printf(" padding bytes: %u\n", pool_buf_size - heap_max_size);
#endif
return gc_init_internal(heap, base_addr, heap_max_size);
}
@ -124,16 +124,17 @@ gc_init_with_struct_and_pool(char *struct_buf, gc_size_t struct_buf_size,
int
gc_destroy_with_pool(gc_handle_t handle)
{
gc_heap_t *heap = (gc_heap_t *) handle;
gc_heap_t *heap = (gc_heap_t *)handle;
#if BH_ENABLE_GC_VERIFY != 0
hmu_t *cur = (hmu_t*)heap->base_addr;
hmu_t *end = (hmu_t*)((char*)heap->base_addr + heap->current_size);
hmu_t *cur = (hmu_t *)heap->base_addr;
hmu_t *end = (hmu_t *)((char *)heap->base_addr + heap->current_size);
if (!heap->is_heap_corrupted
&& (hmu_t*)((char *)cur + hmu_get_size(cur)) != end) {
&& (hmu_t *)((char *)cur + hmu_get_size(cur)) != end) {
os_printf("Memory leak detected:\n");
gci_dump(heap);
#if WASM_ENABLE_SPEC_TEST != 0
while (1);
while (1) {
}
#endif
}
#endif
@ -157,13 +158,12 @@ adjust_ptr(uint8 **p_ptr, intptr_t offset)
}
int
gc_migrate(gc_handle_t handle,
char *pool_buf_new, gc_size_t pool_buf_size)
gc_migrate(gc_handle_t handle, char *pool_buf_new, gc_size_t pool_buf_size)
{
gc_heap_t *heap = (gc_heap_t *)handle;
char *base_addr_new = pool_buf_new + GC_HEAD_PADDING;
char *pool_buf_end = pool_buf_new + pool_buf_size;
intptr_t offset = (uint8*)base_addr_new - (uint8*)heap->base_addr;
intptr_t offset = (uint8 *)base_addr_new - (uint8 *)heap->base_addr;
hmu_t *cur = NULL, *end = NULL;
hmu_tree_node_t *tree_node;
gc_size_t heap_max_size, size;
@ -175,8 +175,7 @@ gc_migrate(gc_handle_t handle,
heap_max_size = (uint32)(pool_buf_end - base_addr_new) & (uint32)~7;
if (pool_buf_end < base_addr_new
|| heap_max_size < heap->current_size) {
if (pool_buf_end < base_addr_new || heap_max_size < heap->current_size) {
os_printf("[GC_ERROR]heap migrate invlaid pool buf size\n");
return GC_ERROR;
}
@ -184,13 +183,13 @@ gc_migrate(gc_handle_t handle,
if (offset == 0)
return 0;
heap->base_addr = (uint8*)base_addr_new;
adjust_ptr((uint8**)&heap->kfc_tree_root.left, offset);
adjust_ptr((uint8**)&heap->kfc_tree_root.right, offset);
adjust_ptr((uint8**)&heap->kfc_tree_root.parent, offset);
heap->base_addr = (uint8 *)base_addr_new;
adjust_ptr((uint8 **)&heap->kfc_tree_root.left, offset);
adjust_ptr((uint8 **)&heap->kfc_tree_root.right, offset);
adjust_ptr((uint8 **)&heap->kfc_tree_root.parent, offset);
cur = (hmu_t*)heap->base_addr;
end = (hmu_t*)((char*)heap->base_addr + heap->current_size);
cur = (hmu_t *)heap->base_addr;
end = (hmu_t *)((char *)heap->base_addr + heap->current_size);
while (cur < end) {
size = hmu_get_size(cur);
@ -198,14 +197,14 @@ gc_migrate(gc_handle_t handle,
if (hmu_get_ut(cur) == HMU_FC && !HMU_IS_FC_NORMAL(size)) {
tree_node = (hmu_tree_node_t *)cur;
adjust_ptr((uint8**)&tree_node->left, offset);
adjust_ptr((uint8**)&tree_node->right, offset);
adjust_ptr((uint8 **)&tree_node->left, offset);
adjust_ptr((uint8 **)&tree_node->right, offset);
if (tree_node->parent != &heap->kfc_tree_root)
/* The root node belongs to heap structure,
it is fixed part and isn't changed. */
adjust_ptr((uint8**)&tree_node->parent, offset);
adjust_ptr((uint8 **)&tree_node->parent, offset);
}
cur = (hmu_t*)((char *)cur + size);
cur = (hmu_t *)((char *)cur + size);
}
bh_assert(cur == end);
@ -229,19 +228,19 @@ gci_verify_heap(gc_heap_t *heap)
bh_assert(heap && gci_is_heap_valid(heap));
cur = (hmu_t *)heap->base_addr;
end = (hmu_t *)(heap->base_addr + heap->current_size);
while(cur < end) {
while (cur < end) {
hmu_verify(heap, cur);
cur = (hmu_t *)((gc_uint8*)cur + hmu_get_size(cur));
cur = (hmu_t *)((gc_uint8 *)cur + hmu_get_size(cur));
}
bh_assert(cur == end);
}
#endif
void *
gc_heap_stats(void *heap_arg, uint32* stats, int size)
gc_heap_stats(void *heap_arg, uint32 *stats, int size)
{
int i;
gc_heap_t *heap = (gc_heap_t *) heap_arg;
gc_heap_t *heap = (gc_heap_t *)heap_arg;
for (i = 0; i < size; i++) {
switch (i) {
@ -260,4 +259,3 @@ gc_heap_stats(void *heap_arg, uint32* stats, int size)
}
return heap;
}

50
core/shared/mem-alloc/mem_alloc.c
View File

@ -9,9 +9,10 @@
#include "ems/ems_gc.h"
mem_allocator_t mem_allocator_create(void *mem, uint32_t size)
mem_allocator_t
mem_allocator_create(void *mem, uint32_t size)
{
return gc_init_with_pool((char *) mem, size);
return gc_init_with_pool((char *)mem, size);
}
mem_allocator_t
@ -20,15 +21,14 @@ mem_allocator_create_with_struct_and_pool(void *struct_buf,
void *pool_buf,
uint32_t pool_buf_size)
{
return gc_init_with_struct_and_pool((char *)struct_buf,
struct_buf_size,
pool_buf,
pool_buf_size);
return gc_init_with_struct_and_pool((char *)struct_buf, struct_buf_size,
pool_buf, pool_buf_size);
}
void mem_allocator_destroy(mem_allocator_t allocator)
void
mem_allocator_destroy(mem_allocator_t allocator)
{
gc_destroy_with_pool((gc_handle_t) allocator);
gc_destroy_with_pool((gc_handle_t)allocator);
}
uint32
@ -40,33 +40,33 @@ mem_allocator_get_heap_struct_size()
void *
mem_allocator_malloc(mem_allocator_t allocator, uint32_t size)
{
return gc_alloc_vo((gc_handle_t) allocator, size);
return gc_alloc_vo((gc_handle_t)allocator, size);
}
void *
mem_allocator_realloc(mem_allocator_t allocator, void *ptr, uint32_t size)
{
return gc_realloc_vo((gc_handle_t) allocator, ptr, size);
return gc_realloc_vo((gc_handle_t)allocator, ptr, size);
}
void mem_allocator_free(mem_allocator_t allocator, void *ptr)
void
mem_allocator_free(mem_allocator_t allocator, void *ptr)
{
if (ptr)
gc_free_vo((gc_handle_t) allocator, ptr);
gc_free_vo((gc_handle_t)allocator, ptr);
}
int
mem_allocator_migrate(mem_allocator_t allocator,
char *pool_buf_new, uint32 pool_buf_size)
mem_allocator_migrate(mem_allocator_t allocator, char *pool_buf_new,
uint32 pool_buf_size)
{
return gc_migrate((gc_handle_t) allocator,
pool_buf_new, pool_buf_size);
return gc_migrate((gc_handle_t)allocator, pool_buf_new, pool_buf_size);
}
bool
mem_allocator_is_heap_corrupted(mem_allocator_t allocator)
{
return gc_is_heap_corrupted((gc_handle_t) allocator);
return gc_is_heap_corrupted((gc_handle_t)allocator);
}
#else /* else of DEFAULT_MEM_ALLOCATOR */
@ -76,14 +76,14 @@ mem_allocator_is_heap_corrupted(mem_allocator_t allocator)
typedef struct mem_allocator_tlsf {
tlsf_t tlsf;
korp_mutex lock;
}mem_allocator_tlsf;
} mem_allocator_tlsf;
mem_allocator_t
mem_allocator_create(void *mem, uint32_t size)
{
mem_allocator_tlsf *allocator_tlsf;
tlsf_t tlsf;
char *mem_aligned = (char*)(((uintptr_t)mem + 3) & ~3);
char *mem_aligned = (char *)(((uintptr_t)mem + 3) & ~3);
if (size < 1024) {
printf("Create mem allocator failed: pool size must be "
@ -91,8 +91,8 @@ mem_allocator_create(void *mem, uint32_t size)
return NULL;
}
size -= mem_aligned - (char*)mem;
mem = (void*)mem_aligned;
size -= mem_aligned - (char *)mem;
mem = (void *)mem_aligned;
tlsf = tlsf_create_with_pool(mem, size);
if (!tlsf) {
@ -174,12 +174,10 @@ mem_allocator_free(mem_allocator_t allocator, void *ptr)
}
int
mem_allocator_migrate(mem_allocator_t allocator,
mem_allocator_t allocator_old)
mem_allocator_migrate(mem_allocator_t allocator, mem_allocator_t allocator_old)
{
return tlsf_migrate((mem_allocator_tlsf *) allocator,
(mem_allocator_tlsf *) allocator_old);
return tlsf_migrate((mem_allocator_tlsf *)allocator,
(mem_allocator_tlsf *)allocator_old);
}
#endif /* end of DEFAULT_MEM_ALLOCATOR */

5
core/shared/mem-alloc/mem_alloc.h
View File

@ -39,8 +39,8 @@ void
mem_allocator_free(mem_allocator_t allocator, void *ptr);
int
mem_allocator_migrate(mem_allocator_t allocator,
char *pool_buf_new, uint32 pool_buf_size);
mem_allocator_migrate(mem_allocator_t allocator, char *pool_buf_new,
uint32 pool_buf_size);
bool
mem_allocator_is_heap_corrupted(mem_allocator_t allocator);
@ -50,4 +50,3 @@ mem_allocator_is_heap_corrupted(mem_allocator_t allocator);
#endif
#endif /* #ifndef __MEM_ALLOC_H */

6
core/shared/platform/alios/alios_platform.c
View File

@ -38,8 +38,7 @@ os_realloc(void *ptr, unsigned size)
void
os_free(void *ptr)
{
}
{}
void *
os_mmap(void *hint, size_t size, int prot, int flags)
@ -63,5 +62,4 @@ os_mprotect(void *addr, size_t size, int prot)
void
os_dcache_flush()
{
}
{}

29
core/shared/platform/alios/alios_thread.c
View File

@ -6,6 +6,7 @@
#include "platform_api_vmcore.h"
#include "platform_api_extension.h"
/* clang-format off */
#define bh_assert(v) do { \
if (!(v)) { \
printf("\nASSERTION FAILED: %s, at %s, line %d\n", \
@ -13,7 +14,8 @@
aos_reboot(); \
while (1); \
} \
} while (0)
} while (0)
/* clang-format on */
struct os_thread_data;
typedef struct os_thread_wait_node {
@ -138,8 +140,8 @@ os_thread_wrapper(void *arg)
}
int
os_thread_create(korp_tid *p_tid, thread_start_routine_t start,
void *arg, unsigned int stack_size)
os_thread_create(korp_tid *p_tid, thread_start_routine_t start, void *arg,
unsigned int stack_size)
{
return os_thread_create_with_prio(p_tid, start, arg, stack_size,
BH_THREAD_DEFAULT_PRIORITY);
@ -170,13 +172,12 @@ os_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
if (aos_mutex_new(&thread_data->wait_list_lock))
goto fail2;
snprintf(thread_name, sizeof(thread_name), "%s%d",
"wasm-thread-", ++thread_name_index);
snprintf(thread_name, sizeof(thread_name), "%s%d", "wasm-thread-",
++thread_name_index);
/* Create the thread */
if (aos_task_new_ext((aos_task_t*)thread_data, thread_name,
os_thread_wrapper, thread_data,
stack_size, prio))
if (aos_task_new_ext((aos_task_t *)thread_data, thread_name,
os_thread_wrapper, thread_data, stack_size, prio))
goto fail3;
aos_msleep(10);
@ -199,7 +200,7 @@ os_self_thread()
}
int
os_thread_join (korp_tid thread, void **value_ptr)
os_thread_join(korp_tid thread, void **value_ptr)
{
(void)value_ptr;
os_thread_data *thread_data, *curr_thread_data;
@ -209,7 +210,7 @@ os_thread_join (korp_tid thread, void **value_ptr)
curr_thread_data->wait_node.next = NULL;
/* Get thread data */
thread_data = (os_thread_data*)thread;
thread_data = (os_thread_data *)thread;
aos_mutex_lock(&thread_data->wait_list_lock, AOS_WAIT_FOREVER);
if (!thread_data->thread_wait_list)
@ -272,8 +273,8 @@ os_cond_destroy(korp_cond *cond)
}
static int
os_cond_wait_internal(korp_cond *cond, korp_mutex *mutex,
bool timed, uint32 mills)
os_cond_wait_internal(korp_cond *cond, korp_mutex *mutex, bool timed,
uint32 mills)
{
os_thread_wait_node *node = &thread_data_current()->wait_node;
@ -352,9 +353,9 @@ os_cond_signal(korp_cond *cond)
return BHT_OK;
}
uint8 *os_thread_get_stack_boundary()
uint8 *
os_thread_get_stack_boundary()
{
/* TODO: get alios stack boundary */
return NULL;
}

1
core/shared/platform/alios/alios_time.c
View File

@ -10,4 +10,3 @@ os_time_get_boot_microsecond()
{
return (uint64)aos_now_ms() * 1000;
}

3
core/shared/platform/alios/platform_internal.h
View File

@ -41,6 +41,7 @@ typedef struct korp_cond {
#define os_printf printf
#define os_vprintf vprintf
/* clang-format off */
/* math functions which are not provided by os*/
double sqrt(double x);
double floor(double x);
@ -58,6 +59,6 @@ float rintf(float x);
float truncf(float x);
int signbit(double x);
int isnan(double x);
/* clang-format on */
#endif /* end of _BH_PLATFORM_H */

41
core/shared/platform/android/platform_init.c
View File

@ -19,10 +19,10 @@ bh_platform_init()
void
bh_platform_destroy()
{
}
{}
int os_printf(const char *fmt, ...)
int
os_printf(const char *fmt, ...)
{
int ret;
va_list ap;
@ -34,14 +34,16 @@ int os_printf(const char *fmt, ...)
return ret;
}
int os_vprintf(const char *fmt, va_list ap)
int
os_vprintf(const char *fmt, va_list ap)
{
return __android_log_vprint(ANDROID_LOG_INFO, "wasm_runtime::", fmt, ap);
}
#if __ANDROID_API__ < 19
int futimens(int __dir_fd, const struct timespec __times[2])
int
futimens(int __dir_fd, const struct timespec __times[2])
{
API_NOT_SUPPORT_ERROR(futimens, 19);
return -1;
@ -51,32 +53,37 @@ int futimens(int __dir_fd, const struct timespec __times[2])
#if __ANDROID_API__ < 21
int posix_fallocate(int __fd, off_t __offset, off_t __length)
int
posix_fallocate(int __fd, off_t __offset, off_t __length)
{
API_NOT_SUPPORT_ERROR(posix_fallocate, 21);
return -1;
}
int posix_fadvise(int fd, off_t offset, off_t len, int advice)
int
posix_fadvise(int fd, off_t offset, off_t len, int advice)
{
API_NOT_SUPPORT_ERROR(posix_fadvise, 21);
return -1;
}
int linkat(int __old_dir_fd, const char *__old_path,
int __new_dir_fd, const char *__new_path, int __flags)
int
linkat(int __old_dir_fd, const char *__old_path, int __new_dir_fd,
const char *__new_path, int __flags)
{
API_NOT_SUPPORT_ERROR(linkat, 21);
return -1;
}
int symlinkat(const char *__old_path, int __new_dir_fd, const char *__new_path)
int
symlinkat(const char *__old_path, int __new_dir_fd, const char *__new_path)
{
API_NOT_SUPPORT_ERROR(symlinkat, 21);
return -1;
}
ssize_t readlinkat(int __dir_fd, const char *__path, char *__buf, size_t __buf_size)
ssize_t
readlinkat(int __dir_fd, const char *__path, char *__buf, size_t __buf_size)
{
API_NOT_SUPPORT_ERROR(readlinkat, 21);
return -1;
@ -86,13 +93,15 @@ ssize_t readlinkat(int __dir_fd, const char *__path, char *__buf, size_t __buf_s
#if __ANDROID_API__ < 23
long telldir(DIR *__dir)
long
telldir(DIR *__dir)
{
API_NOT_SUPPORT_ERROR(telldir, 23);
return -1;
}
void seekdir(DIR *__dir, long __location)
void
seekdir(DIR *__dir, long __location)
{
API_NOT_SUPPORT_ERROR(seekdir, 23);
}
@ -101,13 +110,15 @@ void seekdir(DIR *__dir, long __location)
#if __ANDROID_API__ < 24
ssize_t preadv(int __fd, const struct iovec *__iov, int __count, off_t __offset)
ssize_t
preadv(int __fd, const struct iovec *__iov, int __count, off_t __offset)
{
API_NOT_SUPPORT_ERROR(preadv, 24);
return -1;
}
ssize_t pwritev(int __fd, const struct iovec *__iov, int __count, off_t __offset)
ssize_t
pwritev(int __fd, const struct iovec *__iov, int __count, off_t __offset)
{
API_NOT_SUPPORT_ERROR(pwritev, 24);
return -1;

54
core/shared/platform/android/platform_internal.h
View File

@ -59,10 +59,8 @@ typedef pthread_t korp_thread;
#define os_thread_local_attribute __thread
#if WASM_DISABLE_HW_BOUND_CHECK == 0
#if defined(BUILD_TARGET_X86_64) \
|| defined(BUILD_TARGET_AMD_64) \
|| defined(BUILD_TARGET_AARCH64) \
|| defined(BUILD_TARGET_RISCV64_LP64D) \
#if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64) \
|| defined(BUILD_TARGET_AARCH64) || defined(BUILD_TARGET_RISCV64_LP64D) \
|| defined(BUILD_TARGET_RISCV64_LP64)
#include <setjmp.h>
@ -79,15 +77,20 @@ typedef jmp_buf korp_jmpbuf;
typedef void (*os_signal_handler)(void *sig_addr);
int os_thread_signal_init(os_signal_handler handler);
int
os_thread_signal_init(os_signal_handler handler);
void os_thread_signal_destroy();
void
os_thread_signal_destroy();
bool os_thread_signal_inited();
bool
os_thread_signal_inited();
void os_signal_unmask();
void
os_signal_unmask();
void os_sigreturn();
void
os_sigreturn();
#endif /* end of BUILD_TARGET_X86_64/AMD_64/AARCH64/RISCV64 */
#endif /* end of WASM_DISABLE_HW_BOUND_CHECK */
@ -95,38 +98,48 @@ typedef long int __syscall_slong_t;
#if __ANDROID_API__ < 19
int futimens(int __dir_fd, const struct timespec __times[2]);
int
futimens(int __dir_fd, const struct timespec __times[2]);
#endif
#if __ANDROID_API__ < 21
int posix_fallocate(int __fd, off_t __offset, off_t __length);
int
posix_fallocate(int __fd, off_t __offset, off_t __length);
int posix_fadvise(int fd, off_t offset, off_t len, int advice);
int
posix_fadvise(int fd, off_t offset, off_t len, int advice);
int linkat(int __old_dir_fd, const char *__old_path,
int __new_dir_fd, const char *__new_path, int __flags);
int
linkat(int __old_dir_fd, const char *__old_path, int __new_dir_fd,
const char *__new_path, int __flags);
int symlinkat(const char *__old_path, int __new_dir_fd, const char *__new_path);
int
symlinkat(const char *__old_path, int __new_dir_fd, const char *__new_path);
ssize_t readlinkat(int __dir_fd, const char *__path, char *__buf, size_t __buf_size);
ssize_t
readlinkat(int __dir_fd, const char *__path, char *__buf, size_t __buf_size);
#endif
#if __ANDROID_API__ < 23
long telldir(DIR *__dir);
long
telldir(DIR *__dir);
void seekdir(DIR *__dir, long __location);
void
seekdir(DIR *__dir, long __location);
#endif
#if __ANDROID_API__ < 24
ssize_t preadv(int __fd, const struct iovec *__iov, int __count, off_t __offset);
ssize_t
preadv(int __fd, const struct iovec *__iov, int __count, off_t __offset);
ssize_t pwritev(int __fd, const struct iovec *__iov, int __count, off_t __offset);
ssize_t
pwritev(int __fd, const struct iovec *__iov, int __count, off_t __offset);
#endif
@ -135,4 +148,3 @@ ssize_t pwritev(int __fd, const struct iovec *__iov, int __count, off_t __offset
#endif
#endif /* end of _PLATFORM_INTERNAL_H */

5
core/shared/platform/common/freertos/freertos_malloc.c
View File

@ -5,7 +5,6 @@
#include "platform_api_vmcore.h"
void *
os_malloc(unsigned size)
{
@ -20,6 +19,4 @@ os_realloc(void *ptr, unsigned size)
void
os_free(void *ptr)
{
}
{}

66
core/shared/platform/common/freertos/freertos_thread.c
View File

@ -6,6 +6,7 @@
#include "platform_api_vmcore.h"
#include "platform_api_extension.h"
/* clang-format off */
#define bh_assert(v) do { \
if (!(v)) { \
int _count = 1; \
@ -15,7 +16,8 @@
os_printf("%d\n", _count / (_count - 1)); \
while (1); \
} \
} while (0)
} while (0)
/* clang-format on */
struct os_thread_data;
typedef struct os_thread_wait_node {
@ -56,7 +58,8 @@ static os_thread_data supervisor_thread_data;
/* Thread name index */
static int thread_name_index;
static void thread_data_list_add(os_thread_data *thread_data)
static void
thread_data_list_add(os_thread_data *thread_data)
{
xSemaphoreTake(thread_data_lock, portMAX_DELAY);
if (!thread_data_list)
@ -79,7 +82,8 @@ static void thread_data_list_add(os_thread_data *thread_data)
xSemaphoreGive(thread_data_lock);
}
static void thread_data_list_remove(os_thread_data *thread_data)
static void
thread_data_list_remove(os_thread_data *thread_data)
{
xSemaphoreTake(thread_data_lock, portMAX_DELAY);
if (thread_data_list) {
@ -204,14 +208,16 @@ os_thread_wrapper(void *arg)
vTaskDelete(NULL);
}
int os_thread_create(korp_tid *p_tid, thread_start_routine_t start, void *arg,
int
os_thread_create(korp_tid *p_tid, thread_start_routine_t start, void *arg,
unsigned int stack_size)
{
return os_thread_create_with_prio(p_tid, start, arg, stack_size,
BH_THREAD_DEFAULT_PRIORITY);
}
int os_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
int
os_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
void *arg, unsigned int stack_size, int prio)
{
os_thread_data *thread_data;
@ -235,13 +241,13 @@ int os_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
if (!(thread_data->wait_list_lock = xSemaphoreCreateMutex()))
goto fail2;
snprintf(thread_name, sizeof(thread_name), "%s%d",
"wasm-thread-", ++thread_name_index);
snprintf(thread_name, sizeof(thread_name), "%s%d", "wasm-thread-",
++thread_name_index);
/* Create the thread */
if (pdPASS != xTaskCreate(os_thread_wrapper, thread_name,
stack_size / 4, thread_data,
prio, &thread_data->handle))
if (pdPASS
!= xTaskCreate(os_thread_wrapper, thread_name, stack_size / 4,
thread_data, prio, &thread_data->handle))
goto fail3;
thread_data_list_add(thread_data);
@ -257,12 +263,14 @@ fail1:
return BHT_ERROR;
}
korp_tid os_self_thread()
korp_tid
os_self_thread()
{
return xTaskGetCurrentTaskHandle();
}
int os_thread_join(korp_tid thread, void **value_ptr)
int
os_thread_join(korp_tid thread, void **value_ptr)
{
os_thread_data *thread_data, *curr_thread_data;
TaskHandle_t handle = thread;
@ -293,7 +301,8 @@ int os_thread_join(korp_tid thread, void **value_ptr)
return BHT_OK;
}
int os_mutex_init(korp_mutex *mutex)
int
os_mutex_init(korp_mutex *mutex)
{
SemaphoreHandle_t semaphore;
@ -304,7 +313,8 @@ int os_mutex_init(korp_mutex *mutex)
return BHT_OK;
}
int os_recursive_mutex_init(korp_mutex *mutex)
int
os_recursive_mutex_init(korp_mutex *mutex)
{
SemaphoreHandle_t semaphore;
@ -315,13 +325,15 @@ int os_recursive_mutex_init(korp_mutex *mutex)
return BHT_OK;
}
int os_mutex_destroy(korp_mutex *mutex)
int
os_mutex_destroy(korp_mutex *mutex)
{
vSemaphoreDelete(mutex->sem);
return BHT_OK;
}
int os_mutex_lock(korp_mutex *mutex)
int
os_mutex_lock(korp_mutex *mutex)
{
int ret = -1;
@ -332,7 +344,8 @@ int os_mutex_lock(korp_mutex *mutex)
return ret == pdPASS ? BHT_OK : BHT_ERROR;
}
int os_mutex_unlock(korp_mutex *mutex)
int
os_mutex_unlock(korp_mutex *mutex)
{
int ret = -1;
@ -343,7 +356,8 @@ int os_mutex_unlock(korp_mutex *mutex)
return ret == pdPASS ? BHT_OK : BHT_ERROR;
}
int os_cond_init(korp_cond *cond)
int
os_cond_init(korp_cond *cond)
{
if (!(cond->wait_list_lock = xSemaphoreCreateMutex()))
return BHT_ERROR;
@ -352,15 +366,15 @@ int os_cond_init(korp_cond *cond)
return BHT_OK;
}
int os_cond_destroy(korp_cond *cond)
int
os_cond_destroy(korp_cond *cond)
{
vSemaphoreDelete(cond->wait_list_lock);
return BHT_OK;
}
static int
os_cond_wait_internal(korp_cond *cond, korp_mutex *mutex,
bool timed, int mills)
os_cond_wait_internal(korp_cond *cond, korp_mutex *mutex, bool timed, int mills)
{
os_thread_wait_node *node = &thread_data_current()->wait_node;
@ -399,12 +413,14 @@ os_cond_wait_internal(korp_cond *cond, korp_mutex *mutex,
return BHT_OK;
}
int os_cond_wait(korp_cond *cond, korp_mutex *mutex)
int
os_cond_wait(korp_cond *cond, korp_mutex *mutex)
{
return os_cond_wait_internal(cond, mutex, false, 0);
}
int os_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, uint64 useconds)
int
os_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, uint64 useconds)
{
if (useconds == BHT_WAIT_FOREVER) {
return os_cond_wait_internal(cond, mutex, false, 0);
@ -425,7 +441,8 @@ int os_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, uint64 useconds)
}
}
int os_cond_signal(korp_cond *cond)
int
os_cond_signal(korp_cond *cond)
{
/* Signal the head wait node of wait list */
xSemaphoreTake(cond->wait_list_lock, portMAX_DELAY);
@ -435,4 +452,3 @@ int os_cond_signal(korp_cond *cond)
return BHT_OK;
}

1
core/shared/platform/common/freertos/freertos_time.c
View File

@ -11,4 +11,3 @@ os_time_get_boot_microsecond()
TickType_t ticks = xTaskGetTickCount();
return (uint64)1000 * 1000 / configTICK_RATE_HZ * ticks;
}

1307
core/shared/platform/common/math/math.c
View File

File diff suppressed because it is too large Load Diff

3
core/shared/platform/common/posix/posix_malloc.c
View File

@ -22,6 +22,3 @@ os_free(void *ptr)
{
free(ptr);
}

18
core/shared/platform/common/posix/posix_memmap.c
View File

@ -50,21 +50,19 @@ os_mmap(void *hint, size_t size, int prot, int flags)
* (mmap's first argument) to meet the requirement.
*/
if (!hint && !(flags & MMAP_MAP_FIXED) && (flags & MMAP_MAP_32BIT)) {
uint8 *stack_addr = (uint8*)&map_prot;
uint8 *text_addr = (uint8*)os_mmap;
uint8 *stack_addr = (uint8 *)&map_prot;
uint8 *text_addr = (uint8 *)os_mmap;
/* hint address begins with 1MB */
static uint8 *hint_addr = (uint8 *)(uintptr_t)BH_MB;
if ((hint_addr - text_addr >= 0
&& hint_addr - text_addr < 100 * BH_MB)
if ((hint_addr - text_addr >= 0 && hint_addr - text_addr < 100 * BH_MB)
|| (text_addr - hint_addr >= 0
&& text_addr - hint_addr < 100 * BH_MB)) {
/* hint address is possibly in text section, skip it */
hint_addr += 100 * BH_MB;
}
if ((hint_addr - stack_addr >= 0
&& hint_addr - stack_addr < 8 * BH_MB)
if ((hint_addr - stack_addr >= 0 && hint_addr - stack_addr < 8 * BH_MB)
|| (stack_addr - hint_addr >= 0
&& stack_addr - hint_addr < 8 * BH_MB)) {
/* hint address is possibly in native stack area, skip it */
@ -72,8 +70,7 @@ os_mmap(void *hint, size_t size, int prot, int flags)
}
/* try 10 times, step with 1MB each time */
for (i = 0;
i < 10 && hint_addr < (uint8 *)(uintptr_t)(2ULL * BH_GB);
for (i = 0; i < 10 && hint_addr < (uint8 *)(uintptr_t)(2ULL * BH_GB);
i++) {
addr = mmap(hint_addr, request_size, map_prot, map_flags, -1, 0);
if (addr != MAP_FAILED) {
@ -114,7 +111,7 @@ os_munmap(void *addr, size_t size)
if (addr) {
if (munmap(addr, request_size)) {
os_printf("os_munmap error addr:%p, size:0x%"PRIx64", errno:%d\n",
os_printf("os_munmap error addr:%p, size:0x%" PRIx64 ", errno:%d\n",
addr, request_size, errno);
}
}
@ -144,5 +141,4 @@ os_mprotect(void *addr, size_t size, int prot)
void
os_dcache_flush(void)
{
}
{}

90
core/shared/platform/common/posix/posix_thread.c
View File

@ -22,7 +22,8 @@ typedef struct {
static os_thread_local_attribute os_signal_handler signal_handler;
#endif
static void *os_thread_wrapper(void *arg)
static void *
os_thread_wrapper(void *arg)
{
thread_wrapper_arg *targ = arg;
thread_start_routine_t start_func = targ->start;
@ -44,7 +45,8 @@ static void *os_thread_wrapper(void *arg)
return NULL;
}
int os_thread_create_with_prio(korp_tid *tid, thread_start_routine_t start,
int
os_thread_create_with_prio(korp_tid *tid, thread_start_routine_t start,
void *arg, unsigned int stack_size, int prio)
{
pthread_attr_t tattr;
@ -63,7 +65,7 @@ int os_thread_create_with_prio(korp_tid *tid, thread_start_routine_t start,
return BHT_ERROR;
}
targ = (thread_wrapper_arg*) BH_MALLOC(sizeof(*targ));
targ = (thread_wrapper_arg *)BH_MALLOC(sizeof(*targ));
if (!targ) {
pthread_attr_destroy(&tattr);
return BHT_ERROR;
@ -85,24 +87,28 @@ int os_thread_create_with_prio(korp_tid *tid, thread_start_routine_t start,
return BHT_OK;
}
int os_thread_create(korp_tid *tid, thread_start_routine_t start, void *arg,
int
os_thread_create(korp_tid *tid, thread_start_routine_t start, void *arg,
unsigned int stack_size)
{
return os_thread_create_with_prio(tid, start, arg, stack_size,
BH_THREAD_DEFAULT_PRIORITY);
}
korp_tid os_self_thread()
korp_tid
os_self_thread()
{
return (korp_tid) pthread_self();
return (korp_tid)pthread_self();
}
int os_mutex_init(korp_mutex *mutex)
int
os_mutex_init(korp_mutex *mutex)
{
return pthread_mutex_init(mutex, NULL) == 0 ? BHT_OK : BHT_ERROR;
}
int os_recursive_mutex_init(korp_mutex *mutex)
int
os_recursive_mutex_init(korp_mutex *mutex)
{
int ret;
@ -120,7 +126,8 @@ int os_recursive_mutex_init(korp_mutex *mutex)
return ret == 0 ? BHT_OK : BHT_ERROR;
}
int os_mutex_destroy(korp_mutex *mutex)
int
os_mutex_destroy(korp_mutex *mutex)
{
int ret;
@ -130,7 +137,8 @@ int os_mutex_destroy(korp_mutex *mutex)
return ret == 0 ? BHT_OK : BHT_ERROR;
}
int os_mutex_lock(korp_mutex *mutex)
int
os_mutex_lock(korp_mutex *mutex)
{
int ret;
@ -140,7 +148,8 @@ int os_mutex_lock(korp_mutex *mutex)
return ret == 0 ? BHT_OK : BHT_ERROR;
}
int os_mutex_unlock(korp_mutex *mutex)
int
os_mutex_unlock(korp_mutex *mutex)
{
int ret;
@ -150,7 +159,8 @@ int os_mutex_unlock(korp_mutex *mutex)
return ret == 0 ? BHT_OK : BHT_ERROR;
}
int os_cond_init(korp_cond *cond)
int
os_cond_init(korp_cond *cond)
{
assert(cond);
@ -160,7 +170,8 @@ int os_cond_init(korp_cond *cond)
return BHT_OK;
}
int os_cond_destroy(korp_cond *cond)
int
os_cond_destroy(korp_cond *cond)
{
assert(cond);
@ -170,7 +181,8 @@ int os_cond_destroy(korp_cond *cond)
return BHT_OK;
}
int os_cond_wait(korp_cond *cond, korp_mutex *mutex)
int
os_cond_wait(korp_cond *cond, korp_mutex *mutex)
{
assert(cond);
assert(mutex);
@ -181,7 +193,8 @@ int os_cond_wait(korp_cond *cond, korp_mutex *mutex)
return BHT_OK;
}
static void msec_nsec_to_abstime(struct timespec *ts, uint64 usec)
static void
msec_nsec_to_abstime(struct timespec *ts, uint64 usec)
{
struct timeval tv;
time_t tv_sec_new;
@ -201,8 +214,7 @@ static void msec_nsec_to_abstime(struct timespec *ts, uint64 usec)
}
tv_nsec_new = (long int)(tv.tv_usec * 1000 + (usec % 1000000) * 1000);
if (tv.tv_usec * 1000 >= tv.tv_usec
&& tv_nsec_new >= tv.tv_usec * 1000) {
if (tv.tv_usec * 1000 >= tv.tv_usec && tv_nsec_new >= tv.tv_usec * 1000) {
ts->tv_nsec = tv_nsec_new;
}
else {
@ -218,7 +230,8 @@ static void msec_nsec_to_abstime(struct timespec *ts, uint64 usec)
}
}
int os_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, uint64 useconds)
int
os_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, uint64 useconds)
{
int ret;
struct timespec abstime;
@ -236,7 +249,8 @@ int os_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, uint64 useconds)
return ret;
}
int os_cond_signal(korp_cond *cond)
int
os_cond_signal(korp_cond *cond)
{
assert(cond);
@ -246,17 +260,20 @@ int os_cond_signal(korp_cond *cond)
return BHT_OK;
}
int os_thread_join(korp_tid thread, void **value_ptr)
int
os_thread_join(korp_tid thread, void **value_ptr)
{
return pthread_join(thread, value_ptr);
}
int os_thread_detach(korp_tid thread)
int
os_thread_detach(korp_tid thread)
{
return pthread_detach(thread);
}
void os_thread_exit(void *retval)
void
os_thread_exit(void *retval)
{
#ifdef OS_ENABLE_HW_BOUND_CHECK
os_thread_signal_destroy();
@ -268,7 +285,8 @@ void os_thread_exit(void *retval)
static os_thread_local_attribute uint8 *thread_stack_boundary = NULL;
#endif
uint8 *os_thread_get_stack_boundary()
uint8 *
os_thread_get_stack_boundary()
{
pthread_t self;
#ifdef __linux__
@ -286,15 +304,15 @@ uint8 *os_thread_get_stack_boundary()
page_size = getpagesize();
self = pthread_self();
max_stack_size = (size_t)(APP_THREAD_STACK_SIZE_MAX + page_size - 1)
& ~(page_size - 1);
max_stack_size =
(size_t)(APP_THREAD_STACK_SIZE_MAX + page_size - 1) & ~(page_size - 1);
if (max_stack_size < APP_THREAD_STACK_SIZE_DEFAULT)
max_stack_size = APP_THREAD_STACK_SIZE_DEFAULT;
#ifdef __linux__
if (pthread_getattr_np(self, &attr) == 0) {
pthread_attr_getstack(&attr, (void**)&addr, &stack_size);
pthread_attr_getstack(&attr, (void **)&addr, &stack_size);
pthread_attr_getguardsize(&attr, &guard_size);
pthread_attr_destroy(&attr);
if (stack_size > max_stack_size)
@ -306,7 +324,7 @@ uint8 *os_thread_get_stack_boundary()
}
(void)stack_size;
#elif defined(__APPLE__) || defined(__NuttX__)
if ((addr = (uint8*)pthread_get_stackaddr_np(self))) {
if ((addr = (uint8 *)pthread_get_stackaddr_np(self))) {
stack_size = pthread_get_stacksize_np(self);
if (stack_size > max_stack_size)
addr -= max_stack_size;
@ -349,8 +367,7 @@ touch_pages(uint8 *stack_min_addr, uint32 page_size)
{
uint8 sum = 0;
while (1) {
volatile uint8 *touch_addr =
(volatile uint8*)os_alloca(page_size / 2);
volatile uint8 *touch_addr = (volatile uint8 *)os_alloca(page_size / 2);
if (touch_addr < stack_min_addr + page_size) {
sum += *(stack_min_addr + page_size - 1);
break;
@ -378,7 +395,8 @@ init_stack_guard_pages()
(void)touch_pages(stack_min_addr, page_size);
/* First time to call aot function, protect guard pages */
if (os_mprotect(stack_min_addr, page_size * guard_page_count,
MMAP_PROT_NONE) != 0) {
MMAP_PROT_NONE)
!= 0) {
return false;
}
return true;
@ -413,8 +431,7 @@ signal_callback(int sig_num, siginfo_t *sig_info, void *sig_ucontext)
mask_signals(SIG_BLOCK);
if (signal_handler
&& (sig_num == SIGSEGV || sig_num == SIGBUS)) {
if (signal_handler && (sig_num == SIGSEGV || sig_num == SIGBUS)) {
signal_handler(sig_addr);
}
@ -427,8 +444,7 @@ signal_callback(int sig_num, siginfo_t *sig_info, void *sig_ucontext)
os_printf("unhandled SIGBUS, si_addr: %p\n", sig_addr);
break;
default:
os_printf("unhandle signal %d, si_addr: %p\n",
sig_num, sig_addr);
os_printf("unhandle signal %d, si_addr: %p\n", sig_num, sig_addr);
break;
}
@ -452,8 +468,7 @@ os_thread_signal_init(os_signal_handler handler)
}
/* Initialize memory for signal alternate stack of current thread */
if (!(map_addr = os_mmap(NULL, map_size,
MMAP_PROT_READ | MMAP_PROT_WRITE,
if (!(map_addr = os_mmap(NULL, map_size, MMAP_PROT_READ | MMAP_PROT_WRITE,
MMAP_MAP_NONE))) {
os_printf("Failed to mmap memory for alternate stack\n");
goto fail1;
@ -533,7 +548,7 @@ void
os_sigreturn()
{
#if defined(__APPLE__)
#define UC_RESET_ALT_STACK 0x80000000
#define UC_RESET_ALT_STACK 0x80000000
extern int __sigreturn(void *, int);
/* It's necessary to call __sigreturn to restore the sigaltstack state
@ -542,4 +557,3 @@ os_sigreturn()
#endif
}
#endif /* end of OS_ENABLE_HW_BOUND_CHECK */

3
core/shared/platform/common/posix/posix_time.c
View File

@ -13,6 +13,5 @@ os_time_get_boot_microsecond()
return 0;
}
return ((uint64) ts.tv_sec) * 1000 * 1000 + ((uint64)ts.tv_nsec) / 1000;
return ((uint64)ts.tv_sec) * 1000 * 1000 + ((uint64)ts.tv_nsec) / 1000;
}

4
core/shared/platform/darwin/platform_init.c
View File

@ -13,8 +13,7 @@ bh_platform_init()
void
bh_platform_destroy()
{
}
{}
int
os_printf(const char *format, ...)
@ -42,4 +41,3 @@ os_vprintf(const char *format, va_list ap)
return BH_VPRINTF(format, ap);
#endif
}

22
core/shared/platform/darwin/platform_internal.h
View File

@ -60,10 +60,8 @@ typedef pthread_t korp_thread;
#define os_thread_local_attribute __thread
#if WASM_DISABLE_HW_BOUND_CHECK == 0
#if defined(BUILD_TARGET_X86_64) \
|| defined(BUILD_TARGET_AMD_64) \
|| defined(BUILD_TARGET_AARCH64) \
|| defined(BUILD_TARGET_RISCV64_LP64D) \
#if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64) \
|| defined(BUILD_TARGET_AARCH64) || defined(BUILD_TARGET_RISCV64_LP64D) \
|| defined(BUILD_TARGET_RISCV64_LP64)
#include <setjmp.h>
@ -80,15 +78,20 @@ typedef jmp_buf korp_jmpbuf;
typedef void (*os_signal_handler)(void *sig_addr);
int os_thread_signal_init(os_signal_handler handler);
int
os_thread_signal_init(os_signal_handler handler);
void os_thread_signal_destroy();
void
os_thread_signal_destroy();
bool os_thread_signal_inited();
bool
os_thread_signal_inited();
void os_signal_unmask();
void
os_signal_unmask();
void os_sigreturn();
void
os_sigreturn();
#endif /* end of BUILD_TARGET_X86_64/AMD_64/AARCH64/RISCV64 */
#endif /* end of WASM_DISABLE_HW_BOUND_CHECK */
@ -97,4 +100,3 @@ void os_sigreturn();
#endif
#endif /* end of _PLATFORM_INTERNAL_H */

12
core/shared/platform/esp-idf/espidf_platform.c
View File

@ -6,7 +6,6 @@
#include "platform_api_vmcore.h"
#include "platform_api_extension.h"
int errno = 0;
int
@ -27,7 +26,8 @@ bh_platform_destroy()
os_thread_sys_destroy();
}
int os_printf(const char *format, ...)
int
os_printf(const char *format, ...)
{
int ret = 0;
va_list ap;
@ -66,8 +66,7 @@ os_mprotect(void *addr, size_t size, int prot)
void
os_dcache_flush()
{
}
{}
int
atoi(const char *nptr)
@ -112,11 +111,10 @@ memmove(void *dest, const void *src, size_t n)
*d++ = *s++;
}
else {
const char *lasts = s + (n-1);
char *lastd = d + (n-1);
const char *lasts = s + (n - 1);
char *lastd = d + (n - 1);
while (n--)
*lastd-- = *lasts--;
}
return dest;
}

4
core/shared/platform/esp-idf/espidf_thread.c
View File

@ -6,9 +6,9 @@
#include "platform_api_vmcore.h"
#include "platform_api_extension.h"
uint8 *os_thread_get_stack_boundary()
uint8 *
os_thread_get_stack_boundary()
{
/* TODO: implement os_thread_get_stack_boundary */
return NULL;
}

8
core/shared/platform/esp-idf/platform_internal.h
View File

@ -45,9 +45,12 @@ typedef struct korp_cond {
os_thread_wait_list thread_wait_list;
} korp_cond;
int os_printf(const char *format, ...);
int os_vprintf(const char *format, va_list ap);
int
os_printf(const char *format, ...);
int
os_vprintf(const char *format, va_list ap);
/* clang-format off */
/* math functions which are not provided by os */
double sqrt(double x);
double floor(double x);
@ -93,5 +96,6 @@ uint32_t htonl(uint32_t hostlong);
uint16_t htons(uint16_t hostshort);
uint32_t ntohl(uint32_t netlong);
uint16_t ntohs(uint16_t netshort);
/* clang-format on */
#endif

40
core/shared/platform/include/platform_api_extension.h
View File

@ -30,7 +30,6 @@ extern "C" {
* 2. To build the app-mgr and app-framework, you must implement it
*/
/**
* Ceates a thread
*
@ -41,7 +40,8 @@ extern "C" {
*
* @return 0 if success.
*/
int os_thread_create(korp_tid *p_tid, thread_start_routine_t start, void *arg,
int
os_thread_create(korp_tid *p_tid, thread_start_routine_t start, void *arg,
unsigned int stack_size);
/**
@ -55,7 +55,8 @@ int os_thread_create(korp_tid *p_tid, thread_start_routine_t start, void *arg,
*
* @return 0 if success.
*/
int os_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
int
os_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
void *arg, unsigned int stack_size, int prio);
/**
@ -66,7 +67,8 @@ int os_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
*
* @return return 0 if success
*/
int os_thread_join(korp_tid thread, void **retval);
int
os_thread_join(korp_tid thread, void **retval);
/**
* Detach the thread specified by thread
@ -82,7 +84,8 @@ int os_thread_detach(korp_tid);
*
* @param retval the return value of the current thread
*/
void os_thread_exit(void *retval);
void
os_thread_exit(void *retval);
/**
* Initialize current thread environment if current thread
@ -90,12 +93,14 @@ void os_thread_exit(void *retval);
*
* @return 0 if success, -1 otherwise
*/
int os_thread_env_init();
int
os_thread_env_init();
/**
* Destroy current thread environment
*/
void os_thread_env_destroy();
void
os_thread_env_destroy();
/**
* Suspend execution of the calling thread for (at least)
@ -103,7 +108,8 @@ void os_thread_env_destroy();
*
* @return 0 if success, -1 otherwise
*/
int os_usleep(uint32 usec);
int
os_usleep(uint32 usec);
/**
* Creates a recursive mutex
@ -112,7 +118,8 @@ int os_usleep(uint32 usec);
*
* @return 0 if success
*/
int os_recursive_mutex_init(korp_mutex *mutex);
int
os_recursive_mutex_init(korp_mutex *mutex);
/**
* This function creates a condition variable
@ -121,7 +128,8 @@ int os_recursive_mutex_init(korp_mutex *mutex);
*
* @return 0 if success
*/
int os_cond_init(korp_cond *cond);
int
os_cond_init(korp_cond *cond);
/**
* This function destroys condition variable
@ -130,7 +138,8 @@ int os_cond_init(korp_cond *cond);
*
* @return 0 if success
*/
int os_cond_destroy(korp_cond *cond);
int
os_cond_destroy(korp_cond *cond);
/**
* Wait a condition variable.
@ -140,7 +149,8 @@ int os_cond_destroy(korp_cond *cond);
*
* @return 0 if success
*/
int os_cond_wait(korp_cond *cond, korp_mutex *mutex);
int
os_cond_wait(korp_cond *cond, korp_mutex *mutex);
/**
* Wait a condition varible or return if time specified passes.
@ -151,7 +161,8 @@ int os_cond_wait(korp_cond *cond, korp_mutex *mutex);
*
* @return 0 if success
*/
int os_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, uint64 useconds);
int
os_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, uint64 useconds);
/**
* Signals the condition variable
@ -160,7 +171,8 @@ int os_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, uint64 useconds);
*
* @return 0 if success
*/
int os_cond_signal(korp_cond *cond);
int
os_cond_signal(korp_cond *cond);
#ifdef __cplusplus
}

56
core/shared/platform/include/platform_api_vmcore.h
View File

@ -25,23 +25,28 @@ extern "C" {
*
* @return 0 if success
*/
int bh_platform_init(void);
int
bh_platform_init(void);
/**
* Destroy the platform internal resources if needed,
* this function is called by wasm_runtime_destroy()
*/
void bh_platform_destroy(void);
void
bh_platform_destroy(void);
/**
******** memory allocator APIs **********
*/
void *os_malloc(unsigned size);
void *
os_malloc(unsigned size);
void *os_realloc(void *ptr, unsigned size);
void *
os_realloc(void *ptr, unsigned size);
void os_free(void *ptr);
void
os_free(void *ptr);
/**
* Note: the above APIs can simply return NULL if wasm runtime
@ -49,28 +54,32 @@ void os_free(void *ptr);
* Refer to wasm_runtime_full_init().
*/
int
os_printf(const char *format, ...);
int os_printf(const char *format, ...);
int os_vprintf(const char *format, va_list ap);
int
os_vprintf(const char *format, va_list ap);
/**
* Get microseconds after boot.
*/
uint64 os_time_get_boot_microsecond(void);
uint64
os_time_get_boot_microsecond(void);
/**
* Get current thread id.
* Implementation optional: Used by runtime for logging only.
*/
korp_tid os_self_thread(void);
korp_tid
os_self_thread(void);
/**
* Get current thread's stack boundary address, used for runtime
* to check the native stack overflow. Return NULL if it is not
* easy to implement, but may have potential issue.
*/
uint8 *os_thread_get_stack_boundary(void);
uint8 *
os_thread_get_stack_boundary(void);
/**
************** mutext APIs ***********
@ -78,14 +87,17 @@ uint8 *os_thread_get_stack_boundary(void);
* app-mgr: Must be implemented
*/
int os_mutex_init(korp_mutex *mutex);
int
os_mutex_init(korp_mutex *mutex);
int os_mutex_destroy(korp_mutex *mutex);
int
os_mutex_destroy(korp_mutex *mutex);
int os_mutex_lock(korp_mutex *mutex);
int os_mutex_unlock(korp_mutex *mutex);
int
os_mutex_lock(korp_mutex *mutex);
int
os_mutex_unlock(korp_mutex *mutex);
/**************************************************
* Section 2 *
@ -110,9 +122,12 @@ enum {
MMAP_MAP_FIXED = 2
};
void *os_mmap(void *hint, size_t size, int prot, int flags);
void os_munmap(void *addr, size_t size);
int os_mprotect(void *addr, size_t size, int prot);
void *
os_mmap(void *hint, size_t size, int prot, int flags);
void
os_munmap(void *addr, size_t size);
int
os_mprotect(void *addr, size_t size, int prot);
/**
* Flush cpu data cache, in some CPUs, after applying relocation to the
@ -120,7 +135,8 @@ int os_mprotect(void *addr, size_t size, int prot);
* which may cause unexpected behaviour when executing the AOT code.
* Implement this function if required, or just leave it empty.
*/
void os_dcache_flush(void);
void
os_dcache_flush(void);
#ifdef __cplusplus
}

18
core/shared/platform/include/platform_common.h
View File

@ -42,24 +42,27 @@ extern "C" {
__declspec(dllexport) void *BH_MALLOC(unsigned int size);
__declspec(dllexport) void BH_FREE(void *ptr);
#else
__declspec(dllimport) void* BH_MALLOC(unsigned int size);
__declspec(dllimport) void BH_FREE(void* ptr);
__declspec(dllimport) void *BH_MALLOC(unsigned int size);
__declspec(dllimport) void BH_FREE(void *ptr);
#endif
#else
void *BH_MALLOC(unsigned int size);
void BH_FREE(void *ptr);
void *
BH_MALLOC(unsigned int size);
void
BH_FREE(void *ptr);
#endif
#if defined(BH_VPRINTF)
#if defined(MSVC)
__declspec(dllimport) int BH_VPRINTF(const char *format, va_list ap);
#else
int BH_VPRINTF(const char *format, va_list ap);
int
BH_VPRINTF(const char *format, va_list ap);
#endif
#endif
#ifndef NULL
#define NULL (void*)0
#define NULL (void *)0
#endif
#ifndef __cplusplus
@ -99,8 +102,7 @@ typedef double float64;
typedef uint64_t uint64;
typedef int64_t int64;
typedef void* (*thread_start_routine_t)(void*);
typedef void *(*thread_start_routine_t)(void *);
#ifdef __cplusplus
}

9
core/shared/platform/linux-sgx/platform_internal.h
View File

@ -50,14 +50,15 @@ typedef pthread_t korp_tid;
typedef pthread_mutex_t korp_mutex;
typedef pthread_cond_t korp_cond;
typedef void (*os_print_function_t)(const char* message);
void os_set_print_function(os_print_function_t pf);
typedef void (*os_print_function_t)(const char *message);
void
os_set_print_function(os_print_function_t pf);
char *strcpy(char *dest, const char *src);
char *
strcpy(char *dest, const char *src);
#ifdef __cplusplus
}
#endif
#endif /* end of _PLATFORM_INTERNAL_H */

337
core/shared/platform/linux-sgx/sgx_file.c
View File

@ -13,97 +13,129 @@
#define TRACE_OCALL_FAIL() os_printf("ocall %s failed!\n", __FUNCTION__)
/** fd **/
int ocall_open(int *p_fd, const char *pathname, int flags,
int
ocall_open(int *p_fd, const char *pathname, int flags, bool has_mode,
unsigned mode);
int
ocall_openat(int *p_fd, int dirfd, const char *pathname, int flags,
bool has_mode, unsigned mode);
int ocall_openat(int *p_fd, int dirfd, const char *pathname, int flags,
bool has_mode, unsigned mode);
int
ocall_read(ssize_t *p_ret, int fd, void *buf, size_t read_size);
int ocall_read(ssize_t *p_ret, int fd, void *buf, size_t read_size);
int
ocall_close(int *p_ret, int fd);
int ocall_close(int *p_ret, int fd);
int
ocall_lseek(off_t *p_ret, int fd, off_t offset, int whence);
int ocall_lseek(off_t *p_ret, int fd, off_t offset, int whence);
int
ocall_ftruncate(int *p_ret, int fd, off_t length);
int ocall_ftruncate(int *p_ret, int fd, off_t length);
int
ocall_fsync(int *p_ret, int fd);
int ocall_fsync(int *p_ret, int fd);
int
ocall_fdatasync(int *p_ret, int fd);
int ocall_fdatasync(int *p_ret, int fd);
int ocall_isatty(int *p_ret, int fd);
int
ocall_isatty(int *p_ret, int fd);
/** fd end **/
/** DIR **/
int ocall_fdopendir(int fd, void **p_dirp);
int
ocall_fdopendir(int fd, void **p_dirp);
int ocall_readdir(void **p_dirent, void *dirp);
int
ocall_readdir(void **p_dirent, void *dirp);
int ocall_rewinddir(void *dirp);
int
ocall_rewinddir(void *dirp);
int ocall_seekdir(void *dirp, long loc);
int
ocall_seekdir(void *dirp, long loc);
int ocall_telldir(long *p_dir, void *dirp);
int
ocall_telldir(long *p_dir, void *dirp);
int ocall_closedir(int *p_ret, void *dirp);
int
ocall_closedir(int *p_ret, void *dirp);
/** DIR end **/
/** stat **/
int ocall_stat(int *p_ret, const char *pathname,
void *buf, unsigned int buf_len);
int ocall_fstat(int *p_ret, int fd, void *buf, unsigned int buf_len);
int ocall_fstatat(int *p_ret, int dirfd, const char *pathname,
void *buf, unsigned int buf_len, int flags);
int
ocall_stat(int *p_ret, const char *pathname, void *buf, unsigned int buf_len);
int
ocall_fstat(int *p_ret, int fd, void *buf, unsigned int buf_len);
int
ocall_fstatat(int *p_ret, int dirfd, const char *pathname, void *buf,
unsigned int buf_len, int flags);
/** stat end **/
/** link **/
int ocall_mkdirat(int *p_ret, int dirfd, const char * pathname,
unsigned mode);
int ocall_link(int *p_ret, const char *oldpath, const char *newpath);
int ocall_linkat(int *p_ret, int olddirfd, const char *oldpath,
int newdirfd, const char *newpath, int flags);
int ocall_unlinkat(int *p_ret, int dirfd, const char *pathname,
int flags);
int ocall_readlinkat(ssize_t *p_ret, int dirfd, const char *pathname,
char *buf, size_t bufsiz);
int ocall_renameat(int *p_ret, int olddirfd,const char *oldpath,
int newdirfd,const char *newpath);
int ocall_symlinkat(int *p_ret, const char *target, int newdirfd,
int
ocall_mkdirat(int *p_ret, int dirfd, const char *pathname, unsigned mode);
int
ocall_link(int *p_ret, const char *oldpath, const char *newpath);
int
ocall_linkat(int *p_ret, int olddirfd, const char *oldpath, int newdirfd,
const char *newpath, int flags);
int
ocall_unlinkat(int *p_ret, int dirfd, const char *pathname, int flags);
int
ocall_readlinkat(ssize_t *p_ret, int dirfd, const char *pathname, char *buf,
size_t bufsiz);
int
ocall_renameat(int *p_ret, int olddirfd, const char *oldpath, int newdirfd,
const char *newpath);
int
ocall_symlinkat(int *p_ret, const char *target, int newdirfd,
const char *linkpath);
/** link end **/
/** control **/
int ocall_ioctl(int *p_ret, int fd, unsigned long request, void *arg,
int
ocall_ioctl(int *p_ret, int fd, unsigned long request, void *arg,
unsigned int arg_len);
int ocall_fcntl(int *p_ret, int fd, int cmd);
int ocall_fcntl_long(int *p_ret, int fd, int cmd, long arg);
int
ocall_fcntl(int *p_ret, int fd, int cmd);
int
ocall_fcntl_long(int *p_ret, int fd, int cmd, long arg);
/** control end **/
/** **/
int ocall_realpath(int *p_ret, const char *path, char *buf,
unsigned int buf_len);
int ocall_posix_fallocate(int *p_ret, int fd, off_t offset, off_t len);
int ocall_poll(int *p_ret, void *fds, unsigned nfds, int timeout,
int
ocall_realpath(int *p_ret, const char *path, char *buf, unsigned int buf_len);
int
ocall_posix_fallocate(int *p_ret, int fd, off_t offset, off_t len);
int
ocall_poll(int *p_ret, void *fds, unsigned nfds, int timeout,
unsigned int fds_len);
int ocall_getopt(int *p_ret, int argc, char *argv_buf,
unsigned int argv_buf_len, const char *optstring);
int ocall_getrandom(ssize_t *p_ret, void *buf, size_t buflen,
unsigned int flags);
int ocall_getentropy(int *p_ret, void *buffer, size_t length);
int ocall_sched_yield(int *p_ret);
int
ocall_getopt(int *p_ret, int argc, char *argv_buf, unsigned int argv_buf_len,
const char *optstring);
int
ocall_getrandom(ssize_t *p_ret, void *buf, size_t buflen, unsigned int flags);
int
ocall_getentropy(int *p_ret, void *buffer, size_t length);
int
ocall_sched_yield(int *p_ret);
/** struct iovec **/
ssize_t ocall_readv(ssize_t *p_ret, int fd, char *iov_buf,
unsigned int buf_size, int iovcnt,
bool has_offset, off_t offset);
ssize_t ocall_writev(ssize_t *p_ret, int fd, char *iov_buf,
unsigned int buf_size, int iovcnt,
bool has_offset, off_t offset);
ssize_t
ocall_readv(ssize_t *p_ret, int fd, char *iov_buf, unsigned int buf_size,
int iovcnt, bool has_offset, off_t offset);
ssize_t
ocall_writev(ssize_t *p_ret, int fd, char *iov_buf, unsigned int buf_size,
int iovcnt, bool has_offset, off_t offset);
/** iovec end **/
int ocall_get_errno(int *p_ret);
int
ocall_get_errno(int *p_ret);
int open(const char *pathname, int flags, ...)
int
open(const char *pathname, int flags, ...)
{
int fd;
bool has_mode = false;
@ -130,7 +162,8 @@ int open(const char *pathname, int flags, ...)
return fd;
}
int openat(int dirfd, const char *pathname, int flags, ...)
int
openat(int dirfd, const char *pathname, int flags, ...)
{
int fd;
bool has_mode = false;
@ -144,8 +177,8 @@ int openat(int dirfd, const char *pathname, int flags, ...)
has_mode = true;
}
if (SGX_SUCCESS != ocall_openat(&fd, dirfd, pathname, flags,
has_mode, mode)) {
if (SGX_SUCCESS
!= ocall_openat(&fd, dirfd, pathname, flags, has_mode, mode)) {
TRACE_OCALL_FAIL();
return -1;
}
@ -158,7 +191,8 @@ int openat(int dirfd, const char *pathname, int flags, ...)
return fd;
}
int close(int fd)
int
close(int fd)
{
int ret;
@ -171,7 +205,8 @@ int close(int fd)
return ret;
}
ssize_t read(int fd, void *buf, size_t size)
ssize_t
read(int fd, void *buf, size_t size)
{
ssize_t ret;
int size_read_max = 2048, size_read, total_size_read = 0, count, i;
@ -184,9 +219,7 @@ ssize_t read(int fd, void *buf, size_t size)
count = (size + size_read_max - 1) / size_read_max;
for (i = 0; i < count; i++) {
size_read = (i < count - 1)
? size_read_max
: size - size_read_max * i;
size_read = (i < count - 1) ? size_read_max : size - size_read_max * i;
if (ocall_read(&ret, fd, p, size_read) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
@ -208,7 +241,8 @@ ssize_t read(int fd, void *buf, size_t size)
return total_size_read;
}
DIR *fdopendir(int fd)
DIR *
fdopendir(int fd)
{
DIR *result = NULL;
@ -232,7 +266,8 @@ DIR *fdopendir(int fd)
return result;
}
struct dirent *readdir(DIR *dirp)
struct dirent *
readdir(DIR *dirp)
{
struct dirent *result;
@ -249,21 +284,24 @@ struct dirent *readdir(DIR *dirp)
return result;
}
void rewinddir(DIR *dirp)
void
rewinddir(DIR *dirp)
{
if (ocall_rewinddir((void *)*dirp) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
}
}
void seekdir(DIR *dirp, long loc)
void
seekdir(DIR *dirp, long loc)
{
if (ocall_seekdir((void *)*dirp, loc) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
}
}
long telldir(DIR *dirp)
long
telldir(DIR *dirp)
{
long ret;
@ -276,7 +314,8 @@ long telldir(DIR *dirp)
return ret;
}
int closedir(DIR *dirp)
int
closedir(DIR *dirp)
{
int ret;
@ -291,8 +330,8 @@ int closedir(DIR *dirp)
}
static ssize_t
readv_internal(int fd, const struct iovec *iov, int iovcnt,
bool has_offset, off_t offset)
readv_internal(int fd, const struct iovec *iov, int iovcnt, bool has_offset,
off_t offset)
{
ssize_t ret, size_left;
struct iovec *iov1;
@ -317,7 +356,7 @@ readv_internal(int fd, const struct iovec *iov, int iovcnt,
memset(iov1, 0, (uint32)total_size);
p = (char*)(uintptr_t)(sizeof(struct iovec) * iovcnt);
p = (char *)(uintptr_t)(sizeof(struct iovec) * iovcnt);
for (i = 0; i < iovcnt; i++) {
iov1[i].iov_len = iov[i].iov_len;
@ -325,8 +364,9 @@ readv_internal(int fd, const struct iovec *iov, int iovcnt,
p += iov[i].iov_len;
}
if (ocall_readv(&ret, fd, (char *)iov1, (uint32)total_size,
iovcnt, has_offset, offset) != SGX_SUCCESS) {
if (ocall_readv(&ret, fd, (char *)iov1, (uint32)total_size, iovcnt,
has_offset, offset)
!= SGX_SUCCESS) {
TRACE_OCALL_FAIL();
BH_FREE(iov1);
return -1;
@ -343,8 +383,7 @@ readv_internal(int fd, const struct iovec *iov, int iovcnt,
size_left -= iov[i].iov_len;
}
else {
memcpy(iov[i].iov_base, (uintptr_t)p + (char *)iov1,
size_left);
memcpy(iov[i].iov_base, (uintptr_t)p + (char *)iov1, size_left);
break;
}
}
@ -356,8 +395,8 @@ readv_internal(int fd, const struct iovec *iov, int iovcnt,
}
static ssize_t
writev_internal(int fd, const struct iovec *iov, int iovcnt,
bool has_offset, off_t offset)
writev_internal(int fd, const struct iovec *iov, int iovcnt, bool has_offset,
off_t offset)
{
ssize_t ret;
struct iovec *iov1;
@ -387,13 +426,13 @@ writev_internal(int fd, const struct iovec *iov, int iovcnt,
for (i = 0; i < iovcnt; i++) {
iov1[i].iov_len = iov[i].iov_len;
iov1[i].iov_base = p;
memcpy((uintptr_t)p + (char *)iov1, iov[i].iov_base,
iov[i].iov_len);
memcpy((uintptr_t)p + (char *)iov1, iov[i].iov_base, iov[i].iov_len);
p += iov[i].iov_len;
}
if (ocall_writev(&ret, fd, (char *)iov1, (uint32)total_size,
iovcnt, has_offset, offset) != SGX_SUCCESS) {
if (ocall_writev(&ret, fd, (char *)iov1, (uint32)total_size, iovcnt,
has_offset, offset)
!= SGX_SUCCESS) {
TRACE_OCALL_FAIL();
BH_FREE(iov1);
return -1;
@ -405,29 +444,32 @@ writev_internal(int fd, const struct iovec *iov, int iovcnt,
return ret;
}
ssize_t readv(int fd, const struct iovec *iov, int iovcnt)
ssize_t
readv(int fd, const struct iovec *iov, int iovcnt)
{
return readv_internal(fd, iov, iovcnt, false, 0);
}
ssize_t writev(int fd, const struct iovec *iov, int iovcnt)
ssize_t
writev(int fd, const struct iovec *iov, int iovcnt)
{
return writev_internal(fd, iov, iovcnt, false, 0);
}
ssize_t preadv(int fd, const struct iovec *iov, int iovcnt,
off_t offset)
ssize_t
preadv(int fd, const struct iovec *iov, int iovcnt, off_t offset)
{
return readv_internal(fd, iov, iovcnt, true, offset);
}
ssize_t pwritev(int fd, const struct iovec *iov, int iovcnt,
off_t offset)
ssize_t
pwritev(int fd, const struct iovec *iov, int iovcnt, off_t offset)
{
return writev_internal(fd, iov, iovcnt, true, offset);
}
off_t lseek(int fd, off_t offset, int whence)
off_t
lseek(int fd, off_t offset, int whence)
{
off_t ret;
if (ocall_lseek(&ret, fd, (long)offset, whence) != SGX_SUCCESS) {
@ -439,7 +481,8 @@ off_t lseek(int fd, off_t offset, int whence)
return ret;
}
int ftruncate(int fd, off_t length)
int
ftruncate(int fd, off_t length)
{
int ret;
@ -452,16 +495,16 @@ int ftruncate(int fd, off_t length)
return ret;
}
int stat(const char *pathname, struct stat *statbuf)
int
stat(const char *pathname, struct stat *statbuf)
{
int ret;
if (statbuf == NULL)
return -1;
if (ocall_stat(&ret, pathname,
(void *)statbuf,
sizeof(struct stat)) != SGX_SUCCESS) {
if (ocall_stat(&ret, pathname, (void *)statbuf, sizeof(struct stat))
!= SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
@ -471,15 +514,16 @@ int stat(const char *pathname, struct stat *statbuf)
return ret;
}
int fstat(int fd, struct stat *statbuf)
int
fstat(int fd, struct stat *statbuf)
{
int ret;
if (statbuf == NULL)
return -1;
if (ocall_fstat(&ret, fd, (void *)statbuf,
sizeof(struct stat)) != SGX_SUCCESS) {
if (ocall_fstat(&ret, fd, (void *)statbuf, sizeof(struct stat))
!= SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
@ -489,8 +533,8 @@ int fstat(int fd, struct stat *statbuf)
return ret;
}
int fstatat(int dirfd, const char *pathname, struct stat *statbuf,
int flags)
int
fstatat(int dirfd, const char *pathname, struct stat *statbuf, int flags)
{
int ret;
@ -498,7 +542,8 @@ int fstatat(int dirfd, const char *pathname, struct stat *statbuf,
return -1;
if (ocall_fstatat(&ret, dirfd, pathname, (void *)statbuf,
sizeof(struct stat), flags) != SGX_SUCCESS) {
sizeof(struct stat), flags)
!= SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
@ -508,7 +553,8 @@ int fstatat(int dirfd, const char *pathname, struct stat *statbuf,
return ret;
}
int fsync(int fd)
int
fsync(int fd)
{
int ret;
@ -521,7 +567,8 @@ int fsync(int fd)
return ret;
}
int fdatasync(int fd)
int
fdatasync(int fd)
{
int ret;
@ -534,7 +581,8 @@ int fdatasync(int fd)
return ret;
}
int mkdirat(int dirfd, const char *pathname, mode_t mode)
int
mkdirat(int dirfd, const char *pathname, mode_t mode)
{
int ret;
@ -548,7 +596,8 @@ int mkdirat(int dirfd, const char *pathname, mode_t mode)
return ret;
}
int link(const char *oldpath, const char *newpath)
int
link(const char *oldpath, const char *newpath)
{
int ret;
@ -562,13 +611,14 @@ int link(const char *oldpath, const char *newpath)
return ret;
}
int linkat(int olddirfd, const char *oldpath,
int newdirfd, const char *newpath, int flags)
int
linkat(int olddirfd, const char *oldpath, int newdirfd, const char *newpath,
int flags)
{
int ret;
if (ocall_linkat(&ret, olddirfd, oldpath, newdirfd, newpath,
flags) != SGX_SUCCESS) {
if (ocall_linkat(&ret, olddirfd, oldpath, newdirfd, newpath, flags)
!= SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
@ -578,7 +628,8 @@ int linkat(int olddirfd, const char *oldpath,
return ret;
}
int unlinkat(int dirfd, const char *pathname, int flags)
int
unlinkat(int dirfd, const char *pathname, int flags)
{
int ret;
@ -592,16 +643,15 @@ int unlinkat(int dirfd, const char *pathname, int flags)
return ret;
}
ssize_t readlinkat(int dirfd, const char *pathname,
char *buf, size_t bufsiz)
ssize_t
readlinkat(int dirfd, const char *pathname, char *buf, size_t bufsiz)
{
ssize_t ret;
if (buf == NULL)
return -1;
if (ocall_readlinkat(&ret, dirfd, pathname, buf,
bufsiz) != SGX_SUCCESS) {
if (ocall_readlinkat(&ret, dirfd, pathname, buf, bufsiz) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
@ -611,12 +661,12 @@ ssize_t readlinkat(int dirfd, const char *pathname,
return ret;
}
int symlinkat(const char *target, int newdirfd, const char *linkpath)
int
symlinkat(const char *target, int newdirfd, const char *linkpath)
{
int ret;
if (ocall_symlinkat(&ret, target,
newdirfd, linkpath) != SGX_SUCCESS) {
if (ocall_symlinkat(&ret, target, newdirfd, linkpath) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
@ -626,13 +676,13 @@ int symlinkat(const char *target, int newdirfd, const char *linkpath)
return ret;
}
int renameat(int olddirfd, const char *oldpath,
int newdirfd, const char *newpath)
int
renameat(int olddirfd, const char *oldpath, int newdirfd, const char *newpath)
{
int ret;
if (ocall_renameat(&ret, olddirfd, oldpath,
newdirfd, newpath) != SGX_SUCCESS) {
if (ocall_renameat(&ret, olddirfd, oldpath, newdirfd, newpath)
!= SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
@ -642,7 +692,8 @@ int renameat(int olddirfd, const char *oldpath,
return ret;
}
int ioctl(int fd, unsigned long request, ...)
int
ioctl(int fd, unsigned long request, ...)
{
int ret;
va_list args;
@ -651,8 +702,8 @@ int ioctl(int fd, unsigned long request, ...)
case FIONREAD:
va_start(args, request);
int *arg = (int *)va_arg(args, int *);
if (ocall_ioctl(&ret, fd, request, arg,
sizeof(*arg)) != SGX_SUCCESS) {
if (ocall_ioctl(&ret, fd, request, arg, sizeof(*arg))
!= SGX_SUCCESS) {
TRACE_OCALL_FAIL();
va_end(args);
return -1;
@ -670,7 +721,8 @@ int ioctl(int fd, unsigned long request, ...)
return ret;
}
int fcntl(int fd, int cmd, ... /* arg */ )
int
fcntl(int fd, int cmd, ... /* arg */)
{
int ret;
va_list args;
@ -707,7 +759,8 @@ int fcntl(int fd, int cmd, ... /* arg */ )
return ret;
}
int isatty(int fd)
int
isatty(int fd)
{
int ret;
@ -720,7 +773,8 @@ int isatty(int fd)
return ret;
}
char *realpath(const char *path, char *resolved_path)
char *
realpath(const char *path, char *resolved_path)
{
int ret;
char buf[PATH_MAX] = { 0 };
@ -746,7 +800,8 @@ char *realpath(const char *path, char *resolved_path)
return resolved_path;
}
int posix_fallocate(int fd, off_t offset, off_t len)
int
posix_fallocate(int fd, off_t offset, off_t len)
{
int ret;
@ -758,15 +813,16 @@ int posix_fallocate(int fd, off_t offset, off_t len)
return ret;
}
int poll(struct pollfd *fds, nfds_t nfds, int timeout)
int
poll(struct pollfd *fds, nfds_t nfds, int timeout)
{
int ret;
if (fds == NULL)
return -1;
if (ocall_poll(&ret, fds, nfds, timeout,
sizeof(*fds) * nfds) != SGX_SUCCESS) {
if (ocall_poll(&ret, fds, nfds, timeout, sizeof(*fds) * nfds)
!= SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
@ -776,8 +832,8 @@ int poll(struct pollfd *fds, nfds_t nfds, int timeout)
return ret;
}
int getopt(int argc, char * const argv[],
const char *optstring)
int
getopt(int argc, char *const argv[], const char *optstring)
{
int ret;
char **argv1;
@ -805,8 +861,8 @@ int getopt(int argc, char * const argv[],
p += ((uintptr_t)strlen(argv[i]) + 1);
}
if (ocall_getopt(&ret, argc, (char *)argv1, total_size,
optstring) != SGX_SUCCESS) {
if (ocall_getopt(&ret, argc, (char *)argv1, total_size, optstring)
!= SGX_SUCCESS) {
TRACE_OCALL_FAIL();
BH_FREE(argv1);
return -1;
@ -818,7 +874,8 @@ int getopt(int argc, char * const argv[],
return ret;
}
int sched_yield(void)
int
sched_yield(void)
{
int ret;
@ -831,7 +888,8 @@ int sched_yield(void)
return ret;
}
ssize_t getrandom(void *buf, size_t buflen, unsigned int flags)
ssize_t
getrandom(void *buf, size_t buflen, unsigned int flags)
{
ssize_t ret;
@ -844,7 +902,8 @@ ssize_t getrandom(void *buf, size_t buflen, unsigned int flags)
return ret;
}
int getentropy(void *buffer, size_t length)
int
getentropy(void *buffer, size_t length)
{
int ret;
@ -857,7 +916,8 @@ int getentropy(void *buffer, size_t length)
return ret;
}
int get_errno(void)
int
get_errno(void)
{
int ret;
@ -869,4 +929,3 @@ int get_errno(void)
}
#endif

144
core/shared/platform/linux-sgx/sgx_file.h
View File

@ -24,7 +24,7 @@ extern "C" {
#define O_SEARCH O_PATH
#define O_EXEC O_PATH
#define O_ACCMODE (03|O_SEARCH)
#define O_ACCMODE (03 | O_SEARCH)
#define O_RDONLY 00
#define O_WRONLY 01
#define O_RDWR 02
@ -63,13 +63,13 @@ extern "C" {
#define SEEK_CUR 1
#define SEEK_END 2
#define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
#define S_ISCHR(mode) (((mode) & S_IFMT) == S_IFCHR)
#define S_ISBLK(mode) (((mode) & S_IFMT) == S_IFBLK)
#define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG)
#define S_ISFIFO(mode) (((mode) & S_IFMT) == S_IFIFO)
#define S_ISLNK(mode) (((mode) & S_IFMT) == S_IFLNK)
#define S_ISSOCK(mode) (((mode) & S_IFMT) == S_IFSOCK)
#define S_ISDIR(mode) (((mode)&S_IFMT) == S_IFDIR)
#define S_ISCHR(mode) (((mode)&S_IFMT) == S_IFCHR)
#define S_ISBLK(mode) (((mode)&S_IFMT) == S_IFBLK)
#define S_ISREG(mode) (((mode)&S_IFMT) == S_IFREG)
#define S_ISFIFO(mode) (((mode)&S_IFMT) == S_IFIFO)
#define S_ISLNK(mode) (((mode)&S_IFMT) == S_IFLNK)
#define S_ISSOCK(mode) (((mode)&S_IFMT) == S_IFSOCK)
#define DT_UNKNOWN 0
#define DT_FIFO 1
@ -161,71 +161,103 @@ struct pollfd {
short revents;
};
int open(const char *pathname, int flags, ...);
int openat(int dirfd, const char *pathname, int flags, ...);
int close(int fd);
int
open(const char *pathname, int flags, ...);
int
openat(int dirfd, const char *pathname, int flags, ...);
int
close(int fd);
DIR *fdopendir(int fd);
int closedir(DIR *dirp);
void rewinddir(DIR *dirp);
void seekdir(DIR *dirp, long loc);
struct dirent *readdir(DIR *dirp);
long telldir(DIR *dirp);
DIR *
fdopendir(int fd);
int
closedir(DIR *dirp);
void
rewinddir(DIR *dirp);
void
seekdir(DIR *dirp, long loc);
struct dirent *
readdir(DIR *dirp);
long
telldir(DIR *dirp);
ssize_t read(int fd, void *buf, size_t count);
ssize_t readv(int fd, const struct iovec *iov, int iovcnt);
ssize_t writev(int fd, const struct iovec *iov, int iovcnt);
ssize_t preadv(int fd, const struct iovec *iov, int iovcnt,
off_t offset);
ssize_t pwritev(int fd, const struct iovec *iov, int iovcnt,
off_t offset);
ssize_t
read(int fd, void *buf, size_t count);
ssize_t
readv(int fd, const struct iovec *iov, int iovcnt);
ssize_t
writev(int fd, const struct iovec *iov, int iovcnt);
ssize_t
preadv(int fd, const struct iovec *iov, int iovcnt, off_t offset);
ssize_t
pwritev(int fd, const struct iovec *iov, int iovcnt, off_t offset);
off_t lseek(int fd, off_t offset, int whence);
int ftruncate(int fd, off_t length);
off_t
lseek(int fd, off_t offset, int whence);
int
ftruncate(int fd, off_t length);
int stat(const char *pathname, struct stat *statbuf);
int fstat(int fd, struct stat *statbuf);
int fstatat(int dirfd, const char *pathname, struct stat *statbuf,
int
stat(const char *pathname, struct stat *statbuf);
int
fstat(int fd, struct stat *statbuf);
int
fstatat(int dirfd, const char *pathname, struct stat *statbuf, int flags);
int
fsync(int fd);
int
fdatasync(int fd);
int
mkdirat(int dirfd, const char *pathname, mode_t mode);
int
link(const char *oldpath, const char *newpath);
int
linkat(int olddirfd, const char *oldpath, int newdirfd, const char *newpath,
int flags);
int
unlinkat(int dirfd, const char *pathname, int flags);
ssize_t
readlinkat(int dirfd, const char *pathname, char *buf, size_t bufsiz);
int
symlinkat(const char *target, int newdirfd, const char *linkpath);
int
renameat(int olddirfd, const char *oldpath, int newdirfd, const char *newpath);
int fsync(int fd);
int fdatasync(int fd);
int
ioctl(int fd, unsigned long request, ...);
int
fcntl(int fd, int cmd, ... /* arg */);
int mkdirat(int dirfd, const char *pathname, mode_t mode);
int link(const char *oldpath, const char *newpath);
int linkat(int olddirfd, const char *oldpath,
int newdirfd, const char *newpath, int flags);
int unlinkat(int dirfd, const char *pathname, int flags);
ssize_t readlinkat(int dirfd, const char *pathname,
char *buf, size_t bufsiz);
int symlinkat(const char *target, int newdirfd, const char *linkpath);
int renameat(int olddirfd, const char *oldpath,
int newdirfd, const char *newpath);
int
isatty(int fd);
int ioctl(int fd, unsigned long request, ...);
int fcntl(int fd, int cmd, ... /* arg */ );
char *
realpath(const char *path, char *resolved_path);
int isatty(int fd);
int
posix_fallocate(int fd, off_t offset, off_t len);
char *realpath(const char *path, char *resolved_path);
int
poll(struct pollfd *fds, nfds_t nfds, int timeout);
int posix_fallocate(int fd, off_t offset, off_t len);
int
getopt(int argc, char *const argv[], const char *optstring);
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
int
sched_yield(void);
int getopt(int argc, char * const argv[],
const char *optstring);
ssize_t
getrandom(void *buf, size_t buflen, unsigned int flags);
int
getentropy(void *buffer, size_t length);
int sched_yield(void);
ssize_t getrandom(void *buf, size_t buflen, unsigned int flags);
int getentropy(void *buffer, size_t length);
int get_errno(void);
int
get_errno(void);
#ifdef __cplusplus
}
#endif
#endif /* end of _SGX_FILE_H */

56
core/shared/platform/linux-sgx/sgx_platform.c
View File

@ -7,19 +7,19 @@
#include "platform_api_extension.h"
#include "sgx_rsrv_mem_mngr.h"
#define FIXED_BUFFER_SIZE (1<<9)
#define FIXED_BUFFER_SIZE (1 << 9)
static os_print_function_t print_function = NULL;
int bh_platform_init()
int
bh_platform_init()
{
return 0;
}
void
bh_platform_destroy()
{
}
{}
void *
os_malloc(unsigned size)
@ -39,22 +39,26 @@ os_free(void *ptr)
free(ptr);
}
int putchar(int c)
int
putchar(int c)
{
return 0;
}
int puts(const char *s)
int
puts(const char *s)
{
return 0;
}
void os_set_print_function(os_print_function_t pf)
void
os_set_print_function(os_print_function_t pf)
{
print_function = pf;
}
int os_printf(const char *message, ...)
int
os_printf(const char *message, ...)
{
if (print_function != NULL) {
char msg[FIXED_BUFFER_SIZE] = { '\0' };
@ -68,7 +72,8 @@ int os_printf(const char *message, ...)
return 0;
}
int os_vprintf(const char * format, va_list arg)
int
os_vprintf(const char *format, va_list arg)
{
if (print_function != NULL) {
char msg[FIXED_BUFFER_SIZE] = { '\0' };
@ -79,20 +84,23 @@ int os_vprintf(const char * format, va_list arg)
return 0;
}
char *strcpy(char *dest, const char *src)
char *
strcpy(char *dest, const char *src)
{
const unsigned char *s = src;
unsigned char *d = dest;
while ((*d++ = *s++));
while ((*d++ = *s++))
;
return dest;
}
void* os_mmap(void *hint, size_t size, int prot, int flags)
void *
os_mmap(void *hint, size_t size, int prot, int flags)
{
int mprot = 0;
uint64 aligned_size, page_size;
void* ret = NULL;
void *ret = NULL;
sgx_status_t st = 0;
page_size = getpagesize();
@ -103,8 +111,8 @@ void* os_mmap(void *hint, size_t size, int prot, int flags)
ret = sgx_alloc_rsrv_mem(aligned_size);
if (ret == NULL) {
os_printf("os_mmap(size=%u, aligned size=%lu, prot=0x%x) failed.",
size, aligned_size, prot);
os_printf("os_mmap(size=%u, aligned size=%lu, prot=0x%x) failed.", size,
aligned_size, prot);
return NULL;
}
@ -117,8 +125,8 @@ void* os_mmap(void *hint, size_t size, int prot, int flags)
st = sgx_tprotect_rsrv_mem(ret, aligned_size, mprot);
if (st != SGX_SUCCESS) {
os_printf("os_mmap(size=%u, prot=0x%x) failed to set protect.",
size, prot);
os_printf("os_mmap(size=%u, prot=0x%x) failed to set protect.", size,
prot);
sgx_free_rsrv_mem(ret, aligned_size);
return NULL;
}
@ -126,7 +134,8 @@ void* os_mmap(void *hint, size_t size, int prot, int flags)
return ret;
}
void os_munmap(void *addr, size_t size)
void
os_munmap(void *addr, size_t size)
{
uint64 aligned_size, page_size;
@ -135,7 +144,8 @@ void os_munmap(void *addr, size_t size)
sgx_free_rsrv_mem(addr, aligned_size);
}
int os_mprotect(void *addr, size_t size, int prot)
int
os_mprotect(void *addr, size_t size, int prot)
{
int mprot = 0;
sgx_status_t st = 0;
@ -152,14 +162,12 @@ int os_mprotect(void *addr, size_t size, int prot)
mprot |= SGX_PROT_EXEC;
st = sgx_tprotect_rsrv_mem(addr, aligned_size, mprot);
if (st != SGX_SUCCESS)
os_printf("os_mprotect(addr=0x%"PRIx64", size=%u, prot=0x%x) failed.",
os_printf("os_mprotect(addr=0x%" PRIx64 ", size=%u, prot=0x%x) failed.",
(uintptr_t)addr, size, prot);
return (st == SGX_SUCCESS? 0:-1);
return (st == SGX_SUCCESS ? 0 : -1);
}
void
os_dcache_flush(void)
{
}
{}

40
core/shared/platform/linux-sgx/sgx_pthread.c
View File

@ -15,22 +15,27 @@
#ifndef SGX_THREAD_LOCK_INITIALIZER /* defined since sgxsdk-2.11 */
/* sgxsdk doesn't support pthread_rwlock related APIs until
version 2.11, we implement them by ourselves. */
int ocall_pthread_rwlock_init(int *p_ret, void **rwlock, void *attr);
int
ocall_pthread_rwlock_init(int *p_ret, void **rwlock, void *attr);
int ocall_pthread_rwlock_destroy(int *p_ret, void **rwlock);
int
ocall_pthread_rwlock_destroy(int *p_ret, void **rwlock);
int ocall_pthread_rwlock_rdlock(int *p_ret, void **rwlock);
int
ocall_pthread_rwlock_rdlock(int *p_ret, void **rwlock);
int ocall_pthread_rwlock_wrlock(int *p_ret, void **rwlock);
int
ocall_pthread_rwlock_wrlock(int *p_ret, void **rwlock);
int ocall_pthread_rwlock_unlock(int *p_ret, void **rwlock);
int
ocall_pthread_rwlock_unlock(int *p_ret, void **rwlock);
int pthread_rwlock_init(pthread_rwlock_t *rwlock, void *attr)
int
pthread_rwlock_init(pthread_rwlock_t *rwlock, void *attr)
{
int ret = -1;
if (ocall_pthread_rwlock_init(&ret, (void **)rwlock, NULL)
!= SGX_SUCCESS) {
if (ocall_pthread_rwlock_init(&ret, (void **)rwlock, NULL) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
@ -38,7 +43,8 @@ int pthread_rwlock_init(pthread_rwlock_t *rwlock, void *attr)
return ret;
}
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock)
int
pthread_rwlock_destroy(pthread_rwlock_t *rwlock)
{
int ret = -1;
@ -48,31 +54,34 @@ int pthread_rwlock_destroy(pthread_rwlock_t *rwlock)
return ret;
}
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock)
int
pthread_rwlock_rdlock(pthread_rwlock_t *rwlock)
{
int ret = -1;
if (ocall_pthread_rwlock_rdlock(&ret, (void*)*rwlock) != SGX_SUCCESS) {
if (ocall_pthread_rwlock_rdlock(&ret, (void *)*rwlock) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
}
return ret;
}
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock)
int
pthread_rwlock_wrlock(pthread_rwlock_t *rwlock)
{
int ret = -1;
if (ocall_pthread_rwlock_wrlock(&ret, (void*)*rwlock) != SGX_SUCCESS) {
if (ocall_pthread_rwlock_wrlock(&ret, (void *)*rwlock) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
}
return ret;
}
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock)
int
pthread_rwlock_unlock(pthread_rwlock_t *rwlock)
{
int ret = -1;
if (ocall_pthread_rwlock_unlock(&ret, (void*)*rwlock) != SGX_SUCCESS) {
if (ocall_pthread_rwlock_unlock(&ret, (void *)*rwlock) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
}
return ret;
@ -80,4 +89,3 @@ int pthread_rwlock_unlock(pthread_rwlock_t *rwlock)
#endif /* end of SGX_THREAD_LOCK_INITIALIZER */
#endif

16
core/shared/platform/linux-sgx/sgx_pthread.h
View File

@ -15,12 +15,17 @@ extern "C" {
version 2.11, we implement them by ourselves. */
typedef uintptr_t pthread_rwlock_t;
int pthread_rwlock_init(pthread_rwlock_t *rwlock, void *attr);
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
int
pthread_rwlock_init(pthread_rwlock_t *rwlock, void *attr);
int
pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
int
pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int
pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int
pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
#endif /* end of SGX_THREAD_LOCK_INITIALIZER */
#ifdef __cplusplus
@ -28,4 +33,3 @@ int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
#endif
#endif /* end of _SGX_PTHREAD_H */

37
core/shared/platform/linux-sgx/sgx_rsrv_mem_mngr.h
View File

@ -30,7 +30,8 @@
*/
/*
* This file is copied from https://github.com/intel/linux-sgx/blob/4589daddd58bec7367a6a9de3fe301e6de17671a/common/inc/internal/sgx_rsrv_mem_mngr.h
* This file is copied from
* https://github.com/intel/linux-sgx/blob/4589daddd58bec7367a6a9de3fe301e6de17671a/common/inc/internal/sgx_rsrv_mem_mngr.h
* The reason we copied here is that the official SGX SDK release has
* not included this header file yet.
*/
@ -52,39 +53,43 @@
extern "C" {
#endif
/* Allocate a range of EPC memory from the reserved memory area with RW permission
/* Allocate a range of EPC memory from the reserved memory area with RW
* permission
*
* Parameters:
* Inputs: length [in]: Size of region to be allocated in bytes. Page aligned
* Return: Starting address of the new allocated memory area on success; otherwise NULL
* Inputs: length [in]: Size of region to be allocated in bytes. Page aligned.
* Return: Starting address of the new allocated memory area on success;
* otherwise NULL
*/
void * sgx_alloc_rsrv_mem(size_t length);
void *
sgx_alloc_rsrv_mem(size_t length);
/* Free a range of EPC memory from the reserved memory area
/* Free a range of EPC memory from the reserved memory area
*
* Parameters:
* Inputs: addr[in]: Starting address of region to be freed. Page aligned.
* length[in]: The length of the memory to be freed in bytes. Page aligned
* length[in]: The length of the memory to be freed in bytes.
* Page aligned.
* Return: 0 on success; otherwise -1
*/
int sgx_free_rsrv_mem(void * addr, size_t length);
int
sgx_free_rsrv_mem(void *addr, size_t length);
/* Modify the access permissions of the pages in the reserved memory area.
/* Modify the access permissions of the pages in the reserved memory area.
*
* Parameters:
* Inputs: addr[in]: Starting address of region which needs to change access permission. Page aligned.
* length[in]: The length of the memory to be manipulated in bytes. Page aligned.
* Inputs: addr[in]: Starting address of region which needs to change access
* permission. Page aligned.
* length[in]: The length of the memory to be manipulated in bytes.
* Page aligned.
* prot[in]: The target memory protection.
* Return: sgx_status_t - SGX_SUCCESS or failure as defined in sgx_error.h
*/
sgx_status_t sgx_tprotect_rsrv_mem(void *addr, size_t len, int prot);
sgx_status_t
sgx_tprotect_rsrv_mem(void *addr, size_t len, int prot);
#ifdef __cplusplus
}
#endif
#endif

7
core/shared/platform/linux-sgx/sgx_signal.c
View File

@ -9,9 +9,11 @@
#define TRACE_OCALL_FAIL() os_printf("ocall %s failed!\n", __FUNCTION__)
int ocall_raise(int *p_ret, int sig);
int
ocall_raise(int *p_ret, int sig);
int raise(int sig)
int
raise(int sig)
{
int ret;
@ -27,4 +29,3 @@ int raise(int sig)
}
#endif

4
core/shared/platform/linux-sgx/sgx_signal.h
View File

@ -47,11 +47,11 @@ extern "C" {
#define SIGSYS 31 /* Bad system call. */
#define SIGUNUSED 31
int raise(int sig);
int
raise(int sig);
#ifdef __cplusplus
}
#endif
#endif /* end of _SGX_SIGNAL_H */

52
core/shared/platform/linux-sgx/sgx_socket.c
View File

@ -9,18 +9,23 @@
#define TRACE_OCALL_FAIL() os_printf("ocall %s failed!\n", __FUNCTION__)
int ocall_socket(int *p_ret, int domain, int type, int protocol);
int ocall_getsockopt(int *p_ret, int sockfd, int level, int optname,
void *val_buf, unsigned int val_buf_size,
void *len_buf);
int
ocall_socket(int *p_ret, int domain, int type, int protocol);
int
ocall_getsockopt(int *p_ret, int sockfd, int level, int optname, void *val_buf,
unsigned int val_buf_size, void *len_buf);
int ocall_sendmsg(ssize_t *p_ret, int sockfd, void *msg_buf,
int
ocall_sendmsg(ssize_t *p_ret, int sockfd, void *msg_buf,
unsigned int msg_buf_size, int flags);
int ocall_recvmsg(ssize_t *p_ret, int sockfd, void *msg_buf,
int
ocall_recvmsg(ssize_t *p_ret, int sockfd, void *msg_buf,
unsigned int msg_buf_size, int flags);
int ocall_shutdown(int *p_ret, int sockfd, int how);
int
ocall_shutdown(int *p_ret, int sockfd, int how);
int socket(int domain, int type, int protocol)
int
socket(int domain, int type, int protocol)
{
int ret;
@ -35,14 +40,15 @@ int socket(int domain, int type, int protocol)
return ret;
}
int getsockopt(int sockfd, int level, int optname,
void *optval, socklen_t *optlen)
int
getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen)
{
int ret;
unsigned int val_buf_size = *optlen;
if (ocall_getsockopt(&ret, sockfd, level, optname, optval,
val_buf_size, (void *)optlen) != SGX_SUCCESS) {
if (ocall_getsockopt(&ret, sockfd, level, optname, optval, val_buf_size,
(void *)optlen)
!= SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
@ -53,7 +59,8 @@ int getsockopt(int sockfd, int level, int optname,
return ret;
}
ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags)
ssize_t
sendmsg(int sockfd, const struct msghdr *msg, int flags)
{
ssize_t ret;
int i;
@ -77,7 +84,7 @@ ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags)
if (msg1 == NULL)
return -1;
p = (char*)(uintptr_t)sizeof(struct msghdr);
p = (char *)(uintptr_t)sizeof(struct msghdr);
if (msg->msg_name != NULL) {
msg1->msg_name = p;
@ -106,8 +113,8 @@ ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags)
}
}
if (ocall_sendmsg(&ret, sockfd, (void *)msg1, (uint32)total_size,
flags) != SGX_SUCCESS) {
if (ocall_sendmsg(&ret, sockfd, (void *)msg1, (uint32)total_size, flags)
!= SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
@ -118,7 +125,8 @@ ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags)
return ret;
}
ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags)
ssize_t
recvmsg(int sockfd, struct msghdr *msg, int flags)
{
ssize_t ret;
int i;
@ -144,7 +152,7 @@ ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags)
memset(msg1, 0, total_size);
p = (char*)(uintptr_t)sizeof(struct msghdr);
p = (char *)(uintptr_t)sizeof(struct msghdr);
if (msg->msg_name != NULL) {
msg1->msg_name = p;
@ -167,8 +175,8 @@ ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags)
}
}
if (ocall_recvmsg(&ret, sockfd, (void *)msg1, (uint32)total_size,
flags) != SGX_SUCCESS) {
if (ocall_recvmsg(&ret, sockfd, (void *)msg1, (uint32)total_size, flags)
!= SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
@ -203,7 +211,8 @@ ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags)
return ret;
}
int shutdown(int sockfd, int how)
int
shutdown(int sockfd, int how)
{
int ret;
@ -219,4 +228,3 @@ int shutdown(int sockfd, int how)
}
#endif

18
core/shared/platform/linux-sgx/sgx_socket.h
View File

@ -54,21 +54,23 @@ struct msghdr {
int msg_flags;
};
int
socket(int domain, int type, int protocol);
int socket(int domain, int type, int protocol);
int
getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen);
int getsockopt(int sockfd, int level, int optname,
void *optval, socklen_t *optlen);
ssize_t
sendmsg(int sockfd, const struct msghdr *msg, int flags);
ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
ssize_t
recvmsg(int sockfd, struct msghdr *msg, int flags);
ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);
int shutdown(int sockfd, int how);
int
shutdown(int sockfd, int how);
#ifdef __cplusplus
}
#endif
#endif /* end of _SGX_SOCKET_H */

56
core/shared/platform/linux-sgx/sgx_thread.c
View File

@ -12,9 +12,10 @@ typedef struct {
void *arg;
} thread_wrapper_arg;
static void *os_thread_wrapper(void *arg)
static void *
os_thread_wrapper(void *arg)
{
thread_wrapper_arg * targ = arg;
thread_wrapper_arg *targ = arg;
thread_start_routine_t start_func = targ->start;
void *thread_arg = targ->arg;
os_printf("THREAD CREATED %p\n", &targ);
@ -23,7 +24,8 @@ static void *os_thread_wrapper(void *arg)
return NULL;
}
int os_thread_create_with_prio(korp_tid *tid, thread_start_routine_t start,
int
os_thread_create_with_prio(korp_tid *tid, thread_start_routine_t start,
void *arg, unsigned int stack_size, int prio)
{
thread_wrapper_arg *targ;
@ -31,7 +33,7 @@ int os_thread_create_with_prio(korp_tid *tid, thread_start_routine_t start,
assert(tid);
assert(start);
targ = (thread_wrapper_arg *) BH_MALLOC(sizeof(*targ));
targ = (thread_wrapper_arg *)BH_MALLOC(sizeof(*targ));
if (!targ) {
return BHT_ERROR;
}
@ -47,7 +49,8 @@ int os_thread_create_with_prio(korp_tid *tid, thread_start_routine_t start,
return BHT_OK;
}
int os_thread_create(korp_tid *tid, thread_start_routine_t start, void *arg,
int
os_thread_create(korp_tid *tid, thread_start_routine_t start, void *arg,
unsigned int stack_size)
{
return os_thread_create_with_prio(tid, start, arg, stack_size,
@ -55,7 +58,8 @@ int os_thread_create(korp_tid *tid, thread_start_routine_t start, void *arg,
}
#endif
korp_tid os_self_thread()
korp_tid
os_self_thread()
{
#ifndef SGX_DISABLE_PTHREAD
return pthread_self();
@ -64,7 +68,8 @@ korp_tid os_self_thread()
#endif
}
int os_mutex_init(korp_mutex *mutex)
int
os_mutex_init(korp_mutex *mutex)
{
#ifndef SGX_DISABLE_PTHREAD
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
@ -73,7 +78,8 @@ int os_mutex_init(korp_mutex *mutex)
return BHT_OK;
}
int os_mutex_destroy(korp_mutex *mutex)
int
os_mutex_destroy(korp_mutex *mutex)
{
#ifndef SGX_DISABLE_PTHREAD
pthread_mutex_destroy(mutex);
@ -81,7 +87,8 @@ int os_mutex_destroy(korp_mutex *mutex)
return BHT_OK;
}
int os_mutex_lock(korp_mutex *mutex)
int
os_mutex_lock(korp_mutex *mutex)
{
#ifndef SGX_DISABLE_PTHREAD
return pthread_mutex_lock(mutex);
@ -90,7 +97,8 @@ int os_mutex_lock(korp_mutex *mutex)
#endif
}
int os_mutex_unlock(korp_mutex *mutex)
int
os_mutex_unlock(korp_mutex *mutex)
{
#ifndef SGX_DISABLE_PTHREAD
return pthread_mutex_unlock(mutex);
@ -99,7 +107,8 @@ int os_mutex_unlock(korp_mutex *mutex)
#endif
}
int os_cond_init(korp_cond *cond)
int
os_cond_init(korp_cond *cond)
{
#ifndef SGX_DISABLE_PTHREAD
pthread_cond_t c = PTHREAD_COND_INITIALIZER;
@ -108,7 +117,8 @@ int os_cond_init(korp_cond *cond)
return BHT_OK;
}
int os_cond_destroy(korp_cond *cond)
int
os_cond_destroy(korp_cond *cond)
{
#ifndef SGX_DISABLE_PTHREAD
pthread_cond_destroy(cond);
@ -116,7 +126,8 @@ int os_cond_destroy(korp_cond *cond)
return BHT_OK;
}
int os_cond_wait(korp_cond *cond, korp_mutex *mutex)
int
os_cond_wait(korp_cond *cond, korp_mutex *mutex)
{
#ifndef SGX_DISABLE_PTHREAD
assert(cond);
@ -129,14 +140,16 @@ int os_cond_wait(korp_cond *cond, korp_mutex *mutex)
return BHT_OK;
}
int os_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, uint64 useconds)
int
os_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, uint64 useconds)
{
os_printf("warning: SGX pthread_cond_timedwait isn't supported, "
"calling pthread_cond_wait instead!\n");
return BHT_ERROR;
}
int os_cond_signal(korp_cond *cond)
int
os_cond_signal(korp_cond *cond)
{
#ifndef SGX_DISABLE_PTHREAD
assert(cond);
@ -148,7 +161,8 @@ int os_cond_signal(korp_cond *cond)
return BHT_OK;
}
int os_thread_join(korp_tid thread, void **value_ptr)
int
os_thread_join(korp_tid thread, void **value_ptr)
{
#ifndef SGX_DISABLE_PTHREAD
return pthread_join(thread, value_ptr);
@ -157,13 +171,15 @@ int os_thread_join(korp_tid thread, void **value_ptr)
#endif
}
int os_thread_detach(korp_tid thread)
int
os_thread_detach(korp_tid thread)
{
/* SGX pthread_detach isn't provided, return directly. */
return 0;
}
void os_thread_exit(void *retval)
void
os_thread_exit(void *retval)
{
#ifndef SGX_DISABLE_PTHREAD
pthread_exit(retval);
@ -172,9 +188,9 @@ void os_thread_exit(void *retval)
#endif
}
uint8 *os_thread_get_stack_boundary()
uint8 *
os_thread_get_stack_boundary()
{
/* TODO: get sgx stack boundary */
return NULL;
}

65
core/shared/platform/linux-sgx/sgx_time.c
View File

@ -8,16 +8,20 @@
#define TRACE_FUNC() os_printf("undefined %s\n", __FUNCTION__)
#define TRACE_OCALL_FAIL() os_printf("ocall %s failed!\n", __FUNCTION__)
int ocall_clock_gettime(int *p_ret, unsigned clock_id,
void *tp_buf, unsigned int tp_buf_size);
int ocall_clock_getres(int *p_ret, int clock_id,
void *res_buf, unsigned int res_buf_size);
int ocall_utimensat(int *p_ret, int dirfd, const char *pathname,
const void *times_buf, unsigned int times_buf_size,
int flags);
int ocall_futimens(int *p_ret, int fd,
const void *times_buf, unsigned int times_buf_size);
int ocall_clock_nanosleep(int *p_ret, unsigned clock_id, int flags,
int
ocall_clock_gettime(int *p_ret, unsigned clock_id, void *tp_buf,
unsigned int tp_buf_size);
int
ocall_clock_getres(int *p_ret, int clock_id, void *res_buf,
unsigned int res_buf_size);
int
ocall_utimensat(int *p_ret, int dirfd, const char *pathname,
const void *times_buf, unsigned int times_buf_size, int flags);
int
ocall_futimens(int *p_ret, int fd, const void *times_buf,
unsigned int times_buf_size);
int
ocall_clock_nanosleep(int *p_ret, unsigned clock_id, int flags,
const void *req_buf, unsigned int req_buf_size,
const void *rem_buf, unsigned int rem_buf_size);
@ -30,12 +34,13 @@ os_time_get_boot_microsecond()
#ifndef SGX_DISABLE_WASI
int clock_getres(int clock_id, struct timespec *res)
int
clock_getres(int clock_id, struct timespec *res)
{
int ret;
if (ocall_clock_getres(&ret, clock_id, (void *)res,
sizeof(struct timespec)) != SGX_SUCCESS) {
if (ocall_clock_getres(&ret, clock_id, (void *)res, sizeof(struct timespec))
!= SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
@ -46,12 +51,13 @@ int clock_getres(int clock_id, struct timespec *res)
return ret;
}
int clock_gettime(clockid_t clock_id, struct timespec *tp)
int
clock_gettime(clockid_t clock_id, struct timespec *tp)
{
int ret;
if(ocall_clock_gettime(&ret, clock_id, (void *)tp,
sizeof(struct timespec)) != SGX_SUCCESS) {
if (ocall_clock_gettime(&ret, clock_id, (void *)tp, sizeof(struct timespec))
!= SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
@ -62,14 +68,15 @@ int clock_gettime(clockid_t clock_id, struct timespec *tp)
return ret;
}
int utimensat(int dirfd, const char *pathname,
const struct timespec times[2], int flags)
int
utimensat(int dirfd, const char *pathname, const struct timespec times[2],
int flags)
{
int ret;
if (ocall_utimensat(&ret, dirfd, pathname, (void *)times,
sizeof(struct timespec) * 2,
flags) != SGX_SUCCESS) {
sizeof(struct timespec) * 2, flags)
!= SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
@ -80,12 +87,13 @@ int utimensat(int dirfd, const char *pathname,
return ret;
}
int futimens(int fd, const struct timespec times[2])
int
futimens(int fd, const struct timespec times[2])
{
int ret;
if (ocall_futimens(&ret, fd, (void *)times,
sizeof(struct timespec) * 2) != SGX_SUCCESS) {
if (ocall_futimens(&ret, fd, (void *)times, sizeof(struct timespec) * 2)
!= SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
@ -96,16 +104,16 @@ int futimens(int fd, const struct timespec times[2])
return ret;
}
int clock_nanosleep(clockid_t clock_id, int flags,
const struct timespec *request,
int
clock_nanosleep(clockid_t clock_id, int flags, const struct timespec *request,
struct timespec *remain)
{
int ret;
if (ocall_clock_nanosleep(&ret, clock_id, flags, (void *)request,
sizeof(struct timespec),
(void *)remain,
sizeof(struct timespec)) != SGX_SUCCESS) {
sizeof(struct timespec), (void *)remain,
sizeof(struct timespec))
!= SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
@ -117,4 +125,3 @@ int clock_nanosleep(clockid_t clock_id, int flags,
}
#endif

19
core/shared/platform/linux-sgx/sgx_time.h
View File

@ -28,15 +28,19 @@ struct timespec {
long tv_nsec;
};
int clock_getres(int clock_id, struct timespec *res);
int
clock_getres(int clock_id, struct timespec *res);
int clock_gettime(clockid_t clock_id, struct timespec *tp);
int
clock_gettime(clockid_t clock_id, struct timespec *tp);
int utimensat(int dirfd, const char *pathname,
const struct timespec times[2], int flags);
int futimens(int fd, const struct timespec times[2]);
int clock_nanosleep(clockid_t clock_id, int flags,
const struct timespec *request,
int
utimensat(int dirfd, const char *pathname, const struct timespec times[2],
int flags);
int
futimens(int fd, const struct timespec times[2]);
int
clock_nanosleep(clockid_t clock_id, int flags, const struct timespec *request,
struct timespec *remain);
#ifdef __cplusplus
@ -44,4 +48,3 @@ int clock_nanosleep(clockid_t clock_id, int flags,
#endif
#endif /* end of _SGX_TIME_H */

135
core/shared/platform/linux-sgx/untrusted/file.c
View File

@ -19,8 +19,8 @@
#include <poll.h>
#include <errno.h>
int ocall_open(const char *pathname, int flags,
bool has_mode, unsigned mode)
int
ocall_open(const char *pathname, int flags, bool has_mode, unsigned mode)
{
if (has_mode) {
return open(pathname, flags, (mode_t)mode);
@ -30,9 +30,9 @@ int ocall_open(const char *pathname, int flags,
}
}
int ocall_openat(int dirfd,
const char *pathname, int flags,
bool has_mode, unsigned mode)
int
ocall_openat(int dirfd, const char *pathname, int flags, bool has_mode,
unsigned mode)
{
if (has_mode) {
return openat(dirfd, pathname, flags, (mode_t)mode);
@ -42,12 +42,14 @@ int ocall_openat(int dirfd,
}
}
int ocall_close(int fd)
int
ocall_close(int fd)
{
return close(fd);
}
ssize_t ocall_read(int fd, void *buf, size_t read_size)
ssize_t
ocall_read(int fd, void *buf, size_t read_size)
{
if (buf != NULL) {
return read(fd, buf, read_size);
@ -57,45 +59,53 @@ ssize_t ocall_read(int fd, void *buf, size_t read_size)
}
}
off_t ocall_lseek(int fd, off_t offset, int whence)
off_t
ocall_lseek(int fd, off_t offset, int whence)
{
return lseek(fd, offset, whence);
}
int ocall_ftruncate(int fd, off_t length)
int
ocall_ftruncate(int fd, off_t length)
{
return ftruncate(fd, length);
}
int ocall_fsync(int fd)
int
ocall_fsync(int fd)
{
return fsync(fd);
}
int ocall_fdatasync(int fd)
int
ocall_fdatasync(int fd)
{
return fdatasync(fd);
}
int ocall_isatty(int fd)
int
ocall_isatty(int fd)
{
return isatty(fd);
}
void ocall_fdopendir(int fd, void **dirp)
void
ocall_fdopendir(int fd, void **dirp)
{
if (dirp) {
*(DIR **)dirp = fdopendir(fd);
}
}
void *ocall_readdir(void *dirp)
void *
ocall_readdir(void *dirp)
{
DIR *p_dirp = (DIR *)dirp;
return readdir(p_dirp);
}
void ocall_rewinddir(void *dirp)
void
ocall_rewinddir(void *dirp)
{
DIR *p_dirp = (DIR *)dirp;
if (p_dirp) {
@ -103,7 +113,8 @@ void ocall_rewinddir(void *dirp)
}
}
void ocall_seekdir(void *dirp, long loc)
void
ocall_seekdir(void *dirp, long loc)
{
DIR *p_dirp = (DIR *)dirp;
@ -112,7 +123,8 @@ void ocall_seekdir(void *dirp, long loc)
}
}
long ocall_telldir(void *dirp)
long
ocall_telldir(void *dirp)
{
DIR *p_dirp = (DIR *)dirp;
if (p_dirp) {
@ -121,7 +133,8 @@ long ocall_telldir(void *dirp)
return -1;
}
int ocall_closedir(void* dirp)
int
ocall_closedir(void *dirp)
{
DIR *p_dirp = (DIR *)dirp;
if (p_dirp) {
@ -130,81 +143,90 @@ int ocall_closedir(void* dirp)
return -1;
}
int ocall_stat(const char *pathname,
void *buf, unsigned int buf_len)
int
ocall_stat(const char *pathname, void *buf, unsigned int buf_len)
{
return stat(pathname, (struct stat *)buf);
}
int ocall_fstat(int fd, void *buf, unsigned int buf_len)
int
ocall_fstat(int fd, void *buf, unsigned int buf_len)
{
return fstat(fd, (struct stat *)buf);
}
int ocall_fstatat(int dirfd, const char *pathname, void *buf,
unsigned int buf_len, int flags)
int
ocall_fstatat(int dirfd, const char *pathname, void *buf, unsigned int buf_len,
int flags)
{
return fstatat(dirfd, pathname, (struct stat *)buf, flags);
}
int ocall_mkdirat(int dirfd, const char *pathname, unsigned mode)
int
ocall_mkdirat(int dirfd, const char *pathname, unsigned mode)
{
return mkdirat(dirfd, pathname, (mode_t)mode);
}
int ocall_link(const char *oldpath, const char *newpath)
int
ocall_link(const char *oldpath, const char *newpath)
{
return link(oldpath, newpath);
}
int ocall_linkat(int olddirfd, const char *oldpath,
int newdirfd, const char *newpath, int flags)
int
ocall_linkat(int olddirfd, const char *oldpath, int newdirfd,
const char *newpath, int flags)
{
return linkat(olddirfd, oldpath, newdirfd, newpath, flags);
}
int ocall_unlinkat(int dirfd, const char *pathname, int flags)
int
ocall_unlinkat(int dirfd, const char *pathname, int flags)
{
return unlinkat(dirfd, pathname, flags);
}
ssize_t ocall_readlinkat(int dirfd, const char *pathname,
char *buf, size_t bufsiz)
ssize_t
ocall_readlinkat(int dirfd, const char *pathname, char *buf, size_t bufsiz)
{
return readlinkat(dirfd, pathname, buf, bufsiz);
}
int ocall_renameat(int olddirfd, const char *oldpath,
int newdirfd, const char *newpath)
int
ocall_renameat(int olddirfd, const char *oldpath, int newdirfd,
const char *newpath)
{
return renameat(olddirfd, oldpath, newdirfd, newpath);
}
int ocall_symlinkat(const char *target, int newdirfd,
const char *linkpath)
int
ocall_symlinkat(const char *target, int newdirfd, const char *linkpath)
{
return symlinkat(target, newdirfd, linkpath);
}
int ocall_ioctl(int fd, unsigned long request,
void *arg, unsigned int arg_len)
int
ocall_ioctl(int fd, unsigned long request, void *arg, unsigned int arg_len)
{
/* support just int *arg temporally */
return ioctl(fd, request, (int *)arg);
}
int ocall_fcntl(int fd, int cmd)
int
ocall_fcntl(int fd, int cmd)
{
return fcntl(fd, cmd);
}
int ocall_fcntl_long(int fd, int cmd, long arg)
int
ocall_fcntl_long(int fd, int cmd, long arg)
{
return fcntl(fd, cmd, arg);
}
ssize_t ocall_readv(int fd, char *iov_buf,
unsigned int buf_size, int iovcnt,
ssize_t
ocall_readv(int fd, char *iov_buf, unsigned int buf_size, int iovcnt,
bool has_offset, off_t offset)
{
struct iovec *iov = (struct iovec *)iov_buf;
@ -223,8 +245,8 @@ ssize_t ocall_readv(int fd, char *iov_buf,
return ret;
}
ssize_t ocall_writev(int fd, char *iov_buf,
unsigned int buf_size, int iovcnt,
ssize_t
ocall_writev(int fd, char *iov_buf, unsigned int buf_size, int iovcnt,
bool has_offset, off_t offset)
{
struct iovec *iov = (struct iovec *)iov_buf;
@ -243,9 +265,10 @@ ssize_t ocall_writev(int fd, char *iov_buf,
return ret;
}
int ocall_realpath(const char *path, char *buf, unsigned int buf_len)
int
ocall_realpath(const char *path, char *buf, unsigned int buf_len)
{
char* val = NULL;
char *val = NULL;
val = realpath(path, buf);
if (val != NULL) {
return 0;
@ -253,47 +276,53 @@ int ocall_realpath(const char *path, char *buf, unsigned int buf_len)
return -1;
}
int ocall_posix_fallocate(int fd, off_t offset, off_t len)
int
ocall_posix_fallocate(int fd, off_t offset, off_t len)
{
return posix_fallocate(fd, offset, len);
}
int ocall_poll(void *fds, unsigned nfds, int timeout,
unsigned int fds_len)
int
ocall_poll(void *fds, unsigned nfds, int timeout, unsigned int fds_len)
{
return poll((struct pollfd *)fds, (nfds_t)nfds, timeout);
}
int ocall_getopt(int argc, char *argv_buf, unsigned int argv_buf_len,
int
ocall_getopt(int argc, char *argv_buf, unsigned int argv_buf_len,
const char *optstring)
{
int ret;
int i;
char **argv = (char **)argv_buf;
for (i=0; i < argc; i++) {
for (i = 0; i < argc; i++) {
argv[i] = argv_buf + (uintptr_t)argv[i];
}
return getopt(argc, argv, optstring);
}
ssize_t ocall_getrandom(void *buf, size_t buflen, unsigned int flags)
ssize_t
ocall_getrandom(void *buf, size_t buflen, unsigned int flags)
{
return getrandom(buf, buflen, flags);
}
int ocall_getentropy(void *buffer, size_t length)
int
ocall_getentropy(void *buffer, size_t length)
{
return getentropy(buffer, length);
}
int ocall_sched_yield()
int
ocall_sched_yield()
{
return sched_yield();
}
int ocall_get_errno()
int
ocall_get_errno()
{
return errno;
}

16
core/shared/platform/linux-sgx/untrusted/pthread.c
View File

@ -6,7 +6,8 @@
#include <stdlib.h>
#include <pthread.h>
int ocall_pthread_rwlock_init(void **rwlock, void *attr)
int
ocall_pthread_rwlock_init(void **rwlock, void *attr)
{
int ret = 0;
@ -23,7 +24,8 @@ int ocall_pthread_rwlock_init(void **rwlock, void *attr)
return ret;
}
int ocall_pthread_rwlock_destroy(void *rwlock)
int
ocall_pthread_rwlock_destroy(void *rwlock)
{
pthread_rwlock_t *lock = (pthread_rwlock_t *)rwlock;
int ret;
@ -33,18 +35,20 @@ int ocall_pthread_rwlock_destroy(void *rwlock)
return ret;
}
int ocall_pthread_rwlock_rdlock(void *rwlock)
int
ocall_pthread_rwlock_rdlock(void *rwlock)
{
return pthread_rwlock_rdlock((pthread_rwlock_t *)rwlock);
}
int ocall_pthread_rwlock_wrlock(void *rwlock)
int
ocall_pthread_rwlock_wrlock(void *rwlock)
{
return pthread_rwlock_wrlock((pthread_rwlock_t *)rwlock);
}
int ocall_pthread_rwlock_unlock(void *rwlock)
int
ocall_pthread_rwlock_unlock(void *rwlock)
{
return pthread_rwlock_unlock((pthread_rwlock_t *)rwlock);
}

3
core/shared/platform/linux-sgx/untrusted/signal.c
View File

@ -4,7 +4,8 @@
*/
#include <signal.h>
int ocall_raise(int sig)
int
ocall_raise(int sig)
{
return raise(sig);
}

30
core/shared/platform/linux-sgx/untrusted/socket.c
View File

@ -7,20 +7,21 @@
#include <stdint.h>
#include <stddef.h>
int ocall_socket(int domain, int type, int protocol)
int
ocall_socket(int domain, int type, int protocol)
{
return socket(domain, type, protocol);
}
int ocall_getsockopt(int sockfd, int level, int optname, void *val_buf,
int
ocall_getsockopt(int sockfd, int level, int optname, void *val_buf,
unsigned int val_buf_size, void *len_buf)
{
return getsockopt(sockfd, level, optname, val_buf,
(socklen_t *)len_buf);
return getsockopt(sockfd, level, optname, val_buf, (socklen_t *)len_buf);
}
ssize_t ocall_sendmsg(int sockfd, void *msg_buf,
unsigned int msg_buf_size, int flags)
ssize_t
ocall_sendmsg(int sockfd, void *msg_buf, unsigned int msg_buf_size, int flags)
{
struct msghdr *msg = (struct msghdr *)msg_buf;
int i;
@ -35,16 +36,16 @@ ssize_t ocall_sendmsg(int sockfd, void *msg_buf,
if (msg->msg_iov != NULL) {
msg->msg_iov = msg_buf + (unsigned)(uintptr_t)msg->msg_iov;
for (i = 0; i < msg->msg_iovlen; i++) {
msg->msg_iov[i].iov_base = msg_buf + (unsigned)(uintptr_t)
msg->msg_iov[i].iov_base;
msg->msg_iov[i].iov_base =
msg_buf + (unsigned)(uintptr_t)msg->msg_iov[i].iov_base;
}
}
return sendmsg(sockfd, msg, flags);
}
ssize_t ocall_recvmsg(int sockfd, void *msg_buf, unsigned int msg_buf_size,
int flags)
ssize_t
ocall_recvmsg(int sockfd, void *msg_buf, unsigned int msg_buf_size, int flags)
{
struct msghdr *msg = (struct msghdr *)msg_buf;
int i;
@ -58,16 +59,17 @@ ssize_t ocall_recvmsg(int sockfd, void *msg_buf, unsigned int msg_buf_size,
if (msg->msg_iov != NULL) {
msg->msg_iov = msg_buf + (unsigned)(uintptr_t)msg->msg_iov;
for (i = 0; i <msg->msg_iovlen; i++) {
msg->msg_iov[i].iov_base = msg_buf + (unsigned)(uintptr_t)
msg->msg_iov[i].iov_base;
for (i = 0; i < msg->msg_iovlen; i++) {
msg->msg_iov[i].iov_base =
msg_buf + (unsigned)(uintptr_t)msg->msg_iov[i].iov_base;
}
}
return recvmsg(sockfd, msg, flags);
}
int ocall_shutdown(int sockfd, int how)
int
ocall_shutdown(int sockfd, int how)
{
return shutdown(sockfd, how);
}

29
core/shared/platform/linux-sgx/untrusted/time.c
View File

@ -7,41 +7,38 @@
#include <time.h>
#include <fcntl.h>
/** time clock **/
int ocall_clock_gettime(unsigned clock_id, void *tp_buf,
unsigned int tp_buf_size)
int
ocall_clock_gettime(unsigned clock_id, void *tp_buf, unsigned int tp_buf_size)
{
return clock_gettime((clockid_t)clock_id,
(struct timespec *)tp_buf);
return clock_gettime((clockid_t)clock_id, (struct timespec *)tp_buf);
}
int ocall_clock_getres(int clock_id, void *res_buf,
unsigned int res_buf_size)
int
ocall_clock_getres(int clock_id, void *res_buf, unsigned int res_buf_size)
{
return clock_getres(clock_id, (struct timespec *)res_buf);
}
int ocall_utimensat(int dirfd, const char *pathname,
const void *times_buf,
int
ocall_utimensat(int dirfd, const char *pathname, const void *times_buf,
unsigned int times_buf_size, int flags)
{
return utimensat(dirfd, pathname, (struct timespec *)times_buf, flags);
}
int ocall_futimens(int fd, const void *times_buf,
unsigned int times_buf_size)
int
ocall_futimens(int fd, const void *times_buf, unsigned int times_buf_size)
{
return futimens(fd, (struct timespec *)times_buf);
}
int ocall_clock_nanosleep(unsigned clock_id, int flags,
const void *req_buf, unsigned int req_buf_size,
const void *rem_buf, unsigned int rem_buf_size)
int
ocall_clock_nanosleep(unsigned clock_id, int flags, const void *req_buf,
unsigned int req_buf_size, const void *rem_buf,
unsigned int rem_buf_size)
{
return clock_nanosleep((clockid_t)clock_id, flags,
(struct timespec *)req_buf,
(struct timespec *)rem_buf);
}

4
core/shared/platform/linux/platform_init.c
View File

@ -13,8 +13,7 @@ bh_platform_init()
void
bh_platform_destroy()
{
}
{}
int
os_printf(const char *format, ...)
@ -42,4 +41,3 @@ os_vprintf(const char *format, va_list ap)
return BH_VPRINTF(format, ap);
#endif
}

22
core/shared/platform/linux/platform_internal.h
View File

@ -59,10 +59,8 @@ typedef pthread_t korp_thread;
#define os_thread_local_attribute __thread
#if WASM_DISABLE_HW_BOUND_CHECK == 0
#if defined(BUILD_TARGET_X86_64) \
|| defined(BUILD_TARGET_AMD_64) \
|| defined(BUILD_TARGET_AARCH64) \
|| defined(BUILD_TARGET_RISCV64_LP64D) \
#if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64) \
|| defined(BUILD_TARGET_AARCH64) || defined(BUILD_TARGET_RISCV64_LP64D) \
|| defined(BUILD_TARGET_RISCV64_LP64)
#include <setjmp.h>
@ -79,15 +77,20 @@ typedef jmp_buf korp_jmpbuf;
typedef void (*os_signal_handler)(void *sig_addr);
int os_thread_signal_init(os_signal_handler handler);
int
os_thread_signal_init(os_signal_handler handler);
void os_thread_signal_destroy();
void
os_thread_signal_destroy();
bool os_thread_signal_inited();
bool
os_thread_signal_inited();
void os_signal_unmask();
void
os_signal_unmask();
void os_sigreturn();
void
os_sigreturn();
#endif /* end of BUILD_TARGET_X86_64/AMD_64/AARCH64/RISCV64 */
#endif /* end of WASM_DISABLE_HW_BOUND_CHECK */
@ -96,4 +99,3 @@ void os_sigreturn();
#endif
#endif /* end of _PLATFORM_INTERNAL_H */

9
core/shared/platform/riot/platform_internal.h
View File

@ -7,12 +7,12 @@
#ifndef _PLATFORM_INTERNAL_H
#define _PLATFORM_INTERNAL_H
//Riot includes core
/* Riot includes core */
#include <sched.h>
#include <thread.h>
#include <mutex.h>
//Riot includes sys
/* Riot includes sys */
#include <sema.h>
#include <inttypes.h>
@ -39,7 +39,7 @@ typedef thread_t korp_thread;
typedef kernel_pid_t korp_tid;
typedef mutex_t korp_mutex;
// typedef sema_t korp_sem;
/* typedef sema_t korp_sem; */
struct os_thread_wait_node;
typedef struct os_thread_wait_node *os_thread_wait_list;
@ -52,6 +52,7 @@ typedef struct korp_cond {
#define os_vprintf vprintf
#if WA_MATH
/* clang-format off */
/* math functions which are not provided by os*/
double sqrt(double x);
double floor(double x);
@ -69,7 +70,7 @@ float rintf(float x);
float truncf(float x);
int signbit(double x);
int isnan(double x);
/* clang-format on */
#endif
#endif /* end of _BH_PLATFORM_H */

78
core/shared/platform/riot/riot_thread.c
View File

@ -9,19 +9,21 @@
#include <panic.h>
/* clang-format off */
#define bh_assert(v) do { \
if (!(v)) { \
printf("\nASSERTION FAILED: %s, at %s, line %d\n", \
#v, __FILE__, __LINE__); \
core_panic(0,0/*expr_string*/); \
core_panic(0, 0/*expr_string*/); \
while (1); \
} \
} while (0)
} while (0)
/* clang-format on */
struct os_thread_data;
typedef struct os_thread_wait_node {
sema_t sem;
void * ret;
void *ret;
os_thread_wait_list next;
} os_thread_wait_node;
@ -63,7 +65,8 @@ static mutex_t thread_data_lock;
/* Thread data list */
static os_thread_data *thread_data_list = NULL;
static void thread_data_list_add(os_thread_data *thread_data)
static void
thread_data_list_add(os_thread_data *thread_data)
{
mutex_lock(&thread_data_lock);
if (!thread_data_list)
@ -86,7 +89,8 @@ static void thread_data_list_add(os_thread_data *thread_data)
mutex_unlock(&thread_data_lock);
}
static void thread_data_list_remove(os_thread_data *thread_data)
static void
thread_data_list_remove(os_thread_data *thread_data)
{
mutex_lock(&thread_data_lock);
if (thread_data_list) {
@ -153,7 +157,7 @@ thread_data_current()
static void
os_thread_cleanup(void)
{
//TODO Check this (Join sema trigger, cleanup of thread_data)
// TODO Check this (Join sema trigger, cleanup of thread_data)
os_thread_data *thread_data = thread_data_current();
bh_assert(thread_data != NULL);
mutex_lock(&thread_data->wait_list_lock);
@ -177,7 +181,7 @@ static void *
os_thread_wrapper(void *thread_data)
{
/* Set thread custom data */
os_thread_data * t = (os_thread_data*) thread_data;
os_thread_data *t = (os_thread_data *)thread_data;
t->tid = thread_getpid();
thread_data_list_add(t);
@ -187,13 +191,13 @@ os_thread_wrapper(void *thread_data)
os_thread_cleanup(); // internal structures and joiners
BH_FREE(thread_data);
sched_task_exit();// stop thread //clean
return NULL; //never reached
sched_task_exit(); // stop thread //clean
return NULL; // never reached
}
int
os_thread_create(korp_tid *p_tid, thread_start_routine_t start,
void *arg, unsigned int stack_size)
os_thread_create(korp_tid *p_tid, thread_start_routine_t start, void *arg,
unsigned int stack_size)
{
return os_thread_create_with_prio(p_tid, start, arg, stack_size,
BH_THREAD_DEFAULT_PRIORITY);
@ -223,8 +227,8 @@ os_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
thread_data->arg = arg;
/* Create the thread &*/
if (!((tid = thread_create( thread_data->stack,
stack_size,prio,0, os_thread_wrapper, thread_data,"WASM")))) {
if (!((tid = thread_create(thread_data->stack, stack_size, prio, 0,
os_thread_wrapper, thread_data, "WASM")))) {
BH_FREE(thread_data);
return BHT_ERROR;
}
@ -240,15 +244,14 @@ os_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
korp_tid
os_self_thread()
{
return (korp_tid) thread_getpid();
return (korp_tid)thread_getpid();
}
int
os_thread_join (korp_tid thread, void **value_ptr)
os_thread_join(korp_tid thread, void **value_ptr)
{
// will test if thread is still working,
// wait if it is
// (void) value_ptr;
os_thread_data *thread_data;
os_thread_wait_node node;
@ -257,8 +260,8 @@ os_thread_join (korp_tid thread, void **value_ptr)
/* Get thread data */
thread_data = thread_data_list_lookup(thread);
if(thread_data == NULL){
//thread not found
if (thread_data == NULL) {
// thread not found
sema_destroy(&node.sem);
return BHT_ERROR;
}
@ -277,22 +280,21 @@ os_thread_join (korp_tid thread, void **value_ptr)
mutex_unlock(&thread_data->wait_list_lock);
sema_wait(&node.sem);
//get the return value pointer conted may not be availible after return
if(value_ptr) (* value_ptr) = node.ret;
// get the return value pointer conted may not be availible after return
if (value_ptr)
(*value_ptr) = node.ret;
/* Wait some time for the thread to be actually terminated */
// TODO: k_sleep(100);
// TODO: k_sleep(100);
//TODO: bump target prio to make it finish and free its resources
// TODO: bump target prio to make it finish and free its resources
thread_yield();
//node has done its job
// node has done its job
sema_destroy(&node.sem);
return BHT_OK;
}
// int vm_mutex_trylock(korp_mutex *mutex)
// {
// return mutex_trylock(mutex);
@ -308,7 +310,7 @@ os_mutex_init(korp_mutex *mutex)
int
os_mutex_destroy(korp_mutex *mutex)
{
(void) mutex;
(void)mutex;
return BHT_OK;
}
@ -316,15 +318,14 @@ int
os_mutex_lock(korp_mutex *mutex)
{
mutex_lock(mutex);
return 0; //Riot mutexes do not return until success
return 0; // Riot mutexes do not return until success
}
int
os_mutex_unlock(korp_mutex *mutex)
{
mutex_unlock(mutex);
return 0; //Riot mutexes do not return until success
return 0; // Riot mutexes do not return until success
}
int
@ -338,13 +339,13 @@ os_cond_init(korp_cond *cond)
int
os_cond_destroy(korp_cond *cond)
{
(void) cond;
(void)cond;
return BHT_OK;
}
static int
os_cond_wait_internal(korp_cond *cond, korp_mutex *mutex,
bool timed, uint64 useconds)
os_cond_wait_internal(korp_cond *cond, korp_mutex *mutex, bool timed,
uint64 useconds)
{
os_thread_wait_node *node;
@ -369,10 +370,10 @@ os_cond_wait_internal(korp_cond *cond, korp_mutex *mutex,
/* Unlock mutex, wait sem and lock mutex again */
mutex_unlock(mutex);
if(timed)
if (timed)
sema_wait(&node->sem);
else
sema_wait_timed(&node->sem,useconds);
sema_wait_timed(&node->sem, useconds);
mutex_lock(mutex);
/* Remove wait node from wait list */
@ -401,8 +402,8 @@ os_cond_wait(korp_cond *cond, korp_mutex *mutex)
int
os_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, uint64 useconds)
{
return os_cond_wait_internal(cond, mutex,
(useconds != BHT_WAIT_FOREVER), useconds);
return os_cond_wait_internal(cond, mutex, (useconds != BHT_WAIT_FOREVER),
useconds);
}
int
@ -417,11 +418,12 @@ os_cond_signal(korp_cond *cond)
return BHT_OK;
}
uint8 *os_thread_get_stack_boundary()
uint8 *
os_thread_get_stack_boundary()
{
#if defined(DEVELHELP) || defined(SCHED_TEST_STACK) \
|| defined(MODULE_MPU_STACK_GUARD)
return (uint8*)thread_get_active()->stack_start;
return (uint8 *)thread_get_active()->stack_start;
#else
return NULL;
#endif

1
core/shared/platform/riot/riot_time.c
View File

@ -12,4 +12,3 @@ os_time_get_boot_microsecond()
{
return xtimer_now_usec64();
}

3
core/shared/platform/rt-thread/platform_internal.h
View File

@ -44,5 +44,4 @@ typedef rt_int16_t int16_t;
typedef rt_uint64_t uint64_t;
typedef rt_int64_t int64_t;
#endif //RTTHREAD_PLATFORM_INTERNAL_H
#endif /* RTTHREAD_PLATFORM_INTERNAL_H */

123
core/shared/platform/rt-thread/rtt_platform.c
View File

@ -8,67 +8,65 @@
#include <platform_api_extension.h>
typedef struct os_malloc_list {
void* real;
void* used;
void *real;
void *used;
rt_list_t node;
}os_malloc_list_t;
} os_malloc_list_t;
int bh_platform_init(void)
int
bh_platform_init(void)
{
return 0;
}
void bh_platform_destroy(void)
{
}
void
bh_platform_destroy(void)
{}
void *os_malloc(unsigned size)
void *
os_malloc(unsigned size)
{
void *buf_origin;
void *buf_fixed;
rt_ubase_t *addr_field;
buf_origin = rt_malloc(size + 8 + sizeof(rt_ubase_t));
buf_fixed = buf_origin + sizeof(void*);
if ((rt_ubase_t)buf_fixed & 0x7)
{
buf_fixed = (void*)((rt_ubase_t)(buf_fixed+8)&(~7));
buf_fixed = buf_origin + sizeof(void *);
if ((rt_ubase_t)buf_fixed & 0x7) {
buf_fixed = (void *)((rt_ubase_t)(buf_fixed + 8) & (~7));
}
addr_field = buf_fixed - sizeof(rt_ubase_t);
*addr_field = (rt_ubase_t )buf_origin;
*addr_field = (rt_ubase_t)buf_origin;
return buf_fixed;
}
void *os_realloc(void *ptr, unsigned size)
void *
os_realloc(void *ptr, unsigned size)
{
void* mem_origin;
void* mem_new;
void *mem_origin;
void *mem_new;
void *mem_new_fixed;
rt_ubase_t *addr_field;
if (!ptr)
{
if (!ptr) {
return RT_NULL;
}
addr_field = ptr - sizeof(rt_ubase_t);
mem_origin = (void*)(*addr_field);
mem_origin = (void *)(*addr_field);
mem_new = rt_realloc(mem_origin, size + 8 + sizeof(rt_ubase_t));
if (mem_origin != mem_new)
{
if (mem_origin != mem_new) {
mem_new_fixed = mem_new + sizeof(rt_ubase_t);
if ((rt_ubase_t)mem_new_fixed & 0x7)
{
mem_new_fixed = (void*)((rt_ubase_t)(mem_new_fixed+8)&(~7));
if ((rt_ubase_t)mem_new_fixed & 0x7) {
mem_new_fixed = (void *)((rt_ubase_t)(mem_new_fixed + 8) & (~7));
}
addr_field = mem_new_fixed - sizeof(rt_ubase_t);
*addr_field = (rt_ubase_t )mem_new;
*addr_field = (rt_ubase_t)mem_new;
return mem_new_fixed;
}
@ -76,115 +74,130 @@ void *os_realloc(void *ptr, unsigned size)
return ptr;
}
void os_free(void *ptr)
void
os_free(void *ptr)
{
void* mem_origin;
void *mem_origin;
rt_ubase_t *addr_field;
if (ptr)
{
if (ptr) {
addr_field = ptr - sizeof(rt_ubase_t);
mem_origin = (void*)(*addr_field);
mem_origin = (void *)(*addr_field);
rt_free(mem_origin);
}
}
static char wamr_vprint_buf[RT_CONSOLEBUF_SIZE * 2];
int os_printf(const char *format, ...)
int
os_printf(const char *format, ...)
{
va_list ap;
va_start(ap, format);
rt_size_t len = vsnprintf(wamr_vprint_buf, sizeof(wamr_vprint_buf)-1, format, ap);
rt_size_t len =
vsnprintf(wamr_vprint_buf, sizeof(wamr_vprint_buf) - 1, format, ap);
wamr_vprint_buf[len] = 0x00;
rt_kputs(wamr_vprint_buf);
va_end(ap);
return 0;
}
int os_vprintf(const char *format, va_list ap)
int
os_vprintf(const char *format, va_list ap)
{
rt_size_t len = vsnprintf(wamr_vprint_buf, sizeof(wamr_vprint_buf)-1, format, ap);
rt_size_t len =
vsnprintf(wamr_vprint_buf, sizeof(wamr_vprint_buf) - 1, format, ap);
wamr_vprint_buf[len] = 0;
rt_kputs(wamr_vprint_buf);
return 0;
}
uint64 os_time_get_boot_microsecond(void)
uint64
os_time_get_boot_microsecond(void)
{
uint64 ret = rt_tick_get()*1000;
uint64 ret = rt_tick_get() * 1000;
ret /= RT_TICK_PER_SECOND;
return ret;
}
korp_tid os_self_thread(void)
korp_tid
os_self_thread(void)
{
return rt_thread_self();
}
uint8 *os_thread_get_stack_boundary(void)
uint8 *
os_thread_get_stack_boundary(void)
{
rt_thread_t tid = rt_thread_self();
return tid->stack_addr;
}
int os_mutex_init(korp_mutex *mutex)
int
os_mutex_init(korp_mutex *mutex)
{
return rt_mutex_init(mutex, "wamr0", RT_IPC_FLAG_FIFO);
}
int os_mutex_destroy(korp_mutex *mutex)
int
os_mutex_destroy(korp_mutex *mutex)
{
return rt_mutex_detach(mutex);
}
int os_mutex_lock(korp_mutex *mutex)
int
os_mutex_lock(korp_mutex *mutex)
{
return rt_mutex_take(mutex, RT_WAITING_FOREVER);
}
int os_mutex_unlock(korp_mutex *mutex)
int
os_mutex_unlock(korp_mutex *mutex)
{
return rt_mutex_release(mutex);
}
/*
* functions below was not implement
*/
int os_cond_init(korp_cond *cond)
int
os_cond_init(korp_cond *cond)
{
return 0;
}
int os_cond_destroy(korp_cond *cond)
int
os_cond_destroy(korp_cond *cond)
{
return 0;
}
int os_cond_wait(korp_cond *cond, korp_mutex *mutex)
int
os_cond_wait(korp_cond *cond, korp_mutex *mutex)
{
return 0;
}
void *os_mmap(void *hint, size_t size, int prot, int flags)
void *
os_mmap(void *hint, size_t size, int prot, int flags)
{
return rt_malloc(size);
}
void os_munmap(void *addr, size_t size)
void
os_munmap(void *addr, size_t size)
{
rt_free(addr);
}
int os_mprotect(void *addr, size_t size, int prot)
int
os_mprotect(void *addr, size_t size, int prot)
{
return 0;
}
void os_dcache_flush(void)
{
}
void
os_dcache_flush(void)
{}

4
core/shared/platform/vxworks/platform_init.c
View File

@ -13,8 +13,7 @@ bh_platform_init()
void
bh_platform_destroy()
{
}
{}
int
os_printf(const char *format, ...)
@ -42,4 +41,3 @@ os_vprintf(const char *format, va_list ap)
return BH_VPRINTF(format, ap);
#endif
}

19
core/shared/platform/vxworks/platform_internal.h
View File

@ -58,8 +58,7 @@ typedef pthread_t korp_thread;
#define os_thread_local_attribute __thread
#if WASM_DISABLE_HW_BOUND_CHECK == 0
#if defined(BUILD_TARGET_X86_64) \
|| defined(BUILD_TARGET_AMD_64) \
#if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64) \
|| defined(BUILD_TARGET_AARCH64)
#include <setjmp.h>
@ -76,15 +75,20 @@ typedef jmp_buf korp_jmpbuf;
typedef void (*os_signal_handler)(void *sig_addr);
int os_thread_signal_init(os_signal_handler handler);
int
os_thread_signal_init(os_signal_handler handler);
void os_thread_signal_destroy();
void
os_thread_signal_destroy();
bool os_thread_signal_inited();
bool
os_thread_signal_inited();
void os_signal_unmask();
void
os_signal_unmask();
void os_sigreturn();
void
os_sigreturn();
#endif /* end of BUILD_TARGET_X86_64/AMD_64/AARCH64 */
#endif /* end of WASM_DISABLE_HW_BOUND_CHECK */
@ -93,4 +97,3 @@ void os_sigreturn();
#endif
#endif /* end of _PLATFORM_INTERNAL_H */

4
core/shared/platform/windows/platform_init.c
View File

@ -60,6 +60,4 @@ os_getpagesize()
void
os_dcache_flush(void)
{
}
{}

22
core/shared/platform/windows/platform_internal.h
View File

@ -53,15 +53,17 @@ typedef struct korp_cond {
os_thread_wait_list thread_wait_list;
} korp_cond;
unsigned os_getpagesize();
void *os_mem_commit(void *ptr, size_t size, int flags);
void os_mem_decommit(void *ptr, size_t size);
unsigned
os_getpagesize();
void *
os_mem_commit(void *ptr, size_t size, int flags);
void
os_mem_decommit(void *ptr, size_t size);
#define os_thread_local_attribute __declspec(thread)
#if WASM_DISABLE_HW_BOUND_CHECK == 0
#if defined(BUILD_TARGET_X86_64) \
|| defined(BUILD_TARGET_AMD_64)
#if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64)
#include <setjmp.h>
@ -72,11 +74,14 @@ typedef jmp_buf korp_jmpbuf;
#define os_setjmp setjmp
#define os_longjmp longjmp
int os_thread_signal_init();
int
os_thread_signal_init();
void os_thread_signal_destroy();
void
os_thread_signal_destroy();
bool os_thread_signal_inited();
bool
os_thread_signal_inited();
#define os_signal_unmask() (void)0
#define os_sigreturn() (void)0
@ -89,4 +94,3 @@ bool os_thread_signal_inited();
#endif
#endif /* end of _PLATFORM_INTERNAL_H */

3
core/shared/platform/windows/win_malloc.c
View File

@ -22,6 +22,3 @@ os_free(void *ptr)
{
free(ptr);
}

12
core/shared/platform/windows/win_memmap.c
View File

@ -79,8 +79,7 @@ os_munmap(void *addr, size_t size)
}
}
#if TRACE_MEMMAP != 0
printf("Unmap memory, addr: %p, request_size: %zu\n",
addr, request_size);
printf("Unmap memory, addr: %p, request_size: %zu\n", addr, request_size);
#endif
}
@ -95,8 +94,8 @@ os_mem_commit(void *addr, size_t size, int flags)
return NULL;
#if TRACE_MEMMAP != 0
printf("Commit memory, addr: %p, request_size: %zu, protect: 0x%x\n",
addr, request_size, protect);
printf("Commit memory, addr: %p, request_size: %zu, protect: 0x%x\n", addr,
request_size, protect);
#endif
return VirtualAlloc((LPVOID)addr, request_size, MEM_COMMIT, protect);
}
@ -111,8 +110,8 @@ os_mem_decommit(void *addr, size_t size)
return;
#if TRACE_MEMMAP != 0
printf("Decommit memory, addr: %p, request_size: %zu\n",
addr, request_size);
printf("Decommit memory, addr: %p, request_size: %zu\n", addr,
request_size);
#endif
VirtualFree((LPVOID)addr, request_size, MEM_DECOMMIT);
}
@ -134,4 +133,3 @@ os_mprotect(void *addr, size_t size, int prot)
#endif
return VirtualProtect((LPVOID)addr, request_size, protect, NULL);
}

37
core/shared/platform/windows/win_thread.c
View File

@ -47,11 +47,16 @@ static os_thread_data supervisor_thread_data;
/* Thread data key */
static DWORD thread_data_key;
int os_sem_init(korp_sem* sem);
int os_sem_destroy(korp_sem* sem);
int os_sem_wait(korp_sem* sem);
int os_sem_reltimed_wait(korp_sem* sem, uint64 useconds);
int os_sem_signal(korp_sem* sem);
int
os_sem_init(korp_sem *sem);
int
os_sem_destroy(korp_sem *sem);
int
os_sem_wait(korp_sem *sem);
int
os_sem_reltimed_wait(korp_sem *sem, uint64 useconds);
int
os_sem_signal(korp_sem *sem);
int
os_thread_sys_init()
@ -141,8 +146,7 @@ os_thread_cleanup(void *retval)
BH_FREE(thread_data);
}
static unsigned __stdcall
os_thread_wrapper(void *arg)
static unsigned __stdcall os_thread_wrapper(void *arg)
{
os_thread_data *thread_data = arg;
os_thread_data *parent = thread_data->parent;
@ -202,9 +206,8 @@ os_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
goto fail3;
os_mutex_lock(&parent->wait_lock);
if (!_beginthreadex(NULL, stack_size,
os_thread_wrapper, thread_data,
0, NULL)) {
if (!_beginthreadex(NULL, stack_size, os_thread_wrapper, thread_data, 0,
NULL)) {
os_mutex_unlock(&parent->wait_lock);
goto fail4;
}
@ -371,7 +374,7 @@ os_sem_wait(korp_sem *sem)
if (ret == WAIT_OBJECT_0)
return BHT_OK;
else if(ret == WAIT_TIMEOUT)
else if (ret == WAIT_TIMEOUT)
return (int)WAIT_TIMEOUT;
else /* WAIT_FAILED or others */
return BHT_ERROR;
@ -404,7 +407,7 @@ os_sem_reltimed_wait(korp_sem *sem, uint64 useconds)
if (ret == WAIT_OBJECT_0)
return BHT_OK;
else if(ret == WAIT_TIMEOUT)
else if (ret == WAIT_TIMEOUT)
return (int)WAIT_TIMEOUT;
else /* WAIT_FAILED or others */
return BHT_ERROR;
@ -414,8 +417,7 @@ int
os_sem_signal(korp_sem *sem)
{
bh_assert(sem);
return ReleaseSemaphore(*sem, 1, NULL) != FALSE
? BHT_OK: BHT_ERROR;
return ReleaseSemaphore(*sem, 1, NULL) != FALSE ? BHT_OK : BHT_ERROR;
}
int
@ -478,8 +480,8 @@ os_cond_destroy(korp_cond *cond)
}
static int
os_cond_wait_internal(korp_cond *cond, korp_mutex *mutex,
bool timed, uint64 useconds)
os_cond_wait_internal(korp_cond *cond, korp_mutex *mutex, bool timed,
uint64 useconds)
{
os_thread_wait_node *node = &thread_data_current()->wait_node;
@ -567,7 +569,7 @@ os_thread_get_stack_boundary()
GetCurrentThreadStackLimits(&low_limit, &high_limit);
/* 4 pages are set unaccessible by system, we reserved
one more page at least for safety */
thread_stack_boundary = (uint8*)(uintptr_t)low_limit + page_size * 5;
thread_stack_boundary = (uint8 *)(uintptr_t)low_limit + page_size * 5;
return thread_stack_boundary;
}
@ -601,4 +603,3 @@ os_thread_signal_inited()
return thread_signal_inited;
}
#endif

1
core/shared/platform/windows/win_time.c
View File

@ -13,4 +13,3 @@ os_time_get_boot_microsecond()
return ((uint64)ts.tv_sec) * 1000 * 1000 + ((uint64)ts.tv_nsec) / 1000;
}

15
core/shared/platform/zephyr/platform_internal.h
View File

@ -37,7 +37,6 @@
#include <arch/arm/aarch32/cortex_m/cmsis.h>
#endif
#ifndef BH_PLATFORM_ZEPHYR
#define BH_PLATFORM_ZEPHYR
#endif
@ -62,6 +61,7 @@ typedef struct korp_cond {
#define Z_TIMEOUT_MS(ms) ms
#endif
/* clang-format off */
void abort(void);
size_t strspn(const char *s, const char *accept);
size_t strcspn(const char *s, const char *reject);
@ -91,6 +91,7 @@ double scalbn(double x, int n);
unsigned long long int strtoull(const char *nptr, char **endptr, int base);
double strtod(const char *nptr, char **endptr);
float strtof(const char *nptr, char **endptr);
/* clang-format on */
/**
* @brief Allocate executable memroy
@ -99,7 +100,7 @@ float strtof(const char *nptr, char **endptr);
*
* @return the address of the allocated memory if not NULL
*/
typedef void* (*exec_mem_alloc_func_t)(unsigned int size);
typedef void *(*exec_mem_alloc_func_t)(unsigned int size);
/**
* @brief Release executable memroy
@ -108,8 +109,12 @@ typedef void* (*exec_mem_alloc_func_t)(unsigned int size);
*/
typedef void (*exec_mem_free_func_t)(void *addr);
/* Below function are called by external project to set related function pointers that
* will be used to malloc/free executable memory. Otherwise default mechanise will be used. */
void set_exec_mem_alloc_func(exec_mem_alloc_func_t alloc_func, exec_mem_free_func_t free_func);
/* Below function are called by external project to set related function
* pointers that will be used to malloc/free executable memory. Otherwise
* default mechanise will be used.
*/
void
set_exec_mem_alloc_func(exec_mem_alloc_func_t alloc_func,
exec_mem_free_func_t free_func);
#endif

10
core/shared/platform/zephyr/zephyr_platform.c
View File

@ -29,7 +29,6 @@ disable_mpu_rasr_xn(void)
MPU->RASR |= ~MPU_RASR_XN_Msk;
}
}
}
#endif /* end of CONFIG_ARM_MPU */
#endif
@ -84,8 +83,7 @@ os_realloc(void *ptr, unsigned size)
void
os_free(void *ptr)
{
}
{}
#if 0
struct out_context {
@ -203,17 +201,17 @@ os_dcache_flush()
SCB_CleanDCache();
irq_unlock(key);
#elif defined(CONFIG_SOC_CVF_EM7D) && defined(CONFIG_ARC_MPU) \
&& defined (CONFIG_CACHE_FLUSHING)
&& defined(CONFIG_CACHE_FLUSHING)
__asm__ __volatile__("sync");
z_arc_v2_aux_reg_write(_ARC_V2_DC_FLSH, BIT(0));
__asm__ __volatile__("sync");
#endif
}
void set_exec_mem_alloc_func(exec_mem_alloc_func_t alloc_func,
void
set_exec_mem_alloc_func(exec_mem_alloc_func_t alloc_func,
exec_mem_free_func_t free_func)
{
exec_mem_alloc_func = alloc_func;
exec_mem_free_func = free_func;
}

111
core/shared/platform/zephyr/zephyr_thread.c
View File

@ -6,13 +6,15 @@
#include "platform_api_vmcore.h"
#include "platform_api_extension.h"
/* clang-format off */
#define bh_assert(v) do { \
if (!(v)) { \
printf("\nASSERTION FAILED: %s, at %s, line %d\n", \
#v, __FILE__, __LINE__); \
abort(); \
} \
} while (0)
} while (0)
/* clang-format on */
#if defined(CONFIG_ARM_MPU) || defined(CONFIG_ARC_MPU) \
|| KERNEL_VERSION_NUMBER > 0x020300 /* version 2.3.0 */
@ -28,13 +30,13 @@
#endif
#if BH_ENABLE_ZEPHYR_MPU_STACK != 0
static K_THREAD_STACK_ARRAY_DEFINE(mpu_stacks,
BH_ZEPHYR_MPU_STACK_COUNT,
static K_THREAD_STACK_ARRAY_DEFINE(mpu_stacks, BH_ZEPHYR_MPU_STACK_COUNT,
BH_ZEPHYR_MPU_STACK_SIZE);
static bool mpu_stack_allocated[BH_ZEPHYR_MPU_STACK_COUNT];
static struct k_mutex mpu_stack_lock;
static char *mpu_stack_alloc()
static char *
mpu_stack_alloc()
{
int i;
@ -43,14 +45,15 @@ static char *mpu_stack_alloc()
if (!mpu_stack_allocated[i]) {
mpu_stack_allocated[i] = true;
k_mutex_unlock(&mpu_stack_lock);
return (char*)mpu_stacks[i];
return (char *)mpu_stacks[i];
}
}
k_mutex_unlock(&mpu_stack_lock);
return NULL;
}
static void mpu_stack_free(char *stack)
static void
mpu_stack_free(char *stack)
{
int i;
@ -114,7 +117,8 @@ static struct k_mutex thread_obj_lock;
/* Thread object list */
static os_thread_obj *thread_obj_list = NULL;
static void thread_data_list_add(os_thread_data *thread_data)
static void
thread_data_list_add(os_thread_data *thread_data)
{
k_mutex_lock(&thread_data_lock, K_FOREVER);
if (!thread_data_list)
@ -137,7 +141,8 @@ static void thread_data_list_add(os_thread_data *thread_data)
k_mutex_unlock(&thread_data_lock);
}
static void thread_data_list_remove(os_thread_data *thread_data)
static void
thread_data_list_remove(os_thread_data *thread_data)
{
k_mutex_lock(&thread_data_lock, K_FOREVER);
if (thread_data_list) {
@ -174,7 +179,8 @@ thread_data_list_lookup(k_tid_t tid)
return NULL;
}
static void thread_obj_list_add(os_thread_obj *thread_obj)
static void
thread_obj_list_add(os_thread_obj *thread_obj)
{
k_mutex_lock(&thread_obj_lock, K_FOREVER);
if (!thread_obj_list)
@ -187,7 +193,8 @@ static void thread_obj_list_add(os_thread_obj *thread_obj)
k_mutex_unlock(&thread_obj_lock);
}
static void thread_obj_list_reclaim()
static void
thread_obj_list_reclaim()
{
os_thread_obj *p, *p_prev;
k_mutex_lock(&thread_obj_lock, K_FOREVER);
@ -199,12 +206,14 @@ static void thread_obj_list_reclaim()
thread_obj_list = p->next;
BH_FREE(p);
p = thread_obj_list;
} else { /* p is not the head of list */
}
else { /* p is not the head of list */
p_prev->next = p->next;
BH_FREE(p);
p = p_prev->next;
}
} else {
}
else {
p_prev = p;
p = p->next;
}
@ -212,7 +221,8 @@ static void thread_obj_list_reclaim()
k_mutex_unlock(&thread_obj_lock);
}
int os_thread_sys_init()
int
os_thread_sys_init()
{
if (is_thread_sys_inited)
return BHT_OK;
@ -233,7 +243,8 @@ int os_thread_sys_init()
return BHT_OK;
}
void os_thread_sys_destroy(void)
void
os_thread_sys_destroy(void)
{
if (is_thread_sys_inited) {
is_thread_sys_inited = false;
@ -247,7 +258,8 @@ thread_data_current()
return thread_data_list_lookup(tid);
}
static void os_thread_cleanup(void)
static void
os_thread_cleanup(void)
{
os_thread_data *thread_data = thread_data_current();
@ -269,31 +281,34 @@ static void os_thread_cleanup(void)
thread_data_list_remove(thread_data);
/* Set flag to true for the next thread creating to
free the thread object */
((os_thread_obj*) thread_data->tid)->to_be_freed = true;
((os_thread_obj *)thread_data->tid)->to_be_freed = true;
#if BH_ENABLE_ZEPHYR_MPU_STACK != 0
mpu_stack_free(thread_data->stack);
#endif
BH_FREE(thread_data);
}
static void os_thread_wrapper(void *start, void *arg, void *thread_data)
static void
os_thread_wrapper(void *start, void *arg, void *thread_data)
{
/* Set thread custom data */
((os_thread_data*) thread_data)->tid = k_current_get();
((os_thread_data *)thread_data)->tid = k_current_get();
thread_data_list_add(thread_data);
((thread_start_routine_t) start)(arg);
((thread_start_routine_t)start)(arg);
os_thread_cleanup();
}
int os_thread_create(korp_tid *p_tid, thread_start_routine_t start, void *arg,
int
os_thread_create(korp_tid *p_tid, thread_start_routine_t start, void *arg,
unsigned int stack_size)
{
return os_thread_create_with_prio(p_tid, start, arg, stack_size,
BH_THREAD_DEFAULT_PRIORITY);
}
int os_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
int
os_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
void *arg, unsigned int stack_size, int prio)
{
korp_tid tid;
@ -347,7 +362,7 @@ int os_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
/* Set thread custom data */
thread_data_list_add(thread_data);
thread_obj_list_add((os_thread_obj*)tid);
thread_obj_list_add((os_thread_obj *)tid);
*p_tid = tid;
return BHT_OK;
@ -362,14 +377,16 @@ fail1:
return BHT_ERROR;
}
korp_tid os_self_thread()
korp_tid
os_self_thread()
{
return (korp_tid)k_current_get();
}
int os_thread_join(korp_tid thread, void **value_ptr)
int
os_thread_join(korp_tid thread, void **value_ptr)
{
(void) value_ptr;
(void)value_ptr;
os_thread_data *thread_data;
os_thread_wait_node *node;
@ -407,30 +424,35 @@ int os_thread_join(korp_tid thread, void **value_ptr)
return BHT_OK;
}
int os_mutex_init(korp_mutex *mutex)
int
os_mutex_init(korp_mutex *mutex)
{
k_mutex_init(mutex);
return BHT_OK;
}
int os_recursive_mutex_init(korp_mutex *mutex)
int
os_recursive_mutex_init(korp_mutex *mutex)
{
k_mutex_init(mutex);
return BHT_OK;
}
int os_mutex_destroy(korp_mutex *mutex)
int
os_mutex_destroy(korp_mutex *mutex)
{
(void) mutex;
(void)mutex;
return BHT_OK;
}
int os_mutex_lock(korp_mutex *mutex)
int
os_mutex_lock(korp_mutex *mutex)
{
return k_mutex_lock(mutex, K_FOREVER);
}
int os_mutex_unlock(korp_mutex *mutex)
int
os_mutex_unlock(korp_mutex *mutex)
{
#if KERNEL_VERSION_NUMBER >= 0x020200 /* version 2.2.0 */
return k_mutex_unlock(mutex);
@ -440,21 +462,23 @@ int os_mutex_unlock(korp_mutex *mutex)
#endif
}
int os_cond_init(korp_cond *cond)
int
os_cond_init(korp_cond *cond)
{
k_mutex_init(&cond->wait_list_lock);
cond->thread_wait_list = NULL;
return BHT_OK;
}
int os_cond_destroy(korp_cond *cond)
int
os_cond_destroy(korp_cond *cond)
{
(void) cond;
(void)cond;
return BHT_OK;
}
static int os_cond_wait_internal(korp_cond *cond, korp_mutex *mutex,
bool timed, int mills)
static int
os_cond_wait_internal(korp_cond *cond, korp_mutex *mutex, bool timed, int mills)
{
os_thread_wait_node *node;
@ -499,12 +523,14 @@ static int os_cond_wait_internal(korp_cond *cond, korp_mutex *mutex,
return BHT_OK;
}
int os_cond_wait(korp_cond *cond, korp_mutex *mutex)
int
os_cond_wait(korp_cond *cond, korp_mutex *mutex)
{
return os_cond_wait_internal(cond, mutex, false, 0);
}
int os_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, uint64 useconds)
int
os_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, uint64 useconds)
{
if (useconds == BHT_WAIT_FOREVER) {
@ -526,7 +552,8 @@ int os_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, uint64 useconds)
}
}
int os_cond_signal(korp_cond *cond)
int
os_cond_signal(korp_cond *cond)
{
/* Signal the head wait node of wait list */
k_mutex_lock(&cond->wait_list_lock, K_FOREVER);
@ -537,13 +564,13 @@ int os_cond_signal(korp_cond *cond)
return BHT_OK;
}
uint8 *os_thread_get_stack_boundary()
uint8 *
os_thread_get_stack_boundary()
{
#if defined(CONFIG_THREAD_STACK_INFO)
korp_tid thread = k_current_get();
return (uint8*)thread->stack_info.start;
return (uint8 *)thread->stack_info.start;
#else
return NULL;
#endif
}

1
core/shared/platform/zephyr/zephyr_time.c
View File

@ -10,4 +10,3 @@ os_time_get_boot_microsecond()
{
return k_uptime_get() * 1000;
}

8
core/shared/utils/bh_assert.c
View File

@ -5,7 +5,8 @@
#include "bh_assert.h"
void bh_assert_internal(int v, const char *file_name, int line_number,
void
bh_assert_internal(int v, const char *file_name, int line_number,
const char *expr_string)
{
if (v)
@ -17,9 +18,8 @@ void bh_assert_internal(int v, const char *file_name, int line_number,
if (!expr_string)
expr_string = "NULL EXPR_STRING";
os_printf("\nASSERTION FAILED: %s, at file %s, line %d\n",
expr_string, file_name, line_number);
os_printf("\nASSERTION FAILED: %s, at file %s, line %d\n", expr_string,
file_name, line_number);
abort();
}

8
core/shared/utils/bh_assert.h
View File

@ -13,10 +13,11 @@ extern "C" {
#endif
#if BH_DEBUG != 0
void bh_assert_internal(int v, const char *file_name, int line_number,
void
bh_assert_internal(int v, const char *file_name, int line_number,
const char *expr_string);
#define bh_assert(expr) bh_assert_internal((int)(uintptr_t)(expr), \
__FILE__, __LINE__, #expr)
#define bh_assert(expr) \
bh_assert_internal((int)(uintptr_t)(expr), __FILE__, __LINE__, #expr)
#else
#define bh_assert(expr) (void)0
#endif /* end of BH_DEBUG */
@ -26,4 +27,3 @@ void bh_assert_internal(int v, const char *file_name, int line_number,
#endif
#endif /* end of _BH_ASSERT_H */

26
core/shared/utils/bh_common.c
View File

@ -12,11 +12,10 @@
#define RSIZE_MAX 0x7FFFFFFF
int
b_memcpy_s(void * s1, unsigned int s1max,
const void * s2, unsigned int n)
b_memcpy_s(void *s1, unsigned int s1max, const void *s2, unsigned int n)
{
char *dest = (char*)s1;
char *src = (char*)s2;
char *dest = (char *)s1;
char *src = (char *)s2;
if (n == 0) {
return 0;
}
@ -32,11 +31,11 @@ b_memcpy_s(void * s1, unsigned int s1max,
return 0;
}
int b_memmove_s(void * s1, unsigned int s1max,
const void * s2, unsigned int n)
int
b_memmove_s(void *s1, unsigned int s1max, const void *s2, unsigned int n)
{
char *dest = (char*)s1;
char *src = (char*)s2;
char *dest = (char *)s1;
char *src = (char *)s2;
if (n == 0) {
return 0;
}
@ -53,10 +52,9 @@ int b_memmove_s(void * s1, unsigned int s1max,
}
int
b_strcat_s(char * s1, unsigned int s1max, const char * s2)
b_strcat_s(char *s1, unsigned int s1max, const char *s2)
{
if (NULL == s1 || NULL == s2
|| s1max < (strlen(s1) + strlen(s2) + 1)
if (NULL == s1 || NULL == s2 || s1max < (strlen(s1) + strlen(s2) + 1)
|| s1max > RSIZE_MAX) {
return -1;
}
@ -66,10 +64,9 @@ b_strcat_s(char * s1, unsigned int s1max, const char * s2)
}
int
b_strcpy_s(char * s1, unsigned int s1max, const char * s2)
b_strcpy_s(char *s1, unsigned int s1max, const char *s2)
{
if (NULL == s1 || NULL == s2
|| s1max < (strlen(s2) + 1)
if (NULL == s1 || NULL == s2 || s1max < (strlen(s2) + 1)
|| s1max > RSIZE_MAX) {
return -1;
}
@ -105,4 +102,3 @@ wa_strdup(const char *s)
}
return s1;
}

46
core/shared/utils/bh_common.h
View File

@ -12,40 +12,50 @@
extern "C" {
#endif
#define bh_memcpy_s(dest, dlen, src, slen) do { \
int _ret = slen == 0 ? 0 : b_memcpy_s (dest, dlen, src, slen); \
#define bh_memcpy_s(dest, dlen, src, slen) \
do { \
int _ret = slen == 0 ? 0 : b_memcpy_s(dest, dlen, src, slen); \
(void)_ret; \
bh_assert (_ret == 0); \
bh_assert(_ret == 0); \
} while (0)
#define bh_memmove_s(dest, dlen, src, slen) do { \
int _ret = slen == 0 ? 0 : b_memmove_s (dest, dlen, src, slen); \
#define bh_memmove_s(dest, dlen, src, slen) \
do { \
int _ret = slen == 0 ? 0 : b_memmove_s(dest, dlen, src, slen); \
(void)_ret; \
bh_assert (_ret == 0); \
bh_assert(_ret == 0); \
} while (0)
#define bh_strcat_s(dest, dlen, src) do { \
int _ret = b_strcat_s (dest, dlen, src); \
#define bh_strcat_s(dest, dlen, src) \
do { \
int _ret = b_strcat_s(dest, dlen, src); \
(void)_ret; \
bh_assert (_ret == 0); \
bh_assert(_ret == 0); \
} while (0)
#define bh_strcpy_s(dest, dlen, src) do { \
int _ret = b_strcpy_s (dest, dlen, src); \
#define bh_strcpy_s(dest, dlen, src) \
do { \
int _ret = b_strcpy_s(dest, dlen, src); \
(void)_ret; \
bh_assert (_ret == 0); \
bh_assert(_ret == 0); \
} while (0)
int b_memcpy_s(void * s1, unsigned int s1max, const void * s2, unsigned int n);
int b_memmove_s(void * s1, unsigned int s1max, const void * s2, unsigned int n);
int b_strcat_s(char * s1, unsigned int s1max, const char * s2);
int b_strcpy_s(char * s1, unsigned int s1max, const char * s2);
int
b_memcpy_s(void *s1, unsigned int s1max, const void *s2, unsigned int n);
int
b_memmove_s(void *s1, unsigned int s1max, const void *s2, unsigned int n);
int
b_strcat_s(char *s1, unsigned int s1max, const char *s2);
int
b_strcpy_s(char *s1, unsigned int s1max, const char *s2);
/* strdup with string allocated by BH_MALLOC */
char *bh_strdup(const char *s);
char *
bh_strdup(const char *s);
/* strdup with string allocated by WA_MALLOC */
char *wa_strdup(const char *s);
char *
wa_strdup(const char *s);
#ifdef __cplusplus
}

29
core/shared/utils/bh_hashmap.c
View File

@ -25,11 +25,9 @@ struct HashMap {
HashMapElem *elements[1];
};
HashMap*
bh_hash_map_create(uint32 size, bool use_lock,
HashFunc hash_func,
KeyEqualFunc key_equal_func,
KeyDestroyFunc key_destroy_func,
HashMap *
bh_hash_map_create(uint32 size, bool use_lock, HashFunc hash_func,
KeyEqualFunc key_equal_func, KeyDestroyFunc key_destroy_func,
ValueDestroyFunc value_destroy_func)
{
HashMap *map;
@ -46,12 +44,11 @@ bh_hash_map_create(uint32 size, bool use_lock,
return NULL;
}
total_size = offsetof(HashMap, elements) +
sizeof(HashMapElem *) * (uint64)size +
(use_lock ? sizeof(korp_mutex) : 0);
total_size = offsetof(HashMap, elements)
+ sizeof(HashMapElem *) * (uint64)size
+ (use_lock ? sizeof(korp_mutex) : 0);
if (total_size >= UINT32_MAX
|| !(map = BH_MALLOC((uint32)total_size))) {
if (total_size >= UINT32_MAX || !(map = BH_MALLOC((uint32)total_size))) {
LOG_ERROR("HashMap create failed: alloc memory failed.\n");
return NULL;
}
@ -59,8 +56,7 @@ bh_hash_map_create(uint32 size, bool use_lock,
memset(map, 0, (uint32)total_size);
if (use_lock) {
map->lock = (korp_mutex*)
((uint8*)map + offsetof(HashMap, elements)
map->lock = (korp_mutex *)((uint8 *)map + offsetof(HashMap, elements)
+ sizeof(HashMapElem *) * size);
if (os_mutex_init(map->lock)) {
LOG_ERROR("HashMap create failed: init map lock failed.\n");
@ -124,7 +120,7 @@ fail:
return false;
}
void*
void *
bh_hash_map_find(HashMap *map, void *key)
{
uint32 index;
@ -161,8 +157,7 @@ bh_hash_map_find(HashMap *map, void *key)
}
bool
bh_hash_map_update(HashMap *map, void *key, void *value,
void **p_old_value)
bh_hash_map_update(HashMap *map, void *key, void *value, void **p_old_value)
{
uint32 index;
HashMapElem *elem;
@ -199,8 +194,8 @@ bh_hash_map_update(HashMap *map, void *key, void *value,
}
bool
bh_hash_map_remove(HashMap *map, void *key,
void **p_old_key, void **p_old_value)
bh_hash_map_remove(HashMap *map, void *key, void **p_old_key,
void **p_old_value)
{
uint32 index;
HashMapElem *elem, *prev;

18
core/shared/utils/bh_hashmap.h
View File

@ -51,11 +51,9 @@ typedef void (*TraverseCallbackFunc)(void *key, void *value, void *user_data);
*
* @return the hash map created, NULL if failed
*/
HashMap*
bh_hash_map_create(uint32 size, bool use_lock,
HashFunc hash_func,
KeyEqualFunc key_equal_func,
KeyDestroyFunc key_destroy_func,
HashMap *
bh_hash_map_create(uint32 size, bool use_lock, HashFunc hash_func,
KeyEqualFunc key_equal_func, KeyDestroyFunc key_destroy_func,
ValueDestroyFunc value_destroy_func);
/**
@ -79,7 +77,7 @@ bh_hash_map_insert(HashMap *map, void *key, void *value);
*
* @return the value of the found element if success, NULL otherwise
*/
void*
void *
bh_hash_map_find(HashMap *map, void *key);
/**
@ -95,8 +93,7 @@ bh_hash_map_find(HashMap *map, void *key);
* it will be copied to p_old_value for user to process.
*/
bool
bh_hash_map_update(HashMap *map, void *key, void *value,
void **p_old_value);
bh_hash_map_update(HashMap *map, void *key, void *value, void **p_old_value);
/**
* Remove an element from the hash map
@ -112,8 +109,8 @@ bh_hash_map_update(HashMap *map, void *key, void *value,
* p_old_key and p_old_value for user to process.
*/
bool
bh_hash_map_remove(HashMap *map, void *key,
void **p_old_key, void **p_old_value);
bh_hash_map_remove(HashMap *map, void *key, void **p_old_key,
void **p_old_value);
/**
* Destroy the hashmap
@ -166,4 +163,3 @@ bh_hash_map_traverse(HashMap *map, TraverseCallbackFunc callback,
#endif
#endif /* endof WASM_HASHMAP_H */

37
core/shared/utils/bh_list.c
View File

@ -14,10 +14,12 @@
* @return <code>true</code> if the pointer has been in the list;
* <code>false</code> otherwise.
*/
static bool bh_list_is_elem_exist(bh_list *list, void *elem);
static bool
bh_list_is_elem_exist(bh_list *list, void *elem);
#endif
bh_list_status bh_list_init(bh_list *list)
bh_list_status
bh_list_init(bh_list *list)
{
if (!list)
return BH_LIST_ERROR;
@ -27,23 +29,25 @@ bh_list_status bh_list_init(bh_list *list)
return BH_LIST_SUCCESS;
}
bh_list_status bh_list_insert(bh_list *list, void *elem)
bh_list_status
bh_list_insert(bh_list *list, void *elem)
{
bh_list_link *p = NULL;
if (!list || !elem)
return BH_LIST_ERROR;
#if BH_DEBUG != 0
bh_assert (!bh_list_is_elem_exist(list, elem));
bh_assert(!bh_list_is_elem_exist(list, elem));
#endif
p = (bh_list_link *) elem;
p = (bh_list_link *)elem;
p->next = (list->head).next;
(list->head).next = p;
list->len++;
return BH_LIST_SUCCESS;
}
bh_list_status bh_list_remove(bh_list *list, void *elem)
bh_list_status
bh_list_remove(bh_list *list, void *elem)
{
bh_list_link *cur = NULL;
bh_list_link *prev = NULL;
@ -71,32 +75,37 @@ bh_list_status bh_list_remove(bh_list *list, void *elem)
return BH_LIST_ERROR;
}
uint32 bh_list_length(bh_list *list)
uint32
bh_list_length(bh_list *list)
{
return (list ? list->len : 0);
}
void* bh_list_first_elem(bh_list *list)
void *
bh_list_first_elem(bh_list *list)
{
return (list ? (list->head).next : NULL);
}
void* bh_list_elem_next(void *node)
void *
bh_list_elem_next(void *node)
{
return (node ? ((bh_list_link *) node)->next : NULL);
return (node ? ((bh_list_link *)node)->next : NULL);
}
#if BH_DEBUG != 0
static bool bh_list_is_elem_exist(bh_list *list, void *elem)
static bool
bh_list_is_elem_exist(bh_list *list, void *elem)
{
bh_list_link *p = NULL;
if (!list || !elem) return false;
if (!list || !elem)
return false;
p = (list->head).next;
while (p && p != elem) p = p->next;
while (p && p != elem)
p = p->next;
return (p != NULL);
}
#endif

33
core/shared/utils/bh_list.h
View File

@ -46,29 +46,34 @@ typedef enum bh_list_status {
* @return <code>BH_LIST_ERROR</code> if OK;
* <code>BH_LIST_ERROR</code> if list pointer is NULL.
*/
bh_list_status bh_list_init(bh_list *list);
bh_list_status
bh_list_init(bh_list *list);
/**
* Insert an elem pointer into list. The list node memory is maintained by list while
* elem memory is the responsibility of list user.
* Insert an elem pointer into list. The list node memory is maintained by list
* while elem memory is the responsibility of list user.
*
* @param list pointer to list.
* @param elem pointer to elem that will be inserted into list.
* @return <code>BH_LIST_ERROR</code> if OK;
* <code>BH_LIST_ERROR</code> if input is invalid or no memory available.
* <code>BH_LIST_ERROR</code> if input is invalid or no memory
* available.
*/
extern bh_list_status bh_list_insert(bh_list *list, void *elem);
extern bh_list_status
bh_list_insert(bh_list *list, void *elem);
/**
* Remove an elem pointer from list. The list node memory is maintained by list while
* elem memory is the responsibility of list user.
* Remove an elem pointer from list. The list node memory is maintained by list
* while elem memory is the responsibility of list user.
*
* @param list pointer to list.
* @param elem pointer to elem that will be inserted into list.
* @return <code>BH_LIST_ERROR</code> if OK;
* <code>BH_LIST_ERROR</code> if element does not exist in given list.
* <code>BH_LIST_ERROR</code> if element does not exist in given
* list.
*/
bh_list_status bh_list_remove(bh_list *list, void *elem);
bh_list_status
bh_list_remove(bh_list *list, void *elem);
/**
* Get the list length.
@ -76,7 +81,8 @@ bh_list_status bh_list_remove(bh_list *list, void *elem);
* @param list pointer to list.
* @return the length of the list.
*/
uint32 bh_list_length(bh_list *list);
uint32
bh_list_length(bh_list *list);
/**
* Get the first elem in the list.
@ -84,7 +90,8 @@ uint32 bh_list_length(bh_list *list);
* @param list pointer to list.
* @return pointer to the first node.
*/
void* bh_list_first_elem(bh_list *list);
void *
bh_list_first_elem(bh_list *list);
/**
* Get the next elem of given list input elem.
@ -92,11 +99,11 @@ void* bh_list_first_elem(bh_list *list);
* @param node pointer to list node.
* @return pointer to next list node.
*/
void* bh_list_elem_next(void *node);
void *
bh_list_elem_next(void *node);
#ifdef __cplusplus
}
#endif
#endif /* #ifndef _BH_LIST_H */

5
core/shared/utils/bh_log.c
View File

@ -71,9 +71,8 @@ bh_print_time(const char *prompt)
total_time_ms += curr_time_ms - last_time_ms;
os_printf("%-48s time of last stage: %u ms, total time: %u ms\n",
prompt, curr_time_ms - last_time_ms, total_time_ms);
os_printf("%-48s time of last stage: %u ms, total time: %u ms\n", prompt,
curr_time_ms - last_time_ms, total_time_ms);
last_time_ms = curr_time_ms;
}

9
core/shared/utils/bh_log.h
View File

@ -52,9 +52,11 @@ bh_log(LogLevel log_level, const char *file, int line, const char *fmt, ...);
#endif
#if BH_DEBUG != 0
#define LOG_FATAL(...) bh_log(BH_LOG_LEVEL_FATAL, __FILE__, __LINE__, __VA_ARGS__)
#define LOG_FATAL(...) \
bh_log(BH_LOG_LEVEL_FATAL, __FILE__, __LINE__, __VA_ARGS__)
#else
#define LOG_FATAL(...) bh_log(BH_LOG_LEVEL_FATAL, __FUNCTION__, __LINE__, __VA_ARGS__)
#define LOG_FATAL(...) \
bh_log(BH_LOG_LEVEL_FATAL, __FUNCTION__, __LINE__, __VA_ARGS__)
#endif
#define LOG_ERROR(...) bh_log(BH_LOG_LEVEL_ERROR, NULL, 0, __VA_ARGS__)
@ -62,7 +64,8 @@ bh_log(LogLevel log_level, const char *file, int line, const char *fmt, ...);
#define LOG_VERBOSE(...) bh_log(BH_LOG_LEVEL_VERBOSE, NULL, 0, __VA_ARGS__)
#if BH_DEBUG != 0
#define LOG_DEBUG(...) bh_log(BH_LOG_LEVEL_DEBUG, __FILE__, __LINE__, __VA_ARGS__)
#define LOG_DEBUG(...) \
bh_log(BH_LOG_LEVEL_DEBUG, __FILE__, __LINE__, __VA_ARGS__)
#else
#define LOG_DEBUG(...) (void)0
#endif

3
core/shared/utils/bh_platform.h
View File

@ -18,8 +18,6 @@
#include "bh_vector.h"
#include "runtime_timer.h"
/**
* WA_MALLOC/WA_FREE need to be redefined for both
* runtime native and WASM app respectively.
@ -38,4 +36,3 @@
#endif
#endif /* #ifndef _BH_PLATFORM_H */

66
core/shared/utils/bh_queue.c
View File

@ -6,11 +6,11 @@
#include "bh_queue.h"
typedef struct bh_queue_node {
struct bh_queue_node * next;
struct bh_queue_node * prev;
struct bh_queue_node *next;
struct bh_queue_node *prev;
unsigned short tag;
unsigned int len;
void * body;
void *body;
bh_msg_cleaner msg_cleaner;
} bh_queue_node;
@ -20,23 +20,26 @@ struct bh_queue {
unsigned int cnt;
unsigned int max;
unsigned int drops;
bh_queue_node * head;
bh_queue_node * tail;
bh_queue_node *head;
bh_queue_node *tail;
bool exit_loop_run;
};
char * bh_message_payload(bh_message_t message)
char *
bh_message_payload(bh_message_t message)
{
return message->body;
}
uint32 bh_message_payload_len(bh_message_t message)
uint32
bh_message_payload_len(bh_message_t message)
{
return message->len;
}
int bh_message_type(bh_message_t message)
int
bh_message_type(bh_message_t message)
{
return message->tag;
}
@ -68,7 +71,8 @@ bh_queue_create()
return queue;
}
void bh_queue_destroy(bh_queue *queue)
void
bh_queue_destroy(bh_queue *queue)
{
bh_queue_node *node;
@ -89,7 +93,8 @@ void bh_queue_destroy(bh_queue *queue)
bh_queue_free(queue);
}
bool bh_post_msg2(bh_queue *queue, bh_queue_node *msg)
bool
bh_post_msg2(bh_queue *queue, bh_queue_node *msg)
{
if (queue->cnt >= queue->max) {
queue->drops++;
@ -107,7 +112,8 @@ bool bh_post_msg2(bh_queue *queue, bh_queue_node *msg)
queue->cnt = 1;
bh_queue_cond_signal(&queue->queue_wait_cond);
} else {
}
else {
msg->next = NULL;
msg->prev = queue->tail;
queue->tail->next = msg;
@ -120,8 +126,8 @@ bool bh_post_msg2(bh_queue *queue, bh_queue_node *msg)
return true;
}
bool bh_post_msg(bh_queue *queue, unsigned short tag, void *body,
unsigned int len)
bool
bh_post_msg(bh_queue *queue, unsigned short tag, void *body, unsigned int len)
{
bh_queue_node *msg = bh_new_msg(tag, body, len, NULL);
if (msg == NULL) {
@ -139,23 +145,24 @@ bool bh_post_msg(bh_queue *queue, unsigned short tag, void *body,
return true;
}
bh_queue_node * bh_new_msg(unsigned short tag, void *body, unsigned int len,
void * handler)
bh_queue_node *
bh_new_msg(unsigned short tag, void *body, unsigned int len, void *handler)
{
bh_queue_node *msg = (bh_queue_node*)
bh_queue_malloc(sizeof(bh_queue_node));
bh_queue_node *msg =
(bh_queue_node *)bh_queue_malloc(sizeof(bh_queue_node));
if (msg == NULL)
return NULL;
memset(msg, 0, sizeof(bh_queue_node));
msg->len = len;
msg->body = body;
msg->tag = tag;
msg->msg_cleaner = (bh_msg_cleaner) handler;
msg->msg_cleaner = (bh_msg_cleaner)handler;
return msg;
}
void bh_free_msg(bh_queue_node *msg)
void
bh_free_msg(bh_queue_node *msg)
{
if (msg->msg_cleaner) {
msg->msg_cleaner(msg->body);
@ -171,7 +178,8 @@ void bh_free_msg(bh_queue_node *msg)
bh_queue_free(msg);
}
bh_message_t bh_get_msg(bh_queue *queue, uint64 timeout_us)
bh_message_t
bh_get_msg(bh_queue *queue, uint64 timeout_us)
{
bh_queue_node *msg = NULL;
bh_queue_mutex_lock(&queue->queue_lock);
@ -192,13 +200,15 @@ bh_message_t bh_get_msg(bh_queue *queue, uint64 timeout_us)
if (queue->cnt == 0) {
bh_assert(queue->head == NULL);
bh_assert(queue->tail == NULL);
} else if (queue->cnt == 1) {
}
else if (queue->cnt == 1) {
bh_assert(queue->head == queue->tail);
msg = queue->head;
queue->head = queue->tail = NULL;
queue->cnt = 0;
} else {
}
else {
msg = queue->head;
queue->head = queue->head->next;
queue->head->prev = NULL;
@ -210,7 +220,8 @@ bh_message_t bh_get_msg(bh_queue *queue, uint64 timeout_us)
return msg;
}
unsigned bh_queue_get_message_count(bh_queue *queue)
unsigned
bh_queue_get_message_count(bh_queue *queue)
{
if (!queue)
return 0;
@ -218,15 +229,15 @@ unsigned bh_queue_get_message_count(bh_queue *queue)
return queue->cnt;
}
void bh_queue_enter_loop_run(bh_queue *queue,
bh_queue_handle_msg_callback handle_cb,
void
bh_queue_enter_loop_run(bh_queue *queue, bh_queue_handle_msg_callback handle_cb,
void *arg)
{
if (!queue)
return;
while (!queue->exit_loop_run) {
bh_queue_node * message = bh_get_msg(queue, BHT_WAIT_FOREVER);
bh_queue_node *message = bh_get_msg(queue, BHT_WAIT_FOREVER);
if (message) {
handle_cb(message, arg);
@ -235,7 +246,8 @@ void bh_queue_enter_loop_run(bh_queue *queue,
}
}
void bh_queue_exit_loop_run(bh_queue *queue)
void
bh_queue_exit_loop_run(bh_queue *queue)
{
if (queue) {
queue->exit_loop_run = true;

32
core/shared/utils/bh_queue.h
View File

@ -13,7 +13,7 @@ extern "C" {
#include "bh_platform.h"
struct bh_queue_node;
typedef struct bh_queue_node * bh_message_t;
typedef struct bh_queue_node *bh_message_t;
struct bh_queue;
typedef struct bh_queue bh_queue;
@ -45,25 +45,30 @@ bh_queue_create();
void
bh_queue_destroy(bh_queue *queue);
char * bh_message_payload(bh_message_t message);
uint32 bh_message_payload_len(bh_message_t message);
int bh_message_type(bh_message_t message);
char *
bh_message_payload(bh_message_t message);
uint32
bh_message_payload_len(bh_message_t message);
int
bh_message_type(bh_message_t message);
bh_message_t bh_new_msg(unsigned short tag, void *body, unsigned int len,
void * handler);
void bh_free_msg(bh_message_t msg);
bool bh_post_msg(bh_queue *queue, unsigned short tag, void *body,
unsigned int len);
bool bh_post_msg2(bh_queue *queue, bh_message_t msg);
bh_message_t
bh_new_msg(unsigned short tag, void *body, unsigned int len, void *handler);
void
bh_free_msg(bh_message_t msg);
bool
bh_post_msg(bh_queue *queue, unsigned short tag, void *body, unsigned int len);
bool
bh_post_msg2(bh_queue *queue, bh_message_t msg);
bh_message_t bh_get_msg(bh_queue *queue, uint64 timeout_us);
bh_message_t
bh_get_msg(bh_queue *queue, uint64 timeout_us);
unsigned
bh_queue_get_message_count(bh_queue *queue);
void
bh_queue_enter_loop_run(bh_queue *queue,
bh_queue_handle_msg_callback handle_cb,
bh_queue_enter_loop_run(bh_queue *queue, bh_queue_handle_msg_callback handle_cb,
void *arg);
void
bh_queue_exit_loop_run(bh_queue *queue);
@ -73,4 +78,3 @@ bh_queue_exit_loop_run(bh_queue *queue);
#endif
#endif /* #ifndef _BH_QUEUE_H */

22
core/shared/utils/bh_vector.c
View File

@ -5,14 +5,13 @@
#include "bh_vector.h"
static uint8*
static uint8 *
alloc_vector_data(size_t length, size_t size_elem)
{
uint64 total_size = ((uint64)size_elem) * length;
uint8 *data;
if (length > UINT32_MAX
|| size_elem > UINT32_MAX
if (length > UINT32_MAX || size_elem > UINT32_MAX
|| total_size > UINT32_MAX) {
return NULL;
}
@ -82,12 +81,13 @@ bh_vector_set(Vector *vector, uint32 index, const void *elem_buf)
return false;
}
memcpy(vector->data + vector->size_elem * index,
elem_buf, vector->size_elem);
memcpy(vector->data + vector->size_elem * index, elem_buf,
vector->size_elem);
return true;
}
bool bh_vector_get(const Vector *vector, uint32 index, void *elem_buf)
bool
bh_vector_get(const Vector *vector, uint32 index, void *elem_buf)
{
if (!vector || !elem_buf) {
LOG_ERROR("Get vector elem failed: vector or elem buf is NULL.\n");
@ -104,7 +104,8 @@ bool bh_vector_get(const Vector *vector, uint32 index, void *elem_buf)
return true;
}
bool bh_vector_insert(Vector *vector, uint32 index, const void *elem_buf)
bool
bh_vector_insert(Vector *vector, uint32 index, const void *elem_buf)
{
size_t i;
uint8 *p;
@ -135,7 +136,8 @@ bool bh_vector_insert(Vector *vector, uint32 index, const void *elem_buf)
return true;
}
bool bh_vector_append(Vector *vector, const void *elem_buf)
bool
bh_vector_append(Vector *vector, const void *elem_buf)
{
if (!vector || !elem_buf) {
LOG_ERROR("Append vector elem failed: vector or elem buf is NULL.\n");
@ -147,8 +149,8 @@ bool bh_vector_append(Vector *vector, const void *elem_buf)
return false;
}
memcpy(vector->data + vector->size_elem * vector->num_elems,
elem_buf, vector->size_elem);
memcpy(vector->data + vector->size_elem * vector->num_elems, elem_buf,
vector->size_elem);
vector->num_elems++;
return true;
}

1
core/shared/utils/bh_vector.h
View File

@ -122,4 +122,3 @@ bh_vector_destroy(Vector *vector);
#endif
#endif /* endof _WASM_VECTOR_H */

41
core/shared/utils/runtime_timer.c
View File

@ -12,7 +12,7 @@
#endif
typedef struct _app_timer {
struct _app_timer * next;
struct _app_timer *next;
uint32 id;
uint32 interval;
uint64 expiry;
@ -81,13 +81,13 @@ remove_timer_from(timer_ctx_t ctx, uint32 timer_id, bool active_list)
if (t->id == timer_id) {
if (prev == NULL) {
*head = t->next;
PRINT("removed timer [%d] at head from list %d\n",
t->id, active_list);
PRINT("removed timer [%d] at head from list %d\n", t->id,
active_list);
}
else {
prev->next = t->next;
PRINT("removed timer [%d] after [%d] from list %d\n",
t->id, prev->id, active_list);
PRINT("removed timer [%d] after [%d] from list %d\n", t->id,
prev->id, active_list);
}
os_mutex_unlock(&ctx->mutex);
@ -143,8 +143,8 @@ reschedule_timer(timer_ctx_t ctx, app_timer_t *timer)
else {
timer->next = t;
prev->next = timer;
PRINT("rescheduled timer [%d] after [%d]\n",
timer->id, prev->id);
PRINT("rescheduled timer [%d] after [%d]\n", timer->id,
prev->id);
}
goto out;
@ -158,8 +158,8 @@ reschedule_timer(timer_ctx_t ctx, app_timer_t *timer)
if (prev) {
/* insert to the list end */
prev->next = timer;
PRINT("rescheduled timer [%d] at end, after [%d]\n",
timer->id, prev->id);
PRINT("rescheduled timer [%d] at end, after [%d]\n", timer->id,
prev->id);
}
else {
/* insert at the begin */
@ -213,8 +213,8 @@ release_timer_list(app_timer_t **p_list)
timer_ctx_t
create_timer_ctx(timer_callback_f timer_handler,
check_timer_expiry_f expiery_checker,
int prealloc_num, unsigned int owner)
check_timer_expiry_f expiery_checker, int prealloc_num,
unsigned int owner)
{
timer_ctx_t ctx = (timer_ctx_t)BH_MALLOC(sizeof(struct _timer_ctx));
@ -229,7 +229,7 @@ create_timer_ctx(timer_callback_f timer_handler,
ctx->owner = owner;
while (prealloc_num > 0) {
app_timer_t *timer = (app_timer_t*)BH_MALLOC(sizeof(app_timer_t));
app_timer_t *timer = (app_timer_t *)BH_MALLOC(sizeof(app_timer_t));
if (timer == NULL)
goto cleanup;
@ -283,7 +283,7 @@ timer_ctx_get_owner(timer_ctx_t ctx)
}
void
add_idle_timer(timer_ctx_t ctx, app_timer_t * timer)
add_idle_timer(timer_ctx_t ctx, app_timer_t *timer)
{
os_mutex_lock(&ctx->mutex);
timer->next = ctx->idle_timers;
@ -292,8 +292,7 @@ add_idle_timer(timer_ctx_t ctx, app_timer_t * timer)
}
uint32
sys_create_timer(timer_ctx_t ctx, int interval, bool is_period,
bool auto_start)
sys_create_timer(timer_ctx_t ctx, int interval, bool is_period, bool auto_start)
{
app_timer_t *timer;
@ -307,7 +306,7 @@ sys_create_timer(timer_ctx_t ctx, int interval, bool is_period,
}
}
else {
timer = (app_timer_t*)BH_MALLOC(sizeof(app_timer_t));
timer = (app_timer_t *)BH_MALLOC(sizeof(app_timer_t));
if (timer == NULL)
return (uint32)-1;
}
@ -333,7 +332,7 @@ bool
sys_timer_cancel(timer_ctx_t ctx, uint32 timer_id)
{
bool from_active;
app_timer_t * t = remove_timer(ctx, timer_id, &from_active);
app_timer_t *t = remove_timer(ctx, timer_id, &from_active);
if (t == NULL)
return false;
@ -348,7 +347,7 @@ bool
sys_timer_destroy(timer_ctx_t ctx, uint32 timer_id)
{
bool from_active;
app_timer_t * t = remove_timer(ctx, timer_id, &from_active);
app_timer_t *t = remove_timer(ctx, timer_id, &from_active);
if (t == NULL)
return false;
@ -362,7 +361,7 @@ sys_timer_destroy(timer_ctx_t ctx, uint32 timer_id)
bool
sys_timer_restart(timer_ctx_t ctx, uint32 timer_id, int interval)
{
app_timer_t * t = remove_timer(ctx, timer_id, NULL);
app_timer_t *t = remove_timer(ctx, timer_id, NULL);
if (t == NULL)
return false;
@ -376,7 +375,8 @@ sys_timer_restart(timer_ctx_t ctx, uint32 timer_id, int interval)
}
/*
* API called by the timer manager from another thread or the kernel timer handler
* API called by the timer manager from another thread or the kernel timer
* handler
*/
/**
@ -467,4 +467,3 @@ cleanup_app_timers(timer_ctx_t ctx)
os_mutex_unlock(&ctx->mutex);
}

38
core/shared/utils/runtime_timer.h
View File

@ -12,28 +12,38 @@
extern "C" {
#endif
uint64 bh_get_tick_ms();
uint32 bh_get_elpased_ms(uint32 *last_system_clock);
uint64
bh_get_tick_ms();
uint32
bh_get_elpased_ms(uint32 *last_system_clock);
struct _timer_ctx;
typedef struct _timer_ctx * timer_ctx_t;
typedef struct _timer_ctx *timer_ctx_t;
typedef void (*timer_callback_f)(unsigned int id, unsigned int owner);
typedef void (*check_timer_expiry_f)(timer_ctx_t ctx);
timer_ctx_t create_timer_ctx(timer_callback_f timer_handler,
check_timer_expiry_f, int prealloc_num,
unsigned int owner);
timer_ctx_t
create_timer_ctx(timer_callback_f timer_handler, check_timer_expiry_f,
int prealloc_num, unsigned int owner);
void destroy_timer_ctx(timer_ctx_t);
unsigned int timer_ctx_get_owner(timer_ctx_t ctx);
unsigned int
timer_ctx_get_owner(timer_ctx_t ctx);
uint32 sys_create_timer(timer_ctx_t ctx, int interval, bool is_period,
uint32
sys_create_timer(timer_ctx_t ctx, int interval, bool is_period,
bool auto_start);
bool sys_timer_destroy(timer_ctx_t ctx, uint32 timer_id);
bool sys_timer_cancel(timer_ctx_t ctx, uint32 timer_id);
bool sys_timer_restart(timer_ctx_t ctx, uint32 timer_id, int interval);
void cleanup_app_timers(timer_ctx_t ctx);
uint32 check_app_timers(timer_ctx_t ctx);
uint32 get_expiry_ms(timer_ctx_t ctx);
bool
sys_timer_destroy(timer_ctx_t ctx, uint32 timer_id);
bool
sys_timer_cancel(timer_ctx_t ctx, uint32 timer_id);
bool
sys_timer_restart(timer_ctx_t ctx, uint32 timer_id, int interval);
void
cleanup_app_timers(timer_ctx_t ctx);
uint32
check_app_timers(timer_ctx_t ctx);
uint32
get_expiry_ms(timer_ctx_t ctx);
#ifdef __cplusplus
}

21
core/shared/utils/uncommon/bh_getopt.c
View File

@ -9,19 +9,22 @@
#include <stdio.h>
#include <string.h>
char* optarg = NULL;
char *optarg = NULL;
int optind = 1;
int getopt(int argc, char *const argv[], const char *optstring)
int
getopt(int argc, char *const argv[], const char *optstring)
{
static int sp = 1;
int opt;
char *p;
if (sp == 1) {
if ((optind >= argc) || (argv[optind][0] != '-') || (argv[optind][1] == 0)){
if ((optind >= argc) || (argv[optind][0] != '-')
|| (argv[optind][1] == 0)) {
return -1;
} else if (!strcmp(argv[optind], "--")) {
}
else if (!strcmp(argv[optind], "--")) {
optind++;
return -1;
}
@ -31,8 +34,8 @@ int getopt(int argc, char *const argv[], const char *optstring)
p = strchr(optstring, opt);
if (opt == ':' || p == NULL) {
printf("illegal option : '-%c'\n", opt);
if ( argv[optind][++sp] == '\0') {
optind ++;
if (argv[optind][++sp] == '\0') {
optind++;
sp = 1;
}
return ('?');
@ -44,11 +47,13 @@ int getopt(int argc, char *const argv[], const char *optstring)
printf("option '-%c' requires an argument :\n", opt);
sp = 1;
return ('?');
} else {
}
else {
optarg = argv[optind++];
}
sp = 1;
} else {
}
else {
if (argv[optind][++sp] == '\0') {
sp = 1;
optind++;

3
core/shared/utils/uncommon/bh_getopt.h
View File

@ -17,7 +17,8 @@ extern "C" {
extern char *optarg;
extern int optind;
int getopt(int argc, char *const argv[], const char *optstring);
int
getopt(int argc, char *const argv[], const char *optstring);
#ifdef __cplusplus
}

18
core/shared/utils/uncommon/bh_read_file.c
View File

@ -9,7 +9,7 @@
#endif
#if defined(_WIN32) || defined(_WIN32_)
char*
char *
bh_read_file_to_buffer(const char *filename, uint32 *ret_size)
{
char *buffer;
@ -22,15 +22,13 @@ bh_read_file_to_buffer(const char *filename, uint32 *ret_size)
return NULL;
}
if (_sopen_s(&file, filename, _O_RDONLY| _O_BINARY, _SH_DENYNO, 0)) {
printf("Read file to buffer failed: open file %s failed.\n",
filename);
if (_sopen_s(&file, filename, _O_RDONLY | _O_BINARY, _SH_DENYNO, 0)) {
printf("Read file to buffer failed: open file %s failed.\n", filename);
return NULL;
}
if (fstat(file, &stat_buf) != 0) {
printf("Read file to buffer failed: fstat file %s failed.\n",
filename);
printf("Read file to buffer failed: fstat file %s failed.\n", filename);
_close(file);
return NULL;
}
@ -61,7 +59,7 @@ bh_read_file_to_buffer(const char *filename, uint32 *ret_size)
return buffer;
}
#else /* else of defined(_WIN32) || defined(_WIN32_) */
char*
char *
bh_read_file_to_buffer(const char *filename, uint32 *ret_size)
{
char *buffer;
@ -75,14 +73,12 @@ bh_read_file_to_buffer(const char *filename, uint32 *ret_size)
}
if ((file = open(filename, O_RDONLY, 0)) == -1) {
printf("Read file to buffer failed: open file %s failed.\n",
filename);
printf("Read file to buffer failed: open file %s failed.\n", filename);
return NULL;
}
if (fstat(file, &stat_buf) != 0) {
printf("Read file to buffer failed: fstat file %s failed.\n",
filename);
printf("Read file to buffer failed: fstat file %s failed.\n", filename);
close(file);
return NULL;
}

1
core/shared/utils/uncommon/bh_read_file.h
View File

@ -20,4 +20,3 @@ bh_read_file_to_buffer(const char *filename, uint32 *ret_size);
#endif
#endif /* end of _BH_FILE_H */

6
product-mini/app-samples/hello-world-cmake/main.c
View File

@ -5,9 +5,11 @@
#include "stdio.h"
void print_line(char* str);
void
print_line(char *str);
int main()
int
main()
{
print_line("Hello World!");
print_line("Wasm Micro Runtime");

3
product-mini/app-samples/hello-world-cmake/print.c
View File

@ -6,7 +6,8 @@
#include "stdio.h"
#include "string.h"
void print_line(char* str)
void
print_line(char *str)
{
printf("%s\n", str);
}

3
product-mini/app-samples/hello-world/main.c
View File

@ -6,7 +6,8 @@
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char **argv)
int
main(int argc, char **argv)
{
char *buf;

28
product-mini/platforms/alios-things/src/main.c
View File

@ -24,10 +24,10 @@ static char **app_argv;
* @return true if the main function is called, false otherwise.
*/
bool
wasm_application_execute_main(wasm_module_inst_t module_inst,
int32_t argc, char *argv[]);
wasm_application_execute_main(wasm_module_inst_t module_inst, int32_t argc,
char *argv[]);
static void*
static void *
app_instance_main(wasm_module_inst_t module_inst)
{
const char *exception;
@ -40,7 +40,8 @@ app_instance_main(wasm_module_inst_t module_inst)
static char global_heap_buf[256 * 1024] = { 0 };
void iwasm_main(void *arg1)
void
iwasm_main(void *arg1)
{
uint8 *wasm_file_buf = NULL;
uint32 wasm_file_size;
@ -52,7 +53,7 @@ void iwasm_main(void *arg1)
int log_verbose_level = 2;
#endif
(void) arg1;
(void)arg1;
memset(&init_args, 0, sizeof(RuntimeInitArgs));
@ -71,7 +72,7 @@ void iwasm_main(void *arg1)
#endif
/* load WASM byte buffer from byte buffer of include file */
wasm_file_buf = (uint8*) wasm_test_file;
wasm_file_buf = (uint8 *)wasm_test_file;
wasm_file_size = sizeof(wasm_test_file);
/* load WASM module */
@ -82,11 +83,8 @@ void iwasm_main(void *arg1)
}
/* instantiate the module */
if (!(wasm_module_inst = wasm_runtime_instantiate(wasm_module,
8 * 1024,
8 * 1024,
error_buf,
sizeof(error_buf)))) {
if (!(wasm_module_inst = wasm_runtime_instantiate(
wasm_module, 8 * 1024, 8 * 1024, error_buf, sizeof(error_buf)))) {
printf("%s\n", error_buf);
goto fail2;
}
@ -108,10 +106,10 @@ fail1:
#define DEFAULT_THREAD_STACKSIZE (6 * 1024)
#define DEFAULT_THREAD_PRIORITY 50
bool iwasm_init(void)
bool
iwasm_init(void)
{
int ret = aos_task_new("wasm-main", iwasm_main, NULL,
DEFAULT_THREAD_STACKSIZE);
int ret =
aos_task_new("wasm-main", iwasm_main, NULL, DEFAULT_THREAD_STACKSIZE);
return ret == 0 ? true : false;
}

25
product-mini/platforms/android/wasm-jni.cpp
View File

@ -10,7 +10,8 @@
((void)__android_log_print(ANDROID_LOG_INFO, "wasm_jni::", __VA_ARGS__))
static void *
app_instance_main(wasm_module_inst_t module_inst) {
app_instance_main(wasm_module_inst_t module_inst)
{
const char *exception;
wasm_application_execute_main(module_inst, 0, NULL);
@ -58,20 +59,21 @@ static unsigned char wasm_test_file[] = {
};
extern "C" JNIEXPORT void JNICALL
Java_com_intel_wasm_api_Runtime_run(JNIEnv *env, jclass thiz) {
Java_com_intel_wasm_api_Runtime_run(JNIEnv *env, jclass thiz)
{
wasm_module_t wasm_module = NULL;
wasm_module_inst_t wasm_module_inst = NULL;
RuntimeInitArgs init_args;
uint wasm_file_size = 0;
uint8_t *wasm_file_buf = NULL;
char error_buf[128] = {0};
char error_buf[128] = { 0 };
memset(&init_args, 0, sizeof(RuntimeInitArgs));
init_args.mem_alloc_type = Alloc_With_Allocator;
init_args.mem_alloc_option.allocator.malloc_func = (void*)malloc;
init_args.mem_alloc_option.allocator.realloc_func = (void*)realloc;
init_args.mem_alloc_option.allocator.free_func = (void*)free;
init_args.mem_alloc_option.allocator.malloc_func = (void *)malloc;
init_args.mem_alloc_option.allocator.realloc_func = (void *)realloc;
init_args.mem_alloc_option.allocator.free_func = (void *)free;
LOGI("wasm_runtime_full_init");
/* initialize runtime environment */
@ -82,7 +84,7 @@ Java_com_intel_wasm_api_Runtime_run(JNIEnv *env, jclass thiz) {
/* load WASM byte buffer from a preinstall WASM bin file */
LOGI("use an internal test file, gona to output Hello World in logcat\n");
wasm_file_buf = (uint8_t*) wasm_test_file;
wasm_file_buf = (uint8_t *)wasm_test_file;
wasm_file_size = sizeof(wasm_test_file);
/* load WASM module */
@ -96,11 +98,10 @@ Java_com_intel_wasm_api_Runtime_run(JNIEnv *env, jclass thiz) {
/* instantiate the module */
LOGI("wasm_runtime_instantiate");
if (!(wasm_module_inst = wasm_runtime_instantiate(wasm_module,
64 * 1024, /* stack size */
if (!(wasm_module_inst =
wasm_runtime_instantiate(wasm_module, 64 * 1024, /* stack size */
64 * 1024, /* heap size */
error_buf,
sizeof(error_buf)))) {
error_buf, sizeof(error_buf)))) {
LOGI("%s\n", error_buf);
LOGI("goto fail2\n");
goto fail2;
@ -121,7 +122,7 @@ fail2:
fail1:
// in our case, we don't need a free, but it is not a typical one
/* free the file buffer */
//bh_free((void *) wasm_file_buf);
// bh_free((void *) wasm_file_buf);
/* destroy runtime environment */
LOGI("wasm_runtime_destroy");

15
product-mini/platforms/esp-idf/iwasm_main.c
View File

@ -14,7 +14,7 @@
static int app_argc;
static char **app_argv;
static void*
static void *
app_instance_main(wasm_module_inst_t module_inst)
{
const char *exception;
@ -27,7 +27,8 @@ app_instance_main(wasm_module_inst_t module_inst)
static char global_heap_buf[CONFIG_GLOBAL_HEAP_BUF_SIZE] = { 0 };
void iwasm_main(void)
void
iwasm_main(void)
{
uint8 *wasm_file_buf = NULL;
uint32 wasm_file_size;
@ -60,7 +61,7 @@ void iwasm_main(void)
#endif
/* load WASM byte buffer from byte buffer of include file */
wasm_file_buf = (uint8*)wasm_test_file;
wasm_file_buf = (uint8 *)wasm_test_file;
wasm_file_size = sizeof(wasm_test_file);
/* load WASM module */
@ -73,11 +74,9 @@ void iwasm_main(void)
os_printf("### wasm runtime load module success.\n");
/* instantiate the module */
if (!(wasm_module_inst = wasm_runtime_instantiate(wasm_module,
CONFIG_APP_STACK_SIZE,
CONFIG_APP_HEAP_SIZE,
error_buf,
sizeof(error_buf)))) {
if (!(wasm_module_inst = wasm_runtime_instantiate(
wasm_module, CONFIG_APP_STACK_SIZE, CONFIG_APP_HEAP_SIZE,
error_buf, sizeof(error_buf)))) {
os_printf("%s\n", error_buf);
goto fail2;
}

201
product-mini/platforms/linux-sgx/enclave-sample/App/App.cpp
View File

@ -41,7 +41,7 @@ pal_get_enclave_id(void)
}
void
ocall_print(const char* str)
ocall_print(const char *str)
{
printf("%s", str);
}
@ -50,8 +50,7 @@ static char *
get_exe_path(char *path_buf, unsigned path_buf_size)
{
ssize_t i;
ssize_t size = readlink("/proc/self/exe",
path_buf, path_buf_size - 1);
ssize_t size = readlink("/proc/self/exe", path_buf, path_buf_size - 1);
if (size < 0 || (size >= path_buf_size - 1)) {
return NULL;
@ -99,8 +98,9 @@ enclave_init(sgx_enclave_id_t *p_eid)
home_dir = getpwuid(getuid())->pw_dir;
size_t home_dir_len = home_dir ? strlen(home_dir) : 0;
if (home_dir != NULL &&
home_dir_len <= MAX_PATH - 1 - sizeof(TOKEN_FILENAME) - strlen("/")) {
if (home_dir != NULL
&& home_dir_len
<= MAX_PATH - 1 - sizeof(TOKEN_FILENAME) - strlen("/")) {
/* compose the token path */
strncpy(token_path, home_dir, MAX_PATH);
strncat(token_path, "/", strlen("/"));
@ -123,18 +123,19 @@ enclave_init(sgx_enclave_id_t *p_eid)
if (read_num != 0 && read_num != sizeof(sgx_launch_token_t)) {
/* if token is invalid, clear the buffer */
memset(&token, 0x0, sizeof(sgx_launch_token_t));
printf("Warning: Invalid launch token read from \"%s\".\n", token_path);
printf("Warning: Invalid launch token read from \"%s\".\n",
token_path);
}
}
/* Step 2: call sgx_create_enclave to initialize an enclave instance */
/* Debug Support: set 2nd parameter to 1 */
ret = sgx_create_enclave(ENCLAVE_FILENAME, SGX_DEBUG_FLAG,
&token, &updated, p_eid, NULL);
ret = sgx_create_enclave(ENCLAVE_FILENAME, SGX_DEBUG_FLAG, &token, &updated,
p_eid, NULL);
if (ret != SGX_SUCCESS)
/* Try to load enclave.sign.so from the path of exe file */
ret = sgx_create_enclave(enclave_path, SGX_DEBUG_FLAG,
&token, &updated, p_eid, NULL);
ret = sgx_create_enclave(enclave_path, SGX_DEBUG_FLAG, &token, &updated,
p_eid, NULL);
if (ret != SGX_SUCCESS) {
printf("Failed to create enclave from %s, error code: %d\n",
ENCLAVE_FILENAME, ret);
@ -145,8 +146,10 @@ enclave_init(sgx_enclave_id_t *p_eid)
/* Step 3: save the launch token if it is updated */
if (updated == FALSE || fp == NULL) {
/* if the token is not updated, or file handler is invalid, do not perform saving */
if (fp != NULL) fclose(fp);
/* if the token is not updated, or file handler is invalid,
do not perform saving */
if (fp != NULL)
fclose(fp);
return 0;
}
@ -176,8 +179,7 @@ read_file_to_buffer(const char *filename, uint32_t *ret_size)
}
if (!(file = fopen(filename, "r"))) {
printf("Read file to buffer failed: open file %s failed.\n",
filename);
printf("Read file to buffer failed: open file %s failed.\n", filename);
return NULL;
}
@ -185,7 +187,7 @@ read_file_to_buffer(const char *filename, uint32_t *ret_size)
file_size = ftell(file);
fseek(file, 0, SEEK_SET);
if (!(buffer = (unsigned char*)malloc(file_size))) {
if (!(buffer = (unsigned char *)malloc(file_size))) {
printf("Read file to buffer failed: alloc memory failed.\n");
fclose(file);
return NULL;
@ -205,6 +207,7 @@ read_file_to_buffer(const char *filename, uint32_t *ret_size)
return buffer;
}
/* clang-format off */
static int
print_help()
{
@ -227,6 +230,7 @@ print_help()
printf(" --max-threads=n Set maximum thread number per cluster, default is 4\n");
return 1;
}
/* clang-format on */
/**
* Split a space separated strings into an array of strings
@ -287,8 +291,8 @@ typedef enum EcallCmd {
} EcallCmd;
static void
app_instance_func(void *wasm_module_inst, const char *func_name,
int app_argc, char **app_argv);
app_instance_func(void *wasm_module_inst, const char *func_name, int app_argc,
char **app_argv);
static void *
app_instance_repl(void *module_inst, int app_argc, char **app_argv)
@ -315,8 +319,8 @@ app_instance_repl(void *module_inst, int app_argc, char **app_argv)
break;
}
if (app_argc != 0) {
app_instance_func(module_inst, app_argv[0],
app_argc - 1, app_argv + 1);
app_instance_func(module_inst, app_argv[0], app_argc - 1,
app_argv + 1);
}
free(app_argv);
}
@ -349,9 +353,9 @@ set_log_verbose_level(int log_verbose_level)
/* Set log verbose level */
if (log_verbose_level != 2) {
ecall_args[0] = log_verbose_level;
if (SGX_SUCCESS != ecall_handle_command(g_eid, CMD_SET_LOG_LEVEL,
(uint8_t *)ecall_args,
sizeof(uint64_t))) {
if (SGX_SUCCESS
!= ecall_handle_command(g_eid, CMD_SET_LOG_LEVEL,
(uint8_t *)ecall_args, sizeof(uint64_t))) {
printf("Call ecall_handle_command() failed.\n");
return false;
}
@ -366,8 +370,8 @@ init_runtime(bool alloc_with_pool, uint32_t max_thread_num)
ecall_args[0] = alloc_with_pool;
ecall_args[1] = max_thread_num;
if (SGX_SUCCESS != ecall_handle_command(g_eid, CMD_INIT_RUNTIME,
(uint8_t *)ecall_args,
if (SGX_SUCCESS
!= ecall_handle_command(g_eid, CMD_INIT_RUNTIME, (uint8_t *)ecall_args,
sizeof(uint64_t) * 2)) {
printf("Call ecall_handle_command() failed.\n");
return false;
@ -382,15 +386,15 @@ init_runtime(bool alloc_with_pool, uint32_t max_thread_num)
static void
destroy_runtime()
{
if (SGX_SUCCESS != ecall_handle_command(g_eid, CMD_DESTROY_RUNTIME,
NULL, 0)) {
if (SGX_SUCCESS
!= ecall_handle_command(g_eid, CMD_DESTROY_RUNTIME, NULL, 0)) {
printf("Call ecall_handle_command() failed.\n");
}
}
static void *
load_module(uint8_t *wasm_file_buf, uint32_t wasm_file_size,
char *error_buf, uint32_t error_buf_size)
load_module(uint8_t *wasm_file_buf, uint32_t wasm_file_size, char *error_buf,
uint32_t error_buf_size)
{
uint64_t ecall_args[4];
@ -398,8 +402,8 @@ load_module(uint8_t *wasm_file_buf, uint32_t wasm_file_size,
ecall_args[1] = wasm_file_size;
ecall_args[2] = (uint64_t)(uintptr_t)error_buf;
ecall_args[3] = error_buf_size;
if (SGX_SUCCESS != ecall_handle_command(g_eid, CMD_LOAD_MODULE,
(uint8_t *)ecall_args,
if (SGX_SUCCESS
!= ecall_handle_command(g_eid, CMD_LOAD_MODULE, (uint8_t *)ecall_args,
sizeof(uint64_t) * 4)) {
printf("Call ecall_handle_command() failed.\n");
return NULL;
@ -414,16 +418,15 @@ unload_module(void *wasm_module)
uint64_t ecall_args[1];
ecall_args[0] = (uint64_t)(uintptr_t)wasm_module;
if (SGX_SUCCESS != ecall_handle_command(g_eid, CMD_UNLOAD_MODULE,
(uint8_t *)ecall_args,
if (SGX_SUCCESS
!= ecall_handle_command(g_eid, CMD_UNLOAD_MODULE, (uint8_t *)ecall_args,
sizeof(uint64_t))) {
printf("Call ecall_handle_command() failed.\n");
}
}
static void *
instantiate_module(void *wasm_module,
uint32_t stack_size, uint32_t heap_size,
instantiate_module(void *wasm_module, uint32_t stack_size, uint32_t heap_size,
char *error_buf, uint32_t error_buf_size)
{
uint64_t ecall_args[5];
@ -433,9 +436,9 @@ instantiate_module(void *wasm_module,
ecall_args[2] = heap_size;
ecall_args[3] = (uint64_t)(uintptr_t)error_buf;
ecall_args[4] = error_buf_size;
if (SGX_SUCCESS != ecall_handle_command(g_eid, CMD_INSTANTIATE_MODULE,
(uint8_t *)ecall_args,
sizeof(uint64_t) * 5)) {
if (SGX_SUCCESS
!= ecall_handle_command(g_eid, CMD_INSTANTIATE_MODULE,
(uint8_t *)ecall_args, sizeof(uint64_t) * 5)) {
printf("Call ecall_handle_command() failed.\n");
return NULL;
}
@ -449,24 +452,23 @@ deinstantiate_module(void *wasm_module_inst)
uint64_t ecall_args[1];
ecall_args[0] = (uint64_t)(uintptr_t)wasm_module_inst;
if (SGX_SUCCESS != ecall_handle_command(g_eid, CMD_DEINSTANTIATE_MODULE,
(uint8_t *)ecall_args,
sizeof(uint64_t))) {
if (SGX_SUCCESS
!= ecall_handle_command(g_eid, CMD_DEINSTANTIATE_MODULE,
(uint8_t *)ecall_args, sizeof(uint64_t))) {
printf("Call ecall_handle_command() failed.\n");
}
}
static bool
get_exception(void *wasm_module_inst,
char *exception, uint32_t exception_size)
get_exception(void *wasm_module_inst, char *exception, uint32_t exception_size)
{
uint64_t ecall_args[3];
ecall_args[0] = (uint64_t)(uintptr_t)wasm_module_inst;
ecall_args[1] = (uint64_t)(uintptr_t)exception;
ecall_args[2] = exception_size;
if (SGX_SUCCESS != ecall_handle_command(g_eid, CMD_GET_EXCEPTION,
(uint8_t *)ecall_args,
if (SGX_SUCCESS
!= ecall_handle_command(g_eid, CMD_GET_EXCEPTION, (uint8_t *)ecall_args,
sizeof(uint64_t) * 3)) {
printf("Call ecall_handle_command() failed.\n");
}
@ -475,16 +477,15 @@ get_exception(void *wasm_module_inst,
}
static void
app_instance_main(void *wasm_module_inst,
int app_argc, char **app_argv)
app_instance_main(void *wasm_module_inst, int app_argc, char **app_argv)
{
char exception[128];
uint64_t ecall_args_buf[16], *ecall_args = ecall_args_buf;
int i, size;
if (app_argc + 2 > sizeof(ecall_args_buf) / sizeof(uint64_t)) {
if (!(ecall_args = (uint64_t *)
malloc(sizeof(uint64_t) * (app_argc + 2)))) {
if (!(ecall_args =
(uint64_t *)malloc(sizeof(uint64_t) * (app_argc + 2)))) {
printf("Allocate memory failed.\n");
return;
}
@ -497,8 +498,8 @@ app_instance_main(void *wasm_module_inst,
}
size = (uint32_t)sizeof(uint64_t) * (app_argc + 2);
if (SGX_SUCCESS != ecall_handle_command(g_eid, CMD_EXEC_APP_MAIN,
(uint8_t *)ecall_args,
if (SGX_SUCCESS
!= ecall_handle_command(g_eid, CMD_EXEC_APP_MAIN, (uint8_t *)ecall_args,
size)) {
printf("Call ecall_handle_command() failed.\n");
}
@ -513,15 +514,15 @@ app_instance_main(void *wasm_module_inst,
}
static void
app_instance_func(void *wasm_module_inst, const char *func_name,
int app_argc, char **app_argv)
app_instance_func(void *wasm_module_inst, const char *func_name, int app_argc,
char **app_argv)
{
uint64_t ecall_args_buf[16], *ecall_args = ecall_args_buf;
int i, size;
if (app_argc + 3 > sizeof(ecall_args_buf) / sizeof(uint64_t)) {
if (!(ecall_args = (uint64_t *)
malloc(sizeof(uint64_t) * (app_argc + 3)))) {
if (!(ecall_args =
(uint64_t *)malloc(sizeof(uint64_t) * (app_argc + 3)))) {
printf("Allocate memory failed.\n");
return;
}
@ -535,8 +536,8 @@ app_instance_func(void *wasm_module_inst, const char *func_name,
}
size = (uint32_t)sizeof(uint64_t) * (app_argc + 3);
if (SGX_SUCCESS != ecall_handle_command(g_eid, CMD_EXEC_APP_FUNC,
(uint8_t *)ecall_args,
if (SGX_SUCCESS
!= ecall_handle_command(g_eid, CMD_EXEC_APP_FUNC, (uint8_t *)ecall_args,
size)) {
printf("Call ecall_handle_command() failed.\n");
}
@ -547,11 +548,9 @@ app_instance_func(void *wasm_module_inst, const char *func_name,
}
static bool
set_wasi_args(void *wasm_module,
const char **dir_list, uint32_t dir_list_size,
const char **env_list, uint32_t env_list_size,
int stdinfd, int stdoutfd, int stderrfd,
char **argv, uint32_t argc)
set_wasi_args(void *wasm_module, const char **dir_list, uint32_t dir_list_size,
const char **env_list, uint32_t env_list_size, int stdinfd,
int stdoutfd, int stderrfd, char **argv, uint32_t argc)
{
uint64_t ecall_args[10];
@ -565,8 +564,8 @@ set_wasi_args(void *wasm_module,
ecall_args[7] = stderrfd;
ecall_args[8] = (uint64_t)(uintptr_t)argv;
ecall_args[9] = argc;
if (SGX_SUCCESS != ecall_handle_command(g_eid, CMD_SET_WASI_ARGS,
(uint8_t *)ecall_args,
if (SGX_SUCCESS
!= ecall_handle_command(g_eid, CMD_SET_WASI_ARGS, (uint8_t *)ecall_args,
sizeof(uint64_t) * 10)) {
printf("Call ecall_handle_command() failed.\n");
}
@ -698,23 +697,22 @@ main(int argc, char *argv[])
}
/* Load module */
if (!(wasm_module = load_module(wasm_file_buf, wasm_file_size,
error_buf, sizeof(error_buf)))) {
if (!(wasm_module = load_module(wasm_file_buf, wasm_file_size, error_buf,
sizeof(error_buf)))) {
printf("%s\n", error_buf);
goto fail2;
}
/* Set wasi arguments */
if (!set_wasi_args(wasm_module, dir_list, dir_list_size,
env_list, env_list_size, 0, 1, 2, argv, argc)) {
if (!set_wasi_args(wasm_module, dir_list, dir_list_size, env_list,
env_list_size, 0, 1, 2, argv, argc)) {
printf("%s\n", "set wasi arguments failed.\n");
goto fail3;
}
/* Instantiate module */
if (!(wasm_module_inst = instantiate_module(wasm_module,
stack_size, heap_size,
error_buf,
if (!(wasm_module_inst =
instantiate_module(wasm_module, stack_size, heap_size, error_buf,
sizeof(error_buf)))) {
printf("%s\n", error_buf);
goto fail3;
@ -723,8 +721,7 @@ main(int argc, char *argv[])
if (is_repl_mode)
app_instance_repl(wasm_module_inst, argc, argv);
else if (func_name)
app_instance_func(wasm_module_inst, func_name,
argc - 1, argv + 1);
app_instance_func(wasm_module_inst, func_name, argc - 1, argv + 1);
else
app_instance_main(wasm_module_inst, argc, argv);
@ -782,19 +779,19 @@ wamr_pal_create_process(struct wamr_pal_create_process_args *args)
int stderrfd = -1;
int argc = 2;
char *argv[argc] = { (char*)"./iwasm", (char *)args->argv[0] };
char *argv[argc] = { (char *)"./iwasm", (char *)args->argv[0] };
uint8_t *wasm_files_buf = NULL;
void *wasm_modules = NULL;
int len = 0, i;
char *temp = (char *)args->argv[0];
while(temp) {
while (temp) {
len++;
temp=(char *)args->argv[len];
temp = (char *)args->argv[len];
}
if (len > sizeof(wasm_files)/sizeof(char *)) {
if (len > sizeof(wasm_files) / sizeof(char *)) {
printf("Number of input files is out of range\n");
return -1;
}
@ -829,8 +826,8 @@ wamr_pal_create_process(struct wamr_pal_create_process_args *args)
char error_buf[128] = { 0 };
/* Load WASM byte buffer from WASM bin file */
if (!(wasm_file_buf = (uint8_t *)read_file_to_buffer
(wasm_files[i], &wasm_file_size))) {
if (!(wasm_file_buf = (uint8_t *)read_file_to_buffer(
wasm_files[i], &wasm_file_size))) {
printf("Failed to read file to buffer\n");
destroy_runtime();
return -1;
@ -846,10 +843,9 @@ wamr_pal_create_process(struct wamr_pal_create_process_args *args)
}
/* Set wasi arguments */
if (!set_wasi_args(wasm_module, dir_list, dir_list_size,
env_list, env_list_size,
stdinfd, stdoutfd, stderrfd,
argv, argc)) {
if (!set_wasi_args(wasm_module, dir_list, dir_list_size, env_list,
env_list_size, stdinfd, stdoutfd, stderrfd, argv,
argc)) {
printf("%s\n", "set wasi arguments failed.\n");
unload_module(wasm_module);
free(wasm_file_buf);
@ -858,10 +854,9 @@ wamr_pal_create_process(struct wamr_pal_create_process_args *args)
}
/* Instantiate module */
if (!(wasm_module_inst[i] = instantiate_module(wasm_module,
stack_size, heap_size,
error_buf,
sizeof(error_buf)))) {
if (!(wasm_module_inst[i] =
instantiate_module(wasm_module, stack_size, heap_size,
error_buf, sizeof(error_buf)))) {
printf("%s\n", error_buf);
unload_module(wasm_module);
free(wasm_file_buf);
@ -884,37 +879,43 @@ wamr_pal_create_process(struct wamr_pal_create_process_args *args)
int
wamr_pal_destroy(void)
{
//sgx_destroy_enclave(g_eid);
// sgx_destroy_enclave(g_eid);
return 0;
}
int
wamr_pal_exec(struct wamr_pal_exec_args *args)
{
//app_instance_main(wasm_module_inst[i], argc, argv);
// app_instance_main(wasm_module_inst[i], argc, argv);
return 0;
}
int
wamr_pal_kill(int pid, int sig)
{
//deinstantiate_module(wasm_module_inst[i]);
//unload_module(wasm_module);
//free(wasm_file_buf);
// deinstantiate_module(wasm_module_inst[i]);
// unload_module(wasm_module);
// free(wasm_file_buf);
return 0;
}
int pal_get_version(void) __attribute__((weak, alias ("wamr_pal_get_version")));
int
pal_get_version(void) __attribute__((weak, alias("wamr_pal_get_version")));
int pal_init(const struct wamr_pal_attr *attr)\
__attribute__ ((weak, alias ("wamr_pal_init")));
int
pal_init(const struct wamr_pal_attr *attr)
__attribute__((weak, alias("wamr_pal_init")));
int pal_create_process(struct wamr_pal_create_process_args *args)\
__attribute__ ((weak, alias ("wamr_pal_create_process")));
int
pal_create_process(struct wamr_pal_create_process_args *args)
__attribute__((weak, alias("wamr_pal_create_process")));
int pal_exec(struct wamr_pal_exec_args *args)\
__attribute__ ((weak, alias ("wamr_pal_exec")));
int
pal_exec(struct wamr_pal_exec_args *args)
__attribute__((weak, alias("wamr_pal_exec")));
int pal_kill(int pid, int sig) __attribute__ ((weak, alias ("wamr_pal_kill")));
int
pal_kill(int pid, int sig) __attribute__((weak, alias("wamr_pal_kill")));
int pal_destroy(void) __attribute__ ((weak, alias ("wamr_pal_destroy")));
int
pal_destroy(void) __attribute__((weak, alias("wamr_pal_destroy")));

52
product-mini/platforms/linux-sgx/enclave-sample/App/pal_api.h
View File

@ -20,7 +20,8 @@ extern "C" {
*
* @retval If > 0, then success; otherwise, it is an invalid version.
*/
int wamr_pal_get_version(void);
int
wamr_pal_get_version(void);
/*
* WAMR PAL attributes
@ -38,10 +39,12 @@ typedef struct wamr_pal_attr {
const char *log_level;
} wamr_pal_attr_t;
/* clang-format off */
#define WAMR_PAL_ATTR_INITVAL { \
.instance_dir = ".", \
.log_level = 2 \
}
/* clang-format on */
/*
* The struct which consists of file descriptors of standard I/O
@ -66,21 +69,23 @@ struct wamr_pal_create_process_args {
// Argments array pass to new process.
//
// The arguments to the command. By convention, the argv[0] should be the program name.
// And the last element of the array must be NULL to indicate the length of array.
// The arguments to the command. By convention, the argv[0] should be the
// program name. And the last element of the array must be NULL to indicate
// the length of array.
//
// Mandatory field. Must not be NULL.
const char **argv;
// Untrusted environment variable array pass to new process.
//
// The untrusted env vars to the command. And the last element of the array must be
// NULL to indicate the length of array.
// The untrusted env vars to the command. And the last element of the array
// must be NULL to indicate the length of array.
//
// Optional field.
const char **env;
// File descriptors of the redirected standard I/O (i.e., stdin, stdout, stderr)
// File descriptors of the redirected standard I/O (i.e., stdin, stdout,
// stderr)
//
// If set to NULL, will use the original standard I/O file descriptors.
//
@ -115,32 +120,41 @@ struct wamr_pal_exec_args {
int *exit_value;
};
int wamr_pal_init(const struct wamr_pal_attr *args);
int
wamr_pal_init(const struct wamr_pal_attr *args);
int wamr_pal_create_process(struct wamr_pal_create_process_args *args);
int
wamr_pal_create_process(struct wamr_pal_create_process_args *args);
int wamr_pal_destroy(void);
int
wamr_pal_destroy(void);
int wamr_pal_exec(struct wamr_pal_exec_args *args);
int
wamr_pal_exec(struct wamr_pal_exec_args *args);
int wamr_pal_kill(int pid, int sig);
int
wamr_pal_kill(int pid, int sig);
int pal_get_version(void);
int
pal_get_version(void);
int pal_init(const struct wamr_pal_attr *attr);
int
pal_init(const struct wamr_pal_attr *attr);
int pal_create_process(struct wamr_pal_create_process_args *args);
int
pal_create_process(struct wamr_pal_create_process_args *args);
int pal_exec(struct wamr_pal_exec_args *args);
int
pal_exec(struct wamr_pal_exec_args *args);
int pal_kill(int pid, int sig);
int pal_destroy(void);
int
pal_kill(int pid, int sig);
int
pal_destroy(void);
#ifdef __cplusplus
}
#endif
#endif /* __WAMR_PAL_API_H__ */

65
product-mini/platforms/linux-sgx/enclave-sample/Enclave/Enclave.cpp
View File

@ -13,14 +13,15 @@
#include "bh_platform.h"
extern "C" {
typedef void (*os_print_function_t)(const char* message);
extern void os_set_print_function(os_print_function_t pf);
typedef void (*os_print_function_t)(const char *message);
extern void
os_set_print_function(os_print_function_t pf);
void
enclave_print(const char *message)
{
void
enclave_print(const char *message)
{
ocall_print(message);
}
}
}
typedef enum EcallCmd {
@ -130,8 +131,8 @@ handle_cmd_load_module(uint64 *args, uint32 argc)
bh_assert(argc == 4);
if (total_size >= UINT32_MAX
|| !(enclave_module = (EnclaveModule *)
wasm_runtime_malloc((uint32)total_size))) {
|| !(enclave_module =
(EnclaveModule *)wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size,
"WASM module load failed: "
"allocate memory failed.");
@ -140,10 +141,9 @@ handle_cmd_load_module(uint64 *args, uint32 argc)
}
memset(enclave_module, 0, (uint32)total_size);
enclave_module->wasm_file = (uint8 *)enclave_module
+ sizeof(EnclaveModule);
bh_memcpy_s(enclave_module->wasm_file, wasm_file_size,
wasm_file, wasm_file_size);
enclave_module->wasm_file = (uint8 *)enclave_module + sizeof(EnclaveModule);
bh_memcpy_s(enclave_module->wasm_file, wasm_file_size, wasm_file,
wasm_file_size);
if (!(enclave_module->module =
wasm_runtime_load(enclave_module->wasm_file, wasm_file_size,
@ -189,9 +189,8 @@ handle_cmd_instantiate_module(uint64 *args, uint32 argc)
bh_assert(argc == 5);
if (!(module_inst =
wasm_runtime_instantiate(enclave_module->module,
stack_size, heap_size,
error_buf, error_buf_size))) {
wasm_runtime_instantiate(enclave_module->module, stack_size,
heap_size, error_buf, error_buf_size))) {
*(void **)args_org = NULL;
return;
}
@ -225,8 +224,7 @@ handle_cmd_get_exception(uint64 *args, uint32 argc)
bh_assert(argc == 3);
if ((exception1 = wasm_runtime_get_exception(module_inst))) {
snprintf(exception, exception_size,
"%s", exception1);
snprintf(exception, exception_size, "%s", exception1);
args_org[0] = true;
}
else {
@ -339,14 +337,13 @@ handle_cmd_set_wasi_args(uint64 *args, int32 argc)
}
if (total_size >= UINT32_MAX
|| !(enclave_module->wasi_arg_buf = p = (char *)
wasm_runtime_malloc((uint32)total_size))) {
|| !(enclave_module->wasi_arg_buf = p =
(char *)wasm_runtime_malloc((uint32)total_size))) {
*args_org = false;
return;
}
p1 = p + sizeof(char *) * dir_list_size
+ sizeof(char *) * env_list_size
p1 = p + sizeof(char *) * dir_list_size + sizeof(char *) * env_list_size
+ sizeof(char *) * wasi_argc;
if (dir_list_size > 0) {
@ -385,16 +382,11 @@ handle_cmd_set_wasi_args(uint64 *args, int32 argc)
p += sizeof(char *) * wasi_argc;
}
wasm_runtime_set_wasi_args_ex(enclave_module->module,
(const char **)enclave_module->wasi_dir_list,
dir_list_size,
NULL, 0,
(const char **)enclave_module->wasi_env_list,
env_list_size,
enclave_module->wasi_argv,
enclave_module->wasi_argc,
(stdinfd != -1) ? stdinfd : 0,
(stdoutfd != -1) ? stdoutfd : 1,
wasm_runtime_set_wasi_args_ex(
enclave_module->module, (const char **)enclave_module->wasi_dir_list,
dir_list_size, NULL, 0, (const char **)enclave_module->wasi_env_list,
env_list_size, enclave_module->wasi_argv, enclave_module->wasi_argc,
(stdinfd != -1) ? stdinfd : 0, (stdoutfd != -1) ? stdoutfd : 1,
(stderrfd != -1) ? stderrfd : 2);
*args_org = true;
@ -408,8 +400,7 @@ handle_cmd_set_wasi_args(uint64 *args, int32 argc)
#endif /* end of SGX_DISABLE_WASI */
void
ecall_handle_command(unsigned cmd,
unsigned char *cmd_buf,
ecall_handle_command(unsigned cmd, unsigned char *cmd_buf,
unsigned cmd_buf_size)
{
uint64 *args = (uint64 *)cmd_buf;
@ -494,11 +485,9 @@ ecall_iwasm_main(uint8_t *wasm_file_buf, uint32_t wasm_file_size)
}
/* instantiate the module */
if (!(wasm_module_inst = wasm_runtime_instantiate(wasm_module,
16 * 1024,
16 * 1024,
error_buf,
sizeof(error_buf)))) {
if (!(wasm_module_inst =
wasm_runtime_instantiate(wasm_module, 16 * 1024, 16 * 1024,
error_buf, sizeof(error_buf)))) {
ocall_print(error_buf);
ocall_print("\n");
goto fail2;

20
product-mini/platforms/linux-sgx/enclave-sample/Enclave/Enclave_test.cpp
View File

@ -8,7 +8,8 @@
#include "wasm_export.h"
#include "bh_platform.h"
void ecall_iwasm_test()
void
ecall_iwasm_test()
{
ocall_print(" Prepare to invoke sgx_open ... ==>\n\n");
@ -76,7 +77,7 @@ void ecall_iwasm_test()
02 : - O_RDWR */
/** 1. open **/
fd = open(file, O_RDWR);
if (fd !=-1) {
if (fd != -1) {
ocall_print("\tOperation open test_open.txt success.\n");
}
@ -140,7 +141,7 @@ void ecall_iwasm_test()
p_dirent = readdir(dirp);
if (p_dirent != NULL) {
ocall_print("\tOperation readdir success.\t");
ocall_print(p_dirent -> d_name);
ocall_print(p_dirent->d_name);
ocall_print("\n");
}
@ -158,7 +159,7 @@ void ecall_iwasm_test()
/** closedir **/
ret = closedir(dirp);
if (ret == 0 ) {
if (ret == 0) {
ocall_print("\tOperation closedir success. \n");
}
/* 2. close */
@ -336,18 +337,19 @@ void ecall_iwasm_test()
close(fd);
/** getopt **/
while((ret = getopt(argc, argv, "f:abc")) != -1){ //get option from the getopt() method
switch(ret){
//For option i, r, l, print that these are options
while ((ret = getopt(argc, argv, "f:abc"))
!= -1) { // get option from the getopt() method
switch (ret) {
// For option i, r, l, print that these are options
case 'a':
case 'b':
case 'c':
ocall_print("\tGiven Option operation success. \n");
break;
case 'f': //here f is used for some file name
case 'f': // here f is used for some file name
ocall_print("\tGiven File operation success.\n");
break;
case '?': //used for some unknown options
case '?': // used for some unknown options
ocall_print("\tunknown option trigger success.\n");
break;
}

20
product-mini/platforms/posix/main.c
View File

@ -18,6 +18,7 @@ static char **app_argv;
#define MODULE_PATH ("--module-path=")
/* clang-format off */
static int
print_help()
{
@ -55,6 +56,7 @@ print_help()
#endif
return 1;
}
/* clang-format on */
static void *
app_instance_main(wasm_module_inst_t module_inst)
@ -194,8 +196,8 @@ module_reader_callback(const char *module_name, uint8 **p_buffer,
uint32 *p_size)
{
const char *format = "%s/%s.wasm";
int sz = strlen(module_search_path) + strlen("/") + strlen(module_name) +
strlen(".wasm") + 1;
int sz = strlen(module_search_path) + strlen("/") + strlen(module_name)
+ strlen(".wasm") + 1;
char *wasm_file_name = BH_MALLOC(sz);
if (!wasm_file_name) {
return false;
@ -245,8 +247,8 @@ main(int argc, char *argv[])
uint32 env_list_size = 0;
#endif
#if WASM_ENABLE_DEBUG_INTERP != 0
char * ip_addr = NULL;
//int platform_port = 0;
char *ip_addr = NULL;
/* int platform_port = 0; */
int instance_port = 0;
#endif
@ -332,7 +334,7 @@ main(int argc, char *argv[])
#endif
#if WASM_ENABLE_DEBUG_INTERP != 0
else if (!strncmp(argv[0], "-g=", 3)) {
char * port_str = strchr(argv[0] + 3, ':');
char *port_str = strchr(argv[0] + 3, ':');
char *port_end;
if (port_str == NULL)
return print_help();
@ -394,15 +396,15 @@ main(int argc, char *argv[])
int map_prot = MMAP_PROT_READ | MMAP_PROT_WRITE | MMAP_PROT_EXEC;
int map_flags = MMAP_MAP_NONE;
if (!(wasm_file_mapped = os_mmap(NULL, (uint32)wasm_file_size,
map_prot, map_flags))) {
if (!(wasm_file_mapped =
os_mmap(NULL, (uint32)wasm_file_size, map_prot, map_flags))) {
printf("mmap memory failed\n");
wasm_runtime_free(wasm_file_buf);
goto fail1;
}
bh_memcpy_s(wasm_file_mapped, wasm_file_size,
wasm_file_buf, wasm_file_size);
bh_memcpy_s(wasm_file_mapped, wasm_file_size, wasm_file_buf,
wasm_file_size);
wasm_runtime_free(wasm_file_buf);
wasm_file_buf = wasm_file_mapped;
}

Some files were not shown because too many files have changed in this diff Show More