1 /**
2 * D header file for POSIX.
3 *
4 * Copyright: Copyright Sean Kelly 2005 - 2009.
5 * License: $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
6 * Authors: Sean Kelly,
7 Alex Rønne Petersen
8 * Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
9 */
10
11 /* Copyright Sean Kelly 2005 - 2009.
12 * Distributed under the Boost Software License, Version 1.0.
13 * (See accompanying file LICENSE or copy at
14 * http://www.boost.org/LICENSE_1_0.txt)
15 */
16 module core.sys.posix.sys.types;
17
18 import core.sys.posix.config;
19 import core.stdc.stdint;
20 public import core.stdc.stddef;
21
22 version (OSX)
23 version = Darwin;
24 else version (iOS)
25 version = Darwin;
26 else version (TVOS)
27 version = Darwin;
28 else version (WatchOS)
29 version = Darwin;
30
version(Posix)31 version (Posix):
32 extern (C):
33 @system:
34
35 //
36 // bits/typesizes.h -- underlying types for *_t.
37 //
38 /*
39 __syscall_slong_t
40 __syscall_ulong_t
41 */
42 version (CRuntime_Glibc)
43 {
44 version (X86_64)
45 {
46 version (D_X32)
47 {
48 // X32 kernel interface is 64-bit.
49 alias long slong_t;
50 alias ulong ulong_t;
51 }
52 else
53 {
54 alias c_long slong_t;
55 alias c_ulong ulong_t;
56 }
57 }
58 else
59 {
60 alias c_long slong_t;
61 alias c_ulong ulong_t;
62 }
63 }
64 else
65 {
66 alias c_long slong_t;
67 alias c_ulong ulong_t;
68 }
69
70 //
71 // Required
72 //
73 /*
74 blkcnt_t
75 blksize_t
76 dev_t
77 gid_t
78 ino_t
79 mode_t
80 nlink_t
81 off_t
82 pid_t
83 size_t
84 ssize_t
85 time_t
86 uid_t
87 */
88
version(linux)89 version (linux)
90 {
91 static if ( __USE_FILE_OFFSET64 )
92 {
93 alias long blkcnt_t;
94 alias ulong ino_t;
95 alias long off_t;
96 }
97 else
98 {
99 alias slong_t blkcnt_t;
100 alias ulong_t ino_t;
101 alias slong_t off_t;
102 }
103 alias slong_t blksize_t;
104 alias ulong dev_t;
105 alias uint gid_t;
106 alias uint mode_t;
107 alias ulong_t nlink_t;
108 alias int pid_t;
109 //size_t (defined in core.stdc.stddef)
110 alias c_long ssize_t;
111 alias uint uid_t;
112
113 version (CRuntime_Musl)
114 {
115 /**
116 * Musl versions before v1.2.0 (up to v1.1.24) had different
117 * definitions for `time_t` for 32 bits.
118 * This was changed to always be 64 bits in v1.2.0:
119 * https://musl.libc.org/time64.html
120 * This change was only for 32 bits system and
121 * didn't affect 64 bits systems
122 *
123 * To check previous definitions, `grep` for `time_t` in `arch/`,
124 * and the result should be (in v1.1.24):
125 * ---
126 * // arch/riscv64/bits/alltypes.h.in:20:TYPEDEF long time_t;
127 * // arch/s390x/bits/alltypes.h.in:17:TYPEDEF long time_t;
128 * // arch/sh/bits/alltypes.h.in:21:TYPEDEF long time_t;
129 * ---
130 *
131 * In order to be compatible with old versions of Musl,
132 * one can recompile druntime with `CRuntime_Musl_Pre_Time64`.
133 */
134 version (D_X32)
135 alias long time_t;
136 else version (CRuntime_Musl_Pre_Time64)
137 alias c_long time_t;
138 else
139 alias long time_t;
140 }
141 else
142 {
143 alias slong_t time_t;
144 }
145 }
version(Darwin)146 else version (Darwin)
147 {
148 alias long blkcnt_t;
149 alias int blksize_t;
150 alias int dev_t;
151 alias uint gid_t;
152 alias ulong ino_t;
153 alias ushort mode_t;
154 alias ushort nlink_t;
155 alias long off_t;
156 alias int pid_t;
157 //size_t (defined in core.stdc.stddef)
158 alias c_long ssize_t;
159 alias c_long time_t;
160 alias uint uid_t;
161 }
version(FreeBSD)162 else version (FreeBSD)
163 {
164 import core.sys.freebsd.config;
165
166 // https://github.com/freebsd/freebsd/blob/master/sys/sys/_types.h
167 alias long blkcnt_t;
168 alias uint blksize_t;
169
170 static if (__FreeBSD_version >= 1200000)
171 {
172 alias ulong dev_t;
173 alias ulong ino_t;
174 alias ulong nlink_t;
175 }
176 else
177 {
178 alias uint dev_t;
179 alias uint ino_t;
180 alias ushort nlink_t;
181 }
182
183 alias uint gid_t;
184 alias ushort mode_t;
185 alias long off_t;
186 alias int pid_t;
187 //size_t (defined in core.stdc.stddef)
188 alias c_long ssize_t;
189 alias c_long time_t;
190 alias uint uid_t;
191 alias uint fflags_t;
192 }
version(NetBSD)193 else version (NetBSD)
194 {
195 alias long blkcnt_t;
196 alias int blksize_t;
197 alias ulong dev_t;
198 alias uint gid_t;
199 alias ulong ino_t;
200 alias uint mode_t;
201 alias uint nlink_t;
202 alias ulong off_t;
203 alias int pid_t;
204 //size_t (defined in core.stdc.stddef)
205 alias c_long ssize_t;
206 alias c_long time_t;
207 alias uint uid_t;
208 }
version(OpenBSD)209 else version (OpenBSD)
210 {
211 alias char* caddr_t;
212 alias long blkcnt_t;
213 alias int blksize_t;
214 alias int dev_t;
215 alias uint gid_t;
216 alias ulong ino_t;
217 alias uint mode_t;
218 alias uint nlink_t;
219 alias long off_t;
220 alias int pid_t;
221 //size_t (defined in core.stdc.stddef)
222 alias c_long ssize_t;
223 alias long time_t;
224 alias uint uid_t;
225 }
version(DragonFlyBSD)226 else version (DragonFlyBSD)
227 {
228 alias long blkcnt_t;
229 alias long blksize_t;
230 alias uint dev_t;
231 alias uint gid_t;
232 alias long ino_t;
233 alias ushort mode_t;
234 alias uint nlink_t;
235 alias long off_t; //__off_t (defined in /usr/include/sys/stdint.h -> core.stdc.stddef)
236 alias int pid_t; // size_t (defined in /usr/include/sys/stdint.h -> core.stdc.stddef)
237 alias c_long ssize_t;
238 alias long time_t;
239 alias uint uid_t;
240 }
version(Solaris)241 else version (Solaris)
242 {
243 alias char* caddr_t;
244 alias c_long daddr_t;
245 alias short cnt_t;
246
247 static if (__USE_FILE_OFFSET64)
248 {
249 alias long blkcnt_t;
250 alias ulong ino_t;
251 alias long off_t;
252 }
253 else
254 {
255 alias c_long blkcnt_t;
256 alias c_ulong ino_t;
257 alias c_long off_t;
258 }
259
260 version (D_LP64)
261 {
262 alias blkcnt_t blkcnt64_t;
263 alias ino_t ino64_t;
264 alias off_t off64_t;
265 }
266 else
267 {
268 alias long blkcnt64_t;
269 alias ulong ino64_t;
270 alias long off64_t;
271 }
272
273 alias uint blksize_t;
274 alias c_ulong dev_t;
275 alias uid_t gid_t;
276 alias uint mode_t;
277 alias uint nlink_t;
278 alias int pid_t;
279 alias c_long ssize_t;
280 alias c_long time_t;
281 alias uint uid_t;
282 }
283 else
284 {
285 static assert(false, "Unsupported platform");
286 }
287
288 //
289 // XOpen (XSI)
290 //
291 /*
292 clock_t
293 fsblkcnt_t
294 fsfilcnt_t
295 id_t
296 key_t
297 suseconds_t
298 useconds_t
299 */
300
version(linux)301 version (linux)
302 {
303 static if ( __USE_FILE_OFFSET64 )
304 {
305 alias ulong fsblkcnt_t;
306 alias ulong fsfilcnt_t;
307 }
308 else
309 {
310 alias ulong_t fsblkcnt_t;
311 alias ulong_t fsfilcnt_t;
312 }
313 alias slong_t clock_t;
314 alias uint id_t;
315 alias int key_t;
316 alias slong_t suseconds_t;
317 alias uint useconds_t;
318 }
version(Darwin)319 else version (Darwin)
320 {
321 alias uint fsblkcnt_t;
322 alias uint fsfilcnt_t;
323 alias c_long clock_t;
324 alias uint id_t;
325 alias int key_t;
326 alias int suseconds_t;
327 alias uint useconds_t;
328 }
version(FreeBSD)329 else version (FreeBSD)
330 {
331 alias ulong fsblkcnt_t;
332 alias ulong fsfilcnt_t;
333 alias c_long clock_t;
334 alias long id_t;
335 alias c_long key_t;
336 alias c_long suseconds_t;
337 alias uint useconds_t;
338 }
version(NetBSD)339 else version (NetBSD)
340 {
341 alias ulong fsblkcnt_t;
342 alias ulong fsfilcnt_t;
343 alias c_long clock_t;
344 alias long id_t;
345 alias c_long key_t;
346 alias c_long suseconds_t;
347 alias uint useconds_t;
348 }
version(OpenBSD)349 else version (OpenBSD)
350 {
351 alias ulong fsblkcnt_t;
352 alias ulong fsfilcnt_t;
353 alias long clock_t;
354 alias uint id_t;
355 alias c_long key_t;
356 alias c_long suseconds_t;
357 alias uint useconds_t;
358 }
version(DragonFlyBSD)359 else version (DragonFlyBSD)
360 {
361 alias ulong fsblkcnt_t;
362 alias ulong fsfilcnt_t;
363 alias c_long clock_t;
364 alias long id_t;
365 alias c_long key_t;
366 alias c_long suseconds_t;
367 alias uint useconds_t;
368 }
version(Solaris)369 else version (Solaris)
370 {
371 static if (__USE_FILE_OFFSET64)
372 {
373 alias ulong fsblkcnt_t;
374 alias ulong fsfilcnt_t;
375 }
376 else
377 {
378 alias c_ulong fsblkcnt_t;
379 alias c_ulong fsfilcnt_t;
380 }
381
382 alias c_long clock_t;
383 alias int id_t;
384 alias int key_t;
385 alias c_long suseconds_t;
386 alias uint useconds_t;
387
388 alias id_t taskid_t;
389 alias id_t projid_t;
390 alias id_t poolid_t;
391 alias id_t zoneid_t;
392 alias id_t ctid_t;
393 }
394 else
395 {
396 static assert(false, "Unsupported platform");
397 }
398
399 //
400 // Thread (THR)
401 //
402 /*
403 pthread_attr_t
404 pthread_cond_t
405 pthread_condattr_t
406 pthread_key_t
407 pthread_mutex_t
408 pthread_mutexattr_t
409 pthread_once_t
410 pthread_rwlock_t
411 pthread_rwlockattr_t
412 pthread_t
413 */
414
version(CRuntime_Glibc)415 version (CRuntime_Glibc)
416 {
417 version (X86)
418 {
419 enum __SIZEOF_PTHREAD_ATTR_T = 36;
420 enum __SIZEOF_PTHREAD_MUTEX_T = 24;
421 enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
422 enum __SIZEOF_PTHREAD_COND_T = 48;
423 enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
424 enum __SIZEOF_PTHREAD_RWLOCK_T = 32;
425 enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
426 enum __SIZEOF_PTHREAD_BARRIER_T = 20;
427 enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
428 }
429 else version (X86_64)
430 {
431 static if (__WORDSIZE == 64)
432 {
433 enum __SIZEOF_PTHREAD_ATTR_T = 56;
434 enum __SIZEOF_PTHREAD_MUTEX_T = 40;
435 enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
436 enum __SIZEOF_PTHREAD_COND_T = 48;
437 enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
438 enum __SIZEOF_PTHREAD_RWLOCK_T = 56;
439 enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
440 enum __SIZEOF_PTHREAD_BARRIER_T = 32;
441 enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
442 }
443 else
444 {
445 enum __SIZEOF_PTHREAD_ATTR_T = 32;
446 enum __SIZEOF_PTHREAD_MUTEX_T = 32;
447 enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
448 enum __SIZEOF_PTHREAD_COND_T = 48;
449 enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
450 enum __SIZEOF_PTHREAD_RWLOCK_T = 44;
451 enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
452 enum __SIZEOF_PTHREAD_BARRIER_T = 20;
453 enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
454 }
455 }
456 else version (AArch64)
457 {
458 enum __SIZEOF_PTHREAD_ATTR_T = 64;
459 enum __SIZEOF_PTHREAD_MUTEX_T = 48;
460 enum __SIZEOF_PTHREAD_MUTEXATTR_T = 8;
461 enum __SIZEOF_PTHREAD_COND_T = 48;
462 enum __SIZEOF_PTHREAD_CONDATTR_T = 8;
463 enum __SIZEOF_PTHREAD_RWLOCK_T = 56;
464 enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
465 enum __SIZEOF_PTHREAD_BARRIER_T = 32;
466 enum __SIZEOF_PTHREAD_BARRIERATTR_T = 8;
467 }
468 else version (ARM)
469 {
470 enum __SIZEOF_PTHREAD_ATTR_T = 36;
471 enum __SIZEOF_PTHREAD_MUTEX_T = 24;
472 enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
473 enum __SIZEOF_PTHREAD_COND_T = 48;
474 enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
475 enum __SIZEOF_PTHREAD_RWLOCK_T = 32;
476 enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
477 enum __SIZEOF_PTHREAD_BARRIER_T = 20;
478 enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
479 }
480 else version (HPPA)
481 {
482 enum __SIZEOF_PTHREAD_ATTR_T = 36;
483 enum __SIZEOF_PTHREAD_MUTEX_T = 48;
484 enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
485 enum __SIZEOF_PTHREAD_COND_T = 48;
486 enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
487 enum __SIZEOF_PTHREAD_RWLOCK_T = 64;
488 enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
489 enum __SIZEOF_PTHREAD_BARRIER_T = 48;
490 enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
491 }
492 else version (IA64)
493 {
494 enum __SIZEOF_PTHREAD_ATTR_T = 56;
495 enum __SIZEOF_PTHREAD_MUTEX_T = 40;
496 enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
497 enum __SIZEOF_PTHREAD_COND_T = 48;
498 enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
499 enum __SIZEOF_PTHREAD_RWLOCK_T = 56;
500 enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
501 enum __SIZEOF_PTHREAD_BARRIER_T = 32;
502 enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
503 }
504 else version (MIPS32)
505 {
506 enum __SIZEOF_PTHREAD_ATTR_T = 36;
507 enum __SIZEOF_PTHREAD_MUTEX_T = 24;
508 enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
509 enum __SIZEOF_PTHREAD_COND_T = 48;
510 enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
511 enum __SIZEOF_PTHREAD_RWLOCK_T = 32;
512 enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
513 enum __SIZEOF_PTHREAD_BARRIER_T = 20;
514 enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
515 }
516 else version (MIPS64)
517 {
518 enum __SIZEOF_PTHREAD_ATTR_T = 56;
519 enum __SIZEOF_PTHREAD_MUTEX_T = 40;
520 enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
521 enum __SIZEOF_PTHREAD_COND_T = 48;
522 enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
523 enum __SIZEOF_PTHREAD_RWLOCK_T = 56;
524 enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
525 enum __SIZEOF_PTHREAD_BARRIER_T = 32;
526 enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
527 }
528 else version (PPC)
529 {
530 enum __SIZEOF_PTHREAD_ATTR_T = 36;
531 enum __SIZEOF_PTHREAD_MUTEX_T = 24;
532 enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
533 enum __SIZEOF_PTHREAD_COND_T = 48;
534 enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
535 enum __SIZEOF_PTHREAD_RWLOCK_T = 32;
536 enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
537 enum __SIZEOF_PTHREAD_BARRIER_T = 20;
538 enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
539 }
540 else version (PPC64)
541 {
542 enum __SIZEOF_PTHREAD_ATTR_T = 56;
543 enum __SIZEOF_PTHREAD_MUTEX_T = 40;
544 enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
545 enum __SIZEOF_PTHREAD_COND_T = 48;
546 enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
547 enum __SIZEOF_PTHREAD_RWLOCK_T = 56;
548 enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
549 enum __SIZEOF_PTHREAD_BARRIER_T = 32;
550 enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
551 }
552 else version (RISCV32)
553 {
554 enum __SIZEOF_PTHREAD_ATTR_T = 36;
555 enum __SIZEOF_PTHREAD_MUTEX_T = 24;
556 enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
557 enum __SIZEOF_PTHREAD_COND_T = 48;
558 enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
559 enum __SIZEOF_PTHREAD_RWLOCK_T = 32;
560 enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
561 enum __SIZEOF_PTHREAD_BARRIER_T = 20;
562 enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
563 }
564 else version (RISCV64)
565 {
566 enum __SIZEOF_PTHREAD_ATTR_T = 56;
567 enum __SIZEOF_PTHREAD_MUTEX_T = 40;
568 enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
569 enum __SIZEOF_PTHREAD_COND_T = 48;
570 enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
571 enum __SIZEOF_PTHREAD_RWLOCK_T = 56;
572 enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
573 enum __SIZEOF_PTHREAD_BARRIER_T = 32;
574 enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
575 }
576 else version (SPARC)
577 {
578 enum __SIZEOF_PTHREAD_ATTR_T = 36;
579 enum __SIZEOF_PTHREAD_MUTEX_T = 24;
580 enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
581 enum __SIZEOF_PTHREAD_COND_T = 48;
582 enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
583 enum __SIZEOF_PTHREAD_RWLOCK_T = 32;
584 enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
585 enum __SIZEOF_PTHREAD_BARRIER_T = 20;
586 enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
587 }
588 else version (SPARC64)
589 {
590 enum __SIZEOF_PTHREAD_ATTR_T = 56;
591 enum __SIZEOF_PTHREAD_MUTEX_T = 40;
592 enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
593 enum __SIZEOF_PTHREAD_COND_T = 48;
594 enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
595 enum __SIZEOF_PTHREAD_RWLOCK_T = 56;
596 enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
597 enum __SIZEOF_PTHREAD_BARRIER_T = 32;
598 enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
599 }
600 else version (S390)
601 {
602 enum __SIZEOF_PTHREAD_ATTR_T = 36;
603 enum __SIZEOF_PTHREAD_MUTEX_T = 24;
604 enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
605 enum __SIZEOF_PTHREAD_COND_T = 48;
606 enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
607 enum __SIZEOF_PTHREAD_RWLOCK_T = 32;
608 enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
609 enum __SIZEOF_PTHREAD_BARRIER_T = 20;
610 enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
611 }
612 else version (SystemZ)
613 {
614 enum __SIZEOF_PTHREAD_ATTR_T = 56;
615 enum __SIZEOF_PTHREAD_MUTEX_T = 40;
616 enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
617 enum __SIZEOF_PTHREAD_COND_T = 48;
618 enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
619 enum __SIZEOF_PTHREAD_RWLOCK_T = 56;
620 enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
621 enum __SIZEOF_PTHREAD_BARRIER_T = 32;
622 enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
623 }
624 else
625 {
626 static assert (false, "Unsupported platform");
627 }
628
629 union pthread_attr_t
630 {
631 byte[__SIZEOF_PTHREAD_ATTR_T] __size;
632 c_long __align;
633 }
634
635 private alias int __atomic_lock_t;
636
637 private struct _pthread_fastlock
638 {
639 c_long __status;
640 __atomic_lock_t __spinlock;
641 }
642
643 private alias void* _pthread_descr;
644
645 union pthread_cond_t
646 {
647 byte[__SIZEOF_PTHREAD_COND_T] __size;
648 long __align;
649 }
650
651 union pthread_condattr_t
652 {
653 byte[__SIZEOF_PTHREAD_CONDATTR_T] __size;
654 int __align;
655 }
656
657 alias uint pthread_key_t;
658
659 union pthread_mutex_t
660 {
661 byte[__SIZEOF_PTHREAD_MUTEX_T] __size;
662 c_long __align;
663 }
664
665 union pthread_mutexattr_t
666 {
667 byte[__SIZEOF_PTHREAD_MUTEXATTR_T] __size;
668 int __align;
669 }
670
671 alias int pthread_once_t;
672
673 struct pthread_rwlock_t
674 {
675 byte[__SIZEOF_PTHREAD_RWLOCK_T] __size;
676 c_long __align;
677 }
678
679 struct pthread_rwlockattr_t
680 {
681 byte[__SIZEOF_PTHREAD_RWLOCKATTR_T] __size;
682 c_long __align;
683 }
684
685 alias c_ulong pthread_t;
686 }
version(CRuntime_Musl)687 else version (CRuntime_Musl)
688 {
689 version (D_LP64)
690 {
691 union pthread_attr_t
692 {
693 int[14] __i;
694 ulong[7] __s;
695 }
696
697 union pthread_cond_t
698 {
699 int[12] __i;
700 void*[6] __p;
701 }
702
703 union pthread_mutex_t
704 {
705 int[10] __i;
706 void*[5] __p;
707 }
708
709 union pthread_rwlock_t
710 {
711 int[14] __i;
712 void*[7] __p;
713 }
714 }
715 else
716 {
717 union pthread_attr_t
718 {
719 int[9] __i;
720 uint[9] __s;
721 }
722
723 union pthread_cond_t
724 {
725 int[12] __i;
726 void*[12] __p;
727 }
728
729 union pthread_mutex_t
730 {
731 int[6] __i;
732 void*[6] __p;
733 }
734
735 union pthread_rwlock_t
736 {
737 int[8] __i;
738 void*[8] __p;
739 }
740 }
741
742 struct pthread_rwlockattr_t
743 {
744 uint[2] __attr;
745 }
746
747 alias uint pthread_key_t;
748
749 struct pthread_condattr_t
750 {
751 uint __attr;
752 }
753
754 struct pthread_mutexattr_t
755 {
756 uint __attr;
757 }
758
759 alias int pthread_once_t;
760
761 alias c_ulong pthread_t;
762 }
version(Darwin)763 else version (Darwin)
764 {
765 version (D_LP64)
766 {
767 enum __PTHREAD_SIZE__ = 8176;
768 enum __PTHREAD_ATTR_SIZE__ = 56;
769 enum __PTHREAD_MUTEXATTR_SIZE__ = 8;
770 enum __PTHREAD_MUTEX_SIZE__ = 56;
771 enum __PTHREAD_CONDATTR_SIZE__ = 8;
772 enum __PTHREAD_COND_SIZE__ = 40;
773 enum __PTHREAD_ONCE_SIZE__ = 8;
774 enum __PTHREAD_RWLOCK_SIZE__ = 192;
775 enum __PTHREAD_RWLOCKATTR_SIZE__ = 16;
776 }
777 else
778 {
779 enum __PTHREAD_SIZE__ = 4088;
780 enum __PTHREAD_ATTR_SIZE__ = 36;
781 enum __PTHREAD_MUTEXATTR_SIZE__ = 8;
782 enum __PTHREAD_MUTEX_SIZE__ = 40;
783 enum __PTHREAD_CONDATTR_SIZE__ = 4;
784 enum __PTHREAD_COND_SIZE__ = 24;
785 enum __PTHREAD_ONCE_SIZE__ = 4;
786 enum __PTHREAD_RWLOCK_SIZE__ = 124;
787 enum __PTHREAD_RWLOCKATTR_SIZE__ = 12;
788 }
789
790 struct pthread_handler_rec
791 {
792 void function(void*) __routine;
793 void* __arg;
794 pthread_handler_rec* __next;
795 }
796
797 struct pthread_attr_t
798 {
799 c_long __sig;
800 byte[__PTHREAD_ATTR_SIZE__] __opaque;
801 }
802
803 struct pthread_cond_t
804 {
805 c_long __sig;
806 byte[__PTHREAD_COND_SIZE__] __opaque;
807 }
808
809 struct pthread_condattr_t
810 {
811 c_long __sig;
812 byte[__PTHREAD_CONDATTR_SIZE__] __opaque;
813 }
814
815 alias c_ulong pthread_key_t;
816
817 struct pthread_mutex_t
818 {
819 c_long __sig;
820 byte[__PTHREAD_MUTEX_SIZE__] __opaque;
821 }
822
823 struct pthread_mutexattr_t
824 {
825 c_long __sig;
826 byte[__PTHREAD_MUTEXATTR_SIZE__] __opaque;
827 }
828
829 struct pthread_once_t
830 {
831 c_long __sig;
832 byte[__PTHREAD_ONCE_SIZE__] __opaque;
833 }
834
835 struct pthread_rwlock_t
836 {
837 c_long __sig;
838 byte[__PTHREAD_RWLOCK_SIZE__] __opaque;
839 }
840
841 struct pthread_rwlockattr_t
842 {
843 c_long __sig;
844 byte[__PTHREAD_RWLOCKATTR_SIZE__] __opaque;
845 }
846
847 private struct _opaque_pthread_t
848 {
849 c_long __sig;
850 pthread_handler_rec* __cleanup_stack;
851 byte[__PTHREAD_SIZE__] __opaque;
852 }
853
854 alias _opaque_pthread_t* pthread_t;
855 }
version(FreeBSD)856 else version (FreeBSD)
857 {
858 alias int lwpid_t;
859
860 alias void* pthread_attr_t;
861 alias void* pthread_cond_t;
862 alias void* pthread_condattr_t;
863 alias void* pthread_key_t;
864 alias void* pthread_mutex_t;
865 alias void* pthread_mutexattr_t;
866 alias void* pthread_once_t;
867 alias void* pthread_rwlock_t;
868 alias void* pthread_rwlockattr_t;
869 alias void* pthread_t;
870 }
version(NetBSD)871 else version (NetBSD)
872 {
873 struct pthread_queue_t {
874 void* ptqh_first;
875 void** ptqh_last;
876 }
877
878 alias lwpid_t = int;
879 alias pthread_spin_t = ubyte;
880 struct pthread_attr_t {
881 uint pta_magic;
882 int pta_flags;
883 void* pta_private;
884 }
885 struct pthread_spinlock_t {
886 uint pts_magic;
887 pthread_spin_t pts_spin;
888 int pts_flags;
889 }
890 struct pthread_cond_t {
891 uint ptc_magic;
892 pthread_spin_t ptc_lock;
893 pthread_queue_t ptc_waiters;
894 pthread_mutex_t *ptc_mutex;
895 void* ptc_private;
896 }
897 struct pthread_condattr_t {
898 uint ptca_magic;
899 void *ptca_private;
900 }
901 struct pthread_mutex_t {
902 uint ptm_magic;
903 pthread_spin_t ptm_errorcheck;
904 ubyte[3] ptm_pad1;
905 pthread_spin_t ptm_interlock;
906 ubyte[3] ptm_pad2;
907 pthread_t ptm_owner;
908 void* ptm_waiters;
909 uint ptm_recursed;
910 void* ptm_spare2;
911 }
912 struct pthread_mutexattr_t{
913 uint ptma_magic;
914 void* ptma_private;
915 }
916 struct pthread_once_t{
917 pthread_mutex_t pto_mutex;
918 int pto_done;
919 }
920 struct pthread_rwlock_t{
921 uint ptr_magic;
922
923 pthread_spin_t ptr_interlock;
924
925 pthread_queue_t ptr_rblocked;
926 pthread_queue_t ptr_wblocked;
927 uint ptr_nreaders;
928 pthread_t ptr_owner;
929 void *ptr_private;
930 }
931 struct pthread_rwlockattr_t{
932 uint ptra_magic;
933 void* ptra_private;
934 }
935
936 alias uint pthread_key_t;
937 alias void* pthread_t;
938 }
version(OpenBSD)939 else version (OpenBSD)
940 {
941 alias void* pthread_attr_t;
942 alias void* pthread_cond_t;
943 alias void* pthread_condattr_t;
944 alias int pthread_key_t;
945 alias void* pthread_mutex_t;
946 alias void* pthread_mutexattr_t;
947
948 private struct pthread_once
949 {
950 int state;
951 pthread_mutex_t mutex;
952 }
953 alias pthread_once pthread_once_t;
954
955 alias void* pthread_rwlock_t;
956 alias void* pthread_rwlockattr_t;
957 alias void* pthread_t;
958 }
version(DragonFlyBSD)959 else version (DragonFlyBSD)
960 {
961 alias int lwpid_t;
962
963 alias void* pthread_attr_t;
964 alias void* pthread_cond_t;
965 alias void* pthread_condattr_t;
966 alias void* pthread_key_t;
967 alias void* pthread_mutex_t;
968 alias void* pthread_mutexattr_t;
969
970 private struct pthread_once
971 {
972 int state;
973 pthread_mutex_t mutex;
974 }
975 alias pthread_once pthread_once_t;
976
977 alias void* pthread_rwlock_t;
978 alias void* pthread_rwlockattr_t;
979 alias void* pthread_t;
980 }
version(Solaris)981 else version (Solaris)
982 {
983 alias uint pthread_t;
984
985 struct pthread_attr_t
986 {
987 void* __pthread_attrp;
988 }
989
990 struct pthread_cond_t
991 {
992 struct ___pthread_cond_flags
993 {
994 ubyte[4] __pthread_cond_flags;
995 ushort __pthread_cond_type;
996 ushort __pthread_cond_magic;
997 }
998
999 ___pthread_cond_flags __pthread_cond_flags;
1000 ulong __pthread_cond_data;
1001 }
1002
1003 struct pthread_condattr_t
1004 {
1005 void* __pthread_condattrp;
1006 }
1007
1008 struct pthread_rwlock_t
1009 {
1010 int __pthread_rwlock_readers;
1011 ushort __pthread_rwlock_type;
1012 ushort __pthread_rwlock_magic;
1013 pthread_mutex_t __pthread_rwlock_mutex;
1014 pthread_cond_t __pthread_rwlock_readercv;
1015 pthread_cond_t __pthread_rwlock_writercv;
1016 }
1017
1018 struct pthread_rwlockattr_t
1019 {
1020 void* __pthread_rwlockattrp;
1021 }
1022
1023 struct pthread_mutex_t
1024 {
1025 struct ___pthread_mutex_flags
1026 {
1027 ushort __pthread_mutex_flag1;
1028 ubyte __pthread_mutex_flag2;
1029 ubyte __pthread_mutex_ceiling;
1030 ushort __pthread_mutex_type;
1031 ushort __pthread_mutex_magic;
1032 }
1033
1034 ___pthread_mutex_flags __pthread_mutex_flags;
1035
1036 union ___pthread_mutex_lock
1037 {
1038 struct ___pthread_mutex_lock64
1039 {
1040 ubyte[8] __pthread_mutex_pad;
1041 }
1042
1043 ___pthread_mutex_lock64 __pthread_mutex_lock64;
1044
1045 struct ___pthread_mutex_lock32
1046 {
1047 uint __pthread_ownerpid;
1048 uint __pthread_lockword;
1049 }
1050
1051 ___pthread_mutex_lock32 __pthread_mutex_lock32;
1052 ulong __pthread_mutex_owner64;
1053 }
1054
1055 ___pthread_mutex_lock __pthread_mutex_lock;
1056 ulong __pthread_mutex_data;
1057 }
1058
1059 struct pthread_mutexattr_t
1060 {
1061 void* __pthread_mutexattrp;
1062 }
1063
1064 struct pthread_once_t
1065 {
1066 ulong[4] __pthread_once_pad;
1067 }
1068
1069 alias uint pthread_key_t;
1070 }
version(CRuntime_Bionic)1071 else version (CRuntime_Bionic)
1072 {
1073 struct pthread_attr_t
1074 {
1075 uint flags;
1076 void* stack_base;
1077 size_t stack_size;
1078 size_t guard_size;
1079 int sched_policy;
1080 int sched_priority;
1081 version (D_LP64) char[16] __reserved = 0;
1082 }
1083
1084 struct pthread_cond_t
1085 {
1086 version (D_LP64)
1087 int[12] __private;
1088 else
1089 int[1] __private;
1090 }
1091
1092 alias c_long pthread_condattr_t;
1093 alias int pthread_key_t;
1094
1095 struct pthread_mutex_t
1096 {
1097 version (D_LP64)
1098 int[10] __private;
1099 else
1100 int[1] __private;
1101 }
1102
1103 alias c_long pthread_mutexattr_t;
1104 alias int pthread_once_t;
1105
1106 struct pthread_rwlock_t
1107 {
1108 version (D_LP64)
1109 int[14] __private;
1110 else
1111 int[10] __private;
1112 }
1113
1114 alias c_long pthread_rwlockattr_t;
1115 alias c_long pthread_t;
1116 }
version(CRuntime_UClibc)1117 else version (CRuntime_UClibc)
1118 {
1119 version (X86_64)
1120 {
1121 enum __SIZEOF_PTHREAD_ATTR_T = 56;
1122 enum __SIZEOF_PTHREAD_MUTEX_T = 40;
1123 enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
1124 enum __SIZEOF_PTHREAD_COND_T = 48;
1125 enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
1126 enum __SIZEOF_PTHREAD_RWLOCK_T = 56;
1127 enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
1128 enum __SIZEOF_PTHREAD_BARRIER_T = 32;
1129 enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
1130 }
1131 else version (MIPS32)
1132 {
1133 enum __SIZEOF_PTHREAD_ATTR_T = 36;
1134 enum __SIZEOF_PTHREAD_MUTEX_T = 24;
1135 enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
1136 enum __SIZEOF_PTHREAD_COND_T = 48;
1137 enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
1138 enum __SIZEOF_PTHREAD_RWLOCK_T = 32;
1139 enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
1140 enum __SIZEOF_PTHREAD_BARRIER_T = 20;
1141 enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
1142 }
1143 else version (MIPS64)
1144 {
1145 enum __SIZEOF_PTHREAD_ATTR_T = 56;
1146 enum __SIZEOF_PTHREAD_MUTEX_T = 40;
1147 enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
1148 enum __SIZEOF_PTHREAD_COND_T = 48;
1149 enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
1150 enum __SIZEOF_PTHREAD_RWLOCK_T = 56;
1151 enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
1152 enum __SIZEOF_PTHREAD_BARRIER_T = 32;
1153 enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
1154 }
1155 else version (ARM)
1156 {
1157 enum __SIZEOF_PTHREAD_ATTR_T = 36;
1158 enum __SIZEOF_PTHREAD_MUTEX_T = 24;
1159 enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
1160 enum __SIZEOF_PTHREAD_COND_T = 48;
1161 enum __SIZEOF_PTHREAD_COND_COMPAT_T = 12;
1162 enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
1163 enum __SIZEOF_PTHREAD_RWLOCK_T = 32;
1164 enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
1165 enum __SIZEOF_PTHREAD_BARRIER_T = 20;
1166 enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
1167 }
1168 else
1169 {
1170 static assert (false, "Architecture unsupported");
1171 }
1172
1173 union pthread_attr_t
1174 {
1175 byte[__SIZEOF_PTHREAD_ATTR_T] __size;
1176 c_long __align;
1177 }
1178
1179 union pthread_cond_t
1180 {
1181 struct data
1182 {
1183 int __lock;
1184 uint __futex;
1185 ulong __total_seq;
1186 ulong __wakeup_seq;
1187 ulong __woken_seq;
1188 void *__mutex;
1189 uint __nwaiters;
1190 uint __broadcast_seq;
1191 } data __data;
1192 byte[__SIZEOF_PTHREAD_COND_T] __size;
1193 long __align;
1194 }
1195
1196 union pthread_condattr_t
1197 {
1198 byte[__SIZEOF_PTHREAD_CONDATTR_T] __size;
1199 c_long __align;
1200 }
1201
1202 alias uint pthread_key_t;
1203
1204 struct __pthread_slist_t
1205 {
1206 __pthread_slist_t* __next;
1207 }
1208
1209 union pthread_mutex_t
1210 {
1211 struct __pthread_mutex_s
1212 {
1213 int __lock;
1214 uint __count;
1215 int __owner;
1216 /* KIND must stay at this position in the structure to maintain
1217 binary compatibility. */
1218 int __kind;
1219 uint __nusers;
1220 union
1221 {
1222 int __spins;
1223 __pthread_slist_t __list;
1224 }
1225 }
1226 __pthread_mutex_s __data;
1227 byte[__SIZEOF_PTHREAD_MUTEX_T] __size;
1228 c_long __align;
1229 }
1230
1231 union pthread_mutexattr_t
1232 {
1233 byte[__SIZEOF_PTHREAD_MUTEXATTR_T] __size;
1234 c_long __align;
1235 }
1236
1237 alias int pthread_once_t;
1238
1239 struct pthread_rwlock_t
1240 {
1241 struct data
1242 {
1243 int __lock;
1244 uint __nr_readers;
1245 uint __readers_wakeup;
1246 uint __writer_wakeup;
1247 uint __nr_readers_queued;
1248 uint __nr_writers_queued;
1249 version (BigEndian)
1250 {
1251 ubyte __pad1;
1252 ubyte __pad2;
1253 ubyte __shared;
1254 ubyte __flags;
1255 }
1256 else
1257 {
1258 ubyte __flags;
1259 ubyte __shared;
1260 ubyte __pad1;
1261 ubyte __pad2;
1262 }
1263 int __writer;
1264 } data __data;
1265 byte[__SIZEOF_PTHREAD_RWLOCK_T] __size;
1266 c_long __align;
1267 }
1268
1269 struct pthread_rwlockattr_t
1270 {
1271 byte[__SIZEOF_PTHREAD_RWLOCKATTR_T] __size;
1272 c_long __align;
1273 }
1274
1275 alias c_ulong pthread_t;
1276 }
1277 else
1278 {
1279 static assert(false, "Unsupported platform");
1280 }
1281
1282 //
1283 // Barrier (BAR)
1284 //
1285 /*
1286 pthread_barrier_t
1287 pthread_barrierattr_t
1288 */
1289
1290 version (CRuntime_Glibc)
1291 {
1292 struct pthread_barrier_t
1293 {
1294 byte[__SIZEOF_PTHREAD_BARRIER_T] __size;
1295 c_long __align;
1296 }
1297
1298 struct pthread_barrierattr_t
1299 {
1300 byte[__SIZEOF_PTHREAD_BARRIERATTR_T] __size;
1301 int __align;
1302 }
1303 }
1304 else version (FreeBSD)
1305 {
1306 alias void* pthread_barrier_t;
1307 alias void* pthread_barrierattr_t;
1308 }
1309 else version (NetBSD)
1310 {
1311 alias void* pthread_barrier_t;
1312 alias void* pthread_barrierattr_t;
1313 }
1314 else version (OpenBSD)
1315 {
1316 alias void* pthread_barrier_t;
1317 alias void* pthread_barrierattr_t;
1318 }
1319 else version (DragonFlyBSD)
1320 {
1321 alias void* pthread_barrier_t;
1322 alias void* pthread_barrierattr_t;
1323 }
1324 else version (Darwin)
1325 {
1326 }
1327 else version (Solaris)
1328 {
1329 struct pthread_barrier_t
1330 {
1331 uint __pthread_barrier_count;
1332 uint __pthread_barrier_current;
1333 ulong __pthread_barrier_cycle;
1334 ulong __pthread_barrier_reserved;
1335 pthread_mutex_t __pthread_barrier_lock;
1336 pthread_cond_t __pthread_barrier_cond;
1337 }
1338
1339 struct pthread_barrierattr_t
1340 {
1341 void* __pthread_barrierattrp;
1342 }
1343 }
1344 else version (CRuntime_Bionic)
1345 {
1346 }
1347 else version (CRuntime_Musl)
1348 {
1349 version (D_LP64)
1350 {
1351 union pthread_barrier_t
1352 {
1353 int[8] __i;
1354 void*[4] __p;
1355 }
1356 }
1357 else
1358 {
1359 union pthread_barrier_t
1360 {
1361 int[5] __i;
1362 void*[5] __p;
1363 }
1364 }
1365
1366 struct pthread_barrierattr_t
1367 {
1368 uint __attr;
1369 }
1370 }
1371 else version (CRuntime_UClibc)
1372 {
1373 struct pthread_barrier_t
1374 {
1375 byte[__SIZEOF_PTHREAD_BARRIER_T] __size;
1376 c_long __align;
1377 }
1378
1379 struct pthread_barrierattr_t
1380 {
1381 byte[__SIZEOF_PTHREAD_BARRIERATTR_T] __size;
1382 int __align;
1383 }
1384 }
1385 else
1386 {
1387 static assert(false, "Unsupported platform");
1388 }
1389
1390 //
1391 // Spin (SPN)
1392 //
1393 /*
1394 pthread_spinlock_t
1395 */
1396
1397 version (CRuntime_Glibc)
1398 {
1399 alias int pthread_spinlock_t; // volatile
1400 }
1401 else version (FreeBSD)
1402 {
1403 alias void* pthread_spinlock_t;
1404 }
1405 else version (NetBSD)
1406 {
1407 //already defined
1408 }
1409 else version (OpenBSD)
1410 {
1411 alias void* pthread_spinlock_t;
1412 }
1413 else version (DragonFlyBSD)
1414 {
1415 alias void* pthread_spinlock_t;
1416 }
1417 else version (Solaris)
1418 {
1419 alias pthread_mutex_t pthread_spinlock_t;
1420 }
1421 else version (CRuntime_UClibc)
1422 {
1423 alias int pthread_spinlock_t; // volatile
1424 }
1425 else version (CRuntime_Musl)
1426 {
1427 alias int pthread_spinlock_t;
1428 }
1429
1430 //
1431 // Timer (TMR)
1432 //
1433 /*
1434 clockid_t
1435 timer_t
1436 */
1437
1438 //
1439 // Trace (TRC)
1440 //
1441 /*
1442 trace_attr_t
1443 trace_event_id_t
1444 trace_event_set_t
1445 trace_id_t
1446 */
1447