libffi/src/closures.c

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