cosmopolitan/libc/runtime/mmap.c

/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
│                                                                              │
│ This program is free software; you can redistribute it and/or modify         │
│ it under the terms of the GNU General Public License as published by         │
│ the Free Software Foundation; version 2 of the License.                      │
│                                                                              │
│ This program is distributed in the hope that it will be useful, but          │
│ WITHOUT ANY WARRANTY; without even the implied warranty of                   │
│ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU             │
│ General Public License for more details.                                     │
│                                                                              │
│ You should have received a copy of the GNU General Public License            │
│ along with this program; if not, write to the Free Software                  │
│ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA                │
│ 02110-1301 USA                                                               │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/assert.h"
#include "libc/calls/calls.h"
#include "libc/calls/internal.h"
#include "libc/dce.h"
#include "libc/macros.h"
#include "libc/nt/memory.h"
#include "libc/nt/runtime.h"
#include "libc/rand/rand.h"
#include "libc/runtime/memtrack.h"
#include "libc/runtime/runtime.h"
#include "libc/str/str.h"
#include "libc/sysv/consts/map.h"
#include "libc/sysv/consts/prot.h"
#include "libc/sysv/errfuns.h"

#define IP(X)            (intptr_t)(X)
#define VIP(X)           (void *)IP(X)
#define COORD(a)         (int)(IP(a) >> 16)
#define ADDR(c)          (void *)(IP(c) << 16)
#define ALIGNED(p)       (!(IP(p) & (FRAMESIZE - 1)))
#define CANONICAL(p)     (-0x800000000000 <= IP(p) && IP(p) <= 0x7fffffffffff)
#define LAST_COORD(a, n) (COORD(a) + (ROUNDUP(n, FRAMESIZE) >> 16) - 1)

struct DirectMap {
  void *addr;
  int64_t maphandle;
};

struct MemoryIntervals _mmi;

static textwindows struct DirectMap DirectMapNt(void *addr, size_t size,
                                                unsigned prot, unsigned flags,
                                                int fd, int64_t off) {
  struct DirectMap res; /* NT IS TORTURE */
  if ((res.maphandle = CreateFileMappingNuma(
           fd != -1 ? g_fds.p[fd].handle : kNtInvalidHandleValue,
           &kNtIsInheritable, prot2nt(prot, flags), size >> 32, size, NULL,
           kNtNumaNoPreferredNode))) {
    if (!(res.addr = MapViewOfFileExNuma(res.maphandle, fprot2nt(prot, flags),
                                         off >> 32, off, size, addr,
                                         kNtNumaNoPreferredNode))) {
      CloseHandle(res.maphandle);
      res.maphandle = kNtInvalidHandleValue;
      res.addr = VIP(winerr());
    }
  } else {
    res.maphandle = kNtInvalidHandleValue;
    res.addr = VIP(winerr());
  }
  return res;
}

static struct DirectMap DirectMap(void *addr, size_t size, unsigned prot,
                                  unsigned flags, int fd, int64_t off) {
  if (!IsWindows()) {
    return (struct DirectMap){mmap$sysv(addr, size, prot, flags, fd, off),
                              kNtInvalidHandleValue};
  } else {
    return DirectMapNt(addr, size, prot, flags, fd, off);
  }
}

static int UntrackMemoryIntervals(void *addr, size_t size) {
  return ReleaseMemoryIntervals(&_mmi, COORD(addr), LAST_COORD(addr, size),
                                ReleaseMemoryNt);
}

/**
 * Releases memory pages.
 *
 * @param addr is a pointer within any memory mapped region the process
 *     has permission to control, such as address ranges returned by
 *     mmap(), the program image itself, etc.
 * @param size is the amount of memory to unmap, which needn't be a
 *     multiple of FRAMESIZE, and may be a subset of that which was
 *     mapped previously, and may punch holes in existing mappings,
 *     but your mileage may vary on windows
 * @return 0 on success, or -1 w/ errno
 */
int munmap(void *addr, size_t size) {
  int rc;
  if (!ALIGNED(addr) || !CANONICAL(addr) || !size) return einval();
  size = ROUNDUP(size, FRAMESIZE);
  if (UntrackMemoryIntervals(addr, size) == -1) return -1;
  if (IsWindows()) return 0;
  return munmap$sysv(addr, size);
}

/**
 * Beseeches system for page-table entries.
 *
 * @param addr optionally requests a particular virtual base address,
 *     which needs to be 64kb aligned if passed (for NT compatibility)
 * @param size must be >0 and needn't be a multiple of FRAMESIZE
 * @param prot can have PROT_READ, PROT_WRITE, PROT_EXEC, PROT_NONE, etc.
 * @param flags can have MAP_ANONYMOUS, MAP_SHARED, MAP_PRIVATE, etc.
 * @param fd is an open()'d file descriptor whose contents shall be
 *     mapped, and is ignored if MAP_ANONYMOUS is specified
 * @param offset specifies absolute byte index of fd's file for mapping,
 *     and should be zero if MAP_ANONYMOUS is specified
 * @return virtual base address of new mapping, or MAP_FAILED w/ errno
 */
void *mmap(void *addr, size_t size, int prot, int flags, int fd, int64_t off) {
  int i;
  long gap;
  struct DirectMap dm;
  if (!size) return VIP(einval());
  if (!ALIGNED(off)) return VIP(einval());
  if (!ALIGNED(addr)) return VIP(einval());
  if (!CANONICAL(addr)) return VIP(einval());
  if (!(!!(flags & MAP_ANONYMOUS) ^ (fd != -1))) return VIP(einval());
  if (!(!!(flags & MAP_PRIVATE) ^ !!(flags & MAP_SHARED))) return VIP(einval());
  if (fd == -1) size = ROUNDUP(size, FRAMESIZE);
  if (flags & MAP_FIXED) {
    if (UntrackMemoryIntervals(addr, size) == -1) {
      return MAP_FAILED;
    }
  } else if (_mmi.i) {
    if (0 && IsModeDbg()) {
      addr = VIP(rand64() & 0x00007ffffffff000);
    } else {
      for (i = _mmi.i - 1; i > 0; --i) {
        gap = _mmi.p[i].x - _mmi.p[i - 1].y - 1;
        assert(gap > 0);
        if (gap >= (ROUNDUP(size, FRAMESIZE) >> 16)) {
          addr = ADDR(_mmi.p[i - 1].y + 1);
          break;
        }
      }
      if (!addr) {
        addr = ADDR(_mmi.p[_mmi.i - 1].y + 1);
      }
    }
  } else {
    addr = VIP(kMappingsStart);
  }
  assert((flags & MAP_FIXED) ||
         (!isheap(addr) && !isheap((char *)addr + size - 1)));
  dm = DirectMap(addr, size, prot, flags | MAP_FIXED, fd, off);
  if (dm.addr == MAP_FAILED || dm.addr != addr) {
    return MAP_FAILED;
  }
  if (TrackMemoryInterval(&_mmi, COORD(dm.addr), LAST_COORD(dm.addr, size),
                          dm.maphandle) == -1) {
    _Exit(1);
  }
  return dm.addr;
}