Fix: log_level usage on mingw platform
[babeltrace.git] / src / 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_OUTPUT_LEVEL (mapping->log_level)
30 #define BT_LOG_TAG "COMPAT/MMAN"
31 #include "logging/log.h"
32
33 #include "common/macros.h"
34
35 #ifdef __APPLE__
36 /*
37 * On macOS, we need a dummy symbol so that the linker won't
38 * complain of an empty table of contents.
39 */
40 BT_HIDDEN
41 int bt_mman_dummy_symbol;
42 #endif /* __APPLE__ */
43
44 #ifdef __MINGW32__
45
46 #include <errno.h>
47 #include <glib.h>
48 #include <io.h>
49 #include <pthread.h>
50 #include <stdlib.h>
51 #include <windows.h>
52
53 #include "compat/mman.h"
54
55 struct mmap_mapping {
56 int log_level;
57
58 /* The duplicated handle. */
59 HANDLE file_handle;
60 /* Handle returned by CreateFileMapping. */
61 HANDLE map_handle;
62 };
63
64 static
65 GHashTable *mmap_mappings = NULL;
66
67 /*
68 * This mutex protects the hashtable of memory mappings.
69 */
70 static pthread_mutex_t mmap_mutex = PTHREAD_MUTEX_INITIALIZER;
71
72 static
73 struct mmap_mapping *mapping_create(int log_level)
74 {
75 struct mmap_mapping *mapping;
76
77 mapping = malloc(sizeof(struct mmap_mapping));
78 if (mapping != NULL) {
79 mapping->file_handle = NULL;
80 mapping->map_handle = NULL;
81 mapping->log_level = log_level;
82 }
83
84 return mapping;
85 }
86
87 static
88 void mapping_clean(struct mmap_mapping *mapping)
89 {
90 if (mapping) {
91 if (!CloseHandle(mapping->map_handle)) {
92 BT_LOGF_STR("Failed to close mmap map_handle.");
93 abort();
94 }
95 if (!CloseHandle(mapping->file_handle)) {
96 BT_LOGF_STR("Failed to close mmap file_handle.");
97 abort();
98 }
99 free(mapping);
100 mapping = NULL;
101 }
102 }
103
104 static
105 void addr_clean(void *addr)
106 {
107 /* Cleanup of handles should never fail. */
108 if (!UnmapViewOfFile(addr)) {
109 /*
110 * FIXME: We don't have access to the mapping's log
111 * level here, so force a FATAL level.
112 */
113 BT_LOG_WRITE_CUR_LVL(BT_LOG_FATAL, BT_LOG_FATAL, BT_LOG_TAG,
114 "Failed to unmap mmap mapping.");
115 abort();
116 }
117 }
118
119 static
120 void mmap_lock(int log_level)
121 {
122 if (pthread_mutex_lock(&mmap_mutex)) {
123 BT_LOG_WRITE_CUR_LVL(BT_LOG_FATAL, log_level, BT_LOG_TAG, "Failed to acquire mmap_mutex.");
124 abort();
125 }
126 }
127
128 static
129 void mmap_unlock(int log_level)
130 {
131 if (pthread_mutex_unlock(&mmap_mutex)) {
132 BT_LOG_WRITE_CUR_LVL(BT_LOG_FATAL, log_level, BT_LOG_TAG, "Failed to release mmap_mutex.");
133 abort();
134 }
135 }
136
137 /*
138 * Convert mmap memory protection flags to CreateFileMapping page protection
139 * flag and MapViewOfFile desired access flag.
140 */
141 static
142 DWORD map_prot_flags(int prot, DWORD *dwDesiredAccess)
143 {
144 if (prot & PROT_READ) {
145 if (prot & PROT_WRITE) {
146 *dwDesiredAccess = FILE_MAP_WRITE;
147 if (prot & PROT_EXEC) {
148 return PAGE_EXECUTE_READWRITE;
149 }
150 return PAGE_READWRITE;
151 }
152 if (prot & PROT_EXEC) {
153 *dwDesiredAccess = FILE_MAP_EXECUTE;
154 return PAGE_EXECUTE_READ;
155 }
156 *dwDesiredAccess = FILE_MAP_READ;
157 return PAGE_READONLY;
158 }
159 if (prot & PROT_WRITE) {
160 *dwDesiredAccess = FILE_MAP_COPY;
161 return PAGE_WRITECOPY;
162 }
163 if (prot & PROT_EXEC) {
164 *dwDesiredAccess = FILE_MAP_EXECUTE;
165 return PAGE_EXECUTE_READ;
166 }
167
168 /* Mapping failed. */
169 *dwDesiredAccess = 0;
170 return 0;
171 }
172
173 BT_HIDDEN
174 void *bt_mmap(void *addr, size_t length, int prot, int flags, int fd,
175 off_t offset, int log_level)
176 {
177 struct mmap_mapping *mapping = NULL;
178 void *mapping_addr;
179 DWORD dwDesiredAccess;
180 DWORD flProtect;
181 HANDLE handle;
182
183 /* Check for a valid fd. */
184 if (fd == -1) {
185 _set_errno(EBADF);
186 goto error;
187 }
188
189 /* We don't support this at the moment. */
190 if (flags == MAP_FIXED) {
191 _set_errno(ENOTSUP);
192 goto error;
193 }
194
195 /* Map mmap flags to those of the Windows API. */
196 flProtect = map_prot_flags(prot, &dwDesiredAccess);
197 if (flProtect == 0) {
198 _set_errno(EINVAL);
199 goto error;
200 }
201
202 /* Allocate the mapping struct. */
203 mapping = mapping_create(log_level);
204 if (!mapping) {
205 BT_LOG_WRITE_CUR_LVL(BT_LOG_ERROR, log_level, BT_LOG_TAG,
206 "Failed to allocate mmap mapping.");
207 _set_errno(ENOMEM);
208 goto error;
209 }
210
211 /* Get a handle from the fd. */
212 handle = (HANDLE) _get_osfhandle(fd);
213
214 /* Duplicate the handle and store it in 'mapping.file_handle'. */
215 if (!DuplicateHandle(GetCurrentProcess(), handle, GetCurrentProcess(),
216 &mapping->file_handle, 0, FALSE,
217 DUPLICATE_SAME_ACCESS)) {
218 _set_errno(ENOMEM);
219 goto error;
220 }
221
222 /*
223 * Create a file mapping object with a maximum size
224 * of 'offset' + 'length'.
225 */
226 mapping->map_handle = CreateFileMapping(mapping->file_handle, NULL,
227 flProtect, 0, offset + length, NULL);
228 if (mapping->map_handle == 0) {
229 _set_errno(EACCES);
230 goto error;
231 }
232
233 /* Map the requested block starting at 'offset' for 'length' bytes. */
234 mapping_addr = MapViewOfFile(mapping->map_handle, dwDesiredAccess, 0,
235 offset, length);
236 if (mapping_addr == 0) {
237 DWORD dwLastErr = GetLastError();
238 if (dwLastErr == ERROR_MAPPED_ALIGNMENT) {
239 _set_errno(EINVAL);
240 } else {
241 _set_errno(EACCES);
242 }
243 goto error;
244 }
245
246 mmap_lock(log_level);
247
248 /* If we have never done any mappings, allocate the hashtable. */
249 if (!mmap_mappings) {
250 mmap_mappings = g_hash_table_new_full(g_direct_hash,
251 g_direct_equal, (GDestroyNotify) addr_clean,
252 (GDestroyNotify) mapping_clean);
253 if (!mmap_mappings) {
254 BT_LOGE_STR("Failed to allocate mmap hashtable.");
255 _set_errno(ENOMEM);
256 goto error_mutex_unlock;
257 }
258 }
259
260 /* Add the new mapping to the hashtable. */
261 g_hash_table_insert(mmap_mappings, mapping_addr, mapping);
262
263 mmap_unlock(log_level);
264
265 return mapping_addr;
266
267 error_mutex_unlock:
268 mmap_unlock(log_level);
269 error:
270 mapping_clean(mapping);
271 return MAP_FAILED;
272 }
273
274 BT_HIDDEN
275 int bt_munmap(void *addr, size_t length)
276 {
277 int ret = 0;
278 struct mmap_mapping *mapping = addr;
279 int log_level;
280
281 BT_ASSERT(mapping);
282 log_level = mapping->log_level;
283 mmap_lock(log_level);
284
285 /* Check if the mapping exists in the hashtable. */
286 if (g_hash_table_lookup(mmap_mappings, addr) == NULL) {
287 _set_errno(EINVAL);
288 ret = -1;
289 goto end;
290 }
291
292 /* Remove it. */
293 if (!g_hash_table_remove(mmap_mappings, addr)) {
294 BT_LOGF_STR("Failed to remove mapping from hashtable.");
295 abort();
296 }
297
298 end:
299 mmap_unlock(log_level);
300 return ret;
301 }
302
303 #endif
This page took 0.035141 seconds and 4 git commands to generate.