mmap memory allocation - do not used when under valgrind

we can't sensibly use things like massif to track memory if we bypass
itr with mmaping -1 fd anonymous memory... so if built with valgrind
support and running under valgrind, use malloc/calloc and free so
these tools actually do something useful for these bits of memory.

3 files changed, 96 insertions, 43 deletions

diff --git a/src/lib/eina/eina_debug_chunk.c b/src/lib/eina/eina_debug_chunk.c
index 36629198a0..4ee9655140 100644
--- a/src/lib/eina/eina_debug_chunk.c
+++ b/src/lib/eina/eina_debug_chunk.c
@@ -24,6 +24,11 @@
 #  include "config.h"
 # endif
 
+#ifdef HAVE_VALGRIND
+# include <valgrind.h>
+# include <memcheck.h>
+#endif
+
 #ifdef HAVE_MMAP
 # include <sys/mman.h>
 
@@ -50,9 +55,15 @@ _eina_debug_chunk_need(int size)
 {
    void *ptr;
 
-   ptr = mmap(NULL, size, PROT_READ | PROT_WRITE,
-              MAP_PRIVATE | MAP_ANON, -1, 0);
-   if (ptr == MAP_FAILED) return NULL;
+#ifdef HAVE_VALGRIND
+   if (RUNNING_ON_VALGRIND) ptr = malloc(size);
+   else
+#endif
+     {
+        ptr = mmap(NULL, size, PROT_READ | PROT_WRITE,
+                   MAP_PRIVATE | MAP_ANON, -1, 0);
+        if (ptr == MAP_FAILED) return NULL;
+     }
    return ptr;
 }
 
@@ -60,7 +71,11 @@ _eina_debug_chunk_need(int size)
 static void
 _eina_debug_chunk_noneed(void *ptr, int size)
 {
-   munmap(ptr, size);
+#ifdef HAVE_VALGRIND
+   if (RUNNING_ON_VALGRIND) free(ptr);
+   else
+#endif
+     munmap(ptr, size);
 }
 
 // push a new bit of mem on our growing stack of mem - given our workload,
diff --git a/src/lib/eina/eina_evlog.c b/src/lib/eina/eina_evlog.c
index 9c9cbccdaf..3e5f3c55f2 100644
--- a/src/lib/eina/eina_evlog.c
+++ b/src/lib/eina/eina_evlog.c
@@ -20,6 +20,11 @@
 # include "config.h"
 #endif
 
+#ifdef HAVE_VALGRIND
+# include <valgrind.h>
+# include <memcheck.h>
+#endif
+
 #include "Eina.h"
 #include "eina_evlog.h"
 #include "eina_debug.h"
@@ -97,13 +102,19 @@ alloc_buf(Eina_Evlog_Buf *b, unsigned int size)
    if (b->buf) return;
    b->size = size;
    b->top = 0;
-# ifdef HAVE_MMAP
-   b->buf = mmap(NULL, size, PROT_READ | PROT_WRITE,
-                 MAP_PRIVATE | MAP_ANON, -1, 0);
-   if (b->buf == MAP_FAILED) b->buf = NULL;
-# else
-   b->buf = malloc(size);
+#ifdef HAVE_MMAP
+# ifdef HAVE_VALGRIND
+   if (RUNNING_ON_VALGRIND) b->buf = malloc(size);
+   else
 # endif
+     {
+        b->buf = mmap(NULL, size, PROT_READ | PROT_WRITE,
+                      MAP_PRIVATE | MAP_ANON, -1, 0);
+        if (b->buf == MAP_FAILED) b->buf = NULL;
+     }
+#else
+   b->buf = malloc(size);
+#endif
    b->overflow = 0;
 }
 
@@ -111,11 +122,15 @@ static void
 free_buf(Eina_Evlog_Buf *b)
 {
    if (!b->buf) return;
-# ifdef HAVE_MMAP
+#ifdef HAVE_MMAP
+# ifdef HAVE_VALGRIND
+   if (RUNNING_ON_VALGRIND) free(b->buf);
+   else
+# endif
    munmap(b->buf, b->size);
-# else
+#else
    free(b->buf);
-# endif
+#endif
    b->buf = NULL;
    b->size = 0;
    b->top = 0;
diff --git a/src/lib/eina/eina_safepointer.c b/src/lib/eina/eina_safepointer.c
index 94ec1ab557..1a19f851c7 100644
--- a/src/lib/eina/eina_safepointer.c
+++ b/src/lib/eina/eina_safepointer.c
@@ -2,6 +2,11 @@
 # include "config.h"
 #endif
 
+#ifdef HAVE_VALGRIND
+# include <valgrind.h>
+# include <memcheck.h>
+#endif
+
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -66,26 +71,32 @@ static void *
 _eina_safepointer_calloc(int number, size_t size)
 {
 #ifdef HAVE_MMAP
-   Eina_Memory_Header *header;
-   size_t newsize;
+# ifdef HAVE_VALGRIND
+   if (RUNNING_ON_VALGRIND) return calloc(number, size);
+   else
+# endif
+     {
+        Eina_Memory_Header *header;
+        size_t newsize;
 
-   size = size * number + sizeof (Eina_Memory_Header);
-   newsize = ((size / MEM_PAGE_SIZE) +
-              (size % MEM_PAGE_SIZE ? 1 : 0))
-     * MEM_PAGE_SIZE;
+        size = size * number + sizeof (Eina_Memory_Header);
+        newsize = ((size / MEM_PAGE_SIZE) +
+                   (size % MEM_PAGE_SIZE ? 1 : 0))
+          * MEM_PAGE_SIZE;
 
-   header = mmap(NULL, newsize, PROT_READ | PROT_WRITE,
-                 MAP_PRIVATE | MAP_ANON, -1, 0);
-   if (header == MAP_FAILED)
-     {
-        ERR("mmap of Eina_Safepointer table region failed.");
-        return NULL;
-     }
+        header = mmap(NULL, newsize, PROT_READ | PROT_WRITE,
+                      MAP_PRIVATE | MAP_ANON, -1, 0);
+        if (header == MAP_FAILED)
+          {
+             ERR("mmap of Eina_Safepointer table region failed.");
+             return NULL;
+          }
 
-   header->size = newsize;
-   EINA_MAGIC_SET(header, SAFEPOINTER_MAGIC);
+        header->size = newsize;
+        EINA_MAGIC_SET(header, SAFEPOINTER_MAGIC);
 
-   return (void*)(header + 1);
+        return (void *)(header + 1);
+     }
 #else
    return calloc(number, size);
 #endif
@@ -95,18 +106,24 @@ static void
 _eina_safepointer_free(void *pointer)
 {
 #ifdef HAVE_MMAP
-   Eina_Memory_Header *header;
+# ifdef HAVE_VALGRIND
+   if (RUNNING_ON_VALGRIND) free((void *)((uintptr_t) pointer & ~0x3));
+   else
+# endif
+     {
+        Eina_Memory_Header *header;
 
-   if (!pointer) return ;
+        if (!pointer) return;
 
-   header = (Eina_Memory_Header*)(pointer) - 1;
-   if (!EINA_MAGIC_CHECK(header, SAFEPOINTER_MAGIC))
-     EINA_MAGIC_FAIL(header, SAFEPOINTER_MAGIC);
+        header = (Eina_Memory_Header*)(pointer) - 1;
+        if (!EINA_MAGIC_CHECK(header, SAFEPOINTER_MAGIC))
+          EINA_MAGIC_FAIL(header, SAFEPOINTER_MAGIC);
 
-   EINA_MAGIC_SET(header, 0);
-   munmap(header, header->size);
+        EINA_MAGIC_SET(header, 0);
+        munmap(header, header->size);
+     }
 #else
-   free((void*) ((uintptr_t) pointer & ~0x3));
+   free((void *)((uintptr_t) pointer & ~0x3));
 #endif
 }
 
@@ -115,15 +132,21 @@ static void
 _eina_safepointer_protect(void *pointer, Eina_Bool may_not_write)
 {
 #ifdef HAVE_MMAP
-   Eina_Memory_Header *header;
+# ifdef HAVE_VALGRIND
+   if (RUNNING_ON_VALGRIND) { (void) pointer; }
+   else
+# endif
+     {
+        Eina_Memory_Header *header;
 
-   if (!pointer) return ;
+        if (!pointer) return;
 
-   header = (Eina_Memory_Header*)(pointer) - 1;
-   if (!EINA_MAGIC_CHECK(header, SAFEPOINTER_MAGIC))
-     EINA_MAGIC_FAIL(header, SAFEPOINTER_MAGIC);
+        header = (Eina_Memory_Header*)(pointer) - 1;
+        if (!EINA_MAGIC_CHECK(header, SAFEPOINTER_MAGIC))
+          EINA_MAGIC_FAIL(header, SAFEPOINTER_MAGIC);
 
-   mprotect(header, header->size, PROT_READ | ( may_not_write ? 0 : PROT_WRITE));
+        mprotect(header, header->size, PROT_READ | ( may_not_write ? 0 : PROT_WRITE));
+     }
 #else
    (void) pointer;
 #endif