// Copyright (c) 2005-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:

// e32test\debug\d_logtofile.cpp

// d_logtofile.ldd is kernel side of t_logtofile application that tests *

// trace handler hook (TTraceHandler). See t_logtofile.cpp for details. *

// 

//

#include "d_logtofile.h"

#include <kernel/kern_priv.h>

_LIT(PatternInfo, "Pattern:");

_LIT(BufferInfo, "Buffer Size:");

_LIT(FastCounterInfo, "Fast couner freq:");

const TInt MaxLogSize=300;

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

class DLogToFile : public DLogicalChannelBase

	{

public:

	DLogToFile();

	~DLogToFile();

	static TBool Handler (const TDesC8& aText, TTraceSource aTraceSource);

protected:

	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);

	virtual TInt Request(TInt aFunction, TAny* a1, TAny* a2);

private:

	TInt CreateChunk();

	void Start();

	TInt Stop();

	void RemoveChunk();

private:

    DChunk* iChunk;					/**Shared chunk*/

    TLinAddr iChunkKernelAddr;		/**Kernel base address of the chunk*/

    TUint32 iChunkMapAttr;			/**Mapping attributes of the chunk*/

	TBool iBufferFull;				/**Chunk full indication*/

	TText8* iCurrent;				/**Current pointer to the chunk space*/

	TChunkCreateStr iChunkCreateStr;/**Input arguments(matching pattern and the chunk size) from user side*/

	TTraceHandler iOldHook;			/**Previous trace logging hook*/

	};

DLogToFile* Logger;

DLogToFile::DLogToFile() 

	{

	}

DLogToFile::~DLogToFile()

	{

	Logger = NULL;

	}

/*

Trace handler hook.

Should be able to run in any content (including ISR).

@return EFalse, always and that way suppresses debug logging to serial port.

*/

TBool DLogToFile::Handler (const TDesC8& aText, TTraceSource aTraceSource)

	{

	if(Logger->iBufferFull)

		return ETrue;

	TInt irq=NKern::DisableAllInterrupts(); //Disable interrupts to prevent loggings overlapping each other.

	if (aText.Length() < Logger->iChunkCreateStr.iPattern.Length())

		{

		NKern::RestoreInterrupts(irq);

		return ETrue; //The log is too short to match the pattern

		}

	TPtrC8 ptr( aText.Ptr(), Logger->iChunkCreateStr.iPattern.Length());

	if (ptr != Logger->iChunkCreateStr.iPattern) //Compare the pattern against the start of the log

		{

		NKern::RestoreInterrupts(irq);

		return ETrue; //Does not match

		}

	TBuf8<20> fcBuffer;

	fcBuffer.AppendNum(NKern::FastCounter());//If it was a real tool, we should not do this here.

	memcpy (Logger->iCurrent, fcBuffer.Ptr(), fcBuffer.Length());

	Logger->iCurrent+=fcBuffer.Length();

	*(Logger->iCurrent++) = '\t';

	switch(aTraceSource)

		{

		case EKernelTrace:

			{

			*(Logger->iCurrent++) = 'K';

			*(Logger->iCurrent++) = '\t';

			memcpy (Logger->iCurrent, aText.Ptr(),aText.Length());

			break;	

			}

		case EPlatSecTrace:

			{

			*(Logger->iCurrent++) = 'P';

			*(Logger->iCurrent++) = '\t';

			//PlatSec log could be of any size. Additional checking required:

			if ((TInt)Logger->iCurrent > (TInt)(Logger->iChunkKernelAddr + Logger->iChunkCreateStr.iSize - aText.Length()))

				{

				Logger->iBufferFull = ETrue;

				break;

				}

			memcpy (Logger->iCurrent, aText.Ptr(),aText.Length());

			break;	

			}

		case EUserTrace:

			{

			*(Logger->iCurrent++) = 'U';

			*(Logger->iCurrent++) = '\t';

			memcpy(Logger->iCurrent, aText.Ptr(),aText.Length());

			break;	

			}

		default:

			break;

		}

	Logger->iCurrent+=aText.Length();

	*(Logger->iCurrent++) = '\n';

	if ((TInt)Logger->iCurrent > (TInt)(Logger->iChunkKernelAddr + Logger->iChunkCreateStr.iSize - MaxLogSize))

		Logger->iBufferFull = ETrue;

	NKern::RestoreInterrupts(irq);

	return ETrue;

	}

/**

Creates the channel

*/

TInt DLogToFile::DoCreate(TInt /*aUnit*/, const TDesC8* /*anInfo*/, const TVersion& /*aVer*/)

	{

	return KErrNone;

	}

/*

Creates chunk and opens another chunk handle for user side.

Returns user side handle.

*/

TInt DLogToFile::CreateChunk()

{

	TInt r;

    TChunkCreateInfo info;

    info.iType         = TChunkCreateInfo::ESharedKernelSingle;

    info.iMaxSize      = iChunkCreateStr.iSize;//This is hard coded to 64K. No need to round to page size.

#ifdef __EPOC32__

    info.iMapAttr      = (TInt)EMapAttrFullyBlocking; // Full caching

#endif

    info.iOwnsMemory   = ETrue; // Use memory from system's free pool

    info.iDestroyedDfc = NULL;

	NKern::ThreadEnterCS();

    if (KErrNone != (r = Kern::ChunkCreate(info, iChunk, iChunkKernelAddr, iChunkMapAttr)))

		{

		NKern::ThreadLeaveCS();

		return r;

		}

	r = Kern::ChunkCommit(iChunk,0,iChunkCreateStr.iSize);

    if(r!=KErrNone)

        {

		Kern::ChunkClose(iChunk);

		NKern::ThreadLeaveCS();

		return r;

		}

	r = Kern::MakeHandleAndOpen(NULL, iChunk); 

    if(r < KErrNone)

        {

		Kern::ChunkClose(iChunk);

		NKern::ThreadLeaveCS();

		return r;

		}

	NKern::ThreadLeaveCS();

	iCurrent = (TText8*)iChunkKernelAddr;

	return r;

}

/*

Logs input parameters info into chunk and starts logging.

*/

void DLogToFile::Start()

	{

	//Log pattern info

	memcpy (Logger->iCurrent, ((const TDesC&)PatternInfo).Ptr(), ((const TDesC&)PatternInfo).Length());

	iCurrent+=((const TDesC&)PatternInfo).Length();

	*(Logger->iCurrent++) = '\t';

	memcpy (Logger->iCurrent, iChunkCreateStr.iPattern.Ptr(), iChunkCreateStr.iPattern.Length());

	Logger->iCurrent += iChunkCreateStr.iPattern.Length();

	*(iCurrent++) = '\n';

	//Log buffern info

	memcpy (iCurrent, ((const TDesC&)BufferInfo).Ptr(), ((const TDesC&)BufferInfo).Length());

	iCurrent+=((const TDesC&)BufferInfo).Length();

	*(Logger->iCurrent++) = '\t';

	TBuf8<20> buf;

	buf.AppendNum(iChunkCreateStr.iSize);

	memcpy (iCurrent, buf.Ptr(), buf.Length());

	iCurrent+=buf.Length();

	*(iCurrent++) = '\n';

	//Log fast counter info

	memcpy (iCurrent, ((const TDesC&)FastCounterInfo).Ptr(), ((const TDesC&)FastCounterInfo).Length());

	iCurrent+=((const TDesC&)FastCounterInfo).Length();

	*(iCurrent++) = '\t';

	buf.SetLength(0);

	buf.AppendNum(NKern::FastCounterFrequency());

	memcpy (iCurrent, buf.Ptr(), buf.Length());

	iCurrent+=buf.Length();

	*(iCurrent++) = '\n';

	//Start logging	

	iOldHook = Kern::SetTraceHandler(DLogToFile::Handler);

	}

/*

Stops logging into chunk. Returns the size of the log.

*/

TInt DLogToFile::Stop()

	{

	//Setting the old hook is always risky. Is the old hook still valid?

	//We'll do it for the sake of testing.

	Kern::SetTraceHandler(iOldHook);

	return (TInt)Logger->iCurrent  - Logger->iChunkKernelAddr;

	}

/*

Closes the shared chunk

*/

void DLogToFile::RemoveChunk()

{

	NKern::ThreadEnterCS();

	//It has been a while since we removed the hook. It should be safe to close the chunk now. 

	Kern::ChunkClose(iChunk);

	NKern::ThreadLeaveCS();

}

/**

User side request entry point.

*/

TInt DLogToFile::Request(TInt aFunction, TAny* a1, TAny* /*a2*/)

	{

	TInt r = KErrNone;

	switch (aFunction)

	{

		case RLogToFileDevice::EControlCreateChunk:

			{

			kumemget(&iChunkCreateStr, a1,sizeof(TChunkCreateStr));

			r = CreateChunk();

			break;

			}

		case RLogToFileDevice::EControlStart:

			{

			Start();

			break;

			}

		case RLogToFileDevice::EControlStop:

			{

			r = Stop();

			break;

			}

		case RLogToFileDevice::EControlRemoveChunk:

			{

			RemoveChunk();

			break;

			}

		default:

			r=KErrNotSupported;

			break;

		}

	return r;

	}

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

class DTestFactory : public DLogicalDevice

	{

public:

	DTestFactory();

	// from DLogicalDevice

	virtual TInt Install();

	virtual void GetCaps(TDes8& aDes) const;

	virtual TInt Create(DLogicalChannelBase*& aChannel);

	};

DTestFactory::DTestFactory()

    {

    iParseMask = KDeviceAllowUnit;

    iUnitsMask = 0x3;

    }

TInt DTestFactory::Create(DLogicalChannelBase*& aChannel)

    {

	Logger = new DLogToFile;

	aChannel = Logger;

	return (aChannel ? KErrNone : KErrNoMemory);

    }

TInt DTestFactory::Install()

    {

    return SetName(&KLogToFileName);

    }

void DTestFactory::GetCaps(TDes8& /*aDes*/) const

    {

    }

DECLARE_STANDARD_LDD()

	{

    return new DTestFactory;

	}