#ifdef HAVE_SYS_WAIT_H
#include <sys/wait.h>
#endif
+#ifdef HAVE_SYS_STATVFS_H
+#include <sys/statvfs.h>
+#endif
+#ifdef HAVE_SYS_XATTR_H
+#include <sys/xattr.h>
+#endif
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
errno = EINVAL; return -1;
}
-int Mono_Posix_FromLockFlags (int x, int *r)
+int Mono_Posix_FromLockfCommand (int x, int *r)
{
*r = 0;
if (x == 0)
return 0;
- if (x == Mono_Posix_LockFlags_F_ULOCK)
+ if (x == Mono_Posix_LockfCommand_F_ULOCK)
#ifdef F_ULOCK
{*r = F_ULOCK; return 0;}
#else /* def F_ULOCK */
{errno = EINVAL; return -1;}
#endif /* ndef F_ULOCK */
- if (x == Mono_Posix_LockFlags_F_LOCK)
+ if (x == Mono_Posix_LockfCommand_F_LOCK)
#ifdef F_LOCK
{*r = F_LOCK; return 0;}
#else /* def F_LOCK */
{errno = EINVAL; return -1;}
#endif /* ndef F_LOCK */
- if (x == Mono_Posix_LockFlags_F_TLOCK)
+ if (x == Mono_Posix_LockfCommand_F_TLOCK)
#ifdef F_TLOCK
{*r = F_TLOCK; return 0;}
#else /* def F_TLOCK */
{errno = EINVAL; return -1;}
#endif /* ndef F_TLOCK */
- if (x == Mono_Posix_LockFlags_F_TEST)
+ if (x == Mono_Posix_LockfCommand_F_TEST)
#ifdef F_TEST
{*r = F_TEST; return 0;}
#else /* def F_TEST */
errno = EINVAL; return -1;
}
-int Mono_Posix_ToLockFlags (int x, int *r)
+int Mono_Posix_ToLockfCommand (int x, int *r)
{
*r = 0;
if (x == 0)
return 0;
#ifdef F_ULOCK
if (x == F_ULOCK)
- {*r = Mono_Posix_LockFlags_F_ULOCK; return 0;}
+ {*r = Mono_Posix_LockfCommand_F_ULOCK; return 0;}
#endif /* ndef F_ULOCK */
#ifdef F_LOCK
if (x == F_LOCK)
- {*r = Mono_Posix_LockFlags_F_LOCK; return 0;}
+ {*r = Mono_Posix_LockfCommand_F_LOCK; return 0;}
#endif /* ndef F_LOCK */
#ifdef F_TLOCK
if (x == F_TLOCK)
- {*r = Mono_Posix_LockFlags_F_TLOCK; return 0;}
+ {*r = Mono_Posix_LockfCommand_F_TLOCK; return 0;}
#endif /* ndef F_TLOCK */
#ifdef F_TEST
if (x == F_TEST)
- {*r = Mono_Posix_LockFlags_F_TEST; return 0;}
+ {*r = Mono_Posix_LockfCommand_F_TEST; return 0;}
#endif /* ndef F_TEST */
errno = EINVAL; return -1;
}
return 0;
}
+int Mono_Posix_FromXattrFlags (int x, int *r)
+{
+ *r = 0;
+ if (x == 0)
+ return 0;
+ if ((x & Mono_Posix_XattrFlags_XATTR_AUTO) == Mono_Posix_XattrFlags_XATTR_AUTO)
+#ifdef XATTR_AUTO
+ *r |= XATTR_AUTO;
+#else /* def XATTR_AUTO */
+ {errno = EINVAL; return -1;}
+#endif /* ndef XATTR_AUTO */
+ if ((x & Mono_Posix_XattrFlags_XATTR_CREATE) == Mono_Posix_XattrFlags_XATTR_CREATE)
+#ifdef XATTR_CREATE
+ *r |= XATTR_CREATE;
+#else /* def XATTR_CREATE */
+ {errno = EINVAL; return -1;}
+#endif /* ndef XATTR_CREATE */
+ if ((x & Mono_Posix_XattrFlags_XATTR_REPLACE) == Mono_Posix_XattrFlags_XATTR_REPLACE)
+#ifdef XATTR_REPLACE
+ *r |= XATTR_REPLACE;
+#else /* def XATTR_REPLACE */
+ {errno = EINVAL; return -1;}
+#endif /* ndef XATTR_REPLACE */
+ return 0;
+}
+
+int Mono_Posix_ToXattrFlags (int x, int *r)
+{
+ *r = 0;
+ if (x == 0)
+ return 0;
+#ifdef XATTR_AUTO
+ if ((x & XATTR_AUTO) == XATTR_AUTO)
+ *r |= Mono_Posix_XattrFlags_XATTR_AUTO;
+#endif /* ndef XATTR_AUTO */
+#ifdef XATTR_CREATE
+ if ((x & XATTR_CREATE) == XATTR_CREATE)
+ *r |= Mono_Posix_XattrFlags_XATTR_CREATE;
+#endif /* ndef XATTR_CREATE */
+#ifdef XATTR_REPLACE
+ if ((x & XATTR_REPLACE) == XATTR_REPLACE)
+ *r |= Mono_Posix_XattrFlags_XATTR_REPLACE;
+#endif /* ndef XATTR_REPLACE */
+ return 0;
+}
+
+int Mono_Posix_FromMountFlags (guint64 x, guint64 *r)
+{
+ *r = 0;
+ if (x == 0)
+ return 0;
+ if ((x & Mono_Posix_MountFlags_ST_RDONLY) == Mono_Posix_MountFlags_ST_RDONLY)
+#ifdef ST_RDONLY
+ *r |= ST_RDONLY;
+#else /* def ST_RDONLY */
+ {errno = EINVAL; return -1;}
+#endif /* ndef ST_RDONLY */
+ if ((x & Mono_Posix_MountFlags_ST_NOSUID) == Mono_Posix_MountFlags_ST_NOSUID)
+#ifdef ST_NOSUID
+ *r |= ST_NOSUID;
+#else /* def ST_NOSUID */
+ {errno = EINVAL; return -1;}
+#endif /* ndef ST_NOSUID */
+ if ((x & Mono_Posix_MountFlags_ST_NODEV) == Mono_Posix_MountFlags_ST_NODEV)
+#ifdef ST_NODEV
+ *r |= ST_NODEV;
+#else /* def ST_NODEV */
+ {errno = EINVAL; return -1;}
+#endif /* ndef ST_NODEV */
+ if ((x & Mono_Posix_MountFlags_ST_SYNCHRONOUS) == Mono_Posix_MountFlags_ST_SYNCHRONOUS)
+#ifdef ST_SYNCHRONOUS
+ *r |= ST_SYNCHRONOUS;
+#else /* def ST_SYNCHRONOUS */
+ {errno = EINVAL; return -1;}
+#endif /* ndef ST_SYNCHRONOUS */
+ if ((x & Mono_Posix_MountFlags_ST_MANDLOCK) == Mono_Posix_MountFlags_ST_MANDLOCK)
+#ifdef ST_MANDLOCK
+ *r |= ST_MANDLOCK;
+#else /* def ST_MANDLOCK */
+ {errno = EINVAL; return -1;}
+#endif /* ndef ST_MANDLOCK */
+ if ((x & Mono_Posix_MountFlags_ST_WRITE) == Mono_Posix_MountFlags_ST_WRITE)
+#ifdef ST_WRITE
+ *r |= ST_WRITE;
+#else /* def ST_WRITE */
+ {errno = EINVAL; return -1;}
+#endif /* ndef ST_WRITE */
+ if ((x & Mono_Posix_MountFlags_ST_APPEND) == Mono_Posix_MountFlags_ST_APPEND)
+#ifdef ST_APPEND
+ *r |= ST_APPEND;
+#else /* def ST_APPEND */
+ {errno = EINVAL; return -1;}
+#endif /* ndef ST_APPEND */
+ if ((x & Mono_Posix_MountFlags_ST_IMMUTABLE) == Mono_Posix_MountFlags_ST_IMMUTABLE)
+#ifdef ST_IMMUTABLE
+ *r |= ST_IMMUTABLE;
+#else /* def ST_IMMUTABLE */
+ {errno = EINVAL; return -1;}
+#endif /* ndef ST_IMMUTABLE */
+ if ((x & Mono_Posix_MountFlags_ST_NOATIME) == Mono_Posix_MountFlags_ST_NOATIME)
+#ifdef ST_NOATIME
+ *r |= ST_NOATIME;
+#else /* def ST_NOATIME */
+ {errno = EINVAL; return -1;}
+#endif /* ndef ST_NOATIME */
+ if ((x & Mono_Posix_MountFlags_ST_NODIRATIME) == Mono_Posix_MountFlags_ST_NODIRATIME)
+#ifdef ST_NODIRATIME
+ *r |= ST_NODIRATIME;
+#else /* def ST_NODIRATIME */
+ {errno = EINVAL; return -1;}
+#endif /* ndef ST_NODIRATIME */
+ return 0;
+}
+
+int Mono_Posix_ToMountFlags (guint64 x, guint64 *r)
+{
+ *r = 0;
+ if (x == 0)
+ return 0;
+#ifdef ST_RDONLY
+ if ((x & ST_RDONLY) == ST_RDONLY)
+ *r |= Mono_Posix_MountFlags_ST_RDONLY;
+#endif /* ndef ST_RDONLY */
+#ifdef ST_NOSUID
+ if ((x & ST_NOSUID) == ST_NOSUID)
+ *r |= Mono_Posix_MountFlags_ST_NOSUID;
+#endif /* ndef ST_NOSUID */
+#ifdef ST_NODEV
+ if ((x & ST_NODEV) == ST_NODEV)
+ *r |= Mono_Posix_MountFlags_ST_NODEV;
+#endif /* ndef ST_NODEV */
+#ifdef ST_SYNCHRONOUS
+ if ((x & ST_SYNCHRONOUS) == ST_SYNCHRONOUS)
+ *r |= Mono_Posix_MountFlags_ST_SYNCHRONOUS;
+#endif /* ndef ST_SYNCHRONOUS */
+#ifdef ST_MANDLOCK
+ if ((x & ST_MANDLOCK) == ST_MANDLOCK)
+ *r |= Mono_Posix_MountFlags_ST_MANDLOCK;
+#endif /* ndef ST_MANDLOCK */
+#ifdef ST_WRITE
+ if ((x & ST_WRITE) == ST_WRITE)
+ *r |= Mono_Posix_MountFlags_ST_WRITE;
+#endif /* ndef ST_WRITE */
+#ifdef ST_APPEND
+ if ((x & ST_APPEND) == ST_APPEND)
+ *r |= Mono_Posix_MountFlags_ST_APPEND;
+#endif /* ndef ST_APPEND */
+#ifdef ST_IMMUTABLE
+ if ((x & ST_IMMUTABLE) == ST_IMMUTABLE)
+ *r |= Mono_Posix_MountFlags_ST_IMMUTABLE;
+#endif /* ndef ST_IMMUTABLE */
+#ifdef ST_NOATIME
+ if ((x & ST_NOATIME) == ST_NOATIME)
+ *r |= Mono_Posix_MountFlags_ST_NOATIME;
+#endif /* ndef ST_NOATIME */
+#ifdef ST_NODIRATIME
+ if ((x & ST_NODIRATIME) == ST_NODIRATIME)
+ *r |= Mono_Posix_MountFlags_ST_NODIRATIME;
+#endif /* ndef ST_NODIRATIME */
+ 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;
+}
+
projects / mono.git / blobdiff