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

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