christoph/wamr
1
Fork 0
Code Releases Activity

Implement libc-WASI for Linux SGX platform and update documents (#343)

Browse Source
This commit is contained in:
Wenyong Huang
2020-08-10 15:12:26 +08:00
committed by GitHub
parent 8edf1e152f
commit 1b6ddb37d0
55 changed files with 3692 additions and 516 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
core/iwasm/aot/aot_loader.c
View File

@ -972,9 +972,11 @@ load_object_data_sections(const uint8 **p_buf, const uint8 *buf_end,
return false;
}
#if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64)
#ifndef BH_PLATFORM_LINUX_SGX
/* address must be in the first 2 Gigabytes of
the process address space */
bh_assert((uintptr_t)data_sections[i].data < INT32_MAX);
#endif
#endif
read_byte_array(buf, buf_end,
@ -1799,9 +1801,11 @@ create_sections(const uint8 *buf, uint32 size,
goto fail;
}
#if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64)
#ifndef BH_PLATFORM_LINUX_SGX
/* address must be in the first 2 Gigabytes of
the process address space */
bh_assert((uintptr_t)aot_text < INT32_MAX);
#endif
#endif
bh_memcpy_s(aot_text, (uint32)total_size,
section->section_body, (uint32)section_size);

4
core/iwasm/common/wasm_c_api.c
View File

@ -76,7 +76,9 @@ static inline void
generic_vec_init_data(Vector *out, size_t num_of_elems, size_t size_of_elem)
{
if (!bh_vector_init(out, num_of_elems, size_of_elem)) {
memset(out, 0, sizeof(Vector));
out->data = NULL;
out->max_elems = 0;
out->num_elems = 0;
}
else {
memset(out->data, 0, num_of_elems * size_of_elem);

38
core/iwasm/common/wasm_runtime_common.c
View File

@ -1279,6 +1279,8 @@ wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst,
struct fd_table *curfds;
struct fd_prestats *prestats;
struct argv_environ_values *argv_environ;
bool fd_table_inited = false, fd_prestats_inited = false;
bool argv_environ_inited = false;
int32 offset_argv_offsets = 0, offset_env_offsets = 0;
int32 offset_argv_buf = 0, offset_env_buf = 0;
int32 offset_curfds = 0;
@ -1373,9 +1375,26 @@ wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst,
wasi_ctx->curfds_offset = offset_curfds;
wasi_ctx->prestats_offset = offset_prestats;
wasi_ctx->argv_environ_offset = offset_argv_environ;
wasi_ctx->argv_buf_offset = offset_argv_buf;
wasi_ctx->argv_offsets_offset = offset_argv_offsets;
wasi_ctx->env_buf_offset = offset_env_buf;
wasi_ctx->env_offsets_offset = offset_env_offsets;
fd_table_init(curfds);
fd_prestats_init(prestats);
if (!fd_table_init(curfds)) {
set_error_buf(error_buf, error_buf_size,
"Init wasi environment failed: "
"init fd table failed.");
goto fail;
}
fd_table_inited = true;
if (!fd_prestats_init(prestats)) {
set_error_buf(error_buf, error_buf_size,
"Init wasi environment failed: "
"init fd prestats failed.");
goto fail;
}
fd_prestats_inited = true;
if (!argv_environ_init(argv_environ,
argv_offsets, argc,
@ -1387,6 +1406,7 @@ wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst,
"init argument environment failed.");
goto fail;
}
argv_environ_inited = true;
/* Prepopulate curfds with stdin, stdout, and stderr file descriptors. */
if (!fd_table_insert_existing(curfds, 0, 0)
@ -1424,6 +1444,12 @@ wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst,
return true;
fail:
if (argv_environ_inited)
argv_environ_destroy(argv_environ);
if (fd_prestats_inited)
fd_prestats_destroy(prestats);
if (fd_table_inited)
fd_table_destroy(curfds);
if (offset_curfds != 0)
wasm_runtime_module_free(module_inst, offset_curfds);
if (offset_prestats != 0)
@ -1537,6 +1563,14 @@ wasm_runtime_destroy_wasi(WASMModuleInstanceCommon *module_inst)
fd_prestats_destroy(prestats);
wasm_runtime_module_free(module_inst, wasi_ctx->prestats_offset);
}
if (wasi_ctx->argv_buf_offset)
wasm_runtime_module_free(module_inst, wasi_ctx->argv_buf_offset);
if (wasi_ctx->argv_offsets_offset)
wasm_runtime_module_free(module_inst, wasi_ctx->argv_offsets_offset);
if (wasi_ctx->env_buf_offset)
wasm_runtime_module_free(module_inst, wasi_ctx->env_buf_offset);
if (wasi_ctx->env_offsets_offset)
wasm_runtime_module_free(module_inst, wasi_ctx->env_offsets_offset);
wasm_runtime_free(wasi_ctx);
}
}

4
core/iwasm/common/wasm_runtime_common.h
View File

@ -52,6 +52,10 @@ typedef struct WASIContext {
int32 curfds_offset;
int32 prestats_offset;
int32 argv_environ_offset;
int32 argv_buf_offset;
int32 argv_offsets_offset;
int32 env_buf_offset;
int32 env_offsets_offset;
} WASIContext;
#endif

3
core/iwasm/libraries/libc-wasi/libc_wasi_wrapper.c
View File

@ -4,8 +4,7 @@
*/
#include "libc_wasi_wrapper.h"
#include "bh_common.h"
#include "bh_log.h"
#include "bh_platform.h"
#include "wasm_export.h"
void

6
core/iwasm/libraries/libc-wasi/sandboxed-system-primitives/include/wasmtime_ssp.h
View File

@ -832,9 +832,15 @@ __wasi_errno_t wasmtime_ssp_poll_oneoff(
size_t *nevents
) WASMTIME_SSP_SYSCALL_NAME(poll_oneoff) __attribute__((__warn_unused_result__));
#if 0
/**
* We throw exception in libc-wasi wrapper function wasi_proc_exit()
* but not call this function.
*/
_Noreturn void wasmtime_ssp_proc_exit(
__wasi_exitcode_t rval
) WASMTIME_SSP_SYSCALL_NAME(proc_exit);
#endif
__wasi_errno_t wasmtime_ssp_proc_raise(
__wasi_signal_t sig

250
core/iwasm/libraries/libc-wasi/sandboxed-system-primitives/src/locking.h
View File

@ -14,12 +14,6 @@
#include "ssp_config.h"
#include <assert.h>
#include <errno.h>
#include <pthread.h>
#include <stdint.h>
#include <time.h>
#ifndef __has_extension
#define __has_extension(x) 0
#endif
@ -30,7 +24,7 @@
#define LOCK_ANNOTATE(x)
#endif
// Lock annotation macros.
/* Lock annotation macros. */
#define LOCKABLE LOCK_ANNOTATE(lockable)
@ -50,166 +44,216 @@
#define NO_LOCK_ANALYSIS LOCK_ANNOTATE(no_thread_safety_analysis)
// Mutex that uses the lock annotations.
/* Mutex that uses the lock annotations. */
struct LOCKABLE mutex {
pthread_mutex_t object;
pthread_mutex_t object;
};
#define MUTEX_INITIALIZER \
{ PTHREAD_MUTEX_INITIALIZER }
static inline void mutex_init(struct mutex *lock) REQUIRES_UNLOCKED(*lock) {
pthread_mutex_init(&lock->object, NULL);
static inline bool
mutex_init(struct mutex *lock) REQUIRES_UNLOCKED(*lock)
{
return pthread_mutex_init(&lock->object, NULL) == 0 ? true : false;
}
static inline void mutex_destroy(struct mutex *lock) REQUIRES_UNLOCKED(*lock) {
pthread_mutex_destroy(&lock->object);
static inline void
mutex_destroy(struct mutex *lock) REQUIRES_UNLOCKED(*lock)
{
pthread_mutex_destroy(&lock->object);
}
static inline void mutex_lock(struct mutex *lock)
LOCKS_EXCLUSIVE(*lock) NO_LOCK_ANALYSIS {
pthread_mutex_lock(&lock->object);
static inline void
mutex_lock(struct mutex *lock) LOCKS_EXCLUSIVE(*lock) NO_LOCK_ANALYSIS
{
pthread_mutex_lock(&lock->object);
}
static inline void mutex_unlock(struct mutex *lock)
UNLOCKS(*lock) NO_LOCK_ANALYSIS {
pthread_mutex_unlock(&lock->object);
static inline void
mutex_unlock(struct mutex *lock) UNLOCKS(*lock) NO_LOCK_ANALYSIS
{
pthread_mutex_unlock(&lock->object);
}
// Read-write lock that uses the lock annotations.
/* Read-write lock that uses the lock annotations. */
struct LOCKABLE rwlock {
pthread_rwlock_t object;
pthread_rwlock_t object;
};
static inline void rwlock_init(struct rwlock *lock) REQUIRES_UNLOCKED(*lock) {
pthread_rwlock_init(&lock->object, NULL);
static inline bool
rwlock_init(struct rwlock *lock) REQUIRES_UNLOCKED(*lock)
{
return pthread_rwlock_init(&lock->object, NULL) == 0 ? true : false;
}
static inline void rwlock_rdlock(struct rwlock *lock)
LOCKS_SHARED(*lock) NO_LOCK_ANALYSIS {
pthread_rwlock_rdlock(&lock->object);
static inline void
rwlock_rdlock(struct rwlock *lock) LOCKS_SHARED(*lock) NO_LOCK_ANALYSIS
{
pthread_rwlock_rdlock(&lock->object);
}
static inline void rwlock_wrlock(struct rwlock *lock)
LOCKS_EXCLUSIVE(*lock) NO_LOCK_ANALYSIS {
pthread_rwlock_wrlock(&lock->object);
static inline void
rwlock_wrlock(struct rwlock *lock) LOCKS_EXCLUSIVE(*lock) NO_LOCK_ANALYSIS
{
pthread_rwlock_wrlock(&lock->object);
}
static inline void rwlock_unlock(struct rwlock *lock)
UNLOCKS(*lock) NO_LOCK_ANALYSIS {
pthread_rwlock_unlock(&lock->object);
static inline void
rwlock_unlock(struct rwlock *lock) UNLOCKS(*lock) NO_LOCK_ANALYSIS
{
pthread_rwlock_unlock(&lock->object);
}
// Condition variable that uses the lock annotations.
static inline void
rwlock_destroy(struct rwlock *lock) UNLOCKS(*lock) NO_LOCK_ANALYSIS
{
pthread_rwlock_destroy(&lock->object);
}
/* Condition variable that uses the lock annotations. */
struct LOCKABLE cond {
pthread_cond_t object;
pthread_cond_t object;
#if !CONFIG_HAS_PTHREAD_CONDATTR_SETCLOCK || \
!CONFIG_HAS_PTHREAD_COND_TIMEDWAIT_RELATIVE_NP
clockid_t clock;
clockid_t clock;
#endif
};
static inline void cond_init_monotonic(struct cond *cond) {
static inline bool
cond_init_monotonic(struct cond *cond) {
bool ret = false;
#if CONFIG_HAS_PTHREAD_CONDATTR_SETCLOCK
pthread_condattr_t attr;
pthread_condattr_init(&attr);
pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
pthread_cond_init(&cond->object, &attr);
pthread_condattr_destroy(&attr);
pthread_condattr_t attr;
if (pthread_condattr_init(&attr) != 0)
return false;
if (pthread_condattr_setclock(&attr, CLOCK_MONOTONIC) != 0)
goto fail;
if (pthread_cond_init(&cond->object, &attr) != 0)
goto fail;
ret = true;
fail:
pthread_condattr_destroy(&attr);
#else
pthread_cond_init(&cond->object, NULL);
if (pthread_cond_init(&cond->object, NULL) != 0)
return false;
ret = true;
#endif
#if !CONFIG_HAS_PTHREAD_CONDATTR_SETCLOCK || \
!CONFIG_HAS_PTHREAD_COND_TIMEDWAIT_RELATIVE_NP
cond->clock = CLOCK_MONOTONIC;
cond->clock = CLOCK_MONOTONIC;
#endif
return ret;
}
static inline void cond_init_realtime(struct cond *cond) {
pthread_cond_init(&cond->object, NULL);
static inline bool
cond_init_realtime(struct cond *cond)
{
if (pthread_cond_init(&cond->object, NULL) != 0)
return false;
#if !CONFIG_HAS_PTHREAD_CONDATTR_SETCLOCK || \
!CONFIG_HAS_PTHREAD_COND_TIMEDWAIT_RELATIVE_NP
cond->clock = CLOCK_REALTIME;
cond->clock = CLOCK_REALTIME;
#endif
return true;
}
static inline void cond_destroy(struct cond *cond) {
pthread_cond_destroy(&cond->object);
static inline void
cond_destroy(struct cond *cond) {
pthread_cond_destroy(&cond->object);
}
static inline void cond_signal(struct cond *cond) {
pthread_cond_signal(&cond->object);
static inline void
cond_signal(struct cond *cond) {
pthread_cond_signal(&cond->object);
}
static inline bool cond_timedwait(struct cond *cond, struct mutex *lock,
uint64_t timeout, bool abstime)
REQUIRES_EXCLUSIVE(*lock) NO_LOCK_ANALYSIS {
struct timespec ts = {
.tv_sec = (time_t)(timeout / 1000000000),
.tv_nsec = (long)(timeout % 1000000000),
};
#if !CONFIG_HAS_CLOCK_NANOSLEEP
static inline bool
cond_timedwait(struct cond *cond, struct mutex *lock,
uint64_t timeout, bool abstime)
REQUIRES_EXCLUSIVE(*lock) NO_LOCK_ANALYSIS
{
int ret;
struct timespec ts = {
.tv_sec = (time_t)(timeout / 1000000000),
.tv_nsec = (long)(timeout % 1000000000),
};
if (abstime) {
if (abstime) {
#if !CONFIG_HAS_PTHREAD_CONDATTR_SETCLOCK
// No native support for sleeping on monotonic clocks. Convert the
// timeout to a relative value and then to an absolute value for the
// realtime clock.
if (cond->clock != CLOCK_REALTIME) {
struct timespec ts_monotonic;
clock_gettime(cond->clock, &ts_monotonic);
ts.tv_sec -= ts_monotonic.tv_sec;
ts.tv_nsec -= ts_monotonic.tv_nsec;
if (ts.tv_nsec < 0) {
ts.tv_nsec += 1000000000;
--ts.tv_sec;
}
/**
* No native support for sleeping on monotonic clocks. Convert the
* timeout to a relative value and then to an absolute value for the
* realtime clock.
*/
if (cond->clock != CLOCK_REALTIME) {
struct timespec ts_monotonic;
struct timespec ts_realtime;
struct timespec ts_realtime;
clock_gettime(CLOCK_REALTIME, &ts_realtime);
ts.tv_sec += ts_realtime.tv_sec;
ts.tv_nsec += ts_realtime.tv_nsec;
if (ts.tv_nsec >= 1000000000) {
ts.tv_nsec -= 1000000000;
++ts.tv_sec;
}
}
clock_gettime(cond->clock, &ts_monotonic);
ts.tv_sec -= ts_monotonic.tv_sec;
ts.tv_nsec -= ts_monotonic.tv_nsec;
if (ts.tv_nsec < 0) {
ts.tv_nsec += 1000000000;
--ts.tv_sec;
}
clock_gettime(CLOCK_REALTIME, &ts_realtime);
ts.tv_sec += ts_realtime.tv_sec;
ts.tv_nsec += ts_realtime.tv_nsec;
if (ts.tv_nsec >= 1000000000) {
ts.tv_nsec -= 1000000000;
++ts.tv_sec;
}
}
#endif
} else {
}
else {
#if CONFIG_HAS_PTHREAD_COND_TIMEDWAIT_RELATIVE_NP
// Implementation supports relative timeouts.
int ret =
pthread_cond_timedwait_relative_np(&cond->object, &lock->object, &ts);
assert((ret == 0 || ret == ETIMEDOUT) &&
"pthread_cond_timedwait_relative_np() failed");
return ret == ETIMEDOUT;
/* Implementation supports relative timeouts. */
ret = pthread_cond_timedwait_relative_np(&cond->object,
&lock->object, &ts);
bh_assert((ret == 0 || ret == ETIMEDOUT)
&& "pthread_cond_timedwait_relative_np() failed");
return ret == ETIMEDOUT;
#else
// Convert to absolute timeout.
struct timespec ts_now;
/* Convert to absolute timeout. */
struct timespec ts_now;
#if CONFIG_HAS_PTHREAD_CONDATTR_SETCLOCK
clock_gettime(cond->clock, &ts_now);
clock_gettime(cond->clock, &ts_now);
#else
clock_gettime(CLOCK_REALTIME, &ts_now);
clock_gettime(CLOCK_REALTIME, &ts_now);
#endif
ts.tv_sec += ts_now.tv_sec;
ts.tv_nsec += ts_now.tv_nsec;
if (ts.tv_nsec >= 1000000000) {
ts.tv_nsec -= 1000000000;
++ts.tv_sec;
}
#endif
ts.tv_sec += ts_now.tv_sec;
ts.tv_nsec += ts_now.tv_nsec;
if (ts.tv_nsec >= 1000000000) {
ts.tv_nsec -= 1000000000;
++ts.tv_sec;
}
#endif
}
int ret = pthread_cond_timedwait(&cond->object, &lock->object, &ts);
assert((ret == 0 || ret == ETIMEDOUT) && "pthread_cond_timedwait() failed");
return ret == ETIMEDOUT;
ret = pthread_cond_timedwait(&cond->object, &lock->object, &ts);
bh_assert((ret == 0 || ret == ETIMEDOUT)
&& "pthread_cond_timedwait() failed");
return ret == ETIMEDOUT;
}
#endif
static inline void cond_wait(struct cond *cond, struct mutex *lock)
REQUIRES_EXCLUSIVE(*lock) NO_LOCK_ANALYSIS {
pthread_cond_wait(&cond->object, &lock->object);
static inline void
cond_wait(struct cond *cond, struct mutex *lock)
REQUIRES_EXCLUSIVE(*lock) NO_LOCK_ANALYSIS
{
pthread_cond_wait(&cond->object, &lock->object);
}
#endif

2
core/iwasm/libraries/libc-wasi/sandboxed-system-primitives/src/numeric_limits.h
View File

@ -12,8 +12,6 @@
#ifndef COMMON_LIMITS_H
#define COMMON_LIMITS_H
#include <limits.h>
#define NUMERIC_MIN(t) \
_Generic((t)0, char \
: CHAR_MIN, signed char \

83
core/iwasm/libraries/libc-wasi/sandboxed-system-primitives/src/posix.c
View File

@ -10,34 +10,8 @@
// Copyright (c) 2016-2018 Nuxi, https://nuxi.nl/
#include "ssp_config.h"
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/resource.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/uio.h>
#include <assert.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <sched.h>
#include <signal.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <wasmtime_ssp.h>
#include "bh_platform.h"
#include "wasmtime_ssp.h"
#include "locking.h"
#include "numeric_limits.h"
#include "posix.h"
@ -46,9 +20,6 @@
#include "rights.h"
#include "str.h"
#include "bh_common.h"
#include "bh_assert.h"
#if 0 /* TODO: -std=gnu99 causes compile error, comment them first */
// struct iovec must have the same layout as __wasi_iovec_t.
static_assert(offsetof(struct iovec, iov_base) ==
@ -252,16 +223,18 @@ struct fd_prestat {
const char *dir;
};
void fd_prestats_init(
bool fd_prestats_init(
struct fd_prestats *pt
) {
rwlock_init(&pt->lock);
if (!rwlock_init(&pt->lock))
return false;
pt->prestats = NULL;
pt->size = 0;
pt->used = 0;
#if defined(WASMTIME_SSP_STATIC_CURFDS)
prestats = pt;
#endif
return true;
}
// Grows the preopened resource table to a required lower bound and a
@ -359,16 +332,18 @@ struct fd_entry {
__wasi_rights_t rights_inheriting;
};
void fd_table_init(
bool fd_table_init(
struct fd_table *ft
) {
rwlock_init(&ft->lock);
if (!rwlock_init(&ft->lock))
return false;
ft->entries = NULL;
ft->size = 0;
ft->used = 0;
#if defined(WASMTIME_SSP_STATIC_CURFDS)
curfds = ft;
#endif
return true;
}
// Looks up a file descriptor table entry by number and required rights.
@ -598,17 +573,22 @@ bool fd_table_insert_existing(
) {
__wasi_filetype_t type;
__wasi_rights_t rights_base, rights_inheriting;
if (fd_determine_type_rights(out, &type, &rights_base, &rights_inheriting) !=
0)
struct fd_object *fo;
__wasi_errno_t error;
if (fd_determine_type_rights(out, &type, &rights_base,
&rights_inheriting) != 0)
return false;
struct fd_object *fo;
__wasi_errno_t error = fd_object_new(type, &fo);
error = fd_object_new(type, &fo);
if (error != 0)
return false;
fo->number = out;
if (type == __WASI_FILETYPE_DIRECTORY) {
mutex_init(&fo->directory.lock);
if (!mutex_init(&fo->directory.lock)) {
fd_object_release(fo);
return false;
}
fo->directory.handle = NULL;
}
@ -671,13 +651,17 @@ static __wasi_errno_t fd_table_insert_fd(
) REQUIRES_UNLOCKED(ft->lock) {
struct fd_object *fo;
__wasi_errno_t error = fd_object_new(type, &fo);
if (error != 0) {
close(in);
return error;
}
fo->number = in;
if (type == __WASI_FILETYPE_DIRECTORY) {
mutex_init(&fo->directory.lock);
if (!mutex_init(&fo->directory.lock)) {
fd_object_release(fo);
return -1;
}
fo->directory.handle = NULL;
}
return fd_table_insert(ft, fo, rights_base, rights_inheriting, out);
@ -2471,9 +2455,14 @@ __wasi_errno_t wasmtime_ssp_poll_oneoff(
// Sleeping to an absolute point in time can only be done
// by waiting on a condition variable.
struct mutex mutex;
mutex_init(&mutex);
struct cond cond;
cond_init_realtime(&cond);
if (!mutex_init(&mutex))
return -1;
if (!cond_init_realtime(&cond)) {
mutex_destroy(&mutex);
return -1;
}
mutex_lock(&mutex);
cond_timedwait(&cond, &mutex, in[0].u.clock.timeout, true);
mutex_unlock(&mutex);
@ -2649,11 +2638,17 @@ __wasi_errno_t wasmtime_ssp_poll_oneoff(
return error;
}
#if 0
/**
* We throw exception in libc-wasi wrapper function wasi_proc_exit()
* but not call this function.
*/
void wasmtime_ssp_proc_exit(
__wasi_exitcode_t rval
) {
_Exit((int32)rval);
}
#endif
__wasi_errno_t wasmtime_ssp_proc_raise(
__wasi_signal_t sig
@ -2952,6 +2947,7 @@ void fd_table_destroy(struct fd_table *ft)
fd_object_release(ft->entries[i].object);
}
}
rwlock_destroy(&ft->lock);
wasm_runtime_free(ft->entries);
}
}
@ -2964,6 +2960,7 @@ void fd_prestats_destroy(struct fd_prestats *pt)
wasm_runtime_free((void*)pt->prestats[i].dir);
}
}
rwlock_destroy(&pt->lock);
wasm_runtime_free(pt->prestats);
}
}

8
core/iwasm/libraries/libc-wasi/sandboxed-system-primitives/src/posix.h
View File

@ -12,9 +12,7 @@
#ifndef POSIX_H
#define POSIX_H
#include <stdbool.h>
#include <stddef.h>
#include "bh_platform.h"
#include "locking.h"
struct fd_entry;
@ -46,9 +44,9 @@ struct argv_environ_values {
char *environ_buf;
};
void fd_table_init(struct fd_table *);
bool fd_table_init(struct fd_table *);
bool fd_table_insert_existing(struct fd_table *, __wasi_fd_t, int);
void fd_prestats_init(struct fd_prestats *);
bool fd_prestats_init(struct fd_prestats *);
bool fd_prestats_insert(struct fd_prestats *, const char *, __wasi_fd_t);
bool argv_environ_init(struct argv_environ_values *,
const size_t *argv_offsets, size_t argv_offsets_len,

2
core/iwasm/libraries/libc-wasi/sandboxed-system-primitives/src/queue.h
View File

@ -12,8 +12,6 @@
#ifndef QUEUE_H
#define QUEUE_H
#include <stddef.h>
// LIST: Double-linked list.
#define LIST_HEAD(name, type) \

18
core/iwasm/libraries/libc-wasi/sandboxed-system-primitives/src/random.c
View File

@ -10,15 +10,7 @@
// Copyright (c) 2016 Nuxi, https://nuxi.nl/
#include "ssp_config.h"
#include <fcntl.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include "bh_platform.h"
#include "random.h"
#if CONFIG_HAS_ARC4RANDOM_BUF
@ -29,7 +21,9 @@ void random_buf(void *buf, size_t len) {
#elif CONFIG_HAS_GETRANDOM
#ifndef BH_PLATFORM_LINUX_SGX
#include <sys/random.h>
#endif
void random_buf(void *buf, size_t len) {
for (;;) {
@ -37,7 +31,7 @@ void random_buf(void *buf, size_t len) {
if (x < 0) {
if (errno == EINTR)
continue;
fprintf(stderr, "getrandom failed: %s", strerror(errno));
os_printf("getrandom failed: %s", strerror(errno));
abort();
}
if ((size_t)x == len)
@ -54,7 +48,7 @@ static int urandom;
static void open_urandom(void) {
urandom = open("/dev/urandom", O_RDONLY);
if (urandom < 0) {
fputs("Failed to open /dev/urandom\n", stderr);
os_printf("Failed to open /dev/urandom\n");
abort();
}
}
@ -64,7 +58,7 @@ void random_buf(void *buf, size_t len) {
pthread_once(&open_once, open_urandom);
if ((size_t)read(urandom, buf, len) != len) {
fputs("Short read on /dev/urandom\n", stderr);
os_printf("Short read on /dev/urandom\n");
abort();
}
}

2
core/iwasm/libraries/libc-wasi/sandboxed-system-primitives/src/random.h
View File

@ -12,8 +12,6 @@
#ifndef RANDOM_H
#define RANDOM_H
#include <stdint.h>
void random_buf(void *, size_t);
uintmax_t random_uniform(uintmax_t);

97
core/iwasm/libraries/libc-wasi/sandboxed-system-primitives/src/refcount.h
View File

@ -12,36 +12,89 @@
#ifndef REFCOUNT_H
#define REFCOUNT_H
#include <assert.h>
#include <stdatomic.h>
#include <stdbool.h>
#include "bh_platform.h"
#include "locking.h"
// Simple reference counter.
struct LOCKABLE refcount {
atomic_uint count;
};
#define PRODUCES(...) LOCKS_SHARED(__VA_ARGS__) NO_LOCK_ANALYSIS
#define CONSUMES(...) UNLOCKS(__VA_ARGS__) NO_LOCK_ANALYSIS
// Initialize the reference counter.
static void refcount_init(struct refcount *r, unsigned int count) PRODUCES(*r) {
atomic_init(&r->count, count);
#if CONFIG_HAS_STD_ATOMIC != 0
#include <stdatomic.h>
/* Simple reference counter. */
struct LOCKABLE refcount {
atomic_uint count;
};
/* Initialize the reference counter. */
static inline void
refcount_init(struct refcount *r, unsigned int count) PRODUCES(*r)
{
atomic_init(&r->count, count);
}
// Increment the reference counter.
static inline void refcount_acquire(struct refcount *r) PRODUCES(*r) {
atomic_fetch_add_explicit(&r->count, 1, memory_order_acquire);
/* Increment the reference counter. */
static inline void
refcount_acquire(struct refcount *r) PRODUCES(*r)
{
atomic_fetch_add_explicit(&r->count, 1, memory_order_acquire);
}
// Decrement the reference counter, returning whether the reference
// dropped to zero.
static inline bool refcount_release(struct refcount *r) CONSUMES(*r) {
int old = (int)atomic_fetch_sub_explicit(&r->count, 1, memory_order_release);
assert(old != 0 && "Reference count becoming negative");
return old == 1;
/* Decrement the reference counter, returning whether the reference
dropped to zero. */
static inline bool
refcount_release(struct refcount *r) CONSUMES(*r)
{
int old = (int)atomic_fetch_sub_explicit(&r->count, 1,
memory_order_release);
bh_assert(old != 0 && "Reference count becoming negative");
return old == 1;
}
#endif
#elif defined(BH_PLATFORM_LINUX_SGX)
#include <sgx_spinlock.h>
/* Simple reference counter. */
struct refcount {
sgx_spinlock_t lock;
unsigned int count;
};
/* Initialize the reference counter. */
static inline void
refcount_init(struct refcount *r, unsigned int count)
{
r->lock = SGX_SPINLOCK_INITIALIZER;
r->count = count;
}
/* Increment the reference counter. */
static inline void
refcount_acquire(struct refcount *r)
{
sgx_spin_lock(&r->lock);
r->count++;
sgx_spin_unlock(&r->lock);
}
/* Decrement the reference counter, returning whether the reference
dropped to zero. */
static inline bool
refcount_release(struct refcount *r)
{
int old;
sgx_spin_lock(&r->lock);
old = (int)r->count;
r->count--;
sgx_spin_unlock(&r->lock);
bh_assert(old != 0 && "Reference count becoming negative");
return old == 1;
}
#else /* else of CONFIG_HAS_STD_ATOMIC */
#error "Reference counter isn't implemented"
#endif /* end of CONFIG_HAS_STD_ATOMIC */
#endif /* end of REFCOUNT_H */

8
core/iwasm/libraries/libc-wasi/sandboxed-system-primitives/src/ssp_config.h
View File

@ -73,7 +73,7 @@
#define CONFIG_HAS_PTHREAD_COND_TIMEDWAIT_RELATIVE_NP 0
#endif
#ifndef __APPLE__
#if !defined(__APPLE__) && !defined(BH_PLATFORM_LINUX_SGX)
#define CONFIG_HAS_PTHREAD_CONDATTR_SETCLOCK 1
#else
#define CONFIG_HAS_PTHREAD_CONDATTR_SETCLOCK 0
@ -97,4 +97,10 @@
#define CONFIG_TLS_USE_GSBASE 0
#endif
#if !defined(BH_PLATFORM_LINUX_SGX)
#define CONFIG_HAS_STD_ATOMIC 1
#else
#define CONFIG_HAS_STD_ATOMIC 0
#endif
#endif

43
core/iwasm/libraries/libc-wasi/sandboxed-system-primitives/src/str.c
View File

@ -10,24 +10,35 @@
// Copyright (c) 2016 Nuxi, https://nuxi.nl/
#include "ssp_config.h"
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "bh_platform.h"
#include "str.h"
char *str_nullterminate(const char *s, size_t len) {
// Copy string.
char *ret = strndup(s, len);
if (ret == NULL)
return NULL;
static char *
bh_strndup(const char *s, size_t n)
{
size_t l = strnlen(s, n);
char *s1 = wasm_runtime_malloc((uint32)(l + 1));
// Ensure that it contains no null bytes within.
if (strlen(ret) != len) {
free(ret);
errno = EILSEQ;
return NULL;
}
if (!s1)
return NULL;
bh_memcpy_s(s1, (uint32)(l + 1), s, (uint32)l);
s1[l] = 0;
return s1;
}
char *
str_nullterminate(const char *s, size_t len) {
/* Copy string */
char *ret = bh_strndup(s, len);
if (ret == NULL)
return NULL;
/* Ensure that it contains no null bytes within */
if (strlen(ret) != len) {
wasm_runtime_free(ret);
errno = EILSEQ;
return NULL;
}
return ret;
}

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

@ -630,6 +630,12 @@ gci_dump(gc_heap_t *heap)
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);
os_printf("#%s:%d\n", prefix->file_name, prefix->line_no);
}
#endif
cur = (hmu_t*)((char *)cur + size);
i++;

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

@ -84,8 +84,8 @@ hmu_verify(hmu_t *hmu)
if(!is_padding_ok)
{
printf("Invalid padding for object created at %s:%d",
(prefix->file_name ? prefix->file_name : ""), prefix->line_no);
os_printf("Invalid padding for object created at %s:%d",
(prefix->file_name ? prefix->file_name : ""), prefix->line_no);
}
bh_assert(is_padding_ok);
}

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

@ -80,6 +80,17 @@ int
gc_destroy_with_pool(gc_handle_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);
if ((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);
#endif
}
#endif
os_mutex_destroy(&heap->lock);
memset(heap->base_addr, 0, heap->current_size);
memset(heap, 0, sizeof(gc_heap_t));

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

@ -10,7 +10,6 @@
#include <stdbool.h>
#include <assert.h>
#include <time.h>
#include <sys/time.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
@ -18,15 +17,24 @@
#include <stdarg.h>
#include <ctype.h>
#include <pthread.h>
#include <signal.h>
#include <semaphore.h>
#include <limits.h>
#include <dirent.h>
#include <fcntl.h>
#include <unistd.h>
#include <poll.h>
#include <sched.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <netinet/in.h>
#include <sys/time.h>
#include <sys/uio.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/resource.h>
#include <android/log.h>
#ifdef __cplusplus
@ -53,7 +61,6 @@ typedef pthread_t korp_thread;
|| defined(BUILD_TARGET_AMD_64) \
|| defined(BUILD_TARGET_AARCH64)
#include <signal.h>
#include <setjmp.h>
#define OS_ENABLE_HW_BOUND_CHECK

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

@ -10,8 +10,6 @@
#include <stdbool.h>
#include <assert.h>
#include <time.h>
#include <sys/time.h>
#include <sys/timeb.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
@ -19,15 +17,26 @@
#include <stdarg.h>
#include <ctype.h>
#include <pthread.h>
#include <signal.h>
#include <semaphore.h>
#include <limits.h>
#include <dirent.h>
#include <fcntl.h>
#include <unistd.h>
#include <poll.h>
#include <sched.h>
#include <errno.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <netinet/in.h>
#include <sys/time.h>
#include <sys/timeb.h>
#include <sys/uio.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/resource.h>
#ifdef __cplusplus
extern "C" {
@ -56,7 +65,6 @@ typedef pthread_t korp_thread;
|| defined(BUILD_TARGET_AMD_64) \
|| defined(BUILD_TARGET_AARCH64)
#include <signal.h>
#include <setjmp.h>
#define OS_ENABLE_HW_BOUND_CHECK

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

@ -20,6 +20,14 @@
#include <limits.h>
#include <errno.h>
#include <sgx_thread.h>
#include <pthread.h>
#include "sgx_error.h"
#include "sgx_file.h"
#include "sgx_pthread.h"
#include "sgx_time.h"
#include "sgx_socket.h"
#include "sgx_signal.h"
#ifdef __cplusplus
extern "C" {
@ -37,14 +45,16 @@ extern "C" {
/* Default thread priority */
#define BH_THREAD_DEFAULT_PRIORITY 0
typedef sgx_thread_t korp_thread;
typedef sgx_thread_t korp_tid;
typedef sgx_thread_mutex_t korp_mutex;
typedef sgx_thread_cond_t korp_cond;
typedef pthread_t korp_thread;
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);
char *strcpy(char *dest, const char *src);
#ifdef __cplusplus
}
#endif

832
core/shared/platform/linux-sgx/sgx_file.c Normal file
View File

@ -0,0 +1,832 @@
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#include "platform_api_vmcore.h"
#include "sgx_error.h"
#include "sgx_file.h"
#define TRACE_FUNC() os_printf("undefined %s\n", __FUNCTION__)
#define TRACE_OCALL_FAIL() os_printf("ocall %s failed!\n", __FUNCTION__)
/** fd **/
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_read(ssize_t *p_ret, int fd, void *buf, size_t read_size);
int ocall_close(int *p_ret, int fd);
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_fsync(int *p_ret, int fd);
int ocall_fdatasync(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_readdir(void **p_dirent, void *dirp);
int ocall_rewinddir(void *dirp);
int ocall_seekdir(void *dirp, long loc);
int ocall_telldir(long *p_dir, void *dirp);
int ocall_closedir(int *p_ret, void *dirp);
/** DIR end **/
/** stat **/
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,
const char *linkpath);
/** link end **/
/** control **/
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);
/** 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,
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_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);
/** iovec end **/
int ocall_get_errno(int *p_ret);
int open(const char *pathname, int flags, ...)
{
int fd;
bool has_mode = false;
mode_t mode = 0;
if ((flags & O_CREAT) || (flags & O_TMPFILE) == O_TMPFILE) {
va_list ap;
va_start(ap, flags);
mode = va_arg(ap, mode_t);
va_end(ap);
has_mode = true;
}
if (SGX_SUCCESS != ocall_open(&fd, pathname, flags, has_mode, mode)) {
TRACE_OCALL_FAIL();
return -1;
}
if (fd >= 0 && (flags & O_CLOEXEC))
fcntl(fd, F_SETFD, FD_CLOEXEC);
if (fd == -1)
errno = get_errno();
return fd;
}
int openat(int dirfd, const char *pathname, int flags, ...)
{
int fd;
bool has_mode = false;
mode_t mode = 0;
if ((flags & O_CREAT) || (flags & O_TMPFILE) == O_TMPFILE) {
va_list ap;
va_start(ap, flags);
mode = va_arg(ap, mode_t);
va_end(ap);
has_mode = true;
}
if (SGX_SUCCESS != ocall_openat(&fd, dirfd, pathname, flags,
has_mode, mode)) {
TRACE_OCALL_FAIL();
return -1;
}
if (fd >= 0 && (flags & O_CLOEXEC))
fcntl(fd, F_SETFD, FD_CLOEXEC);
if (fd == -1)
errno = get_errno();
return fd;
}
int close(int fd)
{
int ret;
if (ocall_close(&ret, fd) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
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;
char *p = buf;
if (buf == NULL) {
TRACE_FUNC();
return -1;
}
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;
if (ocall_read(&ret, fd, p, size_read) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1) {
/* read failed */
errno = get_errno();
return -1;
}
p += ret;
total_size_read += ret;
if (ret < size_read)
/* end of file */
break;
}
return total_size_read;
}
DIR *fdopendir(int fd)
{
DIR *result = NULL;
result = (DIR *)BH_MALLOC(sizeof(DIR));
if (!result)
return NULL;
if (ocall_fdopendir(fd, (void **)result) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
BH_FREE(result);
return NULL;
}
if ((void *)*result == NULL) { /* opendir failed */
TRACE_FUNC();
BH_FREE(result);
errno = get_errno();
return NULL;
}
return result;
}
struct dirent *readdir(DIR *dirp)
{
struct dirent *result;
if (dirp == NULL)
return NULL;
if (ocall_readdir((void **)&result, (void *)*dirp) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return NULL;
}
if (!result)
errno = get_errno();
return result;
}
void rewinddir(DIR *dirp)
{
if (ocall_rewinddir((void *)*dirp) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
}
}
void seekdir(DIR *dirp, long loc)
{
if (ocall_seekdir((void *)*dirp, loc) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
}
}
long telldir(DIR *dirp)
{
long ret;
if (ocall_telldir(&ret, (void *)*dirp) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
int closedir(DIR *dirp)
{
int ret;
if (ocall_closedir(&ret, (void *)*dirp) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
BH_FREE(dirp);
if (ret == -1)
errno = get_errno();
return ret;
}
static ssize_t
readv_internal(int fd, const struct iovec *iov, int iovcnt,
bool has_offset, off_t offset)
{
ssize_t ret, size_left;
struct iovec *iov1;
int i;
char *p;
uint64 total_size = sizeof(struct iovec) * (uint64)iovcnt;
if (iov == NULL || iovcnt < 1)
return -1;
for (i = 0; i < iovcnt; i++) {
total_size += iov[i].iov_len;
}
if (total_size >= UINT32_MAX)
return -1;
iov1 = BH_MALLOC((uint32)total_size);
if (iov1 == NULL)
return -1;
memset(iov1, 0, (uint32)total_size);
p = (char*)(uintptr_t)(sizeof(struct iovec) * iovcnt);
for (i = 0; i < iovcnt; i++) {
iov1[i].iov_len = iov[i].iov_len;
iov1[i].iov_base = p;
p += iov[i].iov_len;
}
if (ocall_readv(&ret, fd, (char *)iov1, (uint32)total_size,
iovcnt, has_offset, offset) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
BH_FREE(iov1);
return -1;
}
p = (char *)(uintptr_t)(sizeof(struct iovec) * iovcnt);
size_left = ret;
for (i = 0; i < iovcnt; i++) {
if (size_left > iov[i].iov_len) {
memcpy(iov[i].iov_base, (uintptr_t)p + (char *)iov1,
iov[i].iov_len);
p += iov[i].iov_len;
size_left -= iov[i].iov_len;
}
else {
memcpy(iov[i].iov_base, (uintptr_t)p + (char *)iov1,
size_left);
break;
}
}
BH_FREE(iov1);
if (ret == -1)
errno = get_errno();
return ret;
}
static ssize_t
writev_internal(int fd, const struct iovec *iov, int iovcnt,
bool has_offset, off_t offset)
{
ssize_t ret;
struct iovec *iov1;
int i;
char *p;
uint64 total_size = sizeof(struct iovec) * (uint64)iovcnt;
if (iov == NULL || iovcnt < 1)
return -1;
for (i = 0; i < iovcnt; i++) {
total_size += iov[i].iov_len;
}
if (total_size >= UINT32_MAX)
return -1;
iov1 = BH_MALLOC((uint32)total_size);
if (iov1 == NULL)
return -1;
memset(iov1, 0, (uint32)total_size);
p = (char *)(uintptr_t)(sizeof(struct iovec) * 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);
p += iov[i].iov_len;
}
if (ocall_writev(&ret, fd, (char *)iov1, (uint32)total_size,
iovcnt, has_offset, offset) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
BH_FREE(iov1);
return -1;
}
BH_FREE(iov1);
if (ret == -1)
errno = get_errno();
return ret;
}
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)
{
return writev_internal(fd, iov, iovcnt, false, 0);
}
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)
{
return writev_internal(fd, iov, iovcnt, true, offset);
}
off_t lseek(int fd, off_t offset, int whence)
{
off_t ret;
if (ocall_lseek(&ret, fd, (long)offset, whence) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
int ftruncate(int fd, off_t length)
{
int ret;
if (ocall_ftruncate(&ret, fd, length) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
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) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
int fstatat(int dirfd, const char *pathname, struct stat *statbuf,
int flags)
{
int ret;
if (statbuf == NULL)
return -1;
if (ocall_fstatat(&ret, dirfd, pathname, (void *)statbuf,
sizeof(struct stat), flags) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
int fsync(int fd)
{
int ret;
if (ocall_fsync(&ret, fd) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
int fdatasync(int fd)
{
int ret;
if (ocall_fdatasync(&ret, fd) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
int mkdirat(int dirfd, const char *pathname, mode_t mode)
{
int ret;
if (ocall_mkdirat(&ret, dirfd, pathname, mode) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
int link(const char *oldpath, const char *newpath)
{
int ret;
if (ocall_link(&ret, oldpath, newpath) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
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) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
int unlinkat(int dirfd, const char *pathname, int flags)
{
int ret;
if (ocall_unlinkat(&ret, dirfd, pathname, flags) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
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) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
int symlinkat(const char *target, int newdirfd, const char *linkpath)
{
int ret;
if (ocall_symlinkat(&ret, target,
newdirfd, linkpath) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
int renameat(int olddirfd, const char *oldpath,
int newdirfd, const char *newpath)
{
int ret;
if (ocall_renameat(&ret, olddirfd, oldpath,
newdirfd, newpath) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
int ioctl(int fd, unsigned long request, ...)
{
int ret;
va_list args;
switch (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) {
TRACE_OCALL_FAIL();
va_end(args);
return -1;
}
va_end(args);
break;
default:
os_printf("ioctl failed: unknown request", request);
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
int fcntl(int fd, int cmd, ... /* arg */ )
{
int ret;
va_list args;
switch (cmd) {
case F_GETFD:
case F_GETFL:
if (ocall_fcntl(&ret, fd, cmd) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
break;
case F_DUPFD:
case F_SETFD:
case F_SETFL:
va_start(args, cmd);
long arg_1 = (long)va_arg(args, long);
if (ocall_fcntl_long(&ret, fd, cmd, arg_1) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
va_end(args);
return -1;
}
va_end(args);
break;
default:
os_printf("fcntl failed: unknown cmd %d.\n", cmd);
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
int isatty(int fd)
{
int ret;
if (ocall_isatty(&ret, fd) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == 0)
errno = get_errno();
return ret;
}
char *realpath(const char *path, char *resolved_path)
{
int ret;
char buf[PATH_MAX] = { 0 };
if (ocall_realpath(&ret, path, buf, PATH_MAX) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return (char *)NULL;
}
if (ret != 0)
return (char *)NULL;
if (resolved_path) {
strcpy(resolved_path, buf);
}
else {
resolved_path = BH_MALLOC(strlen(buf) + 1);
if (resolved_path == NULL)
return NULL;
strcpy(resolved_path, buf);
}
return resolved_path;
}
int posix_fallocate(int fd, off_t offset, off_t len)
{
int ret;
if (ocall_posix_fallocate(&ret, fd, offset, len) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
return ret;
}
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) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
int getopt(int argc, char * const argv[],
const char *optstring)
{
int ret;
char **argv1;
char *p;
int i;
uint64 total_size = sizeof(char *) * (uint64)argc;
for (i = 0; i < argc; i++) {
total_size += strlen(argv[i]) + 1;
}
if (total_size >= UINT32_MAX)
return -1;
argv1 = BH_MALLOC((uint32)total_size);
if (argv1 == NULL)
return -1;
p = (char *)(uintptr_t)(sizeof(char *) * argc);
for (i = 0; i < argc; i++) {
argv1[i] = p;
strcpy((char *)argv1 + (uintptr_t)p, argv[i]);
p += ((uintptr_t)strlen(argv[i]) + 1);
}
if (ocall_getopt(&ret, argc, (char *)argv1, total_size,
optstring) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
BH_FREE(argv1);
return -1;
}
BH_FREE(argv1);
if (ret == -1)
errno = get_errno();
return ret;
}
int sched_yield(void)
{
int ret;
if (ocall_sched_yield(&ret) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
ssize_t getrandom(void *buf, size_t buflen, unsigned int flags)
{
ssize_t ret;
if (ocall_getrandom(&ret, buf, buflen, flags) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
int get_errno(void)
{
int ret;
if (ocall_get_errno(&ret) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
return ret;
}

229
core/shared/platform/linux-sgx/sgx_file.h Normal file
View File

@ -0,0 +1,229 @@
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#ifndef _SGX_FILE_H
#define _SGX_FILE_H
#include "sgx_time.h"
#ifdef __cplusplus
extern "C" {
#endif
#define F_DUPFD 0
#define F_GETFD 1
#define F_SETFD 2
#define F_GETFL 3
#define F_SETFL 4
#define FD_CLOEXEC 1
#define O_PATH 010000000
#define O_SEARCH O_PATH
#define O_EXEC O_PATH
#define O_ACCMODE (03|O_SEARCH)
#define O_RDONLY 00
#define O_WRONLY 01
#define O_RDWR 02
#define O_CREAT 0100
#define O_EXCL 0200
#define O_NOCTTY 0400
#define O_TRUNC 01000
#define O_APPEND 02000
#define O_NONBLOCK 04000
#define O_DSYNC 010000
#define O_SYNC 04010000
#define O_RSYNC 04010000
#define O_DIRECTORY 0200000
#define O_NOFOLLOW 0400000
#define O_CLOEXEC 02000000
#define O_ASYNC 020000
#define O_DIRECT 040000
#define O_LARGEFILE 0
#define O_NOATIME 01000000
#define O_PATH 010000000
#define O_TMPFILE 020200000
#define O_NDELAY O_NONBLOCK
#define S_IFMT 0170000
#define S_IFDIR 0040000
#define S_IFCHR 0020000
#define S_IFBLK 0060000
#define S_IFREG 0100000
#define S_IFIFO 0010000
#define S_IFLNK 0120000
#define S_IFSOCK 0140000
#define SEEK_SET 0
#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 DT_UNKNOWN 0
#define DT_FIFO 1
#define DT_CHR 2
#define DT_DIR 4
#define DT_BLK 6
#define DT_REG 8
#define DT_LNK 10
#define DT_SOCK 12
#define DT_WHT 14
#define AT_SYMLINK_NOFOLLOW 0x100
#define AT_REMOVEDIR 0x200
#define AT_SYMLINK_FOLLOW 0x400
#define POLLIN 0x001
#define POLLPRI 0x002
#define POLLOUT 0x004
#define POLLERR 0x008
#define POLLHUP 0x010
#define POLLNVAL 0x020
#define POLLRDNORM 0x040
#define POLLRDBAND 0x080
#define POLLWRNORM 0x100
#define POLLWRBAND 0x200
#define FIONREAD 0x541B
#define PATH_MAX 4096
/* Special value used to indicate openat should use the current
working directory. */
#define AT_FDCWD -100
typedef long __syscall_slong_t;
typedef unsigned long dev_t;
typedef unsigned long ino_t;
typedef unsigned mode_t;
typedef unsigned long nlink_t;
typedef unsigned socklen_t;
typedef long blksize_t;
typedef long blkcnt_t;
typedef int pid_t;
typedef unsigned gid_t;
typedef unsigned uid_t;
typedef unsigned long nfds_t;
typedef uintptr_t DIR;
struct dirent {
ino_t d_ino;
off_t d_off;
unsigned short d_reclen;
unsigned char d_type;
char d_name[256];
};
struct stat {
dev_t st_dev;
ino_t st_ino;
nlink_t st_nlink;
mode_t st_mode;
uid_t st_uid;
gid_t st_gid;
unsigned int __pad0;
dev_t st_rdev;
off_t st_size;
blksize_t st_blksize;
blkcnt_t st_blocks;
struct timespec st_atim;
struct timespec st_mtim;
struct timespec st_ctim;
long __unused[3];
};
struct iovec {
void *iov_base;
size_t iov_len;
};
struct pollfd {
int fd;
short events;
short revents;
};
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);
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);
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 ioctl(int fd, unsigned long request, ...);
int fcntl(int fd, int cmd, ... /* arg */ );
int isatty(int fd);
char *realpath(const char *path, char *resolved_path);
int posix_fallocate(int fd, off_t offset, off_t len);
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
int getopt(int argc, char * const argv[],
const char *optstring);
int sched_yield(void);
ssize_t getrandom(void *buf, size_t buflen, unsigned int flags);
int get_errno(void);
#ifdef __cplusplus
}
#endif
#endif /* end of _SGX_FILE_H */

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

@ -5,10 +5,7 @@
#include "platform_api_vmcore.h"
#include "platform_api_extension.h"
#if WASM_ENABLE_AOT != 0
#include "sgx_rsrv_mem_mngr.h"
#endif
#define FIXED_BUFFER_SIZE (1<<9)
@ -82,9 +79,17 @@ int os_vprintf(const char * format, va_list arg)
return 0;
}
char *strcpy(char *dest, const char *src)
{
const unsigned char *s = src;
unsigned char *d = dest;
while ((*d++ = *s++));
return dest;
}
void* os_mmap(void *hint, size_t size, int prot, int flags)
{
#if WASM_ENABLE_AOT != 0
int mprot = 0;
uint64 aligned_size, page_size;
void* ret = NULL;
@ -119,25 +124,19 @@ void* os_mmap(void *hint, size_t size, int prot, int flags)
}
return ret;
#else
return NULL;
#endif
}
void os_munmap(void *addr, size_t size)
{
#if WASM_ENABLE_AOT != 0
uint64 aligned_size, page_size;
page_size = getpagesize();
aligned_size = (size + page_size - 1) & ~(page_size - 1);
sgx_free_rsrv_mem(addr, aligned_size);
#endif
}
int os_mprotect(void *addr, size_t size, int prot)
{
#if WASM_ENABLE_AOT != 0
int mprot = 0;
sgx_status_t st = 0;
uint64 aligned_size, page_size;
@ -157,9 +156,6 @@ int os_mprotect(void *addr, size_t size, int prot)
addr, size, prot);
return (st == SGX_SUCCESS? 0:-1);
#else
return -1;
#endif
}
void

75
core/shared/platform/linux-sgx/sgx_pthread.c Normal file
View File

@ -0,0 +1,75 @@
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#include "platform_api_vmcore.h"
#include "sgx_pthread.h"
#include "sgx_error.h"
#define TRACE_FUNC() os_printf("undefined %s\n", __FUNCTION__)
#define TRACE_OCALL_FAIL() os_printf("ocall %s failed!\n", __FUNCTION__)
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_rdlock(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 pthread_rwlock_init(pthread_rwlock_t *rwlock, void *attr)
{
int ret = -1;
if (ocall_pthread_rwlock_init(&ret, (void **)rwlock, NULL)
!= SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
(void)attr;
return ret;
}
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock)
{
int ret = -1;
if (ocall_pthread_rwlock_destroy(&ret, (void *)*rwlock) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
}
return ret;
}
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock)
{
int ret = -1;
if (ocall_pthread_rwlock_rdlock(&ret, (void*)*rwlock) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
}
return ret;
}
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock)
{
int ret = -1;
if (ocall_pthread_rwlock_wrlock(&ret, (void*)*rwlock) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
}
return ret;
}
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock)
{
int ret = -1;
if (ocall_pthread_rwlock_unlock(&ret, (void*)*rwlock) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
}
return ret;
}

27
core/shared/platform/linux-sgx/sgx_pthread.h Normal file
View File

@ -0,0 +1,27 @@
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#ifndef _SGX_PTHREAD_H
#define _SGX_PTHREAD_H
#ifdef __cplusplus
extern "C" {
#endif
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_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
#ifdef __cplusplus
}
#endif
#endif /* end of _SGX_PTHREAD_H */

26
core/shared/platform/linux-sgx/sgx_signal.c Normal file
View File

@ -0,0 +1,26 @@
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#include "platform_api_vmcore.h"
#define TRACE_OCALL_FAIL() os_printf("ocall %s failed!\n", __FUNCTION__)
int ocall_raise(int *p_ret, int sig);
int raise(int sig)
{
int ret;
if (ocall_raise(&ret, sig) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}

57
core/shared/platform/linux-sgx/sgx_signal.h Normal file
View File

@ -0,0 +1,57 @@
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#ifndef _SGX_SIGNAL_H
#define _SGX_SIGNAL_H
#ifdef __cplusplus
extern "C" {
#endif
/* Signals. */
#define SIGHUP 1 /* Hangup (POSIX). */
#define SIGINT 2 /* Interrupt (ANSI). */
#define SIGQUIT 3 /* Quit (POSIX). */
#define SIGILL 4 /* Illegal instruction (ANSI). */
#define SIGTRAP 5 /* Trace trap (POSIX). */
#define SIGABRT 6 /* Abort (ANSI). */
#define SIGIOT 6 /* IOT trap (4.2 BSD). */
#define SIGBUS 7 /* BUS error (4.2 BSD). */
#define SIGFPE 8 /* Floating-point exception (ANSI). */
#define SIGKILL 9 /* Kill, unblockable (POSIX). */
#define SIGUSR1 10 /* User-defined signal 1 (POSIX). */
#define SIGSEGV 11 /* Segmentation violation (ANSI). */
#define SIGUSR2 12 /* User-defined signal 2 (POSIX). */
#define SIGPIPE 13 /* Broken pipe (POSIX). */
#define SIGALRM 14 /* Alarm clock (POSIX). */
#define SIGTERM 15 /* Termination (ANSI). */
#define SIGSTKFLT 16 /* Stack fault. */
#define SIGCLD SIGCHLD /* Same as SIGCHLD (System V). */
#define SIGCHLD 17 /* Child status has changed (POSIX). */
#define SIGCONT 18 /* Continue (POSIX). */
#define SIGSTOP 19 /* Stop, unblockable (POSIX). */
#define SIGTSTP 20 /* Keyboard stop (POSIX). */
#define SIGTTIN 21 /* Background read from tty (POSIX). */
#define SIGTTOU 22 /* Background write to tty (POSIX). */
#define SIGURG 23 /* Urgent condition on socket (4.2 BSD). */
#define SIGXCPU 24 /* CPU limit exceeded (4.2 BSD). */
#define SIGXFSZ 25 /* File size limit exceeded (4.2 BSD). */
#define SIGVTALRM 26 /* Virtual alarm clock (4.2 BSD). */
#define SIGPROF 27 /* Profiling alarm clock (4.2 BSD). */
#define SIGWINCH 28 /* Window size change (4.3 BSD, Sun). */
#define SIGPOLL SIGIO /* Pollable event occurred (System V). */
#define SIGIO 29 /* I/O now possible (4.2 BSD). */
#define SIGPWR 30 /* Power failure restart (System V). */
#define SIGSYS 31 /* Bad system call. */
#define SIGUNUSED 31
int raise(int sig);
#ifdef __cplusplus
}
#endif
#endif /* end of _SGX_SIGNAL_H */

218
core/shared/platform/linux-sgx/sgx_socket.c Normal file
View File

@ -0,0 +1,218 @@
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#include "platform_api_vmcore.h"
#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_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,
unsigned int msg_buf_size, int flags);
int ocall_shutdown(int *p_ret, int sockfd, int how);
int socket(int domain, int type, int protocol)
{
int ret;
if (ocall_socket(&ret, domain, type, protocol) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
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) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags)
{
ssize_t ret;
int i;
char *p;
struct msghdr *msg1;
uint64 total_size = sizeof(struct msghdr) + (uint64)msg->msg_namelen
+ (uint64)msg->msg_controllen;
total_size += sizeof(struct iovec) * (msg->msg_iovlen);
for (i = 0; i < msg->msg_iovlen; i++) {
total_size += msg->msg_iov[i].iov_len;
}
if (total_size >= UINT32_MAX)
return -1;
msg1 = BH_MALLOC((uint32)total_size);
if (msg1 == NULL)
return -1;
p = (char*)(uintptr_t)sizeof(struct msghdr);
if (msg->msg_name != NULL) {
msg1->msg_name = p;
memcpy((uintptr_t)p + (char *)msg1, msg->msg_name,
(size_t)msg->msg_namelen);
p += msg->msg_namelen;
}
if (msg->msg_control != NULL) {
msg1->msg_control = p;
memcpy((uintptr_t)p + (char *)msg1, msg->msg_control,
(size_t)msg->msg_control);
p += msg->msg_controllen;
}
if (msg->msg_iov != NULL) {
msg1->msg_iov = (struct iovec *)p;
p += (uintptr_t)(sizeof(struct iovec) * (msg->msg_iovlen));
for (i = 0; i < msg->msg_iovlen; i++) {
msg1->msg_iov[i].iov_base = p;
msg1->msg_iov[i].iov_len = msg->msg_iov[i].iov_len;
memcpy((uintptr_t)p + (char *)msg1, msg->msg_iov[i].iov_base,
(size_t)(msg->msg_iov[i].iov_len));
p += msg->msg_iov[i].iov_len;
}
}
if (ocall_sendmsg(&ret, sockfd, (void *)msg1, (uint32)total_size,
flags) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags)
{
ssize_t ret;
int i;
char *p;
struct msghdr *msg1;
uint64 total_size = sizeof(struct msghdr) + (uint64)msg->msg_namelen
+ (uint64)msg->msg_controllen;
total_size += sizeof(struct iovec) * (msg->msg_iovlen);
for (i = 0; i < msg->msg_iovlen; i++) {
total_size += msg->msg_iov[i].iov_len;
}
if (total_size >= UINT32_MAX)
return -1;
msg1 = BH_MALLOC((uint32)total_size);
if (msg1 == NULL)
return -1;
memset(msg1, 0, total_size);
p = (char*)(uintptr_t)sizeof(struct msghdr);
if (msg->msg_name != NULL) {
msg1->msg_name = p;
p += msg->msg_namelen;
}
if (msg->msg_control != NULL) {
msg1->msg_control = p;
p += msg->msg_controllen;
}
if (msg->msg_iov != NULL) {
msg1->msg_iov = (struct iovec *)p;
p += (uintptr_t)(sizeof(struct iovec) * (msg->msg_iovlen));
for (i = 0; i < msg->msg_iovlen; i++) {
msg1->msg_iov[i].iov_base = p;
msg1->msg_iov[i].iov_len = msg->msg_iov[i].iov_len;
p += msg->msg_iov[i].iov_len;
}
}
if (ocall_recvmsg(&ret, sockfd, (void *)msg1, (uint32)total_size,
flags) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
p = (char *)(uintptr_t)(sizeof(struct msghdr));
if (msg1->msg_name != NULL) {
memcpy(msg->msg_name, (uintptr_t)p + (char *)msg1,
(size_t)msg1->msg_namelen);
p += msg1->msg_namelen;
}
if (msg1->msg_control != NULL) {
memcpy(msg->msg_control, (uintptr_t)p + (char *)msg1,
(size_t)msg1->msg_control);
p += msg->msg_controllen;
}
if (msg1->msg_iov != NULL) {
p += (uintptr_t)(sizeof(struct iovec) * (msg1->msg_iovlen));
for (i = 0; i < msg1->msg_iovlen; i++) {
memcpy(msg->msg_iov[i].iov_base, (uintptr_t)p + (char *)msg1,
(size_t)(msg1->msg_iov[i].iov_len));
p += msg1->msg_iov[i].iov_len;
}
}
if (ret == -1)
errno = get_errno();
return ret;
}
int shutdown(int sockfd, int how)
{
int ret;
if (ocall_shutdown(&ret, sockfd, how) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}

74
core/shared/platform/linux-sgx/sgx_socket.h Normal file
View File

@ -0,0 +1,74 @@
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#ifndef _SGX_SOCKET_H
#define _SGX_SOCKET_H
#include "sgx_file.h"
#ifdef __cplusplus
extern "C" {
#endif
#define SOL_SOCKET 1
#define SOCK_STREAM 1
#define SOCK_DGRAM 2
#define SO_TYPE 3
#define MSG_OOB 0x0001
#define MSG_PEEK 0x0002
#define MSG_DONTROUTE 0x0004
#define MSG_CTRUNC 0x0008
#define MSG_PROXY 0x0010
#define MSG_TRUNC 0x0020
#define MSG_DONTWAIT 0x0040
#define MSG_EOR 0x0080
#define MSG_WAITALL 0x0100
#define MSG_FIN 0x0200
#define MSG_SYN 0x0400
#define MSG_CONFIRM 0x0800
#define MSG_RST 0x1000
#define MSG_ERRQUEUE 0x2000
#define MSG_NOSIGNAL 0x4000
#define MSG_MORE 0x8000
#define MSG_WAITFORONE 0x10000
#define MSG_BATCH 0x40000
#define MSG_FASTOPEN 0x20000000
#define MSG_CMSG_CLOEXEC 0x40000000
#define SHUT_RD 0
#define SHUT_WR 1
#define SHUT_RDWR 2
struct msghdr {
void *msg_name;
socklen_t msg_namelen;
struct iovec *msg_iov;
int msg_iovlen;
void *msg_control;
socklen_t msg_controllen;
int msg_flags;
};
int socket(int domain, int type, int protocol);
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 recvmsg(int sockfd, struct msghdr *msg, int flags);
int shutdown(int sockfd, int how);
#ifdef __cplusplus
}
#endif
#endif /* end of _SGX_SOCKET_H */

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

@ -6,47 +6,138 @@
#include "platform_api_vmcore.h"
#include "platform_api_extension.h"
typedef struct {
thread_start_routine_t start;
void *arg;
} thread_wrapper_arg;
static void *os_thread_wrapper(void *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);
BH_FREE(targ);
start_func(thread_arg);
return NULL;
}
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;
assert(tid);
assert(start);
targ = (thread_wrapper_arg *) BH_MALLOC(sizeof(*targ));
if (!targ) {
return BHT_ERROR;
}
targ->start = start;
targ->arg = arg;
if (pthread_create(tid, NULL, os_thread_wrapper, targ) != 0) {
BH_FREE(targ);
return BHT_ERROR;
}
return BHT_OK;
}
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()
{
return sgx_thread_self();
return pthread_self();
}
int os_mutex_init(korp_mutex *mutex)
{
sgx_thread_mutex_t m = SGX_THREAD_MUTEX_INITIALIZER;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
*mutex = m;
return BHT_OK;
}
int os_mutex_destroy(korp_mutex *mutex)
{
sgx_thread_mutex_destroy(mutex);
pthread_mutex_destroy(mutex);
return BHT_OK;
}
int os_mutex_lock(korp_mutex *mutex)
{
return sgx_thread_mutex_lock(mutex);
return pthread_mutex_lock(mutex);
}
int os_mutex_unlock(korp_mutex *mutex)
{
return sgx_thread_mutex_unlock(mutex);
return pthread_mutex_unlock(mutex);
}
int os_cond_init(korp_cond *cond)
{
sgx_thread_cond_t c = SGX_THREAD_COND_INITIALIZER;
pthread_cond_t c = PTHREAD_COND_INITIALIZER;
*cond = c;
return BHT_OK;
}
int os_cond_destroy(korp_cond *cond)
{
sgx_thread_cond_destroy(cond);
pthread_cond_destroy(cond);
return BHT_OK;
}
int os_cond_wait(korp_cond *cond, korp_mutex *mutex)
{
assert(cond);
assert(mutex);
if (pthread_cond_wait(cond, mutex) != BHT_OK)
return BHT_ERROR;
return BHT_OK;
}
int os_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, int 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)
{
assert(cond);
if (pthread_cond_signal(cond) != BHT_OK)
return BHT_ERROR;
return BHT_OK;
}
int os_thread_join(korp_tid thread, void **value_ptr)
{
return pthread_join(thread, value_ptr);
}
int os_thread_detach(korp_tid thread)
{
/* SGX pthread_detach isn't provided, return directly. */
return 0;
}
void os_thread_exit(void *retval)
{
return pthread_exit(retval);
}
uint8 *os_thread_get_stack_boundary()
{
/* TODO: get sgx stack boundary */

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

@ -5,6 +5,22 @@
#include "platform_api_vmcore.h"
#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,
const void *req_buf, unsigned int req_buf_size,
const void *rem_buf, unsigned int rem_buf_size);
uint64
os_time_get_boot_microsecond()
{
@ -12,3 +28,88 @@ os_time_get_boot_microsecond()
return 0;
}
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) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
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) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
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) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
int futimens(int fd, const struct timespec times[2])
{
int ret;
if (ocall_futimens(&ret, fd, (void *)times,
sizeof(struct timespec) * 2) != SGX_SUCCESS) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}
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) {
TRACE_OCALL_FAIL();
return -1;
}
if (ret == -1)
errno = get_errno();
return ret;
}

47
core/shared/platform/linux-sgx/sgx_time.h Normal file
View File

@ -0,0 +1,47 @@
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#ifndef _SGX_TIME_H
#define _SGX_TIME_H
#ifdef __cplusplus
extern "C" {
#endif
#define CLOCK_REALTIME 0
#define CLOCK_MONOTONIC 1
#define CLOCK_PROCESS_CPUTIME_ID 2
#define CLOCK_THREAD_CPUTIME_ID 3
#define UTIME_NOW 0x3fffffff
#define UTIME_OMIT 0x3ffffffe
#define TIMER_ABSTIME 1
typedef long int time_t;
typedef int clockid_t;
struct timespec {
time_t tv_sec;
long tv_nsec;
};
int clock_getres(int clock_id, struct timespec *res);
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,
struct timespec *remain);
#ifdef __cplusplus
}
#endif
#endif /* end of _SGX_TIME_H */

132
core/shared/platform/linux-sgx/sgx_wamr.edl Normal file
View File

@ -0,0 +1,132 @@
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
enclave {
include "stdint.h"
include "stdbool.h"
include "unistd.h"
untrusted {
int ocall_open([in, string]const char *pathname, int flags,
bool has_mode, unsigned mode);
int ocall_openat(int dirfd,
[in, string]const char *pathname, int flags,
bool has_mode, unsigned mode);
int ocall_close(int fd);
ssize_t ocall_read(int fd, [out, size=read_size]void *buf,
size_t read_size);
off_t ocall_lseek(int fd, off_t offset, int whence);
int ocall_ftruncate(int fd, off_t length);
int ocall_fsync(int fd);
int ocall_fdatasync(int fd);
int ocall_isatty(int fd);
void ocall_fdopendir(int fd, [out]void **p_dirp);
/* implementation related to multiple thread */
void *ocall_readdir([user_check]void *dirp);
void ocall_rewinddir([user_check]void *dirp);
void ocall_seekdir([user_check]void *dirp, long loc);
long ocall_telldir([user_check]void *dirp);
int ocall_closedir([user_check]void *dirp);
int ocall_fstat(int fd, [out, size=buf_len]void *buf,
unsigned int buf_len);
int ocall_fstatat(int dirfd, [in, string]const char *pathname,
[out, size=buf_len]void *buf,
unsigned int buf_len, int flags);
int ocall_mkdirat(int dirfd, [in, string]const char *pathname,
unsigned mode);
int ocall_link([in, string] const char *oldpath,
[in, string] const char *newpath);
int ocall_linkat(int olddirfd, [in, string]const char *oldpath,
int newdirfd, [in, string]const char *newpath,
int flags);
int ocall_unlinkat(int dirfd, [in, string]const char *pathname,
int flags);
ssize_t ocall_readlinkat(int dirfd,
[in, string]const char *pathname,
[out, size=bufsiz]char *buf,
size_t bufsiz);
int ocall_renameat(int olddirfd,
[in, string]const char *oldpath,
int newdirfd,
[in, string]const char *newpath);
int ocall_symlinkat([in ,string]const char *target,
int newdirfd,
[in, string]const char *linkpath);
int ocall_ioctl(int fd, unsigned long request,
[out, size=arg_len]void *arg,
unsigned int arg_len);
int ocall_fcntl(int fd, int cmd);
int ocall_fcntl_long(int fd, int cmd, long arg);
int ocall_realpath([in, string]const char *path,
[out, size=buf_len]char *buf,
unsigned int buf_len);
int ocall_posix_fallocate(int fd, off_t offset, off_t len);
int ocall_poll([out, size=fds_len]void *fds, unsigned nfds,
int timeout, unsigned int fds_len);
int ocall_getopt(int argc,
[in, size=argv_buf_len]char *argv_buf,
unsigned int argv_buf_len,
[in, string]const char *optstring);
ssize_t ocall_getrandom([out, size=buflen]void *buf, size_t buflen,
unsigned int flags);
ssize_t ocall_readv(int fd,
[in, out, size=buf_size]char *iov_buf,
unsigned int buf_size, int iovcnt,
bool has_offset, off_t offset);
ssize_t ocall_writev(int fd,
[in, size=buf_size]char *iov_buf,
unsigned int buf_size, int iovcnt,
bool has_offset, off_t offset);
/* time clock */
int ocall_clock_gettime(unsigned clock_id,
[out, size=tp_buf_size]void *tp_buf,
unsigned int tp_buf_size);
int ocall_clock_getres(int clock_id,
[out, size=res_buf_size]void *res_buf,
unsigned int res_buf_size);
int ocall_utimensat(int dirfd, [in, string]const char *pathname,
[in, size=times_buf_size]const void *times_buf,
unsigned int times_buf_size, int flags);
int ocall_futimens(int fd, [in, size=times_buf_size]const void *times_buf,
unsigned int times_buf_size);
int ocall_clock_nanosleep(unsigned clock_id, int flags,
[in, size=req_buf_size]const void *req_buf,
unsigned int req_buf_size,
[out, size=rem_buf_size]void *rem_buf,
unsigned int rem_buf_size);
int ocall_raise(int sig);
int ocall_sched_yield();
int ocall_pthread_rwlock_init([out]void **rwlock, [user_check]void *attr);
int ocall_pthread_rwlock_destroy([user_check]void *rwlock);
int ocall_pthread_rwlock_rdlock([user_check]void *rwlock);
int ocall_pthread_rwlock_wrlock([user_check]void *rwlock);
int ocall_pthread_rwlock_unlock([user_check]void *rwlock);
int ocall_get_errno();
int ocall_socket(int domain, int type, int protocol);
int ocall_getsockopt(int sockfd, int level, int optname,
[out, size=val_buf_size]void *val_buf,
unsigned int val_buf_size,
[in, out, size=4]void *len_buf);
ssize_t ocall_sendmsg(int sockfd,
[in, size=msg_buf_size]void *msg_buf,
unsigned int msg_buf_size,
int flags);
ssize_t ocall_recvmsg(int sockfd,
[in, out, size=msg_buf_size]void *msg_buf,
unsigned int msg_buf_size,
int flags);
int ocall_shutdown(int sockfd, int how);
};
};

6
core/shared/platform/linux-sgx/shared_platform.cmake
View File

@ -20,7 +20,11 @@ if (NOT BUILD_UNTRUST_PART EQUAL 1)
${SGX_SDK_DIR}/include/libcxx)
endif ()
file (GLOB_RECURSE source_all ${PLATFORM_SHARED_DIR}/*.c)
file (GLOB source_all ${PLATFORM_SHARED_DIR}/*.c)
file (GLOB source_all_untrusted ${PLATFORM_SHARED_DIR}/untrusted/*.c)
set (PLATFORM_SHARED_SOURCE ${source_all})
set (PLATFORM_SHARED_SOURCE_UNTRUSTED ${source_all_untrusted})

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

@ -0,0 +1,288 @@
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/random.h>
#include <sys/uio.h>
#include <fcntl.h>
#include <unistd.h>
#include <dirent.h>
#include <sched.h>
#include <poll.h>
#include <errno.h>
int ocall_open(const char *pathname, int flags,
bool has_mode, unsigned mode)
{
if (has_mode) {
return open(pathname, flags, (mode_t)mode);
}
else {
return open(pathname, flags);
}
}
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);
}
else {
return openat(dirfd, pathname, flags);
}
}
int ocall_close(int fd)
{
return close(fd);
}
ssize_t ocall_read(int fd, void *buf, size_t read_size)
{
if (buf != NULL) {
return read(fd, buf, read_size);
}
else {
return -1;
}
}
off_t ocall_lseek(int fd, off_t offset, int whence)
{
return lseek(fd, offset, whence);
}
int ocall_ftruncate(int fd, off_t length)
{
return ftruncate(fd, length);
}
int ocall_fsync(int fd)
{
return fsync(fd);
}
int ocall_fdatasync(int fd)
{
return fdatasync(fd);
}
int ocall_isatty(int fd)
{
return isatty(fd);
}
void ocall_fdopendir(int fd, void **dirp)
{
if (dirp) {
*(DIR **)dirp = fdopendir(fd);
}
}
void *ocall_readdir(void *dirp)
{
DIR *p_dirp = (DIR *)dirp;
return readdir(p_dirp);
}
void ocall_rewinddir(void *dirp)
{
DIR *p_dirp = (DIR *)dirp;
if (p_dirp) {
rewinddir(p_dirp);
}
}
void ocall_seekdir(void *dirp, long loc)
{
DIR *p_dirp = (DIR *)dirp;
if (p_dirp) {
seekdir(p_dirp, loc);
}
}
long ocall_telldir(void *dirp)
{
DIR *p_dirp = (DIR *)dirp;
if (p_dirp) {
return telldir(p_dirp);
}
return -1;
}
int ocall_closedir(void* dirp)
{
DIR *p_dirp = (DIR *)dirp;
if (p_dirp) {
return closedir(p_dirp);
}
return -1;
}
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)
{
return fstatat(dirfd, pathname, (struct stat *)buf, flags);
}
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)
{
return link(oldpath, newpath);
}
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)
{
return unlinkat(dirfd, pathname, flags);
}
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)
{
return renameat(olddirfd, oldpath, newdirfd, newpath);
}
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)
{
/* support just int *arg temporally */
return ioctl(fd, request, (int *)arg);
}
int ocall_fcntl(int fd, int cmd)
{
return fcntl(fd, cmd);
}
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,
bool has_offset, off_t offset)
{
struct iovec *iov = (struct iovec *)iov_buf;
ssize_t ret;
int i;
for (i = 0; i < iovcnt; i++) {
iov[i].iov_base = iov_buf + (unsigned)(uintptr_t)iov[i].iov_base;
}
if (has_offset)
ret = preadv(fd, iov, iovcnt, offset);
else
ret = readv(fd, iov, iovcnt);
return ret;
}
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;
int i;
ssize_t ret;
for (i = 0; i < iovcnt; i++) {
iov[i].iov_base = iov_buf + (unsigned)(uintptr_t)iov[i].iov_base;
}
if (has_offset)
ret = pwritev(fd, iov, iovcnt, offset);
else
ret = writev(fd, iov, iovcnt);
return ret;
}
int ocall_realpath(const char *path, char *buf, unsigned int buf_len)
{
char* val = NULL;
val = realpath(path, buf);
if (val != NULL) {
return 0;
}
return -1;
}
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)
{
return poll((struct pollfd *)fds, (nfds_t)nfds, timeout);
}
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++) {
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)
{
return getrandom(buf, buflen, flags);
}
int ocall_sched_yield()
{
return sched_yield();
}
int ocall_get_errno()
{
return errno;
}

50
core/shared/platform/linux-sgx/untrusted/pthread.c Normal file
View File

@ -0,0 +1,50 @@
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#include <stdlib.h>
#include <pthread.h>
int ocall_pthread_rwlock_init(void **rwlock, void *attr)
{
int ret = 0;
*rwlock = malloc(sizeof(pthread_rwlock_t));
if (*rwlock == NULL)
return -1;
ret = pthread_rwlock_init((pthread_rwlock_t *)*rwlock, NULL);
if (ret != 0) {
free(*rwlock);
*rwlock = NULL;
}
(void)attr;
return ret;
}
int ocall_pthread_rwlock_destroy(void *rwlock)
{
pthread_rwlock_t *lock = (pthread_rwlock_t *)rwlock;
int ret;
ret = pthread_rwlock_destroy(lock);
free(lock);
return ret;
}
int ocall_pthread_rwlock_rdlock(void *rwlock)
{
return pthread_rwlock_rdlock((pthread_rwlock_t *)rwlock);
}
int ocall_pthread_rwlock_wrlock(void *rwlock)
{
return pthread_rwlock_wrlock((pthread_rwlock_t *)rwlock);
}
int ocall_pthread_rwlock_unlock(void *rwlock)
{
return pthread_rwlock_unlock((pthread_rwlock_t *)rwlock);
}

10
core/shared/platform/linux-sgx/untrusted/signal.c Normal file
View File

@ -0,0 +1,10 @@
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#include <signal.h>
int ocall_raise(int sig)
{
return raise(sig);
}

73
core/shared/platform/linux-sgx/untrusted/socket.c Normal file
View File

@ -0,0 +1,73 @@
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#include <sys/types.h>
#include <sys/socket.h>
#include <stdint.h>
#include <stddef.h>
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,
unsigned int val_buf_size, void *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)
{
struct msghdr *msg = (struct msghdr *)msg_buf;
int i;
ssize_t ret;
if (msg->msg_name != NULL)
msg->msg_name = msg_buf + (unsigned)(uintptr_t)msg->msg_name;
if (msg->msg_control != NULL)
msg->msg_control = msg_buf + (unsigned)(uintptr_t)msg->msg_control;
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;
}
}
return sendmsg(sockfd, msg, 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;
ssize_t ret;
if (msg->msg_name != NULL)
msg->msg_name = msg_buf + (unsigned)(uintptr_t)msg->msg_name;
if (msg->msg_control != NULL)
msg->msg_control = msg_buf + (unsigned)(uintptr_t)msg->msg_control;
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;
}
}
return recvmsg(sockfd, msg, flags);
}
int ocall_shutdown(int sockfd, int how)
{
return shutdown(sockfd, how);
}

47
core/shared/platform/linux-sgx/untrusted/time.c Normal file
View File

@ -0,0 +1,47 @@
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#include <stdbool.h>
#include <sys/stat.h>
#include <time.h>
#include <fcntl.h>
/** time clock **/
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);
}
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,
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)
{
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)
{
return clock_nanosleep((clockid_t)clock_id, flags,
(struct timespec *)req_buf,
(struct timespec *)rem_buf);
}

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

@ -10,8 +10,6 @@
#include <stdbool.h>
#include <assert.h>
#include <time.h>
#include <sys/time.h>
#include <sys/timeb.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
@ -19,15 +17,25 @@
#include <stdarg.h>
#include <ctype.h>
#include <pthread.h>
#include <signal.h>
#include <semaphore.h>
#include <limits.h>
#include <dirent.h>
#include <fcntl.h>
#include <unistd.h>
#include <poll.h>
#include <sched.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <netinet/in.h>
#include <sys/time.h>
#include <sys/timeb.h>
#include <sys/uio.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/resource.h>
#ifdef __cplusplus
extern "C" {
@ -56,7 +64,6 @@ typedef pthread_t korp_thread;
|| defined(BUILD_TARGET_AMD_64) \
|| defined(BUILD_TARGET_AARCH64)
#include <signal.h>
#include <setjmp.h>
#define OS_ENABLE_HW_BOUND_CHECK

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

@ -10,8 +10,6 @@
#include <stdbool.h>
#include <assert.h>
#include <time.h>
#include <sys/time.h>
#include <sys/timeb.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
@ -19,14 +17,24 @@
#include <stdarg.h>
#include <ctype.h>
#include <pthread.h>
#include <signal.h>
#include <semaphore.h>
#include <limits.h>
#include <dirent.h>
#include <fcntl.h>
#include <unistd.h>
#include <poll.h>
#include <sched.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/time.h>
#include <sys/timeb.h>
#include <sys/uio.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/resource.h>
#ifdef __cplusplus
extern "C" {
@ -55,7 +63,6 @@ typedef pthread_t korp_thread;
|| defined(BUILD_TARGET_AMD_64) \
|| defined(BUILD_TARGET_AARCH64)
#include <signal.h>
#include <setjmp.h>
#define OS_ENABLE_HW_BOUND_CHECK

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

@ -41,7 +41,7 @@ bh_log(LogLevel log_level, const char *file, int line, const char *fmt, ...)
snprintf(buf, sizeof(buf), "%02u:%02u:%02u:%03u", h, m, s, mills);
os_printf("[%s - %X]: ", buf, (uint32)self);
os_printf("[%s - %X]: ", buf, (uint32)(uintptr_t)self);
if (file)
os_printf("%s, line %d, ", file, line);