mono/utils/mono-mmap.c

   1 /**
   2  * \file
   3  * Support for mapping code into the process address space
   4  *
   5  * Author:
   6  *   Mono Team (mono-list@lists.ximian.com)
   7  *
   8  * Copyright 2001-2008 Novell, Inc.
   9  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  10  */
  11
  12 #include <config.h>
  13
  14 #ifndef HOST_WIN32
  15 #include <sys/types.h>
  16 #if HAVE_SYS_STAT_H
  17 #include <sys/stat.h>
  18 #endif
  19 #if HAVE_SYS_MMAN_H
  20 #include <sys/mman.h>
  21 #endif
  22 #ifdef HAVE_SYS_SYSCTL_H
  23 #include <sys/sysctl.h>
  24 #endif
  25 #ifdef HAVE_SIGNAL_H
  26 #include <signal.h>
  27 #endif
  28 #include <fcntl.h>
  29 #include <string.h>
  30 #include <unistd.h>
  31 #include <stdlib.h>
  32 #include <errno.h>
  33 #endif /* !HOST_WIN32 */
  34
  35 #include "mono-mmap.h"
  36 #include "mono-mmap-internals.h"
  37 #include "mono-proclib.h"
  38 #include <mono/utils/mono-threads.h>
  39 #include <mono/utils/atomic.h>
  40 #include <mono/utils/mono-counters.h>
  41
  42 #define BEGIN_CRITICAL_SECTION do { \
  43         MonoThreadInfo *__info = mono_thread_info_current_unchecked (); \
  44         if (__info) __info->inside_critical_region = TRUE;      \
  45
  46 #define END_CRITICAL_SECTION \
  47         if (__info) __info->inside_critical_region = FALSE;     \
  48 } while (0)     \
  49
  50 #ifndef MAP_ANONYMOUS
  51 #define MAP_ANONYMOUS MAP_ANON
  52 #endif
  53
  54 #ifndef MAP_32BIT
  55 #define MAP_32BIT 0
  56 #endif
  57
  58 typedef struct {
  59         int size;
  60         int pid;
  61         int reserved;
  62         short stats_start;
  63         short stats_end;
  64 } SAreaHeader;
  65
  66 void*
  67 mono_malloc_shared_area (int pid)
  68 {
  69         int size = mono_pagesize ();
  70         SAreaHeader *sarea = (SAreaHeader *) g_malloc0 (size);
  71         sarea->size = size;
  72         sarea->pid = pid;
  73         sarea->stats_start = sizeof (SAreaHeader);
  74         sarea->stats_end = sizeof (SAreaHeader);
  75
  76         return sarea;
  77 }
  78
  79 char*
  80 mono_aligned_address (char *mem, size_t size, size_t alignment)
  81 {
  82         char *aligned = (char*)((size_t)(mem + (alignment - 1)) & ~(alignment - 1));
  83         g_assert (aligned >= mem && aligned + size <= mem + size + alignment && !((size_t)aligned & (alignment - 1)));
  84         return aligned;
  85 }
  86
  87 static size_t allocation_count [MONO_MEM_ACCOUNT_MAX];
  88 static size_t total_allocation_count;
  89 static size_t alloc_limit;
  90
  91 void
  92 mono_account_mem (MonoMemAccountType type, ssize_t size)
  93 {
  94         mono_atomic_fetch_add_word (&allocation_count [type], size);
  95         mono_atomic_fetch_add_word (&total_allocation_count, size);
  96 }
  97
  98 void
  99 mono_valloc_set_limit (size_t size)
 100 {
 101         alloc_limit = size;
 102 }
 103
 104 gboolean
 105 mono_valloc_can_alloc (size_t size)
 106 {
 107         if (alloc_limit)
 108                 return (total_allocation_count + size) < alloc_limit;
 109         return TRUE;
 110 }
 111
 112 const char*
 113 mono_mem_account_type_name (MonoMemAccountType type)
 114 {
 115         static const char *names[] = {
 116                 "code",
 117                 "hazard pointers",
 118                 "domain",
 119                 "SGen internal",
 120                 "SGen nursery",
 121                 "SGen LOS",
 122                 "SGen mark&sweep",
 123                 "SGen card table",
 124                 "SGen shadow card table",
 125                 "SGen debugging",
 126                 "SGen binary protocol",
 127                 "exceptions",
 128                 "profiler",
 129                 "other"
 130         };
 131
 132         return names [type];
 133 }
 134
 135 void
 136 mono_mem_account_register_counters (void)
 137 {
 138         for (int i = 0; i < MONO_MEM_ACCOUNT_MAX; ++i) {
 139                 const char *prefix = "Valloc ";
 140                 const char *name = mono_mem_account_type_name ((MonoMemAccountType)i);
 141                 char descr [128];
 142                 g_assert (strlen (prefix) + strlen (name) < sizeof (descr));
 143                 sprintf (descr, "%s%s", prefix, name);
 144                 mono_counters_register (descr, MONO_COUNTER_WORD | MONO_COUNTER_RUNTIME | MONO_COUNTER_BYTES | MONO_COUNTER_VARIABLE, (void*)&allocation_count [i]);
 145         }
 146 }
 147
 148 #ifdef HOST_WIN32
 149 // Windows specific implementation in mono-mmap-windows.c
 150 #define HAVE_VALLOC_ALIGNED
 151
 152 #elif defined(HOST_WASM)
 153 // WebAssembly implementation in mono-mmap-wasm.c
 154 #define HAVE_VALLOC_ALIGNED
 155
 156 #else
 157
 158 static void* malloced_shared_area = NULL;
 159 #if defined(HAVE_MMAP)
 160
 161 /**
 162  * mono_pagesize:
 163  * Get the page size in use on the system. Addresses and sizes in the
 164  * mono_mmap(), mono_munmap() and mono_mprotect() calls must be pagesize
 165  * aligned.
 166  *
 167  * Returns: the page size in bytes.
 168  */
 169 int
 170 mono_pagesize (void)
 171 {
 172         static int saved_pagesize = 0;
 173
 174         if (saved_pagesize)
 175                 return saved_pagesize;
 176
 177         // Prefer sysconf () as it's signal safe.
 178 #if defined (HAVE_SYSCONF) && defined (_SC_PAGESIZE)
 179         saved_pagesize = sysconf (_SC_PAGESIZE);
 180 #else
 181         saved_pagesize = getpagesize ();
 182 #endif
 183
 184
 185         // While this could not happen in any of the Mono supported
 186         // systems, this ensures this function never returns -1, and
 187         // reduces the number of false positives
 188         // that Coverity finds in consumer code.
 189
 190         if (saved_pagesize == -1)
 191                 return 64*1024;
 192
 193         return saved_pagesize;
 194 }
 195
 196 int
 197 mono_valloc_granule (void)
 198 {
 199         return mono_pagesize ();
 200 }
 201
 202 static int
 203 prot_from_flags (int flags)
 204 {
 205         int prot = PROT_NONE;
 206         /* translate the protection bits */
 207         if (flags & MONO_MMAP_READ)
 208                 prot |= PROT_READ;
 209         if (flags & MONO_MMAP_WRITE)
 210                 prot |= PROT_WRITE;
 211         if (flags & MONO_MMAP_EXEC)
 212                 prot |= PROT_EXEC;
 213         return prot;
 214 }
 215
 216 #if defined(__APPLE__)
 217
 218 #define DARWIN_VERSION_MOJAVE 18
 219
 220 static guint32
 221 get_darwin_version (void)
 222 {
 223         static guint32 version;
 224
 225         /* This doesn't need locking */
 226         if (!version) {
 227                 char str[256] = {0};
 228                 size_t size = sizeof(str);
 229                 int err = sysctlbyname("kern.osrelease", str, &size, NULL, 0);
 230                 g_assert (err == 0);
 231                 err = sscanf (str, "%d", &version);
 232                 g_assert (err == 1);
 233                 g_assert (version > 0);
 234         }
 235         return version;
 236 }
 237 #endif
 238
 239 static int use_mmap_jit;
 240
 241 /**
 242  * mono_setmmapjit:
 243  * \param flag indicating whether to enable or disable the use of MAP_JIT in mmap
 244  *
 245  * Call this method to enable or disable the use of MAP_JIT to create the pages
 246  * for the JIT to use.   This is only needed for scenarios where Mono is bundled
 247  * as an App in MacOS
 248  */
 249 void
 250 mono_setmmapjit (int flag)
 251 {
 252         use_mmap_jit = flag;
 253 }
 254
 255 /**
 256  * mono_valloc:
 257  * \param addr memory address
 258  * \param length memory area size
 259  * \param flags protection flags
 260  * Allocates \p length bytes of virtual memory with the \p flags
 261  * protection. \p addr can be a preferred memory address or a
 262  * mandatory one if MONO_MMAP_FIXED is set in \p flags.
 263  * \p addr must be pagesize aligned and can be NULL.
 264  * \p length must be a multiple of pagesize.
 265  * \returns NULL on failure, the address of the memory area otherwise
 266  */
 267 void*
 268 mono_valloc (void *addr, size_t length, int flags, MonoMemAccountType type)
 269 {
 270         void *ptr;
 271         int mflags = 0;
 272         int prot = prot_from_flags (flags);
 273
 274         if (!mono_valloc_can_alloc (length))
 275                 return NULL;
 276
 277         /* translate the flags */
 278         if (flags & MONO_MMAP_FIXED)
 279                 mflags |= MAP_FIXED;
 280         if (flags & MONO_MMAP_32BIT)
 281                 mflags |= MAP_32BIT;
 282
 283 #ifdef HOST_WASM
 284         if (length == 0)
 285                 /* emscripten throws an exception on 0 length */
 286                 return NULL;
 287 #endif
 288
 289 #if defined(__APPLE__) && defined(MAP_JIT)
 290         if (get_darwin_version () >= DARWIN_VERSION_MOJAVE) {
 291                 /* Check for hardened runtime */
 292                 static int is_hardened_runtime;
 293
 294                 if (is_hardened_runtime == 0 && !use_mmap_jit) {
 295                         ptr = mmap (NULL, getpagesize (), PROT_WRITE|PROT_EXEC, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
 296                         if (ptr == MAP_FAILED) {
 297                                 is_hardened_runtime = 1;
 298                         } else {
 299                                 is_hardened_runtime = 2;
 300                                 munmap (ptr, getpagesize ());
 301                         }
 302                 }
 303                 if ((flags & MONO_MMAP_JIT) && (use_mmap_jit || is_hardened_runtime == 1))
 304                         mflags |= MAP_JIT;
 305         }
 306 #endif
 307
 308         mflags |= MAP_ANONYMOUS;
 309         mflags |= MAP_PRIVATE;
 310
 311         BEGIN_CRITICAL_SECTION;
 312         ptr = mmap (addr, length, prot, mflags, -1, 0);
 313         if (ptr == MAP_FAILED) {
 314                 int fd = open ("/dev/zero", O_RDONLY);
 315                 if (fd != -1) {
 316                         ptr = mmap (addr, length, prot, mflags, fd, 0);
 317                         close (fd);
 318                 }
 319         }
 320         END_CRITICAL_SECTION;
 321
 322         if (ptr == MAP_FAILED)
 323                 return NULL;
 324
 325         mono_account_mem (type, (ssize_t)length);
 326
 327         return ptr;
 328 }
 329
 330 /**
 331  * mono_vfree:
 332  * \param addr memory address returned by mono_valloc ()
 333  * \param length size of memory area
 334  * Remove the memory mapping at the address \p addr.
 335  * \returns \c 0 on success.
 336  */
 337 int
 338 mono_vfree (void *addr, size_t length, MonoMemAccountType type)
 339 {
 340         int res;
 341         BEGIN_CRITICAL_SECTION;
 342         res = munmap (addr, length);
 343         END_CRITICAL_SECTION;
 344
 345         mono_account_mem (type, -(ssize_t)length);
 346
 347         return res;
 348 }
 349
 350 /**
 351  * mono_file_map:
 352  * \param length size of data to map
 353  * \param flags protection flags
 354  * \param fd file descriptor
 355  * \param offset offset in the file
 356  * \param ret_handle pointer to storage for returning a handle for the map
 357  * Map the area of the file pointed to by the file descriptor \p fd, at offset
 358  * \p offset and of size \p length in memory according to the protection flags
 359  * \p flags.
 360  * \p offset and \p length must be multiples of the page size.
 361  * \p ret_handle must point to a void*: this value must be used when unmapping
 362  * the memory area using \c mono_file_unmap().
 363  */
 364 void*
 365 mono_file_map (size_t length, int flags, int fd, guint64 offset, void **ret_handle)
 366 {
 367         return mono_file_map_error (length, flags, fd, offset, ret_handle, NULL, NULL);
 368 }
 369
 370 void*
 371 mono_file_map_error (size_t length, int flags, int fd, guint64 offset, void **ret_handle,
 372         const char *filepath, char **error_message)
 373 {
 374         void *ptr;
 375         int mflags = 0;
 376         int prot = prot_from_flags (flags);
 377         /* translate the flags */
 378         if (flags & MONO_MMAP_PRIVATE)
 379                 mflags |= MAP_PRIVATE;
 380         if (flags & MONO_MMAP_SHARED)
 381                 mflags |= MAP_SHARED;
 382         if (flags & MONO_MMAP_FIXED)
 383                 mflags |= MAP_FIXED;
 384         if (flags & MONO_MMAP_32BIT)
 385                 mflags |= MAP_32BIT;
 386
 387 #ifdef HOST_WASM
 388         if (length == 0)
 389                 /* emscripten throws an exception on 0 length */
 390                 *error_message = g_stdrup_printf ("%s failed file:%s length:0x%zx offset:0x%lluX error:%s\n",
 391                         __func__, filepath ? filepath : "", length, offset, "mmaps of zero length are not permitted with emscripten");
 392                 return NULL;
 393 #endif
 394
 395         // No GC safe transition because this is called early in main.c
 396         BEGIN_CRITICAL_SECTION;
 397         ptr = mmap (0, length, prot, mflags, fd, offset);
 398         END_CRITICAL_SECTION;
 399         if (ptr == MAP_FAILED) {
 400                 if (error_message) {
 401                         *error_message = g_strdup_printf ("%s failed file:%s length:0x%zX offset:0x%lluX error:%s(0x%X)\n",
 402                                 __func__, filepath ? filepath : "", length, offset, g_strerror (errno), errno);
 403                 }
 404                 return NULL;
 405         }
 406         *ret_handle = (void*)length;
 407         return ptr;
 408 }
 409
 410 /**
 411  * mono_file_unmap:
 412  * \param addr memory address returned by mono_file_map ()
 413  * \param handle handle of memory map
 414  * Remove the memory mapping at the address \p addr.
 415  * \p handle must be the value returned in ret_handle by \c mono_file_map().
 416  * \returns \c 0 on success.
 417  */
 418 int
 419 mono_file_unmap (void *addr, void *handle)
 420 {
 421         int res;
 422
 423         // No GC safe transition because this is called early in driver.c via mono_debug_init (with a few layers of indirection)
 424         BEGIN_CRITICAL_SECTION;
 425         res = munmap (addr, (size_t)handle);
 426         END_CRITICAL_SECTION;
 427
 428         return res;
 429 }
 430
 431 /**
 432  * mono_mprotect:
 433  * \param addr memory address
 434  * \param length size of memory area
 435  * \param flags new protection flags
 436  * Change the protection for the memory area at \p addr for \p length bytes
 437  * to matche the supplied \p flags.
 438  * If \p flags includes MON_MMAP_DISCARD the pages are discarded from memory
 439  * and the area is cleared to zero.
 440  * \p addr must be aligned to the page size.
 441  * \p length must be a multiple of the page size.
 442  * \returns \c 0 on success.
 443  */
 444 int
 445 mono_mprotect (void *addr, size_t length, int flags)
 446 {
 447         int prot = prot_from_flags (flags);
 448
 449         if (flags & MONO_MMAP_DISCARD) {
 450                 /* on non-linux the pages are not guaranteed to be zeroed (*bsd, osx at least) */
 451 #ifdef __linux__
 452                 if (madvise (addr, length, MADV_DONTNEED))
 453                         memset (addr, 0, length);
 454 #else
 455                 memset (addr, 0, length);
 456 /* some OSes (like AIX) have madvise but no MADV_FREE */
 457 #if defined(HAVE_MADVISE) && defined(MADV_FREE)
 458                 madvise (addr, length, MADV_DONTNEED);
 459                 madvise (addr, length, MADV_FREE);
 460 #else
 461                 posix_madvise (addr, length, POSIX_MADV_DONTNEED);
 462 #endif
 463 #endif
 464         }
 465         // No GC safe transition because this is called early in mini_init via mono_arch_init (with a few layers of indirection)
 466         return mprotect (addr, length, prot);
 467 }
 468
 469 #else
 470
 471 /* dummy malloc-based implementation */
 472 int
 473 mono_pagesize (void)
 474 {
 475         return 4096;
 476 }
 477
 478 int
 479 mono_valloc_granule (void)
 480 {
 481         return mono_pagesize ();
 482 }
 483
 484 void*
 485 mono_valloc (void *addr, size_t length, int flags, MonoMemAccountType type)
 486 {
 487         g_assert (addr == NULL);
 488         return mono_valloc_aligned (length, mono_pagesize (), flags, type);
 489 }
 490
 491 void*
 492 mono_valloc_aligned (size_t size, size_t alignment, int flags, MonoMemAccountType type)
 493 {
 494         void *res = NULL;
 495         if (posix_memalign (&res, alignment, size))
 496                 return NULL;
 497
 498         memset (res, 0, size);
 499         return res;
 500 }
 501
 502 #define HAVE_VALLOC_ALIGNED
 503
 504 int
 505 mono_vfree (void *addr, size_t length, MonoMemAccountType type)
 506 {
 507         g_free (addr);
 508         return 0;
 509 }
 510
 511 int
 512 mono_mprotect (void *addr, size_t length, int flags)
 513 {
 514         if (flags & MONO_MMAP_DISCARD) {
 515                 memset (addr, 0, length);
 516         }
 517         return 0;
 518 }
 519
 520 #endif // HAVE_MMAP
 521
 522 #if defined(HAVE_SHM_OPEN) && !defined (DISABLE_SHARED_PERFCOUNTERS)
 523
 524 static int use_shared_area;
 525
 526 static gboolean
 527 shared_area_disabled (void)
 528 {
 529         if (!use_shared_area) {
 530                 if (g_hasenv ("MONO_DISABLE_SHARED_AREA"))
 531                         use_shared_area = -1;
 532                 else
 533                         use_shared_area = 1;
 534         }
 535         return use_shared_area == -1;
 536 }
 537
 538 static int
 539 mono_shared_area_instances_slow (void **array, int count, gboolean cleanup)
 540 {
 541         int i, j = 0;
 542         int num;
 543         void *data;
 544         gpointer *processes = mono_process_list (&num);
 545         for (i = 0; i < num; ++i) {
 546                 data = mono_shared_area_for_pid (processes [i]);
 547                 if (!data)
 548                         continue;
 549                 mono_shared_area_unload (data);
 550                 if (!cleanup) {
 551                         if (j < count)
 552                                 array [j++] = processes [i];
 553                         else
 554                                 break;
 555                 }
 556         }
 557         g_free (processes);
 558         return j;
 559 }
 560
 561 static int
 562 mono_shared_area_instances_helper (void **array, int count, gboolean cleanup)
 563 {
 564         const char *name;
 565         int i = 0;
 566         int curpid = getpid ();
 567         GDir *dir = g_dir_open ("/dev/shm/", 0, NULL);
 568         if (!dir)
 569                 return mono_shared_area_instances_slow (array, count, cleanup);
 570         while ((name = g_dir_read_name (dir))) {
 571                 int pid;
 572                 char *nend;
 573                 if (strncmp (name, "mono.", 5))
 574                         continue;
 575                 pid = strtol (name + 5, &nend, 10);
 576                 if (pid <= 0 || nend == name + 5 || *nend)
 577                         continue;
 578                 if (!cleanup) {
 579                         if (i < count)
 580                                 array [i++] = GINT_TO_POINTER (pid);
 581                         else
 582                                 break;
 583                 }
 584                 if (curpid != pid && kill (pid, 0) == -1 && (errno == ESRCH || errno == ENOMEM)) {
 585                         char buf [128];
 586                         g_snprintf (buf, sizeof (buf), "/mono.%d", pid);
 587                         shm_unlink (buf);
 588                 }
 589         }
 590         g_dir_close (dir);
 591         return i;
 592 }
 593
 594 void*
 595 mono_shared_area (void)
 596 {
 597         int fd;
 598         int pid = getpid ();
 599         /* we should allow the user to configure the size */
 600         int size = mono_pagesize ();
 601         char buf [128];
 602         void *res;
 603         SAreaHeader *header;
 604
 605         if (shared_area_disabled ()) {
 606                 if (!malloced_shared_area)
 607                         malloced_shared_area = mono_malloc_shared_area (0);
 608                 /* get the pid here */
 609                 return malloced_shared_area;
 610         }
 611
 612         /* perform cleanup of segments left over from dead processes */
 613         mono_shared_area_instances_helper (NULL, 0, TRUE);
 614
 615         g_snprintf (buf, sizeof (buf), "/mono.%d", pid);
 616
 617         fd = shm_open (buf, O_CREAT|O_EXCL|O_RDWR, S_IRUSR|S_IWUSR|S_IRGRP);
 618         if (fd == -1 && errno == EEXIST) {
 619                 /* leftover */
 620                 shm_unlink (buf);
 621                 fd = shm_open (buf, O_CREAT|O_EXCL|O_RDWR, S_IRUSR|S_IWUSR|S_IRGRP);
 622         }
 623         /* in case of failure we try to return a memory area anyway,
 624          * even if it means the data can't be read by other processes
 625          */
 626         if (fd == -1)
 627                 return mono_malloc_shared_area (pid);
 628         if (ftruncate (fd, size) != 0) {
 629                 shm_unlink (buf);
 630                 close (fd);
 631         }
 632         BEGIN_CRITICAL_SECTION;
 633         res = mmap (NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
 634         END_CRITICAL_SECTION;
 635
 636         if (res == MAP_FAILED) {
 637                 shm_unlink (buf);
 638                 close (fd);
 639                 return mono_malloc_shared_area (pid);
 640         }
 641         /* we don't need the file descriptor anymore */
 642         close (fd);
 643         header = (SAreaHeader *) res;
 644         header->size = size;
 645         header->pid = pid;
 646         header->stats_start = sizeof (SAreaHeader);
 647         header->stats_end = sizeof (SAreaHeader);
 648
 649         mono_atexit (mono_shared_area_remove);
 650         return res;
 651 }
 652
 653 void
 654 mono_shared_area_remove (void)
 655 {
 656         char buf [128];
 657
 658         if (shared_area_disabled ()) {
 659                 if (malloced_shared_area)
 660                         g_free (malloced_shared_area);
 661                 return;
 662         }
 663
 664         g_snprintf (buf, sizeof (buf), "/mono.%d", getpid ());
 665         shm_unlink (buf);
 666         if (malloced_shared_area)
 667                 g_free (malloced_shared_area);
 668 }
 669
 670 void*
 671 mono_shared_area_for_pid (void *pid)
 672 {
 673         int fd;
 674         /* we should allow the user to configure the size */
 675         int size = mono_pagesize ();
 676         char buf [128];
 677         void *res;
 678
 679         if (shared_area_disabled ())
 680                 return NULL;
 681
 682         g_snprintf (buf, sizeof (buf), "/mono.%d", GPOINTER_TO_INT (pid));
 683
 684         fd = shm_open (buf, O_RDONLY, S_IRUSR|S_IRGRP);
 685         if (fd == -1)
 686                 return NULL;
 687         BEGIN_CRITICAL_SECTION;
 688         res = mmap (NULL, size, PROT_READ, MAP_SHARED, fd, 0);
 689         END_CRITICAL_SECTION;
 690
 691         if (res == MAP_FAILED) {
 692                 close (fd);
 693                 return NULL;
 694         }
 695         /* FIXME: validate the area */
 696         /* we don't need the file descriptor anymore */
 697         close (fd);
 698         return res;
 699 }
 700
 701 void
 702 mono_shared_area_unload  (void *area)
 703 {
 704         /* FIXME: currently we load only a page */
 705         BEGIN_CRITICAL_SECTION;
 706         munmap (area, mono_pagesize ());
 707         END_CRITICAL_SECTION;
 708 }
 709
 710 int
 711 mono_shared_area_instances (void **array, int count)
 712 {
 713         return mono_shared_area_instances_helper (array, count, FALSE);
 714 }
 715 #else
 716 void*
 717 mono_shared_area (void)
 718 {
 719         if (!malloced_shared_area)
 720                 malloced_shared_area = mono_malloc_shared_area (getpid ());
 721         /* get the pid here */
 722         return malloced_shared_area;
 723 }
 724
 725 void
 726 mono_shared_area_remove (void)
 727 {
 728         if (malloced_shared_area)
 729                 g_free (malloced_shared_area);
 730         malloced_shared_area = NULL;
 731 }
 732
 733 void*
 734 mono_shared_area_for_pid (void *pid)
 735 {
 736         return NULL;
 737 }
 738
 739 void
 740 mono_shared_area_unload (void *area)
 741 {
 742 }
 743
 744 int
 745 mono_shared_area_instances (void **array, int count)
 746 {
 747         return 0;
 748 }
 749
 750 #endif // HAVE_SHM_OPEN
 751
 752 #endif // HOST_WIN32
 753
 754 #ifndef HAVE_VALLOC_ALIGNED
 755 void*
 756 mono_valloc_aligned (size_t size, size_t alignment, int flags, MonoMemAccountType type)
 757 {
 758         /* Allocate twice the memory to be able to put the block on an aligned address */
 759         char *mem = (char *) mono_valloc (NULL, size + alignment, flags, type);
 760         char *aligned;
 761
 762         if (!mem)
 763                 return NULL;
 764
 765         aligned = mono_aligned_address (mem, size, alignment);
 766
 767         if (aligned > mem)
 768                 mono_vfree (mem, aligned - mem, type);
 769         if (aligned + size < mem + size + alignment)
 770                 mono_vfree (aligned + size, (mem + size + alignment) - (aligned + size), type);
 771
 772         return aligned;
 773 }
 774 #endif