klish/lub/heap/heap_check.c

#include "private.h"

/* flag to indicate whether to check memory or not */
static bool_t checking = BOOL_FALSE;

typedef struct 
{
    bool_t      result;
    unsigned    free_blocks;
    lub_heap_t *heap;
} check_arg_t;
/*--------------------------------------------------------- */
static void
process_segment(void    *s,
                unsigned index,
                size_t   size,
                void    *a)
{
    lub_heap_segment_t *segment = s;
    lub_heap_block_t   *block   = lub_heap_block_getfirst(segment);
    check_arg_t        *arg     = a;
    /*
     * don't bother checking if this segment has zero blocks
     */
    if(arg->heap->stats.free_blocks || arg->heap->stats.alloc_blocks)
    {
        arg->result = lub_heap_block_check(block);
        if(BOOL_TRUE == arg->result)
        {
            /* check that the first block has the segment set */
            arg->result = (block->free.tag.segment == 1) ? BOOL_TRUE : BOOL_FALSE;
            if(block->free.tag.free)
            {
                ++arg->free_blocks;
            }
        }
        
        /* now iterate along the block chain checking each one */
        while((BOOL_TRUE == arg->result) 
              && (block = lub_heap_block_getnext(block)))
        {
            /* check this block */
            arg->result = lub_heap_block_check(block);
            if(BOOL_TRUE == arg->result)
            {
                /* ensure that all non-first blocks have the segment clear */
                arg->result = (block->free.tag.segment == 0) ? BOOL_TRUE : BOOL_FALSE;
                if(block->free.tag.free)
                {
                    ++arg->free_blocks;
                }
            }
        }
    }
}

/*--------------------------------------------------------- */
bool_t
lub_heap_check(bool_t enable)
{
    bool_t result = checking;
    
    checking = enable;
    
    return result;
}
/*--------------------------------------------------------- */
bool_t
lub_heap_is_checking(void)
{
    return checking;
}
/*--------------------------------------------------------- */
bool_t
lub_heap_check_memory(lub_heap_t *this)
{
    check_arg_t arg;
    
    arg.result = BOOL_TRUE;
    
    if(BOOL_TRUE == checking)
    {
        arg.free_blocks = 0;
        arg.heap        = this;
        /* iterate all the segments in the system */
        lub_heap_foreach_segment(this,process_segment,&arg);
    
        /* now check that the stats map to the available free blocks 
         * checking the alloc blocks is more difficult because of the hidden
         * overheads when performing leak detection.
         */
        if( (this->stats.free_blocks != arg.free_blocks) )
        {
            arg.result = BOOL_FALSE;
        }
    }
    return arg.result;
}
/*--------------------------------------------------------- */