mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-05-23 05:42:29 +00:00
Make fixes and improvements
- Introduce __assert_disable global - Improve strsignal() thread safety - Make system call tracing thread safe - Fix SO_RCVTIMEO / SO_SNDTIMEO on Windows - Refactor DescribeFoo() functions into one place - Fix fork() on Windows when TLS and MAP_STACK exist - Round upwards in setsockopt(SO_RCVTIMEO) on Windows - Disable futexes on OpenBSD which seem extremely broken - Implement a better kludge for monotonic time on Windows
This commit is contained in:
Justine Tunney
parent
5d837c4e7c
commit
fbc053e018
186 changed files with 1836 additions and 1325 deletions
|
|
@ -16,33 +16,56 @@
|
|||
│ 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/state.internal.h"
|
||||
#include "libc/calls/strace.internal.h"
|
||||
#include "libc/errno.h"
|
||||
#include "libc/intrin/futex.internal.h"
|
||||
#include "libc/intrin/kprintf.h"
|
||||
#include "libc/intrin/pthread.h"
|
||||
#include "libc/intrin/spinlock.h"
|
||||
#include "libc/intrin/wait0.internal.h"
|
||||
#include "libc/log/check.h"
|
||||
#include "libc/macros.internal.h"
|
||||
#include "libc/math.h"
|
||||
#include "libc/mem/mem.h"
|
||||
#include "libc/nexgen32e/threaded.h"
|
||||
#include "libc/runtime/gc.internal.h"
|
||||
#include "libc/runtime/internal.h"
|
||||
#include "libc/runtime/runtime.h"
|
||||
#include "libc/runtime/stack.h"
|
||||
#include "libc/sysv/consts/clone.h"
|
||||
#include "libc/sysv/consts/map.h"
|
||||
#include "libc/sysv/consts/prot.h"
|
||||
#include "libc/sysv/consts/rlimit.h"
|
||||
#include "libc/testlib/ezbench.h"
|
||||
#include "libc/testlib/testlib.h"
|
||||
#include "libc/thread/thread.h"
|
||||
|
||||
#define THREADS 8
|
||||
#define ITERATIONS 512
|
||||
#define TLS_SIZE PAGESIZE
|
||||
|
||||
char *tls[THREADS];
|
||||
char *stack[THREADS];
|
||||
char tls[THREADS][64];
|
||||
_Alignas(PAGESIZE) char tlsdata[THREADS * 3][TLS_SIZE];
|
||||
|
||||
int count;
|
||||
_Atomic(int) started;
|
||||
_Atomic(int) finished;
|
||||
_Alignas(64) char slock;
|
||||
pthread_mutex_t mylock;
|
||||
|
||||
__attribute__((__constructor__)) void init(void) {
|
||||
int i;
|
||||
__enable_tls();
|
||||
__enable_threads();
|
||||
for (i = 0; i < THREADS; ++i) {
|
||||
CHECK_NE(-1, mprotect(tlsdata[i * 3 + 0], TLS_SIZE, PROT_NONE));
|
||||
tls[i] = tlsdata[i * 3 + 1];
|
||||
CHECK_NE(-1, mprotect(tlsdata[i * 3 + 2], TLS_SIZE, PROT_NONE));
|
||||
}
|
||||
}
|
||||
|
||||
TEST(pthread_mutex_lock, normal) {
|
||||
|
|
@ -79,6 +102,7 @@ TEST(pthread_mutex_lock, recursive) {
|
|||
TEST(pthread_mutex_lock, errorcheck) {
|
||||
pthread_mutex_t lock;
|
||||
pthread_mutexattr_t attr;
|
||||
__assert_disable = true;
|
||||
ASSERT_EQ(0, pthread_mutexattr_init(&attr));
|
||||
ASSERT_EQ(0, pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK));
|
||||
ASSERT_EQ(0, pthread_mutex_init(&lock, &attr));
|
||||
|
|
@ -89,20 +113,19 @@ TEST(pthread_mutex_lock, errorcheck) {
|
|||
ASSERT_EQ(0, pthread_mutex_unlock(&lock));
|
||||
ASSERT_EQ(EPERM, pthread_mutex_unlock(&lock));
|
||||
ASSERT_EQ(0, pthread_mutex_destroy(&lock));
|
||||
__assert_disable = false;
|
||||
}
|
||||
|
||||
int count;
|
||||
_Atomic(int) finished;
|
||||
_Alignas(64) char slock;
|
||||
pthread_mutex_t lock;
|
||||
|
||||
int MutexWorker(void *p) {
|
||||
int i;
|
||||
++started;
|
||||
for (i = 0; i < ITERATIONS; ++i) {
|
||||
pthread_mutex_lock(&lock);
|
||||
pthread_mutex_lock(&mylock);
|
||||
++count;
|
||||
pthread_mutex_unlock(&lock);
|
||||
pthread_mutex_unlock(&mylock);
|
||||
}
|
||||
ASSERT_NE(0, (int *)(tls[(intptr_t)p] + 0x38));
|
||||
++finished;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -111,27 +134,36 @@ TEST(pthread_mutex_lock, contention) {
|
|||
pthread_mutexattr_t attr;
|
||||
pthread_mutexattr_init(&attr);
|
||||
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
|
||||
pthread_mutex_init(&lock, &attr);
|
||||
pthread_mutex_init(&mylock, &attr);
|
||||
pthread_mutexattr_destroy(&attr);
|
||||
count = 0;
|
||||
started = 0;
|
||||
finished = 0;
|
||||
for (i = 0; i < THREADS; ++i) {
|
||||
clone(MutexWorker,
|
||||
(stack[i] = mmap(0, GetStackSize(), PROT_READ | PROT_WRITE,
|
||||
MAP_STACK | MAP_ANONYMOUS, -1, 0)),
|
||||
GetStackSize(),
|
||||
CLONE_THREAD | CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND |
|
||||
CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID | CLONE_SETTLS,
|
||||
0, 0, __initialize_tls(tls[i]), sizeof(tls[i]),
|
||||
(int *)(tls[i] + 0x38));
|
||||
ASSERT_NE(MAP_FAILED,
|
||||
(stack[i] = mmap(0, GetStackSize(), PROT_READ | PROT_WRITE,
|
||||
MAP_STACK | MAP_ANONYMOUS, -1, 0)));
|
||||
ASSERT_NE(-1, clone(MutexWorker, stack[i], GetStackSize(),
|
||||
CLONE_THREAD | CLONE_VM | CLONE_FS | CLONE_FILES |
|
||||
CLONE_SIGHAND | CLONE_CHILD_SETTID |
|
||||
CLONE_CHILD_CLEARTID | CLONE_SETTLS,
|
||||
(void *)(intptr_t)i, 0, __initialize_tls(tls[i]),
|
||||
TLS_SIZE, (int *)(tls[i] + 0x38)));
|
||||
}
|
||||
for (i = 0; i < THREADS; ++i) {
|
||||
_wait0((int *)(tls[i] + 0x38));
|
||||
ASSERT_EQ(0, *(int *)(tls[i] + 0x38));
|
||||
}
|
||||
ASSERT_EQ(THREADS * ITERATIONS, count);
|
||||
for (i = 0; i < THREADS; ++i) {
|
||||
munmap(stack[i], GetStackSize());
|
||||
ASSERT_EQ(0, *(int *)(tls[i] + 0x38));
|
||||
}
|
||||
EXPECT_EQ(0, pthread_mutex_destroy(&lock));
|
||||
EXPECT_EQ(THREADS, started);
|
||||
EXPECT_EQ(THREADS, finished);
|
||||
EXPECT_EQ(THREADS * ITERATIONS, count);
|
||||
for (i = 0; i < THREADS; ++i) {
|
||||
ASSERT_SYS(0, 0, munmap(stack[i], GetStackSize()));
|
||||
}
|
||||
EXPECT_EQ(0, pthread_mutex_destroy(&mylock));
|
||||
}
|
||||
|
||||
TEST(pthread_mutex_lock, rcontention) {
|
||||
|
|
@ -139,27 +171,36 @@ TEST(pthread_mutex_lock, rcontention) {
|
|||
pthread_mutexattr_t attr;
|
||||
pthread_mutexattr_init(&attr);
|
||||
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
|
||||
pthread_mutex_init(&lock, &attr);
|
||||
pthread_mutex_init(&mylock, &attr);
|
||||
pthread_mutexattr_destroy(&attr);
|
||||
count = 0;
|
||||
started = 0;
|
||||
finished = 0;
|
||||
for (i = 0; i < THREADS; ++i) {
|
||||
clone(MutexWorker,
|
||||
(stack[i] = mmap(0, GetStackSize(), PROT_READ | PROT_WRITE,
|
||||
MAP_STACK | MAP_ANONYMOUS, -1, 0)),
|
||||
GetStackSize(),
|
||||
CLONE_THREAD | CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND |
|
||||
CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID | CLONE_SETTLS,
|
||||
0, 0, __initialize_tls(tls[i]), sizeof(tls[i]),
|
||||
(int *)(tls[i] + 0x38));
|
||||
ASSERT_NE(MAP_FAILED,
|
||||
(stack[i] = mmap(0, GetStackSize(), PROT_READ | PROT_WRITE,
|
||||
MAP_STACK | MAP_ANONYMOUS, -1, 0)));
|
||||
ASSERT_NE(-1, clone(MutexWorker, stack[i], GetStackSize(),
|
||||
CLONE_THREAD | CLONE_VM | CLONE_FS | CLONE_FILES |
|
||||
CLONE_SIGHAND | CLONE_CHILD_SETTID |
|
||||
CLONE_CHILD_CLEARTID | CLONE_SETTLS,
|
||||
(void *)(intptr_t)i, 0, __initialize_tls(tls[i]),
|
||||
TLS_SIZE, (int *)(tls[i] + 0x38)));
|
||||
}
|
||||
for (i = 0; i < THREADS; ++i) {
|
||||
_wait0((int *)(tls[i] + 0x38));
|
||||
ASSERT_EQ(0, *(int *)(tls[i] + 0x38));
|
||||
}
|
||||
ASSERT_EQ(THREADS * ITERATIONS, count);
|
||||
for (i = 0; i < THREADS; ++i) {
|
||||
munmap(stack[i], GetStackSize());
|
||||
ASSERT_EQ(0, *(int *)(tls[i] + 0x38));
|
||||
}
|
||||
EXPECT_EQ(0, pthread_mutex_destroy(&lock));
|
||||
EXPECT_EQ(THREADS, started);
|
||||
EXPECT_EQ(THREADS, finished);
|
||||
EXPECT_EQ(THREADS * ITERATIONS, count);
|
||||
for (i = 0; i < THREADS; ++i) {
|
||||
ASSERT_SYS(0, 0, munmap(stack[i], GetStackSize()));
|
||||
}
|
||||
EXPECT_EQ(0, pthread_mutex_destroy(&mylock));
|
||||
}
|
||||
|
||||
TEST(pthread_mutex_lock, econtention) {
|
||||
|
|
@ -167,36 +208,47 @@ TEST(pthread_mutex_lock, econtention) {
|
|||
pthread_mutexattr_t attr;
|
||||
pthread_mutexattr_init(&attr);
|
||||
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
|
||||
pthread_mutex_init(&lock, &attr);
|
||||
pthread_mutex_init(&mylock, &attr);
|
||||
pthread_mutexattr_destroy(&attr);
|
||||
count = 0;
|
||||
started = 0;
|
||||
finished = 0;
|
||||
for (i = 0; i < THREADS; ++i) {
|
||||
clone(MutexWorker,
|
||||
(stack[i] = mmap(0, GetStackSize(), PROT_READ | PROT_WRITE,
|
||||
MAP_STACK | MAP_ANONYMOUS, -1, 0)),
|
||||
GetStackSize(),
|
||||
CLONE_THREAD | CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND |
|
||||
CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID | CLONE_SETTLS,
|
||||
0, 0, __initialize_tls(tls[i]), sizeof(tls[i]),
|
||||
(int *)(tls[i] + 0x38));
|
||||
ASSERT_NE(MAP_FAILED,
|
||||
(stack[i] = mmap(0, GetStackSize(), PROT_READ | PROT_WRITE,
|
||||
MAP_STACK | MAP_ANONYMOUS, -1, 0)));
|
||||
ASSERT_NE(-1, clone(MutexWorker, stack[i], GetStackSize(),
|
||||
CLONE_THREAD | CLONE_VM | CLONE_FS | CLONE_FILES |
|
||||
CLONE_SIGHAND | CLONE_CHILD_SETTID |
|
||||
CLONE_CHILD_CLEARTID | CLONE_SETTLS,
|
||||
(void *)(intptr_t)i, 0, __initialize_tls(tls[i]),
|
||||
TLS_SIZE, (int *)(tls[i] + 0x38)));
|
||||
}
|
||||
for (i = 0; i < THREADS; ++i) {
|
||||
_wait0((int *)(tls[i] + 0x38));
|
||||
ASSERT_EQ(0, *(int *)(tls[i] + 0x38));
|
||||
}
|
||||
ASSERT_EQ(THREADS * ITERATIONS, count);
|
||||
for (i = 0; i < THREADS; ++i) {
|
||||
munmap(stack[i], GetStackSize());
|
||||
ASSERT_EQ(0, *(int *)(tls[i] + 0x38));
|
||||
}
|
||||
EXPECT_EQ(0, pthread_mutex_destroy(&lock));
|
||||
EXPECT_EQ(THREADS, started);
|
||||
EXPECT_EQ(THREADS, finished);
|
||||
EXPECT_EQ(THREADS * ITERATIONS, count);
|
||||
for (i = 0; i < THREADS; ++i) {
|
||||
ASSERT_SYS(0, 0, munmap(stack[i], GetStackSize()));
|
||||
}
|
||||
EXPECT_EQ(0, pthread_mutex_destroy(&mylock));
|
||||
}
|
||||
|
||||
int SpinlockWorker(void *p) {
|
||||
int i;
|
||||
++started;
|
||||
for (i = 0; i < ITERATIONS; ++i) {
|
||||
_spinlock(&slock);
|
||||
++count;
|
||||
_spunlock(&slock);
|
||||
}
|
||||
ASSERT_NE(0, (int *)(tls[(intptr_t)p] + 0x38));
|
||||
++finished;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -204,24 +256,27 @@ int SpinlockWorker(void *p) {
|
|||
TEST(_spinlock, contention) {
|
||||
int i;
|
||||
count = 0;
|
||||
started = 0;
|
||||
finished = 0;
|
||||
for (i = 0; i < THREADS; ++i) {
|
||||
clone(SpinlockWorker,
|
||||
(stack[i] = mmap(0, GetStackSize(), PROT_READ | PROT_WRITE,
|
||||
MAP_STACK | MAP_ANONYMOUS, -1, 0)),
|
||||
GetStackSize(),
|
||||
CLONE_THREAD | CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND |
|
||||
CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID | CLONE_SETTLS,
|
||||
0, 0, __initialize_tls(tls[i]), sizeof(tls[i]),
|
||||
(int *)(tls[i] + 0x38));
|
||||
ASSERT_NE(MAP_FAILED,
|
||||
(stack[i] = mmap(0, GetStackSize(), PROT_READ | PROT_WRITE,
|
||||
MAP_STACK | MAP_ANONYMOUS, -1, 0)));
|
||||
ASSERT_NE(-1, clone(SpinlockWorker, stack[i], GetStackSize(),
|
||||
CLONE_THREAD | CLONE_VM | CLONE_FS | CLONE_FILES |
|
||||
CLONE_SIGHAND | CLONE_CHILD_SETTID |
|
||||
CLONE_CHILD_CLEARTID | CLONE_SETTLS,
|
||||
(void *)(intptr_t)i, 0, __initialize_tls(tls[i]),
|
||||
TLS_SIZE, (int *)(tls[i] + 0x38)));
|
||||
}
|
||||
for (i = 0; i < THREADS; ++i) {
|
||||
_wait0((int *)(tls[i] + 0x38));
|
||||
}
|
||||
ASSERT_EQ(THREADS, finished);
|
||||
ASSERT_EQ(THREADS * ITERATIONS, count);
|
||||
EXPECT_EQ(THREADS, started);
|
||||
EXPECT_EQ(THREADS, finished);
|
||||
EXPECT_EQ(THREADS * ITERATIONS, count);
|
||||
for (i = 0; i < THREADS; ++i) {
|
||||
munmap(stack[i], GetStackSize());
|
||||
ASSERT_SYS(0, 0, munmap(stack[i], GetStackSize()));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue