mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-07-01 08:48:29 +00:00
Make some systemic improvements
- add vdso dump utility - tests now log stack usage - rename g_ftrace to __ftrace - make internal spinlocks go faster - add conformant c11 atomics library - function tracing now logs stack usage - make function call tracing thread safe - add -X unsecure (no ssl) mode to redbean - munmap() has more consistent behavior now - pacify fsync() calls on python unit tests - make --strace flag work better in redbean - start minimizing and documenting compiler flags
This commit is contained in:
Justine Tunney
parent
c6bbca55e9
commit
9208c83f7a
141 changed files with 1948 additions and 1411 deletions
|
|
@ -17,6 +17,7 @@
|
|||
│ PERFORMANCE OF THIS SOFTWARE. │
|
||||
╚─────────────────────────────────────────────────────────────────────────────*/
|
||||
#include "libc/errno.h"
|
||||
#include "libc/intrin/kprintf.h"
|
||||
#include "libc/limits.h"
|
||||
#include "libc/log/check.h"
|
||||
#include "libc/mem/mem.h"
|
||||
|
|
@ -26,6 +27,9 @@
|
|||
#include "libc/str/str.h"
|
||||
#include "libc/testlib/testlib.h"
|
||||
|
||||
#define I(x, y) \
|
||||
{ x, y, 0, (y - x) * FRAMESIZE + FRAMESIZE }
|
||||
|
||||
static bool AreMemoryIntervalsEqual(const struct MemoryIntervals *mm1,
|
||||
const struct MemoryIntervals *mm2) {
|
||||
if (mm1->i != mm2->i) return false;
|
||||
|
|
@ -45,8 +49,10 @@ static void PrintMemoryInterval(const struct MemoryIntervals *mm) {
|
|||
static void CheckMemoryIntervalsEqual(const struct MemoryIntervals *mm1,
|
||||
const struct MemoryIntervals *mm2) {
|
||||
if (!AreMemoryIntervalsEqual(mm1, mm2)) {
|
||||
PrintMemoryInterval(mm1);
|
||||
PrintMemoryInterval(mm2);
|
||||
kprintf("got:\n");
|
||||
PrintMemoryIntervals(2, mm1);
|
||||
kprintf("want:\n");
|
||||
PrintMemoryIntervals(2, mm2);
|
||||
CHECK(!"memory intervals not equal");
|
||||
exit(1);
|
||||
}
|
||||
|
|
@ -65,7 +71,8 @@ static void RunTrackMemoryIntervalTest(const struct MemoryIntervals t[2], int x,
|
|||
struct MemoryIntervals *mm;
|
||||
mm = memcpy(memalign(64, sizeof(*t)), t, sizeof(*t));
|
||||
CheckMemoryIntervalsAreOk(mm);
|
||||
CHECK_NE(-1, TrackMemoryInterval(mm, x, y, h, 0, 0, 0, 0, 0, 0));
|
||||
CHECK_NE(-1, TrackMemoryInterval(mm, x, y, h, 0, 0, 0, 0, 0,
|
||||
(y - x) * FRAMESIZE + FRAMESIZE));
|
||||
CheckMemoryIntervalsAreOk(mm);
|
||||
CheckMemoryIntervalsEqual(mm, t + 1);
|
||||
free(mm);
|
||||
|
|
@ -88,7 +95,7 @@ static int RunReleaseMemoryIntervalsTest(const struct MemoryIntervals t[2],
|
|||
TEST(TrackMemoryInterval, TestEmpty) {
|
||||
static struct MemoryIntervals mm[2] = {
|
||||
{0, OPEN_MAX, 0, {}},
|
||||
{1, OPEN_MAX, 0, {{2, 2, 0}}},
|
||||
{1, OPEN_MAX, 0, {{2, 2, 0, FRAMESIZE}}},
|
||||
};
|
||||
mm[0].p = mm[0].s;
|
||||
mm[1].p = mm[1].s;
|
||||
|
|
@ -114,8 +121,8 @@ TEST(TrackMemoryInterval, TestFull) {
|
|||
|
||||
TEST(TrackMemoryInterval, TestAppend) {
|
||||
static struct MemoryIntervals mm[2] = {
|
||||
{1, OPEN_MAX, 0, {{2, 2}}},
|
||||
{1, OPEN_MAX, 0, {{2, 3}}},
|
||||
{1, OPEN_MAX, 0, {I(2, 2)}},
|
||||
{1, OPEN_MAX, 0, {I(2, 3)}},
|
||||
};
|
||||
mm[0].p = mm[0].s;
|
||||
mm[1].p = mm[1].s;
|
||||
|
|
@ -124,8 +131,8 @@ TEST(TrackMemoryInterval, TestAppend) {
|
|||
|
||||
TEST(TrackMemoryInterval, TestPrepend) {
|
||||
static struct MemoryIntervals mm[2] = {
|
||||
{1, OPEN_MAX, 0, {{2, 2}}},
|
||||
{1, OPEN_MAX, 0, {{1, 2}}},
|
||||
{1, OPEN_MAX, 0, {I(2, 2)}},
|
||||
{1, OPEN_MAX, 0, {I(1, 2)}},
|
||||
};
|
||||
mm[0].p = mm[0].s;
|
||||
mm[1].p = mm[1].s;
|
||||
|
|
@ -134,8 +141,8 @@ TEST(TrackMemoryInterval, TestPrepend) {
|
|||
|
||||
TEST(TrackMemoryInterval, TestFillHole) {
|
||||
static struct MemoryIntervals mm[2] = {
|
||||
{4, OPEN_MAX, 0, {{1, 1}, {3, 4}, {5, 5, 1}, {6, 8}}},
|
||||
{3, OPEN_MAX, 0, {{1, 4}, {5, 5, 1}, {6, 8}}},
|
||||
{4, OPEN_MAX, 0, {I(1, 1), I(3, 4), {5, 5, 1, FRAMESIZE}, I(6, 8)}},
|
||||
{3, OPEN_MAX, 0, {I(1, 4), {5, 5, 1, FRAMESIZE}, I(6, 8)}},
|
||||
};
|
||||
mm[0].p = mm[0].s;
|
||||
mm[1].p = mm[1].s;
|
||||
|
|
@ -144,8 +151,8 @@ TEST(TrackMemoryInterval, TestFillHole) {
|
|||
|
||||
TEST(TrackMemoryInterval, TestAppend2) {
|
||||
static struct MemoryIntervals mm[2] = {
|
||||
{1, OPEN_MAX, 0, {{2, 2}}},
|
||||
{2, OPEN_MAX, 0, {{2, 2}, {3, 3, 1}}},
|
||||
{1, OPEN_MAX, 0, {I(2, 2)}},
|
||||
{2, OPEN_MAX, 0, {I(2, 2), {3, 3, 1, FRAMESIZE}}},
|
||||
};
|
||||
mm[0].p = mm[0].s;
|
||||
mm[1].p = mm[1].s;
|
||||
|
|
@ -154,8 +161,8 @@ TEST(TrackMemoryInterval, TestAppend2) {
|
|||
|
||||
TEST(TrackMemoryInterval, TestPrepend2) {
|
||||
static struct MemoryIntervals mm[2] = {
|
||||
{1, OPEN_MAX, 0, {{2, 2}}},
|
||||
{2, OPEN_MAX, 0, {{1, 1, 1}, {2, 2}}},
|
||||
{1, OPEN_MAX, 0, {I(2, 2)}},
|
||||
{2, OPEN_MAX, 0, {{1, 1, 1, FRAMESIZE}, I(2, 2)}},
|
||||
};
|
||||
mm[0].p = mm[0].s;
|
||||
mm[1].p = mm[1].s;
|
||||
|
|
@ -164,8 +171,25 @@ TEST(TrackMemoryInterval, TestPrepend2) {
|
|||
|
||||
TEST(TrackMemoryInterval, TestFillHole2) {
|
||||
static struct MemoryIntervals mm[2] = {
|
||||
{4, OPEN_MAX, 0, {{1, 1}, {3, 4}, {5, 5, 1}, {6, 8}}},
|
||||
{5, OPEN_MAX, 0, {{1, 1}, {2, 2, 1}, {3, 4}, {5, 5, 1}, {6, 8}}},
|
||||
{4,
|
||||
OPEN_MAX,
|
||||
0,
|
||||
{
|
||||
I(1, 1),
|
||||
I(3, 4),
|
||||
{5, 5, 1, FRAMESIZE},
|
||||
I(6, 8),
|
||||
}},
|
||||
{5,
|
||||
OPEN_MAX,
|
||||
0,
|
||||
{
|
||||
I(1, 1),
|
||||
{2, 2, 1, FRAMESIZE},
|
||||
{3, 4, 0, FRAMESIZE * 2},
|
||||
{5, 5, 1, FRAMESIZE},
|
||||
{6, 8, 0, FRAMESIZE * 3},
|
||||
}},
|
||||
};
|
||||
mm[0].p = mm[0].s;
|
||||
mm[1].p = mm[1].s;
|
||||
|
|
@ -211,8 +235,8 @@ TEST(ReleaseMemoryIntervals, TestEmpty) {
|
|||
|
||||
TEST(ReleaseMemoryIntervals, TestRemoveElement_UsesInclusiveRange) {
|
||||
static struct MemoryIntervals mm[2] = {
|
||||
{3, OPEN_MAX, 0, {{0, 0}, {2, 2}, {4, 4}}},
|
||||
{2, OPEN_MAX, 0, {{0, 0}, {4, 4}}},
|
||||
{3, OPEN_MAX, 0, {I(0, 0), I(2, 2), I(4, 4)}},
|
||||
{2, OPEN_MAX, 0, {I(0, 0), I(4, 4)}},
|
||||
};
|
||||
mm[0].p = mm[0].s;
|
||||
mm[1].p = mm[1].s;
|
||||
|
|
@ -221,8 +245,8 @@ TEST(ReleaseMemoryIntervals, TestRemoveElement_UsesInclusiveRange) {
|
|||
|
||||
TEST(ReleaseMemoryIntervals, TestPunchHole) {
|
||||
static struct MemoryIntervals mm[2] = {
|
||||
{1, OPEN_MAX, 0, {{0, 9}}},
|
||||
{2, OPEN_MAX, 0, {{0, 3}, {6, 9}}},
|
||||
{1, OPEN_MAX, 0, {I(0, 9)}},
|
||||
{2, OPEN_MAX, 0, {I(0, 3), I(6, 9)}},
|
||||
};
|
||||
mm[0].p = mm[0].s;
|
||||
mm[1].p = mm[1].s;
|
||||
|
|
@ -232,8 +256,8 @@ TEST(ReleaseMemoryIntervals, TestPunchHole) {
|
|||
TEST(ReleaseMemoryIntervals, TestShortenLeft) {
|
||||
if (IsWindows()) return;
|
||||
static struct MemoryIntervals mm[2] = {
|
||||
{1, OPEN_MAX, 0, {{0, 9}}},
|
||||
{1, OPEN_MAX, 0, {{0, 7}}},
|
||||
{1, OPEN_MAX, 0, {I(0, 9)}},
|
||||
{1, OPEN_MAX, 0, {I(0, 7)}},
|
||||
};
|
||||
mm[0].p = mm[0].s;
|
||||
mm[1].p = mm[1].s;
|
||||
|
|
@ -243,8 +267,8 @@ TEST(ReleaseMemoryIntervals, TestShortenLeft) {
|
|||
TEST(ReleaseMemoryIntervals, TestShortenRight) {
|
||||
if (IsWindows()) return;
|
||||
static struct MemoryIntervals mm[2] = {
|
||||
{1, OPEN_MAX, 0, {{0, 9}}},
|
||||
{1, OPEN_MAX, 0, {{3, 9}}},
|
||||
{1, OPEN_MAX, 0, {I(0, 9)}},
|
||||
{1, OPEN_MAX, 0, {I(3, 9)}},
|
||||
};
|
||||
mm[0].p = mm[0].s;
|
||||
mm[1].p = mm[1].s;
|
||||
|
|
@ -254,8 +278,8 @@ TEST(ReleaseMemoryIntervals, TestShortenRight) {
|
|||
TEST(ReleaseMemoryIntervals, TestShortenLeft2) {
|
||||
if (IsWindows()) return;
|
||||
static struct MemoryIntervals mm[2] = {
|
||||
{1, OPEN_MAX, 0, {{0, 9}}},
|
||||
{1, OPEN_MAX, 0, {{0, 7}}},
|
||||
{1, OPEN_MAX, 0, {I(0, 9)}},
|
||||
{1, OPEN_MAX, 0, {I(0, 7)}},
|
||||
};
|
||||
mm[0].p = mm[0].s;
|
||||
mm[1].p = mm[1].s;
|
||||
|
|
@ -265,8 +289,8 @@ TEST(ReleaseMemoryIntervals, TestShortenLeft2) {
|
|||
TEST(ReleaseMemoryIntervals, TestShortenRight2) {
|
||||
if (IsWindows()) return;
|
||||
static struct MemoryIntervals mm[2] = {
|
||||
{1, OPEN_MAX, 0, {{0, 9}}},
|
||||
{1, OPEN_MAX, 0, {{3, 9}}},
|
||||
{1, OPEN_MAX, 0, {I(0, 9)}},
|
||||
{1, OPEN_MAX, 0, {I(3, 9)}},
|
||||
};
|
||||
mm[0].p = mm[0].s;
|
||||
mm[1].p = mm[1].s;
|
||||
|
|
@ -275,8 +299,8 @@ TEST(ReleaseMemoryIntervals, TestShortenRight2) {
|
|||
|
||||
TEST(ReleaseMemoryIntervals, TestZeroZero) {
|
||||
static struct MemoryIntervals mm[2] = {
|
||||
{1, OPEN_MAX, 0, {{3, 9}}},
|
||||
{1, OPEN_MAX, 0, {{3, 9}}},
|
||||
{1, OPEN_MAX, 0, {I(3, 9)}},
|
||||
{1, OPEN_MAX, 0, {I(3, 9)}},
|
||||
};
|
||||
mm[0].p = mm[0].s;
|
||||
mm[1].p = mm[1].s;
|
||||
|
|
@ -285,8 +309,8 @@ TEST(ReleaseMemoryIntervals, TestZeroZero) {
|
|||
|
||||
TEST(ReleaseMemoryIntervals, TestNoopLeft) {
|
||||
static struct MemoryIntervals mm[2] = {
|
||||
{1, OPEN_MAX, 0, {{3, 9}}},
|
||||
{1, OPEN_MAX, 0, {{3, 9}}},
|
||||
{1, OPEN_MAX, 0, {I(3, 9)}},
|
||||
{1, OPEN_MAX, 0, {I(3, 9)}},
|
||||
};
|
||||
mm[0].p = mm[0].s;
|
||||
mm[1].p = mm[1].s;
|
||||
|
|
@ -295,8 +319,8 @@ TEST(ReleaseMemoryIntervals, TestNoopLeft) {
|
|||
|
||||
TEST(ReleaseMemoryIntervals, TestNoopRight) {
|
||||
static struct MemoryIntervals mm[2] = {
|
||||
{1, OPEN_MAX, 0, {{3, 9}}},
|
||||
{1, OPEN_MAX, 0, {{3, 9}}},
|
||||
{1, OPEN_MAX, 0, {I(3, 9)}},
|
||||
{1, OPEN_MAX, 0, {I(3, 9)}},
|
||||
};
|
||||
mm[0].p = mm[0].s;
|
||||
mm[1].p = mm[1].s;
|
||||
|
|
@ -305,7 +329,7 @@ TEST(ReleaseMemoryIntervals, TestNoopRight) {
|
|||
|
||||
TEST(ReleaseMemoryIntervals, TestBigFree) {
|
||||
static struct MemoryIntervals mm[2] = {
|
||||
{2, OPEN_MAX, 0, {{0, 3}, {6, 9}}},
|
||||
{2, OPEN_MAX, 0, {I(0, 3), I(6, 9)}},
|
||||
{0, OPEN_MAX, 0, {}},
|
||||
};
|
||||
mm[0].p = mm[0].s;
|
||||
|
|
@ -315,8 +339,8 @@ TEST(ReleaseMemoryIntervals, TestBigFree) {
|
|||
|
||||
TEST(ReleaseMemoryIntervals, TestWeirdGap) {
|
||||
static struct MemoryIntervals mm[2] = {
|
||||
{3, OPEN_MAX, 0, {{10, 10}, {20, 20}, {30, 30}}},
|
||||
{2, OPEN_MAX, 0, {{10, 10}, {30, 30}}},
|
||||
{3, OPEN_MAX, 0, {I(10, 10), I(20, 20), I(30, 30)}},
|
||||
{2, OPEN_MAX, 0, {I(10, 10), I(30, 30)}},
|
||||
};
|
||||
mm[0].p = mm[0].s;
|
||||
mm[1].p = mm[1].s;
|
||||
|
|
|
|||
|
|
@ -16,9 +16,11 @@
|
|||
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
|
||||
│ PERFORMANCE OF THIS SOFTWARE. │
|
||||
╚─────────────────────────────────────────────────────────────────────────────*/
|
||||
#include "libc/bits/atomic.h"
|
||||
#include "libc/bits/bits.h"
|
||||
#include "libc/bits/xchg.internal.h"
|
||||
#include "libc/calls/calls.h"
|
||||
#include "libc/calls/ucontext.h"
|
||||
#include "libc/dce.h"
|
||||
#include "libc/fmt/fmt.h"
|
||||
#include "libc/intrin/kprintf.h"
|
||||
|
|
@ -36,9 +38,12 @@
|
|||
#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/x.h"
|
||||
#include "third_party/xed/x86.h"
|
||||
|
||||
char testlib_enable_tmp_setup_teardown;
|
||||
|
||||
|
|
|
|||
232
test/libc/runtime/munmap_test.c
Normal file
232
test/libc/runtime/munmap_test.c
Normal file
|
|
@ -0,0 +1,232 @@
|
|||
/*-*- 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 2022 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 "libc/bits/atomic.h"
|
||||
#include "libc/calls/calls.h"
|
||||
#include "libc/calls/struct/sigaction.h"
|
||||
#include "libc/calls/struct/siginfo.h"
|
||||
#include "libc/calls/ucontext.h"
|
||||
#include "libc/intrin/kprintf.h"
|
||||
#include "libc/runtime/memtrack.internal.h"
|
||||
#include "libc/runtime/runtime.h"
|
||||
#include "libc/sysv/consts/map.h"
|
||||
#include "libc/sysv/consts/o.h"
|
||||
#include "libc/sysv/consts/prot.h"
|
||||
#include "libc/sysv/consts/sa.h"
|
||||
#include "libc/testlib/testlib.h"
|
||||
#include "third_party/xed/x86.h"
|
||||
|
||||
int gotsignal;
|
||||
char testlib_enable_tmp_setup_teardown;
|
||||
|
||||
void ContinueOnError(int sig, siginfo_t *si, ucontext_t *ctx) {
|
||||
struct XedDecodedInst xedd;
|
||||
xed_decoded_inst_zero_set_mode(&xedd, XED_MACHINE_MODE_LONG_64);
|
||||
xed_instruction_length_decode(&xedd, (void *)ctx->uc_mcontext.rip, 15);
|
||||
ctx->uc_mcontext.rip += xedd.length;
|
||||
gotsignal = sig;
|
||||
}
|
||||
|
||||
noasan bool MemoryExists(char *p) {
|
||||
volatile char c;
|
||||
struct sigaction old[2];
|
||||
struct sigaction sa = {
|
||||
.sa_sigaction = ContinueOnError,
|
||||
.sa_flags = SA_SIGINFO,
|
||||
};
|
||||
gotsignal = 0;
|
||||
sigaction(SIGSEGV, &sa, old + 0);
|
||||
sigaction(SIGBUS, &sa, old + 1);
|
||||
c = atomic_load(p);
|
||||
sigaction(SIGSEGV, old + 0, 0);
|
||||
sigaction(SIGBUS, old + 1, 0);
|
||||
return !gotsignal;
|
||||
}
|
||||
|
||||
TEST(munmap, doesntExist_doesntCare) {
|
||||
EXPECT_SYS(0, 0, munmap(0, FRAMESIZE * 8));
|
||||
if (IsAsan()) {
|
||||
// make sure it didn't unmap the null pointer shadow memory
|
||||
EXPECT_TRUE(MemoryExists((char *)0x7fff8000));
|
||||
}
|
||||
}
|
||||
|
||||
TEST(munmap, test) {
|
||||
char *p;
|
||||
ASSERT_NE(MAP_FAILED, (p = mmap(0, FRAMESIZE, PROT_READ | PROT_WRITE,
|
||||
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
|
||||
EXPECT_TRUE(MemoryExists(p));
|
||||
EXPECT_SYS(0, 0, munmap(p, FRAMESIZE));
|
||||
EXPECT_FALSE(MemoryExists(p));
|
||||
}
|
||||
|
||||
TEST(munmap, invalidParams) {
|
||||
EXPECT_SYS(EINVAL, -1, munmap(0, 0));
|
||||
EXPECT_SYS(EINVAL, -1, munmap((void *)0x100080000000, 0));
|
||||
EXPECT_SYS(EINVAL, -1, munmap((void *)0x100080000001, FRAMESIZE));
|
||||
}
|
||||
|
||||
TEST(munmap, punchHoleInMemory) {
|
||||
char *p;
|
||||
ASSERT_NE(MAP_FAILED, (p = mmap(0, FRAMESIZE * 3, PROT_READ | PROT_WRITE,
|
||||
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
|
||||
EXPECT_TRUE(MemoryExists(p + FRAMESIZE * 0));
|
||||
EXPECT_TRUE(MemoryExists(p + FRAMESIZE * 1));
|
||||
EXPECT_TRUE(MemoryExists(p + FRAMESIZE * 2));
|
||||
EXPECT_SYS(0, 0, munmap(p + FRAMESIZE, FRAMESIZE));
|
||||
EXPECT_TRUE(MemoryExists(p + FRAMESIZE * 0));
|
||||
EXPECT_FALSE(MemoryExists(p + FRAMESIZE * 1));
|
||||
EXPECT_TRUE(MemoryExists(p + FRAMESIZE * 2));
|
||||
EXPECT_SYS(0, 0, munmap(p, FRAMESIZE));
|
||||
EXPECT_SYS(0, 0, munmap(p + FRAMESIZE * 2, FRAMESIZE));
|
||||
EXPECT_FALSE(MemoryExists(p + FRAMESIZE * 0));
|
||||
EXPECT_FALSE(MemoryExists(p + FRAMESIZE * 1));
|
||||
EXPECT_FALSE(MemoryExists(p + FRAMESIZE * 2));
|
||||
}
|
||||
|
||||
TEST(munmap, memoryHasHole) {
|
||||
char *p;
|
||||
ASSERT_NE(MAP_FAILED, (p = mmap(0, FRAMESIZE * 3, PROT_READ | PROT_WRITE,
|
||||
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
|
||||
EXPECT_SYS(0, 0, munmap(p + FRAMESIZE, FRAMESIZE));
|
||||
EXPECT_TRUE(MemoryExists(p + FRAMESIZE * 0));
|
||||
EXPECT_FALSE(MemoryExists(p + FRAMESIZE * 1));
|
||||
EXPECT_TRUE(MemoryExists(p + FRAMESIZE * 2));
|
||||
EXPECT_SYS(0, 0, munmap(p, FRAMESIZE * 3));
|
||||
EXPECT_FALSE(MemoryExists(p + FRAMESIZE * 0));
|
||||
EXPECT_FALSE(MemoryExists(p + FRAMESIZE * 1));
|
||||
EXPECT_FALSE(MemoryExists(p + FRAMESIZE * 2));
|
||||
}
|
||||
|
||||
TEST(munmap, blanketFree) {
|
||||
char *p;
|
||||
ASSERT_NE(MAP_FAILED, (p = mmap(0, FRAMESIZE * 3, PROT_READ | PROT_WRITE,
|
||||
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
|
||||
EXPECT_TRUE(MemoryExists(p + FRAMESIZE * 0));
|
||||
EXPECT_TRUE(MemoryExists(p + FRAMESIZE * 1));
|
||||
EXPECT_TRUE(MemoryExists(p + FRAMESIZE * 2));
|
||||
EXPECT_SYS(0, 0, munmap(p + FRAMESIZE * 0, FRAMESIZE));
|
||||
EXPECT_SYS(0, 0, munmap(p + FRAMESIZE * 2, FRAMESIZE));
|
||||
EXPECT_FALSE(MemoryExists(p + FRAMESIZE * 0));
|
||||
EXPECT_TRUE(MemoryExists(p + FRAMESIZE * 1));
|
||||
EXPECT_FALSE(MemoryExists(p + FRAMESIZE * 2));
|
||||
EXPECT_SYS(0, 0, munmap(p, FRAMESIZE * 3));
|
||||
EXPECT_FALSE(MemoryExists(p + FRAMESIZE * 0));
|
||||
EXPECT_FALSE(MemoryExists(p + FRAMESIZE * 1));
|
||||
EXPECT_FALSE(MemoryExists(p + FRAMESIZE * 2));
|
||||
}
|
||||
|
||||
TEST(munmap, trimLeft) {
|
||||
char *p;
|
||||
ASSERT_NE(MAP_FAILED, (p = mmap(0, FRAMESIZE * 2, PROT_READ | PROT_WRITE,
|
||||
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
|
||||
EXPECT_TRUE(MemoryExists(p + FRAMESIZE * 0));
|
||||
EXPECT_TRUE(MemoryExists(p + FRAMESIZE * 1));
|
||||
EXPECT_SYS(0, 0, munmap(p, FRAMESIZE));
|
||||
EXPECT_FALSE(MemoryExists(p + FRAMESIZE * 0));
|
||||
EXPECT_TRUE(MemoryExists(p + FRAMESIZE * 1));
|
||||
EXPECT_SYS(0, 0, munmap(p, FRAMESIZE * 2));
|
||||
EXPECT_FALSE(MemoryExists(p + FRAMESIZE * 0));
|
||||
EXPECT_FALSE(MemoryExists(p + FRAMESIZE * 1));
|
||||
}
|
||||
|
||||
TEST(munmap, trimRight) {
|
||||
char *p;
|
||||
ASSERT_NE(MAP_FAILED, (p = mmap(0, FRAMESIZE * 2, PROT_READ | PROT_WRITE,
|
||||
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
|
||||
EXPECT_TRUE(MemoryExists(p + FRAMESIZE * 0));
|
||||
EXPECT_TRUE(MemoryExists(p + FRAMESIZE * 1));
|
||||
EXPECT_SYS(0, 0, munmap(p + FRAMESIZE, FRAMESIZE));
|
||||
EXPECT_TRUE(MemoryExists(p + FRAMESIZE * 0));
|
||||
EXPECT_FALSE(MemoryExists(p + FRAMESIZE * 1));
|
||||
EXPECT_SYS(0, 0, munmap(p, FRAMESIZE * 2));
|
||||
EXPECT_FALSE(MemoryExists(p + FRAMESIZE * 0));
|
||||
EXPECT_FALSE(MemoryExists(p + FRAMESIZE * 1));
|
||||
}
|
||||
|
||||
TEST(munmap, memoryGone) {
|
||||
char *p;
|
||||
ASSERT_NE(MAP_FAILED, (p = mmap(0, FRAMESIZE, PROT_READ | PROT_WRITE,
|
||||
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
|
||||
EXPECT_SYS(0, 0, munmap(p, FRAMESIZE));
|
||||
EXPECT_SYS(0, 0, munmap(p, FRAMESIZE));
|
||||
}
|
||||
|
||||
TEST(munmap, testTooSmallToUnmapAsan) {
|
||||
if (!IsAsan()) return;
|
||||
char *p;
|
||||
ASSERT_NE(MAP_FAILED, (p = mmap(0, FRAMESIZE, PROT_READ | PROT_WRITE,
|
||||
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
|
||||
EXPECT_TRUE(MemoryExists((char *)(((intptr_t)p >> 3) + 0x7fff8000)));
|
||||
EXPECT_SYS(0, 0, munmap(p, FRAMESIZE));
|
||||
EXPECT_TRUE(MemoryExists((char *)(((intptr_t)p >> 3) + 0x7fff8000)));
|
||||
}
|
||||
|
||||
TEST(munmap, testLargeEnoughToUnmapAsan) {
|
||||
if (!IsAsan()) return;
|
||||
if (IsWindows()) {
|
||||
// we're unfortunately never able to unmap asan pages on windows
|
||||
// because the memtrack array items always have to be 64kb so we
|
||||
// we're able to store a handle for each
|
||||
return;
|
||||
}
|
||||
char *p;
|
||||
size_t n;
|
||||
n = FRAMESIZE * 8 * 2;
|
||||
ASSERT_NE(MAP_FAILED, (p = mmap(0, n, PROT_READ | PROT_WRITE,
|
||||
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
|
||||
EXPECT_SYS(0, 0, munmap(p, n));
|
||||
#if 0
|
||||
EXPECT_FALSE(
|
||||
MemoryExists((char *)(((intptr_t)(p + n / 2) >> 3) + 0x7fff8000)));
|
||||
#endif
|
||||
}
|
||||
|
||||
TEST(munmap, tinyFile_roundupUnmapSize) {
|
||||
char *p;
|
||||
ASSERT_SYS(0, 3, open("doge", O_WRONLY | O_CREAT | O_TRUNC, 0644));
|
||||
ASSERT_SYS(0, 5, write(3, "hello", 5));
|
||||
ASSERT_SYS(0, 0, close(3));
|
||||
ASSERT_SYS(0, 3, open("doge", O_RDONLY));
|
||||
ASSERT_NE(MAP_FAILED, (p = mmap(0, 5, PROT_READ, MAP_PRIVATE, 3, 0)));
|
||||
ASSERT_SYS(0, 0, close(3));
|
||||
EXPECT_TRUE(MemoryExists(p));
|
||||
// some kernels/versions support this, some don't
|
||||
// EXPECT_FALSE(MemoryExists(p + 5));
|
||||
EXPECT_SYS(0, 0, munmap(p, FRAMESIZE));
|
||||
EXPECT_FALSE(MemoryExists(p));
|
||||
EXPECT_FALSE(MemoryExists(p + 5));
|
||||
}
|
||||
|
||||
TEST(munmap, tinyFile_preciseUnmapSize) {
|
||||
char *p, *q;
|
||||
ASSERT_SYS(0, 3, open("doge", O_WRONLY | O_CREAT | O_TRUNC, 0644));
|
||||
ASSERT_SYS(0, 5, write(3, "hello", 5));
|
||||
ASSERT_SYS(0, 0, close(3));
|
||||
ASSERT_SYS(0, 3, open("doge", O_RDONLY));
|
||||
ASSERT_NE(MAP_FAILED, (p = mmap(0, 5, PROT_READ, MAP_PRIVATE, 3, 0)));
|
||||
ASSERT_NE(MAP_FAILED, (q = mmap(0, 5, PROT_READ, MAP_PRIVATE, 3, 0)));
|
||||
ASSERT_SYS(0, 0, close(3));
|
||||
EXPECT_TRUE(MemoryExists(p));
|
||||
EXPECT_TRUE(MemoryExists(q));
|
||||
EXPECT_SYS(0, 0, munmap(p, 5));
|
||||
EXPECT_FALSE(MemoryExists(p));
|
||||
EXPECT_TRUE(MemoryExists(q));
|
||||
EXPECT_SYS(0, 0, munmap(q, 5));
|
||||
EXPECT_FALSE(MemoryExists(q));
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue