mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-06-28 07:18:30 +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
|
|
@ -64,16 +64,16 @@ TEST(commandv, testPathSearch_appendsComExtension) {
|
|||
|
||||
TEST(commandv, testSlashes_wontSearchPath_butChecksAccess) {
|
||||
EXPECT_NE(-1, touch("home/sh", 0755));
|
||||
i = g_syscount;
|
||||
i = __syscount;
|
||||
EXPECT_STREQ("home/sh", commandv("home/sh", pathbuf, sizeof(pathbuf)));
|
||||
if (!IsWindows()) EXPECT_EQ(i + 1, g_syscount);
|
||||
if (!IsWindows()) EXPECT_EQ(i + 1, __syscount);
|
||||
}
|
||||
|
||||
TEST(commandv, testSlashes_wontSearchPath_butStillAppendsComExtension) {
|
||||
EXPECT_NE(-1, touch("home/sh.com", 0755));
|
||||
i = g_syscount;
|
||||
i = __syscount;
|
||||
EXPECT_STREQ("home/sh.com", commandv("home/sh", pathbuf, sizeof(pathbuf)));
|
||||
if (!IsWindows()) EXPECT_EQ(i + 2, g_syscount);
|
||||
if (!IsWindows()) EXPECT_EQ(i + 2, __syscount);
|
||||
}
|
||||
|
||||
TEST(commandv, testSameDir_doesntHappenByDefaultUnlessItsWindows) {
|
||||
|
|
|
|||
|
|
@ -34,30 +34,31 @@ void SetUp(void) {
|
|||
}
|
||||
|
||||
TEST(mkdir, testNothingExists_ENOENT) {
|
||||
EXPECT_EQ(-1, mkdir("yo/yo/yo", 0755));
|
||||
EXPECT_EQ(ENOENT, errno);
|
||||
EXPECT_SYS(ENOENT, -1, mkdir("yo/yo/yo", 0755));
|
||||
}
|
||||
|
||||
TEST(mkdir, testDirectoryComponentIsFile_ENOTDIR) {
|
||||
EXPECT_NE(-1, touch("yo", 0644));
|
||||
EXPECT_EQ(-1, mkdir("yo/yo/yo", 0755));
|
||||
EXPECT_EQ(ENOTDIR, errno);
|
||||
EXPECT_SYS(0, 0, touch("yo", 0644));
|
||||
EXPECT_SYS(ENOTDIR, -1, mkdir("yo/yo/yo", 0755));
|
||||
}
|
||||
|
||||
TEST(mkdir, testPathIsFile_EEXIST) {
|
||||
EXPECT_NE(-1, mkdir("yo", 0755));
|
||||
EXPECT_NE(-1, mkdir("yo/yo", 0755));
|
||||
EXPECT_NE(-1, touch("yo/yo/yo", 0644));
|
||||
EXPECT_EQ(-1, mkdir("yo/yo/yo", 0755));
|
||||
EXPECT_EQ(EEXIST, errno);
|
||||
EXPECT_SYS(0, 0, mkdir("yo", 0755));
|
||||
EXPECT_SYS(0, 0, mkdir("yo/yo", 0755));
|
||||
EXPECT_SYS(0, 0, touch("yo/yo/yo", 0644));
|
||||
EXPECT_SYS(EEXIST, -1, mkdir("yo/yo/yo", 0755));
|
||||
}
|
||||
|
||||
TEST(mkdir, testPathIsDirectory_EEXIST) {
|
||||
EXPECT_NE(-1, mkdir("yo", 0755));
|
||||
EXPECT_NE(-1, mkdir("yo/yo", 0755));
|
||||
EXPECT_NE(-1, mkdir("yo/yo/yo", 0755));
|
||||
EXPECT_EQ(-1, mkdir("yo/yo/yo", 0755));
|
||||
EXPECT_EQ(EEXIST, errno);
|
||||
EXPECT_SYS(0, 0, mkdir("yo", 0755));
|
||||
EXPECT_SYS(0, 0, mkdir("yo/yo", 0755));
|
||||
EXPECT_SYS(0, 0, mkdir("yo/yo/yo", 0755));
|
||||
EXPECT_SYS(EEXIST, -1, mkdir("yo/yo/yo", 0755));
|
||||
}
|
||||
|
||||
TEST(makedirs, pathExists_isSuccess) {
|
||||
EXPECT_SYS(0, 0, makedirs("foo/bar", 0755));
|
||||
EXPECT_SYS(0, 0, makedirs("foo/bar", 0755));
|
||||
}
|
||||
|
||||
TEST(mkdir, enametoolong) {
|
||||
|
|
@ -69,19 +70,17 @@ TEST(mkdir, enametoolong) {
|
|||
EXPECT_SYS(ENAMETOOLONG, -1, mkdir(s, 0644));
|
||||
}
|
||||
|
||||
TEST(makedirs, testEmptyString_EEXIST) {
|
||||
EXPECT_EQ(-1, mkdir("", 0755));
|
||||
EXPECT_EQ(ENOENT, errno);
|
||||
TEST(makedirs, testEmptyString_ENOENT) {
|
||||
EXPECT_SYS(ENOENT, -1, mkdir("", 0755));
|
||||
}
|
||||
|
||||
TEST(mkdirat, testRelativePath_opensRelativeToDirFd) {
|
||||
int dirfd;
|
||||
ASSERT_NE(-1, mkdir("foo", 0755));
|
||||
ASSERT_NE(-1, (dirfd = open("foo", O_RDONLY | O_DIRECTORY)));
|
||||
EXPECT_NE(-1, mkdirat(dirfd, "bar", 0755));
|
||||
ASSERT_SYS(0, 0, mkdir("foo", 0755));
|
||||
ASSERT_SYS(0, 3, (dirfd = open("foo", O_RDONLY | O_DIRECTORY)));
|
||||
EXPECT_SYS(0, 0, mkdirat(dirfd, "bar", 0755));
|
||||
EXPECT_TRUE(isdirectory("foo/bar"));
|
||||
EXPECT_EQ(-1, makedirs("", 0755));
|
||||
EXPECT_NE(-1, close(dirfd));
|
||||
EXPECT_SYS(0, 0, close(dirfd));
|
||||
}
|
||||
|
||||
TEST(mkdir, longname) {
|
||||
|
|
|
|||
|
|
@ -94,9 +94,13 @@ TEST(LengthInt64Thousands, test) {
|
|||
}
|
||||
|
||||
BENCH(LengthInt64, bench) {
|
||||
EZBENCH2("LengthInt64", donothing, LengthInt64(INT64_MIN));
|
||||
EZBENCH2("LengthUint64", donothing, LengthUint64(UINT64_MAX));
|
||||
EZBENCH2("LengthInt64Thousands", donothing, LengthInt64Thousands(INT64_MIN));
|
||||
unsigned LengthInt64_(int64_t) asm("LengthInt64");
|
||||
unsigned LengthUint64_(uint64_t) asm("LengthUint64");
|
||||
unsigned LengthInt64Thousands_(int64_t) asm("LengthInt64Thousands");
|
||||
unsigned LengthUint64Thousands_(uint64_t) asm("LengthUint64Thousands");
|
||||
EZBENCH2("LengthInt64", donothing, LengthInt64_(INT64_MIN));
|
||||
EZBENCH2("LengthUint64", donothing, LengthUint64_(UINT64_MAX));
|
||||
EZBENCH2("LengthInt64Thousands", donothing, LengthInt64Thousands_(INT64_MIN));
|
||||
EZBENCH2("LengthUint64Thousands", donothing,
|
||||
LengthUint64Thousands(UINT64_MAX));
|
||||
LengthUint64Thousands_(UINT64_MAX));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -43,8 +43,7 @@
|
|||
*/
|
||||
static uint64_t Rando(void) {
|
||||
uint64_t x;
|
||||
do
|
||||
x = lemur64();
|
||||
do x = lemur64();
|
||||
while (((x ^ READ64LE("!!!!!!!!")) - 0x0101010101010101) &
|
||||
~(x ^ READ64LE("!!!!!!!!")) & 0x8080808080808080);
|
||||
return x;
|
||||
|
|
@ -249,9 +248,9 @@ TEST(kprintf, testFailure_wontClobberErrnoAndBypassesSystemCallSupport) {
|
|||
ASSERT_EQ(0, errno);
|
||||
EXPECT_SYS(0, 3, dup(2));
|
||||
EXPECT_SYS(0, 0, close(2));
|
||||
n = g_syscount;
|
||||
n = __syscount;
|
||||
kprintf("hello%n");
|
||||
EXPECT_EQ(n, g_syscount);
|
||||
EXPECT_EQ(n, __syscount);
|
||||
EXPECT_EQ(0, errno);
|
||||
EXPECT_SYS(0, 2, dup2(3, 2));
|
||||
EXPECT_SYS(0, 0, close(3));
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@
|
|||
#include "libc/calls/struct/sigset.h"
|
||||
#include "libc/dce.h"
|
||||
#include "libc/errno.h"
|
||||
#include "libc/intrin/kprintf.h"
|
||||
#include "libc/intrin/spinlock.h"
|
||||
#include "libc/macros.internal.h"
|
||||
#include "libc/nexgen32e/threaded.h"
|
||||
|
|
@ -40,20 +41,26 @@
|
|||
#define ENTRIES 256
|
||||
|
||||
char locks[THREADS];
|
||||
volatile bool ready;
|
||||
_Atomic(bool) ready;
|
||||
volatile uint64_t A[THREADS * ENTRIES];
|
||||
|
||||
void OnChld(int sig) {
|
||||
// do nothing
|
||||
}
|
||||
|
||||
dontinline void Pause(void) {
|
||||
__builtin_ia32_pause();
|
||||
}
|
||||
|
||||
dontinline void Generate(int i) {
|
||||
A[i] = rand64();
|
||||
}
|
||||
|
||||
int Thrasher(void *arg) {
|
||||
int i, id = (intptr_t)arg;
|
||||
while (!ready) {
|
||||
__builtin_ia32_pause();
|
||||
}
|
||||
while (!ready) Pause();
|
||||
for (i = 0; i < ENTRIES; ++i) {
|
||||
A[id * ENTRIES + i] = rand64();
|
||||
Generate(id * ENTRIES + i);
|
||||
}
|
||||
_spunlock(locks + id);
|
||||
return 0;
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
}
|
||||
|
|
@ -53,20 +53,20 @@ TEST(undeflate, testStatCentralDirectory_notFound_noSysCalls) {
|
|||
uint64_t c;
|
||||
struct stat st;
|
||||
stat("/zip/doge.txt", &st); /* warmup */
|
||||
c = g_syscount;
|
||||
c = __syscount;
|
||||
ASSERT_EQ(-1, stat("/zip/doge.txt", &st));
|
||||
ASSERT_EQ(0, g_syscount - c);
|
||||
ASSERT_EQ(0, __syscount - c);
|
||||
ASSERT_EQ(ENOENT, errno);
|
||||
}
|
||||
|
||||
TEST(undeflate, testStatCentralDirectory_isFound_noSysCalls) {
|
||||
uint64_t c;
|
||||
struct stat st = {0};
|
||||
c = g_syscount;
|
||||
c = __syscount;
|
||||
ASSERT_NE(-1, stat("/zip/libc/testlib/hyperion.txt", &st));
|
||||
ASSERT_TRUE(S_ISREG(st.st_mode));
|
||||
ASSERT_EQ(kHyperionSize, st.st_size);
|
||||
ASSERT_EQ(0, g_syscount - c);
|
||||
ASSERT_EQ(0, __syscount - c);
|
||||
}
|
||||
|
||||
TEST(undeflate, testOpenReadCloseEmbeddedZip) {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue