klish/lub/heap/context.c

#include <string.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#include "private.h"
#include "context.h"
#include "node.h"

unsigned long lub_heap_frame_count;

#define CONTEXT_CHUNK_SIZE 100 /* number of contexts per chunk */
#define CONTEXT_MAX_CHUNKS 100 /* allow upto 10000 contexts */

/*--------------------------------------------------------- 
 * PRIVATE META FUNCTIONS
 *--------------------------------------------------------- */
void
lub_heap_context_meta_init(void)
{
    static bool_t initialised = BOOL_FALSE;
    if(BOOL_FALSE == initialised)
    {
        lub_heap_leak_t *leak = lub_heap_leak_instance();
        initialised = BOOL_TRUE;

        /* initialise the context tree */
        lub_bintree_init(&leak->m_context_tree,
                         offsetof(lub_heap_context_t,bt_node),
                         lub_heap_context_compare,
                         lub_heap_context_getkey);
        lub_heap_leak_release(leak);
    }
}
/*--------------------------------------------------------- */
int
lub_heap_context_compare(const void *clientnode,
                         const void *clientkey)
{
    int                                   i,delta=0;
    const lub_heap_context_t             *node = clientnode;
    const lub_heap_context_key_t         *key  = clientkey;    
    function_t                   * const *node_fn = node->key.backtrace;
    function_t                   * const *key_fn  = key->backtrace;
        
    for(i = lub_heap_frame_count;
        i;
        --i,++node_fn,++key_fn)
    {
        delta = ((unsigned long)*node_fn - (unsigned long)*key_fn);
        if(0 != delta)
        {
            break;
        }
    }
    return delta;
}
/*--------------------------------------------------------- */
/* we simply use the embedded key as the index */
void
lub_heap_context_getkey(const void        *clientnode,
                        lub_bintree_key_t *key)
{
    const lub_heap_context_t * context = clientnode;
    memcpy(key,&context->key,sizeof(lub_heap_context_key_t));
}
/*--------------------------------------------------------- */
static bool_t
lub_heap_foreach_context(bool_t (*fn)(lub_heap_context_t *,void *),
                         void    *arg)
{
    bool_t                  result = BOOL_FALSE;
    lub_heap_context_t    * context;
    lub_bintree_iterator_t  iter;

    lub_heap_context_meta_init();

    {
        lub_heap_leak_t *leak = lub_heap_leak_instance();
        for(context = lub_bintree_findfirst(&leak->m_context_tree),
            context ? lub_bintree_iterator_init(&iter,&leak->m_context_tree,context) : (void)0;
            context;
            context = lub_bintree_iterator_next(&iter))
        {
            lub_heap_leak_release(leak);
            /* invoke the specified method on this context */
            result = fn(context,arg);
            leak = lub_heap_leak_instance();
        }
        lub_heap_leak_release(leak);
    }
    return result;
}
/*--------------------------------------------------------- */
static void
lub_heap_show_summary(void)
{
    lub_heap_leak_t *leak = lub_heap_leak_instance();
    size_t ok_allocs   = leak->m_stats.allocs;
    size_t ok_bytes    = leak->m_stats.alloc_bytes; 
    size_t ok_overhead = leak->m_stats.alloc_overhead; 
    
    ok_allocs -= leak->m_stats.partials;
    ok_allocs -= leak->m_stats.leaks;
    
    ok_overhead -= leak->m_stats.partial_overhead;
    ok_overhead -= leak->m_stats.leaked_overhead;
    
    printf("\n"
           "          +----------+----------+----------+----------+\n");
    printf("  TOTALS  |    blocks|     bytes|   average|  overhead|\n");
    printf("+---------+----------+----------+----------+----------+\n");
    printf("|contexts |%10"SIZE_FMT"|%10"SIZE_FMT"|%10"SIZE_FMT"|%10s|\n",
            leak->m_stats.contexts,
            leak->m_stats.contexts * sizeof(lub_heap_context_t),
            leak->m_stats.contexts ? sizeof(lub_heap_context_t) : 0,
            "");
    printf("|allocs   |%10"SIZE_FMT"|%10"SIZE_FMT"|%10"SIZE_FMT"|%10"SIZE_FMT"|\n",
            ok_allocs,
            ok_bytes,
            ok_allocs ? (ok_bytes / ok_allocs) : 0,
            ok_overhead);
    if(leak->m_stats.partials)
    {
        printf("|partials |%10"SIZE_FMT"|%10"SIZE_FMT"|%10"SIZE_FMT"|%10"SIZE_FMT"|\n",
                leak->m_stats.partials,
                leak->m_stats.partial_bytes,
                leak->m_stats.partials ? (leak->m_stats.partial_bytes / leak->m_stats.partials) : 0,
                leak->m_stats.partial_overhead);
    }
    if(leak->m_stats.leaks)
    {
        printf("|leaks    |%10"SIZE_FMT"|%10"SIZE_FMT"|%10"SIZE_FMT"|%10"SIZE_FMT"|\n",
                leak->m_stats.leaks,
                leak->m_stats.leaked_bytes,
                leak->m_stats.leaks ? (leak->m_stats.leaked_bytes / leak->m_stats.leaks) : 0,
                leak->m_stats.leaked_overhead);
    }
    printf("+---------+----------+----------+----------+----------+\n");
    lub_heap_leak_release(leak);
}
/*--------------------------------------------------------- */

/*--------------------------------------------------------- 
 * PRIVATE METHODS
 *--------------------------------------------------------- */
static void
lub_heap_context_foreach_node(lub_heap_context_t *this,
                              void           (*fn)(lub_heap_node_t *))
{
    lub_heap_node_t * node;
 
    for(node = this->first_node;
        node;
        node = lub_heap_node__get_next(node))
    {
        /* invoke the specified method on this node */
        fn(node);
    }
}
/*--------------------------------------------------------- */

/*--------------------------------------------------------- 
 * PUBLIC METHODS
 *--------------------------------------------------------- */
void
lub_heap_context_init(lub_heap_context_t * this,
                      lub_heap_t         * heap,
                      const stackframe_t * stack)
{
    lub_heap_context_meta_init();
    
    this->heap             = heap;
    this->allocs           = 0;
    this->alloc_bytes      = 0;
    this->alloc_overhead   = 0;
    this->leaks            = 0;
    this->leaked_bytes     = 0;
    this->leaked_overhead  = 0;
    this->partials         = 0;
    this->partial_bytes    = 0;
    this->partial_overhead = 0;
    this->first_node       = NULL;
    
    /* set the current backtrace for the context */
    this->key = *stack;
    
    /* intialise this context's binary tree node */
    lub_bintree_node_init(&this->bt_node);

    {
        lub_heap_leak_t *leak = lub_heap_leak_instance();
        /* add this context to the context_tree */
        lub_bintree_insert(&leak->m_context_tree,this);
        lub_heap_leak_release(leak);
    }
}
/*--------------------------------------------------------- */
void
lub_heap_context_fini(lub_heap_context_t * this)
{
    lub_heap_leak_t *leak = lub_heap_leak_instance();
    /* remove this node from the context_tree */
    lub_bintree_remove(&leak->m_context_tree,this);
    lub_heap_leak_release(leak);

    /* cleanup the context */
    lub_heap_context_clear(this);
}
/*--------------------------------------------------------- */
void
lub_heap_context_insert_node(lub_heap_context_t * this,
                             lub_heap_node_t    * node)
{
    /* add the node to the linked list */
    lub_heap_node__set_next(node,this->first_node);
    node->prev = NULL;
    if(this->first_node)
    {
        this->first_node->prev = node;
    }
    this->first_node = node;
    
}
/*--------------------------------------------------------- */
void
lub_heap_context_remove_node(lub_heap_context_t *this,
                             lub_heap_node_t    *node)
{
    lub_heap_node_t *next,*prev    = NULL;
    
    /* remove the node from the context list */
    next = lub_heap_node__get_next(node);
    prev = node->prev;

    if(NULL == prev)
    {
        this->first_node = next;
    }
    else
    {
        lub_heap_node__set_next(prev,next);
    }
    if(NULL != next)
    {
        next->prev = prev;
    }

    /* clear the pointers */
    lub_heap_node__set_next(node,NULL);
    node->prev = NULL;
    
    /* is this the last node in a context? */
    if(0 == this->allocs)
    {
        /* removing the last node deletes the context */
        lub_heap_context_delete(this);
    }
}
/*--------------------------------------------------------- */
void
lub_heap_context_show_frame(lub_heap_context_t * this,
                            int                  frame)
{
    if(frame >= 0)
    {
        long address = (long)this->key.backtrace[frame]; 
        if(address)
        {
            lub_heap_symShow(address);
        }
    }
    printf("\n");
}
/*--------------------------------------------------------- */
void
lub_heap_node_post(lub_heap_node_t *node)
{
    /* assume the worst */
    if(BOOL_TRUE == lub_heap_node__get_leaked(node))
    {
        /* this is a full leak */
        lub_heap_node__set_partial(node,BOOL_FALSE);
    }
}
/*--------------------------------------------------------- */
void
lub_heap_node_prep(lub_heap_node_t *node,
                   void            *arg)
{
    /* assume the worst */
    lub_heap_node__set_leaked(node,BOOL_TRUE);
    lub_heap_node__set_partial(node,BOOL_TRUE);
    lub_heap_node__set_scanned(node,BOOL_FALSE);
}
/*--------------------------------------------------------- */
void
lub_heap_node_scan(lub_heap_node_t *node,
                   void            *arg)
{
    /* only scan nodes which have references */
    if(   (BOOL_FALSE == lub_heap_node__get_leaked(node) )
       && (BOOL_FALSE == lub_heap_node__get_scanned(node)) )
    {
        lub_heap_node__set_scanned(node,BOOL_TRUE);
        lub_heap_scan_memory(lub_heap_node__get_ptr(node),
                             lub_heap_node__get_size(node));
    }
}
/*--------------------------------------------------------- */
static bool_t
lub_heap_context_prep(lub_heap_context_t *this,
                      void               *arg)
{
    /* start off by assuming the worst */
    this->partials         = this->leaks           = this->allocs;
    this->partial_bytes    = this->leaked_bytes    = this->alloc_bytes;
    this->partial_overhead = this->leaked_overhead = this->alloc_overhead;
    {
        lub_heap_leak_t *leak = lub_heap_leak_instance();
        /* initialised the global stats */
        leak->m_stats.allocs         += this->allocs;
        leak->m_stats.alloc_bytes    += this->alloc_bytes;
        leak->m_stats.alloc_overhead += this->alloc_overhead;
        lub_heap_leak_release(leak);
    }
    return BOOL_TRUE;
}
/*--------------------------------------------------------- */
static bool_t
lub_heap_context_post(lub_heap_context_t *this,
                      void               *arg)
{
    /* don't count full leaks as partials */
    this->partials         -= this->leaks;
    this->partial_bytes    -= this->leaked_bytes;
    this->partial_overhead -= this->leaked_overhead;
    
    /* post process the contained nodes */
    lub_heap_context_foreach_node(this,lub_heap_node_post);

    return BOOL_TRUE;
}
/*--------------------------------------------------------- */
static void
scan_segment(void    *ptr,
             unsigned index,
             size_t   size,
             void    *arg)
{
    lub_heap_segment_t *segment = ptr;
    const char         *memory  = (const char*)lub_heap_block_getfirst(segment);
    
    /* now scan the memory in this segment */
    printf(".");
    lub_heap_scan_memory(memory,size);
}
/*--------------------------------------------------------- */
/** 
 * This function scans all the nodes currently allocated in the
 * system for references to other allocated nodes.
 * First of all we mark all nodes as leaked, then scan all the nodes
 * for any references to other ones. If found those other ones 
 * are cleared from being leaked.
 * At the end of the process all nodes which are leaked then
 * update their context leak count.
 */
void
lub_heap_scan_all(void)
{
    lub_heap_t      *heap;
    lub_heap_leak_t *leak = lub_heap_leak_instance();
    

    /* clear the summary stats */
    memset(&leak->m_stats,0,sizeof(leak->m_stats));

    lub_heap_leak_release(leak);
    /* first of all prepare the contexts for scanning */
    lub_heap_foreach_context(lub_heap_context_prep,0);

    /* then prepare all the nodes (including those who have no context) */
    lub_heap_foreach_node(lub_heap_node_prep,0);
    
    printf("  Scanning memory");
    /* clear out the stacks in the system */
    lub_heap_clean_stacks();
    
    /* Scan the current stack */
    printf(".");
    lub_heap_scan_stack();
    
    /* Scan the BSS segment */
    printf(".");
    lub_heap_scan_bss();
    
    /* Scan the DATA segment */
    printf(".");
    lub_heap_scan_data();
    
    /* Scan the non-monitored blocks which are allocated in the system */
    leak = lub_heap_leak_instance();
    for(heap = leak->m_heap_list;
        heap;
        heap = heap->next) 
    {
        lub_heap_leak_release(leak);
        lub_heap_foreach_segment(heap,scan_segment,0);
        leak = lub_heap_leak_instance();
    }
    lub_heap_leak_release(leak);
    
    /* 
     * now scan the nodes NB. only referenced nodes will be scanned 
     * we loop until we stop scanning new nodes
     */
    leak = lub_heap_leak_instance();
    do
    {
        leak->m_stats.scanned = 0;
        /* scan each node */
        lub_heap_leak_release(leak);
        printf(".");
        lub_heap_foreach_node(lub_heap_node_scan,NULL);
        leak = lub_heap_leak_instance();
    } while(leak->m_stats.scanned);
        
    printf("done\n\n");

    /* post process each context and contained nodes */
    lub_heap_leak_release(leak);
    lub_heap_foreach_context(lub_heap_context_post,0);
    leak = lub_heap_leak_instance();
    
    
    lub_heap_leak_release(leak);
}
/*--------------------------------------------------------- */
void lub_heap_node_show(lub_heap_node_t *node)
{
    printf("%s%p[%"SIZE_FMT"] ",
           lub_heap_node__get_leaked(node) ? "*" : lub_heap_node__get_partial(node) ? "+" : "",
           lub_heap_node__get_ptr(node),
           lub_heap_node__get_size(node));
}
/*--------------------------------------------------------- */
static bool_t
lub_heap_context_match(lub_heap_context_t *this,
                       const char         *substring)
{
    bool_t result = BOOL_TRUE;
    if(substring)
    {
        int  i;
        long address;
        result = BOOL_FALSE;
        /* 
         * search the stacktrace for this context
         * to see whether it matches
         */
        for(i = 0;
            (address = (long)this->key.backtrace[i]);
            ++i)
        {
            if(lub_heap_symMatch(address,substring))
            {
                result = BOOL_TRUE;
                break;
            }
        }
    }
    return result;
}
/*--------------------------------------------------------- */
typedef struct
{
    lub_heap_show_e how;
    const char     *substring;
} context_show_arg_t;
/*--------------------------------------------------------- */
bool_t
lub_heap_context_show_fn(lub_heap_context_t *this,
                         void                *arg)
{
    bool_t              result = BOOL_FALSE;
    context_show_arg_t *show_arg = arg;
    
    lub_heap_leak_t *leak = lub_heap_leak_instance();
    /* add in the context details */
    ++leak->m_stats.contexts;
    leak->m_stats.allocs           += this->allocs;
    leak->m_stats.alloc_bytes      += this->alloc_bytes;
    leak->m_stats.alloc_overhead   += this->alloc_overhead;
    leak->m_stats.partials         += this->partials;
    leak->m_stats.partial_bytes    += this->partial_bytes;
    leak->m_stats.partial_overhead += this->partial_overhead;
    leak->m_stats.leaks            += this->leaks;
    leak->m_stats.leaked_bytes     += this->leaked_bytes;
    leak->m_stats.leaked_overhead  += this->leaked_overhead;
    lub_heap_leak_release(leak);
    
    
    if(lub_heap_context_match(this,show_arg->substring))
    {
        result = lub_heap_context_show(this,show_arg->how);
    }
    return result;
}
/*--------------------------------------------------------- */
bool_t
lub_heap_context_show(lub_heap_context_t *this,
                      lub_heap_show_e     how)
{
    long   frame       = lub_heap_frame_count-1;
    size_t ok_allocs   = this->allocs;
    size_t ok_bytes    = this->alloc_bytes;
    size_t ok_overhead = this->alloc_overhead;
    
    ok_allocs -= this->partials;
    ok_allocs -= this->leaks;

    ok_bytes  -= this->partial_bytes;
    ok_bytes  -= this->leaked_bytes;

    ok_overhead  -= this->partial_overhead;
    ok_overhead  -= this->leaked_overhead;

    switch(how)
    {
        case LUB_HEAP_SHOW_ALL:
        {
            /* show everything */
            break;
        }
        case LUB_HEAP_SHOW_PARTIALS:
        {
            if(0 < this->partials)
            {
                /* there's at least one partial in this context */
                break;
            }
            /*lint -e(616) fall through */
        }
        case LUB_HEAP_SHOW_LEAKS:
        {
            if(0 < this->leaks)
            {
                /* there's at least one leak in this context */
                break;
            }
            /*lint -e(616) fall through */
        }
        default:
        {
            /* nothing to be shown */
            return BOOL_FALSE;
        }
    }

    /* find the top of the stack trace */
    while((frame >= 0) && (0 == this->key.backtrace[frame]))
    {
        --frame;
    }
    printf("          +----------+----------+----------+----------+");
    lub_heap_context_show_frame(this,frame--);
    printf(      "%10p|    blocks|     bytes|   average|  overhead|",(void*)this);
    lub_heap_context_show_frame(this,frame--);
    printf("+---------+----------+----------+----------+----------+");
    lub_heap_context_show_frame(this,frame--);

    printf("|allocs   |%10"SIZE_FMT"|%10"SIZE_FMT"|%10"SIZE_FMT"|%10"SIZE_FMT"|",
            ok_allocs,
            ok_bytes,
            ok_allocs ? (ok_bytes / ok_allocs) : 0,
            ok_overhead);
    lub_heap_context_show_frame(this,frame--);

    if(this->partials)
    {
        printf("|partials |%10"SIZE_FMT"|%10"SIZE_FMT"|%10"SIZE_FMT"|%10"SIZE_FMT"|",
                this->partials,
                this->partial_bytes,
                this->partials ? (this->partial_bytes/this->partials) : 0,
                this->partial_overhead);
        lub_heap_context_show_frame(this,frame--);
    }
    if(this->leaks)
    {
        printf("|leaks    |%10"SIZE_FMT"|%10"SIZE_FMT"|%10"SIZE_FMT"|%10"SIZE_FMT"|",
                this->leaks,
                this->leaked_bytes,
                this->leaks ? (this->leaked_bytes/this->leaks) : 0,
                this->leaked_overhead);
        lub_heap_context_show_frame(this,frame--);
    }

    printf("+---------+----------+----------+----------+----------+");
    lub_heap_context_show_frame(this,frame--);

    while(frame >= 0)
    {
        printf("%55s","");
        lub_heap_context_show_frame(this,frame--);
    }

    printf("ALLOCATED BLOCKS: ");
    /* now iterate the allocated nodes */
    lub_heap_context_foreach_node(this,lub_heap_node_show);
    printf("\n\n");
    
    return BOOL_TRUE;
}
/*--------------------------------------------------------- */
void
lub_heap_context_clear(lub_heap_context_t *this)
{
    /* should only ever get cleared when all nodes have left the context */
    assert(0 == this->first_node);
    this->heap = 0;

    /* reset the counters */
    this->allocs        = 0;
    this->alloc_bytes   = 0;
    this->leaks         = 0;
    this->leaked_bytes  = 0;
    this->partials      = 0;
    this->partial_bytes = 0;
}
/*--------------------------------------------------------- */
void
lub_heap_show_leak_trees(void)
{
    lub_heap_leak_t *leak = lub_heap_leak_instance();
    printf("context_tree   : ");
    lub_bintree_dump(&leak->m_context_tree);
    printf("\n");
    printf("node_tree      : ");
    lub_bintree_dump(&leak->m_node_tree);
    printf("\n");
    printf("clear_node_tree: ");
    lub_bintree_dump(&leak->m_clear_node_tree);
    printf("\n");
    lub_heap_leak_release(leak);
}
/*--------------------------------------------------------- */
void
lub_heap_leak_scan(void)
{
    if(0 < lub_heap_frame_count)
    {
        /* check for memory leaks */
        if(!lub_heap_is_tainting())
        {
            printf("******************************************"
                   "*** Memory tainting is disabled so results\n"
                   "*** of scan may miss some real leaks!\n"
                   "******************************************\n\n");
        }
        lub_heap_scan_all();
    }
    else
    {
        printf("Leak detection currently disabled\n\n");
    }
}
/*--------------------------------------------------------- */
bool_t
lub_heap_leak_report(lub_heap_show_e how,
                     const char     *substring)
{
    bool_t result = BOOL_FALSE;
    
    if(0 < lub_heap_frame_count)
    {
        bool_t             bad_arg = BOOL_FALSE;
        lub_heap_leak_t   *leak    = lub_heap_leak_instance();
        context_show_arg_t show_arg;
        show_arg.how       = how;
        show_arg.substring = substring;
        
        /* zero these stats which will be accumulated from the contexts */
        leak->m_stats.contexts         = 0;
        leak->m_stats.allocs           = 0;
        leak->m_stats.alloc_bytes      = 0;
        leak->m_stats.alloc_overhead   = 0;
        leak->m_stats.partials         = 0;
        leak->m_stats.partial_bytes    = 0;
        leak->m_stats.partial_overhead = 0;
        leak->m_stats.leaks            = 0;
        leak->m_stats.leaked_bytes     = 0;
        leak->m_stats.leaked_overhead  = 0;
        lub_heap_leak_release(leak);
        
        switch(how)
        {
            case LUB_HEAP_SHOW_LEAKS:
            case LUB_HEAP_SHOW_PARTIALS:
            case LUB_HEAP_SHOW_ALL:
            {
                result = lub_heap_foreach_context(lub_heap_context_show_fn,(void*)&show_arg);
                break;
            }
            default:
            {
                printf("Invalid argument: 0=leaks, 1=partials and leaks, 2=all allocations\n\n");
                bad_arg = BOOL_TRUE;
                break;
            }
        }
        if(BOOL_FALSE == bad_arg)
        {
            leak = lub_heap_leak_instance();
            if(leak->m_stats.leaks)
            {
                printf("  '*' = leaked memory\n");
            }
            if(leak->m_stats.partials)
            {
                printf("  '+' = partially leaked memory\n");
            }
            lub_heap_leak_release(leak);
            lub_heap_show_summary();
            printf("  %lu stack frames held for each allocation.\n\n",lub_heap_frame_count);
        }
    }
    else
    {
        printf("Leak detection currently disabled\n\n");
    }
    return result;
}
/*--------------------------------------------------------- */

/*--------------------------------------------------------- 
 * PUBLIC META FUNCTIONS
 *--------------------------------------------------------- */
void
lub_heap__set_framecount(unsigned frames)
{
    static bool_t    clear_tainting_on_disable = BOOL_FALSE;
    lub_heap_leak_t *leak;
    
    if(frames == lub_heap_frame_count)
        return;
    
    /* iterate around clearing all the nodes in the node_tree */
    lub_heap_foreach_node(lub_heap_node_clear,0);
    
    leak = lub_heap_leak_instance();
    if(frames)
    {
        static bool_t registered = BOOL_FALSE;
        if(frames <= MAX_BACKTRACE)
        {
            /* change the number of frames held */
            lub_heap_frame_count = frames;
        }
        else
        {
            fprintf(stderr,"--- leak-detection frame count set to a maximum of %d\n",MAX_BACKTRACE);
            lub_heap_frame_count = MAX_BACKTRACE;
        }
        if(!lub_heap_is_tainting())
        {
            /* we need to taint memory to ensure old pointers don't mask leaks */
            clear_tainting_on_disable = BOOL_TRUE;
            lub_heap_taint(BOOL_TRUE);
        }
        if(BOOL_FALSE == registered)
        {
            registered = BOOL_TRUE;
            /* 
             * set up the context pool
             */
            lub_dblockpool_init(&leak->m_context_pool,
                                sizeof(lub_heap_context_t),
                                CONTEXT_CHUNK_SIZE,
                                CONTEXT_MAX_CHUNKS);
        }
    }
    else
    {
        /* switch off leak detection */
        lub_heap_frame_count = 0;
        if(clear_tainting_on_disable)
        {
            lub_heap_taint(BOOL_FALSE);
            clear_tainting_on_disable = BOOL_FALSE;
        }
    }
    lub_heap_leak_release(leak);   
}
/*--------------------------------------------------------- */
unsigned
    lub_heap__get_framecount(void)
{
    return lub_heap_frame_count;
}
/*--------------------------------------------------------- */
size_t
    lub_heap_context__get_instanceSize(void)
{
    return (sizeof(lub_heap_context_t));
}
/*--------------------------------------------------------- */
lub_heap_context_t *
lub_heap_context_find(const stackframe_t *stack)
{
    lub_heap_context_t    *result;
    lub_heap_leak_t       *leak = lub_heap_leak_instance();
    lub_heap_context_key_t key  = *stack;

    result = lub_bintree_find(&leak->m_context_tree,&key);

    lub_heap_leak_release(leak);
    return result;
}
/*--------------------------------------------------------- */