Use dedicated pointer types in internal syscall layer. NFC

Author: kleisauke

system/lib/libc/emscripten_internal.h

@@ -76,9 +76,9 @@ int _mmap_js(size_t length,
              int* allocated,
              void** addr);
 int _munmap_js(
-  intptr_t addr, size_t length, int prot, int flags, int fd, off_t offset);
+  void *addr, size_t length, int prot, int flags, int fd, off_t offset);
 int _msync_js(
-  intptr_t addr, size_t length, int prot, int flags, int fd, off_t offset);
+  void *addr, size_t length, int prot, int flags, int fd, off_t offset);
 
 struct dso;
 

system/lib/libc/emscripten_mmap.c

@@ -35,10 +35,10 @@ struct map {
 static volatile int lock[1];
 static struct map* mappings;
 
-static struct map* find_mapping(intptr_t addr, struct map** prev) {
+static struct map* find_mapping(void *addr, struct map** prev) {
   struct map* map = mappings;
   while (map) {
-    if (map->addr == (void*)addr) {
+    if (map->addr == addr) {
       return map;
     }
     if (prev) {
@@ -49,7 +49,7 @@ static struct map* find_mapping(intptr_t addr, struct map** prev) {
   return map;
 }
 
-int __syscall_munmap(intptr_t addr, size_t length) {
+int __syscall_munmap(void *addr, size_t length) {
   LOCK(lock);
   struct map* prev = NULL;
   struct map* map = find_mapping(addr, &prev);
@@ -89,7 +89,7 @@ int __syscall_munmap(intptr_t addr, size_t length) {
   return 0;
 }
 
-int __syscall_msync(intptr_t addr, size_t len, int flags) {
+int __syscall_msync(void *addr, size_t len, int flags) {
   LOCK(lock);
   struct map* map = find_mapping(addr, NULL);
   UNLOCK(lock);
@@ -102,7 +102,7 @@ int __syscall_msync(intptr_t addr, size_t len, int flags) {
   return _msync_js(addr, len, map->prot, map->flags, map->fd, map->offset);
 }
 
-intptr_t __syscall_mmap2(intptr_t addr, size_t len, int prot, int flags, int fd, off_t offset) {
+void *__syscall_mmap2(void *addr, size_t len, int prot, int flags, int fd, off_t offset) {
   if (addr != 0) {
     // We don't currently support location hints for the address of the mapping
     return -EINVAL;
@@ -147,5 +147,5 @@ intptr_t __syscall_mmap2(intptr_t addr, size_t len, int prot, int flags, int fd,
   mappings = new_map;
   UNLOCK(lock);
 
-  return (long)new_map->addr;
+  return new_map->addr;
 }

system/lib/libc/emscripten_syscall_stubs.c

@@ -11,16 +11,10 @@
  * 3. Return ENOSYS and warn at runtime if called.
  */
 
+#define _GNU_SOURCE // for struct mmsghdr
 #include <errno.h>
-#include <stdio.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <syscall_arch.h>
 #include <string.h>
-#include <sys/resource.h>
-#include <sys/stat.h>
-#include <time.h>
-#include <sys/utsname.h>
+#include <syscall_arch.h>
 #include <emscripten/console.h>
 #include <emscripten/version.h>
 #include <emscripten/stack.h>
@@ -47,24 +41,22 @@ static mode_t g_umask = S_IWGRP | S_IWOTH;
 #define STRINGIFY(s) #s
 #define STR(s) STRINGIFY(s)
 
-weak int __syscall_uname(intptr_t buf) {
+weak int __syscall_uname(struct utsname *buf) {
   if (!buf) {
     return -EFAULT;
   }
   const char* full_version = STR(__EMSCRIPTEN_major__) "." \
                              STR(__EMSCRIPTEN_minor__) "." \
                              STR(__EMSCRIPTEN_tiny__);
 
-  struct utsname *utsname = (struct utsname *)buf;
-
-  strcpy(utsname->sysname, "Emscripten");
-  strcpy(utsname->nodename, "emscripten");
-  strcpy(utsname->release, full_version);
-  strcpy(utsname->version, "#1");
+  strcpy(buf->sysname, "Emscripten");
+  strcpy(buf->nodename, "emscripten");
+  strcpy(buf->release, full_version);
+  strcpy(buf->version, "#1");
 #ifdef __wasm64__
-  strcpy(utsname->machine, "wasm64");
+  strcpy(buf->machine, "wasm64");
 #else
-  strcpy(utsname->machine, "wasm32");
+  strcpy(buf->machine, "wasm32");
 #endif
   return 0;
 }
@@ -105,15 +97,15 @@ weak pid_t __syscall_getppid() {
   return g_ppid;
 }
 
-weak int __syscall_linkat(int olddirfd, intptr_t oldpath, int newdirfd, intptr_t newpath, int flags) {
+weak int __syscall_linkat(int olddirfd, const char *oldpath, int newdirfd, const char *newpath, int flags) {
   return -EMLINK; // no hardlinks for us
 }
 
-weak int __syscall_getgroups32(int count, intptr_t list) {
+weak int __syscall_getgroups32(int count, gid_t list[]) {
   if (count < 1) {
     return -EINVAL;
   }
-  ((gid_t*)list)[0] = 0;
+  list[0] = 0;
   return 1;
 }
 
@@ -134,7 +126,7 @@ struct kusage {
   long stime_tv_usec;
 };
 
-weak int __syscall_getrusage(int who, intptr_t usage) {
+weak int __syscall_getrusage(int who, void *usage) {
   REPORT(getrusage);
   struct kusage *u = (struct kusage*)usage;
   u->utime_tv_sec = 1;
@@ -152,7 +144,7 @@ weak int __syscall_setpriority(int which, id_t who, int prio) {
   return -EPERM;
 }
 
-weak int __syscall_setdomainname(intptr_t name, size_t size) {
+weak int __syscall_setdomainname(const char *name, size_t len) {
   return -EPERM;
 }
 
@@ -172,18 +164,18 @@ weak gid_t __syscall_getegid32(void) {
   return 0;
 }
 
-weak int __syscall_getresuid32(intptr_t ruid, intptr_t euid, intptr_t suid) {
-  *((uid_t *)ruid) = 0;
-  *((uid_t *)euid) = 0;
-  *((uid_t *)suid) = 0;
+weak int __syscall_getresuid32(uid_t *ruid, uid_t *euid, uid_t *suid) {
+  *ruid = 0;
+  *euid = 0;
+  *suid = 0;
   return 0;
 }
 
-weak int __syscall_getresgid32(intptr_t ruid, intptr_t euid, intptr_t suid) {
+weak int __syscall_getresgid32(gid_t *rgid, gid_t *egid, gid_t *sgid) {
   REPORT(getresgid32);
-  *((uid_t *)ruid) = 0;
-  *((uid_t *)euid) = 0;
-  *((uid_t *)suid) = 0;
+  *rgid = 0;
+  *egid = 0;
+  *sgid = 0;
   return 0;
 }
 
@@ -192,28 +184,28 @@ weak int __syscall_pause() {
   return -EINTR; // we can't pause
 }
 
-weak int __syscall_madvise(intptr_t addr, size_t length, int advice) {
+weak int __syscall_madvise(void *addr, size_t length, int advice) {
   REPORT(madvise);
   // advice is welcome, but ignored
   return 0;
 }
 
-weak int __syscall_mlock(intptr_t addr, size_t len) {
+weak int __syscall_mlock(const void *addr, size_t len) {
   REPORT(mlock);
   return 0;
 }
 
-weak int __syscall_munlock(intptr_t addr, size_t len) {
+weak int __syscall_munlock(const void *addr, size_t len) {
   REPORT(munlock);
   return 0;
 }
 
-weak int __syscall_mprotect(size_t addr, size_t len, int prot) {
+weak int __syscall_mprotect(size_t start, size_t len, int prot) {
   REPORT(mprotect);
   return 0; // let's not and say we did
 }
 
-weak int __syscall_mremap(intptr_t old_addr, size_t old_size, size_t new_size, int flags, intptr_t new_addr) {
+weak int __syscall_mremap(void *old_addr, size_t old_size, size_t new_size, int flags, void *new_addr) {
   REPORT(mremap);
   return -ENOMEM; // never succeed
 }
@@ -228,48 +220,47 @@ weak int __syscall_munlockall() {
   return 0;
 }
 
-weak int __syscall_prlimit64(pid_t pid, int resource, intptr_t new_limit, intptr_t old_limit) {
+weak int __syscall_prlimit64(pid_t pid, int resource, const struct rlimit *new_limit, struct rlimit *old_limit) {
   REPORT(prlimit64);
-  struct rlimit *old = (struct rlimit *)old_limit;
   if (new_limit) {
     return -EPERM;
   }
-  if (old) {
+  if (old_limit) {
     if (resource == RLIMIT_NOFILE) {
       // See FS.MAX_OPEN_FDS in src/lib/libfs.js
-      old->rlim_cur = 4096;
-      old->rlim_max = 4096;
+      old_limit->rlim_cur = 4096;
+      old_limit->rlim_max = 4096;
     } else if (resource == RLIMIT_STACK) {
       uintptr_t end = emscripten_stack_get_end();
       uintptr_t base = emscripten_stack_get_base();
 
-      old->rlim_cur = base - end;
+      old_limit->rlim_cur = base - end;
       // we can not change the stack size, so the maximum is the same as the current
-      old->rlim_max = base - end;
+      old_limit->rlim_max = base - end;
     } else {
       // Just report no limits
-      old->rlim_cur = RLIM_INFINITY;
-      old->rlim_max = RLIM_INFINITY;
+      old_limit->rlim_cur = RLIM_INFINITY;
+      old_limit->rlim_max = RLIM_INFINITY;
     }
   }
   return 0;
 }
 
-weak int __syscall_setsockopt(int sockfd, int level, int optname, intptr_t optval, socklen_t optlen, ...) {
+weak int __syscall_setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen, ...) {
   REPORT(setsockopt);
   return -ENOPROTOOPT; // The option is unknown at the level indicated.
 }
 
-weak pid_t __syscall_wait4(pid_t pid, intptr_t wstatus, int options, int rusage) {
+weak pid_t __syscall_wait4(pid_t pid, int *wstatus, int options, struct rusage *rusage) {
   REPORT(wait4);
   return (pid_t)-1;
 }
 
-UNIMPLEMENTED(acct, (intptr_t filename))
-UNIMPLEMENTED(mincore, (intptr_t addr, size_t length, intptr_t vec))
-UNIMPLEMENTED(pipe2, (intptr_t fds, int flags))
-UNIMPLEMENTED(pselect6, (int nfds, intptr_t readfds, intptr_t writefds, intptr_t exceptfds, intptr_t timeout, intptr_t sigmaks))
-UNIMPLEMENTED(recvmmsg, (int sockfd, intptr_t msgvec, unsigned int vlen, unsigned int flags, intptr_t timeout))
-UNIMPLEMENTED(sendmmsg, (int sockfd, intptr_t msgvec, unsigned int vlen, unsigned int flags))
+UNIMPLEMENTED(acct, (const char *filename))
+UNIMPLEMENTED(mincore, (void *addr, size_t length, unsigned char *vec))
+UNIMPLEMENTED(pipe2, (int pipefd[2], int flags))
+UNIMPLEMENTED(pselect6, (int nfds, fd_set *rfds, fd_set *wfds, fd_set *efds, const struct timespec *ts, const void *mask))
+UNIMPLEMENTED(recvmmsg, (int sockfd, struct mmsghdr *msgvec, unsigned int vlen, unsigned int flags, struct timespec *timeout))
+UNIMPLEMENTED(sendmmsg, (int sockfd, struct mmsghdr *msgvec, unsigned int vlen, unsigned int flags))
 UNIMPLEMENTED(shutdown, (int sockfd, int how, ...))
-UNIMPLEMENTED(socketpair, (int domain, int type, int protocol, intptr_t fds, ...))
+UNIMPLEMENTED(socketpair, (int domain, int type, int protocol, int fd[2], ...))