libgo/runtime/mem.c

   1 /* Defining _XOPEN_SOURCE hides the declaration of madvise() on Solaris <
   2    11 and the MADV_DONTNEED definition on IRIX 6.5.  */
   3 #undef _XOPEN_SOURCE
   4
   5 #include <errno.h>
   6 #include <unistd.h>
   7
   8 #include "runtime.h"
   9 #include "arch.h"
  10 #include "malloc.h"
  11
  12 #ifndef MAP_ANON
  13 #ifdef MAP_ANONYMOUS
  14 #define MAP_ANON MAP_ANONYMOUS
  15 #else
  16 #define USE_DEV_ZERO
  17 #define MAP_ANON 0
  18 #endif
  19 #endif
  20
  21 #ifdef USE_DEV_ZERO
  22 static int dev_zero = -1;
  23 #endif
  24
  25 static _Bool
  26 addrspace_free(void *v __attribute__ ((unused)), uintptr n __attribute__ ((unused)))
  27 {
  28 #ifdef HAVE_MINCORE
  29         size_t page_size = getpagesize();
  30         size_t off;
  31         char one_byte;
  32
  33         errno = 0;
  34         for(off = 0; off < n; off += page_size)
  35                 if(mincore((char *)v + off, page_size, (void *)&one_byte) != -1
  36                    || errno != ENOMEM)
  37                         return 0;
  38 #endif
  39         return 1;
  40 }
  41
  42 static void *
  43 mmap_fixed(byte *v, uintptr n, int32 prot, int32 flags, int32 fd, uint32 offset)
  44 {
  45         void *p;
  46
  47         p = runtime_mmap((void *)v, n, prot, flags, fd, offset);
  48         if(p != v && addrspace_free(v, n)) {
  49                 // On some systems, mmap ignores v without
  50                 // MAP_FIXED, so retry if the address space is free.
  51                 if(p != MAP_FAILED)
  52                         runtime_munmap(p, n);
  53                 p = runtime_mmap((void *)v, n, prot, flags|MAP_FIXED, fd, offset);
  54         }
  55         return p;
  56 }
  57
  58 void*
  59 runtime_SysAlloc(uintptr n)
  60 {
  61         void *p;
  62         int fd = -1;
  63
  64         mstats.sys += n;
  65
  66 #ifdef USE_DEV_ZERO
  67         if (dev_zero == -1) {
  68                 dev_zero = open("/dev/zero", O_RDONLY);
  69                 if (dev_zero < 0) {
  70                         runtime_printf("open /dev/zero: errno=%d\n", errno);
  71                         exit(2);
  72                 }
  73         }
  74         fd = dev_zero;
  75 #endif
  76
  77         p = runtime_mmap(nil, n, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_ANON|MAP_PRIVATE, fd, 0);
  78         if (p == MAP_FAILED) {
  79                 if(errno == EACCES) {
  80                         runtime_printf("runtime: mmap: access denied\n");
  81                         runtime_printf("if you're running SELinux, enable execmem for this process.\n");
  82                         exit(2);
  83                 }
  84                 if(errno == EAGAIN) {
  85                         runtime_printf("runtime: mmap: too much locked memory (check 'ulimit -l').\n");
  86                         runtime_exit(2);
  87                 }
  88                 return nil;
  89         }
  90         return p;
  91 }
  92
  93 void
  94 runtime_SysUnused(void *v __attribute__ ((unused)), uintptr n __attribute__ ((unused)))
  95 {
  96 #ifdef MADV_DONTNEED
  97         runtime_madvise(v, n, MADV_DONTNEED);
  98 #endif
  99 }
 100
 101 void
 102 runtime_SysFree(void *v, uintptr n)
 103 {
 104         mstats.sys -= n;
 105         runtime_munmap(v, n);
 106 }
 107
 108 void*
 109 runtime_SysReserve(void *v, uintptr n)
 110 {
 111         int fd = -1;
 112         void *p;
 113
 114 #ifdef USE_DEV_ZERO
 115         if (dev_zero == -1) {
 116                 dev_zero = open("/dev/zero", O_RDONLY);
 117                 if (dev_zero < 0) {
 118                         runtime_printf("open /dev/zero: errno=%d\n", errno);
 119                         exit(2);
 120                 }
 121         }
 122         fd = dev_zero;
 123 #endif
 124
 125         // On 64-bit, people with ulimit -v set complain if we reserve too
 126         // much address space.  Instead, assume that the reservation is okay
 127         // if we can reserve at least 64K and check the assumption in SysMap.
 128         // Only user-mode Linux (UML) rejects these requests.
 129         if(sizeof(void*) == 8 && (uintptr)v >= 0xffffffffU) {
 130                 p = mmap_fixed(v, 64<<10, PROT_NONE, MAP_ANON|MAP_PRIVATE, fd, 0);
 131                 if (p != v)
 132                         return nil;
 133                 runtime_munmap(p, 64<<10);
 134                 return v;
 135         }
 136
 137         p = runtime_mmap(v, n, PROT_NONE, MAP_ANON|MAP_PRIVATE, fd, 0);
 138         if(p == MAP_FAILED)
 139                 return nil;
 140         return p;
 141 }
 142
 143 void
 144 runtime_SysMap(void *v, uintptr n)
 145 {
 146         void *p;
 147         int fd = -1;
 148
 149         mstats.sys += n;
 150
 151 #ifdef USE_DEV_ZERO
 152         if (dev_zero == -1) {
 153                 dev_zero = open("/dev/zero", O_RDONLY);
 154                 if (dev_zero < 0) {
 155                         runtime_printf("open /dev/zero: errno=%d\n", errno);
 156                         exit(2);
 157                 }
 158         }
 159         fd = dev_zero;
 160 #endif
 161
 162         // On 64-bit, we don't actually have v reserved, so tread carefully.
 163         if(sizeof(void*) == 8 && (uintptr)v >= 0xffffffffU) {
 164                 p = mmap_fixed(v, n, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_ANON|MAP_PRIVATE, fd, 0);
 165                 if(p == MAP_FAILED && errno == ENOMEM)
 166                         runtime_throw("runtime: out of memory");
 167                 if(p != v) {
 168                         runtime_printf("runtime: address space conflict: map(%p) = %p\n", v, p);
 169                         runtime_throw("runtime: address space conflict");
 170                 }
 171                 return;
 172         }
 173
 174         p = runtime_mmap(v, n, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_ANON|MAP_FIXED|MAP_PRIVATE, fd, 0);
 175         if(p != v)
 176                 runtime_throw("runtime: cannot map pages in arena address space");
 177 }