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