Changeset 6444e03

Timestamp:

06/02/15 18:23:28 (10 years ago)

Author:

Hal Finkel <hfinkel@…>

Branches:

master

Children:

ed8b809

Parents:

21d3542

git-author:

Hal Finkel <hfinkel@…> (06/02/15 18:23:28)

git-committer:

Hal Finkel <hfinkel@…> (06/02/15 18:23:28)

Message:

working on wrapping mmap, etc.

File:

• memlog.cpp (modified) (9 diffs)

memlog.cpp

@@ -16 +16 @@
 #include <malloc.h>
 #include <execinfo.h>
+#include <sys/mman.h>
 #include <sys/syscall.h>
 #include <sys/time.h>
@@ -52 +53 @@
 
 void *initial_brk = 0;
+
+#ifdef __PIC__
+typedef int (*__real_posix_memalign_t)(void **memptr, size_t alignment,
+                                       size_t size);
+__real_posix_memalign_t __real_posix_memalign = 0;
+#else
+extern "C" {
+extern int __real_posix_memalign(void **memptr, size_t alignment, size_t size);
+}
+#endif
 
 __attribute__((__constructor__))
@@ -248 +259 @@
 extern "C" {
 extern void *__libc_malloc(size_t size);
+extern void *__libc_valloc(size_t size);
 extern void *__libc_realloc(void *ptr, size_t size);
 extern void *__libc_calloc(size_t nmemb, size_t size);
@@ -253 +265 @@
 extern void __libc_free(void *ptr);
 
+extern void *__mmap(void *addr, size_t length, int prot, int flags,
+                    int fd, off_t offset);
+extern void *__mmap64(void *addr, size_t length, int prot, int flags,
+                      int fd, off64_t offset);
+extern int __munmap(void *addr, size_t length);
+
 #ifdef __PIC__
 #define FUNC(x) x
@@ -269 +287 @@
 
   void *ptr = __libc_malloc(size);
-
-  record_malloc(size, ptr, caller);
+  if (ptr)
+    record_malloc(size, ptr, caller);
+
+  in_malloc = 0;
+  return ptr;
+}
+
+void *FUNC(valloc)(size_t size) {
+  const void *caller =
+    __builtin_extract_return_addr(__builtin_return_address(0));
+
+  if (in_malloc)
+    return __libc_valloc(size);
+
+  in_malloc = 1;
+
+  void *ptr = __libc_valloc(size);
+  if (ptr)
+    record_malloc(size, ptr, caller);
 
   in_malloc = 0;
@@ -289 +324 @@
   if (ptr)
     record_free(ptr, caller);
-  record_malloc(size, nptr, caller);
+  if (nptr)
+    record_malloc(size, nptr, caller);
 
   in_malloc = 0;
@@ -307 +343 @@
   void *ptr = __libc_calloc(nmemb, size);
 
-  record_malloc(nmemb*size, ptr, caller);
+  if (ptr)
+    record_malloc(nmemb*size, ptr, caller);
 
   in_malloc = 0;
@@ -325 +362 @@
   void *ptr = __libc_memalign(boundary, size);
 
-  record_malloc(size, ptr, caller);
+  if (ptr)
+    record_malloc(size, ptr, caller);
 
   in_malloc = 0;
@@ -348 +386 @@
 }
 
+int FUNC(posix_memalign)(void **memptr, size_t alignment, size_t size) {
+  const void *caller =
+    __builtin_extract_return_addr(__builtin_return_address(0));
+
+#ifdef __PIC__
+  if (!__real_posix_memalign)
+    if (!(__real_posix_memalign =
+        (__real_posix_memalign_t) dlsym(RTLD_NEXT, "posix_memalign")))
+      return -1;
+#endif
+
+  if (in_malloc)
+    return __real_posix_memalign(memptr, alignment, size);
+
+  in_malloc = 1;
+
+  int r = __real_posix_memalign(memptr, alignment, size);
+
+  if (!r)
+    record_malloc(size, *memptr, caller);
+
+  in_malloc = 0;
+
+  return r;
+}
+
+void *FUNC(mmap)(void *addr, size_t length, int prot, int flags,
+                 int fd, off_t offset) {
+  const void *caller =
+    __builtin_extract_return_addr(__builtin_return_address(0));
+
+  if (in_malloc)
+    return __mmap(addr, length, prot, flags, fd, offset);
+
+  in_malloc = 1;
+
+  void *ptr = __mmap(addr, length, prot, flags, fd, offset);
+
+  if (ptr != MAP_FAILED)
+    record_malloc(length, ptr, caller);
+
+  in_malloc = 0;
+
+  return ptr;
+}
+
+void *FUNC(mmap64)(void *addr, size_t length, int prot, int flags,
+                   int fd, off64_t offset) {
+  const void *caller =
+    __builtin_extract_return_addr(__builtin_return_address(0));
+
+  if (in_malloc)
+    return __mmap64(addr, length, prot, flags, fd, offset);
+
+  in_malloc = 1;
+
+  void *ptr = __mmap64(addr, length, prot, flags, fd, offset);
+
+  if (ptr != MAP_FAILED)
+    record_malloc(length, ptr, caller);
+
+  in_malloc = 0;
+
+  return ptr;
+}
+
+int FUNC(munmap)(void *addr, size_t length) {
+  const void *caller =
+    __builtin_extract_return_addr(__builtin_return_address(0));
+
+  if (in_malloc)
+    return __munmap(addr, length);
+
+  in_malloc = 1;
+
+  record_free(addr, caller);
+
+  int r = __munmap(addr, length);
+
+  in_malloc = 0;
+
+  return r;
+}
+
 } // extern "C"