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
219
220
221
222
223
224
225
226
227
228
229
|
/**
* D header file for POSIX.
*
* Copyright: Copyright Sean Kelly 2005 - 2009.
* License: $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
* Authors: Sean Kelly, Alex Rønne Petersen
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
/* Copyright Sean Kelly 2005 - 2009.
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE or copy at
* http://www.boost.org/LICENSE_1_0.txt)
*/
module core.sys.posix.semaphore;
import core.sys.posix.config;
import core.sys.posix.time;
version (OSX)
version = Darwin;
else version (iOS)
version = Darwin;
else version (TVOS)
version = Darwin;
else version (WatchOS)
version = Darwin;
version (Posix):
extern (C):
nothrow:
@nogc:
@system:
//
// Required
//
/*
sem_t
SEM_FAILED
int sem_close(sem_t*);
int sem_destroy(sem_t*);
int sem_getvalue(sem_t*, int*);
int sem_init(sem_t*, int, uint);
sem_t* sem_open(const scope char*, int, ...);
int sem_post(sem_t*);
int sem_trywait(sem_t*);
int sem_unlink(const scope char*);
int sem_wait(sem_t*);
*/
version (CRuntime_Glibc)
{
private alias int __atomic_lock_t;
private struct _pthread_fastlock
{
c_long __status;
__atomic_lock_t __spinlock;
}
struct sem_t
{
_pthread_fastlock __sem_lock;
int __sem_value;
void* __sem_waiting;
}
enum SEM_FAILED = cast(sem_t*) null;
}
else version (Darwin)
{
alias int sem_t;
enum SEM_FAILED = cast(sem_t*) null;
}
else version (FreeBSD)
{
// FBSD-9.0 definition
struct sem_t
{
uint _magic;
struct _usem
{
shared uint _has_waiters;
shared uint _count;
uint _flags;
} _usem _kern;
}
enum SEM_FAILED = cast(sem_t*) null;
}
else version (NetBSD)
{
alias size_t sem_t;
enum SEM_FAILED = cast(sem_t*) null;
}
else version (OpenBSD)
{
struct __sem;
alias sem_t = __sem*;
enum SEM_FAILED = cast(sem_t*) null;
}
else version (DragonFlyBSD)
{
struct sem_t
{
uint _magic;
struct _usem
{
shared uint _has_waiters;
shared uint _count;
uint _flags;
} _usem _kern;
}
enum SEM_FAILED = cast(sem_t*) null;
}
else version (Solaris)
{
struct sem_t
{
uint sem_count;
ushort sem_type;
ushort sem_magic;
ulong[3] sem_pad1;
ulong[2] sem_pad2;
}
enum SEM_FAILED = cast(sem_t*)-1;
}
else version (CRuntime_Bionic)
{
struct sem_t
{
uint count; //volatile
}
enum SEM_FAILED = null;
}
else version (CRuntime_Musl)
{
struct sem_t {
int[4*c_long.sizeof/int.sizeof] __val;
}
enum SEM_FAILED = (sem_t*).init;
}
else version (CRuntime_UClibc)
{
enum __SIZEOF_SEM_T = 16;
union sem_t
{
byte[__SIZEOF_SEM_T] __size;
c_long __align;
}
enum SEM_FAILED = cast(sem_t*) null;
}
else
{
static assert(false, "Unsupported platform");
}
int sem_close(sem_t*);
int sem_destroy(sem_t*);
int sem_getvalue(sem_t*, int*);
int sem_init(sem_t*, int, uint);
sem_t* sem_open(const scope char*, int, ...);
int sem_post(sem_t*);
int sem_trywait(sem_t*);
int sem_unlink(const scope char*);
int sem_wait(sem_t*);
//
// Timeouts (TMO)
//
/*
int sem_timedwait(sem_t*, const scope timespec*);
*/
version (CRuntime_Glibc)
{
int sem_timedwait(sem_t*, const scope timespec*);
}
else version (Darwin)
{
int sem_timedwait(sem_t*, const scope timespec*);
}
else version (FreeBSD)
{
int sem_timedwait(sem_t*, const scope timespec*);
}
else version (NetBSD)
{
int sem_timedwait(sem_t*, const scope timespec*);
}
else version (OpenBSD)
{
int sem_timedwait(sem_t*, const scope timespec*);
}
else version (DragonFlyBSD)
{
int sem_timedwait(sem_t*, const scope timespec*);
}
else version (Solaris)
{
int sem_timedwait(sem_t*, const scope timespec*);
}
else version (CRuntime_Bionic)
{
int sem_timedwait(sem_t*, const scope timespec*);
}
else version (CRuntime_Musl)
{
int sem_timedwait(sem_t*, const scope timespec*);
}
else version (CRuntime_UClibc)
{
int sem_timedwait(sem_t*, const scope timespec*);
}
else
{
static assert(false, "Unsupported platform");
}
|
