File size: 4,109 Bytes
0b5e147 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 |
// Copyright https://code.google.com/p/mman-win32/
//
// Licensed under the MIT License;
// You may obtain a copy of the License at
//
// https://opensource.org/licenses/MIT
#pragma once
#include "arrow/util/windows_compatibility.h"
#include <errno.h>
#include <io.h>
#include <sys/types.h>
#include <cstdint>
#define PROT_NONE 0
#define PROT_READ 1
#define PROT_WRITE 2
#define PROT_EXEC 4
#define MAP_FILE 0
#define MAP_SHARED 1
#define MAP_PRIVATE 2
#define MAP_TYPE 0xf
#define MAP_FIXED 0x10
#define MAP_ANONYMOUS 0x20
#define MAP_ANON MAP_ANONYMOUS
#define MAP_FAILED ((void*)-1)
/* Flags for msync. */
#define MS_ASYNC 1
#define MS_SYNC 2
#define MS_INVALIDATE 4
#ifndef FILE_MAP_EXECUTE
#define FILE_MAP_EXECUTE 0x0020
#endif
static inline int __map_mman_error(const DWORD err, const int deferr) {
if (err == 0) return 0;
// TODO: implement
return err;
}
static inline DWORD __map_mmap_prot_page(const int prot) {
DWORD protect = 0;
if (prot == PROT_NONE) return protect;
if ((prot & PROT_EXEC) != 0) {
protect = ((prot & PROT_WRITE) != 0) ? PAGE_EXECUTE_READWRITE : PAGE_EXECUTE_READ;
} else {
protect = ((prot & PROT_WRITE) != 0) ? PAGE_READWRITE : PAGE_READONLY;
}
return protect;
}
static inline DWORD __map_mmap_prot_file(const int prot) {
DWORD desiredAccess = 0;
if (prot == PROT_NONE) return desiredAccess;
if ((prot & PROT_READ) != 0) desiredAccess |= FILE_MAP_READ;
if ((prot & PROT_WRITE) != 0) desiredAccess |= FILE_MAP_WRITE;
if ((prot & PROT_EXEC) != 0) desiredAccess |= FILE_MAP_EXECUTE;
return desiredAccess;
}
static inline void* mmap(void* addr, size_t len, int prot, int flags, int fildes,
off_t off) {
HANDLE fm, h;
void* map = MAP_FAILED;
const uint64_t off64 = static_cast<uint64_t>(off);
const uint64_t maxSize = off64 + len;
const DWORD dwFileOffsetLow = static_cast<DWORD>(off64 & 0xFFFFFFFFUL);
const DWORD dwFileOffsetHigh = static_cast<DWORD>((off64 >> 32) & 0xFFFFFFFFUL);
const DWORD dwMaxSizeLow = static_cast<DWORD>(maxSize & 0xFFFFFFFFUL);
const DWORD dwMaxSizeHigh = static_cast<DWORD>((maxSize >> 32) & 0xFFFFFFFFUL);
const DWORD protect = __map_mmap_prot_page(prot);
const DWORD desiredAccess = __map_mmap_prot_file(prot);
errno = 0;
if (len == 0
/* Unsupported flag combinations */
|| (flags & MAP_FIXED) != 0
/* Unsupported protection combinations */
|| prot == PROT_EXEC) {
errno = EINVAL;
return MAP_FAILED;
}
h = ((flags & MAP_ANONYMOUS) == 0) ? (HANDLE)_get_osfhandle(fildes)
: INVALID_HANDLE_VALUE;
if ((flags & MAP_ANONYMOUS) == 0 && h == INVALID_HANDLE_VALUE) {
errno = EBADF;
return MAP_FAILED;
}
fm = CreateFileMapping(h, NULL, protect, dwMaxSizeHigh, dwMaxSizeLow, NULL);
if (fm == NULL) {
errno = __map_mman_error(GetLastError(), EPERM);
return MAP_FAILED;
}
map = MapViewOfFile(fm, desiredAccess, dwFileOffsetHigh, dwFileOffsetLow, len);
CloseHandle(fm);
if (map == NULL) {
errno = __map_mman_error(GetLastError(), EPERM);
return MAP_FAILED;
}
return map;
}
static inline int munmap(void* addr, size_t len) {
if (UnmapViewOfFile(addr)) return 0;
errno = __map_mman_error(GetLastError(), EPERM);
return -1;
}
static inline int mprotect(void* addr, size_t len, int prot) {
DWORD newProtect = __map_mmap_prot_page(prot);
DWORD oldProtect = 0;
if (VirtualProtect(addr, len, newProtect, &oldProtect)) return 0;
errno = __map_mman_error(GetLastError(), EPERM);
return -1;
}
static inline int msync(void* addr, size_t len, int flags) {
if (FlushViewOfFile(addr, len)) return 0;
errno = __map_mman_error(GetLastError(), EPERM);
return -1;
}
static inline int mlock(const void* addr, size_t len) {
if (VirtualLock((LPVOID)addr, len)) return 0;
errno = __map_mman_error(GetLastError(), EPERM);
return -1;
}
static inline int munlock(const void* addr, size_t len) {
if (VirtualUnlock((LPVOID)addr, len)) return 0;
errno = __map_mman_error(GetLastError(), EPERM);
return -1;
}
|