tap-driver.sh: flush stdout after each test result
[babeltrace.git] / compat / compat_mman.c
1 /*
2 * compat/compat_mman.h
3 *
4 * Copyright (C) 2013 JP Ikaheimonen <jp_ikaheimonen@mentor.com>
5 * 2016 Michael Jeanson <mjeanson@efficios.com>
6 *
7 * These sources are based on ftp://g.oswego.edu/pub/misc/malloc.c
8 * file by Doug Lea, released to the public domain.
9 *
10 * Permission is hereby granted, free of charge, to any person obtaining a copy
11 * of this software and associated documentation files (the "Software"), to deal
12 * in the Software without restriction, including without limitation the rights
13 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
14 * copies of the Software, and to permit persons to whom the Software is
15 * furnished to do so, subject to the following conditions:
16 *
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
19 *
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
23 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
26 * SOFTWARE.
27 */
28
29 #define BT_LOG_TAG "COMPAT-MMAN"
30 #include "logging.h"
31
32 #ifdef __APPLE__
33 /*
34 * On macOS, we need a dummy symbol so that the linker won't
35 * complain of an empty table of contents.
36 */
37 BT_HIDDEN
38 int bt_mman_dummy_symbol;
39 #endif /* __APPLE__ */
40
41 #ifdef __MINGW32__
42
43 #include <errno.h>
44 #include <io.h>
45 #include <pthread.h>
46 #include <stdlib.h>
47 #include <windows.h>
48 #include <babeltrace2/compat/mman-internal.h>
49
50 struct mmap_mapping {
51 /* The duplicated handle. */
52 HANDLE file_handle;
53 /* Handle returned by CreateFileMapping. */
54 HANDLE map_handle;
55 };
56
57 static
58 GHashTable *mmap_mappings = NULL;
59
60 /*
61 * This mutex protects the hashtable of memory mappings.
62 */
63 static pthread_mutex_t mmap_mutex = PTHREAD_MUTEX_INITIALIZER;
64
65 static
66 struct mmap_mapping *mapping_create(void)
67 {
68 struct mmap_mapping *mapping;
69
70 mapping = malloc(sizeof(struct mmap_mapping));
71 if (mapping != NULL) {
72 mapping->file_handle = NULL;
73 mapping->map_handle = NULL;
74 }
75
76 return mapping;
77 }
78
79 static
80 void mapping_clean(struct mmap_mapping *mapping)
81 {
82 if (mapping) {
83 if (!CloseHandle(mapping->map_handle)) {
84 BT_LOGF_STR("Failed to close mmap map_handle.");
85 abort();
86 }
87 if (!CloseHandle(mapping->file_handle)) {
88 BT_LOGF_STR("Failed to close mmap file_handle.");
89 abort();
90 }
91 free(mapping);
92 mapping = NULL;
93 }
94 }
95
96 static
97 void addr_clean(void *addr)
98 {
99 /* Cleanup of handles should never fail. */
100 if (!UnmapViewOfFile(addr)) {
101 BT_LOGF_STR("Failed to unmap mmap mapping.");
102 abort();
103 }
104 }
105
106 static
107 void mmap_lock(void)
108 {
109 if (pthread_mutex_lock(&mmap_mutex)) {
110 BT_LOGF_STR("Failed to acquire mmap_mutex.");
111 abort();
112 }
113 }
114
115 static
116 void mmap_unlock(void)
117 {
118 if (pthread_mutex_unlock(&mmap_mutex)) {
119 BT_LOGF_STR("Failed to release mmap_mutex.");
120 abort();
121 }
122 }
123
124 /*
125 * Convert mmap memory protection flags to CreateFileMapping page protection
126 * flag and MapViewOfFile desired access flag.
127 */
128 static
129 DWORD map_prot_flags(int prot, DWORD *dwDesiredAccess)
130 {
131 if (prot & PROT_READ) {
132 if (prot & PROT_WRITE) {
133 *dwDesiredAccess = FILE_MAP_WRITE;
134 if (prot & PROT_EXEC) {
135 return PAGE_EXECUTE_READWRITE;
136 }
137 return PAGE_READWRITE;
138 }
139 if (prot & PROT_EXEC) {
140 *dwDesiredAccess = FILE_MAP_EXECUTE;
141 return PAGE_EXECUTE_READ;
142 }
143 *dwDesiredAccess = FILE_MAP_READ;
144 return PAGE_READONLY;
145 }
146 if (prot & PROT_WRITE) {
147 *dwDesiredAccess = FILE_MAP_COPY;
148 return PAGE_WRITECOPY;
149 }
150 if (prot & PROT_EXEC) {
151 *dwDesiredAccess = FILE_MAP_EXECUTE;
152 return PAGE_EXECUTE_READ;
153 }
154
155 /* Mapping failed. */
156 *dwDesiredAccess = 0;
157 return 0;
158 }
159
160 BT_HIDDEN
161 void *bt_mmap(void *addr, size_t length, int prot, int flags, int fd,
162 off_t offset)
163 {
164 struct mmap_mapping *mapping = NULL;
165 void *mapping_addr;
166 DWORD dwDesiredAccess;
167 DWORD flProtect;
168 HANDLE handle;
169
170 /* Check for a valid fd. */
171 if (fd == -1) {
172 _set_errno(EBADF);
173 goto error;
174 }
175
176 /* We don't support this at the moment. */
177 if (flags == MAP_FIXED) {
178 _set_errno(ENOTSUP);
179 goto error;
180 }
181
182 /* Map mmap flags to those of the Windows API. */
183 flProtect = map_prot_flags(prot, &dwDesiredAccess);
184 if (flProtect == 0) {
185 _set_errno(EINVAL);
186 goto error;
187 }
188
189 /* Allocate the mapping struct. */
190 mapping = mapping_create();
191 if (!mapping) {
192 BT_LOGE_STR("Failed to allocate mmap mapping.");
193 _set_errno(ENOMEM);
194 goto error;
195 }
196
197 /* Get a handle from the fd. */
198 handle = (HANDLE) _get_osfhandle(fd);
199
200 /* Duplicate the handle and store it in 'mapping.file_handle'. */
201 if (!DuplicateHandle(GetCurrentProcess(), handle, GetCurrentProcess(),
202 &mapping->file_handle, 0, FALSE,
203 DUPLICATE_SAME_ACCESS)) {
204 _set_errno(ENOMEM);
205 goto error;
206 }
207
208 /*
209 * Create a file mapping object with a maximum size
210 * of 'offset' + 'length'.
211 */
212 mapping->map_handle = CreateFileMapping(mapping->file_handle, NULL,
213 flProtect, 0, offset + length, NULL);
214 if (mapping->map_handle == 0) {
215 _set_errno(EACCES);
216 goto error;
217 }
218
219 /* Map the requested block starting at 'offset' for 'length' bytes. */
220 mapping_addr = MapViewOfFile(mapping->map_handle, dwDesiredAccess, 0,
221 offset, length);
222 if (mapping_addr == 0) {
223 DWORD dwLastErr = GetLastError();
224 if (dwLastErr == ERROR_MAPPED_ALIGNMENT) {
225 _set_errno(EINVAL);
226 } else {
227 _set_errno(EACCES);
228 }
229 goto error;
230 }
231
232 mmap_lock();
233
234 /* If we have never done any mappings, allocate the hashtable. */
235 if (!mmap_mappings) {
236 mmap_mappings = g_hash_table_new_full(g_direct_hash,
237 g_direct_equal, (GDestroyNotify) addr_clean,
238 (GDestroyNotify) mapping_clean);
239 if (!mmap_mappings) {
240 BT_LOGE_STR("Failed to allocate mmap hashtable.");
241 _set_errno(ENOMEM);
242 goto error_mutex_unlock;
243 }
244 }
245
246 /* Add the new mapping to the hashtable. */
247 g_hash_table_insert(mmap_mappings, mapping_addr, mapping);
248
249 mmap_unlock();
250
251 return mapping_addr;
252
253 error_mutex_unlock:
254 mmap_unlock();
255 error:
256 mapping_clean(mapping);
257 return MAP_FAILED;
258 }
259
260 BT_HIDDEN
261 int bt_munmap(void *addr, size_t length)
262 {
263 int ret = 0;
264
265 mmap_lock();
266
267 /* Check if the mapping exists in the hashtable. */
268 if (g_hash_table_lookup(mmap_mappings, addr) == NULL) {
269 _set_errno(EINVAL);
270 ret = -1;
271 goto end;
272 }
273
274 /* Remove it. */
275 if (!g_hash_table_remove(mmap_mappings, addr)) {
276 BT_LOGF_STR("Failed to remove mapping from hashtable.");
277 abort();
278 }
279
280 end:
281 mmap_unlock();
282 return ret;
283 }
284
285 #endif
This page took 0.034404 seconds and 4 git commands to generate.