This graph shows which files directly or indirectly include this file:

Macros
#define	REASON_INT3 (0)

#define	REASON_SINGLESTEP (1)

#define	REASON_CTRLF (2)

#define	REASON_PAGEFAULT (3)

#define	REASON_GP_FAULT (4)

#define	REASON_HARDWARE_BP (5)

#define	REASON_DOUBLE_FAULT (6)

#define	REASON_MODULE_LOAD (7)

#define	REASON_INTERNAL_ERROR (8)

#define	I8042_PHYSICAL_BASE 0x60

#define	I8042_DATA_REGISTER_OFFSET 0

#define	I8042_COMMAND_REGISTER_OFFSET 4

#define	I8042_STATUS_REGISTER_OFFSET 4

#define	KEYBOARD_IRQ 1

Functions
void	InstallGlobalKeyboardHook (void)

void	DeInstallGlobalKeyboardHook (void)

void	RealIsr (ULONG dwReasonForBreak)

void	NewInt31Handler (void)

void	ShowStatusLine (void)

Variables
volatile BOOLEAN	bNotifyToExit

volatile BOOLEAN	bSingleStep

volatile UCHAR	ucKeyPressedWhileIdle

volatile BOOLEAN	bInDebuggerShell

ULONG	CurrentEIP

ULONG	CurrentEFL

ULONG	CurrentEAX

ULONG	CurrentEBX

ULONG	CurrentECX

ULONG	CurrentEDX

ULONG	CurrentESP

ULONG	CurrentEBP

ULONG	CurrentESI

ULONG	CurrentEDI

ULONG	CurrentDR0

ULONG	CurrentDR1

ULONG	CurrentDR2

ULONG	CurrentDR3

ULONG	CurrentDR6

ULONG	CurrentDR7

ULONG	CurrentCR0

ULONG	CurrentCR2

ULONG	CurrentCR3

USHORT	CurrentCS

USHORT	CurrentDS

USHORT	CurrentES

USHORT	CurrentFS

USHORT	CurrentGS

USHORT	CurrentSS

volatile BOOLEAN	bControl

volatile BOOLEAN	bShift

volatile BOOLEAN	bAlt

ULONG	OldEIP

ULONG	OldEFL

ULONG	OldEAX

ULONG	OldEBX

ULONG	OldECX

ULONG	OldEDX

ULONG	OldESP

ULONG	OldEBP

ULONG	OldESI

ULONG	OldEDI

USHORT	OldCS

USHORT	OldDS

USHORT	OldES

USHORT	OldFS

USHORT	OldGS

USHORT	OldSS

ULONG	CurrentProcess

USHORT	OldSelector

ULONG	OldOffset

ULONG	ulRealStackPtr

ULONG	g_ulLineNumberStart

BOOLEAN	bStepThroughSource

BOOLEAN	bStepInto

volatile BOOLEAN	bEnterNow

Macro Definition Documentation

◆ I8042_COMMAND_REGISTER_OFFSET

#define I8042_COMMAND_REGISTER_OFFSET 4

Definition at line 86 of file shell.h.

◆ I8042_DATA_REGISTER_OFFSET

#define I8042_DATA_REGISTER_OFFSET 0

Definition at line 85 of file shell.h.

◆ I8042_PHYSICAL_BASE

#define I8042_PHYSICAL_BASE 0x60

Definition at line 84 of file shell.h.

◆ I8042_STATUS_REGISTER_OFFSET

#define I8042_STATUS_REGISTER_OFFSET 4

Definition at line 87 of file shell.h.

◆ KEYBOARD_IRQ

#define KEYBOARD_IRQ 1

Definition at line 91 of file shell.h.

◆ REASON_CTRLF

#define REASON_CTRLF (2)

Definition at line 73 of file shell.h.

◆ REASON_DOUBLE_FAULT

#define REASON_DOUBLE_FAULT (6)

Definition at line 77 of file shell.h.

◆ REASON_GP_FAULT

#define REASON_GP_FAULT (4)

Definition at line 75 of file shell.h.

◆ REASON_HARDWARE_BP

#define REASON_HARDWARE_BP (5)

Definition at line 76 of file shell.h.

◆ REASON_INT3

#define REASON_INT3 (0)

Definition at line 71 of file shell.h.

◆ REASON_INTERNAL_ERROR

#define REASON_INTERNAL_ERROR (8)

Definition at line 79 of file shell.h.

◆ REASON_MODULE_LOAD

#define REASON_MODULE_LOAD (7)

Definition at line 78 of file shell.h.

◆ REASON_PAGEFAULT

#define REASON_PAGEFAULT (3)

Definition at line 74 of file shell.h.

◆ REASON_SINGLESTEP

#define REASON_SINGLESTEP (1)

Definition at line 72 of file shell.h.

Function Documentation

◆ DeInstallGlobalKeyboardHook()

void DeInstallGlobalKeyboardHook ( void )

Definition at line 1677 of file shell.c.

 {
     ENTER_FUNC();
 
     MaskIrqs();
     if(OldGlobalInt31Handler)
     {
         SetGlobalInt(KeyboardIRQL,(ULONG)OldGlobalInt31Handler);
         OldGlobalInt31Handler=0;
     }
     UnmaskIrqs();
 
     LEAVE_FUNC();
 }

Referenced by CleanUpPICE().

◆ InstallGlobalKeyboardHook()

void InstallGlobalKeyboardHook ( void )

Definition at line 1657 of file shell.c.

 {
     ULONG LocalNewGlobalInt31Handler;
 
     ENTER_FUNC();
 
     MaskIrqs();
     if(!OldGlobalInt31Handler)
     {
         __asm__("mov $NewGlobalInt31Handler,%0"
             :"=r" (LocalNewGlobalInt31Handler)
             :
             :"eax");
         OldGlobalInt31Handler=SetGlobalInt(KeyboardIRQL,(ULONG)LocalNewGlobalInt31Handler);
     }
     UnmaskIrqs();
 
     LEAVE_FUNC();
 }

Referenced by InitPICE().

◆ NewInt31Handler()

void NewInt31Handler ( void )

◆ RealIsr()

void RealIsr ( ULONG dwReasonForBreak )

Definition at line 1016 of file shell.c.

 {
   BOOLEAN ReinstallPermanentBp = FALSE;
 
     DPRINT((0,"reason: %u#################################################################\n", dwReasonForBreak));
     ENTER_FUNC();
 
     // in handler
     bInDebuggerShell = TRUE;
 
     bStepping = FALSE;
 
     // don't assume we must call original handlers yet
     dwCallOldInt1Handler = dwCallOldInt3Handler = dwCallOldIntEHandler = dwCallOldGPFaultHandler = 0;
     bSkipMainLoop = FALSE;
     bEnterNow = FALSE;
 
     // reset trace flag (TF) on the stack
     CurrentEFL&=(~0x100);
 
     InstallPrintkHook();
 
     // control is not depressed
     bControl=FALSE;
 
     bIrqStateAtBreak = ((CurrentEFL&(1<<9))!=0);
 
     DPRINT((0,"\nbInDebuggerShell %x, dwReasonForBreak: %x, bIrqStateAtBreak: %d\n", bInDebuggerShell, dwReasonForBreak, bIrqStateAtBreak));
     DPRINT((0,"CurrentEIP: %x, CurrentESP: %x\n", CurrentEIP, CurrentESP));
 
     // came in because TF flag was set
     if(dwReasonForBreak == REASON_SINGLESTEP)
     {
         ULONG ulAddress,ulAddressCurrent;
 
         DPRINT((0,"REASON_SINGLESTEP: bSingleStep: %u\n", bSingleStep));
 
         if(!bSingleStep)
         {
             dwCallOldInt1Handler = 1;
             DPRINT((0,"no single step requested: %u!\n", dwCallOldInt1Handler));
             goto common_return_point;
         }
 
         ulAddress = GetLinearAddress(OldCS,OldEIP);
         ulAddressCurrent = GetLinearAddress(CurrentCS,CurrentEIP);
 
         // if we came in because we needed to skip past a permanent
         // INT3 hook, we need to put the INT3 back in place and
         // simply restart the system.
         if(NeedToReInstallSWBreakpoints(ulAddress,TRUE) )
         {
             DPRINT((0,"reinstalling INT3 @ %.4X:%.8X\n",OldCS,OldEIP));
 
             ReInstallSWBreakpoint(ulAddress);
 
             // previous command was go i.e. we did not single-step over a location
             // where a permanent breakpoint was installed (Printk() etc.) we simply restart
             // else we must stop the system.
             if(bPreviousCommandWasGo)
             {
                 bPreviousCommandWasGo = FALSE;
                 bInDebuggerShell = FALSE;
 
                 if(bStepThroughSource)
                 {
                     // set TF flag
                     CurrentEFL |= 0x100;
                 }
 
                 LEAVE_FUNC();
                 DPRINT((0,"singlestep-----------------------------------------------------------------\n"));
                 return;
             }
             bPreviousCommandWasGo = FALSE;
         }
 
         if(IsSwBpAtAddressInstalled(ulAddressCurrent))
             DeInstallSWBreakpoint(ulAddressCurrent);
 
         // we came here while stepping through source code block
         if(bStepThroughSource)
         {
             ULONG ulLineNumber;
             LPSTR pSrc,pFileName;
 
             DPRINT((0,"RealIsr(): stepping through source!\n"));
 
             // look up the corresponding source line
             // if there isn't any or the source line number has changed
             // we break back into the debugger
             if(bShowSrc)
                 pSrc = FindSourceLineForAddress(ulAddressCurrent,&ulLineNumber,NULL,NULL,&pFileName);
             else pSrc = NULL;
 
             DPRINT((0,"RealIsr(): line #%u pSrc=%x (old line #%u)\n",ulLineNumber,(ULONG)pSrc,g_ulLineNumberStart));
 
             // if we have found a source line there
             if(pSrc && ulLineNumber==g_ulLineNumberStart)
             {
                 DPRINT((0,"RealIsr(): stepping through line #%u in file = %s!\n",ulLineNumber,pFileName));
 
                 if(bStepInto)
                     StepInto(NULL);
                 else
                     StepOver(NULL);
 
                 bInDebuggerShell = FALSE;
                 LEAVE_FUNC();
                 DPRINT((0,"singstep-----------------------------------------------------------------\n"));
                 return;
             }
             bStepThroughSource = FALSE;
             bNotifyToExit = FALSE;
             bSkipMainLoop = FALSE;
         }
     }
     // came in because hardware register triggered a breakpoint
     else if(dwReasonForBreak == REASON_HARDWARE_BP)
     {
         ULONG ulReason;
 
         DPRINT((0,"REASON_HARDWARE_BP\n"));
 
         // disable HW breakpoints
         __asm__("\n\t \
             movl %%dr6,%%eax\n\t \
             movl %%eax,%0\n\t \
             xorl %%eax,%%eax\n\t \
             movl %%eax,%%dr6\n\t \
             movl %%eax,%%dr7"
             :"=m" (ulReason)
             :
             :"eax"
             );
 
         DPRINT((0,"REASON_HARDWARE_BP: %x\n",(ulReason&0xF)));
 
         // HW breakpoint DR1 (skip: only used in init_module detection)
         if(ulReason&0x2)
         {
             CurrentEFL |=(1<<16); // set resume flag
 
             bSkipMainLoop = TRUE;
 
             TryToInstallVirtualSWBreakpoints();
         }
         // HW breakpoint DR0
         else if(ulReason&0x1)
         {
             ULONG ulAddressCurrent;
 
             ulAddressCurrent = GetLinearAddress(CurrentCS,CurrentEIP);
 
             // we came here while stepping through source code block
             if(bStepThroughSource)
             {
                 ULONG ulLineNumber;
                 LPSTR pSrc,pFileName;
 
                 DPRINT((0,"RealIsr(): stepping through source! [2]\n"));
 
                 // look up the corresponding source line
                 // if there isn't any or the source line number has changed
                 // we break back into the debugger
                 if(bShowSrc)
                     pSrc = FindSourceLineForAddress(ulAddressCurrent,&ulLineNumber,NULL,NULL,&pFileName);
                 else
                     pSrc = NULL;
 
                 DPRINT((0,"RealIsr(): line #%u pSrc=%x (old line #%u) [2]\n",ulLineNumber,(ULONG)pSrc,g_ulLineNumberStart));
 
                 // if we have found a source line there
                 if(pSrc && ulLineNumber==g_ulLineNumberStart)
                 {
                     DPRINT((0,"RealIsr(): stepping through line #%u in file = %s! [2]\n",ulLineNumber,pFileName));
 
                     if(bStepInto)
                         StepInto(NULL);
                     else
                         StepOver(NULL);
 
                     bInDebuggerShell = FALSE;
                     LEAVE_FUNC();
                     DPRINT((0,"rrr-----------------------------------------------------------------\n"));
                     return;
                 }
                 bNotifyToExit = FALSE;
                 bSkipMainLoop = FALSE;
                 bStepThroughSource = FALSE;
             }
         }
     }
     else if(dwReasonForBreak==REASON_INT3)
     {
         ULONG ulAddress;
 
         DPRINT((0,"REASON_INT3\n"));
 
         // must subtract one cause INT3s are generated after instructions execution
         CurrentEIP--;
 
         // make a flat address
         ulAddress = GetLinearAddress(CurrentCS,CurrentEIP);
 
         DPRINT((0,"INT3 @ %.8X\n",ulAddress));
 
         // if there's a breakpoint installed at current EIP remove it
         if(DeInstallSWBreakpoint(ulAddress) )
         {
             PSW_BP p;
 
             DPRINT((0,"INT3 @ %.8X removed\n",ulAddress));
 
             // if it's permanent (must be Printk() ) skip the DebuggerShell() and
             // do a callback
             if( (p = IsPermanentSWBreakpoint(ulAddress)) )
             {
                 DPRINT((0,"permanent breakpoint\n"));
 
                 ReinstallPermanentBp = TRUE;
 
                 OldCS = CurrentCS;
                 OldEIP = CurrentEIP;
 
                 bSkipMainLoop = TRUE;
                 DPRINT((0,"callback at %x\n",p->Callback));
                 if(p->Callback)
                     p->Callback();
             }
             else
             {
                 LPSTR pFind;
                 if(ScanExportsByAddress(&pFind,GetLinearAddress(CurrentCS,CurrentEIP)))
                 {
                     PICE_sprintf(tempShell,"pICE: SW Breakpoint at %s (%.4X:%.8X)\n",pFind,CurrentCS,CurrentEIP);
                 }
                 else
                 {
                     PICE_sprintf(tempShell,"pICE: SW Breakpoint at %.4X:%.8X\n",CurrentCS,CurrentEIP);
                 }
                 Print(OUTPUT_WINDOW,tempShell);
             }
             CurrentEFL &= ~(1<<16); // clear resume flag
         }
         else
         {
             LPSTR pFind;
             PEPROCESS my_current = IoGetCurrentProcess();
 
             DPRINT((0,"can't deinstall, somebody else's breakpoint\n"));
 
 
             // if no other debugger is running on this process and the address is
             // above TASK_SIZE we assume this to be a hard embedded INT3
 /*
 #if REAL_LINUX_VERSION_CODE < 0x020400
             if(ulAddress<TASK_SIZE && !(my_current->flags & PF_PTRACED) )
 #else
             if(ulAddress<TASK_SIZE && !(my_current->ptrace & PT_PTRACED) )
 #endif
 */
             if( ulAddress )
             {
                 if(ScanExportsByAddress(&pFind,GetLinearAddress(CurrentCS,CurrentEIP)))
                 {
                     PICE_sprintf(tempShell,"pICE: break due to embedded INT 3 at %s (%.4X:%.8X)\n",pFind,CurrentCS,CurrentEIP);
                 }
                 else
                 {
                     PICE_sprintf(tempShell,"pICE: break due to embedded INT 3 at user-mode address %.4X:%.8X\n",CurrentCS,CurrentEIP);
                 }
                 Print(OUTPUT_WINDOW,tempShell);
                 CurrentEFL &= ~(1<<16); // clear resume flag
             }
             // well someone is already debugging this, we must pass the INT3 on to old handler
             // but only when it's a user-mode address
 /*
             else
             {
                 if(ulAddress<TASK_SIZE || !bInt3Here)
                 {
                     DPRINT((0,"SW Breakpoint but debugged by other process at %.4X:%.8X\n",CurrentCS,CurrentEIP));
                     // call the old handler on return from RealIsr()
                     dwCallOldInt3Handler = 1;
                     // and skip DebuggerShell()
                     bSkipMainLoop = TRUE;
                 }
                 else
                 {
                     if(ScanExportsByAddress(&pFind,GetLinearAddress(CurrentCS,CurrentEIP)))
                     {
                         PICE_sprintf(tempShell,"pICE: break due to embedded INT 3 at (%s) %.4X:%.8X\n",
                                      pFind,CurrentCS,CurrentEIP);
                     }
                     else
                     {
                         PICE_sprintf(tempShell,"pICE: break due to embedded INT 3 at kernel-mode address %.4X:%.8X\n",
                                      CurrentCS,CurrentEIP);
                     }
                     Print(OUTPUT_WINDOW,tempShell);
                     CurrentEFL &= ~(1<<16); // clear resume flag
                 }
             }
 */
             // skip INT3
             CurrentEIP++;
         }
     }
     else if(dwReasonForBreak == REASON_PAGEFAULT)
     {
         LPSTR pSymbolName;
 
         DPRINT((0,"REASON_PAGEFAULT\n"));
 
         if( ScanExportsByAddress(&pSymbolName,GetLinearAddress(CurrentCS,CurrentEIP)) )
         {
             PICE_sprintf(tempShell,"pICE: Breakpoint due to page fault at %.4X:%.8X (%s)\n",CurrentCS,CurrentEIP,pSymbolName);
         }
         else
         {
             PICE_sprintf(tempShell,"pICE: Breakpoint due to page fault at %.4X:%.8X\n",CurrentCS,CurrentEIP);
         }
         Print(OUTPUT_WINDOW,tempShell);
         PICE_sprintf(tempShell,"pICE: memory referenced %x\n",CurrentCR2);
         Print(OUTPUT_WINDOW,tempShell);
         dwCallOldIntEHandler = 1;
     }
     else if(dwReasonForBreak == REASON_GP_FAULT)
     {
         LPSTR pSymbolName;
 
         DPRINT((0,"REASON_GPFAULT\n"));
 
         if( ScanExportsByAddress(&pSymbolName,GetLinearAddress(CurrentCS,CurrentEIP)) )
         {
             PICE_sprintf(tempShell,"pICE: Breakpoint due to general protection fault at %.4X:%.8X (%s)\n",CurrentCS,CurrentEIP,pSymbolName);
         }
         else
         {
             PICE_sprintf(tempShell,"pICE: Breakpoint due to general protection fault at %.4X:%.8X\n",CurrentCS,CurrentEIP);
         }
         Print(OUTPUT_WINDOW,tempShell);
         dwCallOldGPFaultHandler = 1;
     }
     else if(dwReasonForBreak == REASON_CTRLF)
     {
         DPRINT((0,"REASON_CTRLF\n"));
         // nothing to do
     }
     else if(dwReasonForBreak == REASON_DOUBLE_FAULT)
     {
         DPRINT((0,"REASON_DOUBLE_FAULT\n"));
 
         PICE_sprintf(tempShell,"pICE: Breakpoint due to double fault at %.4X:%.8X\n",CurrentCS,CurrentEIP);
         Print(OUTPUT_WINDOW,tempShell);
     }
     else if(dwReasonForBreak == REASON_INTERNAL_ERROR)
     {
         DPRINT((0,"REASON_INTERNAL_ERROR\n"));
 
         Print(OUTPUT_WINDOW,"pICE: Please report this error to klauspg@diamondmm.com!\n");
 //        Print(OUTPUT_WINDOW,"pICE: !!! SYSTEM HALTED !!!\n");
 //        __asm__ __volatile__("hlt");
     }
     else
     {
         DPRINT((0,"REASON_UNKNOWN\n"));
 
         PICE_sprintf(tempShell,"pICE: Breakpoint due to unknown reason at %.4X:%.8X (code %x)\n",CurrentCS,CurrentEIP,dwReasonForBreak);
         Print(OUTPUT_WINDOW,tempShell);
         Print(OUTPUT_WINDOW,"pICE: Please report this error to klauspg@diamondmm.com!\n");
         Print(OUTPUT_WINDOW,"pICE: !!! SYSTEM HALTED !!!\n");
         __asm__ __volatile__("hlt");
     }
 
     // we don't single-step yet
     DPRINT((0,"RealIsr(): not stepping yet\n"));
     bSingleStep=FALSE;
 
     // process commands
     if(bSkipMainLoop == FALSE)
     {
         DPRINT((0,"RealIsr(): saving registers\n"));
         // save the extended regs
         __asm__ __volatile__
         ("\n\t \
             pushl %eax\n\t \
             movw %es,%ax\n\t \
             movw %ax,_CurrentES\n\t \
             //movw %fs,%ax\n\t \
             //movw %ax,_CurrentFS\n\t \
             movw %gs,%ax\n\t \
             movw %ax,_CurrentGS\n\t \
             movl %dr0,%eax\n\t \
             movl %eax,_CurrentDR0\n\t \
             movl %dr1,%eax\n\t \
             movl %eax,_CurrentDR1\n\t \
             movl %dr2,%eax\n\t \
             movl %eax,_CurrentDR2\n\t \
             movl %dr3,%eax\n\t \
             movl %eax,_CurrentDR3\n\t \
             movl %dr6,%eax\n\t \
             movl %eax,_CurrentDR6\n\t \
             movl %dr7,%eax\n\t \
             movl %eax,_CurrentDR7\n\t \
             movl %cr0,%eax\n\t \
             movl %eax,_CurrentCR0\n\t \
             movl %cr2,%eax\n\t \
             movl %eax,_CurrentCR2\n\t \
             movl %cr3,%eax\n\t \
             movl %eax,_CurrentCR3\n\t \
             popl %eax"
         );
 
         CurrentFS = OLD_PCR;
         DPRINT((0,"RealIsr(): adding colon to output()\n"));
         Print(OUTPUT_WINDOW,":");
 
         DPRINT((0,"RealIsr(): calling DebuggerShell()\n"));
         DebuggerShell();
     }
 
     // if there was a SW breakpoint at CS:EIP
     if(NeedToReInstallSWBreakpoints(GetLinearAddress(CurrentCS,CurrentEIP),TRUE) || ReinstallPermanentBp)
     {
         DPRINT((0,"need to reinstall INT3\n"));
         // remember how we restarted last time
         bPreviousCommandWasGo = !bSingleStep;
         // do a single step to reinstall breakpoint
         // modify trace flag
         CurrentEFL|=0x100; // set trace flag (TF)
 
         bSingleStep=TRUE;
         bNotifyToExit=TRUE;
     }
 
 common_return_point:
 
     // reset the global flags
     bNotifyToExit = FALSE;
     bSkipMainLoop = FALSE;
 
     // not in handler anymore
     bInDebuggerShell = FALSE;
 
     LEAVE_FUNC();
     DPRINT((0,"common return-----------------------------------------------------------------\n"));
 }

Referenced by InitPICE().

◆ ShowStatusLine()

void ShowStatusLine ( void )

Definition at line 216 of file shell.c.

 {
     PEPROCESS pCurrentProcess = IoGetCurrentProcess();
     LPSTR pProcessName;
 
     ENTER_FUNC();
 
     if(IsAddressValid((ULONG)pCurrentProcess))
     {
         SetForegroundColor(COLOR_TEXT);
         SetBackgroundColor(COLOR_CAPTION);
 
         ClrLine(wWindow[OUTPUT_WINDOW].y-1);
 
         pProcessName = pCurrentProcess->ImageFileName;
         if(IsAddressValid((ULONG)pProcessName) )
         {
             PICE_sprintf(tempShell,
                     " PROCESS(%.8X \"%s\") ",
                     (ULONG)pCurrentProcess,pProcessName);
         }
         else
         {
             PICE_sprintf(tempShell,
                     " PROCESS(%.8X) ",
                     (ULONG)pCurrentProcess);
         }
         PutChar(tempShell,1,wWindow[OUTPUT_WINDOW].y-1);
 
         ResetColor();
     }
 
     LEAVE_FUNC();
 }