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