support/sys-mman.c

   1 /*
   2  * <sys/mman.h> wrapper functions.
   3  *
   4  * Authors:
   5  *   Jonathan Pryor (jonpryor@vt.edu)
   6  *
   7  * Copyright (C) 2004-2006 Jonathan Pryor
   8  */
   9
  10 #include <config.h>
  11
  12 #ifndef __OpenBSD__
  13 #define _XOPEN_SOURCE 600
  14 #endif
  15
  16 #ifdef HOST_DARWIN
  17 /* For mincore () */
  18 #define _DARWIN_C_SOURCE
  19 #endif
  20 #if defined(__FreeBSD__) || defined(__OpenBSD__)
  21 /* For mincore () */
  22 #define __BSD_VISIBLE 1
  23 #endif
  24
  25 #ifdef __NetBSD__
  26 /* For mincore () */
  27 #define _NETBSD_SOURCE
  28 #endif
  29
  30 #include <sys/types.h>
  31 #include <sys/mman.h>
  32 #include <errno.h>
  33
  34 #include "mono/utils/mono-compiler.h"
  35 #include "map.h"
  36 #include "mph.h"
  37
  38 G_BEGIN_DECLS
  39
  40 void*
  41 Mono_Posix_Syscall_mmap (void *start, mph_size_t length, int prot, int flags,
  42                 int fd, mph_off_t offset)
  43 {
  44         int _prot, _flags;
  45
  46         mph_return_val_if_size_t_overflow (length, MAP_FAILED);
  47         mph_return_val_if_off_t_overflow (offset, MAP_FAILED);
  48
  49         if (Mono_Posix_FromMmapProts (prot, &_prot) == -1)
  50                 return MAP_FAILED;
  51         if (Mono_Posix_FromMmapFlags (flags, &_flags) == -1)
  52                 return MAP_FAILED;
  53
  54         return mmap (start, (size_t) length, _prot, _flags, fd, (off_t) offset);
  55 }
  56
  57 int
  58 Mono_Posix_Syscall_munmap (void *start, mph_size_t length)
  59 {
  60         mph_return_if_size_t_overflow (length);
  61
  62         return munmap (start, (size_t) length);
  63 }
  64
  65 int
  66 Mono_Posix_Syscall_mprotect (void *start, mph_size_t len, int prot)
  67 {
  68         int _prot;
  69         mph_return_if_size_t_overflow (len);
  70
  71         if (Mono_Posix_FromMmapProts (prot, &_prot) == -1)
  72                 return -1;
  73
  74         return mprotect (start, (size_t) len, _prot);
  75 }
  76
  77 int
  78 Mono_Posix_Syscall_msync (void *start, mph_size_t len, int flags)
  79 {
  80         int _flags;
  81         mph_return_if_size_t_overflow (len);
  82
  83         if (Mono_Posix_FromMsyncFlags (flags, &_flags) == -1)
  84                 return -1;
  85
  86         return msync (start, (size_t) len, _flags);
  87 }
  88
  89 int
  90 Mono_Posix_Syscall_mlock (void *start, mph_size_t len)
  91 {
  92 #if !defined (HAVE_MLOCK)
  93         return ENOSYS;
  94 #else
  95         mph_return_if_size_t_overflow (len);
  96
  97         return mlock (start, (size_t) len);
  98 #endif
  99 }
 100
 101 int
 102 Mono_Posix_Syscall_munlock (void *start, mph_size_t len)
 103 {
 104 #if !defined (HAVE_MUNLOCK)
 105         return ENOSYS;
 106 #else
 107         mph_return_if_size_t_overflow (len);
 108
 109         return munlock (start, (size_t) len);
 110 #endif
 111 }
 112
 113 #ifdef HAVE_MREMAP
 114 void*
 115 Mono_Posix_Syscall_mremap (void *old_address, mph_size_t old_size,
 116                 mph_size_t new_size, guint64 flags)
 117 {
 118         guint64 _flags;
 119
 120         mph_return_val_if_size_t_overflow (old_size, MAP_FAILED);
 121         mph_return_val_if_size_t_overflow (new_size, MAP_FAILED);
 122
 123         if (Mono_Posix_FromMremapFlags (flags, &_flags) == -1)
 124                 return MAP_FAILED;
 125
 126 #if defined(linux)
 127         return mremap (old_address, (size_t) old_size, (size_t) new_size,
 128                         (unsigned long) _flags);
 129 #elif defined(__NetBSD__)
 130         return mremap (old_address, (size_t) old_size, old_address,
 131                         (size_t) new_size, (unsigned long) _flags);
 132 #else
 133 #error Port me
 134 #endif
 135 }
 136 #endif /* def HAVE_MREMAP */
 137
 138 int
 139 Mono_Posix_Syscall_mincore (void *start, mph_size_t length, unsigned char *vec)
 140 {
 141 #if !defined (HAVE_MINCORE)
 142         return ENOSYS;
 143 #else
 144         mph_return_if_size_t_overflow (length);
 145
 146 #if defined (__linux__) || defined (HOST_WASM)
 147         typedef unsigned char T;
 148 #else
 149         typedef char T;
 150 #endif
 151         return mincore (start, (size_t) length, (T*)vec);
 152 #endif
 153 }
 154
 155 #ifdef HAVE_POSIX_MADVISE
 156 gint32
 157 Mono_Posix_Syscall_posix_madvise (void *addr, mph_size_t len, gint32 advice)
 158 {
 159         mph_return_if_size_t_overflow (len);
 160
 161         if (Mono_Posix_FromPosixMadviseAdvice (advice, &advice) == -1)
 162                 return -1;
 163
 164         return posix_madvise (addr, (size_t) len, advice);
 165 }
 166 #endif /* def HAVE_POSIX_MADVISE */
 167
 168 #ifdef HAVE_REMAP_FILE_PAGES
 169 int
 170 Mono_Posix_Syscall_remap_file_pages (void *start, mph_size_t size,
 171                 int prot, mph_ssize_t pgoff, int flags)
 172 {
 173         int _prot, _flags;
 174
 175         mph_return_if_size_t_overflow (size);
 176         mph_return_if_ssize_t_overflow (pgoff);
 177
 178         if (Mono_Posix_FromMmapProts (prot, &_prot) == -1)
 179                 return -1;
 180         if (Mono_Posix_FromMmapFlags (flags, &_flags) == -1)
 181                 return -1;
 182
 183         return remap_file_pages (start, (size_t) size, _prot, (ssize_t) pgoff, _flags);
 184 }
 185 #endif /* def HAVE_REMAP_FILE_PAGES */
 186
 187 G_END_DECLS
 188
 189 /*
 190  * vim: noexpandtab
 191  */