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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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 <e32base.h>    //base stuff

#include <e32debug.h>   //logging

#include <e32cons.h>    //console

#include <e32property.h>

#include <e32utrace.h>

#include <d32btrace.h>

#include <uloggerclient.h>

#include "t_crashdriver_drv.h"

#include "crash.h"

#include "crashdefs.h"//definitions included

_LIT(KAlloc, "-a <num_of_kbytes> : memory to be allocated on the heap; default is zero\n");

_LIT(KChunks, "-n <num_of_chunks> :  first global - 1k, the rest 0.5k are local to the process; default is none\n");

_LIT(KDelay, "-d <num_of_seconds> : time before the app crashes; default is 60s\n");

_LIT(KFault, "-c <fault_type> : crash type; default is null pointer dereference\n");

_LIT(KFaultTypes, "None=0, PrefetchAbort=1, DataRead=2\n DataWrite=3, UndefInstr=4, UserPanic=5\n UserException=6, EStackOverflow=7, UserExit=8\n UserLeave=9, ThreadKill=10, ThreadPanic=11\n ThreadTerminate=12, DivByZero=13\n");

_LIT(KLoad, "-l : load esock.dll library into process address space; default is no\n");

_LIT(KSimon, "-s : to create a dummy child thread that is not going to crash; default is no\n");

_LIT(KThreads, "-m <num_of_threads> : that are going to be created and then crashed; if not specified the main thread is going to crash\n");

_LIT(KTrace, "-t: includes test trace data\n");

_LIT(KKernelCrash, "-k: causes the crash to occur in a device driver\n");

_LIT(KCrashDriverLddFileName, "crashdriverldd");

//crash app trace filter

#define CrashAppTraceFilter 200

/** Crash App UID */

const TUid KCrashAppUid = { 0x102831E5 };

using namespace Ulogger;

enum TFaultType

{

    ENone			=0,

    EPrefetchAbort	=1,

    EDataRead		=2,

    EDataWrite		=3,

    EUndefInstr		=4,

    EUserPanic		=5,

    EUserException	=6,

    EStackOverflow	=7,

    EUserExit		=8,

    EUserLeave		=9,

    EThreadKill		=10,

    EThreadPanic	=11,

    EThreadTerminate=12,

    EDivByZero		=13,

};

enum TProgress 

{ 

	EMainThread, 	

	EChildThread	

};

CConsoleBase *console;

_LIT(KPanicCategory, "example panic category");

TInt gAlloc = 0;

TInt gDelay = 60; 

TBool gLibrary = EFalse;

TInt gChunks = 0;

TInt gMultikill = 0;

TBool gScreamer = EFalse;

TFaultType gFault = ENone;

TBool gTrace = EFalse;

TBool gKernelSide = EFalse;

void WriteTraceData()

	{	

	RBTrace trace;

    TInt e = trace.Open();

    if(e != KErrNone)

    	{

    	RDebug::Printf("crashapp: opening trace buffer failed: %d\n", e);

    	trace.Close();

    	return;

    	}

    RDebug::Printf("crashapp: opening trace buffer succesful\n");

    trace.SetFilter(200, ETrue);

    trace.SetFilter2(1);

    trace.SetMode(RBTrace::EEnable);

	//do some tracing

	TPrimaryFilter prim = KTraceCategory; //arbitrary once between 192 and 253

	RDebug::Printf("crashapp: making trace calls");

	User::After(15000000);

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

		{				

		TUTrace::PrintfPrimary(prim, ETrue, ETrue, "crashapp trace call number %d", i);

		}

	trace.Close();		

	}

typedef void (*Tfunc)();

void PrefetchAbort()

{

    Tfunc f = NULL;

    f();

}

void DataRead()

{

  	TInt* r = (TInt*) 0x1000;

   	TInt rr = (TInt)*r;

	// Stop compilation warning. Should not get here anyway.

	rr++;

}

void DataWrite()

{

  	TInt* r = (TInt*) 0x1000;

   	*r = 0x42;                

}

void UndefInstr()

{

   	TUint32 undef = 0xE6000010;

   	Tfunc f = (Tfunc) &undef;

   	f();

}

void DivByZero()

{

    int i = 1;

    int j = 10;

    for(j=10; j>0; --j)

    	{

    	//this is here to avoid compiler div by zero warnings 

    	}

    i = i/j;

}

void UserPanic()

{

    User::Panic(KPanicCategory, KErrGeneral); 

}

void UserException()

{

    User::RaiseException(EExcGeneral);

}

void UserExit()

{

    User::Exit(KErrGeneral);

}

void UserLeaveL()

{

    User::Leave(KErrGeneral);

}

void ThreadKill()

{

    RThread thread;

    thread.Kill(KErrNone);

}

void ThreadPanic()

{

    RThread thread;

    thread.Panic(KPanicCategory, KErrGeneral);

}

void ThreadTerminate()

{

    RThread thread;

    thread.Terminate(KErrGeneral);

}

static TUint recurseCount;

void StackOverflow()

{

	TUint32 array[128];

	array[0] = ++recurseCount;

    StackOverflow();

	TUint warnRem = array[0];

	array[0] = warnRem;

}

void ParseCommandlineArgsL()

{

    TInt argc = User::CommandLineLength();

    if(argc > 0)

    {

	    HBufC* args = HBufC::NewLC(User::CommandLineLength());

        TPtr argv = args->Des();

	    User::CommandLine(argv);

	    TLex lex(*args);

        while(!lex.Eos())

        {

            if(lex.Get() == '-')

            {

                TChar c = lex.Get();

                if(c == '-')

                {

                    TPtrC16 token = lex.NextToken();

                    c = token[0];

                }

                lex.SkipSpace();

                switch(c)

                {

                    case 'a':

                        lex.Val(gAlloc);

                        break;

                    case 'd':

                        lex.Val(gDelay);

                        break;

                    case 'n':

                        lex.Val(gChunks);

                        break;

                    case 'c':

                        lex.Val((TInt&)gFault);

                        break;

                    case 'l':

                        gLibrary = ETrue;

                        break;

                    case 'm':

                        lex.Val(gMultikill);

                        break;

                    case 's':

                        gScreamer = ETrue;

                        break;

                    case 't':

                    	gTrace = ETrue;

                    	break;

                    case 'k':

                    	gKernelSide = ETrue;

                    	break;

                    case 'h':

                    default:

                        _LIT(KParams, "full parameter list:\n");

                        console->Printf(KParams);

                        console->Printf(KAlloc);

                        console->Printf(KChunks);

                        console->Printf(KDelay);

                        console->Printf(KFault);

						console->Printf(KFaultTypes);

                        console->Printf(KLoad);

                        console->Printf(KSimon);

                        console->Printf(KThreads);

                        console->Printf(KTrace);

                        console->Printf(KKernelCrash);

                        _LIT(KPressAnyKey,"[press any key]");

                        console->Printf(KPressAnyKey);

	                    console->Getch();

                        User::Leave(KErrNone);

                }

            }

            lex.SkipSpace();

        }

	    CleanupStack::PopAndDestroy(args);  

    }

}

TInt ThreadSimon(TAny* /*aCall*/)

{

    RThread thread;

    TUint simonCounter = 1;

    while(simonCounter++)

    {

        User::After(1000000);

        RDebug::Printf("crashapp.exe - Simon[%Lu] says...%d\n", thread.Id().Id(), simonCounter);

    }

    return 0;

}

TInt ThreadCrash(TAny* aCall)

{

    User::After(gDelay*1000000);

    Tfunc call = (Tfunc)(aCall);

    RThread thread;

    RDebug::Printf("crashapp.exe - time to die[%Lu]!\n", thread.Id().Id());

    call();

    return 0;

}

void MainL()

{

	//Setup a property to monitor main thread    

	static _LIT_SECURITY_POLICY_PASS(KAllowAllPolicy);

	TInt err = RProperty::Define(KCrashAppUid, EMainThread, RProperty::EInt, KAllowAllPolicy, KAllowAllPolicy);

	if (err != KErrAlreadyExists)

	    {

	    User::LeaveIfError(err);

	    }

    Tfunc call = NULL;

	recurseCount = 0;

    _LIT(KConsole, "crash console");

    console = Console::NewL(KConsole, TSize(KConsFullScreen, KConsFullScreen));

    CleanupStack::PushL(console);          

    ParseCommandlineArgsL();

    if(gTrace)

    	{

    	WriteTraceData();

    	}

    CleanupStack::PopAndDestroy(console);

    //Load crash driver

    RKernelCrashDrv crashDriver;

    if(gKernelSide)

    	{

    	err = User::LoadLogicalDevice(KCrashDriverLddFileName);

    	if(KErrNone != err && KErrAlreadyExists != err )

    		{

    		RDebug::Printf("Unable to load kernel crash driver (%d)", err);

    		User::Leave(err);

    		}

    	CleanupClosePushL(crashDriver);

    	RDebug::Printf("Crash Driver loaded");

    	err = crashDriver.Open();

    	if(KErrNone != err)

    		{

    		RDebug::Printf("Unable to open kernel crash driver (%d)", err);

    		User::Leave(err);

    		}

    	RDebug::Printf("Crash Driver opened");

    	}        

    TInt32 array[3];

	array[0] = 0xDEADDEAD;

	array[1] = 0xF000BEEF;

	array[2] = 0xBEEBEE00;

    RDebug::Printf("crashapp.exe will crash after %d secs, crash type: ", gDelay);

    TRequestStatus status;

    switch(gFault)

    {

        default:

        case ENone:

        	{

            RDebug::Printf("null pointer\n");        	             

            break;

        	}

        case EPrefetchAbort:

        	{

            RDebug::Printf("prefetch abort\n");

        	if(gKernelSide)

	    		{

	    		User::After(gDelay*1000000);

#ifdef __MARM__	    		

	    		SetRegs();

#endif	    		

	    		crashDriver.SendPrefetchAbortFault(status);

	    		User::WaitForRequest(status);

	    		err = status.Int();

	    		if(KErrNone != err)

	    			{

	    			RDebug::Printf("Send request failed (%d)", err);

	    			User::Leave(err);

	    			}

	    		break;

	    		}              

            call = PrefetchAbort;

            break;

        	}

        case EDataRead:

        	{

            RDebug::Printf("data read");

        	if(gKernelSide)

	    		{

	    		User::After(gDelay*1000000);

#ifdef __MARM__	    		

	    		SetRegs();

#endif	    	

	    		crashDriver.SendDataReadFault(status);

	    		User::WaitForRequest(status);

	    		err = status.Int();

	    		if(KErrNone != err)

	    			{

	    			RDebug::Printf("Send request failed (%d)", err);

	    			User::Leave(err);

	    			}

	    		break;

	    		}            

            call = DataRead;

            break;

        	}            

        case EDataWrite:

        	{

            RDebug::Printf("data write");

        	if(gKernelSide)

	    		{

	    		User::After(gDelay*1000000);

#ifdef __MARM__	    		

	    		SetRegs();

#endif	    		

	    		crashDriver.SendDataWriteFault(status);

	    		User::WaitForRequest(status);

	    		err = status.Int();

	    		if(KErrNone != err)

	    			{

	    			RDebug::Printf("Send request failed (%d)", err);

	    			User::Leave(err);

	    			}

	    		break;

	    		}            

            call = DataWrite;

            break;

        	}

        case EUndefInstr:

        	{        	

        	RDebug::Printf("Undefined instruction");

        	if(gKernelSide)

	    		{

	    		User::After(gDelay*1000000);

#ifdef __MARM__	    		

	    		SetRegs();

#endif	    		

	    		crashDriver.SendUndefInstructionFault(status);

	    		User::WaitForRequest(status);

	    		err = status.Int();

	    		if(KErrNone != err)

	    			{

	    			RDebug::Printf("Send request failed (%d)", err);

	    			User::Leave(err);

	    			}

	    		break;

	    		}

            RDebug::Printf("undefined instruction");

            call = UndefInstr;

            break;

        	}        

        case EDivByZero:

        	{

        	RDebug::Printf("Division by zero");

        	if(gKernelSide)

        		{

        		User::After(gDelay*1000000);

#ifdef	__MARM__        		

        		SetRegs();

#endif        		

        		crashDriver.SendDivByZeroFault(status);

        		User::WaitForRequest(status);

        		err = status.Int();

        		if(KErrNone != err)

        			{

        			RDebug::Printf("Send request failed (%d)", err);

        			User::Leave(err);

        			}

        		break;

        		}

            RDebug::Printf("division by zero");

            call = DivByZero;

            break;

        	}        

        case EUserPanic:

        	{        	

            RDebug::Printf("user panic");

        	if(gKernelSide)

        		{

        		RDebug::Printf("This crash is not supported kernel side");

        		User::Leave(KErrNotSupported);

        		}            

            call = UserPanic;

            break;

        	}

        case EUserException:

        	{

            RDebug::Printf("user exception\n");

        	if(gKernelSide)

        		{

        		RDebug::Printf("This crash is not supported kernel side");

        		User::Leave(KErrNotSupported);

        		}            

            call = UserException;

            break;

        	}

        case EUserExit:

        	{

            RDebug::Printf("user exit\n");

        	if(gKernelSide)

        		{

        		RDebug::Printf("This crash is not supported kernel side");

        		User::Leave(KErrNotSupported);

        		}            

            call = UserExit;

            break;

        	}

        case EUserLeave:

        	{

            RDebug::Printf("user leave\n");

        	if(gKernelSide)

        		{

        		RDebug::Printf("This crash is not supported kernel side");

        		User::Leave(KErrNotSupported);

        		}            

            call = UserLeaveL;

            break;

        	}