CONTENTS

SYNOPSIS

"#include <malloc.h>"

"void *(*__malloc_hook)(size_t "size, "const void *"caller);

"void *(*__realloc_hook)(void *"ptr, "size_t "size, "const void *"caller);

"void *(*__memalign_hook)(size_t "alignment, "size_t "size, "const void *"caller);

"void (*__free_hook)(void *"ptr, "const void *"caller);

"void (*__malloc_initialize_hook)(void);"

The variable __malloc_initialize_hook points at a function that is called once when the malloc implementation is initialized. This is a weak variable, so it can be overridden in the application with a definition like the following:


void (*__malloc_initialize_hook)(void) = my_init_hook;


Now the function my_init_hook() can do the initialization of all hooks.

The four functions pointed at by __malloc_hook, __realloc_hook, __memalign_hook, __free_hook have a prototype like the functions malloc(), realloc(), memalign(), free(), respectively, except that they have a final argument caller that gives the address of the caller of malloc(), etc.

#include <stdio.h>
#include <malloc.h>

/* Prototypes for our hooks. */
static void my_init_hook(void);
static void *my_malloc_hook(size_t, const void *);

/* Variables to save original hooks. */
static void *(*old_malloc_hook)(size_t, const void *);

/* Override initialising hook from the C library. */
void (*__malloc_initialize_hook) (void) = my_init_hook;

static void
my_init_hook(void) {
old_malloc_hook = __malloc_hook;
__malloc_hook = my_malloc_hook;
}

static void *
my_malloc_hook (size_t size, const void *caller) {
void *result;

/* Restore all old hooks */
__malloc_hook = old_malloc_hook;

/* Call recursively */
result = malloc (size);

/* Save underlying hooks */
old_malloc_hook = __malloc_hook;

/* ‘printf’ might call ‘malloc’, so protect it too. */
printf ("malloc(%u) called from %p returns %p0,
(unsigned int) size, caller, result);

/* Restore our own hooks */
__malloc_hook = my_malloc_hook;