1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
|
// Copyright © Tavian Barnes <tavianator@tavianator.com>
// SPDX-License-Identifier: 0BSD
#include "thread.h"
#include "bfstd.h"
#include "diag.h"
#include <errno.h>
#include <pthread.h>
#if __has_include(<pthread_np.h>)
# include <pthread_np.h>
#endif
#define THREAD_FALLIBLE(expr) \
do { \
int err = expr; \
if (err == 0) { \
return 0; \
} else { \
errno = err; \
return -1; \
} \
} while (0)
#define THREAD_INFALLIBLE(...) \
THREAD_INFALLIBLE_(__VA_ARGS__, 0, )
#define THREAD_INFALLIBLE_(expr, allowed, ...) \
int err = expr; \
bfs_verify(err == 0 || err == allowed, "%s: %s", #expr, xstrerror(err)); \
(void)0
int thread_create(pthread_t *thread, const pthread_attr_t *attr, thread_fn *fn, void *arg) {
THREAD_FALLIBLE(pthread_create(thread, attr, fn, arg));
}
void thread_setname(pthread_t thread, const char *name) {
#if BFS_HAS_PTHREAD_SETNAME_NP
pthread_setname_np(thread, name);
#elif BFS_HAS_PTHREAD_SET_NAME_NP
pthread_set_name_np(thread, name);
#endif
}
void thread_join(pthread_t thread, void **ret) {
THREAD_INFALLIBLE(pthread_join(thread, ret));
}
int mutex_init(pthread_mutex_t *mutex, pthread_mutexattr_t *attr) {
THREAD_FALLIBLE(pthread_mutex_init(mutex, attr));
}
void mutex_lock(pthread_mutex_t *mutex) {
THREAD_INFALLIBLE(pthread_mutex_lock(mutex));
}
bool mutex_trylock(pthread_mutex_t *mutex) {
THREAD_INFALLIBLE(pthread_mutex_trylock(mutex), EBUSY);
return err == 0;
}
void mutex_unlock(pthread_mutex_t *mutex) {
THREAD_INFALLIBLE(pthread_mutex_unlock(mutex));
}
void mutex_destroy(pthread_mutex_t *mutex) {
THREAD_INFALLIBLE(pthread_mutex_destroy(mutex));
}
int cond_init(pthread_cond_t *cond, pthread_condattr_t *attr) {
THREAD_FALLIBLE(pthread_cond_init(cond, attr));
}
void cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) {
THREAD_INFALLIBLE(pthread_cond_wait(cond, mutex));
}
void cond_signal(pthread_cond_t *cond) {
THREAD_INFALLIBLE(pthread_cond_signal(cond));
}
void cond_broadcast(pthread_cond_t *cond) {
THREAD_INFALLIBLE(pthread_cond_broadcast(cond));
}
void cond_destroy(pthread_cond_t *cond) {
THREAD_INFALLIBLE(pthread_cond_destroy(cond));
}
void invoke_once(pthread_once_t *once, once_fn *fn) {
THREAD_INFALLIBLE(pthread_once(once, fn));
}
|
