|
111
|
1 /* -----------------------------------------------------------------------
|
|
|
2 closures.c - Copyright (c) 2007, 2009, 2010 Red Hat, Inc.
|
|
|
3 Copyright (C) 2007, 2009, 2010 Free Software Foundation, Inc
|
|
|
4 Copyright (c) 2011 Plausible Labs Cooperative, Inc.
|
|
|
5
|
|
|
6 Code to allocate and deallocate memory for closures.
|
|
|
7
|
|
|
8 Permission is hereby granted, free of charge, to any person obtaining
|
|
|
9 a copy of this software and associated documentation files (the
|
|
|
10 ``Software''), to deal in the Software without restriction, including
|
|
|
11 without limitation the rights to use, copy, modify, merge, publish,
|
|
|
12 distribute, sublicense, and/or sell copies of the Software, and to
|
|
|
13 permit persons to whom the Software is furnished to do so, subject to
|
|
|
14 the following conditions:
|
|
|
15
|
|
|
16 The above copyright notice and this permission notice shall be included
|
|
|
17 in all copies or substantial portions of the Software.
|
|
|
18
|
|
|
19 THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
|
|
|
20 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
21 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
|
22 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|
|
23 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
|
24 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
|
|
|
26 DEALINGS IN THE SOFTWARE.
|
|
|
27 ----------------------------------------------------------------------- */
|
|
|
28
|
|
|
29 #if defined __linux__ && !defined _GNU_SOURCE
|
|
|
30 #define _GNU_SOURCE 1
|
|
|
31 #endif
|
|
|
32
|
|
|
33 #include <ffi.h>
|
|
|
34 #include <ffi_common.h>
|
|
|
35
|
|
|
36 #if !FFI_MMAP_EXEC_WRIT && !FFI_EXEC_TRAMPOLINE_TABLE
|
|
|
37 # if __gnu_linux__ && !defined(__ANDROID__)
|
|
|
38 /* This macro indicates it may be forbidden to map anonymous memory
|
|
|
39 with both write and execute permission. Code compiled when this
|
|
|
40 option is defined will attempt to map such pages once, but if it
|
|
|
41 fails, it falls back to creating a temporary file in a writable and
|
|
|
42 executable filesystem and mapping pages from it into separate
|
|
|
43 locations in the virtual memory space, one location writable and
|
|
|
44 another executable. */
|
|
|
45 # define FFI_MMAP_EXEC_WRIT 1
|
|
|
46 # define HAVE_MNTENT 1
|
|
|
47 # endif
|
|
|
48 # if defined(X86_WIN32) || defined(X86_WIN64) || defined(__OS2__)
|
|
|
49 /* Windows systems may have Data Execution Protection (DEP) enabled,
|
|
|
50 which requires the use of VirtualMalloc/VirtualFree to alloc/free
|
|
|
51 executable memory. */
|
|
|
52 # define FFI_MMAP_EXEC_WRIT 1
|
|
|
53 # endif
|
|
|
54 #endif
|
|
|
55
|
|
|
56 #if FFI_MMAP_EXEC_WRIT && !defined FFI_MMAP_EXEC_SELINUX
|
|
|
57 # ifdef __linux__
|
|
|
58 /* When defined to 1 check for SELinux and if SELinux is active,
|
|
|
59 don't attempt PROT_EXEC|PROT_WRITE mapping at all, as that
|
|
|
60 might cause audit messages. */
|
|
|
61 # define FFI_MMAP_EXEC_SELINUX 1
|
|
|
62 # endif
|
|
|
63 #endif
|
|
|
64
|
|
|
65 #if FFI_CLOSURES
|
|
|
66
|
|
|
67 # if FFI_EXEC_TRAMPOLINE_TABLE
|
|
|
68
|
|
|
69 // Per-target implementation; It's unclear what can reasonable be shared between two OS/architecture implementations.
|
|
|
70
|
|
|
71 # elif FFI_MMAP_EXEC_WRIT /* !FFI_EXEC_TRAMPOLINE_TABLE */
|
|
|
72
|
|
|
73 #define USE_LOCKS 1
|
|
|
74 #define USE_DL_PREFIX 1
|
|
|
75 #ifdef __GNUC__
|
|
|
76 #ifndef USE_BUILTIN_FFS
|
|
|
77 #define USE_BUILTIN_FFS 1
|
|
|
78 #endif
|
|
|
79 #endif
|
|
|
80
|
|
|
81 /* We need to use mmap, not sbrk. */
|
|
|
82 #define HAVE_MORECORE 0
|
|
|
83
|
|
|
84 /* We could, in theory, support mremap, but it wouldn't buy us anything. */
|
|
|
85 #define HAVE_MREMAP 0
|
|
|
86
|
|
|
87 /* We have no use for this, so save some code and data. */
|
|
|
88 #define NO_MALLINFO 1
|
|
|
89
|
|
|
90 /* We need all allocations to be in regular segments, otherwise we
|
|
|
91 lose track of the corresponding code address. */
|
|
|
92 #define DEFAULT_MMAP_THRESHOLD MAX_SIZE_T
|
|
|
93
|
|
|
94 /* Don't allocate more than a page unless needed. */
|
|
|
95 #define DEFAULT_GRANULARITY ((size_t)malloc_getpagesize)
|
|
|
96
|
|
|
97 #if FFI_CLOSURE_TEST
|
|
|
98 /* Don't release single pages, to avoid a worst-case scenario of
|
|
|
99 continuously allocating and releasing single pages, but release
|
|
|
100 pairs of pages, which should do just as well given that allocations
|
|
|
101 are likely to be small. */
|
|
|
102 #define DEFAULT_TRIM_THRESHOLD ((size_t)malloc_getpagesize)
|
|
|
103 #endif
|
|
|
104
|
|
|
105 #include <sys/types.h>
|
|
|
106 #include <sys/stat.h>
|
|
|
107 #include <fcntl.h>
|
|
|
108 #include <errno.h>
|
|
|
109 #ifndef _MSC_VER
|
|
|
110 #include <unistd.h>
|
|
|
111 #endif
|
|
|
112 #include <string.h>
|
|
|
113 #include <stdio.h>
|
|
|
114 #if !defined(X86_WIN32) && !defined(X86_WIN64)
|
|
|
115 #ifdef HAVE_MNTENT
|
|
|
116 #include <mntent.h>
|
|
|
117 #endif /* HAVE_MNTENT */
|
|
|
118 #include <sys/param.h>
|
|
|
119 #include <pthread.h>
|
|
|
120
|
|
|
121 /* We don't want sys/mman.h to be included after we redefine mmap and
|
|
|
122 dlmunmap. */
|
|
|
123 #include <sys/mman.h>
|
|
|
124 #define LACKS_SYS_MMAN_H 1
|
|
|
125
|
|
|
126 #if FFI_MMAP_EXEC_SELINUX
|
|
|
127 #include <sys/statfs.h>
|
|
|
128 #include <stdlib.h>
|
|
|
129
|
|
|
130 static int selinux_enabled = -1;
|
|
|
131
|
|
|
132 static int
|
|
|
133 selinux_enabled_check (void)
|
|
|
134 {
|
|
|
135 struct statfs sfs;
|
|
|
136 FILE *f;
|
|
|
137 char *buf = NULL;
|
|
|
138 size_t len = 0;
|
|
|
139
|
|
|
140 if (statfs ("/selinux", &sfs) >= 0
|
|
|
141 && (unsigned int) sfs.f_type == 0xf97cff8cU)
|
|
|
142 return 1;
|
|
|
143 f = fopen ("/proc/mounts", "r");
|
|
|
144 if (f == NULL)
|
|
|
145 return 0;
|
|
|
146 while (getline (&buf, &len, f) >= 0)
|
|
|
147 {
|
|
|
148 char *p = strchr (buf, ' ');
|
|
|
149 if (p == NULL)
|
|
|
150 break;
|
|
|
151 p = strchr (p + 1, ' ');
|
|
|
152 if (p == NULL)
|
|
|
153 break;
|
|
|
154 if (strncmp (p + 1, "selinuxfs ", 10) == 0)
|
|
|
155 {
|
|
|
156 free (buf);
|
|
|
157 fclose (f);
|
|
|
158 return 1;
|
|
|
159 }
|
|
|
160 }
|
|
|
161 free (buf);
|
|
|
162 fclose (f);
|
|
|
163 return 0;
|
|
|
164 }
|
|
|
165
|
|
|
166 #define is_selinux_enabled() (selinux_enabled >= 0 ? selinux_enabled \
|
|
|
167 : (selinux_enabled = selinux_enabled_check ()))
|
|
|
168
|
|
|
169 #else
|
|
|
170
|
|
|
171 #define is_selinux_enabled() 0
|
|
|
172
|
|
|
173 #endif /* !FFI_MMAP_EXEC_SELINUX */
|
|
|
174
|
|
|
175 /* On PaX enable kernels that have MPROTECT enable we can't use PROT_EXEC. */
|
|
|
176 #ifdef FFI_MMAP_EXEC_EMUTRAMP_PAX
|
|
|
177 #include <stdlib.h>
|
|
|
178
|
|
|
179 static int emutramp_enabled = -1;
|
|
|
180
|
|
|
181 static int
|
|
|
182 emutramp_enabled_check (void)
|
|
|
183 {
|
|
|
184 char *buf = NULL;
|
|
|
185 size_t len = 0;
|
|
|
186 FILE *f;
|
|
|
187 int ret;
|
|
|
188 f = fopen ("/proc/self/status", "r");
|
|
|
189 if (f == NULL)
|
|
|
190 return 0;
|
|
|
191 ret = 0;
|
|
|
192
|
|
|
193 while (getline (&buf, &len, f) != -1)
|
|
|
194 if (!strncmp (buf, "PaX:", 4))
|
|
|
195 {
|
|
|
196 char emutramp;
|
|
|
197 if (sscanf (buf, "%*s %*c%c", &emutramp) == 1)
|
|
|
198 ret = (emutramp == 'E');
|
|
|
199 break;
|
|
|
200 }
|
|
|
201 free (buf);
|
|
|
202 fclose (f);
|
|
|
203 return ret;
|
|
|
204 }
|
|
|
205
|
|
|
206 #define is_emutramp_enabled() (emutramp_enabled >= 0 ? emutramp_enabled \
|
|
|
207 : (emutramp_enabled = emutramp_enabled_check ()))
|
|
|
208 #endif /* FFI_MMAP_EXEC_EMUTRAMP_PAX */
|
|
|
209
|
|
|
210 #elif defined (__CYGWIN__) || defined(__INTERIX)
|
|
|
211
|
|
|
212 #include <sys/mman.h>
|
|
|
213
|
|
|
214 /* Cygwin is Linux-like, but not quite that Linux-like. */
|
|
|
215 #define is_selinux_enabled() 0
|
|
|
216
|
|
|
217 #endif /* !defined(X86_WIN32) && !defined(X86_WIN64) */
|
|
|
218
|
|
|
219 #ifndef FFI_MMAP_EXEC_EMUTRAMP_PAX
|
|
|
220 #define is_emutramp_enabled() 0
|
|
|
221 #endif /* FFI_MMAP_EXEC_EMUTRAMP_PAX */
|
|
|
222
|
|
|
223 /* Declare all functions defined in dlmalloc.c as static. */
|
|
|
224 static void *dlmalloc(size_t);
|
|
|
225 static void dlfree(void*);
|
|
|
226 static void *dlcalloc(size_t, size_t) MAYBE_UNUSED;
|
|
|
227 static void *dlrealloc(void *, size_t) MAYBE_UNUSED;
|
|
|
228 static void *dlmemalign(size_t, size_t) MAYBE_UNUSED;
|
|
|
229 static void *dlvalloc(size_t) MAYBE_UNUSED;
|
|
|
230 static int dlmallopt(int, int) MAYBE_UNUSED;
|
|
|
231 static size_t dlmalloc_footprint(void) MAYBE_UNUSED;
|
|
|
232 static size_t dlmalloc_max_footprint(void) MAYBE_UNUSED;
|
|
|
233 static void** dlindependent_calloc(size_t, size_t, void**) MAYBE_UNUSED;
|
|
|
234 static void** dlindependent_comalloc(size_t, size_t*, void**) MAYBE_UNUSED;
|
|
|
235 static void *dlpvalloc(size_t) MAYBE_UNUSED;
|
|
|
236 static int dlmalloc_trim(size_t) MAYBE_UNUSED;
|
|
|
237 static size_t dlmalloc_usable_size(void*) MAYBE_UNUSED;
|
|
|
238 static void dlmalloc_stats(void) MAYBE_UNUSED;
|
|
|
239
|
|
|
240 #if !(defined(X86_WIN32) || defined(X86_WIN64) || defined(__OS2__)) || defined (__CYGWIN__) || defined(__INTERIX)
|
|
|
241 /* Use these for mmap and munmap within dlmalloc.c. */
|
|
|
242 static void *dlmmap(void *, size_t, int, int, int, off_t);
|
|
|
243 static int dlmunmap(void *, size_t);
|
|
|
244 #endif /* !(defined(X86_WIN32) || defined(X86_WIN64) || defined(__OS2__)) || defined (__CYGWIN__) || defined(__INTERIX) */
|
|
|
245
|
|
|
246 #define mmap dlmmap
|
|
|
247 #define munmap dlmunmap
|
|
|
248
|
|
|
249 #include "dlmalloc.c"
|
|
|
250
|
|
|
251 #undef mmap
|
|
|
252 #undef munmap
|
|
|
253
|
|
|
254 #if !(defined(X86_WIN32) || defined(X86_WIN64) || defined(__OS2__)) || defined (__CYGWIN__) || defined(__INTERIX)
|
|
|
255
|
|
|
256 /* A mutex used to synchronize access to *exec* variables in this file. */
|
|
|
257 static pthread_mutex_t open_temp_exec_file_mutex = PTHREAD_MUTEX_INITIALIZER;
|
|
|
258
|
|
|
259 /* A file descriptor of a temporary file from which we'll map
|
|
|
260 executable pages. */
|
|
|
261 static int execfd = -1;
|
|
|
262
|
|
|
263 /* The amount of space already allocated from the temporary file. */
|
|
|
264 static size_t execsize = 0;
|
|
|
265
|
|
|
266 /* Open a temporary file name, and immediately unlink it. */
|
|
|
267 static int
|
|
|
268 open_temp_exec_file_name (char *name, int flags)
|
|
|
269 {
|
|
|
270 int fd;
|
|
|
271
|
|
|
272 #ifdef HAVE_MKOSTEMP
|
|
|
273 fd = mkostemp (name, flags);
|
|
|
274 #else
|
|
|
275 fd = mkstemp (name);
|
|
|
276 #endif
|
|
|
277
|
|
|
278 if (fd != -1)
|
|
|
279 unlink (name);
|
|
|
280
|
|
|
281 return fd;
|
|
|
282 }
|
|
|
283
|
|
|
284 /* Open a temporary file in the named directory. */
|
|
|
285 static int
|
|
|
286 open_temp_exec_file_dir (const char *dir)
|
|
|
287 {
|
|
|
288 static const char suffix[] = "/ffiXXXXXX";
|
|
|
289 int lendir, flags;
|
|
|
290 char *tempname;
|
|
|
291 #ifdef O_TMPFILE
|
|
|
292 int fd;
|
|
|
293 #endif
|
|
|
294
|
|
|
295 #ifdef O_CLOEXEC
|
|
|
296 flags = O_CLOEXEC;
|
|
|
297 #else
|
|
|
298 flags = 0;
|
|
|
299 #endif
|
|
|
300
|
|
|
301 #ifdef O_TMPFILE
|
|
|
302 fd = open (dir, flags | O_RDWR | O_EXCL | O_TMPFILE, 0700);
|
|
|
303 /* If the running system does not support the O_TMPFILE flag then retry without it. */
|
|
|
304 if (fd != -1 || (errno != EINVAL && errno != EISDIR && errno != EOPNOTSUPP)) {
|
|
|
305 return fd;
|
|
|
306 } else {
|
|
|
307 errno = 0;
|
|
|
308 }
|
|
|
309 #endif
|
|
|
310
|
|
|
311 lendir = strlen (dir);
|
|
|
312 tempname = __builtin_alloca (lendir + sizeof (suffix));
|
|
|
313
|
|
|
314 if (!tempname)
|
|
|
315 return -1;
|
|
|
316
|
|
|
317 memcpy (tempname, dir, lendir);
|
|
|
318 memcpy (tempname + lendir, suffix, sizeof (suffix));
|
|
|
319
|
|
|
320 return open_temp_exec_file_name (tempname, flags);
|
|
|
321 }
|
|
|
322
|
|
|
323 /* Open a temporary file in the directory in the named environment
|
|
|
324 variable. */
|
|
|
325 static int
|
|
|
326 open_temp_exec_file_env (const char *envvar)
|
|
|
327 {
|
|
|
328 const char *value = getenv (envvar);
|
|
|
329
|
|
|
330 if (!value)
|
|
|
331 return -1;
|
|
|
332
|
|
|
333 return open_temp_exec_file_dir (value);
|
|
|
334 }
|
|
|
335
|
|
|
336 #ifdef HAVE_MNTENT
|
|
|
337 /* Open a temporary file in an executable and writable mount point
|
|
|
338 listed in the mounts file. Subsequent calls with the same mounts
|
|
|
339 keep searching for mount points in the same file. Providing NULL
|
|
|
340 as the mounts file closes the file. */
|
|
|
341 static int
|
|
|
342 open_temp_exec_file_mnt (const char *mounts)
|
|
|
343 {
|
|
|
344 static const char *last_mounts;
|
|
|
345 static FILE *last_mntent;
|
|
|
346
|
|
|
347 if (mounts != last_mounts)
|
|
|
348 {
|
|
|
349 if (last_mntent)
|
|
|
350 endmntent (last_mntent);
|
|
|
351
|
|
|
352 last_mounts = mounts;
|
|
|
353
|
|
|
354 if (mounts)
|
|
|
355 last_mntent = setmntent (mounts, "r");
|
|
|
356 else
|
|
|
357 last_mntent = NULL;
|
|
|
358 }
|
|
|
359
|
|
|
360 if (!last_mntent)
|
|
|
361 return -1;
|
|
|
362
|
|
|
363 for (;;)
|
|
|
364 {
|
|
|
365 int fd;
|
|
|
366 struct mntent mnt;
|
|
|
367 char buf[MAXPATHLEN * 3];
|
|
|
368
|
|
|
369 if (getmntent_r (last_mntent, &mnt, buf, sizeof (buf)) == NULL)
|
|
|
370 return -1;
|
|
|
371
|
|
|
372 if (hasmntopt (&mnt, "ro")
|
|
|
373 || hasmntopt (&mnt, "noexec")
|
|
|
374 || access (mnt.mnt_dir, W_OK))
|
|
|
375 continue;
|
|
|
376
|
|
|
377 fd = open_temp_exec_file_dir (mnt.mnt_dir);
|
|
|
378
|
|
|
379 if (fd != -1)
|
|
|
380 return fd;
|
|
|
381 }
|
|
|
382 }
|
|
|
383 #endif /* HAVE_MNTENT */
|
|
|
384
|
|
|
385 /* Instructions to look for a location to hold a temporary file that
|
|
|
386 can be mapped in for execution. */
|
|
|
387 static struct
|
|
|
388 {
|
|
|
389 int (*func)(const char *);
|
|
|
390 const char *arg;
|
|
|
391 int repeat;
|
|
|
392 } open_temp_exec_file_opts[] = {
|
|
|
393 { open_temp_exec_file_env, "TMPDIR", 0 },
|
|
|
394 { open_temp_exec_file_dir, "/tmp", 0 },
|
|
|
395 { open_temp_exec_file_dir, "/var/tmp", 0 },
|
|
|
396 { open_temp_exec_file_dir, "/dev/shm", 0 },
|
|
|
397 { open_temp_exec_file_env, "HOME", 0 },
|
|
|
398 #ifdef HAVE_MNTENT
|
|
|
399 { open_temp_exec_file_mnt, "/etc/mtab", 1 },
|
|
|
400 { open_temp_exec_file_mnt, "/proc/mounts", 1 },
|
|
|
401 #endif /* HAVE_MNTENT */
|
|
|
402 };
|
|
|
403
|
|
|
404 /* Current index into open_temp_exec_file_opts. */
|
|
|
405 static int open_temp_exec_file_opts_idx = 0;
|
|
|
406
|
|
|
407 /* Reset a current multi-call func, then advances to the next entry.
|
|
|
408 If we're at the last, go back to the first and return nonzero,
|
|
|
409 otherwise return zero. */
|
|
|
410 static int
|
|
|
411 open_temp_exec_file_opts_next (void)
|
|
|
412 {
|
|
|
413 if (open_temp_exec_file_opts[open_temp_exec_file_opts_idx].repeat)
|
|
|
414 open_temp_exec_file_opts[open_temp_exec_file_opts_idx].func (NULL);
|
|
|
415
|
|
|
416 open_temp_exec_file_opts_idx++;
|
|
|
417 if (open_temp_exec_file_opts_idx
|
|
|
418 == (sizeof (open_temp_exec_file_opts)
|
|
|
419 / sizeof (*open_temp_exec_file_opts)))
|
|
|
420 {
|
|
|
421 open_temp_exec_file_opts_idx = 0;
|
|
|
422 return 1;
|
|
|
423 }
|
|
|
424
|
|
|
425 return 0;
|
|
|
426 }
|
|
|
427
|
|
|
428 /* Return a file descriptor of a temporary zero-sized file in a
|
|
|
429 writable and executable filesystem. */
|
|
|
430 static int
|
|
|
431 open_temp_exec_file (void)
|
|
|
432 {
|
|
|
433 int fd;
|
|
|
434
|
|
|
435 do
|
|
|
436 {
|
|
|
437 fd = open_temp_exec_file_opts[open_temp_exec_file_opts_idx].func
|
|
|
438 (open_temp_exec_file_opts[open_temp_exec_file_opts_idx].arg);
|
|
|
439
|
|
|
440 if (!open_temp_exec_file_opts[open_temp_exec_file_opts_idx].repeat
|
|
|
441 || fd == -1)
|
|
|
442 {
|
|
|
443 if (open_temp_exec_file_opts_next ())
|
|
|
444 break;
|
|
|
445 }
|
|
|
446 }
|
|
|
447 while (fd == -1);
|
|
|
448
|
|
|
449 return fd;
|
|
|
450 }
|
|
|
451
|
|
|
452 /* Map in a chunk of memory from the temporary exec file into separate
|
|
|
453 locations in the virtual memory address space, one writable and one
|
|
|
454 executable. Returns the address of the writable portion, after
|
|
|
455 storing an offset to the corresponding executable portion at the
|
|
|
456 last word of the requested chunk. */
|
|
|
457 static void *
|
|
|
458 dlmmap_locked (void *start, size_t length, int prot, int flags, off_t offset)
|
|
|
459 {
|
|
|
460 void *ptr;
|
|
|
461
|
|
|
462 if (execfd == -1)
|
|
|
463 {
|
|
|
464 open_temp_exec_file_opts_idx = 0;
|
|
|
465 retry_open:
|
|
|
466 execfd = open_temp_exec_file ();
|
|
|
467 if (execfd == -1)
|
|
|
468 return MFAIL;
|
|
|
469 }
|
|
|
470
|
|
|
471 offset = execsize;
|
|
|
472
|
|
|
473 if (ftruncate (execfd, offset + length))
|
|
|
474 return MFAIL;
|
|
|
475
|
|
|
476 flags &= ~(MAP_PRIVATE | MAP_ANONYMOUS);
|
|
|
477 flags |= MAP_SHARED;
|
|
|
478
|
|
|
479 ptr = mmap (NULL, length, (prot & ~PROT_WRITE) | PROT_EXEC,
|
|
|
480 flags, execfd, offset);
|
|
|
481 if (ptr == MFAIL)
|
|
|
482 {
|
|
|
483 if (!offset)
|
|
|
484 {
|
|
|
485 close (execfd);
|
|
|
486 goto retry_open;
|
|
|
487 }
|
|
|
488 ftruncate (execfd, offset);
|
|
|
489 return MFAIL;
|
|
|
490 }
|
|
|
491 else if (!offset
|
|
|
492 && open_temp_exec_file_opts[open_temp_exec_file_opts_idx].repeat)
|
|
|
493 open_temp_exec_file_opts_next ();
|
|
|
494
|
|
|
495 start = mmap (start, length, prot, flags, execfd, offset);
|
|
|
496
|
|
|
497 if (start == MFAIL)
|
|
|
498 {
|
|
|
499 munmap (ptr, length);
|
|
|
500 ftruncate (execfd, offset);
|
|
|
501 return start;
|
|
|
502 }
|
|
|
503
|
|
|
504 mmap_exec_offset ((char *)start, length) = (char*)ptr - (char*)start;
|
|
|
505
|
|
|
506 execsize += length;
|
|
|
507
|
|
|
508 return start;
|
|
|
509 }
|
|
|
510
|
|
|
511 /* Map in a writable and executable chunk of memory if possible.
|
|
|
512 Failing that, fall back to dlmmap_locked. */
|
|
|
513 static void *
|
|
|
514 dlmmap (void *start, size_t length, int prot,
|
|
|
515 int flags, int fd, off_t offset)
|
|
|
516 {
|
|
|
517 void *ptr;
|
|
|
518
|
|
|
519 assert (start == NULL && length % malloc_getpagesize == 0
|
|
|
520 && prot == (PROT_READ | PROT_WRITE)
|
|
|
521 && flags == (MAP_PRIVATE | MAP_ANONYMOUS)
|
|
|
522 && fd == -1 && offset == 0);
|
|
|
523
|
|
|
524 #if FFI_CLOSURE_TEST
|
|
|
525 printf ("mapping in %zi\n", length);
|
|
|
526 #endif
|
|
|
527
|
|
|
528 if (execfd == -1 && is_emutramp_enabled ())
|
|
|
529 {
|
|
|
530 ptr = mmap (start, length, prot & ~PROT_EXEC, flags, fd, offset);
|
|
|
531 return ptr;
|
|
|
532 }
|
|
|
533
|
|
|
534 if (execfd == -1 && !is_selinux_enabled ())
|
|
|
535 {
|
|
|
536 ptr = mmap (start, length, prot | PROT_EXEC, flags, fd, offset);
|
|
|
537
|
|
|
538 if (ptr != MFAIL || (errno != EPERM && errno != EACCES))
|
|
|
539 /* Cool, no need to mess with separate segments. */
|
|
|
540 return ptr;
|
|
|
541
|
|
|
542 /* If MREMAP_DUP is ever introduced and implemented, try mmap
|
|
|
543 with ((prot & ~PROT_WRITE) | PROT_EXEC) and mremap with
|
|
|
544 MREMAP_DUP and prot at this point. */
|
|
|
545 }
|
|
|
546
|
|
|
547 if (execsize == 0 || execfd == -1)
|
|
|
548 {
|
|
|
549 pthread_mutex_lock (&open_temp_exec_file_mutex);
|
|
|
550 ptr = dlmmap_locked (start, length, prot, flags, offset);
|
|
|
551 pthread_mutex_unlock (&open_temp_exec_file_mutex);
|
|
|
552
|
|
|
553 return ptr;
|
|
|
554 }
|
|
|
555
|
|
|
556 return dlmmap_locked (start, length, prot, flags, offset);
|
|
|
557 }
|
|
|
558
|
|
|
559 /* Release memory at the given address, as well as the corresponding
|
|
|
560 executable page if it's separate. */
|
|
|
561 static int
|
|
|
562 dlmunmap (void *start, size_t length)
|
|
|
563 {
|
|
|
564 /* We don't bother decreasing execsize or truncating the file, since
|
|
|
565 we can't quite tell whether we're unmapping the end of the file.
|
|
|
566 We don't expect frequent deallocation anyway. If we did, we
|
|
|
567 could locate pages in the file by writing to the pages being
|
|
|
568 deallocated and checking that the file contents change.
|
|
|
569 Yuck. */
|
|
|
570 msegmentptr seg = segment_holding (gm, start);
|
|
|
571 void *code;
|
|
|
572
|
|
|
573 #if FFI_CLOSURE_TEST
|
|
|
574 printf ("unmapping %zi\n", length);
|
|
|
575 #endif
|
|
|
576
|
|
|
577 if (seg && (code = add_segment_exec_offset (start, seg)) != start)
|
|
|
578 {
|
|
|
579 int ret = munmap (code, length);
|
|
|
580 if (ret)
|
|
|
581 return ret;
|
|
|
582 }
|
|
|
583
|
|
|
584 return munmap (start, length);
|
|
|
585 }
|
|
|
586
|
|
|
587 #if FFI_CLOSURE_FREE_CODE
|
|
|
588 /* Return segment holding given code address. */
|
|
|
589 static msegmentptr
|
|
|
590 segment_holding_code (mstate m, char* addr)
|
|
|
591 {
|
|
|
592 msegmentptr sp = &m->seg;
|
|
|
593 for (;;) {
|
|
|
594 if (addr >= add_segment_exec_offset (sp->base, sp)
|
|
|
595 && addr < add_segment_exec_offset (sp->base, sp) + sp->size)
|
|
|
596 return sp;
|
|
|
597 if ((sp = sp->next) == 0)
|
|
|
598 return 0;
|
|
|
599 }
|
|
|
600 }
|
|
|
601 #endif
|
|
|
602
|
|
|
603 #endif /* !(defined(X86_WIN32) || defined(X86_WIN64) || defined(__OS2__)) || defined (__CYGWIN__) || defined(__INTERIX) */
|
|
|
604
|
|
|
605 /* Allocate a chunk of memory with the given size. Returns a pointer
|
|
|
606 to the writable address, and sets *CODE to the executable
|
|
|
607 corresponding virtual address. */
|
|
|
608 void *
|
|
|
609 ffi_closure_alloc (size_t size, void **code)
|
|
|
610 {
|
|
|
611 void *ptr;
|
|
|
612
|
|
|
613 if (!code)
|
|
|
614 return NULL;
|
|
|
615
|
|
|
616 ptr = dlmalloc (size);
|
|
|
617
|
|
|
618 if (ptr)
|
|
|
619 {
|
|
|
620 msegmentptr seg = segment_holding (gm, ptr);
|
|
|
621
|
|
|
622 *code = add_segment_exec_offset (ptr, seg);
|
|
|
623 }
|
|
|
624
|
|
|
625 return ptr;
|
|
|
626 }
|
|
|
627
|
|
|
628 /* Release a chunk of memory allocated with ffi_closure_alloc. If
|
|
|
629 FFI_CLOSURE_FREE_CODE is nonzero, the given address can be the
|
|
|
630 writable or the executable address given. Otherwise, only the
|
|
|
631 writable address can be provided here. */
|
|
|
632 void
|
|
|
633 ffi_closure_free (void *ptr)
|
|
|
634 {
|
|
|
635 #if FFI_CLOSURE_FREE_CODE
|
|
|
636 msegmentptr seg = segment_holding_code (gm, ptr);
|
|
|
637
|
|
|
638 if (seg)
|
|
|
639 ptr = sub_segment_exec_offset (ptr, seg);
|
|
|
640 #endif
|
|
|
641
|
|
|
642 dlfree (ptr);
|
|
|
643 }
|
|
|
644
|
|
|
645
|
|
|
646 #if FFI_CLOSURE_TEST
|
|
|
647 /* Do some internal sanity testing to make sure allocation and
|
|
|
648 deallocation of pages are working as intended. */
|
|
|
649 int main ()
|
|
|
650 {
|
|
|
651 void *p[3];
|
|
|
652 #define GET(idx, len) do { p[idx] = dlmalloc (len); printf ("allocated %zi for p[%i]\n", (len), (idx)); } while (0)
|
|
|
653 #define PUT(idx) do { printf ("freeing p[%i]\n", (idx)); dlfree (p[idx]); } while (0)
|
|
|
654 GET (0, malloc_getpagesize / 2);
|
|
|
655 GET (1, 2 * malloc_getpagesize - 64 * sizeof (void*));
|
|
|
656 PUT (1);
|
|
|
657 GET (1, 2 * malloc_getpagesize);
|
|
|
658 GET (2, malloc_getpagesize / 2);
|
|
|
659 PUT (1);
|
|
|
660 PUT (0);
|
|
|
661 PUT (2);
|
|
|
662 return 0;
|
|
|
663 }
|
|
|
664 #endif /* FFI_CLOSURE_TEST */
|
|
|
665 # else /* ! FFI_MMAP_EXEC_WRIT */
|
|
|
666
|
|
|
667 /* On many systems, memory returned by malloc is writable and
|
|
|
668 executable, so just use it. */
|
|
|
669
|
|
|
670 #include <stdlib.h>
|
|
|
671
|
|
|
672 void *
|
|
|
673 ffi_closure_alloc (size_t size, void **code)
|
|
|
674 {
|
|
|
675 if (!code)
|
|
|
676 return NULL;
|
|
|
677
|
|
|
678 return *code = malloc (size);
|
|
|
679 }
|
|
|
680
|
|
|
681 void
|
|
|
682 ffi_closure_free (void *ptr)
|
|
|
683 {
|
|
|
684 free (ptr);
|
|
|
685 }
|
|
|
686
|
|
|
687 # endif /* ! FFI_MMAP_EXEC_WRIT */
|
|
|
688 #endif /* FFI_CLOSURES */
|
