/* ------------------------------------------------------------------
 * Copyright (C) 2008 PacketVideo
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 * -------------------------------------------------------------------
 */

/*! \file oscl_mem_audit.cpp
    \brief This file contains the implementation of MM_Audit class
*/
#include "osclconfig_memory.h"

#if (!OSCL_BYPASS_MEMMGT)

#include "oscl_types.h"
#include "oscl_mem.h"
#include "oscl_mem_audit.h"
#include "oscl_mem_audit_internals.h"
#include "oscl_assert.h"
#include "oscl_stdstring.h"


#if MM_AUDIT_FENCE_SUPPORT
const uint32 PRE_PAD_SIZE = sizeof(MM_AllocBlockFence);
const uint32 POST_FENCE_SIZE = sizeof(MM_AllocBlockFence);
#else
const uint32 PRE_PAD_SIZE = 0;
const uint32 POST_FENCE_SIZE = 0;
#endif

const uint32 CONTROL_HEADER_SIZE = sizeof(MM_AllocBlockHdr);
const uint32 BLOCK_HDR_SIZE = CONTROL_HEADER_SIZE + PRE_PAD_SIZE;
const uint32 BLOCK_OVERHEAD_SIZE = BLOCK_HDR_SIZE + POST_FENCE_SIZE;


/**
 * MM_Audit_Imp constructor and descontructor
 */

/* ======================================================================== */
/*	Function : MM_Audit()													*/
/*	Date     : 10/08/2002													*/
/*	Purpose  : Constructor, create the root node in statistics table		*/
/*	In/out   :																*/
/*	Return   :																*/
/*	Modified :																*/
/* ======================================================================== */

const char root_tag[] = "";

MM_Audit_Imp::MM_Audit_Imp()
{
    mpCurrAllocNode = mpAllocNode = NULL;
    mNumAllocNodes = 0;

    prefill_pattern = DEFAULT_PREFILL_PATTERN;
    postfill_pattern = DEFAULT_POSTFILL_PATTERN;

    mpStatsNode = NULL;
    mnAllocNum = 0;
    mnMaxTagLevel = 10;

    mm_audit_per_block_overhead = 0;
    mm_audit_stats_overhead = 0;

    mode = DEFAULT_MM_AUDIT_MODE;

    /* create root node in memory statistics table */
    mpStatsNode = createStatsNode(root_tag);
}

/* ======================================================================== */
/*	Function : ~MM_Audit()													*/
/*	Date     : 10/08/2002													*/
/*	Purpose  : destructor, remove all the nodes in allocation and			*/
/*			   statistics table												*/
/*	In/out   :																*/
/*	Return   :																*/
/*	Modified :																*/
/* ======================================================================== */

MM_Audit_Imp::~MM_Audit_Imp()
{

#if MM_AUDIT_ALLOC_NODE_SUPPORT
    /**
     * Delete all the allocation nodes
     */
    removeALLAllocNodes();
    mpAllocNode = mpCurrAllocNode = NULL;
    mnAllocNum = 0;
#endif

    /**
     * Delete all the statistics nodes
     */
    mpStatsNode = NULL;

    mTagTree.clear();
}


/*
* ===================== API FUNCTIONS: MM_xxx() ==================================
*/

/* ============================================================================ */
/*	Function : MM_allocate()													*/
/*	Date     : 10/08/2002														*/
/*	Purpose  : API for a memory allocation attempt: create a new node in		*/
/*			   allocation table and update/create the corresponding node in		*/
/*			   statistics table													*/
/*	In/out   : all parameters are input											*/
/*	Return   : memory pointer, if something is wrong, the pointer will be NULL	*/
/*	Modified :																	*/
/* ============================================================================	*/

OSCL_EXPORT_REF void* MM_Audit_Imp::MM_allocate(const OsclMemStatsNode* pInStatsNode,
        uint32 sizeIn,
        const char *pFileName,
        uint32 lineNumber,
        bool allocNodeTracking)
{

#if defined(DEBUG_ENABLE)
    PVUStackTrace();
    if (pFileName)
    {
        printf("In MM_allocate, nBytes %d, file_name is %s, line_num is %d\n", sizeIn, pFileName, lineNumber);
    }
    else
    {
        printf("In MM_allocate with tag %s operator, nBytes %d\n", sizeIn);
    }
#endif

    MMAuditUint8AutoPtr pMem;
    void  *pMem_out = NULL;

#if (MM_AUDIT_ALLOC_NODE_SUPPORT && MM_AUDIT_INCLUDE_ALL_HEAP_VALIDATION)
    if (mode & MM_AUDIT_VALIDATE_ALL_HEAP_FLAG)
    {
        validate_all_heap();
    }
#endif

    OsclMemStatsNode* pStatsNode;
    if (pInStatsNode)
    {
        // remove "constness" of the stats node so it can be updated.
        pStatsNode = const_cast<OsclMemStatsNode*>(pInStatsNode);
    }
    else
    {
        pStatsNode = mpStatsNode; // set to the root node.
    }

    uint32 full_size = sizeIn + BLOCK_OVERHEAD_SIZE;

#if MM_AUDIT_FAILURE_SIMULATION_SUPPORT
    if (!isSetFailure(pStatsNode))
    {
        pMem.allocate(full_size);
    }
#else
    if (full_size > sizeIn)
    {
        pMem.allocate(full_size);
    }
#endif

    if (!pMem.get())
    {
        updateStatsNodeInFailure(pStatsNode);
        return NULL;
    }


    MM_AllocNode* pAllocNode = NULL;
#if MM_AUDIT_ALLOC_NODE_SUPPORT

    if ((mode & MM_AUDIT_ALLOC_NODE_ENABLE_FLAG) || allocNodeTracking ||
            (sizeIn & MM_AllocBlockHdr::ALLOC_NODE_FLAG))
    {
        if ((pAllocNode = addAllocNode((void *)pMem.get(), sizeIn, pStatsNode, pFileName, lineNumber)) == NULL)
        {
            updateStatsNodeInFailure(pStatsNode);
            return NULL;
        }
    }
#endif

    // now write the header to the block
    MM_AllocBlockHdr *block_hdr =
        static_cast<MM_AllocBlockHdr *>(static_cast<void*>(pMem.get()));
    block_hdr->size = sizeIn;
    if (pAllocNode)
    {
        block_hdr->setAllocNodeFlag();
        block_hdr->pNode = pAllocNode;
    }
    else
    {
        block_hdr->pNode =  pStatsNode;
    }

    /**
    * Save the root audit node pointer in the header.
    * This pointer will be used when the block is deallocated.
    */
    OsclAuditCB audit;
    OsclMemInit(audit);
    block_hdr->pRootNode = audit.pAudit;

#if MM_AUDIT_FILL_SUPPORT
    if ((mode & MM_AUDIT_PREFILL_FLAG))
    {
        oscl_memset(pMem.get() + BLOCK_HDR_SIZE, prefill_pattern, sizeIn);
    }
#endif


#if MM_AUDIT_FENCE_SUPPORT
    /* fill the pre-fence */
    MM_AllocBlockFence *pFence =
        static_cast<MM_AllocBlockFence*>(static_cast<void*>(pMem.get() +
                                         CONTROL_HEADER_SIZE));
    pFence->fill_fence();

    /* fill the post-fence */
    uint32 post_fence_offset = sizeIn + BLOCK_HDR_SIZE;
    pFence =
        static_cast<MM_AllocBlockFence*>(static_cast<void*>(pMem.get() +
                                         post_fence_offset));
    pFence->fill_fence();
#endif


    /* 8-byte alignment */
    pMem_out = pMem.get() + BLOCK_HDR_SIZE;
    MM_Stats_t delta;
    delta.numBytes = sizeIn;
    delta.numAllocs = 1;
    delta.numAllocFails = 0;
    updateStatsNode(pStatsNode, delta, true);

    pMem.release(); // release so it doesn't free up memory on exit

    // account for the per-block overhead
    mm_audit_per_block_overhead += BLOCK_OVERHEAD_SIZE;
    return pMem_out;

}

/* ============================================================================ */
/*	Function : MM_deallocate()													*/
/*	Date     : 10/08/2002														*/
/*	Purpose  : API for a memory de-allocation attempt: remove a node in			*/
/*			   allocation table and update the corresponding node in			*/
/*			   statistics table													*/
/*	In/out   : all parameters are input											*/
/*	Return   :																	*/
/*	Modified :																	*/
/* ============================================================================	*/

OSCL_EXPORT_REF bool  MM_Audit_Imp::MM_deallocate(void *pMemBlockIn)
{
    if (!pMemBlockIn)  return false;

    if (mpStatsNode == NULL ||
            (mpStatsNode && mpStatsNode->pMMStats && mpStatsNode->pMMStats->peakNumBytes == 0)) /* No actual allocation happens */
    {
        return true;
    }

#if (MM_AUDIT_ALLOC_NODE_SUPPORT && MM_AUDIT_INCLUDE_ALL_HEAP_VALIDATION)
    if (mode & MM_AUDIT_VALIDATE_ALL_HEAP_FLAG)
    {
        validate_all_heap();
    }
#endif

    bool status = true;
#if MM_AUDIT_VALIDATE_BLOCK
    if (mode & MM_AUDIT_VALIDATE_ON_FREE_FLAG)
    {
        if (!validate(pMemBlockIn))
        {
            return false;
        }
    }
#endif

    uint8 *pMem = static_cast<uint8 *>(pMemBlockIn);
    pMem -= BLOCK_HDR_SIZE;

    OsclMemStatsNode *pStatsNode = NULL;
    MM_AllocBlockHdr *pMemBlockHdr =
        static_cast<MM_AllocBlockHdr*>(static_cast<void*>(pMem));
    uint32 size = pMemBlockHdr->size;

#if MM_AUDIT_ALLOC_NODE_SUPPORT
    if (size & MM_AllocBlockHdr::ALLOC_NODE_FLAG)
    {
        pStatsNode = removeAllocNode((void *)pMem, size);
        OSCL_ASSERT(pStatsNode);
    }
#endif

    if (!pStatsNode)
    {
        pStatsNode = static_cast<OsclMemStatsNode*>(pMemBlockHdr->pNode);
    }
    /**
     * 3/1. update the node in memory statistics table
     */
    MM_Stats_t delta;
    delta.numAllocs = 1;
    delta.numBytes = size;
    delta.numAllocFails = 0;
    status = updateStatsNode(pStatsNode, delta, false);

#if MM_AUDIT_FILL_SUPPORT
    if ((mode & MM_AUDIT_POSTFILL_FLAG))
    {
        oscl_memset(pMem + BLOCK_HDR_SIZE, postfill_pattern, size);
    }
#endif


    MMAuditUint8AutoPtr::deallocate(pMem);

    // account for the per-block overhead
    mm_audit_per_block_overhead -= BLOCK_OVERHEAD_SIZE;


    return status;
}


/* ============================================================================ */
/*	Function : MM_GetTreeNodes()												*/
/*	Date     : 10/31/2002														*/
/*	Purpose  : API to get the number of tree nodes including the tag node and   */
/*			   its subtree														*/
/*	In/out   : all parameters are input											*/
/*	Return   : 0 means no tag node ; >0 means the number of tree nodes			*/
/*	Modified :																	*/
/* ============================================================================	*/

OSCL_EXPORT_REF uint32 MM_Audit_Imp::MM_GetTreeNodes(const char *  tagIn)
{
    int32 count = 0;

    MMAuditCharAutoPtr tag;
    makeValidTag(tagIn, tag); //tagIn = NULL means root tag
    OsclTagTreeType::iterator iter = mTagTree.find(tag.get());

    if (iter != mTagTree.end())
    {
        count++; //to account for the parent
        count = iter->children.size();
    }
    return ((uint32)count);
}


/* ================================================================================ */
/*	Function : MM_GetStats()														*/
/*	Date     : 10/08/2002															*/
/*	Purpose  : API to get memory statistics through context string(tag)				*/
/*	In/out   : all parameters are input												*/
/*	Return   : the statistics (pointer) for the current tag node					*/
/*			   if something is wrong, return NULL									*/
/*	Modified :																		*/
/* ================================================================================ */


OSCL_EXPORT_REF MM_Stats_t* MM_Audit_Imp::MM_GetStats(const char * const  tagIn)
{
    MM_Stats_t *pMMStats = NULL;
    MMAuditCharAutoPtr tag;
    makeValidTag(tagIn, tag); //tagIn = NULL means root tag
    OsclTagTreeType::iterator iter = mTagTree.find(tag.get());

    if (iter != mTagTree.end())
    {
        /* Got it! */
        OsclMemStatsNode *pStatsNode = (iter->value).get();
        if (pStatsNode)
        {
            pMMStats = pStatsNode->pMMStats;
        }
    }
    return pMMStats;
}


OSCL_EXPORT_REF uint32 MM_Audit_Imp::MM_GetStatsInDepth(const char *tagIn,
        MM_Stats_CB *array_ptr,
        uint32 max_nodes)
{
    uint32 curr_array_index = 0;
    populateChildren(tagIn, array_ptr, curr_array_index, max_nodes);
    return (curr_array_index);
}


/* ============================================================================ */
/*	Function : getNodeChildren()												*/
/*	Date     : 10/08/2002														*/
/*	Purpose  : recursive function to go throught each child node for the 		*/
/*			   current node and counter it										*/
/*	In/out   : all parameters are input											*/
/*	Return   :																	*/
/*	Modified :																	*/
/* ============================================================================	*/

void MM_Audit_Imp::populateChildren(const char *tagIn,
                                    MM_Stats_CB *array_ptr,
                                    uint32 &curr_array_index,
                                    uint32 max_nodes)
{
    MMAuditCharAutoPtr tag;
    makeValidTag(tagIn, tag); //tagIn = NULL means root tag
    OsclTagTreeType::iterator miter = mTagTree.find(tag.get());

    if (curr_array_index > max_nodes)
    {
        return;
    }

    if (miter != mTagTree.end() && max_nodes > 0)
    {
        uint32 num_children = miter->children.size();

        miter->sort_children();

        array_ptr[curr_array_index].num_child_nodes = num_children;

        for (uint32 i = 0; i < num_children; i++)
        {
            array_ptr[curr_array_index].tag = (miter->tag).tag;

            OsclMemStatsNode *pStatsNode = (miter->value).get();
            if (pStatsNode)
            {
                array_ptr[curr_array_index].pStats = pStatsNode->pMMStats;
            }
            curr_array_index++;

            if (curr_array_index > max_nodes)
            {
                return;
            }
        }

        /* access its children nodes */
        if (!miter->children.empty())
        {
            /* recursive search */
            for (uint32 i = 0; i < num_children; i++)
            {
                populateChildren((miter->children[i]->tag).tag,
                                 array_ptr,
                                 curr_array_index,
                                 max_nodes);
            }
        }
    }

    return;
}

/* ============================================================================ */
/*	Function : MM_GetTag()														*/
/*	Date     : 10/08/2002														*/
/*	Purpose  : API to get an StatsNode or creates one if it doesn't exist */
/*	In/out   : all parameters are input											*/
/*	Return   : pointer to OsclMemStatsNode if operation succeeds, NULL otherwise										*/
/*	Modified :																	*/
/* ============================================================================	*/

OSCL_EXPORT_REF const OsclMemStatsNode* MM_Audit_Imp::MM_GetTagNode(const char * tagIn)
{
    MMAuditCharAutoPtr tag;
    makeValidTag(tagIn, tag); //tagIn = NULL means root tag
    OsclTagTreeType::iterator iter = mTagTree.find(tag.get());
    if (iter != mTagTree.end())
        return ((iter->value).get());
    else
        return createStatsNode(tag.get()); /* create a new empty node */
}

/* ============================================================================ */
/*	Function : MM_GetTag()														*/
/*	Date     : 10/08/2002														*/
/*	Purpose  : API to get an existing node  */
/*	In/out   : all parameters are input											*/
/*	Return   : pointer to OsclMemStatsNode if operation succeeds, NULL otherwise										*/
/*	Modified :																	*/
/* ============================================================================	*/

OSCL_EXPORT_REF const OsclMemStatsNode* MM_Audit_Imp::MM_GetExistingTag(const char * tagIn)
{
    MMAuditCharAutoPtr tag;
    makeValidTag(tagIn, tag); //tagIn = NULL means root tag
    OsclTagTreeType::iterator iter = mTagTree.find(tag.get());
    if (iter != mTagTree.end())
        return ((iter->value).get());
    else
        return NULL;
}


/* ============================================================================ */
/*	Function : MM_Validate()													*/
/*	Date     : 10/08/2002														*/
/*	Purpose  : API to check the input pointer is a valid pointer to a chunk of  */
/*			   memory															*/
/*	In/out   : all parameters are input											*/
/*	Return   :																	*/
/*	Modified :																	*/
/* ============================================================================	*/

OSCL_EXPORT_REF bool MM_Audit_Imp::MM_Validate(const void *ptrIn)
{
    bool status = validate(const_cast<void*>(ptrIn));
    return status;
}

/* ============================================================================ */
/*	Function : MM_SetTagLevel()													*/
/*	Date     : 10/08/2002														*/
/*	Purpose  : API to set the maximum tag level,i.e. tag level for a.b.c.d = 4	*/
/*	In/out   : all parameters are input											*/
/*	Return   :																	*/
/*	Modified :																	*/
/* ============================================================================	*/

OSCL_EXPORT_REF void MM_Audit_Imp::MM_SetTagLevel(uint32 level)
{
    if (level >= 1) mnMaxTagLevel = level;
}


OSCL_EXPORT_REF void MM_Audit_Imp::MM_SetMode(uint32 in_mode)
{
    mode = in_mode;
}


OSCL_EXPORT_REF void MM_Audit_Imp::MM_SetPrefillPattern(uint8 pattern)
{
    prefill_pattern = pattern;
}


OSCL_EXPORT_REF void MM_Audit_Imp::MM_SetPostfillPattern(uint8 pattern)
{
    postfill_pattern = pattern;
}

OSCL_EXPORT_REF MM_AllocQueryInfo* MM_Audit_Imp::MM_CreateAllocNodeInfo(uint32 array_size)
{
    return(MM_AllocQueryInfo*)_oscl_malloc(array_size*sizeof(MM_AllocQueryInfo));
}

OSCL_EXPORT_REF void MM_Audit_Imp::MM_ReleaseAllocNodeInfo(MM_AllocQueryInfo* output_array)
{
    _oscl_free(output_array);
}

OSCL_EXPORT_REF uint32 MM_Audit_Imp::MM_GetAllocNodeInfo(MM_AllocQueryInfo* output_array,
        uint32 max_array_size, uint32 offset)
{
    uint32 num_nodes = 0;

    if (!output_array)
    {
        return 0;
    };


    if (offset >= mNumAllocNodes)
    {
        return 0;
    }

    MM_AllocNode *pAllocNode = mpAllocNode;

    // skip the leading nodes
    uint32 ii;
    for (ii = 0; pAllocNode && ii < offset; ++ii, pAllocNode = pAllocNode->pNext)
    {
    }

    if (ii != offset)
    {
        return 0;
    }

    MM_AllocQueryInfo* pOutNode = output_array;

    while (pAllocNode && (num_nodes < max_array_size))
    {

        pOutNode->allocNum = pAllocNode->pAllocInfo->allocNum;
        pOutNode->lineNo = pAllocNode->pAllocInfo->lineNo;
        pOutNode->size = pAllocNode->pAllocInfo->size;
        pOutNode->pMemBlock = pAllocNode->pAllocInfo->pMemBlock;
        pOutNode->size = pAllocNode->pAllocInfo->size;

        if (pAllocNode->pAllocInfo->pFileName)
        {
            oscl_strncpy(pOutNode->fileName, pAllocNode->pAllocInfo->pFileName,
                         oscl_strlen(pAllocNode->pAllocInfo->pFileName) + 1);
            pOutNode->fileName[MM_ALLOC_MAX_QUERY_FILENAME_LEN-1] = '\0';
        }
        else
        {
            pOutNode->fileName[0] = '\0';
        }

        if (pAllocNode->pAllocInfo->pStatsNode->tag)
        {
            oscl_strncpy(pOutNode->tag, pAllocNode->pAllocInfo->pStatsNode->tag,
                         oscl_strlen(pAllocNode->pAllocInfo->pStatsNode->tag) + 1);
            pOutNode->tag[MM_ALLOC_MAX_QUERY_TAG_LEN-1] = '\0';
        }
        else
        {
            pOutNode->tag[0] = '\0';
        }

        ++num_nodes;
        ++pOutNode;
        pAllocNode = pAllocNode->pNext;
    }
    return num_nodes;
}

/* ============================================================================ */
/*	Function : MM_SetFailurePoint()												*/
/*	Date     : 11/05/2002														*/
/*	Purpose  : API to insert allocation failure deterministically according to  */
/*			   allocation number associated with tag							*/
/*	In/out   : all parameters are input											*/
/*	Return   : true if operation succeeds										*/
/*	Modified :																	*/
/* ============================================================================	*/

OSCL_EXPORT_REF bool MM_Audit_Imp::MM_SetFailurePoint(const char * tagIn, uint32 alloc_number)
{
    if (alloc_number == 0) return false;

    bool status = true;
    MMAuditCharAutoPtr tag;
    makeValidTag(tagIn, tag); //tagIn = NULL means root tag
    OsclTagTreeType::iterator miter = mTagTree.find(tag.get());

    if (miter != mTagTree.end())
    {
        /* found */
        OsclMemStatsNode *pStatsNode = (miter->value).get();

        if (pStatsNode == NULL || pStatsNode->pMMFIParam == NULL)
        {
            return false;
        }
        pStatsNode->pMMFIParam->nAllocNum = alloc_number;
    }
    else
    {
        /* Needs to create a new node */
        OsclMemStatsNode *pStatsNode = createStatsNode(tag.get());
        if (pStatsNode == NULL || pStatsNode->pMMFIParam == NULL)
        {
            return false;
        }
        pStatsNode->pMMFIParam->nAllocNum = alloc_number;
    }

    return status;
}


/* ============================================================================ */
/*	Function : MM_UnsetFailurePoint()											*/
/*	Date     : 11/05/2002														*/
/*	Purpose  : API to cancel the allocation failure point associated with tag	*/
/*	In/out   : all parameters are input											*/
/*	Return   :																	*/
/*	Modified :																	*/
/* ============================================================================	*/

OSCL_EXPORT_REF void MM_Audit_Imp::MM_UnsetFailurePoint(const char * tagIn)
{
    MMAuditCharAutoPtr tag;
    makeValidTag(tagIn, tag); //tagIn = NULL means root tag
    OsclTagTreeType::iterator miter = mTagTree.find(tag.get());

    if (miter != mTagTree.end())
    {
        /* found */
        OsclMemStatsNode *pStatsNode = (miter->value).get();
        if (pStatsNode && pStatsNode->pMMFIParam)
        {
            pStatsNode->pMMFIParam->nAllocNum = 0;
        }
    }
}


/*
* ===================== PRIVATE (SUPPORTING) FUNCTIONS ===========================
*/


#if MM_AUDIT_ALLOC_NODE_SUPPORT
/* ============================================================================ */
/*	Function : addAllocNode()													*/
/*	Date     : 10/08/2002														*/
/*	Purpose  : add a node in memory allocation table triggered by an allocation	*/
/*			   attempt, i.e. MM_allocate(); then update/creat the corresponding */
/*			   node in memory statistics table									*/
/*	In/out   : all parameters are input											*/
/*	Return   : true if operation succeeds										*/
/*	Modified :																	*/
/* ============================================================================	*/

MM_AllocNode* MM_Audit_Imp::addAllocNode(void *pMemBlockIn, uint32 sizeIn,
        OsclMemStatsNode *pStatsNode,
        const char *pFileName, uint32 lineNumber
                                        )
{
    uint32 tmp_overhead_size = 0;

    /**
     * 1. allocate memory for a new node
     */

    MM_AllocNodeAutoPtr currAllocAutoPtr(new MM_AllocNode);
    if (! currAllocAutoPtr.get())
    {
        return NULL;
    }
    tmp_overhead_size += sizeof(MM_AllocNode);

    MM_AllocInfo* pAllocInfo = currAllocAutoPtr->pAllocInfo = new MM_AllocInfo;
    if (pAllocInfo == NULL)
    {
        return NULL;
    }
    tmp_overhead_size += sizeof(MM_AllocInfo);

    // allocate space for the filename in AllocInfo
    if (pFileName)
    {
        int len = oscl_strlen(pFileName);
        Oscl_TAlloc<char, OsclMemBasicAllocator> charAlloc;
        if ((pAllocInfo->pFileName =
                    charAlloc.allocate(len + 1)) == NULL)
        {
            return NULL;
        }
        oscl_strncpy(const_cast<char*>(pAllocInfo->pFileName), pFileName, oscl_strlen(pFileName) + 1);
        tmp_overhead_size += len + 1;
    }

    pAllocInfo->allocNum  = mnAllocNum;

    //To find memory leaks by allocation number, put a debug breakpoint here, like this:
    //if(mnAllocNum==113)
    //{
    //  mnAllocNum++;
    //  mnAllocNum--;
    //}

    //To find allocations with a NULL filename, put a debug breakpoint here, like this:
    //if(pFileName==NULL)
    //{
    //  mnAllocNum++;
    //  mnAllocNum--;
    //}

    mnAllocNum++;

    pAllocInfo->pMemBlock = pMemBlockIn;
    pAllocInfo->size	  = sizeIn;
    pAllocInfo->lineNo  = lineNumber;
    pAllocInfo->pStatsNode = pStatsNode;

    if (!mpCurrAllocNode)  /* First node */
    {
        /* mpAllocNode always represents the very first node */
        mpAllocNode = mpCurrAllocNode = currAllocAutoPtr.release();
    }
    else
    {
        OSCL_ASSERT(!mpCurrAllocNode->pNext);
        mpCurrAllocNode->pNext = currAllocAutoPtr.release();
        currAllocAutoPtr->pPrev = mpCurrAllocNode;
        mpCurrAllocNode = mpCurrAllocNode->pNext;
    }

#if 0
    //for debug & analysis-- print all allocations as they occur...
    fprintf(stderr, "Alloc Info:\n");
    fprintf(stderr, "  allocNum %d\n", pAllocInfo->allocNum);
    fprintf(stderr, "  fileName %s\n", pAllocInfo->pFileName);
    fprintf(stderr, "  lineNo %d\n", pAllocInfo->lineNo);
    fprintf(stderr, "  size %d\n", pAllocInfo->size);
    fprintf(stderr, "  pMemBlock 0x%x\n", pAllocInfo->pMemBlock);
    fprintf(stderr, "  tag %s\n", pAllocInfo->pStatsNode->tag);
#endif

    /* increment the list counter */
    ++mNumAllocNodes;

    mm_audit_per_block_overhead += tmp_overhead_size;
    return mpCurrAllocNode;

}

/* ============================================================================ */
/*	Function : removeAllocNode()												*/
/*	Date     : 10/08/2002														*/
/*	Purpose  : remove a node in memory allocation table triggered by an			*/
/*			   de-allocationattempt, i.e. MM_deallocate()						*/
/*	In/out   : all parameters are input											*/
/*	Return   : true if operation succeeds										*/
/*	Modified :																	*/
/* ============================================================================	*/

OsclMemStatsNode* MM_Audit_Imp::removeAllocNode(void *pMemBlockIn, uint32& size)
{

    if (pMemBlockIn == NULL)
        return NULL;

    OsclMemStatsNode *pStatsNode = NULL;

    OSCL_ASSERT(mpAllocNode);
    OSCL_ASSERT(mpCurrAllocNode);
    OSCL_ASSERT(mNumAllocNodes);

    /* take the allocation node pointer from the control info header */
    MM_AllocBlockHdr *pMemBlockHdr = static_cast<MM_AllocBlockHdr*>(pMemBlockIn);
    MM_AllocNode *pAllocNode = static_cast<MM_AllocNode*>(pMemBlockHdr->pNode);
    if (!pAllocNode)  return NULL;

    /*
     * 1. remove the current node from the list
     */
    if (pAllocNode == mpAllocNode)
    {
        /* head of the list*/
        mpAllocNode = mpAllocNode->pNext;
        if (mpAllocNode)
        {
            mpAllocNode->pPrev = NULL;
        }
        else
        {
            // list is empty
            mpCurrAllocNode = mpAllocNode = NULL;
        }
    }
    else if (pAllocNode == mpCurrAllocNode) /* end of the list */
    {
        mpCurrAllocNode = mpCurrAllocNode->pPrev;
        if (mpCurrAllocNode)
        {
            mpCurrAllocNode->pNext = NULL;
        }
        else
        {
            // list is empty
            mpCurrAllocNode = mpAllocNode = NULL;
        }
    }
    else   /* somewhere in the list */
    {
        MM_AllocNode *pPrevNode = pAllocNode->pPrev;
        MM_AllocNode *pNextNode = pAllocNode->pNext;

        OSCL_ASSERT(pPrevNode && pNextNode);

        pPrevNode->pNext = pNextNode;
        pNextNode->pPrev = pPrevNode;
    }

    /**
     * 2. free the memory for the current node
     */
    OSCL_ASSERT(pAllocNode->pAllocInfo);
    pStatsNode = pAllocNode->pAllocInfo->pStatsNode;
    size = pAllocNode->pAllocInfo->size;

    // adjust the overhead accounting
    uint32 filename_len = (pAllocNode->pAllocInfo->pFileName) ? oscl_strlen(pAllocNode->pAllocInfo->pFileName) + 1 : 0;
    mm_audit_per_block_overhead -= sizeof(MM_AllocNode) + sizeof(MM_AllocInfo) +
                                   filename_len;


    OSCL_DELETE(pAllocNode);


    /*
     * decrement the list counter
     */
    --mNumAllocNodes;


    return pStatsNode;

}

/* ============================================================================ */
/*	Function : removeALLAllocNodes()											*/
/*	Date     : 10/08/2002														*/
/*	Purpose  : remove all the nodes in memory allocation table needed in 		*/
/*			   destructor														*/
/*	In/out   :																	*/
/*	Return   :																	*/
/*	Modified :																	*/
/* ============================================================================	*/

void MM_Audit_Imp::removeALLAllocNodes()
{

    while (mpCurrAllocNode)
    {
        MM_AllocNode *pTmpNode = mpCurrAllocNode;
        mpCurrAllocNode = mpCurrAllocNode->pPrev;
        if (mpCurrAllocNode)
            mpCurrAllocNode->pNext = NULL;
        --mNumAllocNodes;
        OSCL_DELETE(pTmpNode);
    }
}


bool MM_Audit_Imp::validate_all_heap()
{

    // walk the list of allocated nodes
    MM_AllocNode *ptr = mpAllocNode;

    if (!ptr)
    {
        OSCL_ASSERT(mNumAllocNodes == 0);
        return true;
    }

    uint32 counter;

    OSCL_ASSERT(ptr->pPrev == NULL);
    for (counter = 0; ptr; ptr = ptr->pNext, ++counter)
    {
        MM_AllocBlockHdr *pMemBlockHdr = static_cast<MM_AllocBlockHdr*>(ptr->pAllocInfo->pMemBlock);

        OSCL_ASSERT(pMemBlockHdr->pNode == (void *)ptr);
        if (ptr->pNext)
        {
            OSCL_ASSERT(ptr->pNext->pPrev == ptr);
        }
        else
        {
            OSCL_ASSERT(ptr == mpCurrAllocNode);
        }

        uint8* pMem = static_cast<uint8*>(static_cast<void*>(pMemBlockHdr));
        pMem += BLOCK_HDR_SIZE;
        bool status = validate(pMem);
        OSCL_ASSERT(status);
        if (!status)
        {
            return false;
        }
    }

    OSCL_ASSERT(counter == mNumAllocNodes);

    return true;

}


#endif // #if MM_AUDIT_ALLOC_NODE_SUPPORT

/* ============================================================================ */
/*	Function : validate()														*/
/*	Date     : 11/05/2002														*/
/*	Purpose  : validate the input pointer to a chunk of memory					*/
/*	In/out   : input the memory pointer						*/
/*	Return   : true if operation succeeds										*/
/*	Modified :																	*/
/* ============================================================================	*/

bool MM_Audit_Imp::validate(void *ptrIn)
{
    if (!ptrIn) return false;

    uint8 *pMem = static_cast<uint8*>(const_cast<void*>(ptrIn));

    pMem -= BLOCK_HDR_SIZE;

    MM_AllocBlockHdr *pMemBlockHdr =
        static_cast<MM_AllocBlockHdr*>((void *)pMem);

    OSCL_ASSERT(pMemBlockHdr->pNode);
    if (!pMemBlockHdr->pNode)
    {
        return false;
    }


    OsclMemStatsNode *pStatsNode = NULL;
#if MM_AUDIT_ALLOC_NODE_SUPPORT
#if MM_AUDIT_FENCE_SUPPORT
    uint32 size = pMemBlockHdr->size;
#endif
    if (pMemBlockHdr->isAllocNodePtr())
    {
        MM_AllocNode *pAllocNode = NULL;
        pAllocNode = static_cast<MM_AllocNode*>(pMemBlockHdr->pNode);
        OSCL_ASSERT(pAllocNode->pAllocInfo);
#if MM_AUDIT_FENCE_SUPPORT
        OSCL_ASSERT(((size ^ pAllocNode->pAllocInfo->size) & (~MM_AllocBlockHdr::ALLOC_NODE_FLAG)) == 0);
        size = pAllocNode->pAllocInfo->size;
#endif
        pStatsNode =  pAllocNode->pAllocInfo->pStatsNode;
    }
#endif

    if (!pStatsNode)
    {
        // must be a stats node
        pStatsNode = static_cast<OsclMemStatsNode*>(pMemBlockHdr->pNode);
    }

    OSCL_ASSERT(pStatsNode->pMMStats);

#if MM_AUDIT_FENCE_SUPPORT
    bool status;

    // check the pre-fence
    MM_AllocBlockFence *fence =
        static_cast<MM_AllocBlockFence*>(static_cast<void*>(pMem +
                                         CONTROL_HEADER_SIZE));
    status = fence->check_fence();
    OSCL_ASSERT(status);
    if (!status)
    {
        return status;
    }

    // check the post fence
    fence =
        static_cast<MM_AllocBlockFence*>(static_cast<void*>(pMem +
                                         BLOCK_HDR_SIZE
                                         + size));
    status = fence->check_fence();
    OSCL_ASSERT(status);
    if (!status)
    {
        return status;
    }
#endif

    return true;
}

/** Retrieve the audit root pointer from within an allocation block*/
OsclMemAudit * MM_Audit_Imp::getAuditRoot(void *ptrIn)
{
    if (!ptrIn) return false;

    uint8 *pMem = static_cast<uint8*>(const_cast<void*>(ptrIn));

    pMem -= BLOCK_HDR_SIZE;

    MM_AllocBlockHdr *pMemBlockHdr =
        static_cast<MM_AllocBlockHdr*>((void *)pMem);

    return (OsclMemAudit*)pMemBlockHdr->pRootNode;
}

uint32 MM_Audit_Imp::getSize(void *ptrIn)
{//get original allocation size.

    if (!ptrIn)
        return 0;

    uint8 *pMem = static_cast<uint8*>(const_cast<void*>(ptrIn));

    pMem -= BLOCK_HDR_SIZE;

    MM_AllocBlockHdr *pMemBlockHdr = static_cast<MM_AllocBlockHdr*>((void *)pMem);

    //if it's an alloc node we have to strip out the alloc node bit
    //from the size field.
    if (pMemBlockHdr->isAllocNodePtr())
    {
        return pMemBlockHdr->size & ~MM_AllocBlockHdr::ALLOC_NODE_FLAG;
    }
    else
    {
        return pMemBlockHdr->size;
    }
}


/* ============================================================================ */
/*	Function : createStatsNode()												*/
/*	Date     : 10/08/2002														*/
/*	Purpose  : creat a new node in memory statistics table triggered by an		*/
/*			   allocation attempt,												*/
/*	In/out   : all parameters are input											*/
/*	Return   : true if operation succeeds										*/
/*	Modified :																	*/
/* ============================================================================	*/


OsclMemStatsNode* MM_Audit_Imp::createStatsNode(const char *  tagIn)
{
    OsclTagTreeType::iterator iter;
    MMAuditCharAutoPtr currentTag;
    OsclMemStatsNode* statsNode;

    /* If the input tag already exists in the tagtree, it should have a pointer value of NULL */
    OSCL_ASSERT((mTagTree.find(const_cast<char* const&>(tagIn)) == mTagTree.end()) ||
                (mTagTree.find(const_cast<char* const&>(tagIn)))->value.get() == 0);

#if 1
    statsNode = new OsclMemStatsNode;
    if (statsNode == NULL) return NULL;

    currentTag.allocate(oscl_strlen(tagIn) + 1);
    if (!currentTag.get()) return NULL;
    oscl_strncpy(currentTag.get(), tagIn, oscl_strlen(tagIn) + 1);
    statsNode->tag = currentTag.release();

    if ((statsNode->pMMStats = new MM_Stats_t) == NULL) return NULL;

    if ((statsNode->pMMFIParam = new MM_FailInsertParam) == NULL) return NULL;

    OsclMemStatsNodeAutoPtr statsNodeAutoPtr(statsNode);

    // reassign ownership of the StatsNode to the tag tree
    mTagTree[statsNodeAutoPtr->tag] = statsNodeAutoPtr;

    // account for the overhead memory
    mm_audit_stats_overhead += sizeof(MM_Stats_t) +
                               sizeof(MM_FailInsertParam) +
                               sizeof(OsclMemStatsNode) +
                               oscl_strlen(currentTag.get()) + 1;

    // how many levels deep is the node we just inserted?
    iter = mTagTree.find(statsNodeAutoPtr->tag);
    uint32 depth = iter->depth();

    // the tag tree will automatically create the parent, grandparent, etc.
    // make sure each ancestor's stats node is initialized, i.e. initialize each ancestor
    // until you reach one that is already initialized.
    OsclTagTreeType::node_ptr parent = iter->parent;
    for (uint32 ii = 0; ii < depth; ii++)
    {

        OSCL_ASSERT(parent != 0);

        // if initialized then we're done
        OsclMemStatsNode* tmpStatsNode = (parent->value).get();
        if (tmpStatsNode != NULL) break;

        // create new stats node
        tmpStatsNode = new OsclMemStatsNode;
        if (tmpStatsNode == NULL) return NULL;

        // copy tag already created by the tag tree
        currentTag.allocate(oscl_strlen(parent->tag.tag) + 1);
        if (!currentTag.get()) return NULL;
        oscl_strncpy(currentTag.get(), parent->tag.tag, oscl_strlen(parent->tag.tag) + 1);
        tmpStatsNode->tag = currentTag.release();

        if ((tmpStatsNode->pMMStats = new MM_Stats_t) == NULL) return NULL;

        if ((tmpStatsNode->pMMFIParam = new MM_FailInsertParam) == NULL) return NULL;

        // set the new stats node to be held by the tag tree
        parent->value.takeOwnership(tmpStatsNode);

        // account for the overhead memory
        mm_audit_stats_overhead += sizeof(OsclMemStatsNode) +
                                   oscl_strlen(currentTag.get()) + 1 +
                                   sizeof(MM_Stats_t) +
                                   sizeof(MM_FailInsertParam);

        parent = parent->parent;
    }

    return statsNode;
#else
    OsclMemStatsNodeAutoPtr pCurrentStatsAutoPtr;
    OsclMemStatsNode* pStatsNodePtr = NULL;
    uint32 len = oscl_strlen(tagIn) + 1;

    do
    {
        if ((iter = mTagTree.find(currentTag.get())) == mTagTree.end())
        {
            // printf("Didn't find tag %s.  Creating a new stats node\n", currentTag.get());
            OsclMemStatsNodeAutoPtr statsNodeAutoPtr(new OsclMemStatsNode);
            if (statsNodeAutoPtr.get() == NULL)
            {
                return NULL;
            }

            // statsNodeAutoPtr will now "own" the tag string. It will
            // be responsible for freeing it.
            statsNodeAutoPtr->tag = currentTag.release();

            if ((statsNodeAutoPtr->pMMStats = new MM_Stats_t) == NULL)
            {
                return NULL;
            }

            if ((statsNodeAutoPtr->pMMFIParam = new MM_FailInsertParam) == NULL)
            {
                return NULL;
            }

            // reassign ownership of the StatsNode to the map class
            mTagTree[statsNodeAutoPtr->tag] = statsNodeAutoPtr;

            // account for the overhead memory
            mm_audit_stats_overhead += sizeof(MM_Stats_t) +
                                       sizeof(MM_FailInsertParam) + sizeof(OsclMemStatsNode) +
                                       oscl_strlen(currentTag.get()) + 1;

            pStatsNodePtr = statsNodeAutoPtr.get();

            // update the current ptr
            pCurrentStatsAutoPtr = statsNodeAutoPtr;

            // Get the parent tag length
            len = retrieveParentTagLength(tagIn, len - 1);

            if (len > 0)
            {
                currentTag.allocate(len);
                if (! currentTag.get())
                {
                    return NULL;
                }
                strncpy(currentTag.get(), tagIn, len);
                *(currentTag.get() + (len - 1)) = '\0';
            }

        }
        else
        {
            break;
        }
    }
    while (len > 0);

    return pStatsNodePtr;
#endif
}


/* ============================================================================ */
/*	Function : updateStatsNode()												*/
/*	Date     : 10/08/2002														*/
/*	Purpose  : update the node in memory statistics table triggered by an		*/
/*			   allocation/de-alocation attempt,									*/
/*	In/out   : all parameters are input											*/
/*	Return   : true if operation succeeds										*/
/*	Modified :																	*/
/* ============================================================================	*/


bool MM_Audit_Imp::updateStatsNode(OsclMemStatsNode *pCurrStatsNode, const MM_Stats_t& delta, bool add)
{
    MMAuditCharAutoPtr tag;
    makeValidTag((const char*)(pCurrStatsNode->tag), tag);

    //Update
    if (!pCurrStatsNode->pMMStats) return false;
    pCurrStatsNode->pMMStats->update(delta, add);

    OsclTagTreeType::iterator miter = mTagTree.find(tag.get());

    uint32 depth = miter->depth();

    OsclTagTreeType::node_ptr parent = miter->parent;

    for (uint32 i = 0; i < depth; i++)
    {
        if (!parent->value->pMMStats) return false;
        parent->value->pMMStats->update(delta, add);
        parent = miter->parent;
    }

    return true;
}


/* ============================================================================ */
/*	Function : updateStatsNodeInFailure()										*/
/*	Date     : 11/05/2002														*/
/*	Purpose  : update "pMMStats->numAllocFails" for the current tag node with 	*/
/*			   its parent tag nodes												*/
/*	In/out   : all parameters are input											*/
/*	Return   : true if operation succeeds										*/
/*	Modified :																	*/
/* ============================================================================	*/
bool MM_Audit_Imp::updateStatsNodeInFailure(const char * tagIn)
{
    MMAuditCharAutoPtr tag;
    makeValidTag(tagIn, tag);
    OsclTagTreeType::iterator miter = mTagTree.find(tag.get());
    OsclMemStatsNode *pStatsNode;
    if (miter != mTagTree.end())
    {/* found */
        pStatsNode = (miter->value).get();
    }
    else
    {
        pStatsNode = mpStatsNode; // update the root node
    }

    return updateStatsNodeInFailure(pStatsNode);
}

bool MM_Audit_Imp::updateStatsNodeInFailure(OsclMemStatsNode * pStatsNode)
{
    MMAuditCharAutoPtr tag;

    if (!pStatsNode) return false;

    makeValidTag((const char*)(pStatsNode->tag), tag);

    if (!pStatsNode->pMMStats) return false;
    pStatsNode->pMMStats->numAllocFails++;

    OsclTagTreeType::iterator miter = mTagTree.find(tag.get());

    uint32 depth = miter->depth();

    OsclTagTreeType::node_ptr parent = miter->parent;

    for (uint32 i = 0; i < depth; i++)
    {
        if (!parent->value->pMMStats) return false;
        parent->value->pMMStats->numAllocFails++;
        parent = miter->parent;
    }

    return true;
}

/* ============================================================================ */
/*	Function : isSetFailure()													*/
/*	Date     : 11/05/2002														*/
/*	Purpose  : do allocation failure check										*/
/*	In/out   : all parameters are input											*/
/*	Return   : true if operation succeeds										*/
/*	Modified :																	*/
/* ============================================================================	*/

bool MM_Audit_Imp::isSetFailure(const char * tagIn)
{
    MMAuditCharAutoPtr tag;
    makeValidTag(tagIn, tag);
    OsclTagTreeType::iterator miter = mTagTree.find(tag.get());
    if (miter != mTagTree.end()) /* found */
    {
        OsclMemStatsNode *pStatsNode = (miter->value).get();
        return isSetFailure(pStatsNode);
    }

    return false;
}

bool MM_Audit_Imp::isSetFailure(OsclMemStatsNode* pStatsNode)
{
    if (pStatsNode == NULL) return false;

    if (pStatsNode->pMMFIParam == NULL) return false;

    /* decision for deterministic failure insertion */
    if (pStatsNode->pMMFIParam->nAllocNum > 0)
    {
        /* the "+ 1" term in the computation of total_allocs is to
         * count the current allocation
         */
        uint32 total_allocs = pStatsNode->pMMStats->peakNumAllocs + 1 +
                              pStatsNode->pMMStats->numAllocFails ;

        if (total_allocs == pStatsNode->pMMFIParam->nAllocNum)
            return true;
    }

    return false;
}
/* ========================================================================================== */
/*	Function : retrieveParentTagLength()													  */
/*	Date     : 10/16/2002																	  */
/*	Purpose  : get the length of the parent tag(i.e."a.b.c") of the input tag(i.e. "a.b.c.d") */
/*			   current node and counter it													  */
/*	In/out   : all parameters are input														  */
/*	Return   : length of the parent tag(sub-string)	of an input tag							  */
/*	Modified :																				  */
/* ========================================================================================== */

int32 MM_Audit_Imp::retrieveParentTagLength(const char *tag, int32 bound)
{
    if (!tag)  return 0;

#define PV_MIN(a,b)	  ((a)<(b)? (a):(b))

    int count = 0;
    int len = PV_MIN((int32)(oscl_strlen(tag)), bound);
    if (len <= 0)
        return 0;
    else
    {
        bool bFound = false;
        for (count = len - 1; count >= 0; count--)
        {
            if (tag[count] == '.')
            {
                bFound = true;
                break;
            }
        }
        if (!bFound)	 count = 0;
    }

    return count + 1;
}

void MM_Audit_Imp::retrieveParentTag(char *tag)
{
    if (!tag)  return;

    int32 len = oscl_strlen(tag);
    if (len == 1)
        tag[0] = '\0';
    else
    {
        bool bFound = false;
        for (int32 i = len - 1; i >= 0; i--)
        {
            if (tag[i] == '.')
            {
                tag[i] = '\0';
                bFound = true;
                break;
            }
        }
        if (!bFound)
            tag[0] = '\0';
    }
}

/* ========================================================================================== */
/*	Function : makeValidTag()																  */
/*	Date     : 10/25/2002																	  */
/*	Purpose  : check the input tag and make sure its level would be bounded in maximum tag    */
/*			   level, if its level is larger, then truncate it								  */
/*			   Note that level of "a.b.c.d" = 4												  */
/*	In/out   : In: tagIn ; Out: *bFree														  */
/*	Return   : a valid tag within the maximum tag level constraint							  */
/*	Modified :																				  */
/* ========================================================================================== */

void MM_Audit_Imp::makeValidTag(const char * tagIn, MMAuditCharAutoPtr& autoptr)
{

    if (tagIn == NULL)
    {
        //tagIn = NULL means root tag
        autoptr.setWithoutOwnership(const_cast<char*>(root_tag));
    }

    else
    {
        uint32 len = getTagActualSize(tagIn);
        if (len == 0)
        {
            /* len = 0 meaning no need of truncation */
            autoptr.setWithoutOwnership(const_cast<char*>(tagIn));
        }

        else
        {
            autoptr.allocate(len + 1);
            oscl_strncpy(autoptr.get(), tagIn, len);
            *(autoptr.get() + len) = '\0';
        }
    }
}

/* ========================================================================================== */
/*	Function : getTagActualSize()															  */
/*	Date     : 10/25/2002																	  */
/*	Purpose  : get the actual size of an input tag within the maximum tag level constraint    */
/*			   Note that level of "a.b.c.d" = 4												  */
/*	In/out   : In: tagIn ; Out: *bFree														  */
/*	Return   : 0 means no truncation ; >0 means truncated size								  */
/*	Modified :																				  */
/* ========================================================================================== */

uint32 MM_Audit_Imp::getTagActualSize(const char * tagIn)
{
    uint32 i, len;
    uint32 level = 0, count = 0;

    len = oscl_strlen(tagIn);
    if (len <= 2*mnMaxTagLevel - 1)
        return 0; /* no truncation */

    for (i = 0; i < len; i++)
    {
        if (tagIn[i] == '.')
        {
            if (++level == mnMaxTagLevel)
            {
                count = i;
                break;
            }
        }
    }
    return count;
}


#endif //if OSCL_BYPASS_MEMMGT