mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-02-12 09:17:53 +00:00
467 lines
16 KiB
C
467 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 pagesz;
|
|
int granularity;
|
|
|
|
void SetUpOnce(void) {
|
|
pagesz = getpagesize();
|
|
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, 1, PROT_READ,
|
|
MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED_NOREPLACE, -1, 0));
|
|
}
|
|
|
|
TEST(mmap, noreplaceExistingMap) {
|
|
char *p;
|
|
ASSERT_NE(MAP_FAILED,
|
|
(p = mmap(0, 1, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
|
|
ASSERT_SYS(EEXIST, MAP_FAILED,
|
|
mmap(p, 1, PROT_READ,
|
|
MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED_NOREPLACE, -1, 0));
|
|
EXPECT_SYS(0, 0, munmap(p, 1));
|
|
}
|
|
|
|
TEST(mmap, pageBeyondGone) {
|
|
int pagesz = getpagesize();
|
|
char *p = mmap(0, pagesz * 2, PROT_READ | PROT_WRITE,
|
|
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
|
|
ASSERT_EQ(0, munmap(p, pagesz * 2));
|
|
p = mmap(p, 1, PROT_READ | PROT_WRITE,
|
|
MAP_FIXED | MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
|
|
ASSERT_NE(MAP_FAILED, p);
|
|
EXPECT_TRUE(testlib_memoryexists(p));
|
|
EXPECT_TRUE(testlib_memoryexists(p + pagesz - 1));
|
|
EXPECT_FALSE(testlib_memoryexists(p + pagesz));
|
|
ASSERT_EQ(0, munmap(p, 1));
|
|
}
|
|
|
|
TEST(mmap, fixedTaken) {
|
|
char *p;
|
|
ASSERT_NE(MAP_FAILED,
|
|
(p = mmap(0, 1, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
|
|
ASSERT_NE(MAP_FAILED, mmap(p, 1, PROT_READ,
|
|
MAP_FIXED | MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
|
|
EXPECT_SYS(0, 0, munmap(p, 1));
|
|
}
|
|
|
|
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, getpagesize(), 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 : getpagesize();
|
|
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 * 10, 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 * 10))
|
|
__builtin_trap();
|
|
}
|
|
|
|
BENCH(mmap, bench) {
|
|
EZBENCH2("mmap", donothing, BenchMmapPrivate());
|
|
EZBENCH2("munmap", donothing, BenchUnmap());
|
|
}
|