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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
| | #ifndef _PTHREAD_IMPL_H
#define _PTHREAD_IMPL_H
#include <pthread.h>
#include <signal.h>
#include <errno.h>
#include <limits.h>
#include "libc.h"
#include "syscall.h"
#include "atomic.h"
#include "futex.h"
#define pthread __pthread
struct pthread {
struct pthread *self;
void **dtv, *unused1, *unused2;
uintptr_t sysinfo;
uintptr_t canary;
pid_t tid, pid;
int tsd_used, errno_val;
volatile int cancel, canceldisable, cancelasync;
int detached;
unsigned char *map_base;
size_t map_size;
void *stack;
size_t stack_size;
void *start_arg;
void *(*start)(void *);
void *result;
struct __ptcb *cancelbuf;
void **tsd;
pthread_attr_t attr;
volatile int dead;
struct {
void **head;
long off;
void *pending;
} robust_list;
int unblock_cancel;
int timer_id;
locale_t locale;
int killlock[2];
int exitlock[2];
int startlock[2];
unsigned long sigmask[_NSIG/8/sizeof(long)];
};
struct __timer {
int timerid;
pthread_t thread;
};
/* For the moment this type has the same layout as
pthread_mutex_t. This is subject to change in later versions of the
C thread implementation, be it for the simple reason that this
would reduce the size of the structure by half. */
struct __mtx_on_heap {
int _mt_typ;
int _mt_lck;
int _mt_wts;
int _mt_pad3;
int _mt_pad4;
int _mt_cnt;
int _mt_rfs;
int _mt_pad7;
int _mt_pad8;
int _mt_pad9;
};
static inline
void __mtx_addref(struct __mtx_on_heap *m) {
if (m) {
a_inc(&m->_mt_rfs);
}
}
struct __cnd_on_heap {
int rfs;
int tok;
int wts;
int seq;
struct __mtx_on_heap* mtx;
};
static inline
void __cnd_addref(struct __cnd_on_heap *c) {
if (c) {
a_inc(&c->rfs);
}
}
/* Unless told otherwise this C thread implementation will only use
private futexes. */
#ifdef __MTX_SHARED
#define THRD_PRIVATE 0
#else
#define THRD_PRIVATE 128
#endif
#define __SU (sizeof(size_t)/sizeof(int))
#define _a_stacksize __u.__s[0]
#define _a_guardsize __u.__s[1]
#define _a_stackaddr __u.__s[2]
#define _a_detach __u.__i[3*__SU+0]
#define _a_sched __u.__i[3*__SU+1]
#define _a_policy __u.__i[3*__SU+2]
#define _a_prio __u.__i[3*__SU+3]
#define _m_type __u.__i[0]
#define _m_lock __u.__i[1]
#define _m_waiters __u.__i[2]
#define _m_prev __u.__p[3]
#define _m_next __u.__p[4]
#define _m_count __u.__i[5]
#define _mx_type __u.__i[0]
#define _mx_lock __u.__i[1]
#define _mx_mtx __u.__p[2]
#define _mx_prev __u.__p[3] /* unused */
#define _mx_next __u.__p[4] /* unused */
#define _mx_count __u.__i[5] /* unused */
#define _c_mutex __u.__p[0]
#define _c_seq __u.__i[2]
#define _c_waiters __u.__i[3]
#define _c_clock __u.__i[4]
#define _c_lock __u.__i[5]
#define _c_lockwait __u.__i[6]
#define _c_waiters2 __u.__i[7]
#define _c_destroy __u.__i[8]
#define _cx_cnd __u.__p[0]
#define _cx_seq __u.__i[2] /* unused */
#define _cx_waiters __u.__i[3] /* unused */
#define _cx_clock __u.__i[4] /* unused */
#define _cx_lock __u.__i[5]
#define _cx_lockwait __u.__i[6]
#define _cx_waiters2 __u.__i[7]/* unused */
#define _cx_destroy __u.__i[8] /* unused */
#define _rw_lock __u.__i[0]
#define _rw_waiters __u.__i[1]
#define _b_lock __u.__i[0]
#define _b_waiters __u.__i[1]
#define _b_limit __u.__i[2]
#define _b_count __u.__i[3]
#define _b_waiters2 __u.__i[4]
#define _b_inst __u.__p[3]
#if defined(__ATOMIC_ACQ_REL) && defined(__ATOMIC_ACQUIRE) && defined(__ATOMIC_RELEASE)
#define a_tas(X) __atomic_test_and_set((X), __ATOMIC_ACQ_REL)
#define a_aqf() __atomic_thread_fence(__ATOMIC_ACQUIRE)
#define a_spunl(X) \
({ \
__asm__ volatile ("# end CS"); \
int volatile* _lck = (X); \
__atomic_clear(_lck, __ATOMIC_RELEASE); \
})
#else
#define a_tas(X) __sync_lock_test_and_set((X), 1)
#define a_aqf() __sync_synchronize()
#define a_spunl(X) \
({ \
__asm__ volatile ("# end CS"); \
int volatile* _lck = (X); \
__sync_lock_release(_lck); \
})
#endif
#define a_splck(X) \
({ \
int volatile* _lck = (X); \
while (a_tas(_lck)) (void)0; \
a_aqf(); \
__asm__ volatile ("# start CS"); \
})
#include "pthread_arch.h"
#define SIGTIMER 32
#define SIGCANCEL 33
#define SIGSYNCCALL 34
#define SIGALL_SET ((sigset_t *)(const unsigned long long [2]){ -1,-1 })
#define SIGPT_SET \
((sigset_t *)(const unsigned long [_NSIG/8/sizeof(long)]){ \
[sizeof(long)==4] = 3UL<<(32*(sizeof(long)>4)) })
#define SIGTIMER_SET \
((sigset_t *)(const unsigned long [_NSIG/8/sizeof(long)]){ \
0x80000000 })
pthread_t __pthread_self_init(void);
int __clone(int (*)(void *), void *, int, void *, ...);
int __set_thread_area(void *);
int __libc_sigaction(int, const struct sigaction *, struct sigaction *);
int __libc_sigprocmask(int, const sigset_t *, sigset_t *);
void __lock(volatile int *);
void __unmapself(void *, size_t);
int __timedwait(volatile int *, int, clockid_t, const struct timespec *, void (*)(void *), void *, int);
void __wait(volatile int *, volatile int *, int, int);
#define __wake(addr, cnt, priv) \
__syscall(SYS_futex, addr, FUTEX_WAKE, (cnt)<0?INT_MAX:(cnt))
void __wait_priv(volatile int *, volatile int *, int);
#define __wake_priv(addr, cnt) \
__syscall(SYS_futex, addr, FUTEX_WAKE|THRD_PRIVATE, (cnt)<0?INT_MAX:(cnt))
void __acquire_ptc();
void __release_ptc();
void __inhibit_ptc();
void __block_all_sigs(void *);
void __block_app_sigs(void *);
void __restore_sigs(void *);
#define DEFAULT_STACK_SIZE 81920
#define DEFAULT_GUARD_SIZE PAGE_SIZE
#endif
|