libphobos/libdruntime/core/sys/posix/sys/mman.d

   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, Alex Rønne Petersen
   7  * Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
   8  */
   9
  10 /*          Copyright Sean Kelly 2005 - 2009.
  11  * Distributed under the Boost Software License, Version 1.0.
  12  *    (See accompanying file LICENSE or copy at
  13  *          http://www.boost.org/LICENSE_1_0.txt)
  14  */
  15 module core.sys.posix.sys.mman;
  16
  17 private import core.sys.posix.config;
  18 public import core.sys.posix.sys.types; // for off_t, mode_t
  19
  20 version (OSX)
  21     version = Darwin;
  22 else version (iOS)
  23     version = Darwin;
  24 else version (TVOS)
  25     version = Darwin;
  26 else version (WatchOS)
  27     version = Darwin;
  28
  29 version (ARM)     version = ARM_Any;
  30 version (AArch64) version = ARM_Any;
  31 version (HPPA)    version = HPPA_Any;
  32 version (HPPA64)  version = HPPA_Any;
  33 version (MIPS32)  version = MIPS_Any;
  34 version (MIPS64)  version = MIPS_Any;
  35 version (PPC)     version = PPC_Any;
  36 version (PPC64)   version = PPC_Any;
  37 version (RISCV32) version = RISCV_Any;
  38 version (RISCV64) version = RISCV_Any;
  39 version (S390)    version = IBMZ_Any;
  40 version (SPARC)   version = SPARC_Any;
  41 version (SPARC64) version = SPARC_Any;
  42 version (SystemZ) version = IBMZ_Any;
  43 version (X86)     version = X86_Any;
  44 version (X86_64)  version = X86_Any;
  45
  46 version (Posix):
  47 extern (C) nothrow @nogc:
  48
  49 //
  50 // Advisory Information (ADV)
  51 //
  52 /*
  53 int posix_madvise(void*, size_t, int);
  54 */
  55
  56 //
  57 // Advisory Information and either Memory Mapped Files or Shared Memory Objects (MC1)
  58 //
  59 /*
  60 POSIX_MADV_NORMAL
  61 POSIX_MADV_SEQUENTIAL
  62 POSIX_MADV_RANDOM
  63 POSIX_MADV_WILLNEED
  64 POSIX_MADV_DONTNEED
  65 */
  66
  67 version (CRuntime_Glibc)
  68 {
  69     version (Alpha)
  70         private enum __POSIX_MADV_DONTNEED = 6;
  71     else
  72         private enum __POSIX_MADV_DONTNEED = 4;
  73
  74     static if (__USE_XOPEN2K)
  75     {
  76         enum
  77         {
  78             POSIX_MADV_NORMAL = 0,
  79             POSIX_MADV_RANDOM = 1,
  80             POSIX_MADV_SEQUENTIAL = 2,
  81             POSIX_MADV_WILLNEED = 3,
  82             POSIX_MADV_DONTNEED = __POSIX_MADV_DONTNEED,
  83         }
  84         int posix_madvise(void *__addr, size_t __len, int __advice);
  85     }
  86 }
  87 else version (Darwin)
  88 {
  89     enum POSIX_MADV_NORMAL      = 0;
  90     enum POSIX_MADV_RANDOM      = 1;
  91     enum POSIX_MADV_SEQUENTIAL  = 2;
  92     enum POSIX_MADV_WILLNEED    = 3;
  93     enum POSIX_MADV_DONTNEED    = 4;
  94     int posix_madvise(void *addr, size_t len, int advice);
  95 }
  96 else version (FreeBSD)
  97 {
  98     enum POSIX_MADV_NORMAL      = 0;
  99     enum POSIX_MADV_RANDOM      = 1;
 100     enum POSIX_MADV_SEQUENTIAL  = 2;
 101     enum POSIX_MADV_WILLNEED    = 3;
 102     enum POSIX_MADV_DONTNEED    = 4;
 103     int posix_madvise(void *addr, size_t len, int advice);
 104 }
 105 else version (NetBSD)
 106 {
 107     enum POSIX_MADV_NORMAL      = 0;
 108     enum POSIX_MADV_RANDOM      = 1;
 109     enum POSIX_MADV_SEQUENTIAL  = 2;
 110     enum POSIX_MADV_WILLNEED    = 3;
 111     enum POSIX_MADV_DONTNEED    = 4;
 112     int posix_madvise(void *addr, size_t len, int advice);
 113 }
 114 else version (OpenBSD)
 115 {
 116     enum POSIX_MADV_NORMAL      = 0;
 117     enum POSIX_MADV_RANDOM      = 1;
 118     enum POSIX_MADV_SEQUENTIAL  = 2;
 119     enum POSIX_MADV_WILLNEED    = 3;
 120     enum POSIX_MADV_DONTNEED    = 4;
 121     int posix_madvise(void *addr, size_t len, int advice);
 122 }
 123 else version (DragonFlyBSD)
 124 {
 125     enum POSIX_MADV_NORMAL      = 0;
 126     enum POSIX_MADV_RANDOM      = 1;
 127     enum POSIX_MADV_SEQUENTIAL  = 2;
 128     enum POSIX_MADV_WILLNEED    = 3;
 129     enum POSIX_MADV_DONTNEED    = 4;
 130     int posix_madvise(void *addr, size_t len, int advice);
 131 }
 132 else version (Solaris)
 133 {
 134 }
 135 else version (CRuntime_Bionic)
 136 {
 137 }
 138 else version (CRuntime_Musl)
 139 {
 140 }
 141 else version (CRuntime_UClibc)
 142 {
 143     enum
 144     {
 145         POSIX_MADV_NORMAL = 0,
 146         POSIX_MADV_RANDOM = 1,
 147         POSIX_MADV_SEQUENTIAL = 2,
 148         POSIX_MADV_WILLNEED = 3,
 149         POSIX_MADV_DONTNEED = 4,
 150     }
 151     int posix_madvise(void *__addr, size_t __len, int __advice);
 152 }
 153 else
 154 {
 155     static assert(false, "Unsupported platform");
 156 }
 157
 158 //
 159 // Memory Mapped Files, Shared Memory Objects, or Memory Protection (MC2)
 160 //
 161 /*
 162 PROT_READ
 163 PROT_WRITE
 164 PROT_EXEC
 165 PROT_NONE
 166 */
 167
 168 version (CRuntime_Glibc)
 169 {
 170     enum PROT_NONE      = 0x0;
 171     enum PROT_READ      = 0x1;
 172     enum PROT_WRITE     = 0x2;
 173     enum PROT_EXEC      = 0x4;
 174 }
 175 else version (Darwin)
 176 {
 177     enum PROT_NONE      = 0x00;
 178     enum PROT_READ      = 0x01;
 179     enum PROT_WRITE     = 0x02;
 180     enum PROT_EXEC      = 0x04;
 181 }
 182 else version (FreeBSD)
 183 {
 184     enum PROT_NONE      = 0x00;
 185     enum PROT_READ      = 0x01;
 186     enum PROT_WRITE     = 0x02;
 187     enum PROT_EXEC      = 0x04;
 188 }
 189 else version (NetBSD)
 190 {
 191     enum PROT_NONE      = 0x00;
 192     enum PROT_READ      = 0x01;
 193     enum PROT_WRITE     = 0x02;
 194     enum PROT_EXEC      = 0x04;
 195 }
 196 else version (OpenBSD)
 197 {
 198     enum PROT_NONE      = 0x00;
 199     enum PROT_READ      = 0x01;
 200     enum PROT_WRITE     = 0x02;
 201     enum PROT_EXEC      = 0x04;
 202 }
 203 else version (DragonFlyBSD)
 204 {
 205     enum PROT_NONE      = 0x00;
 206     enum PROT_READ      = 0x01;
 207     enum PROT_WRITE     = 0x02;
 208     enum PROT_EXEC      = 0x04;
 209 }
 210 else version (Solaris)
 211 {
 212     enum PROT_NONE = 0x00;
 213     enum PROT_READ = 0x01;
 214     enum PROT_WRITE = 0x02;
 215     enum PROT_EXEC = 0x04;
 216 }
 217 else version (CRuntime_Bionic)
 218 {
 219     enum PROT_NONE = 0x00;
 220     enum PROT_READ = 0x01;
 221     enum PROT_WRITE = 0x02;
 222     enum PROT_EXEC = 0x04;
 223 }
 224 else version (CRuntime_Musl)
 225 {
 226     enum PROT_NONE      = 0x0;
 227     enum PROT_READ      = 0x1;
 228     enum PROT_WRITE     = 0x2;
 229     enum PROT_EXEC      = 0x4;
 230 }
 231 else version (CRuntime_UClibc)
 232 {
 233     enum PROT_NONE      = 0x0;
 234     enum PROT_READ      = 0x1;
 235     enum PROT_WRITE     = 0x2;
 236     enum PROT_EXEC      = 0x4;
 237 }
 238 else
 239 {
 240     static assert(false, "Unsupported platform");
 241 }
 242
 243 //
 244 // Memory Mapped Files, Shared Memory Objects, or Typed Memory Objects (MC3)
 245 //
 246 /*
 247 void* mmap(void*, size_t, int, int, int, off_t);
 248 int munmap(void*, size_t);
 249 */
 250
 251 version (CRuntime_Glibc)
 252 {
 253     static if (__USE_LARGEFILE64) void* mmap64(void*, size_t, int, int, int, off_t);
 254     static if (__USE_FILE_OFFSET64)
 255         alias mmap = mmap64;
 256     else
 257         void* mmap(void*, size_t, int, int, int, off_t);
 258     int munmap(void*, size_t);
 259 }
 260 else version (Darwin)
 261 {
 262     void* mmap(void*, size_t, int, int, int, off_t);
 263     int   munmap(void*, size_t);
 264 }
 265 else version (FreeBSD)
 266 {
 267     void* mmap(void*, size_t, int, int, int, off_t);
 268     int   munmap(void*, size_t);
 269 }
 270 else version (NetBSD)
 271 {
 272     void* mmap(void*, size_t, int, int, int, off_t);
 273     int   munmap(void*, size_t);
 274 }
 275 else version (OpenBSD)
 276 {
 277     void* mmap(void*, size_t, int, int, int, off_t);
 278     int   munmap(void*, size_t);
 279 }
 280 else version (DragonFlyBSD)
 281 {
 282     void* mmap(void*, size_t, int, int, int, off_t);
 283     int   munmap(void*, size_t);
 284 }
 285 else version (Solaris)
 286 {
 287     void* mmap(void*, size_t, int, int, int, off_t);
 288     int   munmap(void*, size_t);
 289 }
 290 else version (CRuntime_Bionic)
 291 {
 292     void* mmap(void*, size_t, int, int, int, off_t);
 293     int   munmap(void*, size_t);
 294 }
 295 else version (CRuntime_Musl)
 296 {
 297     static if (__USE_LARGEFILE64) void* mmap64(void*, size_t, int, int, int, off_t);
 298     static if (__USE_FILE_OFFSET64)
 299         alias mmap = mmap64;
 300     else
 301         void* mmap(void*, size_t, int, int, int, off_t);
 302     int munmap(void*, size_t);
 303 }
 304 else version (CRuntime_UClibc)
 305 {
 306     static if (__USE_LARGEFILE64) void* mmap64(void*, size_t, int, int, int, off64_t);
 307     static if (__USE_FILE_OFFSET64)
 308         alias mmap = mmap64;
 309     else
 310         void* mmap(void*, size_t, int, int, int, off_t);
 311     int munmap(void*, size_t);
 312 }
 313 else
 314 {
 315     static assert(false, "Unsupported platform");
 316 }
 317
 318 //
 319 // Memory Mapped Files (MF)
 320 //
 321 /*
 322 MAP_SHARED (MF|SHM)
 323 MAP_PRIVATE (MF|SHM)
 324 MAP_FIXED  (MF|SHM)
 325 MAP_FAILED (MF|SHM)
 326
 327 MS_ASYNC (MF|SIO)
 328 MS_SYNC (MF|SIO)
 329 MS_INVALIDATE (MF|SIO)
 330
 331 int msync(void*, size_t, int); (MF|SIO)
 332 */
 333
 334 version (CRuntime_Glibc)
 335 {
 336     enum MAP_SHARED     = 0x01;
 337     enum MAP_PRIVATE    = 0x02;
 338     enum MAP_FIXED      = 0x10;
 339
 340     enum MAP_FAILED     = cast(void*) -1;
 341
 342     version (MICROBLAZE)
 343         private enum DEFAULTS = true;
 344     else version (Alpha)
 345     {
 346         private enum DEFAULTS = false;
 347         enum MAP_ANON = 0x10;
 348         enum MS_ASYNC = 1;
 349         enum MS_SYNC = 2;
 350         enum MS_INVALIDATE = 4;
 351     }
 352     else version (SH)
 353         private enum DEFAULTS = true;
 354     else version (ARM_Any)
 355         private enum DEFAULTS = true;
 356     else version (IBMZ_Any)
 357         private enum DEFAULTS = true;
 358     else version (IA64)
 359         private enum DEFAULTS = true;
 360     else version (HPPA_Any)
 361     {
 362         private enum DEFAULTS = false;
 363         enum MAP_ANON = 0x10;
 364         enum MS_SYNC = 1;
 365         enum MS_ASYNC = 2;
 366         enum MS_INVALIDATE = 4;
 367     }
 368     else version (M68K)
 369         private enum DEFAULTS = true;
 370     else version (TILE)
 371         private enum DEFAULTS = true;
 372     else version (X86_Any)
 373         private enum DEFAULTS = true;
 374     else version (MIPS_Any)
 375     {
 376         private enum DEFAULTS = false;
 377         enum MAP_ANON = 0x0800;
 378         enum MS_ASYNC = 1;
 379         enum MS_INVALIDATE = 2;
 380         enum MS_SYNC = 4;
 381     }
 382     else version (RISCV_Any)
 383         private enum DEFAULTS = true;
 384     else version (SPARC_Any)
 385         private enum DEFAULTS = true;
 386     else version (PPC_Any)
 387         private enum DEFAULTS = true;
 388     else
 389         static assert(0, "unimplemented");
 390
 391     static if (DEFAULTS)
 392     {
 393         enum MAP_ANON = 0x20;
 394         enum MS_ASYNC = 1;
 395         enum MS_INVALIDATE = 2;
 396         enum MS_SYNC = 4;
 397     }
 398
 399     int msync(void*, size_t, int);
 400 }
 401 else version (Darwin)
 402 {
 403     enum MAP_SHARED     = 0x0001;
 404     enum MAP_PRIVATE    = 0x0002;
 405     enum MAP_FIXED      = 0x0010;
 406     enum MAP_ANON       = 0x1000;
 407
 408     enum MAP_FAILED     = cast(void*)-1;
 409
 410     enum MS_ASYNC       = 0x0001;
 411     enum MS_INVALIDATE  = 0x0002;
 412     enum MS_SYNC        = 0x0010;
 413
 414     int msync(void*, size_t, int);
 415 }
 416 else version (FreeBSD)
 417 {
 418     enum MAP_SHARED     = 0x0001;
 419     enum MAP_PRIVATE    = 0x0002;
 420     enum MAP_FIXED      = 0x0010;
 421     enum MAP_ANON       = 0x1000;
 422
 423     enum MAP_FAILED     = cast(void*)-1;
 424
 425     enum MS_SYNC        = 0x0000;
 426     enum MS_ASYNC       = 0x0001;
 427     enum MS_INVALIDATE  = 0x0002;
 428
 429     int msync(void*, size_t, int);
 430 }
 431 else version (NetBSD)
 432 {
 433     enum MAP_SHARED     = 0x0001;
 434     enum MAP_PRIVATE    = 0x0002;
 435     enum MAP_FIXED      = 0x0010;
 436     enum MAP_ANON       = 0x1000;
 437
 438     enum MAP_FAILED     = cast(void*)-1;
 439
 440     enum MS_SYNC        = 0x0004;
 441     enum MS_ASYNC       = 0x0001;
 442     enum MS_INVALIDATE  = 0x0002;
 443
 444     int __msync13(void*, size_t, int);
 445     alias msync = __msync13;
 446 }
 447 else version (OpenBSD)
 448 {
 449     enum MAP_SHARED     = 0x0001;
 450     enum MAP_PRIVATE    = 0x0002;
 451     enum MAP_FIXED      = 0x0010;
 452     enum MAP_ANON       = 0x1000;
 453
 454     enum MAP_FAILED     = cast(void*)-1;
 455
 456     enum MS_SYNC        = 0x0002;
 457     enum MS_ASYNC       = 0x0001;
 458     enum MS_INVALIDATE  = 0x0004;
 459
 460     int msync(void*, size_t, int);
 461 }
 462 else version (DragonFlyBSD)
 463 {
 464     enum MAP_SHARED     = 0x0001;
 465     enum MAP_PRIVATE    = 0x0002;
 466     enum MAP_FIXED      = 0x0010;
 467     enum MAP_ANON       = 0x1000;
 468
 469     enum MAP_FAILED     = cast(void*)-1;
 470
 471     enum MS_SYNC        = 0x0000;
 472     enum MS_ASYNC       = 0x0001;
 473     enum MS_INVALIDATE  = 0x0002;
 474
 475     int msync(void*, size_t, int);
 476 }
 477 else version (Solaris)
 478 {
 479     enum MAP_SHARED = 0x0001;
 480     enum MAP_PRIVATE = 0x0002;
 481     enum MAP_FIXED = 0x0010;
 482     enum MAP_ANON = 0x0100;
 483
 484     enum MAP_FAILED = cast(void*)-1;
 485
 486     enum MS_SYNC = 0x0004;
 487     enum MS_ASYNC = 0x0001;
 488     enum MS_INVALIDATE  = 0x0002;
 489
 490     int msync(void*, size_t, int);
 491 }
 492 else version (CRuntime_Bionic)
 493 {
 494     enum MAP_SHARED     = 0x0001;
 495     enum MAP_PRIVATE    = 0x0002;
 496     enum MAP_FIXED      = 0x0010;
 497     enum MAP_ANON       = 0x0020;
 498
 499     enum MAP_FAILED     = cast(void*)-1;
 500
 501     enum MS_SYNC        = 4;
 502     enum MS_ASYNC       = 1;
 503     enum MS_INVALIDATE  = 2;
 504
 505     int msync(in void*, size_t, int);
 506 }
 507 else version (CRuntime_Musl)
 508 {
 509     enum MAP_SHARED     = 0x01;
 510     enum MAP_PRIVATE    = 0x02;
 511     enum MAP_FIXED      = 0x10;
 512
 513     enum MAP_FAILED     = cast(void*) -1;
 514     enum MAP_ANON = 0x20;
 515     enum MS_ASYNC = 1;
 516     enum MS_INVALIDATE = 2;
 517     enum MS_SYNC = 4;
 518     int msync(void*, size_t, int);
 519 }
 520 else version (CRuntime_UClibc)
 521 {
 522     enum MAP_SHARED     = 0x01;
 523     enum MAP_PRIVATE    = 0x02;
 524     enum MAP_FIXED      = 0x10;
 525
 526     enum MAP_FAILED     = cast(void*) -1;
 527
 528     version (X86_64)
 529     {
 530         enum MAP_ANON       = 0x20;
 531         enum MS_ASYNC       = 1;
 532         enum MS_INVALIDATE  = 2;
 533         enum MS_SYNC        = 4;
 534     }
 535     else version (MIPS32)
 536     {
 537         enum MAP_ANON       = 0x0800;
 538         enum MS_ASYNC       = 1;
 539         enum MS_INVALIDATE  = 2;
 540         enum MS_SYNC        = 4;
 541     }
 542     else version (ARM)
 543     {
 544         enum MAP_ANON       = 0x020;
 545         enum MS_ASYNC       = 1;
 546         enum MS_INVALIDATE  = 2;
 547         enum MS_SYNC        = 4;
 548     }
 549     else
 550     {
 551         static assert(false, "Architecture not supported.");
 552     }
 553
 554
 555     int msync(void*, size_t, int);
 556 }
 557 else
 558 {
 559     static assert(false, "Unsupported platform");
 560 }
 561
 562 //
 563 // Process Memory Locking (ML)
 564 //
 565 /*
 566 MCL_CURRENT
 567 MCL_FUTURE
 568
 569 int mlockall(int);
 570 int munlockall();
 571 */
 572
 573 version (CRuntime_Glibc)
 574 {
 575     version (SPARC_Any) enum
 576     {
 577         MCL_CURRENT = 0x2000,
 578         MCL_FUTURE = 0x4000,
 579     }
 580     else version (PPC_Any) enum
 581     {
 582         MCL_CURRENT = 0x2000,
 583         MCL_FUTURE = 0x4000,
 584     }
 585     else version (Alpha) enum
 586     {
 587         MCL_CURRENT = 8192,
 588         MCL_FUTURE = 16384,
 589     }
 590     else enum
 591     {
 592         MCL_CURRENT = 1,
 593         MCL_FUTURE = 2,
 594     }
 595
 596     int mlockall(int);
 597     int munlockall();
 598
 599 }
 600 else version (Darwin)
 601 {
 602     enum MCL_CURRENT    = 0x0001;
 603     enum MCL_FUTURE     = 0x0002;
 604
 605     int mlockall(int);
 606     int munlockall();
 607 }
 608 else version (FreeBSD)
 609 {
 610     enum MCL_CURRENT    = 0x0001;
 611     enum MCL_FUTURE     = 0x0002;
 612
 613     int mlockall(int);
 614     int munlockall();
 615 }
 616 else version (NetBSD)
 617 {
 618     enum MCL_CURRENT    = 0x0001;
 619     enum MCL_FUTURE     = 0x0002;
 620
 621     int mlockall(int);
 622     int munlockall();
 623 }
 624 else version (OpenBSD)
 625 {
 626     enum MCL_CURRENT    = 0x0001;
 627     enum MCL_FUTURE     = 0x0002;
 628
 629     int mlockall(int);
 630     int munlockall();
 631 }
 632 else version (DragonFlyBSD)
 633 {
 634     enum MCL_CURRENT    = 0x0001;
 635     enum MCL_FUTURE     = 0x0002;
 636
 637     int mlockall(int);
 638     int munlockall();
 639 }
 640 else version (Solaris)
 641 {
 642     enum MCL_CURRENT = 0x0001;
 643     enum MCL_FUTURE = 0x0002;
 644
 645     int mlockall(int);
 646     int munlockall();
 647 }
 648 else version (CRuntime_Bionic)
 649 {
 650     enum MCL_CURRENT = 1;
 651     enum MCL_FUTURE  = 2;
 652
 653     int mlockall(int);
 654     int munlockall();
 655 }
 656 else version (CRuntime_Musl)
 657 {
 658 }
 659 else version (CRuntime_UClibc)
 660 {
 661     enum
 662     {
 663         MCL_CURRENT = 1,
 664         MCL_FUTURE = 2,
 665     }
 666
 667     int mlockall(int);
 668     int munlockall();
 669
 670 }
 671 else
 672 {
 673     static assert(false, "Unsupported platform");
 674 }
 675
 676 //
 677 // Range Memory Locking (MLR)
 678 //
 679 /*
 680 int mlock(in void*, size_t);
 681 int munlock(in void*, size_t);
 682 */
 683
 684 version (CRuntime_Glibc)
 685 {
 686     int mlock(in void*, size_t);
 687     int munlock(in void*, size_t);
 688 }
 689 else version (Darwin)
 690 {
 691     int mlock(in void*, size_t);
 692     int munlock(in void*, size_t);
 693 }
 694 else version (FreeBSD)
 695 {
 696     int mlock(in void*, size_t);
 697     int munlock(in void*, size_t);
 698 }
 699 else version (NetBSD)
 700 {
 701     int mlock(in void*, size_t);
 702     int munlock(in void*, size_t);
 703 }
 704 else version (OpenBSD)
 705 {
 706     int mlock(in void*, size_t);
 707     int munlock(in void*, size_t);
 708 }
 709 else version (DragonFlyBSD)
 710 {
 711     int mlock(in void*, size_t);
 712     int munlock(in void*, size_t);
 713 }
 714 else version (Solaris)
 715 {
 716     int mlock(in void*, size_t);
 717     int munlock(in void*, size_t);
 718 }
 719 else version (CRuntime_Bionic)
 720 {
 721     int mlock(in void*, size_t);
 722     int munlock(in void*, size_t);
 723 }
 724 else version (CRuntime_Musl)
 725 {
 726 }
 727 else version (CRuntime_UClibc)
 728 {
 729     int mlock(in void*, size_t);
 730     int munlock(in void*, size_t);
 731 }
 732 else
 733 {
 734     static assert(false, "Unsupported platform");
 735 }
 736
 737 //
 738 // Memory Protection (MPR)
 739 //
 740 /*
 741 int mprotect(void*, size_t, int);
 742 */
 743
 744 version (CRuntime_Glibc)
 745 {
 746     int mprotect(void*, size_t, int);
 747 }
 748 else version (Darwin)
 749 {
 750     int mprotect(void*, size_t, int);
 751 }
 752 else version (FreeBSD)
 753 {
 754     int mprotect(void*, size_t, int);
 755 }
 756 else version (NetBSD)
 757 {
 758     int mprotect(void*, size_t, int);
 759 }
 760 else version (OpenBSD)
 761 {
 762     int mprotect(void*, size_t, int);
 763 }
 764 else version (DragonFlyBSD)
 765 {
 766     int mprotect(void*, size_t, int);
 767 }
 768 else version (Solaris)
 769 {
 770     int mprotect(void*, size_t, int);
 771 }
 772 else version (CRuntime_Bionic)
 773 {
 774     int mprotect(in void*, size_t, int);
 775 }
 776 else version (CRuntime_Musl)
 777 {
 778     int mprotect(void*, size_t, int);
 779 }
 780 else version (CRuntime_UClibc)
 781 {
 782     int mprotect(void*, size_t, int);
 783 }
 784 else
 785 {
 786     static assert(false, "Unsupported platform");
 787 }
 788
 789 //
 790 // Shared Memory Objects (SHM)
 791 //
 792 /*
 793 int shm_open(in char*, int, mode_t);
 794 int shm_unlink(in char*);
 795 */
 796
 797 version (CRuntime_Glibc)
 798 {
 799     int shm_open(in char*, int, mode_t);
 800     int shm_unlink(in char*);
 801 }
 802 else version (Darwin)
 803 {
 804     int shm_open(in char*, int, mode_t);
 805     int shm_unlink(in char*);
 806 }
 807 else version (FreeBSD)
 808 {
 809     int shm_open(in char*, int, mode_t);
 810     int shm_unlink(in char*);
 811 }
 812 else version (NetBSD)
 813 {
 814     int shm_open(in char*, int, mode_t);
 815     int shm_unlink(in char*);
 816 }
 817 else version (OpenBSD)
 818 {
 819     int shm_open(in char*, int, mode_t);
 820     int shm_unlink(in char*);
 821 }
 822 else version (DragonFlyBSD)
 823 {
 824     int shm_open(in char*, int, mode_t);
 825     int shm_unlink(in char*);
 826 }
 827 else version (Solaris)
 828 {
 829     int shm_open(in char*, int, mode_t);
 830     int shm_unlink(in char*);
 831 }
 832 else version (CRuntime_Bionic)
 833 {
 834 }
 835 else version (CRuntime_Musl)
 836 {
 837 }
 838 else version (CRuntime_UClibc)
 839 {
 840     int shm_open(in char*, int, mode_t);
 841     int shm_unlink(in char*);
 842 }
 843 else
 844 {
 845     static assert(false, "Unsupported platform");
 846 }
 847
 848 //
 849 // Typed Memory Objects (TYM)
 850 //
 851 /*
 852 POSIX_TYPED_MEM_ALLOCATE
 853 POSIX_TYPED_MEM_ALLOCATE_CONTIG
 854 POSIX_TYPED_MEM_MAP_ALLOCATABLE
 855
 856 struct posix_typed_mem_info
 857 {
 858     size_t posix_tmi_length;
 859 }
 860
 861 int posix_mem_offset(in void*, size_t, off_t *, size_t *, int *);
 862 int posix_typed_mem_get_info(int, struct posix_typed_mem_info *);
 863 int posix_typed_mem_open(in char*, int, int);
 864 */