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
version(Posix)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 }
version(Darwin)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 }
version(FreeBSD)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 }
version(NetBSD)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 }
version(DragonFlyBSD)114 else version (DragonFlyBSD)
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 }
version(Solaris)123 else version (Solaris)
124 {
125 }
version(CRuntime_Bionic)126 else version (CRuntime_Bionic)
127 {
128 }
version(CRuntime_Musl)129 else version (CRuntime_Musl)
130 {
131 }
version(CRuntime_UClibc)132 else version (CRuntime_UClibc)
133 {
134 enum
135 {
136 POSIX_MADV_NORMAL = 0,
137 POSIX_MADV_RANDOM = 1,
138 POSIX_MADV_SEQUENTIAL = 2,
139 POSIX_MADV_WILLNEED = 3,
140 POSIX_MADV_DONTNEED = 4,
141 }
142 int posix_madvise(void *__addr, size_t __len, int __advice);
143 }
144 else
145 {
146 static assert(false, "Unsupported platform");
147 }
148
149 //
150 // Memory Mapped Files, Shared Memory Objects, or Memory Protection (MC2)
151 //
152 /*
153 PROT_READ
154 PROT_WRITE
155 PROT_EXEC
156 PROT_NONE
157 */
158
version(CRuntime_Glibc)159 version (CRuntime_Glibc)
160 {
161 enum PROT_NONE = 0x0;
162 enum PROT_READ = 0x1;
163 enum PROT_WRITE = 0x2;
164 enum PROT_EXEC = 0x4;
165 }
version(Darwin)166 else version (Darwin)
167 {
168 enum PROT_NONE = 0x00;
169 enum PROT_READ = 0x01;
170 enum PROT_WRITE = 0x02;
171 enum PROT_EXEC = 0x04;
172 }
version(FreeBSD)173 else version (FreeBSD)
174 {
175 enum PROT_NONE = 0x00;
176 enum PROT_READ = 0x01;
177 enum PROT_WRITE = 0x02;
178 enum PROT_EXEC = 0x04;
179 }
version(NetBSD)180 else version (NetBSD)
181 {
182 enum PROT_NONE = 0x00;
183 enum PROT_READ = 0x01;
184 enum PROT_WRITE = 0x02;
185 enum PROT_EXEC = 0x04;
186 }
version(DragonFlyBSD)187 else version (DragonFlyBSD)
188 {
189 enum PROT_NONE = 0x00;
190 enum PROT_READ = 0x01;
191 enum PROT_WRITE = 0x02;
192 enum PROT_EXEC = 0x04;
193 }
version(Solaris)194 else version (Solaris)
195 {
196 enum PROT_NONE = 0x00;
197 enum PROT_READ = 0x01;
198 enum PROT_WRITE = 0x02;
199 enum PROT_EXEC = 0x04;
200 }
version(CRuntime_Bionic)201 else version (CRuntime_Bionic)
202 {
203 enum PROT_NONE = 0x00;
204 enum PROT_READ = 0x01;
205 enum PROT_WRITE = 0x02;
206 enum PROT_EXEC = 0x04;
207 }
version(CRuntime_Musl)208 else version (CRuntime_Musl)
209 {
210 enum PROT_NONE = 0x0;
211 enum PROT_READ = 0x1;
212 enum PROT_WRITE = 0x2;
213 enum PROT_EXEC = 0x4;
214 }
version(CRuntime_UClibc)215 else version (CRuntime_UClibc)
216 {
217 enum PROT_NONE = 0x0;
218 enum PROT_READ = 0x1;
219 enum PROT_WRITE = 0x2;
220 enum PROT_EXEC = 0x4;
221 }
222 else
223 {
224 static assert(false, "Unsupported platform");
225 }
226
227 //
228 // Memory Mapped Files, Shared Memory Objects, or Typed Memory Objects (MC3)
229 //
230 /*
231 void* mmap(void*, size_t, int, int, int, off_t);
232 int munmap(void*, size_t);
233 */
234
version(CRuntime_Glibc)235 version (CRuntime_Glibc)
236 {
237 static if (__USE_LARGEFILE64) void* mmap64(void*, size_t, int, int, int, off_t);
238 static if (__USE_FILE_OFFSET64)
239 alias mmap = mmap64;
240 else
241 void* mmap(void*, size_t, int, int, int, off_t);
242 int munmap(void*, size_t);
243 }
version(Darwin)244 else version (Darwin)
245 {
246 void* mmap(void*, size_t, int, int, int, off_t);
247 int munmap(void*, size_t);
248 }
version(FreeBSD)249 else version (FreeBSD)
250 {
251 void* mmap(void*, size_t, int, int, int, off_t);
252 int munmap(void*, size_t);
253 }
version(NetBSD)254 else version (NetBSD)
255 {
256 void* mmap(void*, size_t, int, int, int, off_t);
257 int munmap(void*, size_t);
258 }
version(DragonFlyBSD)259 else version (DragonFlyBSD)
260 {
261 void* mmap(void*, size_t, int, int, int, off_t);
262 int munmap(void*, size_t);
263 }
version(Solaris)264 else version (Solaris)
265 {
266 void* mmap(void*, size_t, int, int, int, off_t);
267 int munmap(void*, size_t);
268 }
version(CRuntime_Bionic)269 else version (CRuntime_Bionic)
270 {
271 void* mmap(void*, size_t, int, int, int, off_t);
272 int munmap(void*, size_t);
273 }
version(CRuntime_Musl)274 else version (CRuntime_Musl)
275 {
276 static if (__USE_LARGEFILE64) void* mmap64(void*, size_t, int, int, int, off_t);
277 static if (__USE_FILE_OFFSET64)
278 alias mmap = mmap64;
279 else
280 void* mmap(void*, size_t, int, int, int, off_t);
281 int munmap(void*, size_t);
282 }
version(CRuntime_UClibc)283 else version (CRuntime_UClibc)
284 {
285 static if (__USE_LARGEFILE64) void* mmap64(void*, size_t, int, int, int, off64_t);
286 static if (__USE_FILE_OFFSET64)
287 alias mmap = mmap64;
288 else
289 void* mmap(void*, size_t, int, int, int, off_t);
290 int munmap(void*, size_t);
291 }
292 else
293 {
294 static assert(false, "Unsupported platform");
295 }
296
297 //
298 // Memory Mapped Files (MF)
299 //
300 /*
301 MAP_SHARED (MF|SHM)
302 MAP_PRIVATE (MF|SHM)
303 MAP_FIXED (MF|SHM)
304 MAP_FAILED (MF|SHM)
305
306 MS_ASYNC (MF|SIO)
307 MS_SYNC (MF|SIO)
308 MS_INVALIDATE (MF|SIO)
309
310 int msync(void*, size_t, int); (MF|SIO)
311 */
312
version(CRuntime_Glibc)313 version (CRuntime_Glibc)
314 {
315 enum MAP_SHARED = 0x01;
316 enum MAP_PRIVATE = 0x02;
317 enum MAP_FIXED = 0x10;
318
319 enum MAP_FAILED = cast(void*) -1;
320
321 version (MICROBLAZE)
322 private enum DEFAULTS = true;
323 else version (Alpha)
324 {
325 private enum DEFAULTS = false;
326 enum MAP_ANON = 0x10;
327 enum MS_ASYNC = 1;
328 enum MS_SYNC = 2;
329 enum MS_INVALIDATE = 4;
330 }
331 else version (SH)
332 private enum DEFAULTS = true;
333 else version (ARM_Any)
334 private enum DEFAULTS = true;
335 else version (IBMZ_Any)
336 private enum DEFAULTS = true;
337 else version (IA64)
338 private enum DEFAULTS = true;
339 else version (HPPA_Any)
340 {
341 private enum DEFAULTS = false;
342 enum MAP_ANON = 0x10;
343 enum MS_SYNC = 1;
344 enum MS_ASYNC = 2;
345 enum MS_INVALIDATE = 4;
346 }
347 else version (M68K)
348 private enum DEFAULTS = true;
349 else version (TILE)
350 private enum DEFAULTS = true;
351 else version (X86_Any)
352 private enum DEFAULTS = true;
353 else version (MIPS_Any)
354 {
355 private enum DEFAULTS = false;
356 enum MAP_ANON = 0x0800;
357 enum MS_ASYNC = 1;
358 enum MS_INVALIDATE = 2;
359 enum MS_SYNC = 4;
360 }
361 else version (RISCV_Any)
362 private enum DEFAULTS = true;
363 else version (SPARC_Any)
364 private enum DEFAULTS = true;
365 else version (PPC_Any)
366 private enum DEFAULTS = true;
367 else
368 static assert(0, "unimplemented");
369
370 static if (DEFAULTS)
371 {
372 enum MAP_ANON = 0x20;
373 enum MS_ASYNC = 1;
374 enum MS_INVALIDATE = 2;
375 enum MS_SYNC = 4;
376 }
377
378 int msync(void*, size_t, int);
379 }
version(Darwin)380 else version (Darwin)
381 {
382 enum MAP_SHARED = 0x0001;
383 enum MAP_PRIVATE = 0x0002;
384 enum MAP_FIXED = 0x0010;
385 enum MAP_ANON = 0x1000;
386
387 enum MAP_FAILED = cast(void*)-1;
388
389 enum MS_ASYNC = 0x0001;
390 enum MS_INVALIDATE = 0x0002;
391 enum MS_SYNC = 0x0010;
392
393 int msync(void*, size_t, int);
394 }
version(FreeBSD)395 else version (FreeBSD)
396 {
397 enum MAP_SHARED = 0x0001;
398 enum MAP_PRIVATE = 0x0002;
399 enum MAP_FIXED = 0x0010;
400 enum MAP_ANON = 0x1000;
401
402 enum MAP_FAILED = cast(void*)-1;
403
404 enum MS_SYNC = 0x0000;
405 enum MS_ASYNC = 0x0001;
406 enum MS_INVALIDATE = 0x0002;
407
408 int msync(void*, size_t, int);
409 }
version(NetBSD)410 else version (NetBSD)
411 {
412 enum MAP_SHARED = 0x0001;
413 enum MAP_PRIVATE = 0x0002;
414 enum MAP_FIXED = 0x0010;
415 enum MAP_ANON = 0x1000;
416
417 enum MAP_FAILED = cast(void*)-1;
418
419 enum MS_SYNC = 0x0004;
420 enum MS_ASYNC = 0x0001;
421 enum MS_INVALIDATE = 0x0002;
422
423 int __msync13(void*, size_t, int);
424 alias msync = __msync13;
425 }
version(DragonFlyBSD)426 else version (DragonFlyBSD)
427 {
428 enum MAP_SHARED = 0x0001;
429 enum MAP_PRIVATE = 0x0002;
430 enum MAP_FIXED = 0x0010;
431 enum MAP_ANON = 0x1000;
432
433 enum MAP_FAILED = cast(void*)-1;
434
435 enum MS_SYNC = 0x0000;
436 enum MS_ASYNC = 0x0001;
437 enum MS_INVALIDATE = 0x0002;
438
439 int msync(void*, size_t, int);
440 }
version(Solaris)441 else version (Solaris)
442 {
443 enum MAP_SHARED = 0x0001;
444 enum MAP_PRIVATE = 0x0002;
445 enum MAP_FIXED = 0x0010;
446 enum MAP_ANON = 0x0100;
447
448 enum MAP_FAILED = cast(void*)-1;
449
450 enum MS_SYNC = 0x0004;
451 enum MS_ASYNC = 0x0001;
452 enum MS_INVALIDATE = 0x0002;
453
454 int msync(void*, size_t, int);
455 }
version(CRuntime_Bionic)456 else version (CRuntime_Bionic)
457 {
458 enum MAP_SHARED = 0x0001;
459 enum MAP_PRIVATE = 0x0002;
460 enum MAP_FIXED = 0x0010;
461 enum MAP_ANON = 0x0020;
462
463 enum MAP_FAILED = cast(void*)-1;
464
465 enum MS_SYNC = 4;
466 enum MS_ASYNC = 1;
467 enum MS_INVALIDATE = 2;
468
469 int msync(in void*, size_t, int);
470 }
version(CRuntime_Musl)471 else version (CRuntime_Musl)
472 {
473 enum MAP_SHARED = 0x01;
474 enum MAP_PRIVATE = 0x02;
475 enum MAP_FIXED = 0x10;
476
477 enum MAP_FAILED = cast(void*) -1;
478 enum MAP_ANON = 0x20;
479 enum MS_ASYNC = 1;
480 enum MS_INVALIDATE = 2;
481 enum MS_SYNC = 4;
482 int msync(void*, size_t, int);
483 }
version(CRuntime_UClibc)484 else version (CRuntime_UClibc)
485 {
486 enum MAP_SHARED = 0x01;
487 enum MAP_PRIVATE = 0x02;
488 enum MAP_FIXED = 0x10;
489
490 enum MAP_FAILED = cast(void*) -1;
491
492 version (X86_64)
493 {
494 enum MAP_ANON = 0x20;
495 enum MS_ASYNC = 1;
496 enum MS_INVALIDATE = 2;
497 enum MS_SYNC = 4;
498 }
499 else version (MIPS32)
500 {
501 enum MAP_ANON = 0x0800;
502 enum MS_ASYNC = 1;
503 enum MS_INVALIDATE = 2;
504 enum MS_SYNC = 4;
505 }
506 else version (ARM)
507 {
508 enum MAP_ANON = 0x020;
509 enum MS_ASYNC = 1;
510 enum MS_INVALIDATE = 2;
511 enum MS_SYNC = 4;
512 }
513 else
514 {
515 static assert(false, "Architecture not supported.");
516 }
517
518
519 int msync(void*, size_t, int);
520 }
521 else
522 {
523 static assert(false, "Unsupported platform");
524 }
525
526 //
527 // Process Memory Locking (ML)
528 //
529 /*
530 MCL_CURRENT
531 MCL_FUTURE
532
533 int mlockall(int);
534 int munlockall();
535 */
536
version(CRuntime_Glibc)537 version (CRuntime_Glibc)
538 {
539 version (SPARC_Any) enum
540 {
541 MCL_CURRENT = 0x2000,
542 MCL_FUTURE = 0x4000,
543 }
544 else version (PPC_Any) enum
545 {
546 MCL_CURRENT = 0x2000,
547 MCL_FUTURE = 0x4000,
548 }
549 else version (Alpha) enum
550 {
551 MCL_CURRENT = 8192,
552 MCL_FUTURE = 16384,
553 }
554 else enum
555 {
556 MCL_CURRENT = 1,
557 MCL_FUTURE = 2,
558 }
559
560 int mlockall(int);
561 int munlockall();
562
563 }
version(Darwin)564 else version (Darwin)
565 {
566 enum MCL_CURRENT = 0x0001;
567 enum MCL_FUTURE = 0x0002;
568
569 int mlockall(int);
570 int munlockall();
571 }
version(FreeBSD)572 else version (FreeBSD)
573 {
574 enum MCL_CURRENT = 0x0001;
575 enum MCL_FUTURE = 0x0002;
576
577 int mlockall(int);
578 int munlockall();
579 }
version(NetBSD)580 else version (NetBSD)
581 {
582 enum MCL_CURRENT = 0x0001;
583 enum MCL_FUTURE = 0x0002;
584
585 int mlockall(int);
586 int munlockall();
587 }
version(DragonFlyBSD)588 else version (DragonFlyBSD)
589 {
590 enum MCL_CURRENT = 0x0001;
591 enum MCL_FUTURE = 0x0002;
592
593 int mlockall(int);
594 int munlockall();
595 }
version(Solaris)596 else version (Solaris)
597 {
598 enum MCL_CURRENT = 0x0001;
599 enum MCL_FUTURE = 0x0002;
600
601 int mlockall(int);
602 int munlockall();
603 }
version(CRuntime_Bionic)604 else version (CRuntime_Bionic)
605 {
606 enum MCL_CURRENT = 1;
607 enum MCL_FUTURE = 2;
608
609 int mlockall(int);
610 int munlockall();
611 }
version(CRuntime_Musl)612 else version (CRuntime_Musl)
613 {
614 }
version(CRuntime_UClibc)615 else version (CRuntime_UClibc)
616 {
617 enum
618 {
619 MCL_CURRENT = 1,
620 MCL_FUTURE = 2,
621 }
622
623 int mlockall(int);
624 int munlockall();
625
626 }
627 else
628 {
629 static assert(false, "Unsupported platform");
630 }
631
632 //
633 // Range Memory Locking (MLR)
634 //
635 /*
636 int mlock(in void*, size_t);
637 int munlock(in void*, size_t);
638 */
639
version(CRuntime_Glibc)640 version (CRuntime_Glibc)
641 {
642 int mlock(in void*, size_t);
643 int munlock(in void*, size_t);
644 }
version(Darwin)645 else version (Darwin)
646 {
647 int mlock(in void*, size_t);
648 int munlock(in void*, size_t);
649 }
version(FreeBSD)650 else version (FreeBSD)
651 {
652 int mlock(in void*, size_t);
653 int munlock(in void*, size_t);
654 }
version(NetBSD)655 else version (NetBSD)
656 {
657 int mlock(in void*, size_t);
658 int munlock(in void*, size_t);
659 }
version(DragonFlyBSD)660 else version (DragonFlyBSD)
661 {
662 int mlock(in void*, size_t);
663 int munlock(in void*, size_t);
664 }
version(Solaris)665 else version (Solaris)
666 {
667 int mlock(in void*, size_t);
668 int munlock(in void*, size_t);
669 }
version(CRuntime_Bionic)670 else version (CRuntime_Bionic)
671 {
672 int mlock(in void*, size_t);
673 int munlock(in void*, size_t);
674 }
version(CRuntime_Musl)675 else version (CRuntime_Musl)
676 {
677 }
version(CRuntime_UClibc)678 else version (CRuntime_UClibc)
679 {
680 int mlock(in void*, size_t);
681 int munlock(in void*, size_t);
682 }
683 else
684 {
685 static assert(false, "Unsupported platform");
686 }
687
688 //
689 // Memory Protection (MPR)
690 //
691 /*
692 int mprotect(void*, size_t, int);
693 */
694
version(CRuntime_Glibc)695 version (CRuntime_Glibc)
696 {
697 int mprotect(void*, size_t, int);
698 }
version(Darwin)699 else version (Darwin)
700 {
701 int mprotect(void*, size_t, int);
702 }
version(FreeBSD)703 else version (FreeBSD)
704 {
705 int mprotect(void*, size_t, int);
706 }
version(NetBSD)707 else version (NetBSD)
708 {
709 int mprotect(void*, size_t, int);
710 }
version(DragonFlyBSD)711 else version (DragonFlyBSD)
712 {
713 int mprotect(void*, size_t, int);
714 }
version(Solaris)715 else version (Solaris)
716 {
717 int mprotect(void*, size_t, int);
718 }
version(CRuntime_Bionic)719 else version (CRuntime_Bionic)
720 {
721 int mprotect(in void*, size_t, int);
722 }
version(CRuntime_Musl)723 else version (CRuntime_Musl)
724 {
725 int mprotect(void*, size_t, int);
726 }
version(CRuntime_UClibc)727 else version (CRuntime_UClibc)
728 {
729 int mprotect(void*, size_t, int);
730 }
731 else
732 {
733 static assert(false, "Unsupported platform");
734 }
735
736 //
737 // Shared Memory Objects (SHM)
738 //
739 /*
740 int shm_open(in char*, int, mode_t);
741 int shm_unlink(in char*);
742 */
743
version(CRuntime_Glibc)744 version (CRuntime_Glibc)
745 {
746 int shm_open(in char*, int, mode_t);
747 int shm_unlink(in char*);
748 }
version(Darwin)749 else version (Darwin)
750 {
751 int shm_open(in char*, int, mode_t);
752 int shm_unlink(in char*);
753 }
version(FreeBSD)754 else version (FreeBSD)
755 {
756 int shm_open(in char*, int, mode_t);
757 int shm_unlink(in char*);
758 }
version(NetBSD)759 else version (NetBSD)
760 {
761 int shm_open(in char*, int, mode_t);
762 int shm_unlink(in char*);
763 }
version(DragonFlyBSD)764 else version (DragonFlyBSD)
765 {
766 int shm_open(in char*, int, mode_t);
767 int shm_unlink(in char*);
768 }
version(Solaris)769 else version (Solaris)
770 {
771 int shm_open(in char*, int, mode_t);
772 int shm_unlink(in char*);
773 }
version(CRuntime_Bionic)774 else version (CRuntime_Bionic)
775 {
776 }
version(CRuntime_Musl)777 else version (CRuntime_Musl)
778 {
779 }
version(CRuntime_UClibc)780 else version (CRuntime_UClibc)
781 {
782 int shm_open(in char*, int, mode_t);
783 int shm_unlink(in char*);
784 }
785 else
786 {
787 static assert(false, "Unsupported platform");
788 }
789
790 //
791 // Typed Memory Objects (TYM)
792 //
793 /*
794 POSIX_TYPED_MEM_ALLOCATE
795 POSIX_TYPED_MEM_ALLOCATE_CONTIG
796 POSIX_TYPED_MEM_MAP_ALLOCATABLE
797
798 struct posix_typed_mem_info
799 {
800 size_t posix_tmi_length;
801 }
802
803 int posix_mem_offset(in void*, size_t, off_t *, size_t *, int *);
804 int posix_typed_mem_get_info(int, struct posix_typed_mem_info *);
805 int posix_typed_mem_open(in char*, int, int);
806 */
807