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
95
96
97
98
| | #define _GNU_SOURCE
#include "pthread_impl.h"
#include "stdio_impl.h"
#include "libc.h"
#include <sys/mman.h>
#include <threads.h>
void *__mmap(void *, size_t, int, int, int, off_t);
int __munmap(void *, size_t);
int __mprotect(void *, size_t, int);
void __thread_enable(void);
_Noreturn void __pthread_exit(void *);
void *__copy_tls(unsigned char *);
extern volatile size_t __pthread_tsd_size;
_Noreturn void thrd_exit(int result) {
__pthread_exit((void*)(intptr_t)result);
}
static void dummy_0()
{
}
weak_alias(dummy_0, __acquire_ptc);
weak_alias(dummy_0, __release_ptc);
static int start(void *p)
{
thrd_t self = p;
int (*start)(void*) = (int(*)(void*)) self->start;
thrd_exit(start(self->start_arg));
return 0;
}
#define ROUND(x) (((x)+PAGE_SIZE-1)&-PAGE_SIZE)
int thrd_create(thrd_t *res, thrd_start_t entry, void *arg)
{
int ret = -ENOMEM;
size_t guard = ROUND(DEFAULT_GUARD_SIZE);
size_t size = guard + ROUND(DEFAULT_STACK_SIZE + libc.tls_size + __pthread_tsd_size);
struct pthread *self, *new;
unsigned char *map, *stack, *tsd, *stack_limit;
unsigned flags = CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND
| CLONE_THREAD | CLONE_SYSVSEM | CLONE_SETTLS
| CLONE_PARENT_SETTID | CLONE_CHILD_CLEARTID | CLONE_DETACHED;
if (!libc.can_do_threads) return thrd_error;
self = __pthread_self();
if (!libc.threaded) __thread_enable();
__acquire_ptc();
if (guard) {
map = __mmap(0, size, PROT_NONE, MAP_PRIVATE|MAP_ANON, -1, 0);
if (map == MAP_FAILED) goto CLEANUP;
if (__mprotect(map+guard, size-guard, PROT_READ|PROT_WRITE)) {
__munmap(map, size);
goto CLEANUP;
}
} else {
map = __mmap(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, -1, 0);
if (map == MAP_FAILED) goto CLEANUP;
}
tsd = map + size - __pthread_tsd_size;
stack = tsd - libc.tls_size;
stack_limit = map + guard;
new = __copy_tls(tsd - libc.tls_size);
new->map_base = map;
new->map_size = size;
new->stack = stack;
new->stack_size = stack - stack_limit;
new->start = (void *(*)(void*))entry;
new->start_arg = arg;
new->self = new;
new->tsd = (void *)tsd;
new->locale = &libc.global_locale;
new->unblock_cancel = self->cancel;
new->canary = self->canary;
a_inc(&libc.threads_minus_1);
ret = __clone(start, stack, flags, new, &new->tid, TP_ADJ(new), &new->tid);
CLEANUP:
__release_ptc();
if (ret > 0) {
*res = new;
ret = thrd_success;
} else if (ret == -ENOMEM) {
ret = thrd_nomem;
} else {
a_dec(&libc.threads_minus_1);
if (map) __munmap(map, size);
ret = thrd_error;
}
return ret;
}
|