有时会绕过 gcc 内存挂钩吗？

Question

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

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

所以我的猜测是某些malloc's 和free's 没有通过我的钩子。请注意，当我只跟踪 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 在他的回答中提到的，上面的代码中存在竞争条件。不幸的是，按照我的方式删除和重新安装钩子时，不能在多线程环境中安全地使用 malloc 钩子。出于同样的原因，mcheck 不能用于多线程应用程序 (http://sources.redhat.com/bugzilla/show_bug.cgi?id=9939)。

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

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

Answer 1

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

编辑

我在程序中挂钩/拦截 malloc 的首选方式是使用宏拦截来自我的程序的调用，而不用担心来自 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 和朋友的文件只需要相应的#undefs，但不需要对代码进行其他更改。

Answer 2

我不知道您控制此代码的程度以及您如何尝试检测 malloc/free 是否匹配。但可能发生的一件事是，它们中的任何一个都伪装成realloc。这可以与某些类型的参数具有相同的效果 malloc（初始指针为 0）或 free（新大小为 0），IIRC。

编辑：我看到您使用的是 pthreads？另一种可能性是您的malloc/free 按顺序发生，但您的调试输出的printf 出现故障。对FILE* 变量的访问通常是互斥的。尝试在调试输出前加上时间戳，并首先根据该时间戳进行排序。