parse.c

Linux下的类似softice的调试工具

	    // modify trace flag 
	    pFrame->eflags |= TF_FLAG; // set trace flag (TF)

		ulSingleStepCondition |= SINGLE_STEP_CONDITION_SINGLE_STEP;

		// leave PICE
	    pArgs->bNotifyToExit=TRUE;
    }

    LEAVE_FUNC();

    return TRUE;
}


//*************************************************************************
// StepOver()
//
// step over calls
//*************************************************************************
COMMAND_PROTOTYPE(StepOver)
{
	char tempDisasm[256];
	ULONG dwBreakAddress;
    ULONG ulLineNumber;
    LPSTR pSrcStart,pSrcEnd,pFilename;

    ENTER_FUNC();

    // only no arguments supplied
    // when we have source and current disassembly mod is SOURCE
    // we have to analyse the code block for the source line
    if(FindSourceLineForAddress(GetLinearAddress(pFrame->cs,pFrame->eip),&ulLineNumber,&pSrcStart,&pSrcEnd,&pFilename))
    {
        DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "we have source here!\n");
        DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "line #%u in file = %s!\n",ulLineNumber,pFilename);

        g_ulLineNumberStart = ulLineNumber;
        bStepThroughSource = TRUE;

        // deinstall the INT3 in kernel's printk()
        DeInstallPrintkHook();

        goto proceed_as_normal;
    }
    else
    {
        DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "no source here!\n");

proceed_as_normal:
		// if there is some form of call instruction at EIP we need to find
		// the return address
		if(IsCallInstrAtEIP(pFrame))
		{
			// get address of next instruction
			dwBreakAddress=GetLinearAddress(pFrame->cs,pFrame->eip);

			Disasm(&dwBreakAddress,tempDisasm);

			DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "address of break = %.4X:%.8X\n",pFrame->cs,dwBreakAddress);

			dwBreakAddress=GetLinearAddress(pFrame->cs,dwBreakAddress);

			DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "linear address of break = %.8X\n",dwBreakAddress);

			DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "setting DR0=%.8X\n",dwBreakAddress);

            SetHardwareBreakPoint(dwBreakAddress,0);

			pFrame->eflags &= ~TF_FLAG; // clear TF

			pArgs->bNotifyToExit = TRUE;
		}
		else
		{
			if(IsPopfdInstrAtEIP(pFrame))
			{
				// set trace flag in value on stack
				*(PULONG)pFrame->esp |= TF_FLAG;
			}
	        // modify trace flag 
	        pFrame->eflags |= TF_FLAG; // set trace flag (TF)

			ulSingleStepCondition |= SINGLE_STEP_CONDITION_SINGLE_STEP;

	        pArgs->bNotifyToExit=TRUE;
		}
    }

    bStepInto = FALSE;

    LEAVE_FUNC();

    return TRUE;
}

//*************************************************************************
// StepInto()
//
// step into calls
//*************************************************************************
COMMAND_PROTOTYPE(StepInto)
{
    ULONG ulLineNumber;
    LPSTR pSrcStart,pSrcEnd,pFilename;

    ENTER_FUNC();

    // only no arguments supplied
    // when we have source and current disassembly mod is SOURCE
    // we have to analyse the code block for the source line
    if(FindSourceLineForAddress(GetLinearAddress(pFrame->cs,pFrame->eip),&ulLineNumber,&pSrcStart,&pSrcEnd,&pFilename))
    {
        DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "we have source here!\n");
        DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "line #%u in file = %s!\n",ulLineNumber,pFilename);

        g_ulLineNumberStart = ulLineNumber;
        bStepThroughSource = TRUE;

        // deinstall the INT3 in kernel's printk()
        DeInstallPrintkHook();

        goto proceed_as_normal_into;
    }
    else
    {
        DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "no source here!\n");

proceed_as_normal_into:

	    // modify trace flag 
	    pFrame->eflags |= TF_FLAG; // set trace flag (TF)

		ulSingleStepCondition |= SINGLE_STEP_CONDITION_SINGLE_STEP;

	    pArgs->bNotifyToExit=TRUE;
    }
    
    bStepInto = TRUE;

    LEAVE_FUNC();

    return TRUE;
}

//*************************************************************************
// SetBreakpoint()
//
//*************************************************************************
COMMAND_PROTOTYPE(SetBreakpoint) 
{ 
    ULONG addr,addrorg; 
    USHORT segment; 
 
	if(pArgs->Count<=2) 
	{ 
        if(pArgs->bNotTranslated[0]==FALSE)
        {
		    if(gCurrentSelector) 
		    { 
			    addr =pArgs->Value[0]; 
			    addrorg =gCurrentOffset; 
			    segment =gCurrentSelector; 
		    } 
		    else 
		    { 
			    addrorg =addr =pArgs->Value[0]; 
			    segment = pFrame->cs; 
		    } 

            if(InstallSWBreakpoint(GetLinearAddress(segment,addr),FALSE,NULL) )
            {
		        PICE_sprintf(tempCmd,"BP #%u set to %.4X:%.8X\n",0,segment,addr); 
            }
            else
            {
		        PICE_sprintf(tempCmd,"BP #%u NOT set (either page not valid OR already used)\n",0); 
            }
	        Print(OUTPUT_WINDOW,tempCmd); 
        }
        else
        {
            if(InstallVirtualSWBreakpoint((LPSTR)pArgs->Value[0],(LPSTR)pArgs->Value[1]) )
            {
		        PICE_sprintf(tempCmd,"BP #%u virtually set to %s!%s\n",0,(LPSTR)pArgs->Value[0],(LPSTR)pArgs->Value[1]); 
            }
            else
            {
		        PICE_sprintf(tempCmd,"BP #%u NOT set (maybe no symbols loaded)\n",0); 
            }
	        Print(OUTPUT_WINDOW,tempCmd); 
        }
		
		RepaintSource(pFrame);

	} 
	return TRUE; 
} 
 
//*************************************************************************
// ListBreakpoints()
//
//*************************************************************************
COMMAND_PROTOTYPE(ListBreakpoints) 
{ 
	ULONG i; 
 
    ListSWBreakpoints();

	for(i=0;i<4;i++) 
	{ 
		if(Bp[i].Used) 
		{ 
			PICE_sprintf(tempCmd,"(%u) %s %.4X:%.8X(linear %.8X)\n",i,Bp[i].Active?"*":" ",Bp[i].Segment,Bp[i].Offset,Bp[i].LinearAddress); 
			Print(OUTPUT_WINDOW,tempCmd); 
		} 
	} 
	return TRUE; 
} 

//*************************************************************************
// ClearBreakpoints()
//
//*************************************************************************
COMMAND_PROTOTYPE(ClearBreakpoints) 
{ 
	if(pArgs->Count == 1)  
	{ 
		if(pArgs->Value[0] == -1)
		{
			RemoveAllSWBreakpoints(FALSE);
		}
		else if(pArgs->Value[0]<64) 
		{ 
			if(!RemoveSWBreakpointByNumber(pArgs->Value[0]))
			{
				PICE_sprintf(tempCmd,"no valid breakpoint!\n"); 
				Print(OUTPUT_WINDOW,tempCmd); 
			}
		} 
		else
		{
			PICE_sprintf(tempCmd,"no breakpoint specified!\n"); 
			Print(OUTPUT_WINDOW,tempCmd); 
		}
		RepaintSource(pFrame);
	} 
	else
	{
		PICE_sprintf(tempCmd,"need argument!\n"); 
		Print(OUTPUT_WINDOW,tempCmd); 
	}
	return TRUE; 
} 

//*************************************************************************
// LeaveIce()
//
//*************************************************************************
COMMAND_PROTOTYPE(LeaveIce)
{
	 ENTER_FUNC();
	 SetHardwareBreakPoints(); 

	 pFrame->eflags &= ~TF_FLAG; // clear TF
	 
	 pArgs->bNotifyToExit=TRUE;

	 LEAVE_FUNC();
	return TRUE;
}

//*************************************************************************
// ShowGdt()
//
//*************************************************************************
COMMAND_PROTOTYPE(ShowGdt)
{
	ULONG gdtr[2];
	USHORT i;
	PGDT pGdt;
	static ULONG addr=0;
	LPSTR pVerbose;

	ENTER_FUNC();
	// get GDT register
	__asm__ ("sgdt %0\n"
	 	:"=m" (gdtr));
	
    // info out
	PICE_sprintf(tempCmd,"Address=%.8X Limit=%.4X\n",(gdtr[1]<<16)|(gdtr[0]>>16),gdtr[0]&0xFFFF);
	Print(OUTPUT_WINDOW,tempCmd);
    WaitForKey();

	// make pointer to GDT
	pGdt=(PGDT)(((ULONG)(gdtr[1]<<16))|((ULONG)(gdtr[0]>>16)));
	if(pArgs->Count==1)
	{
	ULONG limit=((pGdt[addr].Limit_19_16<<16)|pGdt[addr].Limit_15_0);

		addr=pArgs->Value[0];
		addr&=(~0x7);
		if(pGdt[addr>>3].Gran)limit=(limit*4096)|0xfff;

		if(!pGdt[addr>>3].DescType)
			pVerbose = SystemSegmentTypes[pGdt[addr>>3].SegType];
		else
			pVerbose = NonSystemSegmentTypes[pGdt[addr>>3].SegType];

		PICE_sprintf(tempCmd,"%.4X %.8X %.8X %s %u %s\n",
						addr,
						(pGdt[addr>>3].Base_31_24<<24)|(pGdt[addr>>3].Base_23_16<<16)|(pGdt[addr>>3].Base_15_0),
						limit,
						pGdt[addr>>3].Present?" P":"NP",
						pGdt[addr>>3].Dpl,
						pVerbose);
		Print(OUTPUT_WINDOW,tempCmd);
	}
	else if(pArgs->Count==0)
	{
		for(i=0;i<((gdtr[0]&0xFFFF)>>3);i++)
		{
			ULONG limit=((pGdt[i].Limit_19_16<<16)|pGdt[i].Limit_15_0);

			if(!pGdt[i].DescType)
				pVerbose = SystemSegmentTypes[pGdt[i].SegType];
			else
				pVerbose = NonSystemSegmentTypes[pGdt[i].SegType];

			if(pGdt[i].Gran)limit=(limit*4096)|0xfff;

			PICE_sprintf(tempCmd,"%.4X %.8X %.8X %s %u %s\n",
							i<<3,
							(pGdt[i].Base_31_24<<24)|(pGdt[i].Base_23_16<<16)|(pGdt[i].Base_15_0),
							limit,
							pGdt[i].Present?" P":"NP",
							pGdt[i].Dpl,
							pVerbose);
			Print(OUTPUT_WINDOW,tempCmd);
			if(WaitForKey()==FALSE)break;
		}
	}
	LEAVE_FUNC();
	return TRUE;
}

//*************************************************************************
// OutputIdtEntry()
//
//*************************************************************************
void OutputIdtEntry(PIDT pIdt,ULONG i)
{
    USHORT seg;
    ULONG offset;
    LPSTR pSym;

	ENTER_FUNC();
    seg = (USHORT)pIdt[i].Selector;
    offset = (pIdt[i].Offset_31_16<<16)|(pIdt[i].Offset_15_0);

    switch(pIdt[i].DescType)
	{
		// task gate
		case 0x5:
			PICE_sprintf(tempCmd,"(%0.4X) %0.4X:%0.8X %u [task]\n",i,
															seg,
															GetLinearAddress((USHORT)seg,0),
															pIdt[i].Dpl);
			break;
		// interrupt gate
		case 0x6:
		case 0xE:
#ifdef ACTIVATE_SYMBOL_LOOKUP
			if(FindSymbolByAddress(&pSym,GetLinearAddress((USHORT)seg,offset)))
				PICE_sprintf(tempCmd,"(%0.4X) %0.4X:%0.8X %u [int] (%s)\n",i,
																	seg,
																	offset,
																	pIdt[i].Dpl,
																	pSym);
			else
#endif // ACTIVATE_SYMBOL_LOOKUP
				PICE_sprintf(tempCmd,"(%0.4X) %0.4X:%0.8X %u [int]\n",i,
																	seg,
																	offset,
																	pIdt[i].Dpl);
			break;
		// trap gate
		case 0x7:
		case 0xF:
#ifdef ACTIVATE_SYMBOL_LOOKUP
			if(FindSymbolByAddress(&pSym,GetLinearAddress((USHORT)seg,offset)))
				PICE_sprintf(tempCmd,"(%0.4X) %0.4X:%0.8X %u [trap] (%s)\n",i,
																	seg,
																	offset,
																	pIdt[i].Dpl,
																	pSym);
			else
#endif // ACTIVATE_SYMBOL_LOOKUP
				PICE_sprintf(tempCmd,"(%0.4X) %0.4X:%0.8X %u [trap]\n",i,
																	seg,
																	offset,
																	pIdt[i].Dpl);
			break;
		default:
			PICE_sprintf(tempCmd,"(%0.4X) INVALID\n",i);
			break;
	}
	Print(OUTPUT_WINDOW,tempCmd);
	LEAVE_FUNC();
}

//*************************************************************************
// ShowIdt()
//
//*************************************************************************
COMMAND_PROTOTYPE(ShowIdt) 
{ 
	ULONG idtr[2]; 
	USHORT i; 
	PIDT pIdt; 
	ULONG addr=0;
 
	ENTER_FUNC();

    // get GDT register 
	__asm__ __volatile__ ("sidt %0\n":"=m" (idtr));
	__asm__ __volatile__ ("cpuid" : : : "ax", "bx", "cx", "dx");

	// info out 
	PICE_sprintf(tempCmd,"Address=%.8X Limit=%.4X\n",(idtr[1]<<16)|(idtr[0]>>16),idtr[0]&0xFFFF); 
	Print(OUTPUT_WINDOW,tempCmd); 
    WaitForKey();
	// make pointer to GDT 
	pIdt=(PIDT)(((ULONG)(idtr[1]<<16))|((ULONG)(idtr[0]>>16))); 
	if(pArgs->Count==1) 
	{ 
		addr=pArgs->Value[0]; 
		addr&=(~0x7); 
        OutputIdtEntry(pIdt,addr);
 
	} 
	else if(pArgs->Count==0) 
	{ 
		for(i=0;i<((idtr[0]&0xFFFF)>>3);i++) 
		{ 
            OutputIdtEntry(pIdt,i);
			if(WaitForKey()==FALSE)break; 
		} 
	} 
	LEAVE_FUNC();
	return TRUE; 
} 

//*************************************************************************
// ShowHelp()
//
//*************************************************************************
COMMAND_PROTOTYPE(ShowHelp)
{
	ULONG i,j;

	ENTER_FUNC();

    SetForegroundColor(COLOR_TEXT);
	SetBackgroundColor(COLOR_CAPTION);
    PutStatusText("COMMAND KEYWORD        DESCRIPTION");
	ResetColor();
    for(j=0;j<COMMAND_GROUP_LAST;j++)
    {
		PICE_sprintf(tempCmd,"= %-20s =====================================\n",CommandGroups[j]);
		Print(OUTPUT_WINDOW,tempCmd);
        WaitForKey();

	    for(i=0;CmdTable[i].Cmd!=NULL;i++)
	    {
            if(CmdTable[i].CommandGroup == j)
            {