/src/core/sys/posix/sys/mman.d

http://github.com/AlexeyProkhin/druntime · D · 412 lines · 264 code · 40 blank · 108 comment · 25 complexity · c42a1cd2b191fcf56a0de845d322d02b MD5 · raw file

  1. /**
  2. * D header file for POSIX.
  3. *
  4. * Copyright: Copyright Sean Kelly 2005 - 2009.
  5. * License: <a href="http://www.boost.org/LICENSE_1_0.txt">Boost License 1.0</a>.
  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. /* Copyright Sean Kelly 2005 - 2009.
  10. * Distributed under the Boost Software License, Version 1.0.
  11. * (See accompanying file LICENSE or copy at
  12. * http://www.boost.org/LICENSE_1_0.txt)
  13. */
  14. module core.sys.posix.sys.mman;
  15. private import core.sys.posix.config;
  16. public import core.stdc.stddef; // for size_t
  17. public import core.sys.posix.sys.types; // for off_t, mode_t
  18. version (Posix):
  19. extern (C):
  20. //
  21. // Advisory Information (ADV)
  22. //
  23. /*
  24. int posix_madvise(void*, size_t, int);
  25. */
  26. //
  27. // Advisory Information and either Memory Mapped Files or Shared Memory Objects (MC1)
  28. //
  29. /*
  30. POSIX_MADV_NORMAL
  31. POSIX_MADV_SEQUENTIAL
  32. POSIX_MADV_RANDOM
  33. POSIX_MADV_WILLNEED
  34. POSIX_MADV_DONTNEED
  35. */
  36. version( linux )
  37. {
  38. enum POSIX_MADV_NORMAL = 0;
  39. enum POSIX_MADV_RANDOM = 1;
  40. enum POSIX_MADV_SEQUENTIAL = 2;
  41. enum POSIX_MADV_WILLNEED = 3;
  42. enum POSIX_MADV_DONTNEED = 4;
  43. }
  44. else version( OSX )
  45. {
  46. enum POSIX_MADV_NORMAL = 0;
  47. enum POSIX_MADV_RANDOM = 1;
  48. enum POSIX_MADV_SEQUENTIAL = 2;
  49. enum POSIX_MADV_WILLNEED = 3;
  50. enum POSIX_MADV_DONTNEED = 4;
  51. }
  52. else version( FreeBSD )
  53. {
  54. enum POSIX_MADV_NORMAL = 0;
  55. enum POSIX_MADV_RANDOM = 1;
  56. enum POSIX_MADV_SEQUENTIAL = 2;
  57. enum POSIX_MADV_WILLNEED = 3;
  58. enum POSIX_MADV_DONTNEED = 4;
  59. }
  60. else version (Solaris)
  61. {
  62. enum POSIX_MADV_NORMAL = 0;
  63. enum POSIX_MADV_RANDOM = 1;
  64. enum POSIX_MADV_SEQUENTIAL = 2;
  65. enum POSIX_MADV_WILLNEED = 3;
  66. enum POSIX_MADV_DONTNEED = 4;
  67. }
  68. else
  69. {
  70. static assert(false, "Unsupported platform");
  71. }
  72. //
  73. // Memory Mapped Files, Shared Memory Objects, or Memory Protection (MC2)
  74. //
  75. /*
  76. PROT_READ
  77. PROT_WRITE
  78. PROT_EXEC
  79. PROT_NONE
  80. */
  81. version( linux )
  82. {
  83. enum PROT_NONE = 0x0;
  84. enum PROT_READ = 0x1;
  85. enum PROT_WRITE = 0x2;
  86. enum PROT_EXEC = 0x4;
  87. }
  88. else version( OSX )
  89. {
  90. enum PROT_NONE = 0x00;
  91. enum PROT_READ = 0x01;
  92. enum PROT_WRITE = 0x02;
  93. enum PROT_EXEC = 0x04;
  94. }
  95. else version( FreeBSD )
  96. {
  97. enum PROT_NONE = 0x00;
  98. enum PROT_READ = 0x01;
  99. enum PROT_WRITE = 0x02;
  100. enum PROT_EXEC = 0x04;
  101. }
  102. else version (Solaris)
  103. {
  104. enum PROT_NONE = 0x00;
  105. enum PROT_READ = 0x01;
  106. enum PROT_WRITE = 0x02;
  107. enum PROT_EXEC = 0x04;
  108. }
  109. else
  110. {
  111. static assert(false, "Unsupported platform");
  112. }
  113. //
  114. // Memory Mapped Files, Shared Memory Objects, or Typed Memory Objects (MC3)
  115. //
  116. /*
  117. void* mmap(void*, size_t, int, int, int, off_t);
  118. int munmap(void*, size_t);
  119. */
  120. version( linux )
  121. {
  122. //void* mmap(void*, size_t, int, int, int, off_t);
  123. int munmap(void*, size_t);
  124. static if( __USE_FILE_OFFSET64 )
  125. {
  126. void* mmap64(void*, size_t, int, int, int, off_t);
  127. alias mmap64 mmap;
  128. }
  129. else
  130. {
  131. void* mmap(void*, size_t, int, int, int, off_t);
  132. }
  133. }
  134. else version( OSX )
  135. {
  136. void* mmap(void*, size_t, int, int, int, off_t);
  137. int munmap(void*, size_t);
  138. }
  139. else version( FreeBSD )
  140. {
  141. void* mmap(void*, size_t, int, int, int, off_t);
  142. int munmap(void*, size_t);
  143. }
  144. else version (Solaris)
  145. {
  146. void* mmap(void*, size_t, int, int, int, off_t);
  147. int munmap(void*, size_t);
  148. }
  149. else
  150. {
  151. static assert(false, "Unsupported platform");
  152. }
  153. //
  154. // Memory Mapped Files (MF)
  155. //
  156. /*
  157. MAP_SHARED (MF|SHM)
  158. MAP_PRIVATE (MF|SHM)
  159. MAP_FIXED (MF|SHM)
  160. MAP_FAILED (MF|SHM)
  161. MS_ASYNC (MF|SIO)
  162. MS_SYNC (MF|SIO)
  163. MS_INVALIDATE (MF|SIO)
  164. int msync(void*, size_t, int); (MF|SIO)
  165. */
  166. version( linux )
  167. {
  168. enum MAP_SHARED = 0x01;
  169. enum MAP_PRIVATE = 0x02;
  170. enum MAP_FIXED = 0x10;
  171. version (MIPS)
  172. enum MAP_ANON = 0x0800; // non-standard
  173. else
  174. enum MAP_ANON = 0x20; // non-standard
  175. enum MAP_FAILED = cast(void*) -1;
  176. enum
  177. {
  178. MS_ASYNC = 1,
  179. MS_SYNC = 4,
  180. MS_INVALIDATE = 2
  181. }
  182. int msync(void*, size_t, int);
  183. }
  184. else version( OSX )
  185. {
  186. enum MAP_SHARED = 0x0001;
  187. enum MAP_PRIVATE = 0x0002;
  188. enum MAP_FIXED = 0x0010;
  189. enum MAP_ANON = 0x1000; // non-standard
  190. enum MAP_FAILED = cast(void*)-1;
  191. enum MS_ASYNC = 0x0001;
  192. enum MS_INVALIDATE = 0x0002;
  193. enum MS_SYNC = 0x0010;
  194. int msync(void*, size_t, int);
  195. }
  196. else version( FreeBSD )
  197. {
  198. enum MAP_SHARED = 0x0001;
  199. enum MAP_PRIVATE = 0x0002;
  200. enum MAP_FIXED = 0x0010;
  201. enum MAP_ANON = 0x1000; // non-standard
  202. enum MAP_FAILED = cast(void*)-1;
  203. enum MS_SYNC = 0x0000;
  204. enum MS_ASYNC = 0x0001;
  205. enum MS_INVALIDATE = 0x0002;
  206. int msync(void*, size_t, int);
  207. }
  208. else version (Solaris)
  209. {
  210. enum MAP_SHARED = 0x0001;
  211. enum MAP_PRIVATE = 0x0002;
  212. enum MAP_FIXED = 0x0010;
  213. enum MAP_ANON = 0x0100;
  214. enum MAP_FAILED = cast(void*)-1;
  215. enum MS_SYNC = 0x0004;
  216. enum MS_ASYNC = 0x0001;
  217. enum MS_INVALIDATE = 0x0002;
  218. int msync(void*, size_t, int);
  219. }
  220. else
  221. {
  222. static assert(false, "Unsupported platform");
  223. }
  224. //
  225. // Process Memory Locking (ML)
  226. //
  227. /*
  228. MCL_CURRENT
  229. MCL_FUTURE
  230. int mlockall(int);
  231. int munlockall();
  232. */
  233. version( linux )
  234. {
  235. enum MCL_CURRENT = 1;
  236. enum MCL_FUTURE = 2;
  237. int mlockall(int);
  238. int munlockall();
  239. }
  240. else version( OSX )
  241. {
  242. enum MCL_CURRENT = 0x0001;
  243. enum MCL_FUTURE = 0x0002;
  244. int mlockall(int);
  245. int munlockall();
  246. }
  247. else version( FreeBSD )
  248. {
  249. enum MCL_CURRENT = 0x0001;
  250. enum MCL_FUTURE = 0x0002;
  251. int mlockall(int);
  252. int munlockall();
  253. }
  254. else version (Solaris)
  255. {
  256. enum MCL_CURRENT = 0x0001;
  257. enum MCL_FUTURE = 0x0002;
  258. int mlockall(int);
  259. int munlockall();
  260. }
  261. else
  262. {
  263. static assert(false, "Unsupported platform");
  264. }
  265. //
  266. // Range Memory Locking (MLR)
  267. //
  268. /*
  269. int mlock(in void*, size_t);
  270. int munlock(in void*, size_t);
  271. */
  272. version( linux )
  273. {
  274. int mlock(in void*, size_t);
  275. int munlock(in void*, size_t);
  276. }
  277. else version( OSX )
  278. {
  279. int mlock(in void*, size_t);
  280. int munlock(in void*, size_t);
  281. }
  282. else version( FreeBSD )
  283. {
  284. int mlock(in void*, size_t);
  285. int munlock(in void*, size_t);
  286. }
  287. else version (Solaris)
  288. {
  289. int mlock(in void*, size_t);
  290. int munlock(in void*, size_t);
  291. }
  292. else
  293. {
  294. static assert(false, "Unsupported platform");
  295. }
  296. //
  297. // Memory Protection (MPR)
  298. //
  299. /*
  300. int mprotect(void*, size_t, int);
  301. */
  302. version (linux)
  303. {
  304. int mprotect(void*, size_t, int);
  305. }
  306. else version( OSX )
  307. {
  308. int mprotect(void*, size_t, int);
  309. }
  310. else version( FreeBSD )
  311. {
  312. int mprotect(void*, size_t, int);
  313. }
  314. else version (Solaris)
  315. {
  316. int mprotect(void*, size_t, int);
  317. }
  318. else
  319. {
  320. static assert(false, "Unsupported platform");
  321. }
  322. //
  323. // Shared Memory Objects (SHM)
  324. //
  325. /*
  326. int shm_open(in char*, int, mode_t);
  327. int shm_unlink(in char*);
  328. */
  329. version( linux )
  330. {
  331. int shm_open(in char*, int, mode_t);
  332. int shm_unlink(in char*);
  333. }
  334. else version( OSX )
  335. {
  336. int shm_open(in char*, int, mode_t);
  337. int shm_unlink(in char*);
  338. }
  339. else version( FreeBSD )
  340. {
  341. int shm_open(in char*, int, mode_t);
  342. int shm_unlink(in char*);
  343. }
  344. else version (Solaris)
  345. {
  346. int shm_open(in char*, int, mode_t);
  347. int shm_unlink(in char*);
  348. }
  349. else
  350. {
  351. static assert(false, "Unsupported platform");
  352. }
  353. //
  354. // Typed Memory Objects (TYM)
  355. //
  356. /*
  357. POSIX_TYPED_MEM_ALLOCATE
  358. POSIX_TYPED_MEM_ALLOCATE_CONTIG
  359. POSIX_TYPED_MEM_MAP_ALLOCATABLE
  360. struct posix_typed_mem_info
  361. {
  362. size_t posix_tmi_length;
  363. }
  364. int posix_mem_offset(in void*, size_t, off_t *, size_t *, int *);
  365. int posix_typed_mem_get_info(int, struct posix_typed_mem_info *);
  366. int posix_typed_mem_open(in char*, int, int);
  367. */