1 /* 2 * This code is derived from uClibc (original license follows). 3 * https://git.uclibc.org/uClibc/tree/utils/mmap-windows.c 4 */ 5 /* mmap() replacement for Windows 6 * 7 * Author: Mike Frysinger <vapier@gentoo.org> 8 * Placed into the public domain 9 */ 10 11 /* References: 12 * CreateFileMapping: http://msdn.microsoft.com/en-us/library/aa366537(VS.85).aspx 13 * CloseHandle: http://msdn.microsoft.com/en-us/library/ms724211(VS.85).aspx 14 * MapViewOfFile: http://msdn.microsoft.com/en-us/library/aa366761(VS.85).aspx 15 * UnmapViewOfFile: http://msdn.microsoft.com/en-us/library/aa366882(VS.85).aspx 16 */ 17 18 #if defined(_WIN32) 19 20 #include "WindowsMMap.h" 21 22 #define WIN32_LEAN_AND_MEAN 23 #include <windows.h> 24 25 #include "InstrProfiling.h" 26 27 COMPILER_RT_VISIBILITY 28 void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset) 29 { 30 if (prot & ~(PROT_READ | PROT_WRITE | PROT_EXEC)) 31 return MAP_FAILED; 32 if (fd == -1) { 33 if (!(flags & MAP_ANON) || offset) 34 return MAP_FAILED; 35 } else if (flags & MAP_ANON) 36 return MAP_FAILED; 37 38 DWORD flProtect; 39 if (prot & PROT_WRITE) { 40 if (prot & PROT_EXEC) 41 flProtect = PAGE_EXECUTE_READWRITE; 42 else 43 flProtect = PAGE_READWRITE; 44 } else if (prot & PROT_EXEC) { 45 if (prot & PROT_READ) 46 flProtect = PAGE_EXECUTE_READ; 47 else if (prot & PROT_EXEC) 48 flProtect = PAGE_EXECUTE; 49 } else 50 flProtect = PAGE_READONLY; 51 52 off_t end = length + offset; 53 HANDLE mmap_fd, h; 54 if (fd == -1) 55 mmap_fd = INVALID_HANDLE_VALUE; 56 else 57 mmap_fd = (HANDLE)_get_osfhandle(fd); 58 h = CreateFileMapping(mmap_fd, NULL, flProtect, DWORD_HI(end), DWORD_LO(end), NULL); 59 if (h == NULL) 60 return MAP_FAILED; 61 62 DWORD dwDesiredAccess; 63 if (prot & PROT_WRITE) 64 dwDesiredAccess = FILE_MAP_WRITE; 65 else 66 dwDesiredAccess = FILE_MAP_READ; 67 if (prot & PROT_EXEC) 68 dwDesiredAccess |= FILE_MAP_EXECUTE; 69 if (flags & MAP_PRIVATE) 70 dwDesiredAccess |= FILE_MAP_COPY; 71 void *ret = MapViewOfFile(h, dwDesiredAccess, DWORD_HI(offset), DWORD_LO(offset), length); 72 if (ret == NULL) { 73 CloseHandle(h); 74 ret = MAP_FAILED; 75 } 76 return ret; 77 } 78 79 COMPILER_RT_VISIBILITY 80 void munmap(void *addr, size_t length) 81 { 82 UnmapViewOfFile(addr); 83 /* ruh-ro, we leaked handle from CreateFileMapping() ... */ 84 } 85 86 COMPILER_RT_VISIBILITY 87 int msync(void *addr, size_t length, int flags) 88 { 89 if (flags & MS_INVALIDATE) 90 return -1; /* Not supported. */ 91 92 /* Exactly one of MS_ASYNC or MS_SYNC must be specified. */ 93 switch (flags & (MS_ASYNC | MS_SYNC)) { 94 case MS_SYNC: 95 case MS_ASYNC: 96 break; 97 default: 98 return -1; 99 } 100 101 if (!FlushViewOfFile(addr, length)) 102 return -1; 103 104 if (flags & MS_SYNC) { 105 /* FIXME: No longer have access to handle from CreateFileMapping(). */ 106 /* 107 * if (!FlushFileBuffers(h)) 108 * return -1; 109 */ 110 } 111 112 return 0; 113 } 114 115 COMPILER_RT_VISIBILITY 116 int madvise(void *addr, size_t length, int advice) 117 { 118 if (advice != MADV_DONTNEED) 119 return -1; /* Not supported. */ 120 121 if (!VirtualUnlock(addr, length)) 122 return -1; 123 124 return 0; 125 } 126 127 COMPILER_RT_VISIBILITY 128 int lock(HANDLE handle, DWORD lockType, BOOL blocking) { 129 DWORD flags = lockType; 130 if (!blocking) 131 flags |= LOCKFILE_FAIL_IMMEDIATELY; 132 133 OVERLAPPED overlapped; 134 ZeroMemory(&overlapped, sizeof(OVERLAPPED)); 135 overlapped.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); 136 BOOL result = LockFileEx(handle, flags, 0, MAXDWORD, MAXDWORD, &overlapped); 137 if (!result) { 138 DWORD dw = GetLastError(); 139 140 // In non-blocking mode, return an error if the file is locked. 141 if (!blocking && dw == ERROR_LOCK_VIOLATION) 142 return -1; // EWOULDBLOCK 143 144 // If the error is ERROR_IO_PENDING, we need to wait until the operation 145 // finishes. Otherwise, we return an error. 146 if (dw != ERROR_IO_PENDING) 147 return -1; 148 149 DWORD dwNumBytes; 150 if (!GetOverlappedResult(handle, &overlapped, &dwNumBytes, TRUE)) 151 return -1; 152 } 153 154 return 0; 155 } 156 157 COMPILER_RT_VISIBILITY 158 int flock(int fd, int operation) { 159 HANDLE handle = (HANDLE)_get_osfhandle(fd); 160 if (handle == INVALID_HANDLE_VALUE) 161 return -1; 162 163 BOOL blocking = (operation & LOCK_NB) == 0; 164 int op = operation & ~LOCK_NB; 165 166 switch (op) { 167 case LOCK_EX: 168 return lock(handle, LOCKFILE_EXCLUSIVE_LOCK, blocking); 169 170 case LOCK_SH: 171 return lock(handle, 0, blocking); 172 173 case LOCK_UN: 174 if (!UnlockFile(handle, 0, 0, MAXDWORD, MAXDWORD)) 175 return -1; 176 break; 177 178 default: 179 return -1; 180 } 181 182 return 0; 183 } 184 185 #undef DWORD_HI 186 #undef DWORD_LO 187 188 #endif /* _WIN32 */ 189