// Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// kernel\eka\common\debugfunction.cpp

// 

//

#include "common.h"

#ifdef __KERNEL_MODE__

#include <kernel/kern_priv.h>

#endif

#include "dla.h"

#ifndef __KERNEL_MODE__

#include "slab.h"

#include "page_alloc.h"

#endif

#include "heap_hybrid.h"

#define GM  (&iGlobalMallocState)

#define __HEAP_CORRUPTED_TRACE(t,p,l) BTraceContext12(BTrace::EHeap, BTrace::EHeapCorruption, (TUint32)t, (TUint32)p, (TUint32)l);

#define __HEAP_CORRUPTED_TEST(c,x, p,l) if (!c) { if (iFlags & (EMonitorMemory+ETraceAllocs) )  __HEAP_CORRUPTED_TRACE(this,p,l)  HEAP_PANIC(x); }

#define __HEAP_CORRUPTED_TEST_STATIC(c,t,x,p,l) if (!c) { if (t && (t->iFlags & (EMonitorMemory+ETraceAllocs) )) __HEAP_CORRUPTED_TRACE(t,p,l) HEAP_PANIC(x); }

TInt RHybridHeap::DebugFunction(TInt aFunc, TAny* a1, TAny* a2)

{

    TInt r = KErrNone;

    switch(aFunc)

        {

        case RAllocator::ECount:

            struct HeapInfo info;

            Lock();

            GetInfo(&info, NULL);

            *(unsigned*)a1 = info.iFreeN;

            r = info.iAllocN;

            Unlock();

            break;

        case RAllocator::EMarkStart:

            __DEBUG_ONLY(DoMarkStart());

            break;

        case RAllocator::EMarkEnd:

            __DEBUG_ONLY( r = DoMarkEnd((TInt)a1) );

            break;

        case RAllocator::ECheck:

            r = DoCheckHeap((SCheckInfo*)a1);

            break;

        case RAllocator::ESetFail:

            __DEBUG_ONLY(DoSetAllocFail((TAllocFail)(TInt)a1, (TInt)a2));

            break;

        case RAllocator::EGetFail:

            __DEBUG_ONLY(r = iFailType);

            break;

        case RAllocator::ESetBurstFail:

#if _DEBUG

            {

            SRAllocatorBurstFail* fail = (SRAllocatorBurstFail*) a2;

            DoSetAllocFail((TAllocFail)(TInt)a1, fail->iRate, fail->iBurst);

            }

#endif

            break;

        case RAllocator::ECheckFailure:

            // iRand will be incremented for each EFailNext, EBurstFailNext,

            // EDeterministic and EBurstDeterministic failure.

            r = iRand;

            break;

        case RAllocator::ECopyDebugInfo:

            {

            TInt nestingLevel = ((SDebugCell*)a1)[-1].nestingLevel;

            ((SDebugCell*)a2)[-1].nestingLevel = nestingLevel;

            break;

            }

		case RAllocator::EGetSize:

			{

			r = iChunkSize - sizeof(RHybridHeap);

			break;

			}

		case RAllocator::EGetMaxLength:

			{

			r = iMaxLength;

			break;

			}

		case RAllocator::EGetBase:

			{

			*(TAny**)a1 = iBase;

			break;

			}

		case RAllocator::EAlignInteger:

			{

			r = _ALIGN_UP((TInt)a1, iAlign);

			break;

			}

		case RAllocator::EAlignAddr:

			{

            *(TAny**)a2 = (TAny*)_ALIGN_UP((TLinAddr)a1, iAlign);

			break;

			}

        case RHybridHeap::EWalk:

            struct HeapInfo hinfo;

            SWalkInfo winfo;

            Lock();

            winfo.iFunction = (TWalkFunc)a1;

            winfo.iParam    = a2;

			winfo.iHeap     = (RHybridHeap*)this; 	

            GetInfo(&hinfo, &winfo);

            Unlock();

            break;

#ifndef __KERNEL_MODE__

        case RHybridHeap::EHybridHeap:

            {

			if ( !a1 )

				return KErrGeneral;

			STestCommand* cmd = (STestCommand*)a1;

			switch ( cmd->iCommand )

				{

				case EGetConfig:

					cmd->iConfig.iSlabBits = iSlabConfigBits;

					cmd->iConfig.iDelayedSlabThreshold = iPageThreshold;

					cmd->iConfig.iPagePower = iPageThreshold;

					break;

				case ESetConfig:

					//

					// New configuration data for slab and page allocator.

					// Reset heap to get data into use

					//

#if USE_HYBRID_HEAP

					iSlabConfigBits  = cmd->iConfig.iSlabBits & 0x3fff;

					iSlabInitThreshold = cmd->iConfig.iDelayedSlabThreshold;

					iPageThreshold = (cmd->iConfig.iPagePower & 0x1f);

					Reset();

#endif

					break;

				case EHeapMetaData:

					cmd->iData = this;

					break;

				case ETestData:

					iTestData = cmd->iData;

					break;

				default:

					return KErrNotSupported;

				}

            break;

			}

#endif  // __KERNEL_MODE            

        default:

            return KErrNotSupported;

        }

    return r;

}

void RHybridHeap::Walk(SWalkInfo* aInfo, TAny* aBfr, TInt aLth, TCellType aBfrType, TAllocatorType aAllocatorType)

{

    //

    // This function is always called from RHybridHeap::GetInfo.

    // Actual walk function is called if SWalkInfo pointer is defined

    // 

    //

    if ( aInfo )

        {

#ifdef __KERNEL_MODE__

		(void)aAllocatorType;

#if defined(_DEBUG)		

		if ( aBfrType == EGoodAllocatedCell )

			aInfo->iFunction(aInfo->iParam, aBfrType, ((TUint8*)aBfr+EDebugHdrSize), (aLth-EDebugHdrSize) );

		else

			aInfo->iFunction(aInfo->iParam, aBfrType,  aBfr, aLth );

#else

		aInfo->iFunction(aInfo->iParam, aBfrType, aBfr, aLth );

#endif

#else  // __KERNEL_MODE__

        if ( aAllocatorType & (EFullSlab + EPartialFullSlab + EEmptySlab + ESlabSpare) )

			{

			if ( aInfo->iHeap )

				{

				TUint32 dummy;

				TInt    npages;

				aInfo->iHeap->DoCheckSlab((slab*)aBfr, aAllocatorType);

				__HEAP_CORRUPTED_TEST_STATIC(aInfo->iHeap->CheckBitmap(Floor(aBfr, PAGESIZE), PAGESIZE, dummy, npages),

											 aInfo->iHeap, ETHeapBadCellAddress, aBfr, aLth);

				}

			if ( aAllocatorType & EPartialFullSlab )

				 WalkPartialFullSlab(aInfo, (slab*)aBfr, aBfrType, aLth);	

            else if ( aAllocatorType & EFullSlab )

					WalkFullSlab(aInfo, (slab*)aBfr, aBfrType, aLth);

			}

#if defined(_DEBUG)     

        else  if ( aBfrType == EGoodAllocatedCell )

            aInfo->iFunction(aInfo->iParam, aBfrType, ((TUint8*)aBfr+EDebugHdrSize), (aLth-EDebugHdrSize) );

        else

            aInfo->iFunction(aInfo->iParam, aBfrType,  aBfr, aLth );

#else

        else

            aInfo->iFunction(aInfo->iParam, aBfrType, aBfr, aLth );

#endif

#endif // __KERNEL_MODE	

        }

}

#ifndef __KERNEL_MODE__

void RHybridHeap::WalkPartialFullSlab(SWalkInfo* aInfo, slab* aSlab, TCellType /*aBfrType*/, TInt /*aLth*/)

{

	if ( aInfo )

		{

		//

		// Build bitmap of free buffers in the partial full slab

		//

		TUint32 bitmap[4];

		__HEAP_CORRUPTED_TEST_STATIC( (aInfo->iHeap != NULL), aInfo->iHeap, ETHeapBadCellAddress, 0, aSlab);

		aInfo->iHeap->BuildPartialSlabBitmap(bitmap, aSlab);

		//

		// Find used (allocated) buffers from iPartial full slab

		//

		TUint32 h = aSlab->iHeader;

		TUint32 size = SlabHeaderSize(h);

		TUint32 count = KMaxSlabPayload / size;  // Total buffer count in slab

		TUint32 i = 0;

		TUint32 ix = 0;

		TUint32 bit = 1;				

		while ( i < count )

			{

			if ( bitmap[ix] & bit )

				{

				aInfo->iFunction(aInfo->iParam, EGoodFreeCell, &aSlab->iPayload[i*size], size ); 

				} 

			else

				{

#if defined(_DEBUG)

				aInfo->iFunction(aInfo->iParam, EGoodAllocatedCell, (&aSlab->iPayload[i*size]+EDebugHdrSize), (size-EDebugHdrSize) );

#else				

				aInfo->iFunction(aInfo->iParam, EGoodAllocatedCell, &aSlab->iPayload[i*size], size );

#endif

				}

			bit <<= 1;

			if ( bit == 0 )

				{

				bit = 1;

				ix ++;

				}

			i ++;

			}

		}

}

void RHybridHeap::WalkFullSlab(SWalkInfo* aInfo, slab* aSlab, TCellType aBfrType, TInt /*aLth*/)

{

	if ( aInfo )

		{

		TUint32 h = aSlab->iHeader;

		TUint32 size = SlabHeaderSize(h);

		TUint32 count = (SlabHeaderUsedm4(h) + 4) / size;

		TUint32 i = 0;

		while ( i < count )

			{

#if defined(_DEBUG)

			if ( aBfrType == EGoodAllocatedCell )

				aInfo->iFunction(aInfo->iParam, aBfrType, (&aSlab->iPayload[i*size]+EDebugHdrSize), (size-EDebugHdrSize) );

			else

				aInfo->iFunction(aInfo->iParam, aBfrType, &aSlab->iPayload[i*size], size );

#else

			aInfo->iFunction(aInfo->iParam, aBfrType, &aSlab->iPayload[i*size], size );

#endif      

			i ++;

			}

		}

}

void RHybridHeap::BuildPartialSlabBitmap(TUint32* aBitmap, slab* aSlab, TAny* aBfr)

{

	//

	// Build a bitmap of free buffers in a partial full slab

	//

	TInt i;

	TUint32 bit = 0;

	TUint32 index;  

	TUint32 h = aSlab->iHeader;

	TUint32 used = SlabHeaderUsedm4(h)+4;

	TUint32 size = SlabHeaderSize(h);

	TInt    count = (KMaxSlabPayload / size);

	TInt    free_count = count -  (used / size); // Total free buffer count in slab

	aBitmap[0] = 0, aBitmap[1] = 0,	aBitmap[2] = 0, aBitmap[3] = 0;

	TUint32 offs = (h & 0xff) << 2;

	//

	// Process first buffer in partial slab free buffer chain

	//

	while ( offs )

		{

		unsigned char* p = (unsigned char*)Offset(aSlab, offs); 		

		__HEAP_CORRUPTED_TEST( (sizeof(slabhdr) <= offs), ETHeapBadCellAddress, p, aSlab);

		offs -= sizeof(slabhdr);

		__HEAP_CORRUPTED_TEST( (offs % size == 0), ETHeapBadCellAddress, p, aSlab);

		index = (offs / size);  // Bit index in bitmap

		i = 0;

		while ( i < 4 )

			{

			if ( index < 32 )

				{

				bit = (1 << index);

				break;

				}

			index -= 32;

			i ++;

			}

		__HEAP_CORRUPTED_TEST( ((aBitmap[i] & bit) == 0), ETHeapBadCellAddress, p, aSlab);  // Buffer already in chain

		aBitmap[i] |= bit;

		free_count --;

		offs = ((unsigned)*p) << 2; // Next in free chain

		}

	__HEAP_CORRUPTED_TEST( (free_count >= 0), ETHeapBadCellAddress, aBfr, aSlab);  // free buffer count/size mismatch	

	//

	// Process next rest of the free buffers which are in the

	// wilderness (at end of the slab)

	//

	index = count - 1;

	i = index / 32;

	index = index % 32;

	while ( free_count && (i >= 0))

		{

		bit = (1 << index);

		__HEAP_CORRUPTED_TEST( ((aBitmap[i] & bit) == 0), ETHeapBadCellAddress, aBfr, aSlab);  // Buffer already in chain

		aBitmap[i] |= bit;

		if ( index )

			index --;

		else

			{

			index = 31;

			i --;

			}

		free_count --;

		}

	if ( aBfr )  // Assure that specified buffer does NOT exist in partial slab free buffer chain

		{

		offs = LowBits(aBfr, SLABSIZE);

		__HEAP_CORRUPTED_TEST( (sizeof(slabhdr) <= offs), ETHeapBadCellAddress, aBfr, aSlab);

		offs -= sizeof(slabhdr);

		__HEAP_CORRUPTED_TEST( ((offs % size) == 0), ETHeapBadCellAddress, aBfr, aSlab);

		index = (offs / size);  // Bit index in bitmap

		i = 0;

		while ( i < 4 )

			{

			if ( index < 32 )

				{

				bit = (1 << index);

				break;

				}

			index -= 32;

			i ++;

			}

		__HEAP_CORRUPTED_TEST( ((aBitmap[i] & bit) == 0), ETHeapBadCellAddress, aBfr, aSlab);  // Buffer already in chain

		}

}

#endif	// __KERNEL_MODE__

void RHybridHeap::WalkCheckCell(TAny* aPtr, TCellType aType, TAny* aCell, TInt aLen)

{

    (void)aCell;

    SHeapCellInfo& info = *(SHeapCellInfo*)aPtr;

    switch(aType)

        {

        case EGoodAllocatedCell:

            {

            ++info.iTotalAlloc;

            info.iTotalAllocSize += aLen; 

#if defined(_DEBUG)

            RHybridHeap& h = *info.iHeap;

            SDebugCell* DbgCell = (SDebugCell*)((TUint8*)aCell-EDebugHdrSize);

            if ( DbgCell->nestingLevel == h.iNestingLevel )

                {

                if (++info.iLevelAlloc==1)

                    info.iStranded = DbgCell;

#ifdef __KERNEL_MODE__

                if (KDebugNum(KSERVER) || KDebugNum(KTESTFAST))

                    {

                    Kern::Printf("LEAKED KERNEL HEAP CELL @ %08x : len=%d", aCell, aLen);

                    TLinAddr base = ((TLinAddr)aCell)&~0x0f;

                    TLinAddr end = ((TLinAddr)aCell)+(TLinAddr)aLen;

                    while(base<end)

                        {

                        const TUint32* p = (const TUint32*)base;

                        Kern::Printf("%08x: %08x %08x %08x %08x", p, p[0], p[1], p[2], p[3]);

                        base += 16;

                        }

                    }

#endif

                }

#endif  

            break;

            }

        case EGoodFreeCell:

            ++info.iTotalFree;

            break;

        case EBadAllocatedCellSize:

            HEAP_PANIC(ETHeapBadAllocatedCellSize);

        case EBadAllocatedCellAddress:

            HEAP_PANIC(ETHeapBadAllocatedCellAddress);

        case EBadFreeCellAddress:

            HEAP_PANIC(ETHeapBadFreeCellAddress);

        case EBadFreeCellSize:

            HEAP_PANIC(ETHeapBadFreeCellSize);

        default:

            HEAP_PANIC(ETHeapWalkBadCellType);

        }

}

TInt RHybridHeap::DoCheckHeap(SCheckInfo* aInfo)

{

    (void)aInfo;

    SHeapCellInfo info;

    memclr(&info, sizeof(info));

    info.iHeap = this;

    struct HeapInfo hinfo;

    SWalkInfo winfo;

    Lock();

	DoCheckMallocState(GM);  // Check DL heap internal structure

#ifndef __KERNEL_MODE__

	TUint32 dummy;

	TInt    npages;

	__HEAP_CORRUPTED_TEST(CheckBitmap(NULL, 0, dummy, npages), ETHeapBadCellAddress, this, 0);  // Check page allocator buffers

	DoCheckSlabTrees();	

	DoCheckCommittedSize(npages, GM);

#endif				   

    winfo.iFunction = WalkCheckCell;

    winfo.iParam    = &info;

	winfo.iHeap     = (RHybridHeap*)this; 		

    GetInfo(&hinfo, &winfo);

    Unlock();

#if defined(_DEBUG)

    if (!aInfo)

        return KErrNone;

    TInt expected = aInfo->iCount;

    TInt actual = aInfo->iAll ? info.iTotalAlloc : info.iLevelAlloc;

    if (actual!=expected && !iTestData)

        {

#ifdef __KERNEL_MODE__

        Kern::Fault("KERN-ALLOC COUNT", (expected<<16)|actual );

#else

        User::Panic(_L("ALLOC COUNT"), (expected<<16)|actual );

#endif

        }

#endif

    return KErrNone;

}

#ifdef _DEBUG

void RHybridHeap::DoMarkStart()

{

    if (iNestingLevel==0)

        iAllocCount=0;

    iNestingLevel++;

}

TUint32 RHybridHeap::DoMarkEnd(TInt aExpected)

{

    if (iNestingLevel==0)

        return 0;

    SHeapCellInfo info;

    SHeapCellInfo* p = iTestData ? (SHeapCellInfo*)iTestData : &info;

    memclr(p, sizeof(info));

    p->iHeap = this;

    struct HeapInfo hinfo;

    SWalkInfo winfo;

    Lock();

    winfo.iFunction = WalkCheckCell;

    winfo.iParam    = p;

	winfo.iHeap     = (RHybridHeap*)this; 	

    GetInfo(&hinfo, &winfo);

    Unlock();

    if (p->iLevelAlloc != aExpected && !iTestData)

        return (TUint32)(p->iStranded + 1);

    if (--iNestingLevel == 0)

        iAllocCount = 0;

    return 0;

}

void RHybridHeap::DoSetAllocFail(TAllocFail aType, TInt aRate)

{// Default to a burst mode of 1, as aType may be a burst type.

    DoSetAllocFail(aType, aRate, 1);

}

void ResetAllocCellLevels(TAny* aPtr, RHybridHeap::TCellType aType, TAny* aCell, TInt aLen)

{