Adding upstream version 1.44.3.upstream/1.44.3

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

5 files changed, 578 insertions, 0 deletions

diff --git a/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/shared/platform/linux-sgx/untrusted/file.c b/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/shared/platform/linux-sgx/untrusted/file.c
new file mode 100644
index 000000000..cb9bf6a21
--- /dev/null
+++ b/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/shared/platform/linux-sgx/untrusted/file.c
@@ -0,0 +1,321 @@
+/*
+ * 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/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_stat(const char *pathname, void *buf, unsigned int buf_len)
+{
+    return stat(pathname, (struct stat *)buf);
+}
+
+int
+ocall_fstat(int fd, void *buf, unsigned int buf_len)
+{
+    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_readlink(const char *pathname, char *buf, size_t bufsiz)
+{
+    return readlink(pathname, buf, bufsiz);
+}
+
+ssize_t
+ocall_readlinkat(int dirfd, const char *pathname, char *buf, size_t bufsiz)
+{
+    return readlinkat(dirfd, pathname, buf, bufsiz);
+}
+
+int
+ocall_renameat(int olddirfd, const char *oldpath, int newdirfd,
+               const char *newpath)
+{
+    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);
+}
+
+int
+ocall_sched_yield()
+{
+    return sched_yield();
+}
+
+int
+ocall_get_errno()
+{
+    return errno;
+}
diff --git a/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/shared/platform/linux-sgx/untrusted/pthread.c b/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/shared/platform/linux-sgx/untrusted/pthread.c
new file mode 100644
index 000000000..890ef754c
--- /dev/null
+++ b/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/shared/platform/linux-sgx/untrusted/pthread.c
@@ -0,0 +1,54 @@
+/*
+ * 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);
+}
diff --git a/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/shared/platform/linux-sgx/untrusted/signal.c b/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/shared/platform/linux-sgx/untrusted/signal.c
new file mode 100644
index 000000000..b2eecfb7a
--- /dev/null
+++ b/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/shared/platform/linux-sgx/untrusted/signal.c
@@ -0,0 +1,11 @@
+/*
+ * 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);
+}
\ No newline at end of file
diff --git a/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/shared/platform/linux-sgx/untrusted/socket.c b/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/shared/platform/linux-sgx/untrusted/socket.c
new file mode 100644
index 000000000..6f598ab8f
--- /dev/null
+++ b/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/shared/platform/linux-sgx/untrusted/socket.c
@@ -0,0 +1,148 @@
+/*
+ * 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>
+#include <netinet/in.h>
+#include <arpa/inet.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);
+}
+
+int
+ocall_setsockopt(int sockfd, int level, int optname, void *optval,
+                 unsigned int optlen)
+{
+    return setsockopt(sockfd, level, optname, optval, optlen);
+}
+
+int
+ocall_bind(int sockfd, const void *addr, uint32_t addrlen)
+{
+    return bind(sockfd, (const struct sockaddr *)addr, addrlen);
+}
+
+int
+ocall_getsockname(int sockfd, void *addr, uint32_t *addrlen, uint32_t addr_size)
+{
+    return getsockname(sockfd, (struct sockaddr *)addr, addrlen);
+}
+
+int
+ocall_getpeername(int sockfd, void *addr, uint32_t *addrlen, uint32_t addr_size)
+{
+    return getpeername(sockfd, (struct sockaddr *)addr, addrlen);
+}
+
+int
+ocall_listen(int sockfd, int backlog)
+{
+    return listen(sockfd, backlog);
+}
+
+int
+ocall_accept(int sockfd, void *addr, uint32_t *addrlen, uint32_t addr_size)
+{
+    return accept(sockfd, (struct sockaddr *)addr, addrlen);
+}
+
+int
+ocall_recv(int sockfd, void *buf, size_t len, int flags)
+{
+    return recv(sockfd, buf, len, flags);
+}
+
+ssize_t
+ocall_recvfrom(int sockfd, void *buf, size_t len, int flags, void *src_addr,
+               uint32_t *addrlen, uint32_t addr_size)
+{
+    return recvfrom(sockfd, buf, len, flags, (struct sockaddr *)src_addr,
+                    addrlen);
+}
+
+int
+ocall_send(int sockfd, const void *buf, size_t len, int flags)
+{
+    return send(sockfd, buf, len, flags);
+}
+
+ssize_t
+ocall_sendto(int sockfd, const void *buf, size_t len, int flags,
+             void *dest_addr, uint32_t addrlen)
+{
+    return sendto(sockfd, buf, len, flags, (struct sockaddr *)dest_addr,
+                  addrlen);
+}
+
+int
+ocall_connect(int sockfd, void *addr, uint32_t addrlen)
+{
+    return connect(sockfd, (const struct sockaddr *)addr, addrlen);
+}
\ No newline at end of file
diff --git a/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/shared/platform/linux-sgx/untrusted/time.c b/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/shared/platform/linux-sgx/untrusted/time.c
new file mode 100644
index 000000000..5fa387b0c
--- /dev/null
+++ b/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/shared/platform/linux-sgx/untrusted/time.c
@@ -0,0 +1,44 @@
+/*
+ * 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);
+}