Debian Codegraph @

src/closures.c

raw
1 /* -----------------------------------------------------------------------
2 closures.c - Copyright (c) 2019, 2022 Anthony Green
3 Copyright (c) 2007, 2009, 2010 Red Hat, Inc.
4 Copyright (C) 2007, 2009, 2010 Free Software Foundation, Inc
5 Copyright (c) 2011 Plausible Labs Cooperative, Inc.
6
7 Code to allocate and deallocate memory for closures.
8
9 Permission is hereby granted, free of charge, to any person obtaining
10 a copy of this software and associated documentation files (the
11 ``Software''), to deal in the Software without restriction, including
12 without limitation the rights to use, copy, modify, merge, publish,
13 distribute, sublicense, and/or sell copies of the Software, and to
14 permit persons to whom the Software is furnished to do so, subject to
15 the following conditions:
16
17 The above copyright notice and this permission notice shall be included
18 in all copies or substantial portions of the Software.
19
20 THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
21 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
23 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
24 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
25 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
26 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
27 DEALINGS IN THE SOFTWARE.
28 ----------------------------------------------------------------------- */
29
30 #if (defined __linux__ || defined __CYGWIN__) && !defined _GNU_SOURCE
31 #define _GNU_SOURCE 1
32 #endif
33
34 #ifndef __EMSCRIPTEN__
35
36 #include <fficonfig.h>
37 #include <ffi.h>
38 #include <ffi_common.h>
39 #include <tramp.h>
40
41 #ifdef __NetBSD__
42 #include <sys/param.h>
43 #endif
44
45 #if __NetBSD_Version__ - 0 >= 799007200
46 /* NetBSD with PROT_MPROTECT */
47 #include <sys/mman.h>
48
49 #include <stddef.h>
50 #include <unistd.h>
51 #ifdef HAVE_SYS_MEMFD_H
52 #include <sys/memfd.h>
53 #endif
54
55 static const size_t overhead =
56 (sizeof(max_align_t) > sizeof(void *) + sizeof(size_t)) ?
57 sizeof(max_align_t)
58 : sizeof(void *) + sizeof(size_t);
59
60 #define ADD_TO_POINTER(p, d) ((void *)((uintptr_t)(p) + (d)))
61
62 void *
63 ffi_closure_alloc (size_t size, void **code)
64 {
65 static size_t page_size;
66 size_t rounded_size;
67 void *codeseg, *dataseg;
68 int prot;
69
70 /* Expect that PAX mprotect is active and a separate code mapping is necessary. */
71 if (!code)
72 return NULL;
73
74 /* Obtain system page size. */
75 if (!page_size)
76 page_size = sysconf(_SC_PAGESIZE);
77
78 /* Round allocation size up to the next page, keeping in mind the size field and pointer to code map. */
79 rounded_size = (size + overhead + page_size - 1) & ~(page_size - 1);
80
81 /* Primary mapping is RW, but request permission to switch to PROT_EXEC later. */
82 prot = PROT_READ | PROT_WRITE | PROT_MPROTECT(PROT_EXEC);
83 dataseg = mmap(NULL, rounded_size, prot, MAP_ANON | MAP_PRIVATE, -1, 0);
84 if (dataseg == MAP_FAILED)
85 return NULL;
86
87 /* Create secondary mapping and switch it to RX. */
88 codeseg = mremap(dataseg, rounded_size, NULL, rounded_size, MAP_REMAPDUP);
89 if (codeseg == MAP_FAILED) {
90 munmap(dataseg, rounded_size);
91 return NULL;
92 }
93 if (mprotect(codeseg, rounded_size, PROT_READ | PROT_EXEC) == -1) {
94 munmap(codeseg, rounded_size);
95 munmap(dataseg, rounded_size);
96 return NULL;
97 }
98
99 /* Remember allocation size and location of the secondary mapping for ffi_closure_free. */
100 memcpy(dataseg, &rounded_size, sizeof(rounded_size));
101 memcpy(ADD_TO_POINTER(dataseg, sizeof(size_t)), &codeseg, sizeof(void *));
102 *code = ADD_TO_POINTER(codeseg, overhead);
103 return ADD_TO_POINTER(dataseg, overhead);
104 }
105
106 void
107 ffi_closure_free (void *ptr)
108 {
109 void *codeseg, *dataseg;
110 size_t rounded_size;
111
112 dataseg = ADD_TO_POINTER(ptr, -overhead);
113 memcpy(&rounded_size, dataseg, sizeof(rounded_size));
114 memcpy(&codeseg, ADD_TO_POINTER(dataseg, sizeof(size_t)), sizeof(void *));
115 munmap(dataseg, rounded_size);
116 munmap(codeseg, rounded_size);
117 }
118
119 int
120 ffi_tramp_is_present (__attribute__((unused)) void *ptr)
121 {
122 return 0;
123 }
124 #else /* !NetBSD with PROT_MPROTECT */
125
126 #if !FFI_MMAP_EXEC_WRIT && !FFI_EXEC_TRAMPOLINE_TABLE
127 # if __linux__ && !defined(__ANDROID__)
128 /* This macro indicates it may be forbidden to map anonymous memory
129 with both write and execute permission. Code compiled when this
130 option is defined will attempt to map such pages once, but if it
131 fails, it falls back to creating a temporary file in a writable and
132 executable filesystem and mapping pages from it into separate
133 locations in the virtual memory space, one location writable and
134 another executable. */
135 # define FFI_MMAP_EXEC_WRIT 1
136 # define HAVE_MNTENT 1
137 # endif
138 # if defined(__CYGWIN__) || defined(_WIN32) || defined(__OS2__)
139 /* Windows systems may have Data Execution Protection (DEP) enabled,
140 which requires the use of VirtualMalloc/VirtualFree to alloc/free
141 executable memory. */
142 # define FFI_MMAP_EXEC_WRIT 1
143 # endif
144 #endif
145
146 #if FFI_MMAP_EXEC_WRIT && defined(__linux__) && !defined(__ANDROID__)
147 # if !defined FFI_MMAP_EXEC_SELINUX
148 /* When defined to 1 check for SELinux and if SELinux is active,
149 don't attempt PROT_EXEC|PROT_WRITE mapping at all, as that
150 might cause audit messages. */
151 # define FFI_MMAP_EXEC_SELINUX 1
152 # endif /* !defined FFI_MMAP_EXEC_SELINUX */
153 # if !defined FFI_MMAP_PAX
154 /* Also check for PaX MPROTECT */
155 # define FFI_MMAP_PAX 1
156 # endif /* !defined FFI_MMAP_PAX */
157 #endif /* FFI_MMAP_EXEC_WRIT && defined(__linux__) && !defined(__ANDROID__) */
158
159 #if FFI_CLOSURES
160
161 #if FFI_EXEC_TRAMPOLINE_TABLE
162
163 #ifdef __MACH__
164
165 #include <mach/mach.h>
166 #include <pthread.h>
167 #ifdef HAVE_ARM64E_PTRAUTH
168 #include <ptrauth.h>
169 #endif
170 #include <stdio.h>
171 #include <stdlib.h>
172
173 extern void *ffi_closure_trampoline_table_page;
174
175 typedef struct ffi_trampoline_table ffi_trampoline_table;
176 typedef struct ffi_trampoline_table_entry ffi_trampoline_table_entry;
177
178 struct ffi_trampoline_table
179 {
180 /* contiguous writable and executable pages */
181 vm_address_t config_page;
182
183 /* free list tracking */
184 uint16_t free_count;
185 ffi_trampoline_table_entry *free_list;
186 ffi_trampoline_table_entry *free_list_pool;
187
188 ffi_trampoline_table *prev;
189 ffi_trampoline_table *next;
190 };
191
192 struct ffi_trampoline_table_entry
193 {
194 void *(*trampoline) (void);
195 ffi_trampoline_table_entry *next;
196 };
197
198 /* Total number of trampolines that fit in one trampoline table */
199 #define FFI_TRAMPOLINE_COUNT (PAGE_MAX_SIZE / FFI_TRAMPOLINE_SIZE)
200
201 static pthread_mutex_t ffi_trampoline_lock = PTHREAD_MUTEX_INITIALIZER;
202 static ffi_trampoline_table *ffi_trampoline_tables = NULL;
203
204 static ffi_trampoline_table *
205 ffi_trampoline_table_alloc (void)
206 {
207 ffi_trampoline_table *table;
208 vm_address_t config_page;
209 vm_address_t trampoline_page;
210 vm_address_t trampoline_page_template;
211 vm_prot_t cur_prot;
212 vm_prot_t max_prot;
213 kern_return_t kt;
214 uint16_t i;
215
216 /* Allocate two pages -- a config page and a placeholder page */
217 config_page = 0x0;
218 kt = vm_allocate (mach_task_self (), &config_page, PAGE_MAX_SIZE * 2,
219 VM_FLAGS_ANYWHERE);
220 if (kt != KERN_SUCCESS)
221 return NULL;
222
223 /* Remap the trampoline table on top of the placeholder page */
224 trampoline_page = config_page + PAGE_MAX_SIZE;
225
226 #ifdef HAVE_ARM64E_PTRAUTH
227 trampoline_page_template = (vm_address_t)(uintptr_t)ptrauth_auth_data((void *)&ffi_closure_trampoline_table_page, ptrauth_key_function_pointer, 0);
228 #else
229 trampoline_page_template = (vm_address_t)&ffi_closure_trampoline_table_page;
230 #endif
231
232 #ifdef __arm__
233 /* ffi_closure_trampoline_table_page can be thumb-biased on some ARM archs */
234 trampoline_page_template &= ~1UL;
235 #endif
236 kt = vm_remap (mach_task_self (), &trampoline_page, PAGE_MAX_SIZE, 0x0,
237 VM_FLAGS_OVERWRITE, mach_task_self (), trampoline_page_template,
238 FALSE, &cur_prot, &max_prot, VM_INHERIT_SHARE);
239 if (kt != KERN_SUCCESS)
240 {
241 vm_deallocate (mach_task_self (), config_page, PAGE_MAX_SIZE * 2);
242 return NULL;
243 }
244
245 if (!(cur_prot & VM_PROT_EXECUTE))
246 {
247 /* If VM_PROT_EXECUTE isn't set on the remapped trampoline page, set it */
248 kt = vm_protect (mach_task_self (), trampoline_page, PAGE_MAX_SIZE,
249 FALSE, cur_prot | VM_PROT_EXECUTE);
250 if (kt != KERN_SUCCESS)
251 {
252 vm_deallocate (mach_task_self (), config_page, PAGE_MAX_SIZE * 2);
253 return NULL;
254 }
255 }
256
257 /* We have valid trampoline and config pages */
258 table = calloc (1, sizeof (ffi_trampoline_table));
259 table->free_count = FFI_TRAMPOLINE_COUNT;
260 table->config_page = config_page;
261
262 /* Create and initialize the free list */
263 table->free_list_pool =
264 calloc (FFI_TRAMPOLINE_COUNT, sizeof (ffi_trampoline_table_entry));
265
266 for (i = 0; i < table->free_count; i++)
267 {
268 ffi_trampoline_table_entry *entry = &table->free_list_pool[i];
269 entry->trampoline =
270 (void *) (trampoline_page + (i * FFI_TRAMPOLINE_SIZE));
271 #ifdef HAVE_ARM64E_PTRAUTH
272 entry->trampoline = ptrauth_sign_unauthenticated(entry->trampoline, ptrauth_key_function_pointer, 0);
273 #endif
274
275 if (i < table->free_count - 1)
276 entry->next = &table->free_list_pool[i + 1];
277 }
278
279 table->free_list = table->free_list_pool;
280
281 return table;
282 }
283
284 static void
285 ffi_trampoline_table_free (ffi_trampoline_table *table)
286 {
287 /* Remove from the list */
288 if (table->prev != NULL)
289 table->prev->next = table->next;
290
291 if (table->next != NULL)
292 table->next->prev = table->prev;
293
294 /* Deallocate pages */
295 vm_deallocate (mach_task_self (), table->config_page, PAGE_MAX_SIZE * 2);
296
297 /* Deallocate free list */
298 free (table->free_list_pool);
299 free (table);
300 }
301
302 void *
303 ffi_closure_alloc (size_t size, void **code)
304 {
305 /* Create the closure */
306 ffi_closure *closure = malloc (size);
307 if (closure == NULL)
308 return NULL;
309
310 pthread_mutex_lock (&ffi_trampoline_lock);
311
312 /* Check for an active trampoline table with available entries. */
313 ffi_trampoline_table *table = ffi_trampoline_tables;
314 if (table == NULL || table->free_list == NULL)
315 {
316 table = ffi_trampoline_table_alloc ();
317 if (table == NULL)
318 {
319 pthread_mutex_unlock (&ffi_trampoline_lock);
320 free (closure);
321 return NULL;
322 }
323
324 /* Insert the new table at the top of the list */
325 table->next = ffi_trampoline_tables;
326 if (table->next != NULL)
327 table->next->prev = table;
328
329 ffi_trampoline_tables = table;
330 }
331
332 /* Claim the free entry */
333 ffi_trampoline_table_entry *entry = ffi_trampoline_tables->free_list;
334 ffi_trampoline_tables->free_list = entry->next;
335 ffi_trampoline_tables->free_count--;
336 entry->next = NULL;
337
338 pthread_mutex_unlock (&ffi_trampoline_lock);
339
340 /* Initialize the return values */
341 *code = entry->trampoline;
342 closure->trampoline_table = table;
343 closure->trampoline_table_entry = entry;
344
345 return closure;
346 }
347
348 void
349 ffi_closure_free (void *ptr)
350 {
351 ffi_closure *closure = ptr;
352
353 pthread_mutex_lock (&ffi_trampoline_lock);
354
355 /* Fetch the table and entry references */
356 ffi_trampoline_table *table = closure->trampoline_table;
357 ffi_trampoline_table_entry *entry = closure->trampoline_table_entry;
358
359 /* Return the entry to the free list */
360 entry->next = table->free_list;
361 table->free_list = entry;
362 table->free_count++;
363
364 /* If all trampolines within this table are free, and at least one other table exists, deallocate
365 * the table */
366 if (table->free_count == FFI_TRAMPOLINE_COUNT
367 && ffi_trampoline_tables != table)
368 {
369 ffi_trampoline_table_free (table);
370 }
371 else if (ffi_trampoline_tables != table)
372 {
373 /* Otherwise, bump this table to the top of the list */
374 table->prev = NULL;
375 table->next = ffi_trampoline_tables;
376 if (ffi_trampoline_tables != NULL)
377 ffi_trampoline_tables->prev = table;
378
379 ffi_trampoline_tables = table;
380 }
381
382 pthread_mutex_unlock (&ffi_trampoline_lock);
383
384 /* Free the closure */
385 free (closure);
386 }
387
388 #endif
389
390 // Per-target implementation; It's unclear what can reasonable be shared between two OS/architecture implementations.
391
392 #elif FFI_MMAP_EXEC_WRIT /* !FFI_EXEC_TRAMPOLINE_TABLE */
393
394 #define USE_LOCKS 1
395 #define USE_DL_PREFIX 1
396 #ifdef __GNUC__
397 #ifndef USE_BUILTIN_FFS
398 #define USE_BUILTIN_FFS 1
399 #endif
400 #endif
401
402 /* We need to use mmap, not sbrk. */
403 #define HAVE_MORECORE 0
404
405 /* We could, in theory, support mremap, but it wouldn't buy us anything. */
406 #define HAVE_MREMAP 0
407
408 /* We have no use for this, so save some code and data. */
409 #define NO_MALLINFO 1
410
411 /* We need all allocations to be in regular segments, otherwise we
412 lose track of the corresponding code address. */
413 #define DEFAULT_MMAP_THRESHOLD MAX_SIZE_T
414
415 /* Don't allocate more than a page unless needed. */
416 #define DEFAULT_GRANULARITY ((size_t)malloc_getpagesize)
417
418 #include <sys/types.h>
419 #include <sys/stat.h>
420 #include <fcntl.h>
421 #include <errno.h>
422 #ifndef _MSC_VER
423 #include <unistd.h>
424 #endif
425 #include <string.h>
426 #include <stdio.h>
427 #if !defined(_WIN32)
428 #ifdef HAVE_MNTENT
429 #include <mntent.h>
430 #endif /* HAVE_MNTENT */
431 #include <sys/param.h>
432 #include <pthread.h>
433
434 /* We don't want sys/mman.h to be included after we redefine mmap and
435 dlmunmap. */
436 #include <sys/mman.h>
437 #define LACKS_SYS_MMAN_H 1
438
439 #if FFI_MMAP_EXEC_SELINUX
440 #include <sys/statfs.h>
441 #include <stdlib.h>
442
443 static int selinux_enabled = -1;
444
445 static int
446 selinux_enabled_check (void)
447 {
448 struct statfs sfs;
449 FILE *f;
450 char *buf = NULL;
451 size_t len = 0;
452
453 if (statfs ("/selinux", &sfs) >= 0
454 && (unsigned int) sfs.f_type == 0xf97cff8cU)
455 return 1;
456 f = fopen ("/proc/mounts", "r");
457 if (f == NULL)
458 return 0;
459 while (getline (&buf, &len, f) >= 0)
460 {
461 char *p = strchr (buf, ' ');
462 if (p == NULL)
463 break;
464 p = strchr (p + 1, ' ');
465 if (p == NULL)
466 break;
467 if (strncmp (p + 1, "selinuxfs ", 10) == 0)
468 {
469 free (buf);
470 fclose (f);
471 return 1;
472 }
473 }
474 free (buf);
475 fclose (f);
476 return 0;
477 }
478
479 #define is_selinux_enabled() (selinux_enabled >= 0 ? selinux_enabled \
480 : (selinux_enabled = selinux_enabled_check ()))
481
482 #else
483
484 #define is_selinux_enabled() 0
485
486 #endif /* !FFI_MMAP_EXEC_SELINUX */
487
488 /* On PaX enable kernels that have MPROTECT enabled we can't use PROT_EXEC. */
489 #if defined FFI_MMAP_PAX
490 #include <stdlib.h>
491
492 enum {
493 PAX_MPROTECT = (1 << 0),
494 PAX_EMUTRAMP = (1 << 1),
495 };
496 static int cached_pax_flags = -1;
497
498 static int
499 pax_flags_check (void)
500 {
501 char *buf = NULL;
502 size_t len = 0;
503 FILE *f;
504 int ret;
505 f = fopen ("/proc/self/status", "r");
506 if (f == NULL)
507 return 0;
508 ret = 0;
509
510 while (getline (&buf, &len, f) != -1)
511 if (!strncmp (buf, "PaX:", 4))
512 {
513 if (NULL != strchr (buf + 4, 'M'))
514 ret |= PAX_MPROTECT;
515 if (NULL != strchr (buf + 4, 'E'))
516 ret |= PAX_EMUTRAMP;
517 break;
518 }
519 free (buf);
520 fclose (f);
521 return ret;
522 }
523
524 #define get_pax_flags() (cached_pax_flags >= 0 ? cached_pax_flags \
525 : (cached_pax_flags = pax_flags_check ()))
526 #define has_pax_flags(flags) ((flags) == ((flags) & get_pax_flags ()))
527 #define is_mprotect_enabled() (has_pax_flags (PAX_MPROTECT))
528 #define is_emutramp_enabled() (has_pax_flags (PAX_EMUTRAMP))
529
530 #endif /* defined FFI_MMAP_PAX */
531
532 #elif defined (__CYGWIN__) || defined(__INTERIX)
533
534 #include <sys/mman.h>
535
536 /* Cygwin is Linux-like, but not quite that Linux-like. */
537 #define is_selinux_enabled() 0
538
539 #endif /* !defined(X86_WIN32) && !defined(X86_WIN64) */
540
541 #if !defined FFI_MMAP_PAX
542 # define is_mprotect_enabled() 0
543 # define is_emutramp_enabled() 0
544 #endif /* !defined FFI_MMAP_PAX */
545
546 /* Declare all functions defined in dlmalloc.c as static. */
547 static void *dlmalloc(size_t);
548 static void dlfree(void*);
549 static void *dlcalloc(size_t, size_t) MAYBE_UNUSED;
550 static void *dlrealloc(void *, size_t) MAYBE_UNUSED;
551 static void *dlmemalign(size_t, size_t) MAYBE_UNUSED;
552 static void *dlvalloc(size_t) MAYBE_UNUSED;
553 static int dlmallopt(int, int) MAYBE_UNUSED;
554 static size_t dlmalloc_footprint(void) MAYBE_UNUSED;
555 static size_t dlmalloc_max_footprint(void) MAYBE_UNUSED;
556 static void** dlindependent_calloc(size_t, size_t, void**) MAYBE_UNUSED;
557 static void** dlindependent_comalloc(size_t, size_t*, void**) MAYBE_UNUSED;
558 static void *dlpvalloc(size_t) MAYBE_UNUSED;
559 static int dlmalloc_trim(size_t) MAYBE_UNUSED;
560 static size_t dlmalloc_usable_size(void*) MAYBE_UNUSED;
561 static void dlmalloc_stats(void) MAYBE_UNUSED;
562
563 #if !(defined(_WIN32) || defined(__OS2__)) || defined (__CYGWIN__) || defined(__INTERIX)
564 /* Use these for mmap and munmap within dlmalloc.c. */
565 static void *dlmmap(void *, size_t, int, int, int, off_t);
566 static int dlmunmap(void *, size_t);
567 #endif /* !(defined(_WIN32) || defined(__OS2__)) || defined (__CYGWIN__) || defined(__INTERIX) */
568
569 #define mmap dlmmap
570 #define munmap dlmunmap
571
572 #include "dlmalloc.c"
573
574 #undef mmap
575 #undef munmap
576
577 #if !(defined(_WIN32) || defined(__OS2__)) || defined (__CYGWIN__) || defined(__INTERIX)
578
579 /* A mutex used to synchronize access to *exec* variables in this file. */
580 static pthread_mutex_t open_temp_exec_file_mutex = PTHREAD_MUTEX_INITIALIZER;
581
582 /* A file descriptor of a temporary file from which we'll map
583 executable pages. */
584 static int execfd = -1;
585
586 /* The amount of space already allocated from the temporary file. */
587 static size_t execsize = 0;
588
589 #ifdef HAVE_MEMFD_CREATE
590 /* Open a temporary file name, and immediately unlink it. */
591 static int
592 open_temp_exec_file_memfd (const char *name)
593 {
594 int fd;
595 fd = memfd_create (name, MFD_CLOEXEC);
596 return fd;
597 }
598 #endif
599
600 /* Open a temporary file name, and immediately unlink it. */
601 static int
602 open_temp_exec_file_name (char *name, int flags MAYBE_UNUSED)
603 {
604 int fd;
605
606 #ifdef HAVE_MKOSTEMP
607 fd = mkostemp (name, flags);
608 #else
609 fd = mkstemp (name);
610 #endif
611
612 if (fd != -1)
613 unlink (name);
614
615 return fd;
616 }
617
618 /* Open a temporary file in the named directory. */
619 static int
620 open_temp_exec_file_dir (const char *dir)
621 {
622 static const char suffix[] = "/ffiXXXXXX";
623 int lendir, flags;
624 char *tempname;
625 #ifdef O_TMPFILE
626 int fd;
627 #endif
628
629 #ifdef O_CLOEXEC
630 flags = O_CLOEXEC;
631 #else
632 flags = 0;
633 #endif
634
635 #ifdef O_TMPFILE
636 fd = open (dir, flags | O_RDWR | O_EXCL | O_TMPFILE, 0700);
637 /* If the running system does not support the O_TMPFILE flag then retry without it. */
638 if (fd != -1 || (errno != EINVAL && errno != EISDIR && errno != EOPNOTSUPP)) {
639 return fd;
640 } else {
641 errno = 0;
642 }
643 #endif
644
645 lendir = (int) strlen (dir);
646 tempname = __builtin_alloca (lendir + sizeof (suffix));
647
648 if (!tempname)
649 return -1;
650
651 memcpy (tempname, dir, lendir);
652 memcpy (tempname + lendir, suffix, sizeof (suffix));
653
654 return open_temp_exec_file_name (tempname, flags);
655 }
656
657 /* Open a temporary file in the directory in the named environment
658 variable. */
659 static int
660 open_temp_exec_file_env (const char *envvar)
661 {
662 const char *value = getenv (envvar);
663
664 if (!value)
665 return -1;
666
667 return open_temp_exec_file_dir (value);
668 }
669
670 #ifdef HAVE_MNTENT
671 /* Open a temporary file in an executable and writable mount point
672 listed in the mounts file. Subsequent calls with the same mounts
673 keep searching for mount points in the same file. Providing NULL
674 as the mounts file closes the file. */
675 static int
676 open_temp_exec_file_mnt (const char *mounts)
677 {
678 static const char *last_mounts;
679 static FILE *last_mntent;
680
681 if (mounts != last_mounts)
682 {
683 if (last_mntent)
684 endmntent (last_mntent);
685
686 last_mounts = mounts;
687
688 if (mounts)
689 last_mntent = setmntent (mounts, "r");
690 else
691 last_mntent = NULL;
692 }
693
694 if (!last_mntent)
695 return -1;
696
697 for (;;)
698 {
699 int fd;
700 struct mntent mnt;
701 char buf[MAXPATHLEN * 3];
702
703 if (getmntent_r (last_mntent, &mnt, buf, sizeof (buf)) == NULL)
704 return -1;
705
706 if (hasmntopt (&mnt, "ro")
707 || hasmntopt (&mnt, "noexec")
708 || access (mnt.mnt_dir, W_OK))
709 continue;
710
711 fd = open_temp_exec_file_dir (mnt.mnt_dir);
712
713 if (fd != -1)
714 return fd;
715 }
716 }
717 #endif /* HAVE_MNTENT */
718
719 /* Instructions to look for a location to hold a temporary file that
720 can be mapped in for execution. */
721 static struct
722 {
723 int (*func)(const char *);
724 const char *arg;
725 int repeat;
726 } open_temp_exec_file_opts[] = {
727 #ifdef HAVE_MEMFD_CREATE
728 { open_temp_exec_file_memfd, "libffi", 0 },
729 #endif
730 { open_temp_exec_file_env, "LIBFFI_TMPDIR", 0 },
731 { open_temp_exec_file_env, "TMPDIR", 0 },
732 { open_temp_exec_file_dir, "/tmp", 0 },
733 { open_temp_exec_file_dir, "/var/tmp", 0 },
734 { open_temp_exec_file_dir, "/dev/shm", 0 },
735 { open_temp_exec_file_env, "HOME", 0 },
736 #ifdef HAVE_MNTENT
737 { open_temp_exec_file_mnt, "/etc/mtab", 1 },
738 { open_temp_exec_file_mnt, "/proc/mounts", 1 },
739 #endif /* HAVE_MNTENT */
740 };
741
742 /* Current index into open_temp_exec_file_opts. */
743 static int open_temp_exec_file_opts_idx = 0;
744
745 /* Reset a current multi-call func, then advances to the next entry.
746 If we're at the last, go back to the first and return nonzero,
747 otherwise return zero. */
748 static int
749 open_temp_exec_file_opts_next (void)
750 {
751 if (open_temp_exec_file_opts[open_temp_exec_file_opts_idx].repeat)
752 open_temp_exec_file_opts[open_temp_exec_file_opts_idx].func (NULL);
753
754 open_temp_exec_file_opts_idx++;
755 if (open_temp_exec_file_opts_idx
756 == (sizeof (open_temp_exec_file_opts)
757 / sizeof (*open_temp_exec_file_opts)))
758 {
759 open_temp_exec_file_opts_idx = 0;
760 return 1;
761 }
762
763 return 0;
764 }
765
766 /* Return a file descriptor of a temporary zero-sized file in a
767 writable and executable filesystem. */
768 int
769 open_temp_exec_file (void)
770 {
771 int fd;
772
773 do
774 {
775 fd = open_temp_exec_file_opts[open_temp_exec_file_opts_idx].func
776 (open_temp_exec_file_opts[open_temp_exec_file_opts_idx].arg);
777
778 if (!open_temp_exec_file_opts[open_temp_exec_file_opts_idx].repeat
779 || fd == -1)
780 {
781 if (open_temp_exec_file_opts_next ())
782 break;
783 }
784 }
785 while (fd == -1);
786
787 return fd;
788 }
789
790 /* We need to allocate space in a file that will be backing a writable
791 mapping. Several problems exist with the usual approaches:
792 - fallocate() is Linux-only
793 - posix_fallocate() is not available on all platforms
794 - ftruncate() does not allocate space on filesystems with sparse files
795 Failure to allocate the space will cause SIGBUS to be thrown when
796 the mapping is subsequently written to. */
797 static int
798 allocate_space (int fd, off_t len)
799 {
800 static long page_size;
801
802 /* Obtain system page size. */
803 if (!page_size)
804 page_size = sysconf(_SC_PAGESIZE);
805
806 unsigned char buf[page_size];
807 memset (buf, 0, page_size);
808
809 while (len > 0)
810 {
811 off_t to_write = (len < page_size) ? len : page_size;
812 if (write (fd, buf, to_write) < to_write)
813 return -1;
814 len -= to_write;
815 }
816
817 return 0;
818 }
819
820 /* Map in a chunk of memory from the temporary exec file into separate
821 locations in the virtual memory address space, one writable and one
822 executable. Returns the address of the writable portion, after
823 storing an offset to the corresponding executable portion at the
824 last word of the requested chunk. */
825 static void *
826 dlmmap_locked (void *start, size_t length, int prot, int flags, off_t offset)
827 {
828 void *ptr;
829
830 if (execfd == -1)
831 {
832 open_temp_exec_file_opts_idx = 0;
833 retry_open:
834 execfd = open_temp_exec_file ();
835 if (execfd == -1)
836 return MFAIL;
837 }
838
839 offset = execsize;
840
841 if (allocate_space (execfd, length))
842 return MFAIL;
843
844 flags &= ~(MAP_PRIVATE | MAP_ANONYMOUS);
845 flags |= MAP_SHARED;
846
847 ptr = mmap (NULL, length, (prot & ~PROT_WRITE) | PROT_EXEC,
848 flags, execfd, offset);
849 if (ptr == MFAIL)
850 {
851 if (!offset)
852 {
853 close (execfd);
854 goto retry_open;
855 }
856 if (ftruncate (execfd, offset) != 0)
857 {
858 /* Fixme : Error logs can be added here. Returning an error for
859 * ftruncte() will not add any advantage as it is being
860 * validating in the error case. */
861 }
862
863 return MFAIL;
864 }
865 else if (!offset
866 && open_temp_exec_file_opts[open_temp_exec_file_opts_idx].repeat)
867 open_temp_exec_file_opts_next ();
868
869 start = mmap (start, length, prot, flags, execfd, offset);
870
871 if (start == MFAIL)
872 {
873 munmap (ptr, length);
874 if (ftruncate (execfd, offset) != 0)
875 {
876 /* Fixme : Error logs can be added here. Returning an error for
877 * ftruncte() will not add any advantage as it is being
878 * validating in the error case. */
879 }
880 return start;
881 }
882
883 mmap_exec_offset ((char *)start, length) = (char*)ptr - (char*)start;
884
885 execsize += length;
886
887 return start;
888 }
889
890 /* Map in a writable and executable chunk of memory if possible.
891 Failing that, fall back to dlmmap_locked. */
892 static void *
893 dlmmap (void *start, size_t length, int prot,
894 int flags, int fd, off_t offset)
895 {
896 void *ptr;
897
898 assert (start == NULL && length % malloc_getpagesize == 0
899 && prot == (PROT_READ | PROT_WRITE)
900 && flags == (MAP_PRIVATE | MAP_ANONYMOUS)
901 && fd == -1 && offset == 0);
902
903 if (execfd == -1 && ffi_tramp_is_supported ())
904 {
905 ptr = mmap (start, length, prot & ~PROT_EXEC, flags, fd, offset);
906 return ptr;
907 }
908
909 /* -1 != execfd hints that we already decided to use dlmmap_locked
910 last time. */
911 if (execfd == -1 && is_mprotect_enabled ())
912 {
913 #ifdef FFI_MMAP_EXEC_EMUTRAMP_PAX
914 if (is_emutramp_enabled ())
915 {
916 /* emutramp requires the kernel recognizing the trampoline pattern
917 generated by ffi_prep_closure_loc; there is no way to test
918 in advance whether this will work, so this is experimental. */
919 ptr = mmap (start, length, prot & ~PROT_EXEC, flags, fd, offset);
920 return ptr;
921 }
922 #endif
923 /* fallback to dlmmap_locked. */
924 }
925 else if (execfd == -1 && !is_selinux_enabled ())
926 {
927 ptr = mmap (start, length, prot | PROT_EXEC, flags, fd, offset);
928
929 if (ptr != MFAIL || (errno != EPERM && errno != EACCES))
930 /* Cool, no need to mess with separate segments. */
931 return ptr;
932
933 /* If MREMAP_DUP is ever introduced and implemented, try mmap
934 with ((prot & ~PROT_WRITE) | PROT_EXEC) and mremap with
935 MREMAP_DUP and prot at this point. */
936 }
937
938 pthread_mutex_lock (&open_temp_exec_file_mutex);
939 ptr = dlmmap_locked (start, length, prot, flags, offset);
940 pthread_mutex_unlock (&open_temp_exec_file_mutex);
941
942 return ptr;
943 }
944
945 /* Release memory at the given address, as well as the corresponding
946 executable page if it's separate. */
947 static int
948 dlmunmap (void *start, size_t length)
949 {
950 /* We don't bother decreasing execsize or truncating the file, since
951 we can't quite tell whether we're unmapping the end of the file.
952 We don't expect frequent deallocation anyway. If we did, we
953 could locate pages in the file by writing to the pages being
954 deallocated and checking that the file contents change.
955 Yuck. */
956 msegmentptr seg = segment_holding (gm, start);
957 void *code;
958
959 if (seg && (code = add_segment_exec_offset (start, seg)) != start)
960 {
961 int ret = munmap (code, length);
962 if (ret)
963 return ret;
964 }
965
966 return munmap (start, length);
967 }
968
969 #if FFI_CLOSURE_FREE_CODE
970 /* Return segment holding given code address. */
971 static msegmentptr
972 segment_holding_code (mstate m, char* addr)
973 {
974 msegmentptr sp = &m->seg;
975 for (;;) {
976 if (addr >= add_segment_exec_offset (sp->base, sp)
977 && addr < add_segment_exec_offset (sp->base, sp) + sp->size)
978 return sp;
979 if ((sp = sp->next) == 0)
980 return 0;
981 }
982 }
983 #endif
984
985 #endif /* !(defined(_WIN32) || defined(__OS2__)) || defined (__CYGWIN__) || defined(__INTERIX) */
986
987 /* Allocate a chunk of memory with the given size. Returns a pointer
988 to the writable address, and sets *CODE to the executable
989 corresponding virtual address. */
990 void *
991 ffi_closure_alloc (size_t size, void **code)
992 {
993 void *ptr, *ftramp;
994
995 if (!code)
996 return NULL;
997
998 ptr = dlmalloc (size);
999
1000 if (ptr)
1001 {
1002 msegmentptr seg = segment_holding (gm, ptr);
1003
1004 *code = FFI_FN (add_segment_exec_offset (ptr, seg));
1005 if (!ffi_tramp_is_supported ())
1006 return ptr;
1007
1008 ftramp = ffi_tramp_alloc (0);
1009 if (ftramp == NULL)
1010 {
1011 dlfree (ptr);
1012 return NULL;
1013 }
1014 *code = FFI_FN (ffi_tramp_get_addr (ftramp));
1015 ((ffi_closure *) ptr)->ftramp = ftramp;
1016 }
1017
1018 return ptr;
1019 }
1020
1021 void *
1022 ffi_data_to_code_pointer (void *data)
1023 {
1024 msegmentptr seg = segment_holding (gm, data);
1025 /* We expect closures to be allocated with ffi_closure_alloc(), in
1026 which case seg will be non-NULL. However, some users take on the
1027 burden of managing this memory themselves, in which case this
1028 we'll just return data. */
1029 if (seg)
1030 {
1031 if (!ffi_tramp_is_supported ())
1032 return add_segment_exec_offset (data, seg);
1033 return ffi_tramp_get_addr (((ffi_closure *) data)->ftramp);
1034 }
1035 else
1036 return data;
1037 }
1038
1039 /* Release a chunk of memory allocated with ffi_closure_alloc. If
1040 FFI_CLOSURE_FREE_CODE is nonzero, the given address can be the
1041 writable or the executable address given. Otherwise, only the
1042 writable address can be provided here. */
1043 void
1044 ffi_closure_free (void *ptr)
1045 {
1046 #if FFI_CLOSURE_FREE_CODE
1047 msegmentptr seg = segment_holding_code (gm, ptr);
1048
1049 if (seg)
1050 ptr = sub_segment_exec_offset (ptr, seg);
1051 #endif
1052 if (ffi_tramp_is_supported ())
1053 ffi_tramp_free (((ffi_closure *) ptr)->ftramp);
1054
1055 dlfree (ptr);
1056 }
1057
1058 int
1059 ffi_tramp_is_present (void *ptr)
1060 {
1061 msegmentptr seg = segment_holding (gm, ptr);
1062 return seg != NULL && ffi_tramp_is_supported();
1063 }
1064
1065 # else /* ! FFI_MMAP_EXEC_WRIT */
1066
1067 /* On many systems, memory returned by malloc is writable and
1068 executable, so just use it. */
1069
1070 #include <stdlib.h>
1071
1072 void *
1073 ffi_closure_alloc (size_t size, void **code)
1074 {
1075 void *c;
1076
1077 if (!code)
1078 return NULL;
1079
1080 c = malloc (size);
1081 *code = FFI_FN (c);
1082 return c;
1083 }
1084
1085 void
1086 ffi_closure_free (void *ptr)
1087 {
1088 free (ptr);
1089 }
1090
1091 void *
1092 ffi_data_to_code_pointer (void *data)
1093 {
1094 return data;
1095 }
1096
1097 int
1098 ffi_tramp_is_present (__attribute__((unused)) void *ptr)
1099 {
1100 return 0;
1101 }
1102
1103 # endif /* ! FFI_MMAP_EXEC_WRIT */
1104 #endif /* FFI_CLOSURES */
1105
1106 #endif /* NetBSD with PROT_MPROTECT */
1107 #endif /* __EMSCRIPTEN__ */