* sys-mman.c: Add wrappers for mmap, munmap, mprotect, msync, mlock,

	  munlock, mremap, mincore, remap_file_pages.
	* map-icalls.h: Update to latest shared interface.
	* map.c, map.h: Add {To,From} pairs for MmapFlags, MmapProt, MsyncFlags,
	  MlockallFlags, MremapFlags.
	* mph.h: Add mph_return_*_if_ssize_t_overflow macros.

svn path=/trunk/mono/; revision=45279

6 files changed, 520 insertions, 0 deletions

diff --git a/support/ChangeLog b/support/ChangeLog
index 65a696f8b58..7c1c8b10663 100644
--- a/support/ChangeLog
+++ b/support/ChangeLog
@@ -1,5 +1,14 @@
 2005-05-31  Jonathan Pryor  <jonpryor@vt.edu>
 
+	* sys-mman.c: Add wrappers for mmap, munmap, mprotect, msync, mlock,
+	  munlock, mremap, mincore, remap_file_pages.
+	* map-icalls.h: Update to latest shared interface.
+	* map.c, map.h: Add {To,From} pairs for MmapFlags, MmapProt, MsyncFlags,
+	  MlockallFlags, MremapFlags.
+	* mph.h: Add mph_return_*_if_ssize_t_overflow macros.
+
+2005-05-31  Jonathan Pryor  <jonpryor@vt.edu>
+
 	* unistd.c: Oops -- deal with s/LockFlags/LockfCommand/ change.
 
 2005-05-31  Jonathan Pryor  <jonpryor@vt.edu>
diff --git a/support/map-icalls.h b/support/map-icalls.h
index 9652aa6b9e1..98122454f77 100644
--- a/support/map-icalls.h
+++ b/support/map-icalls.h
@@ -37,7 +37,12 @@ int Mono_Posix_FromFcntlCommand (int value, int* rval);
 int Mono_Posix_FromFilePermissions (unsigned int value, unsigned int* rval);
 int Mono_Posix_FromLockType (short value, short* rval);
 int Mono_Posix_FromLockfCommand (int value, int* rval);
+int Mono_Posix_FromMlockallFlags (int value, int* rval);
+int Mono_Posix_FromMmapFlags (int value, int* rval);
+int Mono_Posix_FromMmapProt (int value, int* rval);
 int Mono_Posix_FromMountFlags (guint64 value, guint64* rval);
+int Mono_Posix_FromMremapFlags (guint64 value, guint64* rval);
+int Mono_Posix_FromMsyncFlags (int value, int* rval);
 int Mono_Posix_FromOpenFlags (int value, int* rval);
 int Mono_Posix_FromPathConf (int value, int* rval);
 int Mono_Posix_FromPollEvents (short value, short* rval);
@@ -134,7 +139,15 @@ int Mono_Posix_Syscall_lockf (int fd, int cmd, gint64 len);
 gint64 Mono_Posix_Syscall_lseek (int fd, gint64 offset, int whence);
 int Mono_Posix_Syscall_lsetxattr (const char* path, const char* name, void* value, guint64 size, int flags);
 int Mono_Posix_Syscall_lstat (const char* file_name, struct Mono_Posix_Stat* buf);
+int Mono_Posix_Syscall_mincore (void* start, guint64 length, void* vec);
 int Mono_Posix_Syscall_mknod (const char* pathname, unsigned int mode, guint64 dev);
+int Mono_Posix_Syscall_mlock (void* start, guint64 len);
+void* Mono_Posix_Syscall_mmap (void* start, guint64 length, int prot, int flags, int fd, gint64 offset);
+int Mono_Posix_Syscall_mprotect (void* start, guint64 len, int prot);
+void* Mono_Posix_Syscall_mremap (void* old_address, guint64 old_size, guint64 new_size, guint64 flags);
+int Mono_Posix_Syscall_msync (void* start, guint64 len, int flags);
+int Mono_Posix_Syscall_munlock (void* start, guint64 len);
+int Mono_Posix_Syscall_munmap (void* start, guint64 length);
 int Mono_Posix_Syscall_open (const char* pathname, int flags);
 int Mono_Posix_Syscall_open_mode (const char* pathname, int flags, unsigned int mode);
 gint64 Mono_Posix_Syscall_pathconf (const char* path, int name);
@@ -148,6 +161,7 @@ gint64 Mono_Posix_Syscall_read (int fd, void* buf, guint64 count);
 int Mono_Posix_Syscall_readdir (void* dir, struct Mono_Posix_Syscall__Dirent* dentry);
 int Mono_Posix_Syscall_readdir_r (void* dirp, struct Mono_Posix_Syscall__Dirent* entry, void** result);
 int Mono_Posix_Syscall_readlink (const char* path, char* buf, guint64 bufsiz);
+int Mono_Posix_Syscall_remap_file_pages (void* start, guint64 size, int prot, gint64 pgoff, int flags);
 int Mono_Posix_Syscall_seekdir (void* dir, gint64 offset);
 gint64 Mono_Posix_Syscall_sendfile (int out_fd, int in_fd, gint64* offset, guint64 count);
 int Mono_Posix_Syscall_setdomainname (const char* name, guint64 len);
@@ -178,7 +192,12 @@ int Mono_Posix_ToFcntlCommand (int value, int* rval);
 int Mono_Posix_ToFilePermissions (unsigned int value, unsigned int* rval);
 int Mono_Posix_ToLockType (short value, short* rval);
 int Mono_Posix_ToLockfCommand (int value, int* rval);
+int Mono_Posix_ToMlockallFlags (int value, int* rval);
+int Mono_Posix_ToMmapFlags (int value, int* rval);
+int Mono_Posix_ToMmapProt (int value, int* rval);
 int Mono_Posix_ToMountFlags (guint64 value, guint64* rval);
+int Mono_Posix_ToMremapFlags (guint64 value, guint64* rval);
+int Mono_Posix_ToMsyncFlags (int value, int* rval);
 int Mono_Posix_ToOpenFlags (int value, int* rval);
 int Mono_Posix_ToPathConf (int value, int* rval);
 int Mono_Posix_ToPollEvents (short value, short* rval);
diff --git a/support/map.c b/support/map.c
index a43e8addcc7..83551ad266e 100644
--- a/support/map.c
+++ b/support/map.c
@@ -6140,3 +6140,343 @@ int Mono_Posix_ToMountFlags (guint64 x, guint64 *r)
 	return 0;
 }
 
+int Mono_Posix_FromMmapFlags (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+	if ((x & Mono_Posix_MmapFlags_MAP_SHARED) == Mono_Posix_MmapFlags_MAP_SHARED)
+#ifdef MAP_SHARED
+		*r |= MAP_SHARED;
+#else /* def MAP_SHARED */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_SHARED */
+	if ((x & Mono_Posix_MmapFlags_MAP_PRIVATE) == Mono_Posix_MmapFlags_MAP_PRIVATE)
+#ifdef MAP_PRIVATE
+		*r |= MAP_PRIVATE;
+#else /* def MAP_PRIVATE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_PRIVATE */
+	if ((x & Mono_Posix_MmapFlags_MAP_TYPE) == Mono_Posix_MmapFlags_MAP_TYPE)
+#ifdef MAP_TYPE
+		*r |= MAP_TYPE;
+#else /* def MAP_TYPE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_TYPE */
+	if ((x & Mono_Posix_MmapFlags_MAP_FIXED) == Mono_Posix_MmapFlags_MAP_FIXED)
+#ifdef MAP_FIXED
+		*r |= MAP_FIXED;
+#else /* def MAP_FIXED */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_FIXED */
+	if ((x & Mono_Posix_MmapFlags_MAP_FILE) == Mono_Posix_MmapFlags_MAP_FILE)
+#ifdef MAP_FILE
+		*r |= MAP_FILE;
+#else /* def MAP_FILE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_FILE */
+	if ((x & Mono_Posix_MmapFlags_MAP_ANONYMOUS) == Mono_Posix_MmapFlags_MAP_ANONYMOUS)
+#ifdef MAP_ANONYMOUS
+		*r |= MAP_ANONYMOUS;
+#else /* def MAP_ANONYMOUS */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_ANONYMOUS */
+	if ((x & Mono_Posix_MmapFlags_MAP_ANON) == Mono_Posix_MmapFlags_MAP_ANON)
+#ifdef MAP_ANON
+		*r |= MAP_ANON;
+#else /* def MAP_ANON */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_ANON */
+	if ((x & Mono_Posix_MmapFlags_MAP_GROWSDOWN) == Mono_Posix_MmapFlags_MAP_GROWSDOWN)
+#ifdef MAP_GROWSDOWN
+		*r |= MAP_GROWSDOWN;
+#else /* def MAP_GROWSDOWN */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_GROWSDOWN */
+	if ((x & Mono_Posix_MmapFlags_MAP_DENYWRITE) == Mono_Posix_MmapFlags_MAP_DENYWRITE)
+#ifdef MAP_DENYWRITE
+		*r |= MAP_DENYWRITE;
+#else /* def MAP_DENYWRITE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_DENYWRITE */
+	if ((x & Mono_Posix_MmapFlags_MAP_EXECUTABLE) == Mono_Posix_MmapFlags_MAP_EXECUTABLE)
+#ifdef MAP_EXECUTABLE
+		*r |= MAP_EXECUTABLE;
+#else /* def MAP_EXECUTABLE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_EXECUTABLE */
+	if ((x & Mono_Posix_MmapFlags_MAP_LOCKED) == Mono_Posix_MmapFlags_MAP_LOCKED)
+#ifdef MAP_LOCKED
+		*r |= MAP_LOCKED;
+#else /* def MAP_LOCKED */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_LOCKED */
+	if ((x & Mono_Posix_MmapFlags_MAP_NORESERVE) == Mono_Posix_MmapFlags_MAP_NORESERVE)
+#ifdef MAP_NORESERVE
+		*r |= MAP_NORESERVE;
+#else /* def MAP_NORESERVE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_NORESERVE */
+	if ((x & Mono_Posix_MmapFlags_MAP_POPULATE) == Mono_Posix_MmapFlags_MAP_POPULATE)
+#ifdef MAP_POPULATE
+		*r |= MAP_POPULATE;
+#else /* def MAP_POPULATE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_POPULATE */
+	if ((x & Mono_Posix_MmapFlags_MAP_NONBLOCK) == Mono_Posix_MmapFlags_MAP_NONBLOCK)
+#ifdef MAP_NONBLOCK
+		*r |= MAP_NONBLOCK;
+#else /* def MAP_NONBLOCK */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MAP_NONBLOCK */
+	return 0;
+}
+
+int Mono_Posix_ToMmapFlags (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+#ifdef MAP_SHARED
+	if ((x & MAP_SHARED) == MAP_SHARED)
+		*r |= Mono_Posix_MmapFlags_MAP_SHARED;
+#endif /* ndef MAP_SHARED */
+#ifdef MAP_PRIVATE
+	if ((x & MAP_PRIVATE) == MAP_PRIVATE)
+		*r |= Mono_Posix_MmapFlags_MAP_PRIVATE;
+#endif /* ndef MAP_PRIVATE */
+#ifdef MAP_TYPE
+	if ((x & MAP_TYPE) == MAP_TYPE)
+		*r |= Mono_Posix_MmapFlags_MAP_TYPE;
+#endif /* ndef MAP_TYPE */
+#ifdef MAP_FIXED
+	if ((x & MAP_FIXED) == MAP_FIXED)
+		*r |= Mono_Posix_MmapFlags_MAP_FIXED;
+#endif /* ndef MAP_FIXED */
+#ifdef MAP_FILE
+	if ((x & MAP_FILE) == MAP_FILE)
+		*r |= Mono_Posix_MmapFlags_MAP_FILE;
+#endif /* ndef MAP_FILE */
+#ifdef MAP_ANONYMOUS
+	if ((x & MAP_ANONYMOUS) == MAP_ANONYMOUS)
+		*r |= Mono_Posix_MmapFlags_MAP_ANONYMOUS;
+#endif /* ndef MAP_ANONYMOUS */
+#ifdef MAP_ANON
+	if ((x & MAP_ANON) == MAP_ANON)
+		*r |= Mono_Posix_MmapFlags_MAP_ANON;
+#endif /* ndef MAP_ANON */
+#ifdef MAP_GROWSDOWN
+	if ((x & MAP_GROWSDOWN) == MAP_GROWSDOWN)
+		*r |= Mono_Posix_MmapFlags_MAP_GROWSDOWN;
+#endif /* ndef MAP_GROWSDOWN */
+#ifdef MAP_DENYWRITE
+	if ((x & MAP_DENYWRITE) == MAP_DENYWRITE)
+		*r |= Mono_Posix_MmapFlags_MAP_DENYWRITE;
+#endif /* ndef MAP_DENYWRITE */
+#ifdef MAP_EXECUTABLE
+	if ((x & MAP_EXECUTABLE) == MAP_EXECUTABLE)
+		*r |= Mono_Posix_MmapFlags_MAP_EXECUTABLE;
+#endif /* ndef MAP_EXECUTABLE */
+#ifdef MAP_LOCKED
+	if ((x & MAP_LOCKED) == MAP_LOCKED)
+		*r |= Mono_Posix_MmapFlags_MAP_LOCKED;
+#endif /* ndef MAP_LOCKED */
+#ifdef MAP_NORESERVE
+	if ((x & MAP_NORESERVE) == MAP_NORESERVE)
+		*r |= Mono_Posix_MmapFlags_MAP_NORESERVE;
+#endif /* ndef MAP_NORESERVE */
+#ifdef MAP_POPULATE
+	if ((x & MAP_POPULATE) == MAP_POPULATE)
+		*r |= Mono_Posix_MmapFlags_MAP_POPULATE;
+#endif /* ndef MAP_POPULATE */
+#ifdef MAP_NONBLOCK
+	if ((x & MAP_NONBLOCK) == MAP_NONBLOCK)
+		*r |= Mono_Posix_MmapFlags_MAP_NONBLOCK;
+#endif /* ndef MAP_NONBLOCK */
+	return 0;
+}
+
+int Mono_Posix_FromMmapProt (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+	if ((x & Mono_Posix_MmapProt_PROT_READ) == Mono_Posix_MmapProt_PROT_READ)
+#ifdef PROT_READ
+		*r |= PROT_READ;
+#else /* def PROT_READ */
+		{errno = EINVAL; return -1;}
+#endif /* ndef PROT_READ */
+	if ((x & Mono_Posix_MmapProt_PROT_WRITE) == Mono_Posix_MmapProt_PROT_WRITE)
+#ifdef PROT_WRITE
+		*r |= PROT_WRITE;
+#else /* def PROT_WRITE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef PROT_WRITE */
+	if ((x & Mono_Posix_MmapProt_PROT_EXEC) == Mono_Posix_MmapProt_PROT_EXEC)
+#ifdef PROT_EXEC
+		*r |= PROT_EXEC;
+#else /* def PROT_EXEC */
+		{errno = EINVAL; return -1;}
+#endif /* ndef PROT_EXEC */
+	if ((x & Mono_Posix_MmapProt_PROT_NONE) == Mono_Posix_MmapProt_PROT_NONE)
+#ifdef PROT_NONE
+		*r |= PROT_NONE;
+#else /* def PROT_NONE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef PROT_NONE */
+	if ((x & Mono_Posix_MmapProt_PROT_GROWSDOWN) == Mono_Posix_MmapProt_PROT_GROWSDOWN)
+#ifdef PROT_GROWSDOWN
+		*r |= PROT_GROWSDOWN;
+#else /* def PROT_GROWSDOWN */
+		{errno = EINVAL; return -1;}
+#endif /* ndef PROT_GROWSDOWN */
+	if ((x & Mono_Posix_MmapProt_PROT_GROWSUP) == Mono_Posix_MmapProt_PROT_GROWSUP)
+#ifdef PROT_GROWSUP
+		*r |= PROT_GROWSUP;
+#else /* def PROT_GROWSUP */
+		{errno = EINVAL; return -1;}
+#endif /* ndef PROT_GROWSUP */
+	return 0;
+}
+
+int Mono_Posix_ToMmapProt (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+#ifdef PROT_READ
+	if ((x & PROT_READ) == PROT_READ)
+		*r |= Mono_Posix_MmapProt_PROT_READ;
+#endif /* ndef PROT_READ */
+#ifdef PROT_WRITE
+	if ((x & PROT_WRITE) == PROT_WRITE)
+		*r |= Mono_Posix_MmapProt_PROT_WRITE;
+#endif /* ndef PROT_WRITE */
+#ifdef PROT_EXEC
+	if ((x & PROT_EXEC) == PROT_EXEC)
+		*r |= Mono_Posix_MmapProt_PROT_EXEC;
+#endif /* ndef PROT_EXEC */
+#ifdef PROT_NONE
+	if ((x & PROT_NONE) == PROT_NONE)
+		*r |= Mono_Posix_MmapProt_PROT_NONE;
+#endif /* ndef PROT_NONE */
+#ifdef PROT_GROWSDOWN
+	if ((x & PROT_GROWSDOWN) == PROT_GROWSDOWN)
+		*r |= Mono_Posix_MmapProt_PROT_GROWSDOWN;
+#endif /* ndef PROT_GROWSDOWN */
+#ifdef PROT_GROWSUP
+	if ((x & PROT_GROWSUP) == PROT_GROWSUP)
+		*r |= Mono_Posix_MmapProt_PROT_GROWSUP;
+#endif /* ndef PROT_GROWSUP */
+	return 0;
+}
+
+int Mono_Posix_FromMsyncFlags (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+	if ((x & Mono_Posix_MsyncFlags_MS_ASYNC) == Mono_Posix_MsyncFlags_MS_ASYNC)
+#ifdef MS_ASYNC
+		*r |= MS_ASYNC;
+#else /* def MS_ASYNC */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MS_ASYNC */
+	if ((x & Mono_Posix_MsyncFlags_MS_SYNC) == Mono_Posix_MsyncFlags_MS_SYNC)
+#ifdef MS_SYNC
+		*r |= MS_SYNC;
+#else /* def MS_SYNC */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MS_SYNC */
+	if ((x & Mono_Posix_MsyncFlags_MS_INVALIDATE) == Mono_Posix_MsyncFlags_MS_INVALIDATE)
+#ifdef MS_INVALIDATE
+		*r |= MS_INVALIDATE;
+#else /* def MS_INVALIDATE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MS_INVALIDATE */
+	return 0;
+}
+
+int Mono_Posix_ToMsyncFlags (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+#ifdef MS_ASYNC
+	if ((x & MS_ASYNC) == MS_ASYNC)
+		*r |= Mono_Posix_MsyncFlags_MS_ASYNC;
+#endif /* ndef MS_ASYNC */
+#ifdef MS_SYNC
+	if ((x & MS_SYNC) == MS_SYNC)
+		*r |= Mono_Posix_MsyncFlags_MS_SYNC;
+#endif /* ndef MS_SYNC */
+#ifdef MS_INVALIDATE
+	if ((x & MS_INVALIDATE) == MS_INVALIDATE)
+		*r |= Mono_Posix_MsyncFlags_MS_INVALIDATE;
+#endif /* ndef MS_INVALIDATE */
+	return 0;
+}
+
+int Mono_Posix_FromMlockallFlags (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+	if ((x & Mono_Posix_MlockallFlags_MCL_CURRENT) == Mono_Posix_MlockallFlags_MCL_CURRENT)
+#ifdef MCL_CURRENT
+		*r |= MCL_CURRENT;
+#else /* def MCL_CURRENT */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MCL_CURRENT */
+	if ((x & Mono_Posix_MlockallFlags_MCL_FUTURE) == Mono_Posix_MlockallFlags_MCL_FUTURE)
+#ifdef MCL_FUTURE
+		*r |= MCL_FUTURE;
+#else /* def MCL_FUTURE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MCL_FUTURE */
+	return 0;
+}
+
+int Mono_Posix_ToMlockallFlags (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+#ifdef MCL_CURRENT
+	if ((x & MCL_CURRENT) == MCL_CURRENT)
+		*r |= Mono_Posix_MlockallFlags_MCL_CURRENT;
+#endif /* ndef MCL_CURRENT */
+#ifdef MCL_FUTURE
+	if ((x & MCL_FUTURE) == MCL_FUTURE)
+		*r |= Mono_Posix_MlockallFlags_MCL_FUTURE;
+#endif /* ndef MCL_FUTURE */
+	return 0;
+}
+
+int Mono_Posix_FromMremapFlags (guint64 x, guint64 *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+	if ((x & Mono_Posix_MremapFlags_MREMAP_MAYMOVE) == Mono_Posix_MremapFlags_MREMAP_MAYMOVE)
+#ifdef MREMAP_MAYMOVE
+		*r |= MREMAP_MAYMOVE;
+#else /* def MREMAP_MAYMOVE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MREMAP_MAYMOVE */
+	return 0;
+}
+
+int Mono_Posix_ToMremapFlags (guint64 x, guint64 *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+#ifdef MREMAP_MAYMOVE
+	if ((x & MREMAP_MAYMOVE) == MREMAP_MAYMOVE)
+		*r |= Mono_Posix_MremapFlags_MREMAP_MAYMOVE;
+#endif /* ndef MREMAP_MAYMOVE */
+	return 0;
+}
+
diff --git a/support/map.h b/support/map.h
index 3f426fc7a9f..abfb9e76ce8 100644
--- a/support/map.h
+++ b/support/map.h
@@ -653,6 +653,47 @@ int Mono_Posix_ToXattrFlags (int x, int *r);
 int Mono_Posix_FromMountFlags (guint64 x, guint64 *r);
 int Mono_Posix_ToMountFlags (guint64 x, guint64 *r);
 
+#define Mono_Posix_MmapFlags_MAP_SHARED 0x00000001
+#define Mono_Posix_MmapFlags_MAP_PRIVATE 0x00000002
+#define Mono_Posix_MmapFlags_MAP_TYPE 0x0000000f
+#define Mono_Posix_MmapFlags_MAP_FIXED 0x00000010
+#define Mono_Posix_MmapFlags_MAP_FILE 0x00000000
+#define Mono_Posix_MmapFlags_MAP_ANONYMOUS 0x00000020
+#define Mono_Posix_MmapFlags_MAP_ANON 0x00000020
+#define Mono_Posix_MmapFlags_MAP_GROWSDOWN 0x00000100
+#define Mono_Posix_MmapFlags_MAP_DENYWRITE 0x00000800
+#define Mono_Posix_MmapFlags_MAP_EXECUTABLE 0x00001000
+#define Mono_Posix_MmapFlags_MAP_LOCKED 0x00002000
+#define Mono_Posix_MmapFlags_MAP_NORESERVE 0x00004000
+#define Mono_Posix_MmapFlags_MAP_POPULATE 0x00008000
+#define Mono_Posix_MmapFlags_MAP_NONBLOCK 0x00010000
+int Mono_Posix_FromMmapFlags (int x, int *r);
+int Mono_Posix_ToMmapFlags (int x, int *r);
+
+#define Mono_Posix_MmapProt_PROT_READ 0x00000001
+#define Mono_Posix_MmapProt_PROT_WRITE 0x00000002
+#define Mono_Posix_MmapProt_PROT_EXEC 0x00000004
+#define Mono_Posix_MmapProt_PROT_NONE 0x00000000
+#define Mono_Posix_MmapProt_PROT_GROWSDOWN 0x01000000
+#define Mono_Posix_MmapProt_PROT_GROWSUP 0x02000000
+int Mono_Posix_FromMmapProt (int x, int *r);
+int Mono_Posix_ToMmapProt (int x, int *r);
+
+#define Mono_Posix_MsyncFlags_MS_ASYNC 0x00000001
+#define Mono_Posix_MsyncFlags_MS_SYNC 0x00000004
+#define Mono_Posix_MsyncFlags_MS_INVALIDATE 0x00000002
+int Mono_Posix_FromMsyncFlags (int x, int *r);
+int Mono_Posix_ToMsyncFlags (int x, int *r);
+
+#define Mono_Posix_MlockallFlags_MCL_CURRENT 0x00000001
+#define Mono_Posix_MlockallFlags_MCL_FUTURE 0x00000002
+int Mono_Posix_FromMlockallFlags (int x, int *r);
+int Mono_Posix_ToMlockallFlags (int x, int *r);
+
+#define Mono_Posix_MremapFlags_MREMAP_MAYMOVE 0x00000001
+int Mono_Posix_FromMremapFlags (guint64 x, guint64 *r);
+int Mono_Posix_ToMremapFlags (guint64 x, guint64 *r);
+
 G_END_DECLS
 
 #endif /* ndef INC_Mono_Posix_map_H */
diff --git a/support/mph.h b/support/mph.h
index 6db796d77a9..0c8b37fdd93 100644
--- a/support/mph.h
+++ b/support/mph.h
@@ -110,8 +110,13 @@ typedef   guint64 mph_fsfilcnt_t;
 #define mph_return_val_if_size_t_overflow(var, ret) \
 	_mph_return_val_if_cb_(var, ret, mph_have_size_t_overflow)
 
+#define mph_return_val_if_ssize_t_overflow(var, ret) \
+	_mph_return_val_if_cb_(var, ret, mph_have_long_overflow)
+
 #define mph_return_if_size_t_overflow(var) mph_return_val_if_size_t_overflow(var, -1)
 
+#define mph_return_if_ssize_t_overflow(var) mph_return_val_if_ssize_t_overflow(var, -1)
+
 #define mph_have_off_t_overflow(var) \
 	(((var) < MPH_OFF_T_MIN) || ((var) > MPH_OFF_T_MAX))
 
diff --git a/support/sys-mman.c b/support/sys-mman.c
index 57b4e08c735..22ee678217a 100644
--- a/support/sys-mman.c
+++ b/support/sys-mman.c
@@ -18,6 +18,95 @@
 
 G_BEGIN_DECLS
 
+void*
+Mono_Posix_Syscall_mmap (void *start, mph_size_t length, int prot, int flags, 
+		int fd, mph_off_t offset)
+{
+	int _prot, _flags;
+
+	mph_return_val_if_size_t_overflow (length, MAP_FAILED);
+	mph_return_val_if_off_t_overflow (offset, MAP_FAILED);
+
+	if (Mono_Posix_FromMmapProt (prot, &_prot) == -1)
+		return MAP_FAILED;
+	if (Mono_Posix_FromMmapFlags (flags, &_flags) == -1)
+		return MAP_FAILED;
+
+	return mmap (start, (size_t) length, _prot, _flags, fd, (off_t) offset);
+}
+
+int
+Mono_Posix_Syscall_munmap (void *start, mph_size_t length)
+{
+	mph_return_if_size_t_overflow (length);
+
+	return munmap (start, (size_t) length);
+}
+
+int
+Mono_Posix_Syscall_mprotect (void *start, mph_size_t len, int prot)
+{
+	int _prot;
+	mph_return_if_size_t_overflow (len);
+
+	if (Mono_Posix_FromMmapProt (prot, &_prot) == -1)
+		return -1;
+
+	return mprotect (start, (size_t) len, _prot);
+}
+
+int
+Mono_Posix_Syscall_msync (void *start, mph_size_t len, int flags)
+{
+	int _flags;
+	mph_return_if_size_t_overflow (len);
+
+	if (Mono_Posix_FromMsyncFlags (flags, &_flags) == -1)
+		return -1;
+
+	return msync (start, (size_t) len, _flags);
+}
+
+int
+Mono_Posix_Syscall_mlock (void *start, mph_size_t len)
+{
+	mph_return_if_size_t_overflow (len);
+
+	return mlock (start, (size_t) len);
+}
+
+int
+Mono_Posix_Syscall_munlock (void *start, mph_size_t len)
+{
+	mph_return_if_size_t_overflow (len);
+
+	return munlock (start, (size_t) len);
+}
+
+void*
+Mono_Posix_Syscall_mremap (void *old_address, mph_size_t old_size, 
+		mph_size_t new_size, guint64 flags)
+{
+	guint64 _flags;
+
+	mph_return_val_if_size_t_overflow (old_size, MAP_FAILED);
+	mph_return_val_if_size_t_overflow (new_size, MAP_FAILED);
+
+	if (Mono_Posix_FromMremapFlags (flags, &_flags) == -1)
+		return MAP_FAILED;
+
+	return mremap (old_address, (size_t) old_size, (size_t) new_size,
+			(unsigned long) _flags);
+}
+
+int
+Mono_Posix_Syscall_mincore (void *start, mph_size_t length, void *vec)
+{
+	mph_return_if_size_t_overflow (length);
+
+	return mincore (start, (size_t) length, (unsigned char*) vec);
+}
+
 #ifdef HAVE_POSIX_MADVISE
 gint32
 Mono_Posix_Syscall_posix_madvise (void *addr, mph_size_t len, gint32 advice)
@@ -31,6 +120,23 @@ Mono_Posix_Syscall_posix_madvise (void *addr, mph_size_t len, gint32 advice)
 }
 #endif /* def HAVE_POSIX_MADVISE */
 
+int
+Mono_Posix_Syscall_remap_file_pages (void *start, mph_size_t size, 
+		int prot, mph_ssize_t pgoff, int flags)
+{
+	int _prot, _flags;
+
+	mph_return_if_size_t_overflow (size);
+	mph_return_if_ssize_t_overflow (pgoff);
+
+	if (Mono_Posix_FromMmapProt (prot, &_prot) == -1)
+		return -1;
+	if (Mono_Posix_FromMmapFlags (flags, &_flags) == -1)
+		return -1;
+
+	return remap_file_pages (start, (size_t) size, _prot, (ssize_t) pgoff, _flags);
+}
+
 G_END_DECLS
 
 /*