1466 lines
37 KiB
C
1466 lines
37 KiB
C
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
SetFile()
|
|
|
|
BREAKPOINT masterBP = {0L,0L};
|
|
PBREAKPOINT bpList = &masterBP;
|
|
|
|
extern HTHDX thdList;
|
|
extern CRITICAL_SECTION csThreadProcList;
|
|
|
|
|
|
PBREAKPOINT
|
|
GetNewBp(
|
|
HPRCX hprc,
|
|
HTHDX hthd,
|
|
BPTP BpType,
|
|
BPNS BpNotify,
|
|
ADDR *AddrBp,
|
|
HPID id,
|
|
PBREAKPOINT BpUse
|
|
)
|
|
/*++
|
|
Routine Description:
|
|
Allocates a BREAKPOINT structure and initializes it.
|
|
Note that this does NOT add the structure to the breakpoint list (bplist).
|
|
If it is not an address bp (i.e. it is a watchpoint), the hwalk field must be initialized later.
|
|
Arguments:
|
|
hprc - Supplies process to put BP in
|
|
hthd - Supplies optional thread
|
|
AddrBp - Supplies address structure for the breakpoint
|
|
id - Supplies EM id for BP
|
|
BpUse - (optional) Supplies other BP on same address (so we can steal the original code from it instead of reading).
|
|
Return Value:
|
|
PBREAKPOINT - Pointer to allocated and initialized structure.
|
|
--*/
|
|
{
|
|
PBREAKPOINT Bp;
|
|
DWORD i;
|
|
|
|
assert(!BpUse || (BpUse->hthd != hthd) || (BpUse->bpNotify != BpNotify));
|
|
|
|
Bp = (PBREAKPOINT)MHAlloc(sizeof(BREAKPOINT));
|
|
assert(Bp);
|
|
|
|
if (Bp) {
|
|
assert(bpList);
|
|
|
|
Bp->next = NULL;
|
|
Bp->hprc = hprc;
|
|
Bp->hthd = hthd;
|
|
Bp->id = id;
|
|
Bp->instances = 1;
|
|
Bp->isStep = FALSE;
|
|
Bp->hBreakPoint = 0;
|
|
Bp->bpType = BpType;
|
|
Bp->bpNotify = BpNotify;
|
|
Bp->hWalk = NULL;
|
|
#if defined(TARGET_IA64)
|
|
Bp->flags = 1;
|
|
#endif
|
|
memset(&Bp->addr, 0, sizeof(Bp->addr));
|
|
|
|
// Get the opcode from the indicated address
|
|
if (AddrBp) {
|
|
|
|
assert(!ADDR_IS_LI(*AddrBp));
|
|
if (ADDR_IS_LI(*AddrBp)) {
|
|
MHFree(Bp);
|
|
Bp = NULL;
|
|
} else {
|
|
Bp->instr1 = 0;
|
|
Bp->addr = *AddrBp;
|
|
|
|
if (BpUse) {
|
|
Bp->instr1 = BpUse->instr1;
|
|
} else if (!AddrReadMemory(hprc, hthd, AddrBp, &(Bp->instr1), BP_SIZE, &i) || (i != BP_SIZE)) {
|
|
#ifdef KERNEL
|
|
Bp->instr1 = 0;
|
|
#else
|
|
assert(!"AddrReadMemory failed");
|
|
MHFree(Bp);
|
|
Bp = NULL;
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return Bp;
|
|
}
|
|
|
|
|
|
|
|
PBREAKPOINT
|
|
SetBP(
|
|
HPRCX hprc,
|
|
HTHDX hthd,
|
|
BPTP bptype,
|
|
BPNS bpnotify,
|
|
LPADDR paddr,
|
|
HPID id
|
|
)
|
|
/*++
|
|
Routine Description:
|
|
Set a breakpoint, or increment instance count on an existing bp.
|
|
if hthd is non-NULL, BP is only for that thread.
|
|
Arguments:
|
|
hprc - Supplies process to put BP in
|
|
hthd - Supplies optional thread
|
|
bptype - Supplies OSDEBUG BP type
|
|
bpnotify - Supplies OSDEBUG notification code
|
|
paddr - Supplies address structure for the breakpoint
|
|
id - Supplies EM id for BP
|
|
Return Value:
|
|
pointer to bp structure, or NULL for failure
|
|
--*/
|
|
{
|
|
PBREAKPOINT pbp;
|
|
PBREAKPOINT pbpT;
|
|
ADDR addr;
|
|
ADDR addr2;
|
|
|
|
if (!hprc) {
|
|
return (PBREAKPOINT)NULL;
|
|
}
|
|
|
|
EnterCriticalSection(&csThreadProcList);
|
|
|
|
/*
|
|
* First let's try to find a breakpoint that
|
|
* matches this description
|
|
*/
|
|
|
|
pbpT = FindBP(hprc, hthd, bptype, bpnotify, paddr, FALSE);
|
|
|
|
/*
|
|
* If this thread has a breakpoint here,
|
|
* increment reference count.
|
|
*/
|
|
|
|
if (pbpT && pbpT->hthd == hthd && pbpT->bpNotify == bpnotify) {
|
|
pbp = pbpT;
|
|
pbp->instances++;
|
|
} else if (pbp = GetNewBp(hprc, hthd, bptype, bpnotify, paddr, id, pbpT)) {
|
|
if (pbpT) {
|
|
AddBpToList(pbp); // if already a bp at that addr, just add to list
|
|
} else {
|
|
// Now write the cpu-specific breakpoint code.
|
|
if (WriteBreakPoint(pbp)) {
|
|
AddBpToList(pbp);
|
|
} else {
|
|
MHFree(pbp);
|
|
pbp = NULL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Make it a linear address to start with
|
|
*/
|
|
|
|
addr2 = *paddr;
|
|
TranslateAddress(hprc, hthd, &addr2, TRUE);
|
|
|
|
/*
|
|
* Check with the threads to see if we are at this address. If so then
|
|
* we need to set the BP field so we don't hit the bp imeadiately
|
|
*/
|
|
|
|
if (hthd) {
|
|
AddrFromHthdx(&addr, hthd);
|
|
if ((hthd->tstate & ts_stopped) && (AtBP(hthd) == NULL) && AreAddrsEqual(hprc, hthd, &addr, &addr2)) {
|
|
SetBPFlag(hthd, pbp);
|
|
}
|
|
} else {
|
|
for (hthd = hprc->hthdChild; hthd; hthd = hthd->nextSibling) {
|
|
AddrFromHthdx(&addr, hthd);
|
|
if ((hthd->tstate & ts_stopped) && (AtBP(hthd) == NULL) && AreAddrsEqual(hprc, hthd, &addr, &addr2)) {
|
|
SetBPFlag(hthd, pbp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
LeaveCriticalSection(&csThreadProcList);
|
|
|
|
return pbp;
|
|
} /* SetBP() */
|
|
|
|
|
|
#ifdef KERNEL
|
|
|
|
|
|
BOOL
|
|
SetBPEx(
|
|
HPRCX hprc,
|
|
HTHDX hthd,
|
|
HPID id,
|
|
DWORD Count,
|
|
ADDR *Addrs,
|
|
PBREAKPOINT *Bps,
|
|
DWORD ContinueStatus
|
|
)
|
|
/*++
|
|
Routine Description:
|
|
Allocates a bunch of breakpoints from a given list of linear offsets.
|
|
Arguments:
|
|
hprc - Supplies process to put BP in
|
|
hthd - Supplies optional thread
|
|
Count - Supplies count of breakpoints to set
|
|
Addrs - Supplies list with Count addresses
|
|
Bps - Supplies buffer to be filled with Count pointers to
|
|
BREAKPOINT structures. Original contents are
|
|
overwritten.
|
|
|
|
ContinueStatus -
|
|
|
|
Return Value:
|
|
|
|
BOOL - If TRUE, then ALL breakpoints were set.
|
|
If FALSE, then NONE of the breakpoints were set.
|
|
|
|
|
|
NOTENOTE - Not sure of what will happen if the list contains duplicated
|
|
addresses!
|
|
|
|
--*/
|
|
|
|
{
|
|
PDBGKD_WRITE_BREAKPOINT64 DbgKdBp;
|
|
PDBGKD_RESTORE_BREAKPOINT DbgKdBpRes;
|
|
DWORD SetCount = 0;
|
|
DWORD NewCount = 0;
|
|
DWORD i;
|
|
DWORD j;
|
|
PBREAKPOINT BpT;
|
|
BOOL Ok;
|
|
ADDR Addr;
|
|
ADDR Addr2;
|
|
|
|
if (!hprc) {
|
|
assert(!"hprc == NULL is SetBPEx");
|
|
return FALSE;
|
|
}
|
|
|
|
assert(Count > 0);
|
|
assert(Addrs);
|
|
assert(Bps);
|
|
|
|
if (Count == 1) {
|
|
// Only one breakpoint, faster to simply call SetBP
|
|
Bps[0] = SetBP(hprc, hthd, bptpExec, bpnsStop, &Addrs[0], id);
|
|
return (Bps[0] != NULL);
|
|
}
|
|
|
|
EnterCriticalSection(&csThreadProcList);
|
|
|
|
AddrInit(&Addr, 0, 0, 0, TRUE, TRUE, FALSE, FALSE);
|
|
|
|
// Allocate space for Count breakpoints
|
|
DbgKdBp = (PDBGKD_WRITE_BREAKPOINT64)MHAlloc(sizeof(DBGKD_WRITE_BREAKPOINT64) * Count);
|
|
assert(DbgKdBp);
|
|
if (!DbgKdBp) {
|
|
LeaveCriticalSection(&csThreadProcList);
|
|
return FALSE;
|
|
}
|
|
|
|
for (i = 0; i < Count; i++) {
|
|
// See if we already have a breakpoint at this address.
|
|
BpT = FindBP(hprc, hthd, bptpExec, bpnsStop, &Addrs[i], FALSE);
|
|
|
|
if (BpT && BpT->hthd == hthd && BpT->bpNotify == bpnsStop) {
|
|
// exact match: just bump the instance count
|
|
Bps[i] = BpT;
|
|
Bps[i]->instances++;
|
|
} else if (BpT) {
|
|
// address matched: keep the old BP handle, make a new record
|
|
Bps[i] = GetNewBp(hprc, hthd, bptpExec, bpnsStop, &Addrs[i], id, NULL);
|
|
Bps[i]->hBreakPoint = BpT->hBreakPoint;
|
|
} else {
|
|
// no match: need a new BP
|
|
Bps[i] = GetNewBp(hprc, hthd, bptpExec, bpnsStop, &Addrs[i], id, NULL);
|
|
assert(Bps[i]);
|
|
|
|
// set instance to 0 to indicate it is unset
|
|
Bps[i]->instances = 0;
|
|
|
|
DbgKdBp[NewCount].BreakPointAddress = GetAddrOff(Addrs[i]);
|
|
DbgKdBp[NewCount].BreakPointHandle = 0;
|
|
|
|
// keep BP packet index in handle field until BP is set
|
|
Bps[i]->hBreakPoint = NewCount++;
|
|
}
|
|
}
|
|
|
|
Ok = TRUE;
|
|
if (NewCount > 0) {
|
|
// Set all new breakpoints
|
|
assert(NewCount <= Count);
|
|
Ok = WriteBreakPointEx(hthd, NewCount, DbgKdBp, ContinueStatus);
|
|
}
|
|
|
|
if (Ok) {
|
|
// Fill in the breakpoint list
|
|
for (i = 0; i < Count; i++) {
|
|
if (Bps[i] && Bps[i]->instances == 0) {
|
|
j = Bps[i]->hBreakPoint;
|
|
|
|
assert(GetAddrOff(Addrs[i]) == DbgKdBp[j].BreakPointAddress);
|
|
// Allocate new BP structure and get handle from
|
|
// the breakpoint packet.
|
|
Bps[i]->hBreakPoint = DbgKdBp[j].BreakPointHandle;
|
|
Bps[i]->instances = 1;
|
|
AddBpToList(Bps[i]);
|
|
}
|
|
|
|
SetCount++;
|
|
|
|
|
|
// Check with the threads to see if we are at this address.
|
|
// If so then we need to set the BP field so we don't hit
|
|
// the bp imeadiately
|
|
|
|
|
|
Addr2 = Bps[i]->addr;
|
|
|
|
if (hthd) {
|
|
AddrFromHthdx(&Addr, hthd);
|
|
if ((hthd->tstate & ts_stopped) && (AtBP(hthd) == NULL) && AreAddrsEqual(hprc, hthd, &Addr, &Addr2)) {
|
|
SetBPFlag(hthd, Bps[i]);
|
|
}
|
|
} else {
|
|
for (hthd = hprc->hthdChild; hthd; hthd = hthd->nextSibling) {
|
|
AddrFromHthdx(&Addr, hthd);
|
|
if ((hthd->tstate & ts_stopped) && (AtBP(hthd) == NULL) && AreAddrsEqual(hprc, hthd, &Addr, &Addr2)) {
|
|
SetBPFlag(hthd, Bps[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
assert(j == NewCount);
|
|
} else {
|
|
// Clean up any breakpoints that were set.
|
|
DbgKdBpRes = (PDBGKD_RESTORE_BREAKPOINT)MHAlloc(sizeof(DBGKD_RESTORE_BREAKPOINT) * NewCount);
|
|
assert(DbgKdBpRes);
|
|
if (DbgKdBpRes) {
|
|
// Put all breakpoints with a valid handle on the list of
|
|
// breakpoints to be removed.
|
|
j = 0;
|
|
for (i = 0; i < NewCount; i++) {
|
|
if (DbgKdBp[i].BreakPointHandle != 0) {
|
|
DbgKdBpRes[j++].BreakPointHandle = DbgKdBp[i].BreakPointHandle;
|
|
}
|
|
}
|
|
|
|
// Now remove them
|
|
if (j > 0) {
|
|
assert(j <= NewCount);
|
|
RestoreBreakPointEx(j, DbgKdBpRes);
|
|
}
|
|
|
|
MHFree(DbgKdBpRes);
|
|
|
|
// Remove allocated BP structures
|
|
for (i = 0; i < Count; i++) {
|
|
if (Bps[i] && Bps[i]->instances == 0) {
|
|
assert(!Bps[i]->next);
|
|
MHFree(Bps[i]);
|
|
Bps[i] = NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
MHFree(DbgKdBp);
|
|
|
|
LeaveCriticalSection(&csThreadProcList);
|
|
|
|
return (SetCount == Count);
|
|
}
|
|
|
|
|
|
#else // KERNEL
|
|
|
|
BOOL
|
|
SetBPEx(
|
|
HPRCX hprc,
|
|
HTHDX hthd,
|
|
HPID id,
|
|
DWORD Count,
|
|
ADDR *Addrs,
|
|
PBREAKPOINT *Bps,
|
|
DWORD ContinueStatus
|
|
)
|
|
/*++
|
|
Routine Description:
|
|
Allocates a bunch of breakpoints from a given list of linear offsets.
|
|
Arguments:
|
|
hprc - Supplies process to put BP in
|
|
hthd - Supplies optional thread
|
|
Count - Supplies count of breakpoints to set
|
|
Addrs - Supplies list with Count addresses
|
|
Bps - Supplies buffer to be filled with Count pointers to BREAKPOINT structures. Original contents is overwritten.
|
|
ContinueStatus -
|
|
Return Value:
|
|
BOOL - If TRUE, then ALL breakpoints were set.
|
|
If FALSE, then NONE of the breakpoints were set.
|
|
NOTENOTE - Not sure of what will happen if the list contains duplicated addresses!
|
|
--*/
|
|
{
|
|
DWORD SetCount = 0;
|
|
DWORD NewCount = 0;
|
|
DWORD i;
|
|
DWORD j;
|
|
DWORD cbBytes;
|
|
ADDR Addr;
|
|
ADDR Addr2;
|
|
PBREAKPOINT BpT;
|
|
|
|
if (!hprc) {
|
|
assert(!"hprc == NULL in SetBPEx");
|
|
return FALSE;
|
|
}
|
|
|
|
assert(Count > 0);
|
|
assert(Addrs);
|
|
assert(Bps);
|
|
|
|
if (Count == 1) {
|
|
// Only one breakpoint, faster to simply call SetBP
|
|
Bps[0] = SetBP(hprc, hthd, bptpExec, bpnsStop, &Addrs[0], id);
|
|
return (Bps[0] != NULL);
|
|
}
|
|
|
|
EnterCriticalSection(&csThreadProcList);
|
|
|
|
for (i = 0; i < Count; i++) {
|
|
// See if we already have a breakpoint at this address.
|
|
BpT = FindBP(hprc, hthd, bptpExec, bpnsStop, &Addrs[i], FALSE);
|
|
|
|
if (BpT && BpT->hthd == hthd && BpT->bpNotify == bpnsStop) {
|
|
// Reuse this breakpoint
|
|
Bps[i]->instances++;
|
|
assert(Bps[i]->instances > 1);
|
|
} else {
|
|
// Get new breakpoint
|
|
Bps[i] = GetNewBp(hprc, hthd, bptpExec, bpnsStop, &Addrs[i], id, BpT);
|
|
if (!Bps[i]) {
|
|
assert(!"GetNewBp failed in SetBPEx");
|
|
break;
|
|
}
|
|
|
|
if (!BpT) {
|
|
if (!WriteBreakPoint(Bps[i])) {
|
|
MHFree(Bps[i]);
|
|
Bps[i] = NULL;
|
|
assert(!"WriteBreakPoint failed in SetBPEx");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (i < Count) {
|
|
// Something went wrong, will backtrack
|
|
assert(!"i < Count in SetBPEx");
|
|
|
|
for (j = 0; j < i; j++) {
|
|
assert(Bps[j]);
|
|
Bps[j]->instances--;
|
|
if (Bps[j]->instances == 0) {
|
|
if (!ADDR_IS_LI(Bps[j]->addr)) {
|
|
#if defined(TARGET_IA64)
|
|
BP_UNIT Content;
|
|
ADDR BundleAddr;
|
|
|
|
// Read in memory since adjancent instructions in the same bundle may have
|
|
// been modified after we save them. Restore only the content of the slot which has
|
|
// the break instruction inserted.
|
|
AddrReadMemory(hprc, hthd, &Bps[j]->addr, (LPBYTE)&Content, BP_SIZE, &cbBytes);
|
|
switch (GetAddrOff(Bps[j]->addr) & 0xf) {
|
|
case 0:
|
|
Content = (Content & ~(INST_SLOT0_MASK)) | (Bps[j]->instr1 & INST_SLOT0_MASK);
|
|
break;
|
|
case 4:
|
|
Content = (Content & ~(INST_SLOT1_MASK)) | (Bps[j]->instr1 & INST_SLOT1_MASK);
|
|
break;
|
|
case 8:
|
|
Content = (Content & ~(INST_SLOT2_MASK)) | (Bps[j]->instr1 & INST_SLOT2_MASK);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
AddrWriteMemory(hprc, hthd, &Bps[j]->addr, (LPBYTE)&Content, BP_SIZE, &cbBytes);
|
|
|
|
// restore template to MLI if displaced instruction was MOVL
|
|
if (Bps[j]->flags & BREAKPOINT_IA64_MOVL) {
|
|
GetAddrOff(BundleAddr) = GetAddrOff(Bps[j]->addr) & ~0xf;
|
|
AddrReadMemory(hprc, hthd, &BundleAddr, (LPBYTE)&Content, BP_SIZE, &cbBytes);
|
|
|
|
Content &= ~((INST_TEMPL_MASK >> 1) << 1); // set template to MLI
|
|
Content |= 0x4;
|
|
|
|
AddrWriteMemory(hprc, hthd, &BundleAddr, (LPBYTE)&Content, BP_SIZE, &cbBytes);
|
|
}
|
|
#else
|
|
AddrWriteMemory(hprc, hthd, &Bps[j]->addr,
|
|
(LPBYTE)&Bps[j]->instr1, BP_SIZE, &cbBytes);
|
|
#endif
|
|
}
|
|
MHFree(Bps[j]);
|
|
Bps[j] = NULL;
|
|
}
|
|
}
|
|
} else {
|
|
// Add all the new breakpoints to the list
|
|
for (i = 0; i < Count; i++) {
|
|
if (Bps[i]->instances == 1) {
|
|
AddBpToList(Bps[i]);
|
|
}
|
|
|
|
// Check with the threads to see if we are at this address. If so then
|
|
// we need to set the BP field so we don't hit the bp imeadiately
|
|
Addr2 = Bps[i]->addr;
|
|
if (hthd) {
|
|
AddrFromHthdx(&Addr, hthd);
|
|
if ((hthd->tstate & ts_stopped) && (AtBP(hthd) == NULL) && AreAddrsEqual(hprc, hthd, &Addr, &Addr2)) {
|
|
SetBPFlag(hthd, Bps[i]);
|
|
}
|
|
} else {
|
|
for (hthd = hprc->hthdChild; hthd; hthd = hthd->nextSibling) {
|
|
AddrFromHthdx(&Addr, hthd);
|
|
if ((hthd->tstate & ts_stopped) && (AtBP(hthd) == NULL) && AreAddrsEqual(hprc, hthd, &Addr, &Addr2)) {
|
|
SetBPFlag(hthd, Bps[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
SetCount = Count;
|
|
}
|
|
|
|
LeaveCriticalSection(&csThreadProcList);
|
|
|
|
return (SetCount == Count);
|
|
}
|
|
|
|
#endif // KERNEL
|
|
|
|
BOOL
|
|
BPInRange(
|
|
HPRCX hprc,
|
|
HTHDX hthd,
|
|
PBREAKPOINT bp,
|
|
LPADDR paddrStart,
|
|
DWORD cb,
|
|
LPDWORD offset,
|
|
BP_UNIT * instr
|
|
)
|
|
{
|
|
ADDR addr1;
|
|
ADDR addr2;
|
|
|
|
/*
|
|
* If the breakpoint has a Loader index address then we can not
|
|
* possibly match it
|
|
*/
|
|
|
|
assert(!ADDR_IS_LI(*paddrStart));
|
|
if (ADDR_IS_LI(bp->addr)) {
|
|
return FALSE;
|
|
}
|
|
|
|
*offset = 0;
|
|
|
|
/*
|
|
* Now check for "equality" of the addresses.
|
|
|
|
* Need to include size of BP in the address range check. Since
|
|
* the address may start half way through a breakpoint.
|
|
*/
|
|
|
|
if ((ADDR_IS_FLAT(*paddrStart) == TRUE) &&
|
|
(ADDR_IS_FLAT(bp->addr) == TRUE)) {
|
|
#if defined(TARGET_IA64)
|
|
|
|
// This is a bit different for IA64 because intraslot addresses
|
|
// are "quasi" addresses
|
|
|
|
if (
|
|
// we have a match if the BP start within the read memory range
|
|
((GetAddrOff(bp->addr) >= GetAddrOff(*paddrStart)) &&
|
|
(GetAddrOff(bp->addr) < GetAddrOff(*paddrStart) + cb)) ||
|
|
|
|
// or we have a match if the range starts within the BP itself -
|
|
// notice - the length of BP is 4, not sizeof(BP_UNIT) which is 8
|
|
((GetAddrOff(*paddrStart) >= GetAddrOff(bp->addr)) &&
|
|
(GetAddrOff(*paddrStart) < GetAddrOff(bp->addr) + 4))
|
|
) {
|
|
#else
|
|
if ((GetAddrOff(*paddrStart) - sizeof(BP_UNIT) + 1 <=
|
|
GetAddrOff(bp->addr)) &&
|
|
(GetAddrOff(bp->addr) < GetAddrOff(*paddrStart) + cb)) {
|
|
#endif
|
|
*offset = (DWORD)(GetAddrOff(bp->addr) - GetAddrOff(*paddrStart));
|
|
*instr = bp->instr1;
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* The two addresses did not start out as flat addresses. So change
|
|
* them to linear addresses so that we can see if the addresses are
|
|
* are really the same
|
|
*/
|
|
|
|
addr1 = *paddrStart;
|
|
if (!TranslateAddress(hprc, hthd, &addr1, TRUE)) {
|
|
return FALSE;
|
|
}
|
|
addr2 = bp->addr;
|
|
if (!TranslateAddress(hprc, hthd, &addr2, TRUE)) {
|
|
return FALSE;
|
|
}
|
|
|
|
#if defined(TARGET_IA64) //same as above
|
|
if (
|
|
((GetAddrOff(addr2) >= GetAddrOff(addr1)) &&
|
|
(GetAddrOff(addr2) < GetAddrOff(addr1) + cb)) ||
|
|
((GetAddrOff(addr1) >= GetAddrOff(addr2)) &&
|
|
(GetAddrOff(addr1) < GetAddrOff(addr2) + 4))
|
|
) {
|
|
#else
|
|
if ((GetAddrOff(addr1) - sizeof(BP_UNIT) + 1 <= GetAddrOff(addr2)) &&
|
|
(GetAddrOff(addr2) < GetAddrOff(addr1) + cb)) {
|
|
#endif
|
|
*offset = (DWORD)(GetAddrOff(addr2) - GetAddrOff(addr1));
|
|
*instr = bp->instr1;
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
BPPriorityIsGreater(
|
|
BPNS n1,
|
|
BPNS n2
|
|
)
|
|
{
|
|
if (n1 == bpnsStop) {
|
|
return (n2 == bpnsContinue) || (n2 == bpnsCheck);
|
|
} else if (n1 == bpnsCheck) {
|
|
return (n2 == bpnsContinue);
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
#if 0
|
|
PBREAKPOINT
|
|
FindBP(
|
|
HPRCX hprc,
|
|
HTHDX hthd,
|
|
BPTP bptype,
|
|
BPNS bpnotify,
|
|
LPADDR paddr,
|
|
BOOL fExact
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Find and return a pointer to a BP struct.
|
|
|
|
This is called for the following cases:
|
|
|
|
1) A breakpoint has been hit, and we want to find a BP record for it.
|
|
In this case, we want to see the highest priority match, with
|
|
preference to the correct thread.
|
|
|
|
Call with bpnotify == -1, hthd == xxxx, fExact == FALSE
|
|
|
|
2) We want to step off/through a BP. Any match will do, we just need
|
|
the instruction.
|
|
|
|
Call with bpnotify == -1, hthd == 0, fExact == FALSE
|
|
|
|
3) We want to delete a BP. Everything must match exactly. (It would
|
|
be better to do this directly by the pointer to the BP, but the
|
|
shells do not support this properly.)
|
|
|
|
Call with bpnotify == bpnsXXXX, hthd == xxxx, fExact == TRUE
|
|
(N.B. hthd may be NULL, which means "any thread")
|
|
|
|
Always returns a BP that matches hthd and bpnotify if one exists; if
|
|
fExact is FALSE and there is no exact match, a BP matching only hprc
|
|
and address will succeed.
|
|
|
|
|
|
Arguments:
|
|
|
|
hprc - Supplies process
|
|
|
|
hthd - Supplies thread
|
|
|
|
bptype - Supplies OSDEBUG BP type
|
|
|
|
bpnotify -
|
|
|
|
paddr - Supplies address
|
|
|
|
fExact - Supplies TRUE if must be for a certain thread
|
|
|
|
Return Value:
|
|
|
|
pointer to BREAKPOINT struct, or NULL if none found.
|
|
|
|
--*/
|
|
{
|
|
PBREAKPOINT pbp;
|
|
PBREAKPOINT pbpFound = NULL;
|
|
ADDR addr;
|
|
|
|
EnterCriticalSection(&csThreadProcList);
|
|
|
|
/*
|
|
* Pre-translate the address to a linear address
|
|
*/
|
|
|
|
addr = *paddr;
|
|
TranslateAddress(hprc, hthd, &addr, TRUE);
|
|
|
|
|
|
// Check for an equivalent breakpoint. Breakpoints will be equal if
|
|
|
|
// 1. The process must be the same
|
|
// 2. The BP type must be the same
|
|
// 3. a) if it is an exec BP the addresses must match
|
|
// b) if not, MatchWalk is called
|
|
// 4. The thread and notify types must match if fExact is specified
|
|
|
|
|
|
for (pbp = bpList->next; pbp; pbp = pbp->next) {
|
|
if ((pbp->hprc == hprc) && (bptype == pbp->bpType)) {
|
|
if (bptype == bptpExec && AreAddrsEqual(hprc, hthd, &pbp->addr, &addr)) {
|
|
|
|
|
|
// if it matches exactly, take it now.
|
|
// if not, take it if it is better than the
|
|
// previous partial match
|
|
|
|
|
|
if (hthd == pbp->hthd && bpnotify == pbp->bpNotify) {
|
|
pbpFound = pbp;
|
|
break;
|
|
}
|
|
|
|
if (!pbpFound) {
|
|
|
|
// any match is better than none
|
|
|
|
|
|
pbpFound = pbp;
|
|
|
|
} else if (pbp->hthd == NULL || pbp->hthd == hthd) {
|
|
|
|
// this thread matches:
|
|
// is it better than the one we had?
|
|
|
|
if (hthd != pbpFound->hthd) {
|
|
pbpFound = pbp;
|
|
} else if (bpnotify == pbp->bpNotify && bpnotify != pbpFound->bpNotify) {
|
|
pbpFound = pbp;
|
|
} else if ((bpnotify == (BPNS)-1) &&
|
|
BPPriorityIsGreater(pbp->bpNotify, pbpFound->bpNotify)) {
|
|
pbpFound = pbp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
LeaveCriticalSection(&csThreadProcList);
|
|
|
|
if (!fExact || (
|
|
pbpFound &&
|
|
(pbpFound->hthd == hthd) &&
|
|
(pbpFound->bpNotify == bpnotify))) {
|
|
return pbpFound;
|
|
} else {
|
|
return NULL;
|
|
}
|
|
} /* FindBP() */
|
|
|
|
#endif
|
|
|
|
PBREAKPOINT
|
|
FindBP(
|
|
HPRCX hprc,
|
|
HTHDX hthd,
|
|
BPTP bptype,
|
|
BPNS bpnotify,
|
|
LPADDR paddr,
|
|
BOOL fExact
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Find and return a pointer to a BP struct.
|
|
|
|
This is called for the following cases:
|
|
|
|
1) A breakpoint has been hit, and we want to find a BP record for it.
|
|
In this case, we want to see the highest priority match, with
|
|
preference to the correct thread.
|
|
|
|
Call with bpnotify == -1, hthd == xxxx, fExact == FALSE
|
|
|
|
2) We want to step off/through a BP. Any match will do, we just need
|
|
the instruction.
|
|
|
|
Call with bpnotify == -1, hthd == 0, fExact == FALSE
|
|
|
|
3) We want to delete a BP. Everything must match exactly. (It would
|
|
be better to do this directly by the pointer to the BP, but the
|
|
shells do not support this properly.)
|
|
|
|
Call with bpnotify == bpnsXXXX, hthd == xxxx, fExact == TRUE
|
|
(N.B. hthd may be NULL, which means "any thread")
|
|
|
|
Always returns a BP that matches hthd and bpnotify if one exists; if
|
|
fExact is FALSE and there is no exact match, a BP matching only hprc
|
|
and address will succeed.
|
|
|
|
|
|
Arguments:
|
|
|
|
hprc - Supplies process
|
|
|
|
hthd - Supplies thread
|
|
|
|
bptype - Supplies OSDEBUG BP type
|
|
|
|
bpnotify -
|
|
|
|
paddr - Supplies address
|
|
|
|
fExact - Supplies TRUE if must be for a certain thread
|
|
|
|
Return Value:
|
|
|
|
pointer to BREAKPOINT struct, or NULL if none found.
|
|
|
|
--*/
|
|
{
|
|
PBREAKPOINT pbp;
|
|
PBREAKPOINT pbpFound = NULL;
|
|
ADDR addr;
|
|
|
|
EnterCriticalSection(&csThreadProcList);
|
|
|
|
/*
|
|
* Pre-translate the address to a linear address
|
|
*/
|
|
|
|
addr = *paddr;
|
|
TranslateAddress(hprc, hthd, &addr, TRUE);
|
|
|
|
|
|
// Check for an equivalent breakpoint. Breakpoints will be equal if
|
|
|
|
// 1. The process must be the same
|
|
// 2. The BP type must be the same
|
|
// 3. a) if it is an exec BP the addresses must match
|
|
// b) if it is a message BP, the addresses must match
|
|
// c) other BP types are not supported at this time
|
|
// 4. The thread and notify types must match if fExact is specified
|
|
|
|
|
|
for (pbp = bpList->next; pbp; pbp = pbp->next) {
|
|
if ((pbp->hprc == hprc) && (bptype == pbp->bpType)) {
|
|
switch (bptype) {
|
|
|
|
case bptpMessage:
|
|
case bptpExec:
|
|
|
|
if (AreAddrsEqual(hprc, hthd, &pbp->addr, &addr)) {
|
|
|
|
// if it matches exactly, take it now.
|
|
// if not, take it if it is better than the
|
|
// previous partial match
|
|
|
|
|
|
if (hthd == pbp->hthd && bpnotify == pbp->bpNotify) {
|
|
pbpFound = pbp;
|
|
goto out_of_loop;
|
|
}
|
|
|
|
if (!pbpFound) {
|
|
|
|
|
|
// any match is better than none
|
|
|
|
|
|
pbpFound = pbp;
|
|
|
|
} else if (pbp->hthd == NULL || pbp->hthd == hthd) {
|
|
|
|
|
|
// this thread matches:
|
|
// is it better than the one we had?
|
|
|
|
|
|
if (hthd != pbpFound->hthd) {
|
|
pbpFound = pbp;
|
|
} else if (bpnotify == pbp->bpNotify &&
|
|
bpnotify != pbpFound->bpNotify) {
|
|
pbpFound = pbp;
|
|
} else if ((bpnotify == (BPNS)-1) &&
|
|
BPPriorityIsGreater(pbp->bpNotify,
|
|
pbpFound->bpNotify)
|
|
) {
|
|
pbpFound = pbp;
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
// At this time FindBP () only supports types Message and
|
|
// exec. Add your matching code this this switch stmt.
|
|
|
|
assert(FALSE);
|
|
}
|
|
}
|
|
}
|
|
|
|
out_of_loop:
|
|
|
|
LeaveCriticalSection(&csThreadProcList);
|
|
|
|
if (!fExact || (
|
|
pbpFound &&
|
|
(pbpFound->hthd == hthd) &&
|
|
(pbpFound->bpNotify == bpnotify))) {
|
|
return pbpFound;
|
|
} else {
|
|
return NULL;
|
|
}
|
|
} /* FindBP() */
|
|
|
|
|
|
PBREAKPOINT
|
|
BPNextHprcPbp(
|
|
HPRCX hprc,
|
|
PBREAKPOINT pbp
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Find the next breakpoint for the given process after pbp.
|
|
If pbp is NULL start at the front of the list, for a find
|
|
first, find next behaviour.
|
|
|
|
|
|
Arguments:
|
|
|
|
hprc - Supplies the process handle to match breakpoints for
|
|
|
|
pbp - Supplies pointer to breakpoint item to start searching after
|
|
|
|
Return Value:
|
|
|
|
NULL if no matching breakpoint is found else a pointer to the
|
|
matching breakpoint
|
|
|
|
--*/
|
|
|
|
{
|
|
EnterCriticalSection(&csThreadProcList);
|
|
if (pbp == NULL) {
|
|
pbp = bpList->next;
|
|
} else {
|
|
pbp = pbp->next;
|
|
}
|
|
|
|
for (; pbp; pbp = pbp->next) {
|
|
if (pbp->hprc == hprc) {
|
|
break;
|
|
}
|
|
}
|
|
LeaveCriticalSection(&csThreadProcList);
|
|
|
|
return pbp;
|
|
} /* BPNextHprcPbp() */
|
|
|
|
|
|
PBREAKPOINT
|
|
BPNextHthdPbp(
|
|
HTHDX hthd,
|
|
PBREAKPOINT pbp
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Find the next breakpoint for the given thread after pbp.
|
|
If pbp is NULL start at the front of the list for find
|
|
first, find next behaviour.
|
|
|
|
Arguments:
|
|
|
|
hthd - Supplies the thread handle to match breakpoints for
|
|
|
|
pbp - Supplies pointer to breakpoint item to start searching after
|
|
|
|
Return Value:
|
|
|
|
NULL if no matching breakpoint is found else a pointer to the
|
|
matching breakpoint
|
|
|
|
--*/
|
|
|
|
{
|
|
EnterCriticalSection(&csThreadProcList);
|
|
|
|
if (pbp == NULL) {
|
|
pbp = bpList->next;
|
|
} else {
|
|
pbp = pbp->next;
|
|
}
|
|
|
|
for (; pbp; pbp = pbp->next) {
|
|
if (pbp->hthd == hthd) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
LeaveCriticalSection(&csThreadProcList);
|
|
|
|
return pbp;
|
|
} /* BPNextHthdPbp() */
|
|
|
|
|
|
|
|
|
|
BOOL
|
|
RemoveBPHelper(
|
|
PBREAKPOINT pbp,
|
|
BOOL fRestore
|
|
)
|
|
{
|
|
PBREAKPOINT pbpPrev;
|
|
PBREAKPOINT pbpCur;
|
|
PBREAKPOINT pbpT;
|
|
HTHDX hthd;
|
|
BOOL rVal = FALSE;
|
|
|
|
|
|
|
|
// first, is it real?
|
|
|
|
if (!pbp || pbp == EMBEDDED_BP) {
|
|
return FALSE;
|
|
}
|
|
|
|
EnterCriticalSection(&csThreadProcList);
|
|
|
|
/* Decrement the instances counter */
|
|
if (--pbp->instances) {
|
|
|
|
/*
|
|
* BUGBUG: jimsch -- Feb 29 1993
|
|
* This piece of code is most likely incorrect. We need to
|
|
* know if we are the DM freeing a breakpoint or the user
|
|
* freeing a breakpoint before we clear the step bit. Otherwise
|
|
* we may be in the following situation
|
|
|
|
* Set a thread specific breakpoint on an address
|
|
* Step the thread so that the address is the destination is
|
|
* where the step ends up (but it takes some time such
|
|
* as over a function call)
|
|
* Clear the thread specific breakpoint
|
|
|
|
* This will cause the step breakpoint to be cleared so we will
|
|
* stop at the address instead of just continuing stepping.
|
|
*/
|
|
|
|
pbp->isStep = FALSE;
|
|
LeaveCriticalSection(&csThreadProcList);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Search the list for the specified breakpoint */
|
|
|
|
|
|
for (pbpPrev = bpList, pbpCur = bpList->next;
|
|
pbpCur;
|
|
pbpPrev = pbpCur, pbpCur = pbpCur->next) {
|
|
|
|
if (pbpCur == pbp) {
|
|
|
|
/*
|
|
* Remove this bp from the list:
|
|
*/
|
|
|
|
pbpPrev->next = pbpCur->next;
|
|
|
|
|
|
// pbpT will be used later to replace atBP
|
|
// in any thread which happens to be sitting
|
|
// on the BP which we are removing.
|
|
|
|
if (pbpCur->bpType != bptpExec && pbpCur->bpType != bptpMessage) {
|
|
|
|
pbpT = NULL;
|
|
|
|
} else {
|
|
|
|
// see if there is another bp on the same address:
|
|
|
|
|
|
pbpT = FindBP(pbpCur->hprc,
|
|
pbpCur->hthd,
|
|
pbpCur->bpType,
|
|
(BPNS)-1,
|
|
&pbpCur->addr,
|
|
FALSE);
|
|
|
|
if (!pbpT && (pbpCur->bpType == bptpExec ||
|
|
pbpCur->bpType == bptpMessage)) {
|
|
|
|
// if this was the only one, put the
|
|
// opcode back where it belongs.
|
|
|
|
|
|
if (fRestore) {
|
|
RestoreBreakPoint(pbpCur);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pbpCur->hWalk) {
|
|
RemoveWalk(pbpCur->hWalk, pbpCur->hthd == NULL);
|
|
}
|
|
|
|
|
|
// Now we have to go through all the threads to see
|
|
// if any of them are on this breakpoint and clear
|
|
// the breakpoint indicator on these threads
|
|
|
|
|
|
|
|
// Could be on any thread:
|
|
|
|
|
|
|
|
// (We are already in the ThreadProcList critical section)
|
|
|
|
|
|
for (hthd = thdList->nextGlobalThreadThisProbablyIsntTheOneYouWantedToUse;
|
|
hthd;
|
|
hthd = hthd->nextGlobalThreadThisProbablyIsntTheOneYouWantedToUse) {
|
|
if (hthd->atBP == pbpCur) {
|
|
hthd->atBP = pbpT;
|
|
}
|
|
}
|
|
|
|
MHFree(pbpCur);
|
|
rVal = TRUE;
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
LeaveCriticalSection(&csThreadProcList);
|
|
|
|
return rVal;
|
|
|
|
}
|
|
|
|
|
|
BOOL
|
|
RemoveAllHprcBP(
|
|
HPRCX hprc
|
|
)
|
|
{
|
|
PBREAKPOINT pbp, pbpT;
|
|
|
|
for (pbp = BPNextHprcPbp(hprc, NULL); pbp; pbp = pbpT) {
|
|
BYTE count = pbp->instances;
|
|
pbpT = BPNextHprcPbp(hprc, pbp);
|
|
while (count--) {
|
|
RemoveBPHelper(pbp, TRUE);
|
|
}
|
|
}
|
|
|
|
// All bps for this process should be cleared.
|
|
assert(BPNextHprcPbp(hprc, NULL) == NULL);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
RemoveBP(
|
|
PBREAKPOINT pbp
|
|
)
|
|
{
|
|
return RemoveBPHelper(pbp, TRUE);
|
|
}
|
|
|
|
#ifdef KERNEL
|
|
|
|
BOOL
|
|
RemoveBPEx(
|
|
DWORD Count,
|
|
PBREAKPOINT *Bps
|
|
)
|
|
{
|
|
|
|
PDBGKD_RESTORE_BREAKPOINT DbgKdBp;
|
|
DWORD RestoreCount = 0;
|
|
DWORD GoneCount = 0;
|
|
DWORD i;
|
|
PBREAKPOINT BpCur;
|
|
PBREAKPOINT BpOther;
|
|
|
|
assert(Count > 0);
|
|
|
|
if (Count == 1) {
|
|
|
|
// Only one breakpoint, its faster to simply call RemoveBP
|
|
|
|
return RemoveBP(Bps[0]);
|
|
}
|
|
|
|
EnterCriticalSection(&csThreadProcList);
|
|
|
|
DbgKdBp = (PDBGKD_RESTORE_BREAKPOINT)MHAlloc(sizeof(DBGKD_RESTORE_BREAKPOINT) * Count);
|
|
assert(DbgKdBp);
|
|
|
|
if (DbgKdBp) {
|
|
|
|
|
|
// Find out what breakpoints we have to restore and put them in
|
|
// the list.
|
|
|
|
for (i = 0; i < Count; i++) {
|
|
|
|
assert(Bps[i] != EMBEDDED_BP);
|
|
|
|
for (BpCur = bpList->next; BpCur; BpCur = BpCur->next) {
|
|
|
|
if (BpCur == Bps[i]) {
|
|
|
|
|
|
// See if there is another bp on the same address.
|
|
|
|
for (BpOther = bpList->next; BpOther; BpOther = BpOther->next) {
|
|
if ((BpOther != BpCur) &&
|
|
AreAddrsEqual(BpCur->hprc, BpCur->hthd, &BpCur->addr, &BpOther->addr)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!BpOther) {
|
|
|
|
// If this was the only one, put it in the list.
|
|
|
|
DbgKdBp[GoneCount++].BreakPointHandle = Bps[i]->hBreakPoint;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Restore the breakpoints in the list.
|
|
|
|
if (GoneCount > 0) {
|
|
assert(GoneCount <= Count);
|
|
RestoreBreakPointEx(GoneCount, DbgKdBp);
|
|
}
|
|
|
|
|
|
// All breakpoints that were to be restored have been
|
|
// restored, now go ahead and do the cleaning up stuff.
|
|
|
|
for (i = 0; i < Count; i++) {
|
|
RemoveBPHelper(Bps[i], FALSE);
|
|
RestoreCount++;
|
|
}
|
|
|
|
MHFree(DbgKdBp);
|
|
}
|
|
|
|
LeaveCriticalSection(&csThreadProcList);
|
|
|
|
return (RestoreCount == Count);
|
|
}
|
|
|
|
#else // KERNEL
|
|
|
|
BOOL
|
|
RemoveBPEx(
|
|
DWORD Count,
|
|
PBREAKPOINT *Bps
|
|
)
|
|
{
|
|
|
|
DWORD i;
|
|
|
|
assert(Count > 0);
|
|
|
|
for (i = 0; i < Count; i++) {
|
|
|
|
RemoveBPHelper(Bps[i], TRUE);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
#endif // KERNEL
|
|
|
|
|
|
void SetBPFlag(HTHDX hthd, PBREAKPOINT bp)
|
|
{
|
|
hthd->atBP = bp;
|
|
}
|
|
|
|
|
|
|
|
PBREAKPOINT AtBP(HTHDX hthd)
|
|
{
|
|
return hthd->atBP;
|
|
}
|
|
|
|
|
|
|
|
|
|
void ClearBPFlag(HTHDX hthd)
|
|
{
|
|
hthd->atBP = NULL;
|
|
}
|
|
|
|
|
|
|
|
void
|
|
RestoreInstrBP(
|
|
HTHDX hthd,
|
|
PBREAKPOINT bp
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Replace the instruction for a breakpoint. If it was not
|
|
the debugger's BP, skip the IP past it.
|
|
|
|
Arguments:
|
|
|
|
hthd - Thread
|
|
|
|
bp - breakpoint data
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
{
|
|
|
|
// Check if this is an embedded breakpoint
|
|
|
|
|
|
if (bp == EMBEDDED_BP) {
|
|
|
|
|
|
// It was, so there is no instruction to restore,
|
|
// just increment the EIP
|
|
|
|
|
|
IncrementIP(hthd);
|
|
return;
|
|
}
|
|
|
|
if (bp->hWalk) {
|
|
|
|
|
|
// This is really a hardware breakpoint. Let the
|
|
// walk manager fix this.
|
|
|
|
|
|
ExprBPClearBPForStep(hthd);
|
|
|
|
} else {
|
|
|
|
|
|
// Replace the breakpoint current in memory with the correct
|
|
// instruction
|
|
|
|
|
|
RestoreBreakPoint(bp);
|
|
bp->hBreakPoint = 0;
|
|
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
VOID DeleteAllBps(VOID)
|
|
{
|
|
PBREAKPOINT pbp, bpn;
|
|
|
|
EnterCriticalSection(&csThreadProcList);
|
|
|
|
pbp = bpList->next;
|
|
|
|
while (pbp) {
|
|
bpn = pbp->next;
|
|
if (bpn) {
|
|
MHFree(pbp);
|
|
}
|
|
pbp = bpn;
|
|
}
|
|
|
|
bpList->next = NULL;
|
|
bpList->hprc = NULL;
|
|
|
|
LeaveCriticalSection(&csThreadProcList);
|
|
}
|
|
|
|
void AddBpToList(PBREAKPOINT pbp)
|
|
{
|
|
assert(bpList);
|
|
EnterCriticalSection(&csThreadProcList);
|
|
pbp->next = bpList->next;
|
|
bpList->next = pbp;
|
|
LeaveCriticalSection(&csThreadProcList);
|
|
}
|
|
|
|
PBREAKPOINT
|
|
SetWP(
|
|
HPRCX hprc,
|
|
HTHDX hthd,
|
|
BPTP bptype,
|
|
BPNS bpnotify,
|
|
ADDR addr
|
|
)
|
|
{
|
|
return (PBREAKPOINT)0;
|
|
}
|