/****************************************************************************

**

** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbCore module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** This file may be used under the terms of the GNU Lesser General Public

** License version 2.1 as published by the Free Software Foundation and

** appearing in the file LICENSE.LGPL included in the packaging of this file.

** Please review the following information to ensure the GNU Lesser General

** Public License version 2.1 requirements will be met:

** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at developer.feedback@nokia.com.

**

****************************************************************************/

#include "hbsharedmemorymanager_p.h"

#include "hbsharedmemoryallocators_p.h"

#include "hbmemoryutils_p.h"

#include <QSharedMemory>

#include <QString>

#include <QList>

#include <QDebug>

#ifdef HB_THEME_SERVER_MEMORY_REPORT

#include <QDate>

#include <QDir>

#include <QFile>

#endif

#include "hbsharedcache_p.h"

#ifdef HB_BIN_CSS

#include "hbcssconverterutils_p.h"

#endif // HB_BIN_CSS

#define USE_SUBALLOCATOR

#ifdef HB_THEME_SERVER_FULL_MEMORY_REPORT

// identifier and size are packed in one quint32

static const int allocIdentifier =   0x80000000;

static const int freeIdentifier =    0x40000000;

static const int reallocIdentifier = 0xC0000000;

#endif

HbSharedMemoryManager *HbSharedMemoryManager::memManager = 0;

#ifdef HB_HAVE_PROTECTED_CHUNK // Symbian, protected chunk

HbSharedMemoryWrapper::HbSharedMemoryWrapper(const QString &key, QObject *parent) :

    wrapperError(QSharedMemory::NoError),        

    key(key),

    memorySize(0),

    memory(0)

{

    Q_UNUSED(parent);

}

HbSharedMemoryWrapper::~HbSharedMemoryWrapper()

{

    chunk.Close();

    memory = 0;

    memorySize = 0;

}

void HbSharedMemoryWrapper::setErrorString(const QString &function, TInt errorCode)

{

    if (errorCode == KErrNone)

        return;

    switch (errorCode) {

    case KErrAlreadyExists:

        wrapperError = QSharedMemory::AlreadyExists;

        errorString = QSharedMemory::tr("%1: already exists").arg(function);

    break;

    case KErrNotFound:

        wrapperError = QSharedMemory::NotFound;

        errorString = QSharedMemory::tr("%1: doesn't exists").arg(function);

        break;

    case KErrArgument:

        wrapperError = QSharedMemory::InvalidSize;

        errorString = QSharedMemory::tr("%1: invalid size").arg(function);

        break;

    case KErrNoMemory:

        wrapperError = QSharedMemory::OutOfResources;

        errorString = QSharedMemory::tr("%1: out of resources").arg(function);

        break;

    case KErrPermissionDenied:

        wrapperError = QSharedMemory::PermissionDenied;

        errorString = QSharedMemory::tr("%1: permission denied").arg(function);

        break;

    default:

        errorString = QSharedMemory::tr("%1: unknown error %2").arg(function).arg(errorCode);

        wrapperError = QSharedMemory::UnknownError;

    }

}

bool HbSharedMemoryWrapper::create(int size, QSharedMemory::AccessMode mode)

{

    Q_UNUSED(mode);

    TPtrC ptr(TPtrC16(static_cast<const TUint16*>(key.utf16()), key.length()));

    TChunkCreateInfo info;

    info.SetReadOnly();

    info.SetGlobal(ptr);

    info.SetNormal(size, size);

    //TInt err = chunk.CreateGlobal(ptr, size, size); // Original Qt version

    TInt err = chunk.Create(info);

    QString function = QLatin1String("HbSharedMemoryWrapper::create");    

    setErrorString(function, err);

    if (err != KErrNone)

        return false;

    // Zero out the created chunk

    Mem::FillZ(chunk.Base(), chunk.Size());

    memorySize = chunk.Size();

    memory = chunk.Base();

    return true;

}

QSharedMemory::SharedMemoryError HbSharedMemoryWrapper::error() const

{

    return wrapperError;

}

bool HbSharedMemoryWrapper::attach(QSharedMemory::AccessMode mode)

{

    Q_UNUSED(mode);    

    // Grab a pointer to the memory block

    if (!chunk.Handle()) {

        TPtrC ptr(TPtrC16(static_cast<const TUint16*>(key.utf16()), key.length()));        

        TInt err = KErrNoMemory;

        err = chunk.OpenGlobal(ptr, false);

        if (err != KErrNone) {

            QString function = QLatin1String("HbSharedMemoryWrapper::attach");        

            setErrorString(function, err);

            return false;

        }

    }

    memorySize = chunk.Size();

    memory = chunk.Base();

    return true;

}

void *HbSharedMemoryWrapper::data()

{

    return memory;

}

int HbSharedMemoryWrapper::size() const

{

    return memorySize;

}

#else // use QSharedMemory

HbSharedMemoryWrapper::HbSharedMemoryWrapper(const QString &key, QObject *parent)

{

    chunk = new QSharedMemory(key, parent);

}

HbSharedMemoryWrapper::~HbSharedMemoryWrapper()

{

    delete chunk;

    chunk = 0;

}

bool HbSharedMemoryWrapper::create(int size, QSharedMemory::AccessMode mode)

{

    if (chunk) {

        return chunk->create(size, mode);

    }

    return false;

}

QSharedMemory::SharedMemoryError HbSharedMemoryWrapper::error() const

{

    return chunk->error();

}

bool HbSharedMemoryWrapper::attach(QSharedMemory::AccessMode mode)

{

    if (chunk) {

        return chunk->attach(mode);

    }

    return false;

}

void *HbSharedMemoryWrapper::data()

{

    if (chunk) {

        return chunk->data();

    }

    return 0;

}

int HbSharedMemoryWrapper::size() const

{

    if (chunk) {

        return chunk->size();

    }

    return 0;

}

#endif

/* Functions implementation of HbSharedMemoryManager class */

/**

 * HbSharedMemoryManager::initialize

 * 

 * If due to OOM scenario, the initialization of HbSharedMemoryManager fails,

 * it handles the exception and returns false. 

 */

bool HbSharedMemoryManager::initialize()

{

    if (chunk) {

        return true;

    }

    bool success = false;

    chunk = new HbSharedMemoryWrapper(HB_THEME_SHARED_PIXMAP_CHUNK);

    // check if app filename is same as server filename ..

    // ToDo: improve server identification logic.. UID on symbian?

    const QString &appName = HbMemoryUtils::getCleanAppName();

    bool binCSSConverterApp = (appName == BIN_CSS_APP || appName == BIN_CSS_APP_SYMBIAN);

    // Testability support: allowing unit test to write to shared chunk also

    if (appName == THEME_SERVER_NAME || appName == SHARED_MEMORY_MANAGER_UNIT_TEST || binCSSConverterApp) {

        // This is server, create shared memory chunk

        success = chunk->create(CACHE_SIZE, QSharedMemory::ReadWrite);

        // If sharedMemory already exists.

        // (This can happpen if ThemeServer crashed without releasing QSharedMemory)

        if (!success && QSharedMemory::AlreadyExists == chunk->error()) {

            success = chunk->attach(QSharedMemory::ReadWrite);

        }

        writable = true;

    } else {

        // this is not server so just attach to shared memory chunk in ReadOnly mode

        success = chunk->attach(QSharedMemory::ReadOnly);

        writable = false;

    }

    if ( !success ) {

#ifdef THEME_SERVER_TRACES

        qDebug() << "HbSharedMemoryManager:: Could not initialize shared memory chunk";

#endif //THEME_SERVER_TRACES

        delete chunk; 

        chunk = 0;

    }

    if (success && isWritable()) {

        // if we are recovering from theme server crash, shared chunk may

        // already be ready

        bool enableRecovery = false;

        if (binCSSConverterApp) {

            enableRecovery = false;

        }

        HbSharedChunkHeader *chunkHeader = static_cast<HbSharedChunkHeader*>(chunk->data());

        HbSharedCache *cachePtr = 0;

        if (enableRecovery && chunkHeader->identifier == INITIALIZED_CHUNK_IDENTIFIER) {

            // just reconnect allocators to the shared chunk

            mainAllocator->initialize(chunk, chunkHeader->mainAllocatorOffset);

            subAllocator->initialize(chunk, chunkHeader->subAllocatorOffset, mainAllocator);

        } else {

            memset(chunkHeader, 0, sizeof(HbSharedChunkHeader));

            // Load memory file in the beginning of the chunk first.

            int memoryFileSize = 0;

#ifdef Q_OS_SYMBIAN

            if (!binCSSConverterApp) {

                QString memoryFile("z:/resource/hb/themes/hbdefault.cssbin");

                memoryFileSize = loadMemoryFile(memoryFile);

            }

#endif

            // Put main allocator after the memory file or if memory file was not loaded, after chunk header.

            chunkHeader->mainAllocatorOffset = memoryFileSize ? ALIGN(memoryFileSize)

                                                              : sizeof(HbSharedChunkHeader);

            // Clear also allocator identifier so that they will not try to re-connect

            int *mainAllocatorIdentifier = address<int>(chunkHeader->mainAllocatorOffset);

            *mainAllocatorIdentifier = 0;

            mainAllocator->initialize(chunk, chunkHeader->mainAllocatorOffset);

            chunkHeader->subAllocatorOffset = alloc(SPACE_NEEDED_FOR_MULTISEGMENT_ALLOCATOR);

            int *subAllocatorIdentifier = address<int>(chunkHeader->subAllocatorOffset);

            *subAllocatorIdentifier = 0;

            subAllocator->initialize(chunk, chunkHeader->subAllocatorOffset, mainAllocator);

            chunkHeader->identifier = INITIALIZED_CHUNK_IDENTIFIER;

            if (!binCSSConverterApp) {

                if (memoryFileSize == 0) {

                }

            }

        }

        if (!cachePtr) {

            cachePtr = cache();

        }

        if (cachePtr && !binCSSConverterApp) {

            cachePtr->initServer();

        }

        success = true;

    } else {

        HbSharedCache *cachePtr = cache();

        if (cachePtr) {

            cachePtr->initClient();

        }

    }

    return success;

}

/**

 * HbSharedMemoryManager::alloc

 * 

 * This function throws std::bad_alloc in case of OOM condition, else

 * proper offset in case of a successful memory allocation

 */

{

#ifdef HB_THEME_SERVER_MEMORY_REPORT

// some code copied, but much more readable this way

    if (isWritable() && size > 0) {

        int offset = -1;

#ifdef USE_SUBALLOCATOR

        if (size <= MAXIMUM_ALLOC_SIZE_FOR_SUBALLOCATOR) {

            offset = subAllocator->alloc(size);

        } else {

            try{

                // main allocator may throw bad_alloc

                offset = mainAllocator->alloc(size);

            }

            catch(std::bad_alloc &badAlloc){

                Q_UNUSED(badAlloc);

                OOMCount++;

                if (!OOMReportCreated) {

                    OOMReportCreated = true;

                    createReport();

                }

                throw;

            }

        }

#else

        try{

            // main allocator may throw bad_alloc

            offset = mainAllocator->alloc(size);

        }

        catch(std::bad_alloc &badAlloc){

            OOMCount++;

            throw;

        }

#endif

        if (offset == -1) {

            // we ran out of memory

            OOMCount++;

            if (!OOMReportCreated) {

                OOMReportCreated = true;

                createReport();

            }

            throw std::bad_alloc();

        }

    if (allocations.contains(size)) {

        allocations[size].first++;

    } else {

        allocations.insert(size, QPair<quint32, quint32>(1,0));

    }

#else // normal alloc without reporting

    if (isWritable() && size > 0) {

#ifdef USE_SUBALLOCATOR

        if (size <= MAXIMUM_ALLOC_SIZE_FOR_SUBALLOCATOR) {

            offset = subAllocator->alloc(size);

        } else {

            offset = mainAllocator->alloc(size);

        }

#else

        offset = mainAllocator->alloc(size);

#endif

        if (offset == -1) {

            // we ran out of memory

            throw std::bad_alloc();

        }

#endif // HB_THEME_SERVER_MEMORY_REPORT

#ifdef HB_THEME_SERVER_FULL_MEMORY_REPORT

        fullAllocationHistory.append(QPair<quint32,quint32>(size | allocIdentifier, offset));

#endif

#ifdef HB_BIN_CSS

        HbCssConverterUtils::cellAllocated(offset, size);

#endif

        return offset;

    } else {

        // memory manager attached in read only mode, cannot allocate memory

        throw std::bad_alloc();

    }

}

/**

 * free

 */

{

    // don't do anything when freeing NULL (pointer)offset

    if (isWritable() && (offset > 0)) {

        int metaData = *address<int>(offset - sizeof(int));

#ifdef HB_THEME_SERVER_MEMORY_REPORT

        int size = 0;

        if (metaData & MAIN_ALLOCATOR_IDENTIFIER) {

            size = mainAllocator->allocatedSize(offset);

        } else {

            size = subAllocator->allocatedSize(offset);

        }

        if (allocations.contains(size)) {

            allocations[size].second++;

        }

#ifdef HB_THEME_SERVER_FULL_MEMORY_REPORT

        fullAllocationHistory.append(QPair<quint32,quint32>(size | freeIdentifier, offset));

#endif

#endif //HB_THEME_SERVER_MEMORY_REPORT

        if (metaData & MAIN_ALLOCATOR_IDENTIFIER) {

            mainAllocator->free(offset);

        } else {

            subAllocator->free(offset);

        }

#ifdef HB_BIN_CSS

        HbCssConverterUtils::cellFreed(offset);

#endif

    }

}

/**

 * realloc

 * 

 * This function can throw if alloc fails

 */

{

    if (isWritable()) {

#ifdef HB_THEME_SERVER_FULL_MEMORY_REPORT

        if (offset > 0) { // if offset == -1, just do normal alloc and not report realloc

            fullAllocationHistory.append(QPair<quint32, quint32>(newSize | reallocIdentifier, offset));

        }

#endif

	    newOffset = alloc(newSize);

        int allocatedSize = ALIGN(newSize);

        if (offset > 0) {

#ifdef HB_BIN_CSS

            HbCssConverterUtils::cellMoved(offset, newOffset);

#endif

            unsigned char *scrPtr = address<unsigned char>(offset);

            int metaData = *address<int>(offset - sizeof(int));

            if (metaData & MAIN_ALLOCATOR_IDENTIFIER) {

                int oldSize = mainAllocator->allocatedSize(offset);

                memcpy(address<unsigned char>(newOffset), scrPtr, qMin(oldSize, allocatedSize));

#ifdef HB_THEME_SERVER_MEMORY_REPORT

                free(offset);

#else

                mainAllocator->free(offset);

#endif

            } else {

                int oldSize = subAllocator->allocatedSize(offset);

                memcpy(address<unsigned char>(newOffset), scrPtr, qMin(oldSize, allocatedSize));

#ifdef HB_THEME_SERVER_MEMORY_REPORT

                free(offset);

#else

                subAllocator->free(offset);

#endif

            }

#if HB_BIN_CSS

            // Does not matter if already called when calling free() above.

            HbCssConverterUtils::cellFreed(offset);

#endif

        }

    } else {

        // tried to free non-writable memory???

        throw std::bad_alloc();

    }

    return newOffset;

}

/**

 * base

 */

void *HbSharedMemoryManager::base()