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