_heap_walk - Return Information about Default Heap

Syntax

#include <malloc.h>
int _heap_walk(int (*callback_fn)(const void *object, size_t size,
                                                               int flag, int status,
                                                               const char* file, int line) );

Description

• heap_walk traverses the default heap, and for each allocated or freed object, it calls the callback_fn function that you provide. For each object, it passes your function:

  object

  A pointer to the object.
  size
  The size of the object.
  flag
  The value _USEDENTRY if the object is currently allocated, or _FREEENTRY if the object has been freed. (Both values are defined in <malloc.h>.)
  status
  One of the following values, defined in <malloc.h>, depending on the status of the object:
  • HEAPBADBEGIN
    The heap specified is not valid; it may have been closed or destroyed.
    _HEAPBADNODE
    A memory node is corrupted, or the heap is damaged.
    _HEAPEMPTY
    The heap has not been initialized.
    _HEAPOK
    The heap appears to be consistent.
    file
    The name of the file where the object was allocated.
    line
    The line where the object was allocated.

  • heap_walk provides information about all objects, regardless of which memory management functions were used to allocate them. However, the file and line information are only available if the object was allocated and freed using the debug versions of the memory management functions. Otherwise, file is NULL and line is 0.

    _heap_walk calls callback_fn for each object until one of the following occurs:

    • All objects have been traversed. 
      callback_fn returns a nonzero value to _heap_walk.
      
      It cannot continue because of a problem with the heap.

      You may want to code your callback_fn to return a nonzero value if the status of the object is not _HEAPOK. Even if callback_fn returns 0 for an object that is corrupted, _heap_walk cannot continue because of the state of the heap and returns to its caller.

      You can use callback_fn to process the information from _heap_walk in various ways. For example, you may want to print the information to a file or use it to generate your own error messages. You can use the information to look for memory leaks and objects incorrectly allocated or freed from the heap. It can be especially useful to call _heap_walk when _heapchk returns an error.

      A heap-specific version of this function, _uheap_walk, is also available.

      Note:

      • Using the _heapchk, _heapset, and _heap_walk functions (and their heap-specific equivalents) may add overhead to each object allocated from the heap.

      • heap_walk locks the heap while it traverses it, to ensure that no other operations use the heap until _heap_walk finishes. As a result, in your callback_fn, you cannot call any critical functions in the run-time library, either explicitly or by calling another function that calls a critical function. See the VisualAge C++ Programming Guide for a list of critical functions.

    Returns

    • heap_walk returns the last value of status to the caller.
    Example Code

    This example allocates some memory, then uses _heap_walk to walk the heap and pass information about allocated objects to the callback function callback_function. callback_function then checks the information and keeps track of the number of allocated objects.

    #include <stdlib.h>#include <stdio.h>
    #include <malloc.h>
    
    int callback_function(const void *pentry, size_t sz, int useflag, int status,
                          const char *filename, size_t line)
    {
       if (_HEAPOK != status) {
          puts("status is not _HEAPOK.");
          exit(status);
       }
       if (_USEDENTRY == useflag)
          printf("allocated  %p     %u\n", pentry, sz);
       else
          printf("freed      %p     %u\n", pentry, sz);
       return 0;
    }
    
    int main(void)
    {
       char  *p1, *p2, *p3;
    
       if (NULL == (p1 = malloc(100)) ||
           NULL == (p2 = malloc(200)) ||
           NULL == (p3 = malloc(300))) {
          puts("Could not allocate memory block.");
          exit(EXIT_FAILURE);
       }
       free(p2);
       puts("usage      address   size\n-----      -------   ----");
    
       _heap_walk(callback_function);
    
       free(p1);
       free(p3);
       return 0;
    
       /****************************************************************************
          The output should be similar to :
    
          usage      address   size
          -----      -------   ----
          allocated  73A10     300
          allocated  738B0     100
           :
           :
          freed      73920     224
       ****************************************************************************/
    }
    

    Related Information

    • Managing Memory" in the VisualAge C++ Programming Guide
      
    • Debugging Your Heaps" in the VisualAge C++ Programming Guide
      
    • heapchk
      
    • heapmin
      
    • heapset
      
    • uheap_walk

    ---

    [Back: _heapset - Validate and Set Default Heap]
    [Next: hypot - Calculate Hypotenuse]