c - 有时会绕过 gcc 内存 Hook 吗？

Question

对于 c++ arm 应用程序，我需要跟踪内存分配。为此，我正在使用 gcc 内存 Hook 。现在我正在打印分配和解除分配，请参见下面的代码。

但是，malloc 和free 并不相加。有时我看到一个内存块上的 free 之前没有 malloc Hook 。或者内存被释放了两次。当然这可能是我代码中的错误，尽管我没有遇到段错误。但我也看到 malloc 有时会返回一个它之前返回的指针，同时没有 free (至少我的 free 钩子(Hook)没有被调用)。

所以我的猜测是某些 malloc 和 free 没有通过我的钩子(Hook)传递。请注意，当我只跟踪 c++ 分配时，事情确实会很好地加起来。

有没有人有什么想法？

#include <stdlib.h>
#include <stdio.h>
#include <pthread.h>
#include <new>
#include <unistd.h>
#include <string.h>
#include <malloc.h>

pthread_mutex_t lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;

static void push_memhooks();
static void pop_memhooks();

static void *malloc_hook(size_t size, const void *ret)
{

    pthread_mutex_lock(&lock);

    pop_memhooks();

    void *mem = malloc(size);

    if (mem) {
        printf("malloc %p\n", mem);
    }

    push_memhooks();

    pthread_mutex_unlock(&lock);

    return mem;
}

static void *realloc_hook(void* ptr, size_t size, const void *ret)
{
    pthread_mutex_lock(&lock);

    pop_memhooks();

    void* mem = realloc(ptr, size);

    if (mem) {
        printf("realloc %p -> %p\n", ptr, mem);
    }

    push_memhooks();

    pthread_mutex_unlock(&lock);

    return mem;
}

static void* memalign_hook(size_t boundary, size_t size, const void *ret)
{
    pthread_mutex_lock(&lock);
    pop_memhooks();

    void* mem = memalign(boundary, size);

    if (mem) {
        printf("memalign %p\n", mem);
    }

    push_memhooks();

    pthread_mutex_unlock(&lock);

    return mem;
}

static void free_hook(void *mem, const void *ret)
{
    pthread_mutex_lock(&lock);

    pop_memhooks();

    free(mem);

    printf("free %p\n", mem);

    push_memhooks();

    pthread_mutex_unlock(&lock);
}

void *operator new(size_t size)
{
    void* mem = malloc(size);

    if (!mem) {
        throw std::bad_alloc();
    }

    return mem;
}

void operator delete(void* mem)
{
    free(mem);
}

void *operator new[](size_t size)
{       
    void* mem = malloc(size);

    if (!mem) {
        throw std::bad_alloc();
    }

    return mem;
}

void operator delete[](void* mem)
{
    free(mem);
}

static int memhooks = 0;

static void push_memhooks()
{
    if (++memhooks == 1) {
        __malloc_hook = malloc_hook;
        __realloc_hook = realloc_hook;
        __free_hook = free_hook;
        __memalign_hook = memalign_hook;
    }
}

static void pop_memhooks()
{
    if (--memhooks == 0) {
        __malloc_hook = NULL;
        __realloc_hook = NULL;
        __free_hook = NULL;
        __memalign_hook = NULL;
    }
}

static void install_memhooks ()
{
    push_memhooks();
}

void (*__malloc_initialize_hook)(void) = install_memhooks;

例如，当我对显示奇怪行为的指针进行 grep 跟踪时，我得到以下输出。

<snip>
malloc 0x8234818
free 0x8234818
malloc 0x8234818
malloc 0x8234818
free 0x8234818
<snip>

注意两个连续的 malloc。

解决方案:正如 Chris 在他的回答中提到的，上面的代码中存在竞争条件。不幸的是，按照我的方式删除和重新安装 Hook 时，无法在多线程环境中安全地使用 malloc Hook 。出于同样的原因，mcheck 不能用于多线程应用程序 (http://sources.redhat.com/bugzilla/show_bug.cgi?id=9939)。

实现 malloc/realloc/free 并使用 dlsym(RTLD_NEXT, "malloc") 调用 libc 版本 也没有用。首先，dlsym 调用了calloc，所以这里需要特别注意防止无限递归。其次，当调用 libc malloc 时，进程挂起。此外，我发现我的 __malloc_initialize_hook 没有被调用。所以我猜想通过提供我自己的 malloc 实现，libc malloc 没有正确初始化。

我当前的解决方案嵌入了 dlmalloc 实现，以消除对 libc malloc 的依赖。现在我不必不断地删除/重新安装 malloc Hook 。我安装了一次 Hook ，我的 Hook 使用 dlmalloc 分配内存。

Answer 1

如果您在多线程环境中运行，您的竞争条件可能会导致您错过对 malloc/free 的调用。当您的 malloc_hook 函数被调用时，它会解除所有 Hook ，调用 malloc 然后重新 Hook 。如果其他线程在 Hook 未 Hook 时调用 malloc/free，您将看不到该调用。您的互斥量没有帮助，因为当未 Hook 时，malloc/free 调用不会调用您的 Hook 函数，因此不会等待互斥量。

编辑

我在程序中 Hook /拦截 malloc 的首选方法是使用宏拦截来 self 的程序的调用，而不用担心来自 stdlib 的调用。创建一个 wrap_malloc 文件:

#define malloc(sz)     wrap_malloc(sz, __FILE__, __LINE__)
#define free(p)        wrap_free(p, __FILE__, __LINE__)
#define realloc(p, sz) wrap_realloc(p, sz, __FILE__, __LINE__)
#define calloc(s1, s2) wrap_calloc(s1, s2, __FILE__, __LINE__)

然后用-imacros wrap_malloc 编译我所有的代码。定义 wrap_malloc 和 friend 的文件只需要适当的 #undef，但不需要对代码进行其他更改。