Unix/Linux Go Back    

RedHat 9 (Linux i386) - man page for __malloc_hook (redhat section 3)

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:   man
Select Man Page Set:       apropos Keyword Search (sections above)

MALLOC_HOOK(3)			    Linux Programmer's Manual			   MALLOC_HOOK(3)

       __malloc_hook,  __malloc_initialize_hook,  __memalign_hook,  __free_hook,  __realloc_hook,
       __after_morecore_hook - malloc debugging variables

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

       The GNU C library lets you modify the behavior of malloc(), realloc(), and free() by spec-
       ifying  appropriate  hook  functions.   You can use these hooks to help you debug programs
       that use dynamic memory allocation, for example.

       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.

       The  variable  __after_morecore_hook  points  at a function that is called each time after
       sbrk() was asked for more core.

       Here a short example how to use these variables.

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

	   return result;

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

GNU					    2002-07-20				   MALLOC_HOOK(3)
Unix & Linux Commands & Man Pages : ©2000 - 2018 Unix and Linux Forums

All times are GMT -4. The time now is 05:58 AM.