mirrors/cosmopolitan
1
0
Fork 0
mirror of https://github.com/jart/cosmopolitan.git synced 2025-05-23 13:52:28 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Make important improvements

Browse source 
- Fix preadv() and pwritev() for old distros
- Introduce _npassert() and _unassert() macros
- Prove that file locks work properly on Windows
- Support fcntl(F_DUPFD_CLOEXEC) on more systems
This commit is contained in:
Justine Tunney 2022-09-14 21:29:50 -07:00
parent 1ad2f530f9
commit 3f49889841
No known key found for this signature in database
GPG key ID: BE714B4575D6E328
130 changed files with 1225 additions and 431 deletions
Download patch file Download diff file Expand all files Collapse all files

79
test/libc/calls/fcntl_test.c
View file

@ -30,8 +30,29 @@
#include "libc/sysv/consts/o.h"
#include "libc/sysv/consts/sig.h"
#include "libc/testlib/testlib.h"
#include "libc/thread/thread.h"
#include "libc/x/x.h"
int Lock(int fd, int type, long start, long len) {
int e;
struct flock lock = {
.l_type = type,
.l_whence = SEEK_SET,
.l_start = start,
.l_len = len,
};
e = errno;
while (fcntl(fd, F_SETLK, &lock)) {
if (errno == EAGAIN || errno == EACCES) {
errno = e;
continue;
} else {
return -1;
}
}
return 0;
}
char testlib_enable_tmp_setup_teardown;
TEST(fcntl_getfl, testRemembersAccessMode) {
@ -70,59 +91,15 @@ TEST(fcntl, getfd) {
ASSERT_SYS(0, 0, close(3));
}
void OnSig(int sig) {
TEST(fcntl, F_DUPFD_CLOEXEC) {
ASSERT_SYS(0, 3, open("/dev/null", O_RDWR));
ASSERT_SYS(0, 5, fcntl(3, F_DUPFD_CLOEXEC, 5));
ASSERT_SYS(0, FD_CLOEXEC, fcntl(5, F_GETFD));
ASSERT_SYS(0, 0, close(5));
ASSERT_SYS(0, 0, close(3));
}
TEST(posixAdvisoryLocks, oneProcess_unlockedFromOwnPerspectiveHuh) {
struct flock lock;
ASSERT_SYS(0, 3, open("foo", O_RDWR | O_CREAT | O_TRUNC, 0644));
ASSERT_SYS(0, 5, write(3, "hello", 5));
// set lock
lock.l_type = F_WRLCK;
lock.l_whence = SEEK_SET;
lock.l_start = 1;
lock.l_len = 3;
lock.l_pid = -2;
ASSERT_SYS(0, 0, fcntl(3, F_SETLK, &lock));
EXPECT_EQ(F_WRLCK, lock.l_type);
EXPECT_EQ(SEEK_SET, lock.l_whence);
EXPECT_EQ(1, lock.l_start);
EXPECT_EQ(3, lock.l_len);
EXPECT_EQ(-2, lock.l_pid);
ASSERT_SYS(0, 4, open("foo", O_RDWR));
// try lock
lock.l_type = F_WRLCK;
lock.l_whence = SEEK_SET;
lock.l_start = 0;
lock.l_len = 0;
lock.l_pid = -1;
ASSERT_SYS(0, 0, fcntl(4, F_SETLK, &lock));
EXPECT_EQ(F_WRLCK, lock.l_type);
EXPECT_EQ(SEEK_SET, lock.l_whence);
EXPECT_EQ(0, lock.l_start);
EXPECT_EQ(0, lock.l_len);
EXPECT_EQ(-1, lock.l_pid);
// get lock information
if (!IsWindows()) {
lock.l_type = F_RDLCK;
lock.l_whence = SEEK_SET;
lock.l_start = 0;
lock.l_len = 0;
lock.l_pid = -7;
ASSERT_SYS(0, 0, fcntl(4, F_GETLK, &lock));
EXPECT_EQ(F_UNLCK, lock.l_type);
EXPECT_EQ(SEEK_SET, lock.l_whence);
EXPECT_EQ(0, lock.l_start);
EXPECT_EQ(0, lock.l_len);
EXPECT_EQ(-7, lock.l_pid); // doesn't change due to F_UNLCK
}
ASSERT_SYS(0, 0, close(4));
ASSERT_SYS(0, 0, close(3));
void OnSig(int sig) {
}
TEST(posixAdvisoryLocks, twoProcesses) {

186
test/libc/calls/lock_test.c Normal file
View file

@ -0,0 +1,186 @@
/*-*- 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/calls/calls.h"
#include "libc/calls/struct/flock.h"
#include "libc/dce.h"
#include "libc/errno.h"
#include "libc/intrin/kprintf.h"
#include "libc/macros.internal.h"
#include "libc/runtime/runtime.h"
#include "libc/sysv/consts/f.h"
#include "libc/sysv/consts/o.h"
#include "libc/testlib/testlib.h"
#include "libc/thread/thread.h"
/**
* @fileoverview POSIX Advisory Locks Test
*/
#define PROCESSES 8
#define THREADS (IsWindows() ? 8 : 0)
#define RATIO 3
#define ITERATIONS 10
char testlib_enable_tmp_setup_teardown;
_Thread_local const char *kind;
void Log(const char *fmt, ...) {
#if 0
va_list va;
char b[512];
int i, n = sizeof(b);
va_start(va, fmt);
i = ksnprintf(b, n, "%s pid=%d tid=%d ", kind, getpid(), gettid());
i += kvsnprintf(b + i, MAX(0, n - i), fmt, va);
i += ksnprintf(b + i, MAX(0, n - i), "\n");
write(2, b, MIN(i, n));
va_end(va);
#endif
}
void Lock(int fd, int type, long start, long len) {
int e;
struct flock lock = {
.l_type = type,
.l_whence = SEEK_SET,
.l_start = start,
.l_len = len,
};
e = errno;
while (fcntl(fd, F_SETLK, &lock)) {
ASSERT_TRUE(errno == EAGAIN || errno == EACCES);
errno = e;
Log("flock spinning on %d", fd);
}
}
void WriteLock(int fd, long start, long len) {
Lock(fd, F_WRLCK, start, len);
Log("acquired write lock on %d", fd);
}
void ReadLock(int fd, long start, long len) {
Lock(fd, F_RDLCK, start, len);
Log("acquired read lock on %d", fd);
}
void Unlock(int fd, long start, long len) {
Lock(fd, F_UNLCK, start, len);
Log("released lock on %d", fd);
}
void *Reader(void *arg) {
int i, j, fd;
char buf[10];
kind = arg;
ASSERT_NE(-1, (fd = open("db", O_RDONLY)));
for (j = 0; j < ITERATIONS; ++j) {
ReadLock(fd, 10, 10);
for (i = 0; i < 10; ++i) {
ASSERT_SYS(0, 1, pread(fd, buf + i, 1, 10 + i));
ASSERT_EQ(buf[0], buf[i]);
}
Unlock(fd, 10, 10);
sched_yield();
}
ASSERT_SYS(0, 0, close(fd));
return 0;
}
void *Writer(void *arg) {
int i, j, fd;
char buf[10];
kind = arg;
ASSERT_NE(-1, (fd = open("db", O_RDWR)));
for (j = 0; j < ITERATIONS; ++j) {
WriteLock(fd, 10, 10);
for (i = 0; i < 10; ++i) {
ASSERT_SYS(0, 1, pread(fd, buf + i, 1, 10 + i));
ASSERT_EQ(buf[0], buf[i]);
}
for (i = 0; i < 10; ++i) {
buf[i]++;
}
for (i = 0; i < 10; ++i) {
ASSERT_SYS(0, 1, pwrite(fd, buf + i, 1, 10 + i));
}
Unlock(fd, 10, 10);
sched_yield();
}
ASSERT_SYS(0, 0, close(fd));
return 0;
}
TEST(posixAdvisoryLocks, threadsAndProcessesFightingForLock) {
int i, rc, pid, fd, ws;
pthread_t th[THREADS + 1];
ASSERT_SYS(0, 3, creat("db", 0644));
ASSERT_SYS(0, 0, ftruncate(3, 30));
ASSERT_SYS(0, 0, close(3));
for (i = 0; i < THREADS; ++i) {
if (i % RATIO == 0) {
ASSERT_EQ(0, pthread_create(th + i, 0, Reader, "reader thread"));
} else {
ASSERT_EQ(0, pthread_create(th + i, 0, Writer, "writer thread"));
}
}
for (i = 0; i < PROCESSES; ++i) {
ASSERT_NE(-1, (rc = fork()));
if (!rc) {
if (i % RATIO == 0) {
Writer("writer process");
} else {
Reader("reader process");
}
_Exit(0);
}
}
ASSERT_NE(-1, (fd = open("db", O_RDWR)));
Lock(fd, F_WRLCK, 0, 10);
Lock(fd, F_WRLCK, 20, 10);
for (i = 0; i < THREADS; ++i) {
ASSERT_EQ(0, pthread_join(th[i], 0));
}
kind = "main process";
for (;;) {
int e = errno;
if ((pid = waitpid(0, &ws, 0)) != -1) {
if (WIFSIGNALED(ws)) {
Log("process %d terminated with %G", pid, WTERMSIG(ws));
testlib_incrementfailed();
} else if (WEXITSTATUS(ws)) {
Log("process %d exited with %d", pid, WEXITSTATUS(ws));
testlib_incrementfailed();
}
} else {
ASSERT_EQ(ECHILD, errno);
errno = e;
break;
}
}
ASSERT_SYS(0, 0, close(fd));
}

2
test/libc/calls/pledge_test.c
View file

@ -560,7 +560,7 @@ TEST(pledge_openbsd, bigSyscalls) {
int LockWorker(void *arg, int tid) {
flockfile(stdout);
ASSERT_EQ(gettid(), stdout->lock._owner);
ASSERT_EQ(gettid(), ((pthread_mutex_t *)stdout->lock)->_owner);
funlockfile(stdout);
return 0;
}

91
test/libc/calls/preadv_test.c Normal file
View file

@ -0,0 +1,91 @@
/*-*- 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/assert.h"
#include "libc/calls/calls.h"
#include "libc/calls/internal.h"
#include "libc/calls/struct/iovec.h"
#include "libc/errno.h"
#include "libc/nt/files.h"
#include "libc/sysv/consts/o.h"
#include "libc/testlib/testlib.h"
char testlib_enable_tmp_setup_teardown;
TEST(preadv, ebadf) {
EXPECT_SYS(EBADF, -1, preadv(-1, 0, 0, 0));
EXPECT_SYS(EBADF, -1, pwritev(-1, 0, 0, 0));
}
TEST(preadv, testOneIovecWorks_itDelegatesToPread) {
char b1[2] = "hi";
struct iovec v[1] = {{b1, 2}};
ASSERT_SYS(0, 3, open("foo", O_RDWR | O_CREAT | O_TRUNC, 0644));
EXPECT_SYS(0, 2, pwritev(3, v, 1, 0));
b1[0] = 0;
b1[1] = 0;
EXPECT_SYS(0, 0, preadv(3, 0, 0, 0));
EXPECT_SYS(0, 0, pwritev(3, 0, 0, 0));
EXPECT_SYS(0, 2, preadv(3, v, 1, 0));
ASSERT_EQ('h', b1[0]);
ASSERT_EQ('i', b1[1]);
b1[0] = 0;
b1[1] = 0x55;
EXPECT_SYS(0, 1, preadv(3, v, 1, 1));
ASSERT_EQ('i', b1[0]);
ASSERT_EQ(0x55, b1[1]);
ASSERT_SYS(0, 0, close(3));
}
TEST(preadv, testTwoIovecWorks_itMustDoItsThing) {
char b1[1] = "h";
char b2[1] = "i";
struct iovec v[2] = {{b1, 1}, {b2, 1}};
ASSERT_SYS(0, 3, open("foo", O_RDWR | O_CREAT | O_TRUNC, 0644));
EXPECT_SYS(0, 2, pwritev(3, v, 2, 0));
b1[0] = 0;
b2[0] = 0;
EXPECT_SYS(0, 2, preadv(3, v, 2, 0));
ASSERT_EQ('h', b1[0]);
ASSERT_EQ('i', b2[0]);
b1[0] = 0;
b2[0] = 0x55;
EXPECT_SYS(0, 1, preadv(3, v, 2, 1));
ASSERT_EQ('i', b1[0]);
ASSERT_EQ(0x55, b2[0]);
ASSERT_SYS(0, 0, close(3));
}
TEST(pwritev, writePastEof_zeroExtendsFile_alsoDoesntChangeFilePointer) {
char b[6] = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
char s[2] = "hi";
struct iovec v[1] = {{s, 2}};
ASSERT_SYS(0, 3, open("foo", O_RDWR | O_CREAT | O_TRUNC, 0644));
ASSERT_SYS(EINVAL, -1, pwritev(3, v, 1, -999));
ASSERT_SYS(0, 2, pwritev(3, v, 1, 0));
ASSERT_SYS(0, 2, pwritev(3, v, 1, 4));
ASSERT_SYS(0, 2, preadv(3, v, 1, 0));
ASSERT_SYS(0, 6, read(3, b, 6));
ASSERT_EQ('h', b[0]);
ASSERT_EQ('i', b[1]);
ASSERT_EQ(0, b[2]);
ASSERT_EQ(0, b[3]);
ASSERT_EQ('h', b[4]);
ASSERT_EQ('i', b[5]);
ASSERT_SYS(0, 0, close(3));
}

4
test/libc/calls/test.mk
View file

@ -38,6 +38,7 @@ TEST_LIBC_CALLS_DIRECTDEPS = \
LIBC_MEM \
LIBC_NEXGEN32E \
LIBC_STDIO \
LIBC_NT_KERNEL32 \
LIBC_SYSV_CALLS \
LIBC_RUNTIME \
LIBC_STR \
@ -103,6 +104,9 @@ o/$(MODE)/test/libc/calls/poll_test.com.runs: \
o/$(MODE)/test/libc/calls/fcntl_test.com.runs: \
private .PLEDGE = stdio rpath wpath cpath fattr proc flock
o/$(MODE)/test/libc/calls/lock_test.com.runs: \
private .PLEDGE = stdio rpath wpath cpath fattr proc flock
o/$(MODE)/test/libc/calls/openbsd_test.com.runs: \
private .PLEDGE = stdio rpath wpath cpath fattr proc unveil

5
test/libc/intrin/dos2errno_test.c
View file

@ -16,6 +16,7 @@
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/dce.h"
#include "libc/errno.h"
#include "libc/intrin/dos2errno.internal.h"
#include "libc/intrin/kprintf.h"
@ -28,4 +29,8 @@ TEST(__dos2errno, test) {
EXPECT_EQ(0, __dos2errno(0));
EXPECT_EQ(EACCES, __dos2errno(kNtErrorSectorNotFound));
EXPECT_EQ(EADDRNOTAVAIL, __dos2errno(kNtErrorInvalidNetname));
EXPECT_EQ(EAGAIN, __dos2errno(33));
if (IsWindows()) {
EXPECT_EQ(ENOLCK, __dos2errno(kNtErrorNotLocked));
}
}

26
test/libc/mem/djbsort_test.c
View file

@ -20,10 +20,11 @@
#include "libc/log/log.h"
#include "libc/macros.internal.h"
#include "libc/mem/alg.h"
#include "libc/mem/gc.h"
#include "libc/mem/mem.h"
#include "libc/nexgen32e/nexgen32e.h"
#include "libc/nexgen32e/x86feature.h"
#include "libc/mem/gc.internal.h"
#include "libc/runtime/runtime.h"
#include "libc/stdio/rand.h"
#include "libc/stdio/stdio.h"
#include "libc/str/str.h"
@ -52,9 +53,9 @@ void insertionsort(int32_t *a, size_t n) {
TEST(djbsort, test4) {
static const int kA[] = {4, 3, 2, 1};
n = ARRAYLEN(kA);
a = memcpy(gc(malloc(n * 4)), kA, n * 4);
b = memcpy(gc(malloc(n * 4)), kA, n * 4);
c = memcpy(gc(malloc(n * 4)), kA, n * 4);
a = memcpy(_gc(malloc(n * 4)), kA, n * 4);
b = memcpy(_gc(malloc(n * 4)), kA, n * 4);
c = memcpy(_gc(malloc(n * 4)), kA, n * 4);
insertionsort(a, n);
djbsort_avx2(b, n);
djbsort(c, n);
@ -79,9 +80,9 @@ TEST(djbsort, test64) {
-1323943608, -1219421355, -582289873, 1062699814,
};
n = ARRAYLEN(kA);
a = memcpy(gc(malloc(n * 4)), kA, n * 4);
b = memcpy(gc(malloc(n * 4)), kA, n * 4);
c = memcpy(gc(malloc(n * 4)), kA, n * 4);
a = memcpy(_gc(malloc(n * 4)), kA, n * 4);
b = memcpy(_gc(malloc(n * 4)), kA, n * 4);
c = memcpy(_gc(malloc(n * 4)), kA, n * 4);
insertionsort(a, n);
djbsort(c, n);
ASSERT_EQ(0, memcmp(a, c, n * 4));
@ -91,10 +92,19 @@ TEST(djbsort, test64) {
}
}
static int CompareInt(const void *a, const void *b) {
if (*(const int *)a < *(const int *)b) return -1;
if (*(const int *)a > *(const int *)b) return +1;
return 0;
}
BENCH(djbsort, bench) {
n = 256;
a = gc(memalign(32, n * 4));
a = _gc(memalign(32, n * 4));
EZBENCH2("insertionsort[255]", rngset(a, n * 4, rand64, -1),
insertionsort(a, n));
EZBENCH2("djbsort[255]", rngset(a, n * 4, rand64, -1), djbsort(a, n));
EZBENCH2("_intsort[255]", rngset(a, n * 4, rand64, -1), _intsort(a, n));
EZBENCH2("qsort[255]", rngset(a, n * 4, rand64, -1),
qsort(a, n, sizeof(int), CompareInt));
}

3
test/libc/nexgen32e/kbase36_test.c
View file

@ -16,8 +16,7 @@
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/nexgen32e/nexgen32e.h"
#include "libc/str/str.h"
#include "libc/str/tab.internal.h"
#include "libc/testlib/testlib.h"
TEST(kBase36, test) {

5
test/libc/nexgen32e/kcp437_test.c
View file

@ -16,10 +16,9 @@
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/nexgen32e/nexgen32e.h"
#include "libc/str/str.h"
#include "libc/testlib/testlib.h"
#include "libc/str/tab.internal.h"
#include "libc/str/unicode.h"
#include "libc/testlib/testlib.h"
TEST(kcp437, test) {
long i;

1
test/libc/str/blake2_test.c
View file

@ -21,6 +21,7 @@
#include "libc/stdio/rand.h"
#include "libc/str/blake2.h"
#include "libc/str/str.h"
#include "libc/str/tab.internal.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/hyperion.h"
#include "libc/testlib/testlib.h"

7
test/libc/str/strcasestr_test.c
View file

@ -16,13 +16,14 @@
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/mem/alg.h"
#include "libc/intrin/bits.h"
#include "libc/dce.h"
#include "libc/intrin/bits.h"
#include "libc/mem/alg.h"
#include "libc/mem/gc.internal.h"
#include "libc/mem/mem.h"
#include "libc/nexgen32e/x86feature.h"
#include "libc/mem/gc.internal.h"
#include "libc/str/internal.h"
#include "libc/str/tab.internal.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/hyperion.h"
#include "libc/testlib/testlib.h"