diff -r 000000000000 -r c6b0df440bee dbgagents/trkagent/eka2driver/TrkDriver.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbgagents/trkagent/eka2driver/TrkDriver.h Tue Mar 02 10:33:16 2010 +0530 @@ -0,0 +1,351 @@ +/* +* Copyright (c) 2004 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: +* +*/ + + +#ifndef __TRKDRIVER_H__ +#define __TRKDRIVER_H__ + +// Debug messages +#ifdef _DEBUG +#define LOG_MSG(x) __KTRACE_OPT(KDEBUGGER, Kern::Printf(x)) +#define LOG_MSG2(x, y) __KTRACE_OPT(KDEBUGGER, Kern::Printf(x, y)) +#else +#define LOG_MSG(x) +#define LOG_MSG2(x, y) +#endif + + +// +// Macros +// +const TUint32 KArmBreakPoint = 0xE7F123F4; +const TUint16 KThumbBreakPoint = 0xDE56; + +// From mmboot.h header +const TLinAddr KDataSectionEnd =0x40000000u; +const TLinAddr KRomLinearBase =0xF8000000u; + +const TLinAddr KSuperPageMovingLinAddr =0x60000000u; +const TLinAddr KSuperPageMultipleLinAddr =0xC0000000u; +const TLinAddr KKernDataEndMovingLinAddr =0x655FFFFFu;//0xF3FFFFFFu; +const TLinAddr KKernDataEndMultipleLinAddr =0xFFEFFFFFu; + +#define NUMBER_OF_TEMP_BREAKPOINTS 10 +#define NUMBER_OF_EVENTS_TO_QUEUE 50 +#define NUMBER_OF_LIBS_TO_REGISTER 100 +#define ROM_LINEAR_BASE KRomLinearBase + +//for multiple memory model +#define NUMBER_OF_MAX_BREAKPOINTS 100 + +// Result checking +#define ReturnIfError(x) { TInt y = x; if (KErrNone != y) return y; } + +// Register definitions +#define SP_REGISTER 13 +#define LINK_REGISTER 14 +#define PC_REGISTER 15 +#define STATUS_REGISTER 16 + +// ARM instruction bitmasks +#define ARM_OPCODE(x) (((TUint32)(x) & 0x0E000000) >> 25) + +// Generic instruction defines +#define ARM_RM(x) ((TUint32)(x) & 0x0000000F) // bit 0- 4 +#define ARM_RS(x) (((TUint32)(x) & 0x00000F00) >> 8) // bit 8-11 +#define ARM_RD(x) (((TUint32)(x) & 0x0000F000) >> 12) // bit 12-15 +#define ARM_RN(x) (((TUint32)(x) & 0x000F0000) >> 16) // bit 16-19 +#define ARM_LOAD(x) (((TUint32)(x) & 0x00100000) >> 20) // bit 20 + +// Data processing instruction defines +#define ARM_DATA_SHIFT(x) (((TUint32)(x) & 0x00000060) >> 5) // bit 5- 6 +#define ARM_DATA_C(x) (((TUint32)(x) & 0x00000F80) >> 7) // bit 7-11 +#define ARM_DATA_IMM(x) ((TUint32)(x) & 0x000000FF) // bit 0-7 +#define ARM_DATA_ROT(x) (((TUint32)(x) & 0x00000F00) >> 8) // bit 8-11 + +// Single date transfer instruction defines +#define ARM_SINGLE_IMM(x) ((TUint32)(x) & 0x00000FFF) // bit 0-11 +#define ARM_SINGLE_BYTE(x) (((TUint32)(x) & 0x00400000) >> 22) // bit 22 +#define ARM_SINGLE_U(x) (((TUint32)(x) & 0x00800000) >> 23) // bit 23 +#define ARM_SINGLE_PRE(x) (((TUint32)(x) & 0x01000000) >> 24) // bit 24 + +// Block data transfer instruction defines +#define ARM_BLOCK_REGLIST(x) ((TUint32)(x) & 0x0000FFFF) // bit 0-15 +#define ARM_BLOCK_U(x) (((TUint32)(x) & 0x00800000) >> 23) // bit 23 +#define ARM_BLOCK_PRE(x) (((TUint32)(x) & 0x01000000) >> 24) // bit 24 + +// Branch instruction defines +#define ARM_B_ADDR(x) ((x & 0x00800000) ? ((TUint32)(x) & 0x00FFFFFF | 0xFF000000) : (TUint32)(x) & 0x00FFFFFF) +#define ARM_INSTR_B_DEST(x,a) (ARM_B_ADDR(x) << 2) + ((TUint32)(a) + 8) + +#define ARM_CARRY_BIT 0x20000000 // bit 30 + + +// Thumb instruction bitmasks +#define THUMB_OPCODE(x) (((TUint16)(x) & 0xF800) >> 11) +#define THUMB_INST_7_15(x) (((TUint16)(x) & 0xFF80) >> 7) +#define THUMB_INST_8_15(x) (((TUint16)(x) & 0xFF00) >> 8) + + +const TUint8 KArm4Stub[8] = { 0x00, 0xC0, 0x9F, 0xE5, 0x00, 0xF0, 0x9C, 0xE5 }; +const TUint8 KArmIStub[12] = { 0x04, 0xC0, 0x9F, 0xE5, 0x00, 0xC0, 0x9C, 0xE5, 0x1C, 0xFF, 0x2F, 0xE1 }; +const TUint8 KFastArmIStub[12] = { 0x04, 0xC0, 0x9F, 0xE5, 0x1C, 0xFF, 0x2F, 0xE1, 0x00, 0x00, 0x00, 0x00 }; +const TUint8 KThumbStub[12] = { 0x40, 0xB4, 0x02, 0x4E, 0x36, 0x68, 0xB4, 0x46, 0x40, 0xBC, 0x60, 0x47 }; +const TUint8 KThumbStub2[8] = { 0x01, 0x4B, 0x1B, 0x68, 0x18, 0x47, 0xC0, 0x46 }; +const TUint8 KFastThumbStub[12] = { 0x40, 0xB4, 0x02, 0x4E, 0xB4, 0x46, 0x40, 0xBC, 0x60, 0x47, 0xC0, 0x46 }; +const TUint8 KFastThumbStub2[8] = { 0x01, 0x4B, 0x18, 0x47, 0xC0, 0x46, 0xC0, 0x46 }; + +const unsigned char KRvctArm4Stub[4] = { 0x04, 0xF0, 0x1F, 0xE5 }; + +// +// class TBreakEntry +// +class TBreakEntry +{ +public: + + inline TBreakEntry() { Reset(); }; + + inline TBreakEntry(TUint32 aId, TUint32 aThreadId, TUint32 aAddress, TBool aThumbMode) + : iId(aId), + iThreadId(aThreadId), + iAddress(aAddress), + iThumbMode(aThumbMode) + { + iInstruction.FillZ(4); + iPageAddress = 0; + iDisabledForStep = EFalse; + iObsoleteLibraryBreakpoint = EFalse; + iResumeOnceOutOfRange = EFalse; + iSteppingInto = EFalse; + iRangeStart = 0; + iRangeEnd = 0; + iThreadSpecific = EFalse; + }; + + inline void Reset() + { + iThreadId = 0; + iAddress = 0; + iThumbMode = EFalse; + iInstruction.FillZ(4); + iPageAddress = 0; + iDisabledForStep = EFalse; + iObsoleteLibraryBreakpoint = EFalse; + iResumeOnceOutOfRange = EFalse; + iSteppingInto = EFalse; + iRangeStart = 0; + iRangeEnd = 0; + }; + +public: + + TInt32 iId; + TUint32 iThreadId; + TUint32 iAddress; + TBool iThumbMode; + TBuf8<4> iInstruction; + TUint32 iPageAddress; + TBool iDisabledForStep; + TBool iObsoleteLibraryBreakpoint; + TBool iResumeOnceOutOfRange; + TBool iSteppingInto; + TUint32 iRangeStart; + TUint32 iRangeEnd; + TBool iThreadSpecific; +}; + +class TProcessInfo +{ + public: + + inline TProcessInfo() { Reset(); } + + inline TProcessInfo(TUint32 aId, TUint32 aCodeAddress, TUint32 aCodeSize, TUint32 aDataAddress) + : iId(aId), + iCodeAddress(aCodeAddress), + iCodeSize(aCodeSize), + iDataAddress(aDataAddress) { } + + inline void Reset() + { + iId = 0; + iCodeAddress = 0; + iCodeSize = 0; + iDataAddress = 0; + } + + public: + TUint32 iId; + TUint32 iCodeAddress; + TUint32 iCodeSize; + TUint32 iDataAddress; +}; + + +// +// class DMetroTrkDriverFactory +// +class DMetroTrkDriverFactory : public DLogicalDevice +{ +public: + + DMetroTrkDriverFactory(); + virtual TInt Install(); + virtual void GetCaps(TDes8& aDes) const; + virtual TInt Create(DLogicalChannelBase*& aChannel); +}; + +class DMetroTrkEventHandler; +// +// DMetroTrkChannel +// +class DMetroTrkChannel : public DLogicalChannel +{ +public: + + DMetroTrkChannel(DLogicalDevice* aLogicalDevice); + ~DMetroTrkChannel(); + + virtual TInt DoCreate(TInt aUnit, const TDesC* anInfo, const TVersion& aVer); + virtual void HandleMsg(TMessageBase* aMsg); + + //called from the event handler + void AddProcess(DProcess *aProcess, DThread* aThread); + void StartThread(DThread *aThread); + void RemoveProcess(DProcess *aProcess); + void AddLibrary(DLibrary *aLibrary, DThread *aThread); + void RemoveLibrary(DLibrary *aLibrary); + void AddCodeSegment(DCodeSeg *aCodeSeg, DProcess *aProcess); + void RemoveCodeSegment(DCodeSeg *aCodeSeg, DProcess *aProcess); + TBool HandleEventKillThread(DThread* aThread); + TBool HandleSwException(TExcType aExcType); + TBool HandleHwException(TArmExcInfo* aExcInfo); + TBool HandleUserTrace(TText* aStr, TInt aLen); + +protected: + virtual void DoCancel(TInt aReqNo); + virtual void DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2); + virtual TInt DoControl(TInt aFunction, TAny *a1, TAny *a2); + +private: + void HandleException(SEventInfo& aEventInfo, DThread* aCurrentThread); + + TInt SetBreak(TUint32 aThreadId, TMetroTrkBreakInfo* aBreakInfo); + TInt StepRange(DThread* aThread, TMetroTrkStepInfo* aStepInfo); + TInt ReadMemory(DThread* aThread, TMetroTrkMemoryInfo* aMemoryInfo); + TInt WriteMemory(DThread* aThread, TMetroTrkMemoryInfo* aMemoryInfo); + TInt ReadRegisters(DThread* aThread, TMetroTrkRegisterInfo* aRegisterInfo); + TInt WriteRegisters(DThread* aThread, TMetroTrkRegisterInfo* aRegisterInfo); + TInt GetProcessInfo(TInt aIndex, TMetroTrkTaskInfo* aTaskInfo); + TInt GetThreadInfo(TInt aIndex, TMetroTrkTaskInfo* aTaskInfo); + TInt GetProcessAddresses(DThread* aThread, TMetroTrkProcessInfo* aProcessInfo); + TInt GetStaticLibraryInfo(TInt aIndex, SEventInfo* aEventInfo); + TInt GetLibraryInfo(TMetroTrkLibInfo* aLibInfo); + TInt GetExeInfo(TMetroTrkExeInfo* aExeInfo); + TInt GetProcUidInfo(TMetroTrkProcUidInfo* aProcUidInfo); + TInt DetachProcess(DProcess* aProcess); + + TInt DoSetBreak(const TUint32 aProcessId, const TUint32 aThreadId, const TUint32 aAddress, const TBool aThumbMode, TInt32 &aId); + TInt DoEnableBreak(TBreakEntry &aEntry, TBool aSaveOldInstruction); + TInt DoClearBreak(const TInt32 aId); + TInt DoChangeBreakThread(TUint32 aThreadId, TInt32 aId); + TInt DoSuspendThread(DThread *aThread); + TInt DoResumeThread(DThread *aThread); + TInt DoStepRange(DThread *aThread, const TUint32 aStartAddress, const TUint32 aStopAddress, TBool aStepInto, TBool aResumeOnceOutOfRange, TBool aUserRequest = EFalse); + TInt DoReadMemory(DThread *aThread, const TUint32 aAddress, const TInt16 aLength, TDes8 &aData); + TInt DoWriteMemory(DThread *aThread, const TUint32 aAddress, const TInt16 aLength, TDes8 &aData); + TInt DoReadRegisters(DThread *aThread, const TInt16 aFirstRegister, const TInt16 aLastRegister, TDes8 &aValues); + TInt DoWriteRegisters(DThread *aThread, const TInt16 aFirstRegister, const TInt16 aLastRegister, TDesC8 &aValues); + TInt DoGetProcessInfo(const TInt aIndex, TMetroTrkTaskInfo *aInfo); + TInt DoGetThreadInfo(const TInt aIndex, TMetroTrkTaskInfo *aInfo); + TInt DoGetProcessAddresses(DThread *aThread, TUint32 &aCodeAddress, TUint32 &aDataAddress); + TInt DoGetStaticLibraryInfo(const TInt aIndex, SEventInfo *aInfo); + TInt DoGetLibraryInfo(TDesC8 &aDllName, TMetroTrkLibInfo* aLibInfo); + TInt DoGetExeInfo(TDesC8 &aExeName, TMetroTrkExeInfo* aExeInfo); + TInt DoGetProcUidInfo(TMetroTrkProcUidInfo* aProcUidInfo); + + TBool DoSecurityCheck(); + TInt TryToReadMemory(DThread *aThread, TAny *aSrc, TAny *aDest, TInt16 aLength); + TInt TryToWriteMemory(DThread *aThread, TAny *aDest, TAny *aSrc, TInt16 aLength); + TInt32 ReadRegister(DThread *aThread, TInt aNum); + TInt ModifyBreaksForStep(DThread *aThread, TUint32 aRangeStart, TUint32 aRangeEnd, TBool aStepInto, TBool aResumeOnceOutOfRange, TBool aCheckForStubs); + TBool IsExecuted(TUint8 aCondition, TUint32 aStatusRegister); + void ClearAllBreakPoints(); + TInt DisableBreakAtAddress(TUint32 aAddress); + TInt DoEnableDisabledBreak(TUint32 aThreadId); + TUint32 ShiftedRegValue(DThread *aThread, TUint32 aInstruction, TUint32 aCurrentPC, TUint32 aStatusRegister); + TBool InstructionModifiesPC(DThread *aThread, TUint8 *aInstruction, TBool aThumbMode, TBool aStepInto); + TUint32 PCAfterInstructionExecutes(DThread *aThread, TUint32 aCurrentPC, TUint32 aStatusRegister, TInt aInstSize, TBool aStepInto, TUint32 &aNewRangeEnd, TBool &aChangingModes); + void DecodeDataProcessingInstruction(TUint8 aOpcode, TUint32 aOp1, TUint32 aOp2, TUint32 aStatusRegister, TUint32 &aBreakAddress); + TBool IsPreviousInstructionMovePCToLR(DThread *aThread); + + TBool IsAddressInRom(TUint32 aAddress); + TBool IsAddressSecure(TUint32 aAddress); + TBool IsRegisterSecure(TInt registerIndex); + + TInt AllocateShadowPageIfNecessary(TUint32 aAddress, TUint32 &aPageAddress); + TInt FreeShadowPageIfNecessary(TUint32 aAddress, TUint32 aPageAddress); + + void NotifyEvent(SEventInfo aEventInfo, TBool isTraceEvent=EFalse); + DThread* ThreadFromId(TUint32 aId); + DProcess* ProcessFromId(TUint32 aId); + TBool GetSystemThreadRegisters(TArmRegSet* aArmRegSet); + TInt DoGetLibInfoFromCodeSegList(TDesC8 &aDllName, TMetroTrkLibInfo *aInfo); + TInt DoGetLibInfoFromKernLibContainer(TDesC8 &aDllName, TMetroTrkLibInfo *aInfo); + + TBool HasManufacturerCaps(DThread* aThread); + TBool IsBeingDebugged(const DThread* aThread); + + void CheckLibraryNotifyList(TUint32 aProcessId); + +private: + DThread* iClientThread; + DMetroTrkEventHandler* iEventHandler; + + TUint32 iExcludedROMAddressStart; + TUint32 iExcludedROMAddressEnd; + + RArray iBreakPointList; + TInt iNextBreakId; + + SEventInfo *iEventInfo; + RArray iEventQueue; + RArray iTraceEventQueue; + TRequestStatus* iRequestGetEventStatus; + + TUint32 iPageSize; + + TBool iNotifyLibLoadedEvent; + TBool iMultipleMemModel; + + RArray iDebugProcessList; //processes that we are debugging + RArray iProcessNotifyList; + + TDfcQue* iDFCQue; + + TArmExcInfo iCurrentExcInfo; + TBool iExcInfoValid; + TBool iDebugging; + // PANIC_BACKPORT + RPointerArray iFrozenThreadSemaphores; + // END PANIC_BACKPORT + RArray iLibraryNotifyList; + +}; + +#endif //__TRKDRIVER_H__