// CloggerServer.cpp

// 

// Copyright (c) 2006 - 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "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:

// Accenture - Initial contribution

//

#include "CloggerServer.h"

#include "Clogger.h"

#include "cliserv.h"

#include "common.h"

#include <HAL.h>

#include <centralrepository.h>

#include <s32mem.h>

#include "SessionWriter.h"

#include <fshell/common.mmh>

#define ClientPanic(aMsg) PanicClient(aMsg, __LINE__)

static const TUint32 KAllEnabled = 0xFFFFFFFFu;

enum TFlags {

	EAllowCurrentBufferToBeRead,

	EInMiddleOfLog, // so don't call Log again, you'll stamp all over the buffers! This is a debug check to guard against my carelessness, ie calling something from within Log() that tries to call Log() again. Log() is not reenterant!

	ELogBufferOverflow, // Can't log when the overflow occurs, so remember it until the log is in an ok state to record the fact

	EWrittenToLog, // This indicates we have got far enough through construction to have written stuff to the buffers. This is an explicit flag to guard against future changes to the startup ordering

	ECenrepFailed, // Can't log when cenrep is accessed, so remember for when we can log it

	ENeedToCopyCompressedLog, // Indicates we need to call CopyLogToExternalMediaL when the background compress of the log completes

	EForceBreakpoint, // Forces a __DEBUGGER call at the start of DoServiceL(). Useful when debugging tclog

	EUsingTempBuf, // Another check to make sure I don't do something stupid with my buffers

	EMaxFlags

};

__ASSERT_COMPILE(EMaxFlags <= 32);

#define ACQUIRE_FLAG_LOCK_OR_FAIL(aFlag, failureOperation) \

	ASSERT(!iFlags.IsSet(aFlag)); /* Debug behaviour */ \

	if (iFlags.IsSet(aFlag)) { failureOperation; } /* Non debug behaviour - fail gracefully */ \

	iFlags.Set(aFlag);

#define ACQUIRE_FLAG_LOCK(aFlag) ACQUIRE_FLAG_LOCK_OR_FAIL(aFlag, return)

#define RELEASE_FLAG_LOCK(aFlag) iFlags.Clear(aFlag)

enum TInternalLoggingMasks {

	ELogTagChanges = 1,

	ELogNewTags = 2,

	ELogDisks = 4,

	ELogNewRdebuggers = 8,

	};

enum TRDebugPrintMasks {

	ELogRDebugPrint = 1,

	ELogKernPrintf = 2,

	ELogPlatSecDiagnostics = 4,

	};

_LIT8(KCloggerTag, "Clogger");

_LIT8(KOldRDebugTag, "RDebug::Print");

_LIT8(KRDebugTag, "RDebug");

_LIT8(KKernPrintfTag, "Kern::Printf"); // Not used any more - keep the definition because we explicitly ignore it when loading tags from cenrep

_LIT8(KOldFallbackTag, "**Everything else**");

_LIT8(KFallbackTag, "DefaultForNewTags");

_LIT(KLogDir, "\\logs\\"); // Don't include the C: because that would upset moap. Rely on RFs to default to the system drive

_LIT(KLogFile, "clogger.txt");

// Don't reorder these without also changing order they are constructed in CCloggerServer::ConstructL

enum TWriters {

	EFile = 0,

	ERDebug,

	EMessageQueue,

	ESessionWriter,

	// Add new writers here!

	EMaxWriters

	};

enum TCenRep {

	EGlobalOptions = 0,

	EBufferSize,

	ENumBuffers,

	ENumRotates,

	ERotateBehaviour,

	EEnabledTags, // This is obsolete because we now use the partial key functionality of cenrep to store enabled tags. And that was necessary because cenrep limits binary values to 2048 bytes

	ERepositoryVersion,

	};

// Cenrep constants

const TUint32 KEverythingMask = 0xFF000000;

const TUint32 KEverythingPartialKey = 0x80000000;

const TUint32 KEnabledMask = 0xFF000001;

const TUint32 KTagEnabledPartialKey = 0x80000000;

enum TCenrepVersion

	{

	ECenrepOriginalFormat = 0,

	ECenrepThreadNamesArePrettified = 1,

	};

const TInt KMinWriteSize = 512; // 512 bytes is a good minimum size for efficient writes to disk

const TInt KSyncBufferIdx = -99; // Magic number given by the server to writers to mean 'the sync buffer'

const TInt KCompressFileNameBufferIdx = -100; // Magic number given by the server to the compress sync writer, its meaning is internal to CLogCompressor and CCloggerServer

/*

Clogger AOs:

EPriorityHigh + 1:

CBtIncomingPrompt Starter - This shouldn't get starved because of writers

EPriorityHigh:

CLogWriter - emptying buffers

CSyncWriterWrapper - emptying buffers

CLogsDirWatcher - will never be running at same time as CLogWriter

CSessionWriterServer - emptying buffers

EPriorityStandard + 1:

CDebugRouterClient - reads input from RDdebug::Print redirector

EPriorityStandard:

CCloggerServer

CServerCallbackDispatcher - unused

EPriorityLow:

iIdleWriteTimer - only go to next buffer when nothing better to do

*/

class CLogsDirWatcher : public CActive

	{

public:

	CLogsDirWatcher(RFs& aFs, CCloggerServer& aServer)

		: CActive(EPriorityHigh), iFs(aFs), iServer(aServer)

		, iDirToWatch(KLogDir().Left(KLogDir().Length()-1)) // Strip trailing backslash

		{

		CActiveScheduler::Add(this);	

		//__DEBUGGER();

		iFs.NotifyChange(ENotifyAll, iStatus, iDirToWatch);

		SetActive();

		}

	void DoCancel()

		{

		iFs.NotifyChangeCancel();

		}

	~CLogsDirWatcher()

		{

		Cancel();

		}

	void RunL()

		{

		//__DEBUGGER();

		if (iStatus != KErrNone) return; // Give up

		TEntry entry;

		if (iFs.Entry(KLogDir, entry) == KErrNone)

			{

			iServer.LogsDirHasBeenCreated();

			}

		else

			{

			// Keep listening

			iFs.NotifyChange(ENotifyAll, iStatus, iDirToWatch);

			SetActive();

			}	

		}

private:

	RFs& iFs;

	CCloggerServer& iServer;

	TPtrC iDirToWatch;

	};

CSession2* CCloggerServer::NewSessionL(const TVersion& /*aVersion*/, const RMessage2& /*aMessage*/) const

	{

	return new(ELeave) CCloggerSession();

	}

CCloggerServer::CCloggerServer()

: CSensibleServer()

	{

	}

TInt CCloggerServer::TransientServerShutdownTime() const

	{

	return 0; // Never shutdown

	}

CCloggerServer::~CCloggerServer()

	{

	//__DEBUGGER();

	if (iFlags.IsSet(EWrittenToLog)) FlushBuffers();

	CloseBuffers();

	iBufs.Close();

	iChunkForBufs.Close();

	for (TInt i = 0; i < iWriters.Count(); i++)

		{

		iWriters[i]->CloseWriter();

		}

	iWriters.Close();

	delete iSessionWriterServer;

	if (iCompressor)

		{

		iCompressor->Cancel(); // This will wait for the compress to complete. Safest thing to do

		delete iCompressor;

		}

	delete iLogsDirWatcher;

	iLogFile.Close();

	iFs.Close();

	//iFileBeingRotated.Close();

	TPtrHashMapIter<TDesC8, TTagData> tagIter(iTags);

	TTagData* tag;

	while ((tag = const_cast<TTagData*>(tagIter.NextValue())) != NULL)

		{

		tagIter.RemoveCurrent();

		delete tag->iTagName;

		delete tag;

		}

	iTags.Close();

	iTempBuf.Close();

	iSessionTempBuf.Close();

	iRDebugTags.Close();

	delete iIdleWriteTimer;

	ASSERT(!iFlushBufferWait.IsStarted());

	delete iKernDebugRouter; // When should this be deleted?

	}

void CCloggerServer::ConstructL()

	{

	CSensibleServer::ConstructL();

	GetSettingsL();

	iWriters.ReserveL(EMaxWriters);

	// Note: important to get the order of writers in the array to be the same as is defined in enum TWriters

	CLogWriter* filelogger = new(ELeave) CLogWriter(*this, iLogFile);

	filelogger->SetEnabled(ETrue);

	iWriters.Append(filelogger);

	CRDebugWriter* rdebuglogger = new(ELeave) CRDebugWriter(*this);

	CleanupStack::PushL(rdebuglogger);

	CSyncWriterWrapper* rdebugWrapper = CSyncWriterWrapper::NewL(*this, *rdebuglogger, iWriters.Count());

	CleanupStack::Pop(rdebuglogger);

	rdebugWrapper->SetEnabled(EFalse);

	iWriters.Append(rdebugWrapper);

	CMessageQueueWriter* msgq = CMessageQueueWriter::NewL();

	CleanupStack::PushL(msgq);

	CSyncWriterWrapper* msgqWrapper = CSyncWriterWrapper::NewL(*this, *msgq, iWriters.Count());

	CleanupStack::Pop(msgq);

	rdebugWrapper->SetEnabled(EFalse);

	iWriters.Append(msgqWrapper);

	CSessionWriter* sessionWriter = new(ELeave) CSessionWriter(*this);

	sessionWriter->SetEnabled(EFalse);

	iWriters.Append(sessionWriter);

	User::LeaveIfError(iFs.Connect());

	User::LeaveIfError(iFs.SetSessionPath(KLogDir));

	TInt err = OpenLogFile();

	if (err == KErrPathNotFound)

		{

		err = KErrNone;

		iLogsDirWatcher = new(ELeave) CLogsDirWatcher(iFs, *this);

		}

	User::LeaveIfError(err);

	/*TInt err = iLogFile.Open(iFs, KLogFile, EFileWrite|EFileShareAny|EFileStream);

	if (err == KErrNotFound) err = iLogFile.Create(iFs, KLogFile, EFileWrite|EFileShareAny|EFileStream);

	if (err == KErrPathNotFound)

		{

		iWriters[EFile]->SetEnabled(EFalse);

		err = KErrNone;

		iLogsDirWatcher = new(ELeave) CLogsDirWatcher(iFs, *this);

		}

	else

		{

		User::LeaveIfError(err);

		TInt seekTo = -1;

		User::LeaveIfError(iLogFile.Seek(ESeekEnd, seekTo));

		}

	*/

	iIdleWriteTimer = CPeriodic::NewL(CActive::EPriorityLow);

	// Important that we start the kern debug router early, before the first call to UpdateBufferSizeL because we now rely on the debug router to allocate our chunk for us

	TRAPD(debugRouterErr, iKernDebugRouter = CDebugRouterClient::NewL(*this)); // We check 'debugRouterErr' further down

	const TInt KMaxChunkSize = 512*1024; // We will say 512 KB for max chunk size

	err = CreateKernChunkForClient(NULL, KMaxChunkSize, 0, iChunkForBufs);

	if (err == KErrNotSupported)

		{

		// Then debug router not found - so just create a chunk ourselves

		_LIT(KName, "CloggerBufferChunk");

		err = iChunkForBufs.CreateGlobal(KName, 0, KMaxChunkSize);

		}

	User::LeaveIfError(err);

	UpdateBufferSizeL(iBufferSize, iNumBuffers);

	iTempBuf.CreateL(512);

	iSessionTempBuf.CreateL(512);

	// The mechanism to compress log files in the background is a special case of a CSyncWriterWrapper

	CLogCompressor* compressor = CLogCompressor::NewLC(*this);

	iCompressor = CSyncWriterWrapper::NewL(*this, *compressor, -1);

	CleanupStack::Pop(compressor);

	iCompressor->SetEnabled(ETrue); // Otherwise CSyncWriterWrapper will ignore our requests to compress things!

	iTags.ReserveL(32);

	// Construct some tags that always exist

	iCloggerTag = iTags.Find(KCloggerTag);

	if (!iCloggerTag)

		{

		HBufC8* tag = KCloggerTag().AllocLC();

		iCloggerTag = reinterpret_cast<TTagData*>(NewSessionForTagL(tag));

		iCloggerTag->SetShouldDisplay();

		iCloggerTag->iEnabled = ELogNewRdebuggers; // Defaults to off, except for logging new rdebuggers - because you generally want to be able to see the thread name

		CleanupStack::Pop(tag);

		}

	iRDebugTag = iTags.Find(KRDebugTag);

	if (!iRDebugTag)

		{

		HBufC8* tag = KRDebugTag().AllocLC();

		iRDebugTag = reinterpret_cast<TTagData*>(NewSessionForTagL(tag));

		// Should not be shown unless used, so don't SetShouldDisplay

		CleanupStack::Pop(tag);

		}

	iFallbackTag = iTags.Find(KFallbackTag);

	if (!iFallbackTag)

		{

		HBufC8* tag = KFallbackTag().AllocLC();

		iFallbackTag = reinterpret_cast<TTagData*>(NewSessionForTagL(tag));

		iFallbackTag->SetShouldDisplay();

		CleanupStack::Pop(tag);

		}

	TUint32 tickCount = User::NTickCount();

	iTimeAtStartup.UniversalTime();

	TInt tickPeriod;

	//User::LeaveIfError(HAL::Get(HAL::EFastCounterFrequency, iTickFreq));

	User::LeaveIfError(HAL::Get(HAL::ENanoTickPeriod, tickPeriod));

	iTickFreq = 1000000 / tickPeriod; // We work in frequencies because they are the round numbers when using the fast counter, and at some point we might want to again

	iStartupTickInMicroseconds = ((TInt64)tickCount * 1000000) / (TInt64)iTickFreq; // Just making damn sure we're using 64bit math

	// Rotate uses the tick stuff so must come after it

	if (iRotateBehaviour & RClogger::EAutoRotateAtStartup)

		{

		Rotate();

		}

	UpdatedGlobalOptionsL(iOptions & RClogger::EBufferLog); // Passing in the current value of EBufferLog means we don't trigger another UpdateBufferSizeL, which is good because we've explicitly called that earlier on in this function

	iFlags.Set(EWrittenToLog);

	_LIT8(KCrLf, "\r\n");

	_LIT8(KStarted, "Server started (log format v4)");

	// Format v1 used incorrect time stamps, v2 fixed that, v3 indicates that the buffer info is published via P&S

	// v4 scraps P&S and uses the kern debug router to map the buffers into the crashlog

	LogLine(KCrLf);

	Log(NULL, KStarted, User::NTickCount());

	if (iFlags.IsSet(ECenrepFailed))

		{

		_LIT8(KCenrep, "Couldn't access the cenrep repository.");

		LogError(KCenrep);

		}

	if (debugRouterErr)

		{

		_LIT8(KDebugRouterFailed, "Failed to load the debug router LDD, err=%i.");

		LogError(KDebugRouterFailed, debugRouterErr);

		}

	_LIT_SECURITY_POLICY_PASS(KRead);

	_LIT_SECURITY_POLICY_S0(KWrite, KCloggerUid.iUid);

	RProperty::Define(KCloggerUid, ESequenceNumber, RProperty::EInt, KRead, KWrite);

	RProperty::Set(KCloggerUid, ESequenceNumber, iEnabledStatesSequenceNumber);

	}

void CCloggerServer::GetSettingsL()

	{

	TRAPD(err, DoGetSettingsL());

	// Don't allow messed-up cenrep config to prevent us from launching

	if (err)

		{

		iBufferSize = 4096;

		iNumBuffers = 2;

		iNumRotates = 4;

		iFlags.Set(ECenrepFailed);

		}

	}

void CCloggerServer::DoGetSettingsL()

	{

	CRepository* cenrep = CRepository::NewLC(KCloggerUid);

	User::LeaveIfError(cenrep->Get(EGlobalOptions, (TInt&)iOptions));

	User::LeaveIfError(cenrep->Get(EBufferSize, iBufferSize));

	User::LeaveIfError(cenrep->Get(ENumBuffers, iNumBuffers));

	User::LeaveIfError(cenrep->Get(ENumRotates, iNumRotates));

	User::LeaveIfError(cenrep->Get(ERotateBehaviour, (TInt&)iRotateBehaviour));

	TInt version = 0;

	TBool needToPrettifyThreadNames = EFalse;

	TInt err = cenrep->Get(ERepositoryVersion, version);

	if (err || version < ECenrepThreadNamesArePrettified)

		{

		needToPrettifyThreadNames = ETrue;

		}

	RArray<TUint32> foundKeys;

	CleanupClosePushL(foundKeys);

	err = cenrep->FindL(KTagEnabledPartialKey, KEnabledMask, foundKeys);

	if (err == KErrNone)

		{

		TInt n = foundKeys.Count();

		TBuf8<1> dummyBuf;

		for (TInt i = 0; i < n; i++)

			{

			TUint32 enabled;

			User::LeaveIfError(cenrep->Get(foundKeys[i], (TInt&)enabled));

			TInt len;

			HBufC8* tagName = NULL;

			TInt err = cenrep->Get(foundKeys[i]+1, dummyBuf, len);

			if (err == KErrNone)

				{

				tagName = dummyBuf.AllocLC();

				}

			else if (err == KErrOverflow)

				{

				tagName = HBufC8::NewLC(len);

				}

			else

				{

				User::LeaveIfError(err);

				}

			TPtr8 ptr = tagName->Des();

			User::LeaveIfError(cenrep->Get(foundKeys[i]+1, ptr, len));

			if (needToPrettifyThreadNames)

				{

				ThreadPrettyName(ptr);

				}

			if (*tagName == KKernPrintfTag)

				{

				// We don't use this any more

				CleanupStack::PopAndDestroy(tagName);

				continue;

				}

			else if (*tagName == KOldFallbackTag)

				{

				// In case the old definition is kicking round in a cenrep file

				*tagName = KFallbackTag;

				}

			else if (*tagName == KOldRDebugTag)

				{

				// We've renamed this too

				*tagName = KRDebugTag;

				}

			TTagData* tagData = iTags.Find(*tagName);

			if (tagData)

				{

				// tagName is not needed

				CleanupStack::PopAndDestroy(tagName);

				}

			else

				{

				tagData = new(ELeave)TTagData(tagName);

				if (*tagName == KRDebugTag)

					{

					// We don't want this tag to show up unless we've actually used it, since it's only used for last-ditch OOM logging (this is to minimise confusion about which tags are used for what)

					}

				else

					{

					tagData->SetShouldDisplay(); // If the tag comes from cenrep then we should show it

					}

				CleanupStack::PushL(tagData);

				iTags.InsertL(tagName, tagData);

				CleanupStack::Pop(tagData);

				CleanupStack::Pop(tagName);

				}

			tagData->iEnabled = enabled;

			}

		}

	CleanupStack::PopAndDestroy(&foundKeys);

	/*

	TInt descSize = 0;

	TBuf8<1> dummyBuf; // Don't bother trying to succeed without knowing the buffer size

	TInt err = cenrep->Get(EEnabledTags, dummyBuf, descSize);

	if (err == KErrOverflow)

		{

		// If err is not found, we don't care (repository key hasn't been defined) so do nothing

		RBuf8 buf;

		CleanupClosePushL(buf);

		buf.CreateL(descSize);

		err = cenrep->Get(EEnabledTags, buf, descSize);

		User::LeaveIfError(err); // Shouldn't happen

		CBufFlat* cbuf = CBufFlat::NewL(buf.Length());

		CleanupStack::PushL(cbuf);

		cbuf->InsertL(0, buf);

		RBufReadStream stream(*cbuf);

		CleanupClosePushL(stream);

		TInt count = stream.ReadInt32L();

		while (count--)

			{

			TUint32 enabled = stream.ReadUint32L();

			HBufC8* tagName = HBufC8::NewL(stream, 2000);

			TTagData* tagData = iTags.Find(*tagName);

			if (tagData)

				{

				delete tagName; // Not needed

				}

			else

				{

				tagData = new(ELeave)TTagData();

				tagData->iTagName = tagName;

				tagData->iRefCount = 0;

				CleanupStack::PushL(tagData);

				iTags.InsertL(tagName, tagData); // TODO hmm if this leaves, tagName will be leaked

				CleanupStack::Pop(tagData);

				}

			tagData->iEnabled = enabled;