/*

* Copyright (c) 2006 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:  

*

*

*/

#include "common.h"

#include "StopScheduler.h"

#include <hal.h>

#ifdef TRACE_CHUNK_USAGE

void TraceChunkUsage(TInt aChunkHandle, TUint8* aBase, TInt aChunkSize)

	{

	RDebug::Print(_L("MEM: c,%d,%d,%d"), aChunkHandle, aBase, aChunkSize);

	}

#else

#define TraceChunkUsage(a,b,c)

#endif

#ifdef __NEW_ALLOCATOR__

#include "MemoryLogger.h"

#include "SymbianDLHeap.h"

_LIT(KDLHeapPanicCategory, "DL Heap");

#define	GET_PAGE_SIZE(x)			UserHal::PageSizeInBytes(x)

#define	__CHECK_CELL(p)

#define __POWER_OF_2(x)				((TUint32)((x)^((x)-1))>=(TUint32)(x))

#define gm  (&iGlobalMallocState)

void Panic(TCdtPanic aPanic)

	{

	User::Panic(KDLHeapPanicCategory, aPanic);

	}

#undef UEXPORT_C

#define UEXPORT_C 

/* Purpose:     Map chunk memory pages from system RAM

 * Arguments:   tp - tchunkptr in which memmory should be mapped

 *              psize - incoming tchunk size

 * Return:      KErrNone if successful, else KErrNoMemory  

 * Note:        

 */

TInt RSymbianDLHeap::map_chunk_pages(tchunkptr tp, size_t psize)

{

    if(page_not_in_memory(tp, psize)) {

        char *a_addr = tchunk_page_align(tp);

        size_t npages = tp->npages;

#ifdef OOM_LOGGING

        // check that npages matches the psize

        size_t offset = address_offset(a_addr,tp);        

        if(offset < psize && (psize - offset) >= mparams.page_size )

        {               

            size_t tpages = ( psize - offset) >> pageshift;            

            if(tpages != tp->npages) //assert condition                

                MEM_LOG("CHUNK_PAGE_ERROR:map_chunk_pages, error in npages");                        

        }

        else

            MEM_LOG("CHUNK_PAGE_ERROR::map_chunk_pages: - Incorrect page-in-memmory flag");

#endif        

        if(map(a_addr, npages*mparams.page_size)) {        

            TRACE_DL_CHUNK_MAP(tp, psize, a_addr, npages*mparams.page_size);

            ASSERT_RCHUNK_SIZE();

            TRACE_UNMAPPED_CHUNK(-1*npages*mparams.page_size);

            return KErrNone;

        }

        else { 

            MEM_LOGF(_L8("CHUNK_PAGE_ERROR:: map_chunk_pages - Failed to Commit RAM, page_addr=%x, npages=%d, chunk_size=%d"), a_addr, npages, psize);

            MEM_DUMP_OOM_LOGS(psize, "RSymbianDLHeap::map_chunk_pages - Failed to Commit RAM");

            return KErrNoMemory;

        }

    }

    return KErrNone;

}

/* Purpose:     Map partial chunk memory pages from system RAM

 * Arguments:   tp - tchunkptr in which memmory should be mapped

 *              psize - incoming tchunk size

 *              r - remainder chunk pointer

 *              rsize - remainder chunk size  

 * Return:      Number of unmapped pages from remainder chunk if successful (0 or more), else KErrNoMemory

 * Note:        Remainder chunk should be large enough to be mapped out (checked before invoking this function)    

 *              pageout headers will be set from insert_large_chunk(), not here.

 */

TInt RSymbianDLHeap::map_chunk_pages_partial(tchunkptr tp, size_t psize, tchunkptr r, size_t rsize)

{

    if(page_not_in_memory(tp, psize)) {

        size_t npages = tp->npages; // total no of pages unmapped in this chunk        

        char *page_addr_map = tchunk_page_align(tp); // address to begin page map

        char *page_addr_rem = tchunk_page_align(r);  // address in remainder chunk to remain unmapped

        assert(address_offset(page_addr_rem, r) < rsize);

        size_t npages_map = address_offset(page_addr_rem, page_addr_map) >> pageshift; // no of pages to be mapped

        if(npages_map > 0) {

            if(map(page_addr_map, npages_map*mparams.page_size)) {            

                TRACE_DL_CHUNK_MAP(tp, psize, page_addr_map, npages_map*mparams.page_size);

                ASSERT_RCHUNK_SIZE();

                TRACE_UNMAPPED_CHUNK(-1*npages_map*mparams.page_size);    

                return (npages - npages_map);

            }

            else { 

                MEM_LOGF(_L8("CHUNK_PAGE_ERROR:: map_chunk_pages_partial - Failed to Commit RAM, page_addr=%x, npages=%d, chunk_size=%d"), page_addr_map, npages_map, psize);

                MEM_DUMP_OOM_LOGS(psize, "RSymbianDLHeap::map_chunk_pages_partial - Failed to Commit RAM");

                return KErrNoMemory;

            }              

        }

        else {

             // map not needed, first page is already mapped

             return npages;

        }

    }

    return 0;

}

/* Purpose:     Release (unmap) chunk memory pages to system RAM

 * Arguments:   tp - tchunkptr from which memmory may be released

 *              psize - incoming tchunk size

 *              prev_npages - number of pages that has been already unmapped from this chunk

 * Return:      total number of pages that has been unmapped from this chunk (new unmapped pages + prev_npages)

 * Note:        pageout headers will be set from insert_large_chunk(), not here.    

 */

TInt RSymbianDLHeap::unmap_chunk_pages(tchunkptr tp, size_t psize, size_t prev_npages)

{

    size_t npages = 0;

    char *a_addr = tchunk_page_align(tp);

    size_t offset = address_offset(a_addr,tp);    

    if(offset < psize && (psize - offset) >= mparams.page_size)

    { /* check for new pages to decommit */

        npages = ( psize - offset) >> pageshift;

        if(npages > prev_npages) {

            unmap(a_addr, npages*mparams.page_size);    // assuming kernel takes care of already unmapped pages

            TRACE_DL_CHUNK_UNMAP(tp, psize, a_addr, npages*mparams.page_size);

            iChunkSize += prev_npages*mparams.page_size; //adjust actual chunk size

            ASSERT_RCHUNK_SIZE();

            TRACE_UNMAPPED_CHUNK((npages-prev_npages)*mparams.page_size);

            assert((a_addr + npages*mparams.page_size - 1) < (char*)next_chunk(tp));

        }        

    }

#ifdef OOM_LOGGING        

    if(npages && (npages < prev_npages))

        MEM_LOG("CHUNK_PAGE_ERROR:unmap_chunk_pages, error in npages");    

    if(npages > prev_npages) {

        /* check that end of decommited address lie within this chunk */      

        if((a_addr + npages*mparams.page_size - 1) >= (char*)next_chunk(tp))

            MEM_LOG("CHUNK_PAGE_ERROR:unmap_chunk_pages, error chunk boundary");

    }

#endif

#ifdef DL_CHUNK_MEM_DEBUG 

    mchunkptr next = next_chunk(tp);

    do_check_any_chunk_access(next, chunksize(next));

    if(!npages)  do_check_any_chunk_access((mchunkptr)tp, psize);

#endif

    return (npages);

}

/* Purpose:     Unmap all pages between previously unmapped and end of top chunk 

                and reset top to beginning of prev chunk

 * Arguments:   fm - global malloc state

 *              prev - previous chunk which has unmapped pages

 *              psize - size of previous chunk

 *              prev_npages - number of unmapped pages from previous chunk

 * Return:      nonzero if sucessful, else 0

 * Note:                    

 */

TInt RSymbianDLHeap::sys_trim_partial(mstate m, mchunkptr prev, size_t psize, size_t prev_npages)

{

    size_t released = 0;

    size_t extra = 0;

    if (is_initialized(m)) {

      psize += m->topsize;

      char *a_addr = tchunk_page_align(prev); // includes space for TOP footer 

      size_t addr_offset = address_offset(a_addr, prev);

      assert(addr_offset > TOP_FOOT_SIZE); //always assert?

      assert((char*)iTop >= a_addr); //always assert?

      if((char*)iTop > a_addr)

          extra = address_offset(iTop, a_addr);

#ifdef OOM_LOGGING      

      if ((char*)iTop < a_addr)

          MEM_LOGF(_L8("RSymbianDLHeap::sys_trim_partial - incorrect iTop value, top=%x, iTop=%x"), m->top, iTop);

#endif            

        msegmentptr sp = segment_holding(m, (TUint8*)prev);

        if (!is_extern_segment(sp)) {

          if (is_mmapped_segment(sp)) {

            if (HAVE_MMAP &&  sp->size >= extra && !has_segment_link(m, sp)) { /* can't shrink if pinned */

              size_t newsize = sp->size - extra;

              /* Prefer mremap, fall back to munmap */

              if ((CALL_MREMAP(sp->base, sp->size, newsize, 0) != MFAIL) ||

                  (CALL_MUNMAP(sp->base + newsize, extra) == 0)) {

                released = extra;

              }

            }

          }

          else if (HAVE_MORECORE) {

            if (extra >= HALF_MAX_SIZE_T) /* Avoid wrapping negative */

                extra = (HALF_MAX_SIZE_T) + SIZE_T_ONE - mparams.granularity;

            ACQUIRE_MORECORE_LOCK(m);

            {

              /* Make sure end of memory is where we last set it. */

              TUint8* old_br = (TUint8*)(CALL_MORECORE(0));

              if (old_br == sp->base + sp->size) {

                TUint8* rel_br = (TUint8*)(CALL_MORECORE(-extra));

                TUint8* new_br = (TUint8*)(CALL_MORECORE(0));

                if (rel_br != CMFAIL && new_br < old_br)

                  released = old_br - new_br;

              }

            }

            RELEASE_MORECORE_LOCK(m);

          }

        }

        if (released != 0) {

          TRACE_DL_CHUNK_UNMAP(prev, psize, a_addr, released);

          iChunkSize += prev_npages*mparams.page_size; // prev_unmapped was already unmapped

          TRACE_UNMAPPED_CHUNK(-1*prev_npages*mparams.page_size);

          ASSERT_RCHUNK_SIZE();

          sp->size -= released;

          m->footprint -= released;

        }

        /* reset top to prev chunk */

        init_top(m, prev, addr_offset - TOP_FOOT_SIZE);

        check_top_chunk(m, m->top);

    }

    // DL region not initalized, do not reset top here

    return (released != 0)? 1 : 0;

}

UEXPORT_C RSymbianDLHeap::RSymbianDLHeap(TInt aMaxLength, TInt aAlign, TBool aSingleThread)

// constructor for a fixed heap. Just use DL allocator

	:iMinLength(aMaxLength), iMaxLength(aMaxLength), iOffset(0), iGrowBy(0), iChunkHandle(0),

	iNestingLevel(0), iAllocCount(0), iFailType(ENone), iTestData(NULL), iChunkSize(aMaxLength)

	{

	// bodge so GKIServ (hudson generic low level layer) starts up ok - it uses an aAlign of 0 which panics, so if see 0 then force to 4

	if ((TUint32)aAlign>=sizeof(TAny*) && __POWER_OF_2(iAlign))

		{

		iAlign = aAlign;

		}

	else

		{

		iAlign = 4;

		}

	iPageSize = 0;

	iFlags = aSingleThread ? (ESingleThreaded|EFixedSize) : EFixedSize;

	isLowSystemMemory = 0;

	Init(0, 0, 0);

	}

UEXPORT_C RSymbianDLHeap::RSymbianDLHeap(TInt aChunkHandle, TInt aOffset, TInt aMinLength, TInt aMaxLength, TInt aGrowBy,

			TInt aAlign, TBool aSingleThread)

		: iMinLength(aMinLength), iMaxLength(aMaxLength), iOffset(aOffset), iChunkHandle(aChunkHandle), 

		  iAlign(aAlign), iNestingLevel(0), iAllocCount(0), iFailType(ENone), iTestData(NULL), iChunkSize(aMinLength)

	{

	// TODO: Locked the page size to 4 KB - change this to pick up from the OS

	GET_PAGE_SIZE(iPageSize);

	__ASSERT_ALWAYS(aOffset >=0, User::Panic(KDLHeapPanicCategory, ETHeapNewBadOffset));

	iGrowBy = _ALIGN_UP(aGrowBy, iPageSize);

	iFlags = aSingleThread ? ESingleThreaded : 0;

	isLowSystemMemory = 0;

	// Initialise

	// if the heap is created with aMinLength==aMaxLength then it cannot allocate slab or page memory

	// so these sub-allocators should be disabled. Otherwise initialise with default values

	if (aMinLength == aMaxLength)

		Init(0, 0, 0);

	else

		Init(0x3fff, 15, 0x10000);	// all slabs, page {32KB}, trim {64KB}

//		Init(0xabe, 16, iPageSize*4);	// slabs {48, 40, 32, 24, 20, 16, 12}, page {64KB}, trim {16KB}

	}

UEXPORT_C TAny* RSymbianDLHeap::operator new(TUint aSize, TAny* aBase) __NO_THROW

	{

	__ASSERT_ALWAYS(aSize>=sizeof(RSymbianDLHeap), HEAP_PANIC(ETHeapNewBadSize));

	RSymbianDLHeap* h = (RSymbianDLHeap*)aBase;

	h->iAlign = 0x80000000;	// garbage value

	h->iBase = ((TUint8*)aBase) + aSize;

	return aBase;

	}

void RSymbianDLHeap::Init(TInt aBitmapSlab, TInt aPagePower, size_t aTrimThreshold)

	{

	__ASSERT_ALWAYS((TUint32)iAlign>=sizeof(TAny*) && __POWER_OF_2(iAlign), HEAP_PANIC(ETHeapNewBadAlignment));

	/*Moved code which does iunitilization */

	iTop = (TUint8*)this + iMinLength;

	spare_page = 0;

	memset(&mparams,0,sizeof(mparams));

	Init_Dlmalloc(iTop - iBase, 0, aTrimThreshold);

	slab_init(aBitmapSlab);

	/*10-1K,11-2K,12-4k,13-8K,14-16K,15-32K,16-64K*/

	paged_init(aPagePower);

#ifdef OOM_LOGGING    

    iUnmappedChunkSize = 0;

#endif    

	}

UEXPORT_C RSymbianDLHeap::SCell* RSymbianDLHeap::GetAddress(const TAny* aCell) const

//

// As much as possible, check a cell address and backspace it

// to point at the cell header.

//

	{

	TLinAddr m = TLinAddr(iAlign - 1);

	__ASSERT_ALWAYS(!(TLinAddr(aCell)&m), HEAP_PANIC(ETHeapBadCellAddress));

	SCell* pC = (SCell*)(((TUint8*)aCell)-EAllocCellSize);

	__CHECK_CELL(pC);

	return pC;

	}

UEXPORT_C TInt RSymbianDLHeap::AllocLen(const TAny* aCell) const

{

	if (ptrdiff(aCell, this) >= 0)

	{

		mchunkptr m = mem2chunk(aCell);

		return chunksize(m) - CHUNK_OVERHEAD;

	}

	if (lowbits(aCell, pagesize) > cellalign)

		return header_size(slab::slabfor(aCell)->header);

	if (lowbits(aCell, pagesize) == cellalign)

		return *(unsigned*)(offset(aCell,-int(cellalign)))-cellalign;

	return paged_descriptor(aCell)->size;

}

UEXPORT_C TAny* RSymbianDLHeap::Alloc(TInt aSize)

{

	__ASSERT_ALWAYS((TUint)aSize<(KMaxTInt/2),HEAP_PANIC(ETHeapBadAllocatedCellSize));

	TAny* addr;

	Lock();

	if (aSize < slab_threshold)

	{

		TInt ix = sizemap[(aSize+3)>>2];

		ASSERT(ix != 0xff);

		addr = slab_allocate(slaballoc[ix]);

	}else if((aSize >> page_threshold)==0)

		{

		addr = dlmalloc(aSize);

		}

	else

		{

		addr = paged_allocate(aSize);

		if(!addr) { // paged_allocator failed, try in dlmalloc 

            addr = dlmalloc(aSize);

		}

		}

	Unlock();

	return addr;

}

UEXPORT_C TInt RSymbianDLHeap::Compress()

	{

	if (iFlags & EFixedSize)

		return 0;

	Lock();

	dlmalloc_trim(0);

	if (spare_page)

	{

		unmap(spare_page, pagesize);

		spare_page = 0;

	}

	Unlock();

	return 0;

	}

UEXPORT_C void RSymbianDLHeap::Free(TAny* aPtr)

{

	Lock();

	if (!aPtr)

		;

	else if (ptrdiff(aPtr, this) >= 0)

		{

		dlfree( aPtr);

		}

	else if (lowbits(aPtr, pagesize) <= cellalign)

		{

		paged_free(aPtr);

		}

	else

		{

		slab_free(aPtr);

		}

	Unlock();

}

UEXPORT_C void RSymbianDLHeap::Reset()

	{

	// TODO free everything

	}

UEXPORT_C TAny* RSymbianDLHeap::ReAlloc(TAny* aPtr, TInt aSize, TInt /*aMode = 0*/)

//

// Support aMode==0 properly: do not move the cell if the request is smaller than old size

//

	{

	if(ptrdiff(aPtr,this)>=0)

	{

		// original cell is in DL zone

		if((aSize>>page_threshold)==0 || aSize <= chunksize(mem2chunk(aPtr)) - CHUNK_OVERHEAD)

			{

			// new one is below page limit or smaller than old one (so can't be moved)

			Lock();

			TAny* addr = dlrealloc(aPtr,aSize);

			Unlock();

			return addr;

			}

	}

	else if(lowbits(aPtr,pagesize)<=cellalign)

	{

		// original cell is either NULL or in paged zone

		if (!aPtr)

			return Alloc(aSize);

		// either the new size is larger (in which case it will still be in paged zone)

		// or it is smaller, but we will never move a shrinking cell so in paged zone

		// must handle [rare] case that aSize == 0, as paged_[re]allocate() will panic

		if (aSize == 0)

			aSize = 1;

		Lock();

		TAny* addr = paged_reallocate(aPtr,aSize);

		Unlock();

		return addr;

	}

	else

	{

		// original cell is in slab zone

		// return original if new one smaller

		if(aSize <= header_size(slab::slabfor(aPtr)->header))

			return aPtr;

	}

	// can't do better than allocate/copy/free

	TAny* newp = Alloc(aSize);

	if(newp)

	{

		TInt oldsize = AllocLen(aPtr);

		memcpy(newp,aPtr,oldsize<aSize?oldsize:aSize);

		Free(aPtr);

	}

	return newp;

	}

UEXPORT_C TInt RSymbianDLHeap::Available(TInt& aBiggestBlock) const

{

	aBiggestBlock = 0;

	return 1000;

	/*Need to see how to implement this*/

	// TODO: return iHeap.Available(aBiggestBlock);

}

UEXPORT_C TInt RSymbianDLHeap::AllocSize(TInt& aTotalAllocSize) const

{

	aTotalAllocSize = 0;

	return 0;

}

UEXPORT_C TInt RSymbianDLHeap::DebugFunction(TInt /*aFunc*/, TAny* /*a1*/, TAny* /*a2*/)

	{

	return 0;

	}

UEXPORT_C TInt RSymbianDLHeap::Extension_(TUint /* aExtensionId */, TAny*& /* a0 */, TAny* /* a1 */)

	{

	return KErrNotSupported;

	}

long    sysconf		(int size )

	{

	if (UserHal::PageSizeInBytes(size)!=KErrNone)

		size = 0x1000;

	return size;

	}

///////////////////////////////////////////////////////////////////////////////

// imported from dla.cpp

///////////////////////////////////////////////////////////////////////////////

//#include <unistd.h>