NOMBRE

       __malloc_hook,      __malloc_initialize_hook,      __memalign_hook,      __free_hook,     __realloc_hook,
       __after_morecore_hook - variables de depuración de malloc

SINOPSIS

       #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);

       void (*__after_morecore_hook)(void);

DESCRIPCIÓN

       La biblioteca de C de GNU le  permite  modificar  el  comportamiento  de  malloc(),  realloc()  y  free()
       especificando funciones de «enganche» (hook) adecuadas. Puede usar estos enganches para que, por ejemplo,
       le ayuden a depurar programas que usan asignaciones dinámicas de memoria.

       La  variable  __malloc_initialize_hook  apunta  a  una  función  que  se  invoca  una única vez cuando se
       inicializa la implementación de malloc. Esta es una varible normal, por lo que se puede redefinir en  una
       aplicación de forma parecida a la siguiente:
           void (*__malloc_initialize_hook)(void) = my_init_hook;
       Ahora la función my_init_hook() puede hacer la inicialización de todos los enganches.

       Las cuatro funciones apuntadas por __malloc_hook, __realloc_hook, __memalign_hook y __free_hook tienen el
       mismo prototipo de las funciones malloc(), realloc(), memalign() y free(), respectivamente, aunque tienen
       un argumento final adicional caller que proporciona la dirección del invocador de malloc(), etc.

       La  variable  __after_morecore_hook  apunta  a un función que se invoca cada vez que se pide a sbrk() más
       memoria.

EJEMPLO

       A continuación tiene un pequeño ejemplo de cómo usar estas variables.

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

       /* Prototipos para nuestros enganches.  */
       static void my_init_hook(void);
       static void *my_malloc_hook(size_t, const void *);

       /* Variables para guardar los enganches originales. */
       static void *(*old_malloc_hook)(size_t, const void *);

       /* Redefinimos el enganche de inicialización de la biblioteca de C. */
       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;

           /* Restauramos todos los enganches originales */
           __malloc_hook = old_malloc_hook;

           /* Llamamos recursivamente a malloc */
           result = malloc (size);

           /* Guardamos los enganches originales */
           old_malloc_hook = __malloc_hook;

           /* `printf' podría llamar a `malloc', por lo que también hay que protegerla. */
           printf ("malloc(%u) invocada desde %p devuelve %p\n",
               (unsigned int) size, caller, result);

           /* Restauramos nuestros enganches */
           __malloc_hook = my_malloc_hook;

           return result;
       }

VÉASE TAMBIÉN

       mallinfo(3), malloc(3), mtrace(3), mcheck(3)

GNU                                               20 julio 2002                                   MALLOC_HOOK(3)