mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-02-15 02:37:55 +00:00
d1d4388201
It hasn't been helpful enough to be justify the maintenance burden. What actually does help is mprotect(), kprintf(), --ftrace and --strace which can always be counted upon to work correctly. We aren't losing much with this change. Support for ASAN on AARCH64 was never implemented. Applying ASAN to the core libc runtimes was disabled many months ago. If there is some way to have an ASAN runtime for user programs that is less invasive we can potentially consider reintroducing support. But now is premature.
442 lines
16 KiB
C
442 lines
16 KiB
C
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
|
|
│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi │
|
|
╞══════════════════════════════════════════════════════════════════════════════╡
|
|
│ Copyright 2020 Justine Alexandra Roberts Tunney │
|
|
│ │
|
|
│ Permission to use, copy, modify, and/or distribute this software for │
|
|
│ any purpose with or without fee is hereby granted, provided that the │
|
|
│ above copyright notice and this permission notice appear in all copies. │
|
|
│ │
|
|
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
|
|
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
|
|
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
|
|
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
|
|
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
|
|
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
|
|
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
|
|
│ PERFORMANCE OF THIS SOFTWARE. │
|
|
╚─────────────────────────────────────────────────────────────────────────────*/
|
|
#include "ape/sections.internal.h"
|
|
#include "libc/calls/calls.h"
|
|
#include "libc/calls/syscall-sysv.internal.h"
|
|
#include "libc/calls/ucontext.h"
|
|
#include "libc/dce.h"
|
|
#include "libc/errno.h"
|
|
#include "libc/intrin/atomic.h"
|
|
#include "libc/intrin/kprintf.h"
|
|
#include "libc/intrin/safemacros.internal.h"
|
|
#include "libc/intrin/xchg.internal.h"
|
|
#include "libc/limits.h"
|
|
#include "libc/log/log.h"
|
|
#include "libc/macros.internal.h"
|
|
#include "libc/mem/gc.h"
|
|
#include "libc/mem/mem.h"
|
|
#include "libc/runtime/memtrack.internal.h"
|
|
#include "libc/runtime/runtime.h"
|
|
#include "libc/runtime/stack.h"
|
|
#include "libc/runtime/sysconf.h"
|
|
#include "libc/stdio/rand.h"
|
|
#include "libc/stdio/stdio.h"
|
|
#include "libc/str/str.h"
|
|
#include "libc/sysv/consts/auxv.h"
|
|
#include "libc/sysv/consts/map.h"
|
|
#include "libc/sysv/consts/msync.h"
|
|
#include "libc/sysv/consts/o.h"
|
|
#include "libc/sysv/consts/prot.h"
|
|
#include "libc/sysv/consts/sa.h"
|
|
#include "libc/sysv/consts/sig.h"
|
|
#include "libc/testlib/ezbench.h"
|
|
#include "libc/testlib/testlib.h"
|
|
#include "libc/x/xspawn.h"
|
|
#include "third_party/xed/x86.h"
|
|
|
|
// this is also a good torture test for mmap
|
|
//
|
|
// make -j o//test/libc/intrin/pthread_mutex_lock2_test
|
|
// for i in $(seq 100); do
|
|
// o//test/libc/intrin/pthread_mutex_lock2_test &
|
|
// done
|
|
//
|
|
|
|
__static_yoink("zipos");
|
|
|
|
int granularity;
|
|
|
|
void SetUpOnce(void) {
|
|
granularity = __granularity();
|
|
testlib_enable_tmp_setup_teardown();
|
|
// ASSERT_SYS(0, 0, pledge("stdio rpath wpath cpath proc", 0));
|
|
}
|
|
|
|
TEST(mmap, zeroSize) {
|
|
ASSERT_SYS(EINVAL, MAP_FAILED,
|
|
mmap(NULL, 0, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
|
|
}
|
|
|
|
TEST(mmap, overflow) {
|
|
ASSERT_SYS(ENOMEM, MAP_FAILED,
|
|
mmap(NULL, 0x800000000000, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE,
|
|
-1, 0));
|
|
ASSERT_SYS(ENOMEM, MAP_FAILED,
|
|
mmap(NULL, 0x7fffffffffff, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE,
|
|
-1, 0));
|
|
}
|
|
|
|
TEST(mmap, noreplaceImage) {
|
|
ASSERT_SYS(EEXIST, MAP_FAILED,
|
|
mmap(__executable_start, granularity, PROT_READ,
|
|
MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED_NOREPLACE, -1, 0));
|
|
}
|
|
|
|
TEST(mmap, noreplaceExistingMap) {
|
|
char *p;
|
|
ASSERT_NE(MAP_FAILED, (p = mmap(0, granularity, PROT_READ,
|
|
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
|
|
ASSERT_SYS(EEXIST, MAP_FAILED,
|
|
mmap(p, granularity, PROT_READ,
|
|
MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED_NOREPLACE, -1, 0));
|
|
EXPECT_SYS(0, 0, munmap(p, granularity));
|
|
}
|
|
|
|
TEST(mmap, hint) {
|
|
char *p, *q;
|
|
|
|
// obtain four pages
|
|
EXPECT_NE(MAP_FAILED, (p = mmap(NULL, granularity * 4, PROT_READ,
|
|
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)));
|
|
|
|
// unmap two of those pages
|
|
EXPECT_SYS(0, 0, munmap(p + granularity, granularity));
|
|
EXPECT_SYS(0, 0, munmap(p + granularity * 3, granularity));
|
|
|
|
// test AVAILABLE nonfixed nonzero addr is granted
|
|
// - posix doesn't mandate this behavior (but should)
|
|
// - freebsd always chooses for you (which has no acceptable workaround)
|
|
// - netbsd manual claims it'll be like freebsd, but is actually like openbsd
|
|
if (!IsFreebsd())
|
|
EXPECT_EQ(p + granularity, mmap(p + granularity, granularity, PROT_READ,
|
|
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
|
|
|
|
// test UNAVAILABLE nonfixed nonzero addr picks something nearby
|
|
// - posix actually does require this, but doesn't say how close
|
|
// - xnu / linux / openbsd always choose nearest on the right
|
|
// - freebsd goes about 16mb to the right
|
|
// - qemu-user is off the wall
|
|
if (!IsQemuUser()) {
|
|
q = mmap(p + granularity * 2, granularity, PROT_READ,
|
|
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
|
|
EXPECT_LE(ABS(q - (p + granularity * 2)), 64 * 1024 * 1024);
|
|
EXPECT_SYS(0, 0, munmap(q, granularity));
|
|
}
|
|
|
|
// clean up
|
|
EXPECT_SYS(0, 0, munmap(p, granularity * 4));
|
|
}
|
|
|
|
TEST(mmap, smallerThanPage_mapsRemainder) {
|
|
long pagesz = sysconf(_SC_PAGESIZE);
|
|
char *map =
|
|
mmap(0, 4096, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
|
|
ASSERT_NE(MAP_FAILED, map);
|
|
EXPECT_TRUE(testlib_memoryexists(map));
|
|
EXPECT_TRUE(testlib_memoryexists(map + (pagesz - 1)));
|
|
EXPECT_SYS(0, 0, munmap(map, 1));
|
|
EXPECT_FALSE(testlib_memoryexists(map));
|
|
EXPECT_FALSE(testlib_memoryexists(map + (pagesz - 1)));
|
|
}
|
|
|
|
TEST(mmap, testMapFile) {
|
|
int fd;
|
|
char *p;
|
|
char path[PATH_MAX];
|
|
sprintf(path, "%s.%ld", program_invocation_short_name, lemur64());
|
|
ASSERT_NE(-1, (fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644)));
|
|
EXPECT_EQ(5, write(fd, "hello", 5));
|
|
EXPECT_NE(-1, fdatasync(fd));
|
|
EXPECT_NE(MAP_FAILED, (p = mmap(NULL, 5, PROT_READ, MAP_PRIVATE, fd, 0)));
|
|
EXPECT_STREQN("hello", p, 5);
|
|
EXPECT_NE(-1, munmap(p, 5));
|
|
EXPECT_NE(-1, close(fd));
|
|
EXPECT_NE(-1, unlink(path));
|
|
}
|
|
|
|
TEST(mmap, testMapFile_fdGetsClosed_makesNoDifference) {
|
|
int fd;
|
|
char *p, buf[16], path[PATH_MAX];
|
|
sprintf(path, "%s.%ld", program_invocation_short_name, lemur64());
|
|
ASSERT_NE(-1, (fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644)));
|
|
EXPECT_EQ(5, write(fd, "hello", 5));
|
|
EXPECT_NE(-1, fdatasync(fd));
|
|
EXPECT_NE(MAP_FAILED,
|
|
(p = mmap(NULL, 5, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)));
|
|
EXPECT_NE(-1, close(fd));
|
|
EXPECT_STREQN("hello", p, 5);
|
|
p[1] = 'a';
|
|
EXPECT_NE(-1, msync(p, getauxval(AT_PAGESZ), MS_SYNC));
|
|
ASSERT_NE(-1, (fd = open(path, O_RDONLY)));
|
|
EXPECT_EQ(5, read(fd, buf, 5));
|
|
EXPECT_STREQN("hallo", buf, 5);
|
|
EXPECT_NE(-1, close(fd));
|
|
EXPECT_NE(-1, munmap(p, 5));
|
|
EXPECT_NE(-1, unlink(path));
|
|
}
|
|
|
|
TEST(mmap, fileOffset) {
|
|
int fd;
|
|
char *map;
|
|
int offset_align = IsWindows() ? granularity : getauxval(AT_PAGESZ);
|
|
ASSERT_NE(-1, (fd = open("foo", O_CREAT | O_RDWR, 0644)));
|
|
EXPECT_NE(-1, ftruncate(fd, offset_align * 2));
|
|
EXPECT_NE(-1, pwrite(fd, "hello", 5, offset_align * 0));
|
|
EXPECT_NE(-1, pwrite(fd, "there", 5, offset_align * 1));
|
|
EXPECT_NE(-1, fdatasync(fd));
|
|
ASSERT_NE(MAP_FAILED, (map = mmap(NULL, offset_align, PROT_READ, MAP_PRIVATE,
|
|
fd, offset_align)));
|
|
EXPECT_EQ(0, memcmp(map, "there", 5), "%#.*s", 5, map);
|
|
EXPECT_NE(-1, munmap(map, offset_align));
|
|
EXPECT_NE(-1, close(fd));
|
|
}
|
|
|
|
TEST(mmap, mapPrivate_writesDontChangeFile) {
|
|
int fd;
|
|
char *map, buf[6];
|
|
ASSERT_NE(-1, (fd = open("bar", O_CREAT | O_RDWR, 0644)));
|
|
EXPECT_NE(-1, ftruncate(fd, granularity));
|
|
EXPECT_NE(-1, pwrite(fd, "hello", 5, 0));
|
|
ASSERT_NE(MAP_FAILED, (map = mmap(NULL, granularity, PROT_READ | PROT_WRITE,
|
|
MAP_PRIVATE, fd, 0)));
|
|
memcpy(map, "there", 5);
|
|
EXPECT_NE(-1, msync(map, granularity, MS_SYNC));
|
|
EXPECT_NE(-1, munmap(map, granularity));
|
|
EXPECT_NE(-1, pread(fd, buf, 6, 0));
|
|
EXPECT_EQ(0, memcmp(buf, "hello", 5), "%#.*s", 5, buf);
|
|
EXPECT_NE(-1, close(fd));
|
|
}
|
|
|
|
static const char *ziposLifePath = "/zip/life.elf";
|
|
|
|
TEST(mmap, ziposCannotBeShared) {
|
|
int fd;
|
|
void *p;
|
|
ASSERT_NE(-1, (fd = open(ziposLifePath, O_RDONLY), "%s", ziposLifePath));
|
|
EXPECT_SYS(EINVAL, MAP_FAILED,
|
|
(p = mmap(NULL, granularity, PROT_READ, MAP_SHARED, fd, 0)));
|
|
close(fd);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// zipos NON-SHARED READ-ONLY FILE MEMORY
|
|
|
|
TEST(mmap, ziposCow) {
|
|
int fd;
|
|
void *p;
|
|
ASSERT_NE(-1, (fd = open(ziposLifePath, O_RDONLY), "%s", ziposLifePath));
|
|
EXPECT_NE(MAP_FAILED,
|
|
(p = mmap(NULL, granularity, PROT_READ, MAP_PRIVATE, fd, 0)));
|
|
EXPECT_STREQN("\177ELF", ((const char *)p), 4);
|
|
EXPECT_NE(-1, munmap(p, granularity));
|
|
EXPECT_NE(-1, close(fd));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// zipos NON-SHARED READ-ONLY FILE MEMORY BETWEEN PROCESSES
|
|
|
|
TEST(mmap, ziposCowFileMapReadonlyFork) {
|
|
int fd, ws;
|
|
void *p;
|
|
ASSERT_NE(-1, (fd = open(ziposLifePath, O_RDONLY), "%s", ziposLifePath));
|
|
EXPECT_NE(MAP_FAILED, (p = mmap(NULL, 4, PROT_READ, MAP_PRIVATE, fd, 0)));
|
|
EXPECT_STREQN("ELF", ((const char *)p) + 1, 3);
|
|
ASSERT_NE(-1, (ws = xspawn(0)));
|
|
if (ws == -2) {
|
|
ASSERT_STREQN("ELF", ((const char *)p) + 1, 3);
|
|
_exit(0);
|
|
}
|
|
EXPECT_EQ(0, ws);
|
|
EXPECT_STREQN("ELF", ((const char *)p) + 1, 3);
|
|
EXPECT_NE(-1, munmap(p, 6));
|
|
EXPECT_NE(-1, close(fd));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// zipos NON-SHARED READ/WRITE FILE MEMORY BETWEEN PROCESSES
|
|
|
|
TEST(mmap, ziposCowFileMapFork) {
|
|
int fd, ws;
|
|
void *p;
|
|
char lol[4];
|
|
ASSERT_NE(-1, (fd = open(ziposLifePath, O_RDONLY), "%s", ziposLifePath));
|
|
EXPECT_NE(MAP_FAILED,
|
|
(p = mmap(NULL, 6, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0)));
|
|
memcpy(p, "parnt", 6);
|
|
ASSERT_NE(-1, (ws = xspawn(0)));
|
|
if (ws == -2) {
|
|
ASSERT_STREQN("parnt", p, 5);
|
|
strcpy(p, "child");
|
|
ASSERT_STREQN("child", p, 5);
|
|
_exit(0);
|
|
}
|
|
EXPECT_EQ(0, ws);
|
|
EXPECT_STREQN("parnt", p, 5); // child changing memory did not change parent
|
|
EXPECT_EQ(4, pread(fd, lol, 4, 0));
|
|
EXPECT_STREQN("ELF", &lol[1], 3); // changing memory did not change file
|
|
EXPECT_NE(-1, munmap(p, 6));
|
|
EXPECT_NE(-1, close(fd));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// NON-SHARED READ-ONLY FILE MEMORY
|
|
|
|
TEST(mmap, cow) {
|
|
int fd;
|
|
char *p;
|
|
char path[PATH_MAX];
|
|
sprintf(path, "%s.%ld", program_invocation_short_name, lemur64());
|
|
ASSERT_NE(-1, (fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644)), "%s",
|
|
path);
|
|
EXPECT_EQ(5, write(fd, "hello", 5));
|
|
EXPECT_NE(-1, fdatasync(fd));
|
|
EXPECT_NE(MAP_FAILED, (p = mmap(NULL, 5, PROT_READ, MAP_PRIVATE, fd, 0)));
|
|
EXPECT_STREQN("hello", p, 5);
|
|
EXPECT_NE(-1, munmap(p, 5));
|
|
EXPECT_NE(-1, close(fd));
|
|
EXPECT_NE(-1, unlink(path));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// NON-SHARED READ-ONLY FILE MEMORY BETWEEN PROCESSES
|
|
|
|
TEST(mmap, cowFileMapReadonlyFork) {
|
|
char *p;
|
|
int fd, ws;
|
|
char path[PATH_MAX];
|
|
sprintf(path, "%s.%ld", program_invocation_short_name, lemur64());
|
|
ASSERT_NE(-1, (fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644)));
|
|
EXPECT_EQ(6, write(fd, "hello", 6));
|
|
EXPECT_NE(-1, close(fd));
|
|
ASSERT_NE(-1, (fd = open(path, O_RDONLY)));
|
|
EXPECT_NE(MAP_FAILED, (p = mmap(NULL, 6, PROT_READ, MAP_PRIVATE, fd, 0)));
|
|
EXPECT_STREQN("hello", p, 5);
|
|
ASSERT_NE(-1, (ws = xspawn(0)));
|
|
if (ws == -2) {
|
|
ASSERT_STREQN("hello", p, 5);
|
|
_exit(0);
|
|
}
|
|
EXPECT_EQ(0, ws);
|
|
EXPECT_STREQN("hello", p, 5);
|
|
EXPECT_NE(-1, munmap(p, 6));
|
|
EXPECT_NE(-1, close(fd));
|
|
EXPECT_NE(-1, unlink(path));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// NON-SHARED READ/WRITE FILE MEMORY BETWEEN PROCESSES
|
|
|
|
TEST(mmap, cowFileMapFork) {
|
|
char *p;
|
|
int fd, ws;
|
|
char path[PATH_MAX], lol[6];
|
|
sprintf(path, "%s.%ld", program_invocation_short_name, lemur64());
|
|
ASSERT_NE(-1, (fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644)));
|
|
EXPECT_EQ(6, write(fd, "parnt", 6));
|
|
EXPECT_NE(-1, fdatasync(fd));
|
|
EXPECT_NE(MAP_FAILED,
|
|
(p = mmap(NULL, 6, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0)));
|
|
EXPECT_STREQN("parnt", p, 5);
|
|
ASSERT_NE(-1, (ws = xspawn(0)));
|
|
if (ws == -2) {
|
|
ASSERT_STREQN("parnt", p, 5);
|
|
strcpy(p, "child");
|
|
ASSERT_STREQN("child", p, 5);
|
|
_exit(0);
|
|
}
|
|
EXPECT_EQ(0, ws);
|
|
EXPECT_STREQN("parnt", p, 5); // child changing memory did not change parent
|
|
EXPECT_EQ(6, pread(fd, lol, 6, 0));
|
|
EXPECT_STREQN("parnt", lol, 5); // changing memory did not change file
|
|
EXPECT_NE(-1, munmap(p, 6));
|
|
EXPECT_NE(-1, close(fd));
|
|
EXPECT_NE(-1, unlink(path));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// SHARED ANONYMOUS MEMORY BETWEEN PROCESSES
|
|
|
|
TEST(mmap, sharedAnonMapFork) {
|
|
int ws;
|
|
char *p;
|
|
EXPECT_NE(MAP_FAILED, (p = mmap(NULL, 6, PROT_READ | PROT_WRITE,
|
|
MAP_SHARED | MAP_ANONYMOUS, -1, 0)));
|
|
strcpy(p, "parnt");
|
|
EXPECT_STREQN("parnt", p, 5);
|
|
ASSERT_NE(-1, (ws = xspawn(0)));
|
|
if (ws == -2) {
|
|
ASSERT_STREQN("parnt", p, 5);
|
|
strcpy(p, "child");
|
|
ASSERT_STREQN("child", p, 5);
|
|
_exit(0);
|
|
}
|
|
EXPECT_EQ(0, ws);
|
|
EXPECT_STREQN("child", p, 5); // boom
|
|
EXPECT_NE(-1, munmap(p, 5));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// SHARED FILE MEMORY BETWEEN PROCESSES
|
|
|
|
TEST(mmap, sharedFileMapFork) {
|
|
char *p;
|
|
int fd, ws;
|
|
char path[PATH_MAX], lol[6];
|
|
sprintf(path, "%s.%ld", program_invocation_short_name, lemur64());
|
|
ASSERT_NE(-1, (fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644)));
|
|
EXPECT_EQ(6, write(fd, "parnt", 6));
|
|
EXPECT_NE(-1, fdatasync(fd));
|
|
EXPECT_NE(MAP_FAILED,
|
|
(p = mmap(NULL, 6, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)));
|
|
EXPECT_STREQN("parnt", p, 5);
|
|
ASSERT_NE(-1, (ws = xspawn(0)));
|
|
if (ws == -2) {
|
|
ASSERT_STREQN("parnt", p, 5);
|
|
strcpy(p, "child");
|
|
ASSERT_STREQN("child", p, 5);
|
|
ASSERT_NE(-1, msync(p, 6, MS_SYNC | MS_INVALIDATE));
|
|
_exit(0);
|
|
}
|
|
EXPECT_EQ(0, ws);
|
|
EXPECT_STREQN("child", p, 5); // child changing memory changed parent memory
|
|
// XXX: RHEL5 has a weird issue where if we read the file into its own
|
|
// shared memory then corruption occurs!
|
|
EXPECT_EQ(6, pread(fd, lol, 6, 0));
|
|
EXPECT_STREQN("child", lol, 5); // changing memory changed file
|
|
EXPECT_NE(-1, munmap(p, 6));
|
|
EXPECT_NE(-1, close(fd));
|
|
EXPECT_NE(-1, unlink(path));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// BENCHMARKS
|
|
|
|
#define N (EZBENCH_COUNT * EZBENCH_TRIES)
|
|
|
|
int count;
|
|
void *ptrs[N];
|
|
|
|
void BenchMmapPrivate(void) {
|
|
void *p;
|
|
p = mmap(0, granularity, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE,
|
|
-1, 0);
|
|
if (p == MAP_FAILED)
|
|
__builtin_trap();
|
|
ptrs[count++] = p;
|
|
}
|
|
|
|
void BenchUnmap(void) {
|
|
if (munmap(ptrs[--count], granularity))
|
|
__builtin_trap();
|
|
}
|
|
|
|
BENCH(mmap, bench) {
|
|
EZBENCH2("mmap", donothing, BenchMmapPrivate());
|
|
EZBENCH2("munmap", donothing, BenchUnmap());
|
|
}
|