parlib: have 2LS libraries #include parlib/stdio.h
[akaros.git] / user / vmm / linuxemu.c
index bd217e8..a495835 100644 (file)
@@ -5,7 +5,7 @@
 
 #include <sys/stat.h>
 #include <sys/types.h>
-#include <stdio.h>
+#include <parlib/stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <sys/syscall.h>
 #include <vmm/linux_syscalls.h>
 #include <sys/time.h>
+#include <vmm/linuxemu.h>
+#include <dlfcn.h>
+#include <sys/mman.h>
+#include <futex.h>
+#include <sys/epoll.h>
+
+// This is the maximum fd number we allow opened in dune
+#define DUNE_NR_FILE_DESC 100
+
+// Some defines used in linux syscalls
+#define FALLOC_FL_KEEP_SIZE 1
+#define FALLOC_FL_PUNCH_HOLE 2
+#define GRND_NONBLOCK 0x0001
+#define GRND_RANDOM 0x0002
+
+static int lemu_debug;
+
+static uth_mutex_t *lemu_logging_lock;
+static uth_mutex_t *fd_table_lock;
+
+static FILE *lemu_global_logfile;
+
+//Records the open fds of files opened with linuxemu
+// TODO: Make this a dynamic array in the future
+char *openfd_filenames[DUNE_NR_FILE_DESC];
+
+void init_lemu_logging(int log_level)
+{
+       const char *logfile_name = "lemu.log";
+       FILE *x = fopen(logfile_name, "w");
+
+       lemu_debug = log_level;
+       lemu_logging_lock = uth_mutex_alloc();
+
+       if (x != NULL)
+               lemu_global_logfile = x;
+       else
+               lemu_global_logfile = stderr;
+}
+
+void destroy_lemu_logging(void)
+{
+       if (lemu_logging_lock != NULL)
+               uth_mutex_free(lemu_logging_lock);
+
+       if (lemu_global_logfile != stderr)
+               fclose(lemu_global_logfile);
+}
+
+/////////////////////////////////////
+// BEGIN SYSCALL HELPERS
+/////////////////////////////////////
+
+// Checks if path is an absolute path
+// Symlinks are not resolved, we just check if we refer to the root directory
+bool is_absolute_path(const char *path)
+{
+       if (!path || strlen(path) == 0)
+               return false;
+       return (strncmp(path, "/", 1) == 0);
+}
+
+
+// This resolves relative paths in syscalls like openat and unlinkat, based on
+// our currently opened fds in dune
+//
+// This function will allocate memory for the string absolute_path, it is the
+// caller's responsibility to free this memory when it is done
+//
+// If path is an absolute path already, we ignore fd and retrun a copy of path
+// in absolute_path
+bool get_absolute_path_from_fd(int fd, const char *path, char **absolute_path)
+{
+       if (!path) {
+               fprintf(stderr, "get_absolute_path_from_fd: suffix is null.\n");
+               return false;
+       }
+
+       if (fd >= DUNE_NR_FILE_DESC) {
+               fprintf(stderr, "get_absolute_path_from_fd: fd too large.\n");
+               return false;
+       }
+
+       int len1 = strlen(path);
+
+       if (len1 == 0) {
+               fprintf(stderr,
+                       "get_absolute_path_from_fd: suffix is empty.\n");
+               return false;
+       }
+
+       if (is_absolute_path(path)) {
+               *absolute_path = calloc(sizeof(char), len1 + 1);
+               if (!(*absolute_path)) {
+                       fprintf(stderr,
+                               "get_absolute_path_from_fd: couldn't allocate memory.\n");
+                       return false;
+               }
+               strcpy(*absolute_path, path);
+               return true;
+       }
+
+       uth_mutex_lock(fd_table_lock);
+       if (!openfd_filenames[fd]) {
+               uth_mutex_unlock(fd_table_lock);
+               fprintf(stderr,
+                       "get_absolute_path_from_fd: no file open at fd.\n");
+               return false;
+       }
+
+       int len2 = strlen(openfd_filenames[fd]);
+
+       if (len2 == 0) {
+               uth_mutex_unlock(fd_table_lock);
+               fprintf(stderr,
+                       "get_absolute_path_from_fd: prefix has length 0, fd was probably not open.\n");
+               return false;
+       }
+
+       // Add space for an extra slash and a null terminator
+       int total_len = len1 + len2 + 2;
+
+       *absolute_path = calloc(sizeof(char), total_len);
+
+       if (!(*absolute_path)) {
+               uth_mutex_unlock(fd_table_lock);
+               fprintf(stderr,
+                       "get_absolute_path_from_fd: couldn't allocate memory.\n");
+               return false;
+       }
+
+       strcat(*absolute_path, openfd_filenames[fd]);
+       uth_mutex_unlock(fd_table_lock);
+
+       // Add a slash if we don't have one
+       if ((*absolute_path)[len2 - 1] != '/')
+               strcat(*absolute_path, "/");
+
+       strcat(*absolute_path, path);
+
+       fprintf(stderr, "Constructed full path \"%s\"\n", *absolute_path);
+       return true;
+}
+
+
+//Akaros open flags are different than linux
+//This function converts them
+int convert_open_flags_ltoa(int flags)
+{
+       int lower3bits = flags & 0x7;
+       int otherstuff = flags & ~(0x7);
+
+       switch (lower3bits) {
+       case 0:
+               otherstuff |= O_RDONLY;
+               break;
+       case 1:
+               otherstuff |= O_WRONLY;
+               break;
+       case 2:
+               otherstuff |= O_RDWR;
+               break;
+       default:
+               // TODO(ganshun): We panic here for now if they are trying
+               // behavior we do not expect
+               panic("linuxemu, convert_open_flags_ltoa: unknown open flags provided\n");
+               break;
+       }
+       return otherstuff;
+}
+
+int convert_open_flags_atol(int flags)
+{
+       int lower3bits = flags & 0x7;
+       int otherstuff = flags & ~(0x7);
+
+       switch (lower3bits) {
+       case O_RDONLY:
+               otherstuff |= 0;
+               break;
+       case O_WRONLY:
+               otherstuff |= 1;
+               break;
+       case O_RDWR:
+               otherstuff |= 2;
+               break;
+       default:
+               // TODO(ganshun): We panic here for now if they are trying
+               // behavior we do not expect
+               panic("linuxemu, convert_open_flags_atol: unknown open flags provided\n");
+               break;
+       }
+       return otherstuff;
+}
+
+// Updates the fd mapping for a specific fd. Allows the fd mapping to
+// be freed (in the case of a close). Calls to the function may leave
+// values in the fd table as NULL
+bool update_fd_map(int fd, const char *path)
+{
+       int len = 0;
+
+       if (fd >= DUNE_NR_FILE_DESC)
+               return false;
+
+       if (path)
+               len = strlen(path);
+
+       uth_mutex_lock(fd_table_lock);
+
+       // If there was a file here before, free the string
+       // Potential optimization would be to only free when
+       // we need to grow the size of the string.
+       if (openfd_filenames[fd]) {
+               free(openfd_filenames[fd]);
+               openfd_filenames[fd] = NULL;
+       }
+       // If we have a new file to put here, allocate memory
+       // and copy it in.
+       if (len) {
+               openfd_filenames[fd] = (char*) calloc(sizeof(char), len + 1);
+               if (!openfd_filenames[fd]) {
+                       uth_mutex_unlock(fd_table_lock);
+                       panic("update_fd_map could not allocate memory\n");
+                       return false;
+               }
+               strcpy(openfd_filenames[fd], path);
+       }
+
+       uth_mutex_unlock(fd_table_lock);
+       return true;
+}
+
+void convert_stat_akaros_to_linux(struct stat *si_akaros,
+                                  struct linux_stat_amd64 *si)
+{
+       si->st_dev =  (uint64_t) si_akaros->st_dev;
+       si->st_ino = (uint64_t) si_akaros->st_ino;
+       si->st_mode = (uint32_t) si_akaros->st_mode;
+       si->st_nlink = (uint64_t) si_akaros->st_nlink;
+       si->st_uid = (uint32_t) si_akaros->st_uid;
+       si->st_gid = (uint32_t) si_akaros->st_gid;
+       si->st_rdev = (uint64_t) si_akaros->st_rdev;
+       si->st_size = (int64_t) si_akaros->st_size;
+       si->st_blksize = (int64_t) si_akaros->st_blksize;
+       si->st_blocks = (int64_t) si_akaros->st_blocks;
+
+       //For now the akaros timespec works out... this might change
+       //akaros timespec must be 2x int64_t for this to be valid
+       si->st_atim = si_akaros->st_atim;
+       si->st_mtim = si_akaros->st_mtim;
+       si->st_ctim = si_akaros->st_ctim;
+}
+
+/////////////////////////////////////
+// BEGIN DUNE SYSCALL IMPLEMENTATIONS
+/////////////////////////////////////
+
+//////////////////////////////////////////////////////
+// Ported Syscalls (we just call the akaros version)
+//////////////////////////////////////////////////////
+
+bool dune_sys_ftruncate(struct vm_trapframe *tf)
+{
+       int retval = ftruncate((int) tf->tf_rdi, (off_t) tf->tf_rsi);
+       int err = errno;
+
+       if (retval == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %d\n", err);
+               tf->tf_rax = -err;
+       } else {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                         "SUCCESS %d\n", retval);
+               tf->tf_rax = retval;
+       }
+       return true;
+
+}
+
+bool dune_sys_fcntl(struct vm_trapframe *tf)
+{
+       int retval = fcntl((int) tf->tf_rdi, (int) tf->tf_rsi, (int) tf->tf_rdx);
+       int err = errno;
+
+       if (retval == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %d\n", err);
+               tf->tf_rax = -err;
+       } else {
+               // TODO(ganshun): fix fcntl SETFL, ak flags are different.
+               if (tf->tf_rsi == 3)
+                       retval = convert_open_flags_atol(retval);
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                         "SUCCESS %d\n", retval);
+               tf->tf_rax = retval;
+       }
+       return true;
+}
+
+bool dune_sys_pread64(struct vm_trapframe *tf)
+{
+       int fd = (int) tf->tf_rdi;
+       void *buf = (void*) tf->tf_rsi;
+       size_t count = tf->tf_rdx;
+       off_t offset = (off_t) tf->tf_r10;
+
+       ssize_t retval = pread(fd, buf, count, offset);
+       int err = errno;
+
+       if (retval == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %zd\n", err);
+               tf->tf_rax = -err;
+       } else {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                         "SUCCESS %zd\n", retval);
+               tf->tf_rax = retval;
+       }
+       return true;
+}
+
+bool dune_sys_read(struct vm_trapframe *tf)
+{
+       ssize_t retval = read(tf->tf_rdi, (void*) tf->tf_rsi,
+                             (size_t) tf->tf_rdx);
+       int err = errno;
+
+       if (retval == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %zd\n", err);
+               tf->tf_rax = -err;
+       } else {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                         "SUCCESS %zd\n", retval);
+               tf->tf_rax = retval;
+       }
+       return true;
+}
+
+bool dune_sys_pwrite64(struct vm_trapframe *tf)
+{
+       int fd = (int) tf->tf_rdi;
+       const void *buf = (const void*) tf->tf_rsi;
+       size_t length = (size_t) tf->tf_rdx;
+       off_t offset = (off_t) tf->tf_r10;
+
+       ssize_t retval = pwrite(fd, buf, length, offset);
+       int err = errno;
+
+       if (retval == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %zd\n", err);
+               tf->tf_rax = -err;
+       } else {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                         "SUCCESS %zd\n", retval);
+               tf->tf_rax = retval;
+       }
+       return true;
+}
+
+bool dune_sys_write(struct vm_trapframe *tf)
+{
+       ssize_t retval = write((int) tf->tf_rdi, (const void *) tf->tf_rsi,
+                              (size_t) tf->tf_rdx);
+       int err = errno;
+
+       if (retval == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %zd\n", err);
+               tf->tf_rax = -err;
+       } else {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                         "SUCCESS %zd\n", retval);
+               tf->tf_rax = retval;
+       }
+       return true;
+}
+
+bool dune_sys_getpid(struct vm_trapframe *tf)
+{
+       // Getpid always suceeds
+       int retval = getpid();
+
+       lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false, "SUCCESS %d\n",
+                 retval);
+       tf->tf_rax = retval;
+       return true;
+}
+
+bool dune_sys_gettimeofday(struct vm_trapframe *tf)
+{
+       int retval = gettimeofday((struct timeval*) tf->tf_rdi,
+                                 (struct timezone*) tf->tf_rsi);
+       int err = errno;
+
+       if (retval == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %d\n", err);
+               tf->tf_rax = -err;
+       } else {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                         "SUCCESS %d\n", retval);
+               tf->tf_rax = retval;
+       }
+       return true;
+}
+
+bool dune_sys_dup(struct vm_trapframe *tf)
+{
+       int retval = dup((int) tf->tf_rdi);
+       int err = errno;
+
+       if (retval == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %d\n", err);
+               tf->tf_rax = -err;
+       } else {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                         "SUCCESS %d\n", retval);
+               tf->tf_rax = retval;
+       }
+       return true;
+}
+
+bool dune_sys_dup2(struct vm_trapframe *tf)
+{
+       int retval = dup2((int) tf->tf_rdi, (int)tf->tf_rsi);
+       int err = errno;
+
+       if (retval == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %d\n", err);
+               tf->tf_rax = -err;
+       } else {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                         "SUCCESS %d\n", retval);
+               tf->tf_rax = retval;
+       }
+       return true;
+}
+
+bool dune_sys_umask(struct vm_trapframe *tf)
+{
+       //Umask always succeeds
+       int retval = umask((mode_t) tf->tf_rdi);
+
+       lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false, "SUCCESS %d\n",
+                 retval);
+       tf->tf_rax = retval;
+       return true;
+}
+
+bool dune_sys_clock_gettime(struct vm_trapframe *tf)
+{
+       int retval = clock_gettime(tf->tf_rdi, (struct timespec*) tf->tf_rsi);
+       int err = errno;
+
+       if (retval == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %d\n", err);
+               tf->tf_rax = -err;
+       } else {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                         "SUCCESS %d\n", retval);
+               tf->tf_rax = retval;
+       }
+       return true;
+}
+
+bool dune_sys_munmap(struct vm_trapframe *tf)
+{
+       int retval = munmap((void *) tf->tf_rdi, tf->tf_rsi);
+       int err = errno;
+
+       if (retval == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %d\n", err);
+               tf->tf_rax = -err;
+       } else {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                         "SUCCESS %d\n", retval);
+               tf->tf_rax = retval;
+       }
+       return true;
+}
+
+bool dune_sys_futex(struct vm_trapframe *tf)
+{
+       int *uaddr = (int*) tf->tf_rdi;
+       int op = (int) tf->tf_rsi;
+       int val = (int) tf->tf_rdx;
+       struct timespec *timeout = (struct timespec *) tf->tf_r10;
+       int *uaddr2 = (int*) tf->tf_r8;
+       int val3 = (int) tf->tf_r9;
+       int retval = futex(uaddr, op, val, timeout, uaddr2, val3);
+       int err = errno;
+
+       if (retval == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %d\n", err);
+               tf->tf_rax = -err;
+       } else {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                         "SUCCESS %d\n", retval);
+               tf->tf_rax = retval;
+       }
+       return true;
+}
+
+bool dune_sys_gettid(struct vm_trapframe *tf)
+{
+       // Gettid always succeeds
+       int retval = tf->tf_guest_pcoreid;
+
+       lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false, "SUCCESS %d\n",
+                 retval);
+       tf->tf_rax = retval;
+       return true;
+}
+
+/////////////////////////////////////////////////////////
+// Modified Syscalls (Partially implemented in Akaros)
+////////////////////////////////////////////////////////
+
+bool dune_sys_open(struct vm_trapframe *tf)
+{
+       const char *file = (const char *) tf->tf_rdi;
+       int flags = tf->tf_rsi;
+       int mode = tf->tf_rdx;
+
+       flags = convert_open_flags_ltoa(flags);
+       lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                 "Trying to open \"%s\"\n", file);
+
+       int retval  = open(file, flags, mode);
+       int err = errno;
+
+       if (retval == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %d\n", err);
+               tf->tf_rax = -err;
+               return true;
+       }
+
+       if (!update_fd_map(retval, file))
+               panic("[TID %d] %s: ERROR in updating fd_mapping\n",
+                     tf->tf_guest_pcoreid, dune_syscall_table[tf->tf_rax].name);
+
+       lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                 "SUCCESS %d\n", retval);
+       tf->tf_rax = retval;
+       return true;
+}
+
+bool dune_sys_openat(struct vm_trapframe *tf)
+{
+
+       int fd = (int) tf->tf_rdi;
+       const char *s = (const char *) tf->tf_rsi;
+       int flags = (int) tf->tf_rdx;
+       char *s_absolute = NULL;
+       int retval;
+       int err;
+
+       // TODO: we panic here on failure, but there are probably instances
+       // where we'd want to recover and return EBADF or ENOTDIR
+       if (!get_absolute_path_from_fd(fd, s, &s_absolute)) {
+               panic("[TID %d] %s: ERROR in getting absolute path fd was %d, suffix was %s\n",
+                     tf->tf_guest_pcoreid, dune_syscall_table[tf->tf_rax].name,
+                     fd, s);
+       }
+
+       flags = convert_open_flags_ltoa(flags);
+       lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                 "trying to open absolute path %s with translated flags %p\n",
+                 s, flags);
+       retval = open(s_absolute, flags);
+       err = errno;
+
+       if (retval == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %d\n", err);
+               tf->tf_rax = -err;
+               free(s_absolute);
+               return true;
+       }
+
+       if (!update_fd_map(retval, s_absolute)) {
+               panic("[TID %d] %s: ERROR in updating fd_mapping\n",
+                     tf->tf_guest_pcoreid,
+                     dune_syscall_table[tf->tf_rax].name);
+       }
+
+       lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                 "SUCCESS %d\n", retval);
+       free(s_absolute);
+       tf->tf_rax = retval;
+       return true;
+}
+
+bool dune_sys_readlinkat(struct vm_trapframe *tf)
+{
+       int fd = (int) tf->tf_rdi;
+       const char *s = (const char*) tf->tf_rsi;
+       char *buf = (char *) tf->tf_rdx;
+       size_t bufsize = (size_t) tf->tf_r10;
+       ssize_t retval;
+       int err;
+       char *s_absolute = NULL;
+
+
+       if (!get_absolute_path_from_fd(fd, s, &s_absolute)) {
+               panic("[TID %d] %s: ERROR in getting absolute path fd was %d, suffix was %s\n",
+                     tf->tf_guest_pcoreid, dune_syscall_table[tf->tf_rax].name,
+                     fd, s);
+       }
+
+       lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                 "trying to readlink %s\n", s_absolute);
+       retval = readlink(s_absolute, buf, bufsize);
+       err = errno;
+       free(s_absolute);
+
+       if (retval == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %d\n", err);
+               tf->tf_rax = -err;
+       } else {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                         "SUCCESS %zd\n", retval);
+               tf->tf_rax = retval;
+       }
+       return true;
+}
+
+bool dune_sys_unlinkat(struct vm_trapframe *tf)
+{
+       int fd = (int) tf->tf_rdi;
+       const char *s = (const char*) tf->tf_rsi;
+       int flags = (int) tf->tf_rdx;
+       char *s_absolute = NULL;
+       int retval, err;
+
+       if (!get_absolute_path_from_fd(fd, s, &s_absolute)) {
+               panic("[TID %d] %s: ERROR in getting absolute path fd was %d, suffix was %s\n",
+                     tf->tf_guest_pcoreid, dune_syscall_table[tf->tf_rax].name,
+                     fd, s);
+       }
+
+       lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                 "trying to unlink %s\n", s_absolute);
+       retval = unlink(s_absolute);
+       err = errno;
+       free(s_absolute);
+
+       if (retval == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %d\n", err);
+               tf->tf_rax = -err;
+       } else {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                         "SUCCESS %d\n", retval);
+               tf->tf_rax = retval;
+       }
+       return true;
+}
+
+bool dune_sys_close(struct vm_trapframe *tf)
+{
+       int fd = tf->tf_rdi;
+       int retval, err;
+
+       retval = close(fd);
+       err = errno;
+
+       if (retval == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %d\n", err);
+               tf->tf_rax = -err;
+               return true;
+       }
+
+       if (!update_fd_map(fd, NULL)) {
+               panic("[TID %d] %s: ERROR in updating fd_mapping\n",
+                     tf->tf_guest_pcoreid,
+                     dune_syscall_table[tf->tf_rax].name);
+       }
+
+       lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                 "SUCCESS %d\n", retval);
+       tf->tf_rax = retval;
+       return true;
+}
+
+bool dune_sys_sched_yield(struct vm_trapframe *tf)
+{
+       tf->tf_rax = 0;
+       uthread_sched_yield();
+       return true;
+}
+
+
+bool dune_sys_fstat(struct vm_trapframe *tf)
+{
+       struct stat si_akaros_val;
+       int fd = tf->tf_rdi;
+       struct linux_stat_amd64 *si = (struct linux_stat_amd64*) tf->tf_rsi;
+
+       // TODO(ganshun): Check if mmaped
+       if (!si) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %d\n", EFAULT);
+               tf->tf_rax = -EFAULT;
+               return true;
+       }
+
+       struct stat *si_akaros = &si_akaros_val;
+
+       // Make sure we zero out the data on the stack
+       memset((void*) si_akaros, 0, sizeof(struct stat));
+
+       int retval = fstat(fd, si_akaros);
+       int err = errno;
+
+       if (retval == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %d\n", err);
+               tf->tf_rax = -err;
+       } else {
+               convert_stat_akaros_to_linux(si_akaros, si);
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                         "SUCCESS %d\n", retval);
+               tf->tf_rax = retval;
+       }
+       return true;
+}
+
+bool dune_sys_stat(struct vm_trapframe *tf)
+{
+       struct stat si_akaros_val;
+       const char *path = (const char*) tf->tf_rdi;
+       struct linux_stat_amd64 *si = (struct linux_stat_amd64*) tf->tf_rsi;
+
+       // TODO(ganshun): Check if mmaped
+       if (!si) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %d\n", EFAULT);
+               tf->tf_rax = -EFAULT;
+               return true;
+       }
+
+       struct stat *si_akaros = &si_akaros_val;
+
+       // Make sure we zero out the data on the stack
+       memset((void*) si_akaros, 0, sizeof(struct stat));
+
+       int retval = stat(path, si_akaros);
+       int err = errno;
+
+       if (retval == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %d\n", err);
+               tf->tf_rax = -err;
+       } else {
+               convert_stat_akaros_to_linux(si_akaros, si);
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                         "SUCCESS %d\n", retval);
+               tf->tf_rax = retval;
+       }
+       return true;
+}
+
+///////////////////////////////////////////////////
+// Newly Implemented Syscalls
+///////////////////////////////////////////////////
+
+// Dune implementation of fallocate, it just writes zeros for now
+int dune_fallocate(int fd, int mode, off_t offset, off_t len)
+{
+       if (!(mode & (FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE)))
+               return posix_fallocate(fd, offset, len);
+
+       if (offset < 0 || len <= 0) {
+               errno = EINVAL;
+               return -1;
+       }
+       struct stat st;
+       int ret = fstat(fd, &st);
+
+       if (ret == -1) {
+               errno == EBADF;
+               return -1;
+       }
+       if (offset + len >= st.st_size) {
+               // Panic here as we cannot support changing the size of the file
+               // right now.
+               panic("dune_fallocate: would write over the size of the file!");
+       }
+       if (S_ISFIFO(st.st_mode)) {
+               errno = ESPIPE;
+               return -1;
+       }
+       if (!(S_ISREG(st.st_mode) || S_ISDIR(st.st_mode))) {
+               errno = ENODEV;
+               return -1;
+       }
+
+       // TODO(ganshun): For punch hole, we just write zeros to the file for
+       // now
+       if ((mode & FALLOC_FL_PUNCH_HOLE) && (mode & FALLOC_FL_KEEP_SIZE)) {
+               const size_t buffer_size = 0x100000;
+               int pos;
+               ssize_t amt = 0;
+               size_t tot = 0;
+               size_t size;
+               char *buf = calloc(sizeof(char), buffer_size);
+
+               if (!buf)
+                       panic("dune_fallocate: could not allocate a buffer\n");
+
+               for (pos = offset; pos < offset + len; pos += amt) {
+                       size = len + offset - pos;
+                       if (size > buffer_size)
+                               size = buffer_size;
+                       amt = write(fd, buf, size);
+                       if (amt == -1) {
+                               free(buf);
+                               errno = EIO;
+                               return -1;
+                       }
+                       tot += amt;
+                       fprintf(stderr, "%d bytes written so far\n", tot);
+               }
+               free(buf);
+               return tot;
+       }
+
+       // Unsupported otherwise
+       errno = ENOSYS;
+       return -1;
+}
+
+// Fallocate syscall
+bool dune_sys_fallocate(struct vm_trapframe *tf)
+{
+       int fd = (int) tf->tf_rdi;
+       int mode = (int) tf->tf_rsi;
+       off_t offset = (off_t) tf->tf_rdx;
+       off_t len = (off_t) tf->tf_r10;
+
+       int retval = dune_fallocate(fd, mode, offset, len);
+       int err = errno;
+
+       if (retval == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %d\n", err);
+               tf->tf_rax = -err;
+       } else {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                         "SUCCESS %d\n", retval);
+               tf->tf_rax = retval;
+       }
+       return true;
+}
+
+// Currently unsupported
+bool dune_sys_sched_getaffinity(struct vm_trapframe *tf)
+{
+       tf->tf_rax = -ENOSYS;
+       return true;
+}
+
+// We do not implement pselect; however, some applications may try to
+// use it as a portable way to sleep. If that is the case, then we
+// allow it
+bool dune_sys_pselect6(struct vm_trapframe *tf)
+{
+       int nfds = (int) tf->tf_rdi;
+       fd_set *readfds = (fd_set *) tf->tf_rsi;
+       fd_set *writefds = (fd_set *) tf->tf_rdx;
+       fd_set *exceptfds = (fd_set *) tf->tf_r10;
+       const struct timespec *timeout = (const struct timespec *) tf->tf_r8;
+       const sigset_t *sigmask = (const sigset_t *) tf->tf_r9;
+
+       // Check if process wants to sleep
+       if (nfds == 0 && readfds == NULL && writefds == NULL &&
+           exceptfds == NULL && timeout != NULL) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                         "Sleeping for %ld seconds, %ld nanoseconds\n",
+                         timeout->tv_sec, timeout->tv_nsec);
+               nanosleep(timeout, NULL);
+               tf->tf_rax = 0;
+               return true;
+       }
+
+       lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                 "unimplemented, will now fail...\n");
+       return false;
+}
+
+bool dune_sys_getrandom(struct vm_trapframe *tf)
+{
+       const char *random_source = "/dev/urandom";
+       void *buf = (void*) tf->tf_rdi;
+       size_t len = (size_t) tf->tf_rsi;
+       unsigned int flags = (unsigned int) tf->tf_rdx;
+
+       if (!buf) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "buffer inaccessable\n");
+               tf->tf_rax = -EFAULT;
+               return true;
+       }
+       if (flags & GRND_RANDOM || flags & GRND_NONBLOCK) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "unsupported flags specified\n");
+               tf->tf_rax = -EINVAL;
+               return true;
+       }
+
+       int fd = open(random_source, O_RDONLY);
+       int err = errno;
+
+       if (fd == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR opening random source %s, errno=%d\n",
+                         random_source, err);
+               return false;
+       }
+
+       ssize_t retval = read(fd, buf, len);
+
+       err = errno;
+       close(fd);
+       if (retval == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR reading from random source %s, errno=%d\n",
+                         random_source, err);
+               tf->tf_rax = -err;
+       } else {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                         "SUCCESS %zd\n", retval);
+               tf->tf_rax = retval;
+       }
+       return true;
+}
+
+/////////////////////////////////////////////////////////////////
+/// We don't have a good implementation for these syscalls,
+/// they will not work in all cases
+/////////////////////////////////////////////////////////////////
+
+bool dune_sys_getgroups(struct vm_trapframe *tf)
+{
+       tf->tf_rax = 0;
+       return true;
+}
+
+
+bool dune_sys_geteuid(struct vm_trapframe *tf)
+{
+       tf->tf_rax = 0;
+       return true;
+}
+
+bool dune_sys_getegid(struct vm_trapframe *tf)
+{
+       tf->tf_rax = 0;
+       return true;
+}
+
+
+bool dune_sys_getuid(struct vm_trapframe *tf)
+{
+       tf->tf_rax = 0;
+       return true;
+}
+
+
+bool dune_sys_getgid(struct vm_trapframe *tf)
+{
+       tf->tf_rax = 0;
+       return true;
+}
+
+// TODO(ganshun): implement mincore
+bool dune_sys_mincore(struct vm_trapframe *tf)
+{
+       tf->tf_rax = -ENOMEM;
+       return true;
+}
+
+bool dune_sys_rt_sigprocmask(struct vm_trapframe *tf)
+{
+       int retval = sigprocmask(tf->tf_rdi, (const sigset_t*) tf->tf_rsi,
+                                (sigset_t*) tf->tf_rdx);
+       int err = errno;
+
+       if (retval == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %d\n", err);
+               tf->tf_rax = -err;
+       } else {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                         "SUCCESS %d\n", retval);
+               tf->tf_rax = retval;
+       }
+       return true;
+}
+
+// TODO(ganshun): sigaltstack needs to implemented for the guest
+bool dune_sys_sigaltstack(struct vm_trapframe *tf)
+{
+       tf->tf_rax = 0;
+       return true;
+}
+
+
+// TODO(ganshun): more signal code, we need to be careful with this one,
+// we should not register guest signal handlers in akaros
+bool dune_sys_rt_sigaction(struct vm_trapframe *tf)
+{
+       tf->tf_rax = 0;
+       return true;
+}
+
+//TODO(ganshun): we do not support epoll currently except for create and wait
+bool dune_sys_epoll_create1(struct vm_trapframe *tf)
+{
+       int flags = 0;
+       // TODO(ganshun): epoll_create is not fully supported for all flags
+       // so we ignore the flags variable in the trapframe since it is not used.
+       int retval = epoll_create1(flags);
+       int err = errno;
+
+       if (retval == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %d\n", err);
+               tf->tf_rax = -err;
+       } else {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                         "SUCCESS %d\n", retval);
+               tf->tf_rax = retval;
+       }
+       return true;
+}
+
+bool dune_sys_epoll_wait(struct vm_trapframe *tf)
+{
+       int epfd = (int) tf->tf_rdi;
+       struct epoll_event *events = (struct epoll_event*) tf->tf_rsi;
+       int maxevents = (int) tf->tf_rdx;
+       int timeout = (int) tf->tf_r10;
+       int retval = epoll_wait(epfd, events, maxevents, timeout);
+       int err = errno;
+
+       if (retval == -1) {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, true,
+                         "ERROR %d\n", err);
+               tf->tf_rax = -err;
+       } else {
+               lemuprint(tf->tf_guest_pcoreid, tf->tf_rax, false,
+                         "SUCCESS %d\n", retval);
+               tf->tf_rax = retval;
+       }
+       return true;
+}
+
+// Unimplemented
+bool dune_sys_epoll_ctl(struct vm_trapframe *tf)
+{
+       tf->tf_rax = -ENOSYS;
+       return true;
+}
+
+// Unimplemented
+bool dune_sys_fstatfs(struct vm_trapframe *tf)
+{
+       tf->tf_rax = -ENOSYS;
+       return true;
+}
+
+// Main syscall table
+struct dune_sys_table_entry dune_syscall_table[DUNE_MAX_NUM_SYSCALLS] = {
+       [DUNE_SYS_READ] = {dune_sys_read, "DUNE_SYS_READ"},
+       [DUNE_SYS_WRITE] = {dune_sys_write, "DUNE_SYS_WRITE"},
+       [DUNE_SYS_OPEN] = {dune_sys_open, "DUNE_SYS_OPEN"},
+       [DUNE_SYS_CLOSE] = {dune_sys_close, "DUNE_SYS_CLOSE"},
+       [DUNE_SYS_STAT] = {dune_sys_stat, "DUNE_SYS_STAT"},
+       [DUNE_SYS_FSTAT] = {dune_sys_fstat, "DUNE_SYS_FSTAT"},
+       [DUNE_SYS_LSTAT] = {NULL, "DUNE_SYS_LSTAT"},
+       [DUNE_SYS_POLL] = {NULL, "DUNE_SYS_POLL"},
+       [DUNE_SYS_LSEEK] = {NULL, "DUNE_SYS_LSEEK"},
+       [DUNE_SYS_MMAP] = {NULL, "DUNE_SYS_MMAP"},
+       [DUNE_SYS_MPROTECT] = {NULL, "DUNE_SYS_MPROTECT"},
+       [DUNE_SYS_MUNMAP] = {dune_sys_munmap, "DUNE_SYS_MUNMAP"},
+       [DUNE_SYS_BRK] = {NULL, "DUNE_SYS_BRK"},
+       [DUNE_SYS_RT_SIGACTION] = {dune_sys_rt_sigaction, "DUNE_SYS_RT_SIGACTION"},
+       [DUNE_SYS_RT_SIGPROCMASK] = {dune_sys_rt_sigprocmask,
+                                    "DUNE_SYS_RT_SIGPROCMASK"},
+       [DUNE_SYS_RT_SIGRETURN] = {NULL, "DUNE_SYS_RT_SIGRETURN"},
+       [DUNE_SYS_IOCTL] = {NULL, "DUNE_SYS_IOCTL"},
+       [DUNE_SYS_PREAD64] = {dune_sys_pread64, "DUNE_SYS_PREAD64"},
+       [DUNE_SYS_PWRITE64] = {dune_sys_pwrite64, "DUNE_SYS_PWRITE64"},
+       [DUNE_SYS_READV] = {NULL, "DUNE_SYS_READV"},
+       [DUNE_SYS_WRITEV] = {NULL, "DUNE_SYS_WRITEV"},
+       [DUNE_SYS_ACCESS] = {NULL, "DUNE_SYS_ACCESS"},
+       [DUNE_SYS_PIPE] = {NULL, "DUNE_SYS_PIPE"},
+       [DUNE_SYS_SELECT] = {NULL, "DUNE_SYS_SELECT"},
+       [DUNE_SYS_SCHED_YIELD] = {dune_sys_sched_yield, "DUNE_SYS_SCHED_YIELD"},
+       [DUNE_SYS_MREMAP] = {NULL, "DUNE_SYS_MREMAP"},
+       [DUNE_SYS_MSYNC] = {NULL, "DUNE_SYS_MSYNC"},
+       [DUNE_SYS_MINCORE] = {dune_sys_mincore, "DUNE_SYS_MINCORE"},
+       [DUNE_SYS_MADVISE] = {NULL, "DUNE_SYS_MADVISE"},
+       [DUNE_SYS_SHMGET] = {NULL, "DUNE_SYS_SHMGET"},
+       [DUNE_SYS_SHMAT] = {NULL, "DUNE_SYS_SHMAT"},
+       [DUNE_SYS_SHMCTL] = {NULL, "DUNE_SYS_SHMCTL"},
+       [DUNE_SYS_DUP] = {dune_sys_dup, "DUNE_SYS_DUP"},
+       [DUNE_SYS_DUP2] = {dune_sys_dup2, "DUNE_SYS_DUP2"},
+       [DUNE_SYS_PAUSE] = {NULL, "DUNE_SYS_PAUSE"},
+       [DUNE_SYS_NANOSLEEP] = {NULL, "DUNE_SYS_NANOSLEEP"},
+       [DUNE_SYS_GETITIMER] = {NULL, "DUNE_SYS_GETITIMER"},
+       [DUNE_SYS_ALARM] = {NULL, "DUNE_SYS_ALARM"},
+       [DUNE_SYS_SETITIMER] = {NULL, "DUNE_SYS_SETITIMER"},
+       [DUNE_SYS_GETPID] = {dune_sys_getpid, "DUNE_SYS_GETPID"},
+       [DUNE_SYS_SENDFILE] = {NULL, "DUNE_SYS_SENDFILE"},
+       [DUNE_SYS_SOCKET] = {NULL, "DUNE_SYS_SOCKET"},
+       [DUNE_SYS_CONNECT] = {NULL, "DUNE_SYS_CONNECT"},
+       [DUNE_SYS_ACCEPT] = {NULL, "DUNE_SYS_ACCEPT"},
+       [DUNE_SYS_SENDTO] = {NULL, "DUNE_SYS_SENDTO"},
+       [DUNE_SYS_RECVFROM] = {NULL, "DUNE_SYS_RECVFROM"},
+       [DUNE_SYS_SENDMSG] = {NULL, "DUNE_SYS_SENDMSG"},
+       [DUNE_SYS_RECVMSG] = {NULL, "DUNE_SYS_RECVMSG"},
+       [DUNE_SYS_SHUTDOWN] = {NULL, "DUNE_SYS_SHUTDOWN"},
+       [DUNE_SYS_BIND] = {NULL, "DUNE_SYS_BIND"},
+       [DUNE_SYS_LISTEN] = {NULL, "DUNE_SYS_LISTEN"},
+       [DUNE_SYS_GETSOCKNAME] = {NULL, "DUNE_SYS_GETSOCKNAME"},
+       [DUNE_SYS_GETPEERNAME] = {NULL, "DUNE_SYS_GETPEERNAME"},
+       [DUNE_SYS_SOCKETPAIR] = {NULL, "DUNE_SYS_SOCKETPAIR"},
+       [DUNE_SYS_SETSOCKOPT] = {NULL, "DUNE_SYS_SETSOCKOPT"},
+       [DUNE_SYS_GETSOCKOPT] = {NULL, "DUNE_SYS_GETSOCKOPT"},
+       [DUNE_SYS_CLONE] = {NULL, "DUNE_SYS_CLONE"},
+       [DUNE_SYS_FORK] = {NULL, "DUNE_SYS_FORK"},
+       [DUNE_SYS_VFORK] = {NULL, "DUNE_SYS_VFORK"},
+       [DUNE_SYS_EXECVE] = {NULL, "DUNE_SYS_EXECVE"},
+       [DUNE_SYS_EXIT] = {NULL, "DUNE_SYS_EXIT"},
+       [DUNE_SYS_WAIT4] = {NULL, "DUNE_SYS_WAIT4"},
+       [DUNE_SYS_KILL] = {NULL, "DUNE_SYS_KILL"},
+       [DUNE_SYS_UNAME] = {NULL, "DUNE_SYS_UNAME"},
+       [DUNE_SYS_SEMGET] = {NULL, "DUNE_SYS_SEMGET"},
+       [DUNE_SYS_SEMOP] = {NULL, "DUNE_SYS_SEMOP"},
+       [DUNE_SYS_SEMCTL] = {NULL, "DUNE_SYS_SEMCTL"},
+       [DUNE_SYS_SHMDT] = {NULL, "DUNE_SYS_SHMDT"},
+       [DUNE_SYS_MSGGET] = {NULL, "DUNE_SYS_MSGGET"},
+       [DUNE_SYS_MSGSND] = {NULL, "DUNE_SYS_MSGSND"},
+       [DUNE_SYS_MSGRCV] = {NULL, "DUNE_SYS_MSGRCV"},
+       [DUNE_SYS_MSGCTL] = {NULL, "DUNE_SYS_MSGCTL"},
+       [DUNE_SYS_FCNTL] = {dune_sys_fcntl, "DUNE_SYS_FCNTL"},
+       [DUNE_SYS_FLOCK] = {NULL, "DUNE_SYS_FLOCK"},
+       [DUNE_SYS_FSYNC] = {NULL, "DUNE_SYS_FSYNC"},
+       [DUNE_SYS_FDATASYNC] = {NULL, "DUNE_SYS_FDATASYNC"},
+       [DUNE_SYS_TRUNCATE] = {NULL, "DUNE_SYS_TRUNCATE"},
+       [DUNE_SYS_FTRUNCATE] = {dune_sys_ftruncate, "DUNE_SYS_FTRUNCATE"},
+       [DUNE_SYS_GETDENTS] = {NULL, "DUNE_SYS_GETDENTS"},
+       [DUNE_SYS_GETCWD] = {NULL, "DUNE_SYS_GETCWD"},
+       [DUNE_SYS_CHDIR] = {NULL, "DUNE_SYS_CHDIR"},
+       [DUNE_SYS_FCHDIR] = {NULL, "DUNE_SYS_FCHDIR"},
+       [DUNE_SYS_RENAME] = {NULL, "DUNE_SYS_RENAME"},
+       [DUNE_SYS_MKDIR] = {NULL, "DUNE_SYS_MKDIR"},
+       [DUNE_SYS_RMDIR] = {NULL, "DUNE_SYS_RMDIR"},
+       [DUNE_SYS_CREAT] = {NULL, "DUNE_SYS_CREAT"},
+       [DUNE_SYS_LINK] = {NULL, "DUNE_SYS_LINK"},
+       [DUNE_SYS_UNLINK] = {NULL, "DUNE_SYS_UNLINK"},
+       [DUNE_SYS_SYMLINK] = {NULL, "DUNE_SYS_SYMLINK"},
+       [DUNE_SYS_READLINK] = {NULL, "DUNE_SYS_READLINK"},
+       [DUNE_SYS_CHMOD] = {NULL, "DUNE_SYS_CHMOD"},
+       [DUNE_SYS_FCHMOD] = {NULL, "DUNE_SYS_FCHMOD"},
+       [DUNE_SYS_CHOWN] = {NULL, "DUNE_SYS_CHOWN"},
+       [DUNE_SYS_FCHOWN] = {NULL, "DUNE_SYS_FCHOWN"},
+       [DUNE_SYS_LCHOWN] = {NULL, "DUNE_SYS_LCHOWN"},
+       [DUNE_SYS_UMASK] = {dune_sys_umask, "DUNE_SYS_UMASK"},
+       [DUNE_SYS_GETTIMEOFDAY] = {dune_sys_gettimeofday, "DUNE_SYS_GETTIMEOFDAY"},
+       [DUNE_SYS_GETRLIMIT] = {NULL, "DUNE_SYS_GETRLIMIT"},
+       [DUNE_SYS_GETRUSAGE] = {NULL, "DUNE_SYS_GETRUSAGE"},
+       [DUNE_SYS_SYSINFO] = {NULL, "DUNE_SYS_SYSINFO"},
+       [DUNE_SYS_TIMES] = {NULL, "DUNE_SYS_TIMES"},
+       [DUNE_SYS_PTRACE] = {NULL, "DUNE_SYS_PTRACE"},
+       [DUNE_SYS_GETUID] = {dune_sys_getuid, "DUNE_SYS_GETUID"},
+       [DUNE_SYS_SYSLOG] = {NULL, "DUNE_SYS_SYSLOG"},
+       [DUNE_SYS_GETGID] = {dune_sys_getgid, "DUNE_SYS_GETGID"},
+       [DUNE_SYS_SETUID] = {NULL, "DUNE_SYS_SETUID"},
+       [DUNE_SYS_SETGID] = {NULL, "DUNE_SYS_SETGID"},
+       [DUNE_SYS_GETEUID] = {dune_sys_geteuid, "DUNE_SYS_GETEUID"},
+       [DUNE_SYS_GETEGID] = {dune_sys_getegid, "DUNE_SYS_GETEGID"},
+       [DUNE_SYS_SETPGID] = {NULL, "DUNE_SYS_SETPGID"},
+       [DUNE_SYS_GETPPID] = {NULL, "DUNE_SYS_GETPPID"},
+       [DUNE_SYS_GETPGRP] = {NULL, "DUNE_SYS_GETPGRP"},
+       [DUNE_SYS_SETSID] = {NULL, "DUNE_SYS_SETSID"},
+       [DUNE_SYS_SETREUID] = {NULL, "DUNE_SYS_SETREUID"},
+       [DUNE_SYS_SETREGID] = {NULL, "DUNE_SYS_SETREGID"},
+       [DUNE_SYS_GETGROUPS] = {dune_sys_getgroups, "DUNE_SYS_GETGROUPS"},
+       [DUNE_SYS_SETGROUPS] = {NULL, "DUNE_SYS_SETGROUPS"},
+       [DUNE_SYS_SETRESUID] = {NULL, "DUNE_SYS_SETRESUID"},
+       [DUNE_SYS_GETRESUID] = {NULL, "DUNE_SYS_GETRESUID"},
+       [DUNE_SYS_SETRESGID] = {NULL, "DUNE_SYS_SETRESGID"},
+       [DUNE_SYS_GETRESGID] = {NULL, "DUNE_SYS_GETRESGID"},
+       [DUNE_SYS_GETPGID] = {NULL, "DUNE_SYS_GETPGID"},
+       [DUNE_SYS_SETFSUID] = {NULL, "DUNE_SYS_SETFSUID"},
+       [DUNE_SYS_SETFSGID] = {NULL, "DUNE_SYS_SETFSGID"},
+       [DUNE_SYS_GETSID] = {NULL, "DUNE_SYS_GETSID"},
+       [DUNE_SYS_CAPGET] = {NULL, "DUNE_SYS_CAPGET"},
+       [DUNE_SYS_CAPSET] = {NULL, "DUNE_SYS_CAPSET"},
+       [DUNE_SYS_RT_SIGPENDING] = {NULL, "DUNE_SYS_RT_SIGPENDING"},
+       [DUNE_SYS_RT_SIGTIMEDWAIT] = {NULL, "DUNE_SYS_RT_SIGTIMEDWAIT"},
+       [DUNE_SYS_RT_SIGQUEUEINFO] = {NULL, "DUNE_SYS_RT_SIGQUEUEINFO"},
+       [DUNE_SYS_RT_SIGSUSPEND] = {NULL, "DUNE_SYS_RT_SIGSUSPEND"},
+       [DUNE_SYS_SIGALTSTACK] = {dune_sys_sigaltstack, "DUNE_SYS_SIGALTSTACK"},
+       [DUNE_SYS_UTIME] = {NULL, "DUNE_SYS_UTIME"},
+       [DUNE_SYS_MKNOD] = {NULL, "DUNE_SYS_MKNOD"},
+       [DUNE_SYS_USELIB] = {NULL, "DUNE_SYS_USELIB"},
+       [DUNE_SYS_PERSONALITY] = {NULL, "DUNE_SYS_PERSONALITY"},
+       [DUNE_SYS_USTAT] = {NULL, "DUNE_SYS_USTAT"},
+       [DUNE_SYS_STATFS] = {NULL, "DUNE_SYS_STATFS"},
+       [DUNE_SYS_FSTATFS] = {dune_sys_fstatfs, "DUNE_SYS_FSTATFS"},
+       [DUNE_SYS_SYSFS] = {NULL, "DUNE_SYS_SYSFS"},
+       [DUNE_SYS_GETPRIORITY] = {NULL, "DUNE_SYS_GETPRIORITY"},
+       [DUNE_SYS_SETPRIORITY] = {NULL, "DUNE_SYS_SETPRIORITY"},
+       [DUNE_SYS_SCHED_SETPARAM] = {NULL, "DUNE_SYS_SCHED_SETPARAM"},
+       [DUNE_SYS_SCHED_GETPARAM] = {NULL, "DUNE_SYS_SCHED_GETPARAM"},
+       [DUNE_SYS_SCHED_SETSCHEDULER] = {NULL, "DUNE_SYS_SCHED_SETSCHEDULER"},
+       [DUNE_SYS_SCHED_GETSCHEDULER] = {NULL, "DUNE_SYS_SCHED_GETSCHEDULER"},
+       [DUNE_SYS_SCHED_GET_PRIORITY_MAX] = {NULL,
+                                           "DUNE_SYS_SCHED_GET_PRIORITY_MAX"},
+       [DUNE_SYS_SCHED_GET_PRIORITY_MIN] = {NULL,
+                                           "DUNE_SYS_SCHED_GET_PRIORITY_MIN"},
+       [DUNE_SYS_SCHED_RR_GET_INTERVAL] = {NULL, "DUNE_SYS_SCHED_RR_GET_INTERVAL"},
+       [DUNE_SYS_MLOCK] = {NULL, "DUNE_SYS_MLOCK"},
+       [DUNE_SYS_MUNLOCK] = {NULL, "DUNE_SYS_MUNLOCK"},
+       [DUNE_SYS_MLOCKALL] = {NULL, "DUNE_SYS_MLOCKALL"},
+       [DUNE_SYS_MUNLOCKALL] = {NULL, "DUNE_SYS_MUNLOCKALL"},
+       [DUNE_SYS_VHANGUP] = {NULL, "DUNE_SYS_VHANGUP"},
+       [DUNE_SYS_MODIFY_LDT] = {NULL, "DUNE_SYS_MODIFY_LDT"},
+       [DUNE_SYS_PIVOT_ROOT] = {NULL, "DUNE_SYS_PIVOT_ROOT"},
+       [DUNE_SYS__SYSCTL] = {NULL, "DUNE_SYS__SYSCTL"},
+       [DUNE_SYS_PRCTL] = {NULL, "DUNE_SYS_PRCTL"},
+       [DUNE_SYS_ARCH_PRCTL] = {NULL, "DUNE_SYS_ARCH_PRCTL"},
+       [DUNE_SYS_ADJTIMEX] = {NULL, "DUNE_SYS_ADJTIMEX"},
+       [DUNE_SYS_SETRLIMIT] = {NULL, "DUNE_SYS_SETRLIMIT"},
+       [DUNE_SYS_CHROOT] = {NULL, "DUNE_SYS_CHROOT"},
+       [DUNE_SYS_SYNC] = {NULL, "DUNE_SYS_SYNC"},
+       [DUNE_SYS_ACCT] = {NULL, "DUNE_SYS_ACCT"},
+       [DUNE_SYS_SETTIMEOFDAY] = {NULL, "DUNE_SYS_SETTIMEOFDAY"},
+       [DUNE_SYS_MOUNT] = {NULL, "DUNE_SYS_MOUNT"},
+       [DUNE_SYS_UMOUNT2] = {NULL, "DUNE_SYS_UMOUNT2"},
+       [DUNE_SYS_SWAPON] = {NULL, "DUNE_SYS_SWAPON"},
+       [DUNE_SYS_SWAPOFF] = {NULL, "DUNE_SYS_SWAPOFF"},
+       [DUNE_SYS_REBOOT] = {NULL, "DUNE_SYS_REBOOT"},
+       [DUNE_SYS_SETHOSTNAME] = {NULL, "DUNE_SYS_SETHOSTNAME"},
+       [DUNE_SYS_SETDOMAINNAME] = {NULL, "DUNE_SYS_SETDOMAINNAME"},
+       [DUNE_SYS_IOPL] = {NULL, "DUNE_SYS_IOPL"},
+       [DUNE_SYS_IOPERM] = {NULL, "DUNE_SYS_IOPERM"},
+       [DUNE_SYS_CREATE_MODULE] = {NULL, "DUNE_SYS_CREATE_MODULE"},
+       [DUNE_SYS_INIT_MODULE] = {NULL, "DUNE_SYS_INIT_MODULE"},
+       [DUNE_SYS_DELETE_MODULE] = {NULL, "DUNE_SYS_DELETE_MODULE"},
+       [DUNE_SYS_GET_KERNEL_SYMS] = {NULL, "DUNE_SYS_GET_KERNEL_SYMS"},
+       [DUNE_SYS_QUERY_MODULE] = {NULL, "DUNE_SYS_QUERY_MODULE"},
+       [DUNE_SYS_QUOTACTL] = {NULL, "DUNE_SYS_QUOTACTL"},
+       [DUNE_SYS_NFSSERVCTL] = {NULL, "DUNE_SYS_NFSSERVCTL"},
+       [DUNE_SYS_GETPMSG] = {NULL, "DUNE_SYS_GETPMSG"},
+       [DUNE_SYS_PUTPMSG] = {NULL, "DUNE_SYS_PUTPMSG"},
+       [DUNE_SYS_AFS_SYSCALL] = {NULL, "DUNE_SYS_AFS_SYSCALL"},
+       [DUNE_SYS_TUXCALL] = {NULL, "DUNE_SYS_TUXCALL"},
+       [DUNE_SYS_SECURITY] = {NULL, "DUNE_SYS_SECURITY"},
+       [DUNE_SYS_GETTID] = {dune_sys_gettid, "DUNE_SYS_GETTID"},
+       [DUNE_SYS_READAHEAD] = {NULL, "DUNE_SYS_READAHEAD"},
+       [DUNE_SYS_SETXATTR] = {NULL, "DUNE_SYS_SETXATTR"},
+       [DUNE_SYS_LSETXATTR] = {NULL, "DUNE_SYS_LSETXATTR"},
+       [DUNE_SYS_FSETXATTR] = {NULL, "DUNE_SYS_FSETXATTR"},
+       [DUNE_SYS_GETXATTR] = {NULL, "DUNE_SYS_GETXATTR"},
+       [DUNE_SYS_LGETXATTR] = {NULL, "DUNE_SYS_LGETXATTR"},
+       [DUNE_SYS_FGETXATTR] = {NULL, "DUNE_SYS_FGETXATTR"},
+       [DUNE_SYS_LISTXATTR] = {NULL, "DUNE_SYS_LISTXATTR"},
+       [DUNE_SYS_LLISTXATTR] = {NULL, "DUNE_SYS_LLISTXATTR"},
+       [DUNE_SYS_FLISTXATTR] = {NULL, "DUNE_SYS_FLISTXATTR"},
+       [DUNE_SYS_REMOVEXATTR] = {NULL, "DUNE_SYS_REMOVEXATTR"},
+       [DUNE_SYS_LREMOVEXATTR] = {NULL, "DUNE_SYS_LREMOVEXATTR"},
+       [DUNE_SYS_FREMOVEXATTR] = {NULL, "DUNE_SYS_FREMOVEXATTR"},
+       [DUNE_SYS_TKILL] = {NULL, "DUNE_SYS_TKILL"},
+       [DUNE_SYS_TIME] = {NULL, "DUNE_SYS_TIME"},
+       [DUNE_SYS_FUTEX] = {dune_sys_futex, "DUNE_SYS_FUTEX"},
+       [DUNE_SYS_SCHED_SETAFFINITY] = {NULL, "DUNE_SYS_SCHED_SETAFFINITY"},
+       [DUNE_SYS_SCHED_GETAFFINITY] = {dune_sys_sched_getaffinity,
+                                       "DUNE_SYS_SCHED_GETAFFINITY"},
+       [DUNE_SYS_SET_THREAD_AREA] = {NULL, "DUNE_SYS_SET_THREAD_AREA"},
+       [DUNE_SYS_IO_SETUP] = {NULL, "DUNE_SYS_IO_SETUP"},
+       [DUNE_SYS_IO_DESTROY] = {NULL, "DUNE_SYS_IO_DESTROY"},
+       [DUNE_SYS_IO_GETEVENTS] = {NULL, "DUNE_SYS_IO_GETEVENTS"},
+       [DUNE_SYS_IO_SUBMIT] = {NULL, "DUNE_SYS_IO_SUBMIT"},
+       [DUNE_SYS_IO_CANCEL] = {NULL, "DUNE_SYS_IO_CANCEL"},
+       [DUNE_SYS_GET_THREAD_AREA] = {NULL, "DUNE_SYS_GET_THREAD_AREA"},
+       [DUNE_SYS_LOOKUP_DCOOKIE] = {NULL, "DUNE_SYS_LOOKUP_DCOOKIE"},
+       [DUNE_SYS_EPOLL_CREATE] = {NULL, "DUNE_SYS_EPOLL_CREATE"},
+       [DUNE_SYS_EPOLL_CTL_OLD] = {NULL, "DUNE_SYS_EPOLL_CTL_OLD"},
+       [DUNE_SYS_EPOLL_WAIT_OLD] = {NULL, "DUNE_SYS_EPOLL_WAIT_OLD"},
+       [DUNE_SYS_REMAP_FILE_PAGES] = {NULL, "DUNE_SYS_REMAP_FILE_PAGES"},
+       [DUNE_SYS_GETDENTS64] = {NULL, "DUNE_SYS_GETDENTS64"},
+       [DUNE_SYS_SET_TID_ADDRESS] = {NULL, "DUNE_SYS_SET_TID_ADDRESS"},
+       [DUNE_SYS_RESTART_SYSCALL] = {NULL, "DUNE_SYS_RESTART_SYSCALL"},
+       [DUNE_SYS_SEMTIMEDOP] = {NULL, "DUNE_SYS_SEMTIMEDOP"},
+       [DUNE_SYS_FADVISE64] = {NULL, "DUNE_SYS_FADVISE64"},
+       [DUNE_SYS_TIMER_CREATE] = {NULL, "DUNE_SYS_TIMER_CREATE"},
+       [DUNE_SYS_TIMER_SETTIME] = {NULL, "DUNE_SYS_TIMER_SETTIME"},
+       [DUNE_SYS_TIMER_GETTIME] = {NULL, "DUNE_SYS_TIMER_GETTIME"},
+       [DUNE_SYS_TIMER_GETOVERRUN] = {NULL, "DUNE_SYS_TIMER_GETOVERRUN"},
+       [DUNE_SYS_TIMER_DELETE] = {NULL, "DUNE_SYS_TIMER_DELETE"},
+       [DUNE_SYS_CLOCK_SETTIME] = {NULL, "DUNE_SYS_CLOCK_SETTIME"},
+       [DUNE_SYS_CLOCK_GETTIME] = {dune_sys_clock_gettime,
+                                   "DUNE_SYS_CLOCK_GETTIME"},
+       [DUNE_SYS_CLOCK_GETRES] = {NULL, "DUNE_SYS_CLOCK_GETRES"},
+       [DUNE_SYS_CLOCK_NANOSLEEP] = {NULL, "DUNE_SYS_CLOCK_NANOSLEEP"},
+       [DUNE_SYS_EXIT_GROUP] = {NULL, "DUNE_SYS_EXIT_GROUP"},
+       [DUNE_SYS_EPOLL_WAIT] = {dune_sys_epoll_wait, "DUNE_SYS_EPOLL_WAIT"},
+       [DUNE_SYS_EPOLL_CTL] = {dune_sys_epoll_ctl, "DUNE_SYS_EPOLL_CTL"},
+       [DUNE_SYS_TGKILL] = {NULL, "DUNE_SYS_TGKILL"},
+       [DUNE_SYS_UTIMES] = {NULL, "DUNE_SYS_UTIMES"},
+       [DUNE_SYS_VSERVER] = {NULL, "DUNE_SYS_VSERVER"},
+       [DUNE_SYS_MBIND] = {NULL, "DUNE_SYS_MBIND"},
+       [DUNE_SYS_SET_MEMPOLICY] = {NULL, "DUNE_SYS_SET_MEMPOLICY"},
+       [DUNE_SYS_GET_MEMPOLICY] = {NULL, "DUNE_SYS_GET_MEMPOLICY"},
+       [DUNE_SYS_MQ_OPEN] = {NULL, "DUNE_SYS_MQ_OPEN"},
+       [DUNE_SYS_MQ_UNLINK] = {NULL, "DUNE_SYS_MQ_UNLINK"},
+       [DUNE_SYS_MQ_TIMEDSEND] = {NULL, "DUNE_SYS_MQ_TIMEDSEND"},
+       [DUNE_SYS_MQ_TIMEDRECEIVE] = {NULL, "DUNE_SYS_MQ_TIMEDRECEIVE"},
+       [DUNE_SYS_MQ_NOTIFY] = {NULL, "DUNE_SYS_MQ_NOTIFY"},
+       [DUNE_SYS_MQ_GETSETATTR] = {NULL, "DUNE_SYS_MQ_GETSETATTR"},
+       [DUNE_SYS_KEXEC_LOAD] = {NULL, "DUNE_SYS_KEXEC_LOAD"},
+       [DUNE_SYS_WAITID] = {NULL, "DUNE_SYS_WAITID"},
+       [DUNE_SYS_ADD_KEY] = {NULL, "DUNE_SYS_ADD_KEY"},
+       [DUNE_SYS_REQUEST_KEY] = {NULL, "DUNE_SYS_REQUEST_KEY"},
+       [DUNE_SYS_KEYCTL] = {NULL, "DUNE_SYS_KEYCTL"},
+       [DUNE_SYS_IOPRIO_SET] = {NULL, "DUNE_SYS_IOPRIO_SET"},
+       [DUNE_SYS_IOPRIO_GET] = {NULL, "DUNE_SYS_IOPRIO_GET"},
+       [DUNE_SYS_INOTIFY_INIT] = {NULL, "DUNE_SYS_INOTIFY_INIT"},
+       [DUNE_SYS_INOTIFY_ADD_WATCH] = {NULL, "DUNE_SYS_INOTIFY_ADD_WATCH"},
+       [DUNE_SYS_INOTIFY_RM_WATCH] = {NULL, "DUNE_SYS_INOTIFY_RM_WATCH"},
+       [DUNE_SYS_MIGRATE_PAGES] = {NULL, "DUNE_SYS_MIGRATE_PAGES"},
+       [DUNE_SYS_OPENAT] = {dune_sys_openat, "DUNE_SYS_OPENAT"},
+       [DUNE_SYS_MKDIRAT] = {NULL, "DUNE_SYS_MKDIRAT"},
+       [DUNE_SYS_MKNODAT] = {NULL, "DUNE_SYS_MKNODAT"},
+       [DUNE_SYS_FCHOWNAT] = {NULL, "DUNE_SYS_FCHOWNAT"},
+       [DUNE_SYS_FUTIMESAT] = {NULL, "DUNE_SYS_FUTIMESAT"},
+       [DUNE_SYS_NEWFSTATAT] = {NULL, "DUNE_SYS_NEWFSTATAT"},
+       [DUNE_SYS_UNLINKAT] = {dune_sys_unlinkat, "DUNE_SYS_UNLINKAT"},
+       [DUNE_SYS_RENAMEAT] = {NULL, "DUNE_SYS_RENAMEAT"},
+       [DUNE_SYS_LINKAT] = {NULL, "DUNE_SYS_LINKAT"},
+       [DUNE_SYS_SYMLINKAT] = {NULL, "DUNE_SYS_SYMLINKAT"},
+       [DUNE_SYS_READLINKAT] = {dune_sys_readlinkat, "DUNE_SYS_READLINKAT"},
+       [DUNE_SYS_FCHMODAT] = {NULL, "DUNE_SYS_FCHMODAT"},
+       [DUNE_SYS_FACCESSAT] = {NULL, "DUNE_SYS_FACCESSAT"},
+       [DUNE_SYS_PSELECT6] = {dune_sys_pselect6, "DUNE_SYS_PSELECT6"},
+       [DUNE_SYS_PPOLL] = {NULL, "DUNE_SYS_PPOLL"},
+       [DUNE_SYS_UNSHARE] = {NULL, "DUNE_SYS_UNSHARE"},
+       [DUNE_SYS_SET_ROBUST_LIST] = {NULL, "DUNE_SYS_SET_ROBUST_LIST"},
+       [DUNE_SYS_GET_ROBUST_LIST] = {NULL, "DUNE_SYS_GET_ROBUST_LIST"},
+       [DUNE_SYS_SPLICE] = {NULL, "DUNE_SYS_SPLICE"},
+       [DUNE_SYS_TEE] = {NULL, "DUNE_SYS_TEE"},
+       [DUNE_SYS_SYNC_FILE_RANGE] = {NULL, "DUNE_SYS_SYNC_FILE_RANGE"},
+       [DUNE_SYS_VMSPLICE] = {NULL, "DUNE_SYS_VMSPLICE"},
+       [DUNE_SYS_MOVE_PAGES] = {NULL, "DUNE_SYS_MOVE_PAGES"},
+       [DUNE_SYS_UTIMENSAT] = {NULL, "DUNE_SYS_UTIMENSAT"},
+       [DUNE_SYS_EPOLL_PWAIT] = {NULL, "DUNE_SYS_EPOLL_PWAIT"},
+       [DUNE_SYS_SIGNALFD] = {NULL, "DUNE_SYS_SIGNALFD"},
+       [DUNE_SYS_TIMERFD_CREATE] = {NULL, "DUNE_SYS_TIMERFD_CREATE"},
+       [DUNE_SYS_EVENTFD] = {NULL, "DUNE_SYS_EVENTFD"},
+       [DUNE_SYS_FALLOCATE] = {dune_sys_fallocate, "DUNE_SYS_FALLOCATE"},
+       [DUNE_SYS_TIMERFD_SETTIME] = {NULL, "DUNE_SYS_TIMERFD_SETTIME"},
+       [DUNE_SYS_TIMERFD_GETTIME] = {NULL, "DUNE_SYS_TIMERFD_GETTIME"},
+       [DUNE_SYS_ACCEPT4] = {NULL, "DUNE_SYS_ACCEPT4"},
+       [DUNE_SYS_SIGNALFD4] = {NULL, "DUNE_SYS_SIGNALFD4"},
+       [DUNE_SYS_EVENTFD2] = {NULL, "DUNE_SYS_EVENTFD2"},
+       [DUNE_SYS_EPOLL_CREATE1] = {dune_sys_epoll_create1,
+                                   "DUNE_SYS_EPOLL_CREATE1"},
+       [DUNE_SYS_DUP3] = {NULL, "DUNE_SYS_DUP3"},
+       [DUNE_SYS_PIPE2] = {NULL, "DUNE_SYS_PIPE2"},
+       [DUNE_SYS_INOTIFY_INIT1] = {NULL, "DUNE_SYS_INOTIFY_INIT1"},
+       [DUNE_SYS_PREADV] = {NULL, "DUNE_SYS_PREADV"},
+       [DUNE_SYS_PWRITEV] = {NULL, "DUNE_SYS_PWRITEV"},
+       [DUNE_SYS_RT_TGSIGQUEUEINFO] = {NULL, "DUNE_SYS_RT_TGSIGQUEUEINFO"},
+       [DUNE_SYS_PERF_EVENT_OPEN] = {NULL, "DUNE_SYS_PERF_EVENT_OPEN"},
+       [DUNE_SYS_RECVMMSG] = {NULL, "DUNE_SYS_RECVMMSG"},
+       [DUNE_SYS_FANOTIFY_INIT] = {NULL, "DUNE_SYS_FANOTIFY_INIT"},
+       [DUNE_SYS_FANOTIFY_MARK] = {NULL, "DUNE_SYS_FANOTIFY_MARK"},
+       [DUNE_SYS_PRLIMIT64] = {NULL, "DUNE_SYS_PRLIMIT64"},
+       [DUNE_SYS_NAME_TO_HANDLE_AT] = {NULL, "DUNE_SYS_NAME_TO_HANDLE_AT"},
+       [DUNE_SYS_OPEN_BY_HANDLE_AT] = {NULL, "DUNE_SYS_OPEN_BY_HANDLE_AT"},
+       [DUNE_SYS_CLOCK_ADJTIME] = {NULL, "DUNE_SYS_CLOCK_ADJTIME"},
+       [DUNE_SYS_SYNCFS] = {NULL, "DUNE_SYS_SYNCFS"},
+       [DUNE_SYS_SENDMMSG] = {NULL, "DUNE_SYS_SENDMMSG"},
+       [DUNE_SYS_SETNS] = {NULL, "DUNE_SYS_SETNS"},
+       [DUNE_SYS_GETCPU] = {NULL, "DUNE_SYS_GETCPU"},
+       [DUNE_SYS_PROCESS_VM_READV] = {NULL, "DUNE_SYS_PROCESS_VM_READV"},
+       [DUNE_SYS_PROCESS_VM_WRITEV] = {NULL, "DUNE_SYS_PROCESS_VM_WRITEV"},
+       [DUNE_SYS_KCMP] = {NULL, "DUNE_KCMP"},
+       [DUNE_SYS_FINIT_MODULE] = {NULL, "DUNE_SYS_FINIT_MODULE"},
+       [DUNE_SYS_SCHED_SETATTR] = {NULL, "DUNE_SYS_SCHED_SETATTR"},
+       [DUNE_SYS_SCHED_GETATTR] = {NULL, "DUNE_SYS_SCHED_GETATTR"},
+       [DUNE_SYS_RENAMEAT2] = {NULL, "DUNE_SYS_RENAMEAT2"},
+       [DUNE_SYS_SECCOMP] = {NULL, "DUNE_SYS_SECCOMP"},
+       [DUNE_SYS_GETRANDOM] = {dune_sys_getrandom, "DUNE_SYS_GETRANDOM"},
+       [DUNE_SYS_MEMFD_CREATE] = {NULL, "DUNE_SYS_MEMFD_CREATE"},
+       [DUNE_SYS_KEXEC_FILE_LOAD] = {NULL, "DUNE_SYS_KEXEC_FILE_LOAD"},
+       [DUNE_SYS_BPF] = {NULL, "DUNE_SYS_BPF"},
+       [DUNE_STUB_EXECVEAT] = {NULL, "DUNE_STUB_EXECVEAT"},
+       [DUNE_USERFAULTFD] = {NULL, "DUNE_USERFAULTFD"},
+       [DUNE_MEMBARRIER] = {NULL, "DUNE_MEMBARRIER"},
+       [DUNE_MLOCK2] = {NULL, "DUNE_MLOCK2"},
+       [DUNE_COPY_FILE_RANGE] = {NULL, "DUNE_COPY_FILE_RANGE"},
+       [DUNE_PREADV2] = {NULL, "DUNE_PREADV2"},
+       [DUNE_PWRITEV2] = {NULL, "DUNE_PWRITEV2"},
+
+};
+
+bool init_linuxemu(void)
+{
+       fd_table_lock = uth_mutex_alloc();
+       int i;
+
+       for (i = 0; i < DUNE_MAX_NUM_SYSCALLS ; ++i) {
+               if (dune_syscall_table[i].name == NULL)
+                       dune_syscall_table[i].name = "nosyscall";
+       }
+
+       if (dlopen("liblinuxemu_extend.so", RTLD_NOW) == NULL) {
+               fprintf(stderr,
+                       "Not using any syscall extensions\n Reason: %s\n",
+                       dlerror());
+               return false;
+       }
+
+       return true;
+}
+
+void lemuprint(const uint32_t tid, uint64_t syscall_number,
+               const bool isError, const char *fmt, ...)
+{
+       va_list valist;
+       const char *prefix = "[TID %d] %s: ";
+       bool double_logging = false;
+
+       // Do not use global variable as a check to acquire lock.
+       // make sure it is not changed during our acquire/release.
+       int debug = lemu_debug;
+
+       // If we are not going to log anything anyway, just bail out.
+       if (!(debug > 0 || isError))
+               return;
+
+       const char *syscall_name;
+
+       if (syscall_number >= DUNE_MAX_NUM_SYSCALLS)
+               panic("lemuprint: Illegal Syscall #%d!\n", syscall_number);
+       else
+               syscall_name = dune_syscall_table[syscall_number].name;
+
+       va_start(valist, fmt);
+
+       uth_mutex_lock(lemu_logging_lock);
+
+       // Print to stderr if debug level is sufficient
+       if (debug > 1) {
+               fprintf(stderr, prefix, tid, syscall_name);
+               vfprintf(stderr, fmt, valist);
+               // Checks if we will double log to stderr
+               if (lemu_global_logfile == stderr)
+                       double_logging = true;
+       }
+
+       // Log to the global logfile, if we defaulted the global logging to
+       // stderr then we don't want to log 2 times to stderr.
+       if (lemu_global_logfile != NULL && !double_logging) {
+               fprintf(lemu_global_logfile, prefix, tid, syscall_name);
+               vfprintf(lemu_global_logfile, fmt, valist);
+       }
+
+       uth_mutex_unlock(lemu_logging_lock);
+
+       va_end(valist);
+}
+
 
 /* TODO: have an array which classifies syscall args
  * and "special" system calls (ones with weird return
  * call, and in many cases we have to rearrange arguments
  * since Linux and Akaros don't share signatures, so this
  * gets tricky. */
-bool
-linuxemu(struct guest_thread *gth, struct vm_trapframe *tf)
+bool linuxemu(struct guest_thread *gth, struct vm_trapframe *tf)
 {
        bool ret = false;
 
-       fprintf(stderr, "vmcall(%s(%d), %p, %p, %p, %p, %p, %p);\n",
-               tf->tf_rax < 311 ? syscalls[tf->tf_rax] : "",
-               tf->tf_rax, tf->tf_rdi, tf->tf_rsi, tf->tf_rdx,
-               tf->tf_rcx, tf->tf_r8, tf->tf_r9);
+       if (tf->tf_rax >= DUNE_MAX_NUM_SYSCALLS) {
+               fprintf(stderr, "System call %d is out of range\n", tf->tf_rax);
+               return false;
+       }
+
 
-       tf->tf_rip += 3;
-       /* we don't do tic/tou checking here yet. */
-       switch (tf->tf_rax) {
-       default:
-               /* TODO: just return the error to the guest once we are done
-                * debugging this. */
-               fprintf(stderr, "System call %d is not implemented\n", tf->tf_rax);
-               //tf->tf_rax = -ENOSYS;
-               break;
-       case DUNE_SYS_GETTIMEOFDAY:
-               tf->tf_rax = gettimeofday((struct timeval*)tf->tf_rdi,
-                                         (struct timezone*)tf->tf_rsi);
-               ret = true;
-               break;
-       case DUNE_SYS_GETTID:
-               tf->tf_rax = 1;
-               ret = true;
-               break;
-       case DUNE_SYS_WRITE:
-               /* debug: write to stdout too for now. */
-               write(2, (void *)tf->tf_rsi, (size_t)tf->tf_rdx);
-               tf->tf_rax = write(tf->tf_rdi, (void *)tf->tf_rsi, (size_t)tf->tf_rdx);
-               ret = true;
-               break;
+       if (dune_syscall_table[tf->tf_rax].call == NULL) {
+               fprintf(stderr, "System call #%d (%s) is not implemented\n",
+                       tf->tf_rax, dune_syscall_table[tf->tf_rax].name);
+               return false;
        }
-       return ret;
+
+       lemuprint(tf->tf_guest_pcoreid, tf->tf_rax,
+                 false, "vmcall(%d, %p, %p, %p, %p, %p, %p);\n", tf->tf_rax,
+                 tf->tf_rdi, tf->tf_rsi, tf->tf_rdx, tf->tf_r10, tf->tf_r8,
+                 tf->tf_r9);
+
+       tf->tf_rip += 3;
+
+       return (dune_syscall_table[tf->tf_rax].call)(tf);
 }