[Mono.Posix] Add support for memfd_create() and file sealing (#17225)

* [Mono.Posix] Add support for memfd_create() and file sealing

Add the linux syscall memfd_create() and add support for file sealing with
fcntl().

* Bump API snapshot submodule

2 files changed, 306 insertions, 0 deletions

diff --git a/support/map.c b/support/map.c
index 77fd729514c..8c55834e3c6 100644
--- a/support/map.c
+++ b/support/map.c
@@ -2633,6 +2633,12 @@ int Mono_Posix_ToErrno (int x, int *r)
 int Mono_Posix_FromFcntlCommand (int x, int *r)
 {
 	*r = 0;
+	if (x == Mono_Posix_FcntlCommand_F_ADD_SEALS)
+#ifdef F_ADD_SEALS
+		{*r = F_ADD_SEALS; return 0;}
+#else /* def F_ADD_SEALS */
+		{errno = EINVAL; return -1;}
+#endif /* ndef F_ADD_SEALS */
 	if (x == Mono_Posix_FcntlCommand_F_DUPFD)
 #ifdef F_DUPFD
 		{*r = F_DUPFD; return 0;}
@@ -2675,6 +2681,12 @@ int Mono_Posix_FromFcntlCommand (int x, int *r)
 #else /* def F_GETSIG */
 		{errno = EINVAL; return -1;}
 #endif /* ndef F_GETSIG */
+	if (x == Mono_Posix_FcntlCommand_F_GET_SEALS)
+#ifdef F_GET_SEALS
+		{*r = F_GET_SEALS; return 0;}
+#else /* def F_GET_SEALS */
+		{errno = EINVAL; return -1;}
+#endif /* ndef F_GET_SEALS */
 	if (x == Mono_Posix_FcntlCommand_F_NOCACHE)
 #ifdef F_NOCACHE
 		{*r = F_NOCACHE; return 0;}
@@ -2757,6 +2769,10 @@ int Mono_Posix_ToFcntlCommand (int x, int *r)
 	*r = 0;
 	if (x == 0)
 		return 0;
+#ifdef F_ADD_SEALS
+	if (x == F_ADD_SEALS)
+		{*r = Mono_Posix_FcntlCommand_F_ADD_SEALS; return 0;}
+#endif /* ndef F_ADD_SEALS */
 #ifdef F_DUPFD
 	if (x == F_DUPFD)
 		{*r = Mono_Posix_FcntlCommand_F_DUPFD; return 0;}
@@ -2785,6 +2801,10 @@ int Mono_Posix_ToFcntlCommand (int x, int *r)
 	if (x == F_GETSIG)
 		{*r = Mono_Posix_FcntlCommand_F_GETSIG; return 0;}
 #endif /* ndef F_GETSIG */
+#ifdef F_GET_SEALS
+	if (x == F_GET_SEALS)
+		{*r = Mono_Posix_FcntlCommand_F_GET_SEALS; return 0;}
+#endif /* ndef F_GET_SEALS */
 #ifdef F_NOCACHE
 	if (x == F_NOCACHE)
 		{*r = Mono_Posix_FcntlCommand_F_NOCACHE; return 0;}
@@ -3330,6 +3350,172 @@ int Mono_Posix_ToLockfCommand (int x, int *r)
 	errno = EINVAL; return -1;
 }
 
+int Mono_Posix_FromMemfdFlags (unsigned int x, unsigned int *r)
+{
+	*r = 0;
+	if ((x & Mono_Posix_MemfdFlags_MFD_ALLOW_SEALING) == Mono_Posix_MemfdFlags_MFD_ALLOW_SEALING)
+#ifdef MFD_ALLOW_SEALING
+		*r |= MFD_ALLOW_SEALING;
+#else /* def MFD_ALLOW_SEALING */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MFD_ALLOW_SEALING */
+	if ((x & Mono_Posix_MemfdFlags_MFD_CLOEXEC) == Mono_Posix_MemfdFlags_MFD_CLOEXEC)
+#ifdef MFD_CLOEXEC
+		*r |= MFD_CLOEXEC;
+#else /* def MFD_CLOEXEC */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MFD_CLOEXEC */
+	if ((x & Mono_Posix_MemfdFlags_MFD_HUGETLB) == Mono_Posix_MemfdFlags_MFD_HUGETLB)
+#ifdef MFD_HUGETLB
+		*r |= MFD_HUGETLB;
+#else /* def MFD_HUGETLB */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MFD_HUGETLB */
+	if ((x & Mono_Posix_MemfdFlags_MFD_HUGE_16GB) == Mono_Posix_MemfdFlags_MFD_HUGE_16GB)
+#ifdef MFD_HUGE_16GB
+		*r |= MFD_HUGE_16GB;
+#else /* def MFD_HUGE_16GB */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MFD_HUGE_16GB */
+	if ((x & Mono_Posix_MemfdFlags_MFD_HUGE_16MB) == Mono_Posix_MemfdFlags_MFD_HUGE_16MB)
+#ifdef MFD_HUGE_16MB
+		*r |= MFD_HUGE_16MB;
+#else /* def MFD_HUGE_16MB */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MFD_HUGE_16MB */
+	if ((x & Mono_Posix_MemfdFlags_MFD_HUGE_1GB) == Mono_Posix_MemfdFlags_MFD_HUGE_1GB)
+#ifdef MFD_HUGE_1GB
+		*r |= MFD_HUGE_1GB;
+#else /* def MFD_HUGE_1GB */
+		{/* Ignoring Mono_Posix_MemfdFlags_MFD_HUGE_1GB, as it is constructed from other values */}
+#endif /* ndef MFD_HUGE_1GB */
+	if ((x & Mono_Posix_MemfdFlags_MFD_HUGE_1MB) == Mono_Posix_MemfdFlags_MFD_HUGE_1MB)
+#ifdef MFD_HUGE_1MB
+		*r |= MFD_HUGE_1MB;
+#else /* def MFD_HUGE_1MB */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MFD_HUGE_1MB */
+	if ((x & Mono_Posix_MemfdFlags_MFD_HUGE_256MB) == Mono_Posix_MemfdFlags_MFD_HUGE_256MB)
+#ifdef MFD_HUGE_256MB
+		*r |= MFD_HUGE_256MB;
+#else /* def MFD_HUGE_256MB */
+		{/* Ignoring Mono_Posix_MemfdFlags_MFD_HUGE_256MB, as it is constructed from other values */}
+#endif /* ndef MFD_HUGE_256MB */
+	if ((x & Mono_Posix_MemfdFlags_MFD_HUGE_2GB) == Mono_Posix_MemfdFlags_MFD_HUGE_2GB)
+#ifdef MFD_HUGE_2GB
+		*r |= MFD_HUGE_2GB;
+#else /* def MFD_HUGE_2GB */
+		{/* Ignoring Mono_Posix_MemfdFlags_MFD_HUGE_2GB, as it is constructed from other values */}
+#endif /* ndef MFD_HUGE_2GB */
+	if ((x & Mono_Posix_MemfdFlags_MFD_HUGE_2MB) == Mono_Posix_MemfdFlags_MFD_HUGE_2MB)
+#ifdef MFD_HUGE_2MB
+		*r |= MFD_HUGE_2MB;
+#else /* def MFD_HUGE_2MB */
+		{/* Ignoring Mono_Posix_MemfdFlags_MFD_HUGE_2MB, as it is constructed from other values */}
+#endif /* ndef MFD_HUGE_2MB */
+	if ((x & Mono_Posix_MemfdFlags_MFD_HUGE_32MB) == Mono_Posix_MemfdFlags_MFD_HUGE_32MB)
+#ifdef MFD_HUGE_32MB
+		*r |= MFD_HUGE_32MB;
+#else /* def MFD_HUGE_32MB */
+		{/* Ignoring Mono_Posix_MemfdFlags_MFD_HUGE_32MB, as it is constructed from other values */}
+#endif /* ndef MFD_HUGE_32MB */
+	if ((x & Mono_Posix_MemfdFlags_MFD_HUGE_512KB) == Mono_Posix_MemfdFlags_MFD_HUGE_512KB)
+#ifdef MFD_HUGE_512KB
+		*r |= MFD_HUGE_512KB;
+#else /* def MFD_HUGE_512KB */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MFD_HUGE_512KB */
+	if ((x & Mono_Posix_MemfdFlags_MFD_HUGE_512MB) == Mono_Posix_MemfdFlags_MFD_HUGE_512MB)
+#ifdef MFD_HUGE_512MB
+		*r |= MFD_HUGE_512MB;
+#else /* def MFD_HUGE_512MB */
+		{/* Ignoring Mono_Posix_MemfdFlags_MFD_HUGE_512MB, as it is constructed from other values */}
+#endif /* ndef MFD_HUGE_512MB */
+	if ((x & Mono_Posix_MemfdFlags_MFD_HUGE_64KB) == Mono_Posix_MemfdFlags_MFD_HUGE_64KB)
+#ifdef MFD_HUGE_64KB
+		*r |= MFD_HUGE_64KB;
+#else /* def MFD_HUGE_64KB */
+		{errno = EINVAL; return -1;}
+#endif /* ndef MFD_HUGE_64KB */
+	if ((x & Mono_Posix_MemfdFlags_MFD_HUGE_8MB) == Mono_Posix_MemfdFlags_MFD_HUGE_8MB)
+#ifdef MFD_HUGE_8MB
+		*r |= MFD_HUGE_8MB;
+#else /* def MFD_HUGE_8MB */
+		{/* Ignoring Mono_Posix_MemfdFlags_MFD_HUGE_8MB, as it is constructed from other values */}
+#endif /* ndef MFD_HUGE_8MB */
+	if (x == 0)
+		return 0;
+	return 0;
+}
+
+int Mono_Posix_ToMemfdFlags (unsigned int x, unsigned int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+#ifdef MFD_ALLOW_SEALING
+	if ((x & MFD_ALLOW_SEALING) == MFD_ALLOW_SEALING)
+		*r |= Mono_Posix_MemfdFlags_MFD_ALLOW_SEALING;
+#endif /* ndef MFD_ALLOW_SEALING */
+#ifdef MFD_CLOEXEC
+	if ((x & MFD_CLOEXEC) == MFD_CLOEXEC)
+		*r |= Mono_Posix_MemfdFlags_MFD_CLOEXEC;
+#endif /* ndef MFD_CLOEXEC */
+#ifdef MFD_HUGETLB
+	if ((x & MFD_HUGETLB) == MFD_HUGETLB)
+		*r |= Mono_Posix_MemfdFlags_MFD_HUGETLB;
+#endif /* ndef MFD_HUGETLB */
+#ifdef MFD_HUGE_16GB
+	if ((x & MFD_HUGE_16GB) == MFD_HUGE_16GB)
+		*r |= Mono_Posix_MemfdFlags_MFD_HUGE_16GB;
+#endif /* ndef MFD_HUGE_16GB */
+#ifdef MFD_HUGE_16MB
+	if ((x & MFD_HUGE_16MB) == MFD_HUGE_16MB)
+		*r |= Mono_Posix_MemfdFlags_MFD_HUGE_16MB;
+#endif /* ndef MFD_HUGE_16MB */
+#ifdef MFD_HUGE_1GB
+	if ((x & MFD_HUGE_1GB) == MFD_HUGE_1GB)
+		*r |= Mono_Posix_MemfdFlags_MFD_HUGE_1GB;
+#endif /* ndef MFD_HUGE_1GB */
+#ifdef MFD_HUGE_1MB
+	if ((x & MFD_HUGE_1MB) == MFD_HUGE_1MB)
+		*r |= Mono_Posix_MemfdFlags_MFD_HUGE_1MB;
+#endif /* ndef MFD_HUGE_1MB */
+#ifdef MFD_HUGE_256MB
+	if ((x & MFD_HUGE_256MB) == MFD_HUGE_256MB)
+		*r |= Mono_Posix_MemfdFlags_MFD_HUGE_256MB;
+#endif /* ndef MFD_HUGE_256MB */
+#ifdef MFD_HUGE_2GB
+	if ((x & MFD_HUGE_2GB) == MFD_HUGE_2GB)
+		*r |= Mono_Posix_MemfdFlags_MFD_HUGE_2GB;
+#endif /* ndef MFD_HUGE_2GB */
+#ifdef MFD_HUGE_2MB
+	if ((x & MFD_HUGE_2MB) == MFD_HUGE_2MB)
+		*r |= Mono_Posix_MemfdFlags_MFD_HUGE_2MB;
+#endif /* ndef MFD_HUGE_2MB */
+#ifdef MFD_HUGE_32MB
+	if ((x & MFD_HUGE_32MB) == MFD_HUGE_32MB)
+		*r |= Mono_Posix_MemfdFlags_MFD_HUGE_32MB;
+#endif /* ndef MFD_HUGE_32MB */
+#ifdef MFD_HUGE_512KB
+	if ((x & MFD_HUGE_512KB) == MFD_HUGE_512KB)
+		*r |= Mono_Posix_MemfdFlags_MFD_HUGE_512KB;
+#endif /* ndef MFD_HUGE_512KB */
+#ifdef MFD_HUGE_512MB
+	if ((x & MFD_HUGE_512MB) == MFD_HUGE_512MB)
+		*r |= Mono_Posix_MemfdFlags_MFD_HUGE_512MB;
+#endif /* ndef MFD_HUGE_512MB */
+#ifdef MFD_HUGE_64KB
+	if ((x & MFD_HUGE_64KB) == MFD_HUGE_64KB)
+		*r |= Mono_Posix_MemfdFlags_MFD_HUGE_64KB;
+#endif /* ndef MFD_HUGE_64KB */
+#ifdef MFD_HUGE_8MB
+	if ((x & MFD_HUGE_8MB) == MFD_HUGE_8MB)
+		*r |= Mono_Posix_MemfdFlags_MFD_HUGE_8MB;
+#endif /* ndef MFD_HUGE_8MB */
+	return 0;
+}
+
 int Mono_Posix_FromMessageFlags (int x, int *r)
 {
 	*r = 0;
@@ -4718,6 +4904,72 @@ int Mono_Posix_ToPosixMadviseAdvice (int x, int *r)
 	errno = EINVAL; return -1;
 }
 
+int Mono_Posix_FromSealType (int x, int *r)
+{
+	*r = 0;
+	if ((x & Mono_Posix_SealType_F_SEAL_FUTURE_WRITE) == Mono_Posix_SealType_F_SEAL_FUTURE_WRITE)
+#ifdef F_SEAL_FUTURE_WRITE
+		*r |= F_SEAL_FUTURE_WRITE;
+#else /* def F_SEAL_FUTURE_WRITE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef F_SEAL_FUTURE_WRITE */
+	if ((x & Mono_Posix_SealType_F_SEAL_GROW) == Mono_Posix_SealType_F_SEAL_GROW)
+#ifdef F_SEAL_GROW
+		*r |= F_SEAL_GROW;
+#else /* def F_SEAL_GROW */
+		{errno = EINVAL; return -1;}
+#endif /* ndef F_SEAL_GROW */
+	if ((x & Mono_Posix_SealType_F_SEAL_SEAL) == Mono_Posix_SealType_F_SEAL_SEAL)
+#ifdef F_SEAL_SEAL
+		*r |= F_SEAL_SEAL;
+#else /* def F_SEAL_SEAL */
+		{errno = EINVAL; return -1;}
+#endif /* ndef F_SEAL_SEAL */
+	if ((x & Mono_Posix_SealType_F_SEAL_SHRINK) == Mono_Posix_SealType_F_SEAL_SHRINK)
+#ifdef F_SEAL_SHRINK
+		*r |= F_SEAL_SHRINK;
+#else /* def F_SEAL_SHRINK */
+		{errno = EINVAL; return -1;}
+#endif /* ndef F_SEAL_SHRINK */
+	if ((x & Mono_Posix_SealType_F_SEAL_WRITE) == Mono_Posix_SealType_F_SEAL_WRITE)
+#ifdef F_SEAL_WRITE
+		*r |= F_SEAL_WRITE;
+#else /* def F_SEAL_WRITE */
+		{errno = EINVAL; return -1;}
+#endif /* ndef F_SEAL_WRITE */
+	if (x == 0)
+		return 0;
+	return 0;
+}
+
+int Mono_Posix_ToSealType (int x, int *r)
+{
+	*r = 0;
+	if (x == 0)
+		return 0;
+#ifdef F_SEAL_FUTURE_WRITE
+	if ((x & F_SEAL_FUTURE_WRITE) == F_SEAL_FUTURE_WRITE)
+		*r |= Mono_Posix_SealType_F_SEAL_FUTURE_WRITE;
+#endif /* ndef F_SEAL_FUTURE_WRITE */
+#ifdef F_SEAL_GROW
+	if ((x & F_SEAL_GROW) == F_SEAL_GROW)
+		*r |= Mono_Posix_SealType_F_SEAL_GROW;
+#endif /* ndef F_SEAL_GROW */
+#ifdef F_SEAL_SEAL
+	if ((x & F_SEAL_SEAL) == F_SEAL_SEAL)
+		*r |= Mono_Posix_SealType_F_SEAL_SEAL;
+#endif /* ndef F_SEAL_SEAL */
+#ifdef F_SEAL_SHRINK
+	if ((x & F_SEAL_SHRINK) == F_SEAL_SHRINK)
+		*r |= Mono_Posix_SealType_F_SEAL_SHRINK;
+#endif /* ndef F_SEAL_SHRINK */
+#ifdef F_SEAL_WRITE
+	if ((x & F_SEAL_WRITE) == F_SEAL_WRITE)
+		*r |= Mono_Posix_SealType_F_SEAL_WRITE;
+#endif /* ndef F_SEAL_WRITE */
+	return 0;
+}
+
 int Mono_Posix_FromSeekFlags (short x, short *r)
 {
 	*r = 0;
diff --git a/support/map.h b/support/map.h
index 347de214f46..3ed8a93efd6 100644
--- a/support/map.h
+++ b/support/map.h
@@ -504,6 +504,8 @@ int Mono_Posix_FromErrno (int x, int *r);
 int Mono_Posix_ToErrno (int x, int *r);
 
 enum Mono_Posix_FcntlCommand {
+	Mono_Posix_FcntlCommand_F_ADD_SEALS        = 0x00000409,
+	#define Mono_Posix_FcntlCommand_F_ADD_SEALS  Mono_Posix_FcntlCommand_F_ADD_SEALS
 	Mono_Posix_FcntlCommand_F_DUPFD            = 0x00000000,
 	#define Mono_Posix_FcntlCommand_F_DUPFD      Mono_Posix_FcntlCommand_F_DUPFD
 	Mono_Posix_FcntlCommand_F_GETFD            = 0x00000001,
@@ -518,6 +520,8 @@ enum Mono_Posix_FcntlCommand {
 	#define Mono_Posix_FcntlCommand_F_GETOWN     Mono_Posix_FcntlCommand_F_GETOWN
 	Mono_Posix_FcntlCommand_F_GETSIG           = 0x0000000b,
 	#define Mono_Posix_FcntlCommand_F_GETSIG     Mono_Posix_FcntlCommand_F_GETSIG
+	Mono_Posix_FcntlCommand_F_GET_SEALS        = 0x0000040a,
+	#define Mono_Posix_FcntlCommand_F_GET_SEALS  Mono_Posix_FcntlCommand_F_GET_SEALS
 	Mono_Posix_FcntlCommand_F_NOCACHE          = 0x00000030,
 	#define Mono_Posix_FcntlCommand_F_NOCACHE    Mono_Posix_FcntlCommand_F_NOCACHE
 	Mono_Posix_FcntlCommand_F_NOTIFY           = 0x00000402,
@@ -627,6 +631,41 @@ enum Mono_Posix_LockfCommand {
 int Mono_Posix_FromLockfCommand (int x, int *r);
 int Mono_Posix_ToLockfCommand (int x, int *r);
 
+enum Mono_Posix_MemfdFlags {
+	Mono_Posix_MemfdFlags_MFD_ALLOW_SEALING       = 0x00000002,
+	#define Mono_Posix_MemfdFlags_MFD_ALLOW_SEALING Mono_Posix_MemfdFlags_MFD_ALLOW_SEALING
+	Mono_Posix_MemfdFlags_MFD_CLOEXEC             = 0x00000001,
+	#define Mono_Posix_MemfdFlags_MFD_CLOEXEC       Mono_Posix_MemfdFlags_MFD_CLOEXEC
+	Mono_Posix_MemfdFlags_MFD_HUGETLB             = 0x00000004,
+	#define Mono_Posix_MemfdFlags_MFD_HUGETLB       Mono_Posix_MemfdFlags_MFD_HUGETLB
+	Mono_Posix_MemfdFlags_MFD_HUGE_16GB           = 0x88000000,
+	#define Mono_Posix_MemfdFlags_MFD_HUGE_16GB     Mono_Posix_MemfdFlags_MFD_HUGE_16GB
+	Mono_Posix_MemfdFlags_MFD_HUGE_16MB           = 0x60000000,
+	#define Mono_Posix_MemfdFlags_MFD_HUGE_16MB     Mono_Posix_MemfdFlags_MFD_HUGE_16MB
+	Mono_Posix_MemfdFlags_MFD_HUGE_1GB            = 0x78000000,
+	#define Mono_Posix_MemfdFlags_MFD_HUGE_1GB      Mono_Posix_MemfdFlags_MFD_HUGE_1GB
+	Mono_Posix_MemfdFlags_MFD_HUGE_1MB            = 0x50000000,
+	#define Mono_Posix_MemfdFlags_MFD_HUGE_1MB      Mono_Posix_MemfdFlags_MFD_HUGE_1MB
+	Mono_Posix_MemfdFlags_MFD_HUGE_256MB          = 0x70000000,
+	#define Mono_Posix_MemfdFlags_MFD_HUGE_256MB    Mono_Posix_MemfdFlags_MFD_HUGE_256MB
+	Mono_Posix_MemfdFlags_MFD_HUGE_2GB            = 0x7c000000,
+	#define Mono_Posix_MemfdFlags_MFD_HUGE_2GB      Mono_Posix_MemfdFlags_MFD_HUGE_2GB
+	Mono_Posix_MemfdFlags_MFD_HUGE_2MB            = 0x54000000,
+	#define Mono_Posix_MemfdFlags_MFD_HUGE_2MB      Mono_Posix_MemfdFlags_MFD_HUGE_2MB
+	Mono_Posix_MemfdFlags_MFD_HUGE_32MB           = 0x64000000,
+	#define Mono_Posix_MemfdFlags_MFD_HUGE_32MB     Mono_Posix_MemfdFlags_MFD_HUGE_32MB
+	Mono_Posix_MemfdFlags_MFD_HUGE_512KB          = 0x4c000000,
+	#define Mono_Posix_MemfdFlags_MFD_HUGE_512KB    Mono_Posix_MemfdFlags_MFD_HUGE_512KB
+	Mono_Posix_MemfdFlags_MFD_HUGE_512MB          = 0x74000000,
+	#define Mono_Posix_MemfdFlags_MFD_HUGE_512MB    Mono_Posix_MemfdFlags_MFD_HUGE_512MB
+	Mono_Posix_MemfdFlags_MFD_HUGE_64KB           = 0x40000000,
+	#define Mono_Posix_MemfdFlags_MFD_HUGE_64KB     Mono_Posix_MemfdFlags_MFD_HUGE_64KB
+	Mono_Posix_MemfdFlags_MFD_HUGE_8MB            = 0x5c000000,
+	#define Mono_Posix_MemfdFlags_MFD_HUGE_8MB      Mono_Posix_MemfdFlags_MFD_HUGE_8MB
+};
+int Mono_Posix_FromMemfdFlags (unsigned int x, unsigned int *r);
+int Mono_Posix_ToMemfdFlags (unsigned int x, unsigned int *r);
+
 enum Mono_Posix_MessageFlags {
 	Mono_Posix_MessageFlags_MSG_CMSG_CLOEXEC       = 0x40000000,
 	#define Mono_Posix_MessageFlags_MSG_CMSG_CLOEXEC Mono_Posix_MessageFlags_MSG_CMSG_CLOEXEC
@@ -916,6 +955,21 @@ enum Mono_Posix_PosixMadviseAdvice {
 int Mono_Posix_FromPosixMadviseAdvice (int x, int *r);
 int Mono_Posix_ToPosixMadviseAdvice (int x, int *r);
 
+enum Mono_Posix_SealType {
+	Mono_Posix_SealType_F_SEAL_FUTURE_WRITE       = 0x00000010,
+	#define Mono_Posix_SealType_F_SEAL_FUTURE_WRITE Mono_Posix_SealType_F_SEAL_FUTURE_WRITE
+	Mono_Posix_SealType_F_SEAL_GROW               = 0x00000004,
+	#define Mono_Posix_SealType_F_SEAL_GROW         Mono_Posix_SealType_F_SEAL_GROW
+	Mono_Posix_SealType_F_SEAL_SEAL               = 0x00000001,
+	#define Mono_Posix_SealType_F_SEAL_SEAL         Mono_Posix_SealType_F_SEAL_SEAL
+	Mono_Posix_SealType_F_SEAL_SHRINK             = 0x00000002,
+	#define Mono_Posix_SealType_F_SEAL_SHRINK       Mono_Posix_SealType_F_SEAL_SHRINK
+	Mono_Posix_SealType_F_SEAL_WRITE              = 0x00000008,
+	#define Mono_Posix_SealType_F_SEAL_WRITE        Mono_Posix_SealType_F_SEAL_WRITE
+};
+int Mono_Posix_FromSealType (int x, int *r);
+int Mono_Posix_ToSealType (int x, int *r);
+
 enum Mono_Posix_SeekFlags {
 	Mono_Posix_SeekFlags_L_INCR         = 0x0001,
 	#define Mono_Posix_SeekFlags_L_INCR   Mono_Posix_SeekFlags_L_INCR