From 6256e57ba95951b33edf59073027ac2e24557e19 Mon Sep 17 00:00:00 2001
From: Ed Schouten <ed@FreeBSD.org>
Date: Fri, 17 Jul 2015 09:00:38 +0000
Subject: [PATCH] Implement CloudABI memory management system calls.

Add support for the <sys/mman.h> functions by wrapping around our own
implementations. There are no kern_*() variants of these system calls,
but we also don't need them in this case. It is sufficient to just call
into the sys_*() functions.

Differential Revision:	https://reviews.freebsd.org/D3033
Reviewed by:		brooks
---
 sys/compat/cloudabi/cloudabi_mem.c    | 118 +++++++++++++++++++++++---
 sys/contrib/cloudabi/syscalldefs_mi.h |   3 +
 2 files changed, 107 insertions(+), 14 deletions(-)

diff --git a/sys/compat/cloudabi/cloudabi_mem.c b/sys/compat/cloudabi/cloudabi_mem.c
index e519ed15be5b..5bc5a19adc68 100644
--- a/sys/compat/cloudabi/cloudabi_mem.c
+++ b/sys/compat/cloudabi/cloudabi_mem.c
@@ -26,64 +26,154 @@
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
+#include <sys/param.h>
+#include <sys/mman.h>
+#include <sys/sysproto.h>
+
 #include <compat/cloudabi/cloudabi_proto.h>
+#include <compat/cloudabi/cloudabi_syscalldefs.h>
+
+/* Converts CloudABI's memory protection flags to FreeBSD's. */
+static int
+convert_mprot(cloudabi_mprot_t in)
+{
+	int out;
+
+	out = 0;
+	if (in & CLOUDABI_PROT_EXEC)
+		out |= PROT_EXEC;
+	if (in & CLOUDABI_PROT_WRITE)
+		out |= PROT_WRITE;
+	if (in & CLOUDABI_PROT_READ)
+		out |= PROT_READ;
+	return (out);
+}
 
 int
 cloudabi_sys_mem_advise(struct thread *td,
     struct cloudabi_sys_mem_advise_args *uap)
 {
+	struct madvise_args madvise_args = {
+		.addr	= uap->addr,
+		.len	= uap->len
+	};
 
-	/* Not implemented. */
-	return (ENOSYS);
+	switch (uap->advice) {
+	case CLOUDABI_ADVICE_DONTNEED:
+		madvise_args.behav = MADV_DONTNEED;
+		break;
+	case CLOUDABI_ADVICE_NORMAL:
+		madvise_args.behav = MADV_NORMAL;
+		break;
+	case CLOUDABI_ADVICE_RANDOM:
+		madvise_args.behav = MADV_RANDOM;
+		break;
+	case CLOUDABI_ADVICE_SEQUENTIAL:
+		madvise_args.behav = MADV_SEQUENTIAL;
+		break;
+	case CLOUDABI_ADVICE_WILLNEED:
+		madvise_args.behav = MADV_WILLNEED;
+		break;
+	default:
+		return (EINVAL);
+	}
+
+	return (sys_madvise(td, &madvise_args));
 }
 
 int
 cloudabi_sys_mem_lock(struct thread *td, struct cloudabi_sys_mem_lock_args *uap)
 {
+	struct mlock_args mlock_args = {
+		.addr	= uap->addr,
+		.len	= uap->len
+	};
 
-	/* Not implemented. */
-	return (ENOSYS);
+	return (sys_mlock(td, &mlock_args));
 }
 
 int
 cloudabi_sys_mem_map(struct thread *td, struct cloudabi_sys_mem_map_args *uap)
 {
+	struct mmap_args mmap_args = {
+		.addr	= uap->addr,
+		.len	= uap->len,
+		.prot	= convert_mprot(uap->prot),
+		.fd	= uap->fd,
+		.pos	= uap->off
+	};
 
-	/* Not implemented. */
-	return (ENOSYS);
+	/* Translate flags. */
+	if (uap->flags & CLOUDABI_MAP_ANON)
+		mmap_args.flags |= MAP_ANON;
+	if (uap->flags & CLOUDABI_MAP_FIXED)
+		mmap_args.flags |= MAP_FIXED;
+	if (uap->flags & CLOUDABI_MAP_PRIVATE)
+		mmap_args.flags |= MAP_PRIVATE;
+	if (uap->flags & CLOUDABI_MAP_SHARED)
+		mmap_args.flags |= MAP_SHARED;
+
+	return (sys_mmap(td, &mmap_args));
 }
 
 int
 cloudabi_sys_mem_protect(struct thread *td,
     struct cloudabi_sys_mem_protect_args *uap)
 {
+	struct mprotect_args mprotect_args = {
+		.addr	= uap->addr,
+		.len	= uap->len,
+		.prot	= convert_mprot(uap->prot),
+	};
 
-	/* Not implemented. */
-	return (ENOSYS);
+	return (sys_mprotect(td, &mprotect_args));
 }
 
 int
 cloudabi_sys_mem_sync(struct thread *td, struct cloudabi_sys_mem_sync_args *uap)
 {
+	struct msync_args msync_args = {
+		.addr	= uap->addr,
+		.len	= uap->len,
+	};
 
-	/* Not implemented. */
-	return (ENOSYS);
+	/* Convert flags. */
+	switch (uap->flags & (CLOUDABI_MS_ASYNC | CLOUDABI_MS_SYNC)) {
+	case CLOUDABI_MS_ASYNC:
+		msync_args.flags |= MS_ASYNC;
+		break;
+	case CLOUDABI_MS_SYNC:
+		msync_args.flags |= MS_SYNC;
+		break;
+	default:
+		return (EINVAL);
+	}
+	if ((uap->flags & CLOUDABI_MS_INVALIDATE) != 0)
+		msync_args.flags |= MS_INVALIDATE;
+
+	return (sys_msync(td, &msync_args));
 }
 
 int
 cloudabi_sys_mem_unlock(struct thread *td,
     struct cloudabi_sys_mem_unlock_args *uap)
 {
+	struct munlock_args munlock_args = {
+		.addr	= uap->addr,
+		.len	= uap->len
+	};
 
-	/* Not implemented. */
-	return (ENOSYS);
+	return (sys_munlock(td, &munlock_args));
 }
 
 int
 cloudabi_sys_mem_unmap(struct thread *td,
     struct cloudabi_sys_mem_unmap_args *uap)
 {
+	struct munmap_args munmap_args = {
+		.addr	= uap->addr,
+		.len	= uap->len
+	};
 
-	/* Not implemented. */
-	return (ENOSYS);
+	return (sys_munmap(td, &munmap_args));
 }
diff --git a/sys/contrib/cloudabi/syscalldefs_mi.h b/sys/contrib/cloudabi/syscalldefs_mi.h
index 810c0f2349f0..151a3dcc59b9 100644
--- a/sys/contrib/cloudabi/syscalldefs_mi.h
+++ b/sys/contrib/cloudabi/syscalldefs_mi.h
@@ -216,6 +216,9 @@
 #define CLOUDABI_MAP_PRIVATE 0x4
 #define CLOUDABI_MAP_SHARED 0x8
 
+// File descriptor that must be passed in when using CLOUDABI_MAP_ANON.
+#define CLOUDABI_MAP_ANON_FD 0xffffffff
+
 // msync() flags.
 #define CLOUDABI_MS_ASYNC 0x1
 #define CLOUDABI_MS_INVALIDATE 0x2