parse.c

Linux下的类似softice的调试工具

/******************************************************************************
 *
 * Copyright (c) 2003 Gerhard W. Gruber
 *
 * PROJECT: pICE
 * $Source: /cvsroot/pice/pice/module/parse.c,v $
 * $Revision: 1.5 $
 * $Date: 2004/02/17 23:07:36 $
 * $Author: lightweave $
 * $Name:  $
 *
 * $Log: parse.c,v $
 * Revision 1.5  2004/02/17 23:07:36  lightweave
 *
 * Improved the DEBUG facillity and replaced the configuration handler with a
 * new code which now can read MS Windows INI style files. See CHANGES.txt for
 * more details.
 * Also added a macro which prevents compiling for kernels before 2.4.19.
 *
 * Revision 1.4  2003/06/18 22:00:22  lightweave
 * DEBUG and DEBUG_SERIAL added
 *
 *
 *****************************************************************************/

static char *ident = "$Header: /cvsroot/pice/pice/module/parse.c,v 1.5 2004/02/17 23:07:36 lightweave Exp $";


/*++

Copyright (c) 1998-2001 Klaus P. Gerlicher

Module Name:

    parse.c

Abstract:

    execution of debugger commands

Environment:

    Kernel mode only

Author:

    Klaus P. Gerlicher

Revision History:

    19-Aug-1998:	created
    15-Nov-2000:    general cleanup of source files

Copyright notice:

  This file may be distributed under the terms of the GNU Public License.

--*/

////////////////////////////////////////////////////
// INCLUDES
////
#include "remods.h"

#include <linux/sched.h>
#include <asm/io.h>
#include <asm/page.h>
#include <linux/utsname.h>
#include <linux/timer.h>
#include <linux/ctype.h>
#include <linux/sys.h>
#include <linux/highmem.h>

#include "precomp.h"
#include "pci_ids.h"

///////////////////////////////////////////////////
// GLOBALS

ULONG ValueTrue=1,ValueFalse=0;
ULONG ulLastDisassStartAddress=0,ulLastDisassEndAddress=0,ulLastInvertedAddress=0;
USHORT gCurrentSelector=0;
ULONG gCurrentOffset=0;
LONG ulCurrentlyDisplayedLineNumber=0;
USHORT usOldDisasmSegment = 0;
ULONG ulOldDisasmOffset = 0;
static ULONG ulCountForWaitKey = 0;

extern unsigned long sys_call_table[];

BOOLEAN (*DisplayMemory)(EXCEPTION_FRAME* pFrame,PARGS pArgs) = DisplayMemoryDword;

char szCurrentFile[256]="";
struct module* pCurrentMod=NULL;
PICE_SYMBOLFILE_HEADER* pCurrentSymbols=NULL;

// suppresses passing on of function keys while stepping code
BOOLEAN bInt3Here = TRUE;

KEYWORDS RegKeyWords[]={
	{"eax",GetEAX,SetEAX,sizeof(ULONG)},
	{"ebx",GetEBX,SetEBX,sizeof(ULONG)},
	{"ecx",GetECX,SetECX,sizeof(ULONG)},
	{"edx",GetEDX,SetEDX,sizeof(ULONG)},
	{"edi",GetEDI,SetEDI,sizeof(ULONG)},
	{"esi",GetESI,SetESI,sizeof(ULONG)},
	{"ebp",GetEBP,SetEBP,sizeof(ULONG)},
	{"esp",GetESP,SetESP,sizeof(ULONG)},
	{"eip",GetEIP,SetEIP,sizeof(ULONG)},
	{"efl",GetEFLAGS,SetEFLAGS,sizeof(ULONG)},
	{NULL,0,0}
};

KEYWORDS SelectorRegKeyWords[]={
	{"cs",GetCS,SetCS,sizeof(USHORT)},
	{"ds",GetDS,SetDS,sizeof(USHORT)},
	{"es",GetES,SetES,sizeof(USHORT)},
	{"fs",GetFS,SetFS,sizeof(USHORT)},
	{"gs",GetGS,SetGS,sizeof(USHORT)},
	{"ss",GetSS,SetSS,sizeof(USHORT)},
	{NULL,0,0}
};

KEYWORDS OnOffKeyWords[]={
	{"on",GetTRUE,NULL,sizeof(ULONG)},
	{"off",GetFALSE,NULL,sizeof(ULONG)},
	{NULL,0,0}
};

KEYWORDS SpecialKeyWords[]={
	{"process",GetPROCESS,NULL,sizeof(ULONG)},
	{NULL,0,0}
};

LPSTR LocalVarRegs[]=
{
    "EAX",
    "ECX",
    "EDX",
    "EBX", 
    "ESP",
    "EBP",
    "ESI",
    "EDI",
    "EIP",
    "EFL",
    "CS",
    "SS",
    "DS",
    "ES",
    "FS",
    "GS"
};


#define COMMAND_HAS_NO_PARAMS       (0)
#define COMMAND_HAS_PARAMS          (1<<0)
#define COMMAND_HAS_SWITCHES        (1<<1)
//
#define PARAM_CAN_BE_SYMBOLIC           (1<<0)
#define PARAM_CAN_BE_SEG_OFFSET         (1<<1)
#define PARAM_CAN_BE_MODULE             (1<<2)
#define PARAM_CAN_BE_PRNAME             (1<<3)
#define PARAM_CAN_BE_PID                (1<<4)
#define PARAM_CAN_BE_SRC_FILE           (1<<5)
#define PARAM_CAN_BE_NUMERIC            (1<<6)
#define PARAM_CAN_BE_REG_KEYWORD        (1<<7)
#define PARAM_CAN_BE_ONOFF_KEYWORD      (1<<8)
#define PARAM_CAN_BE_SPECIAL_KEYWORD    (1<<9)
#define PARAM_CAN_BE_ASTERISK           (1<<10)
#define PARAM_CAN_BE_ONOFF		        (1<<11)
#define PARAM_CAN_BE_VIRTUAL_SYMBOLIC   (1<<12)
#define PARAM_CAN_BE_SRCLINE            (1<<13)
#define PARAM_CAN_BE_PARTIAL_SYM_NAME   (1<<14)
#define PARAM_CAN_BE_ANY_STRING		    (1<<15)
#define PARAM_CAN_BE_DECIMAL            (1<<16)
#define PARAM_CAN_BE_SIZE_DESC          (1<<17)
#define PARAM_CAN_BE_LETTER             (1<<18)
//
#define COMMAND_GROUP_HELP              (0)
#define COMMAND_GROUP_FLOW              (1)
#define COMMAND_GROUP_STRUCT            (2)
#define COMMAND_GROUP_OS                (3)
#define COMMAND_GROUP_MEM               (4)
#define COMMAND_GROUP_BREAKPOINT        (5)
#define COMMAND_GROUP_WINDOW            (6)
#define COMMAND_GROUP_DEBUG             (7)
#define COMMAND_GROUP_INFO              (8)
#define COMMAND_GROUP_STATE             (9)
#define COMMAND_GROUP_HELP_ONLY         (10)
#define COMMAND_GROUP_LAST              (11)

LPSTR CommandGroups[]=
{
    "HELP",
    "FLOW CONTROL",
    "STRUCTURES",
    "OS SPECIFIC",
    "MEMORY",
    "BREAKPOINTS",
    "WINDOW",
    "DEBUGGING",
    "INFORMATION",
    "STATE",
    "EDITOR",
    NULL
};
// table of command handlers
CMDTABLE CmdTable[]={
	{"regs",ShowRegisters,"show per CPU exception frame"			,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_NUMERIC,0,0,0,0},"",COMMAND_GROUP_MEM},
	{"ib",InportByte,"read model specific register"					,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_NUMERIC,0,0,0,0},"",COMMAND_GROUP_MEM},
	{"ob",OutportByte,"output byte to port"							,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_NUMERIC,PARAM_CAN_BE_NUMERIC,0,0,0},"",COMMAND_GROUP_MEM},
	{"rdmsr",ReadMSR,"read model specific register"					,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_NUMERIC,PARAM_CAN_BE_NUMERIC,0,0,0},"",COMMAND_GROUP_INFO},
	{"zap",ZapBreakpoint,"remove an embedded breakpoint"			,0,{0,0,0,0,0},"",COMMAND_GROUP_DEBUG},
	{"heap",DumpHeap,"dump internal memory heap"					,0,{0,0,0,0,0},"",COMMAND_GROUP_INFO},
	{"gdt",ShowGdt,"display current global descriptor table"		,0,{0,0,0,0,0},"",COMMAND_GROUP_STRUCT},
	{"idt",ShowIdt,"display current interrupt descriptor table"		,0,{0,0,0,0,0},"",COMMAND_GROUP_STRUCT},
	{"x",LeaveIce,"return to Linux"									,0,{0,0,0,0,0},"",COMMAND_GROUP_FLOW},
	{"t",SingleStep,"single step one instruction"					,0,{0,0,0,0,0},"",COMMAND_GROUP_FLOW},
	{"vma",ShowVirtualMemory,"displays VMAs"						,0,{0,0,0,0,0},"",COMMAND_GROUP_OS},
	{"h",ShowHelp,"list help on commands"							,0,{0,0,0,0,0},"",COMMAND_GROUP_HELP},
	{"page",ShowPageDirs,"dump page directories"					,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_NUMERIC|PARAM_CAN_BE_REG_KEYWORD,0,0,0,0},"",COMMAND_GROUP_STRUCT},
	{"proc",ShowProcesses,"list all processes"						,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_PRNAME|PARAM_CAN_BE_PID,0,0,0,0},"",COMMAND_GROUP_OS},
	{"dd",DisplayMemoryDword,"display dword memory"         		,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_NUMERIC|PARAM_CAN_BE_SYMBOLIC|PARAM_CAN_BE_REG_KEYWORD,0,0,0,0},"",COMMAND_GROUP_MEM},
	{"db",DisplayMemoryByte,"display byte memory "		            ,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_NUMERIC|PARAM_CAN_BE_SYMBOLIC|PARAM_CAN_BE_REG_KEYWORD,0,0,0,0},"",COMMAND_GROUP_MEM},
	{"dpd",DisplayPhysMemDword,"display dword physical memory"      ,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_NUMERIC,0,0,0,0},"",COMMAND_GROUP_MEM},
	{"u",Unassemble,"disassemble at address"						,COMMAND_HAS_PARAMS|COMMAND_HAS_SWITCHES,{PARAM_CAN_BE_NUMERIC|PARAM_CAN_BE_SYMBOLIC|PARAM_CAN_BE_REG_KEYWORD|PARAM_CAN_BE_SRCLINE,0,0,0,0},"f",COMMAND_GROUP_MEM},
	{"mod",ShowModules,"displays all modules"					    ,0,{0,0,0,0,0},"",COMMAND_GROUP_OS},
	{"bpx",SetBreakpoint,"set code breakpoint"						,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_NUMERIC|PARAM_CAN_BE_VIRTUAL_SYMBOLIC|PARAM_CAN_BE_SYMBOLIC|PARAM_CAN_BE_SRCLINE|PARAM_CAN_BE_REG_KEYWORD,0,0,0,0},"",COMMAND_GROUP_BREAKPOINT},
	{"bl",ListBreakpoints,"list breakpoints"						,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_NUMERIC,0,0,0,0},"",COMMAND_GROUP_BREAKPOINT},
	{"bc",ClearBreakpoints,"clear breakpoints"						,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_NUMERIC|PARAM_CAN_BE_ASTERISK,0,0,0,0},"",COMMAND_GROUP_BREAKPOINT},
	{"ver",Ver,"display pICE version and state information"			,0,{0,0,0,0,0},"",COMMAND_GROUP_INFO},
	{"hboot",Hboot,"hard boot the system"							,0,{0,0,0,0,0},"",COMMAND_GROUP_FLOW},
	{"code",SetCodeDisplay,"toggle code display"					,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_ONOFF,0,0,0,0},"",COMMAND_GROUP_STATE},
	{"cpu",ShowCPU,"display CPU special registers"					,0,{0,0,0,0,0},"",COMMAND_GROUP_STRUCT},
	{"stack",WalkStack,"display call stack"							,0,{0,0,0,0,0},"",COMMAND_GROUP_STRUCT},
	{"peek",PeekMemory,"peek at physical memory"    		   		,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_SIZE_DESC,PARAM_CAN_BE_NUMERIC,0,0,0},"",COMMAND_GROUP_MEM},
	{"poke",PokeMemory,"poke to physical memory"            		,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_SIZE_DESC,PARAM_CAN_BE_NUMERIC,PARAM_CAN_BE_NUMERIC,0,0},"",COMMAND_GROUP_MEM},
	{".",UnassembleAtCurrentEIP,"unassemble at current instruction" ,0,{0,0,0,0,0},"",COMMAND_GROUP_MEM},
	{"p",StepOver,"single step over call"							,0,{0,0,0,0,0},"",COMMAND_GROUP_FLOW},
	{"i",StepInto,"single step into call"							,0,{0,0,0,0,0},"",COMMAND_GROUP_FLOW},
	{"locals",ShowLocals,"display local symbols"					,0,{0,0,0,0,0},"",COMMAND_GROUP_MEM},
	{"table",SwitchTables,"display loaded symbol tables"			,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_MODULE,0,0,0,0},"",COMMAND_GROUP_DEBUG},
	{"file",SwitchFiles,"display source files in symbol table"		,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_SRC_FILE,0,0,0,0},"",COMMAND_GROUP_DEBUG},
	{"sym",ShowSymbols,"list known symbol information"				,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_PARTIAL_SYM_NAME,0,0,0,0},"",COMMAND_GROUP_DEBUG},
	{"?",EvaluateExpression,"evaluate an expression"				,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_ANY_STRING,0,0,0,0},"",COMMAND_GROUP_DEBUG},
	{"src",SetSrcDisplay,"sets disassembly mode"					,0,{0,0,0,0,0},"",COMMAND_GROUP_DEBUG},
	{"wc",SizeCodeWindow,"change size of code window"	   			,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_DECIMAL,0,0,0,0},"",COMMAND_GROUP_WINDOW},
	{"wd",SizeDataWindow,"change size of data window"	   			,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_DECIMAL,0,0,0,0},"",COMMAND_GROUP_WINDOW},
	{"r",SetGetRegisters,"sets or displays registers"				,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_REG_KEYWORD,PARAM_CAN_BE_NUMERIC,0,0,0},"",COMMAND_GROUP_STRUCT},
	{"cls",ClearScreen,"clear output window"     					,0,{0,0,0,0,0},"",COMMAND_GROUP_WINDOW},
	{"phys",ShowMappings,"show all mappings for linear address"		,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_NUMERIC,0,0,0,0},"",COMMAND_GROUP_MEM},
	{"timers",ShowTimers,"show all active timers"					,0,{0,0,0,0,0},"",COMMAND_GROUP_OS},
	{"pci",ShowPCI,"show PCI devices"   					        ,COMMAND_HAS_PARAMS|COMMAND_HAS_SWITCHES,{PARAM_CAN_BE_DECIMAL,PARAM_CAN_BE_DECIMAL,0,0,0},"a",COMMAND_GROUP_INFO},
	{"next",NextInstr,"advance EIP to next instruction"				,0,{0,0,0,0,0},""},
	{"i3here",I3here,"catch INT 3s"									,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_ONOFF,0,0,0,0},"",COMMAND_GROUP_FLOW},
	{"layout",SetKeyboardLayout,"sets keyboard layout"  			,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_DECIMAL,0,0,0,0},"",COMMAND_GROUP_FLOW},
	{"syscall",ShowSysCallTable,"displays syscall (table)" 			,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_DECIMAL,0,0,0,0},"",COMMAND_GROUP_FLOW},
	{"altkey",SetAltKey,"set alternate break key"        			,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_LETTER,0,0,0,0},"",COMMAND_GROUP_FLOW},
	{"addr",ShowContext,"show/set address contexts"            		,COMMAND_HAS_PARAMS,{PARAM_CAN_BE_PRNAME,0,0,0,0},"",COMMAND_GROUP_FLOW},
	{"arrow up",NULL,""            		                            ,0,{0,0,0,0,0},"",COMMAND_GROUP_HELP_ONLY},
    {NULL,0,NULL}
};

static char tempCmd[1024];

char HexDigit[] = { '0', '1', '2', '3', '4', '5', '6', '7',
                    '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };


CPUINFO CPUInfo[]={
	{"DR0",&CurrentDR0},
	{"DR1",&CurrentDR1},
	{"DR2",&CurrentDR2},
	{"DR3",&CurrentDR3},
	{"DR6",&CurrentDR6},
	{"DR7",&CurrentDR7},
	{"CR0",&CurrentCR0}, 
	{"CR2",&CurrentCR2}, 
	{"CR3",&CurrentCR3}, 
	{"CR4",&CurrentCR4}, 
	{"",NULL},
};

BP Bp[4]={
	{0,0,0,FALSE,FALSE,FALSE,"",""},
	{0,0,0,FALSE,FALSE,FALSE,"",""},
	{0,0,0,FALSE,FALSE,FALSE,"",""},
	{0,0,0,FALSE,FALSE,FALSE,"",""}
};

BOOLEAN bShowSrc = TRUE;
BOOLEAN bCodeOn = FALSE;
BOOLEAN bNeedToFillBuffer = TRUE;

char *NonSystemSegmentTypes[]=
{
	"Data RO",
	"Data RO accessed",
	"Data RW",
	"Data RW accessed",
	"Data RO expand-dwon",
	"Data RO expand-down, accessed",
	"Data RW expand-dwon",
	"Data RW expand-down, accessed",
	"Code EO",
	"Code EO accessed",
	"Code ER",
	"Code ER accessed",
	"Code EO conforming",
	"Code EO conforming, accessed",
	"Code ER conforming",
	"Code ER conforming, accessed"
};

char *SystemSegmentTypes[]=
{
	"reserved0",
	"16-bit TSS (available)",
	"LDT",
	"16-bit TSS (busy)",
	"16-bit call gate",
	"task gate",
	"16-bit interrupt gate",
	"16-bit trap gate",
	"reserved1",
	"32-bit TSS (available)",
	"reserved2",
	"32-bit TSS (busy)",
	"32-bit call gate",
	"reserved3",
	"32-bit interrupt gate",
	"32-bit trap gate"
};

////////////////////////////////////////////////////
// FUNCTIONS
////

//*************************************************************************
// RepaintSource()
//
//*************************************************************************
void RepaintSource(EXCEPTION_FRAME* pFrame)
{
    ARGS Args;

    ENTER_FUNC();

    // disassembly from current address
    PICE_memset(&Args,0,sizeof(ARGS));
    // make unassembler refresh all again 
    ulLastDisassStartAddress=ulLastDisassEndAddress=0;
	Args.Count=0;
	Unassemble(pFrame,&Args);

    LEAVE_FUNC();
}

//*************************************************************************
// RepaintDesktop()
//
//*************************************************************************
void RepaintDesktop(EXCEPTION_FRAME* pFrame)
{
    ARGS Args;
	extern ULONG ulOldInPos,ulInPos;

    ENTER_FUNC();

    PrintTemplate();

    DisplayRegs(pFrame);

    // display data window
	Args.Value[0]=OldSelector;
	Args.Value[1]=OldOffset;
	Args.Count=2;
	DisplayMemory(pFrame,&Args);

    // disassembly from current address
    PICE_memset(&Args,0,sizeof(ARGS));
    // make unassembler refresh all again 
    ulLastDisassStartAddress=ulLastDisassEndAddress=0;
	Args.Count=0;
	Unassemble(pFrame,&Args);

	ulOldInPos = ulInPos-1;
    PrintRingBuffer(wWindow[OUTPUT_WINDOW].cy-1);
    Print(OUTPUT_WINDOW,"");

    ShowStoppedMsg();
    ShowStatusLine(pFrame);

    LEAVE_FUNC();
}

//*************************************************************************
// PutStatusText()
//
//*************************************************************************
void PutStatusText(LPSTR p)
{
    ENTER_FUNC();

	ClrLines(wWindow[OUTPUT_WINDOW].y-1,1);
	PutChar(p,1,wWindow[OUTPUT_WINDOW].y-1);

    LEAVE_FUNC();
}

//*************************************************************************
// WaitForKey()
//
//*************************************************************************
BOOLEAN WaitForKey(void)
{
    BOOLEAN result=TRUE;
	UCHAR ucKeyPressedWhileIdle;

    if(ulCountForWaitKey == 0)
        SuspendPrintRingBuffer(TRUE);

    ulCountForWaitKey++;

	if(ulCountForWaitKey == (wWindow[OUTPUT_WINDOW].cy-1))
	{
        SuspendPrintRingBuffer(FALSE);

    	PrintRingBuffer(wWindow[OUTPUT_WINDOW].cy-1);

        ulCountForWaitKey = 0;

        SetForegroundColor(COLOR_TEXT);
	    SetBackgroundColor(COLOR_CAPTION);
		ClrLines(wWindow[OUTPUT_WINDOW].y+wWindow[OUTPUT_WINDOW].cy,1);
		PutChar(" Press any key to continue listing or press ESC to stop... ",1,wWindow[OUTPUT_WINDOW].y+wWindow[OUTPUT_WINDOW].cy);
		ucKeyPressedWhileIdle=0;
        while(!(ucKeyPressedWhileIdle=GetKeyPolled()))
		{
			PrintCursor(FALSE);
		}
        ResetColor();
		// if ESCAPE then indicate retreat
		if(ucKeyPressedWhileIdle==SCANCODE_ESC)
		{
			result=FALSE;
		}
		ucKeyPressedWhileIdle=0;
	}


    return result;
}

/////////////////////////////////////////////////////////////
// command handlers
/////////////////////////////////////////////////////////////

//*************************************************************************
// SingleStep()
//
//*************************************************************************
COMMAND_PROTOTYPE(SingleStep)
{
    ULONG ulLineNumber;
    LPSTR pSrcStart,pSrcEnd,pFilename;

    ENTER_FUNC();

    if(FindSourceLineForAddress(GetLinearAddress(pFrame->cs,pFrame->eip),&ulLineNumber,&pSrcStart,&pSrcEnd,&pFilename))
    {
        DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "stepping into source\n");
        StepInto(pFrame,NULL);
    }
    else
    {
		DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "step\n");