windows-nt/Source/XPSP1/NT/base/tools/kdexts2/calldata.c
2020-09-26 16:20:57 +08:00

246 lines
5.9 KiB
C

/*++
Copyright (c) 1994 Microsoft Corporation
Module Name:
calldata.c
Abstract:
WinDbg Extension Api
Author:
David N. Cutler (davec) 22-May-1994
Environment:
User Mode.
Revision History:
--*/
#include "precomp.h"
#pragma hdrstop
typedef struct CALL_HASH_READ {
ULONG64 CallersAddress;
ULONG64 CallersCaller;
ULONG CallCount;
} CALL_HASH_READ, *PCALL_HASH_READ;
int __cdecl
HashCompare(
const void * Element1,
const void * Element2
);
DECLARE_API( calldata )
/*++
Routine Description:
Dump call data hash table
Arguments:
arg - name-of-hash-table
Return Value:
None
--*/
{
UCHAR Buffer[256];
ULONG64 Displacement=0;
ULONG64 End=0;
ULONG Index;
ULONG64 CallData;
ULONG64 Next;
ULONG Result;
UCHAR TableName[80];
PCALL_HASH_READ CallerArray;
ULONG NumberCallers = 0;
ULONG ArraySize = 1000;
ULONG64 HashTable_Flink;
//
// If a table name was not specified, then don't attempt to dump the
// table.
//
if (args[0] == '\0') {
dprintf("A call data table name must be specified\n");
return E_INVALIDARG;
}
//
// Get the address of the specified call performance data and read the
// contents of the structure.
//
strcpy(&TableName[0], args);
dprintf("**** Dump Call Performance Data For %s ****\n\n", &TableName[0]);
CallData = GetExpression(&TableName[0]);
if ((CallData == 0) ||
(GetFieldValue(CallData, "_CALL_PERFORMANCE_DATA", "HashTable.Flink", HashTable_Flink)
!= FALSE)) {
//
// The target build does not support specified call performance data.
//
dprintf("%08p: No call performance data available\n", CallData);
} else {
ULONG HashTableOffset;
GetFieldOffset("_CALL_PERFORMANCE_DATA", "HashTable", &HashTableOffset);
//
// Dump the specified call data.
//
CallerArray = LocalAlloc(LMEM_FIXED, sizeof(CALL_HASH_READ) * ArraySize);
if (CallerArray==NULL) {
dprintf("Couldn't allocate memory for caller array\n");
return E_INVALIDARG;
}
dprintf("Loading data");
for (Index = 0; Index < CALL_HASH_TABLE_SIZE; Index += 1) {
UCHAR CallHash[] = "_CALL_HASH_ENTRY";
End = HashTableOffset + CallData + GetTypeSize("_LIST_ENTRY") * Index;
GetFieldValue(End, "_LIST_ENTRY", "Flink", Next);
while (Next != End) {
if (!GetFieldValue(Next, CallHash, "CallersCaller", CallerArray[NumberCallers].CallersCaller) &&
!GetFieldValue(Next, CallHash, "CallersAddress", CallerArray[NumberCallers].CallersAddress) &&
!GetFieldValue(Next, CallHash, "CallCount", CallerArray[NumberCallers].CallCount)) {
NumberCallers++;
if (NumberCallers == ArraySize) {
//
// Grow the caller array
//
PCALL_HASH_READ NewArray;
ArraySize = ArraySize * 2;
NewArray = LocalAlloc(LMEM_FIXED, sizeof(CALL_HASH_READ) * ArraySize);
if (NewArray == NULL) {
dprintf("Couldn't allocate memory to extend caller array\n");
LocalFree(CallerArray);
return E_INVALIDARG;
}
CopyMemory(NewArray, CallerArray, sizeof(CALL_HASH_READ) * NumberCallers);
LocalFree(CallerArray);
CallerArray = NewArray;
}
if ((NumberCallers % 10) == 0) {
dprintf(".");
}
}
GetFieldValue(Next, CallHash, "ListEntry.Flink", Next);
if (CheckControlC()) {
LocalFree(CallerArray);
return E_INVALIDARG;
}
}
if (CheckControlC()) {
return E_INVALIDARG;
}
}
qsort((PVOID)CallerArray,
NumberCallers,
sizeof(CALL_HASH_READ),
HashCompare);
dprintf("\n Number Caller/Caller's Caller\n\n");
for (Index = 0; Index < NumberCallers; Index++) {
GetSymbol(CallerArray[Index].CallersAddress,
Buffer,
&Displacement);
dprintf("%10d %s", CallerArray[Index].CallCount, Buffer);
if (Displacement != 0) {
dprintf("+0x%1p", Displacement);
}
if (CallerArray[Index].CallersCaller != 0) {
dprintf("\n");
GetSymbol(CallerArray[Index].CallersCaller,
Buffer,
&Displacement);
dprintf(" %s", Buffer);
if (Displacement != 0) {
dprintf("+0x%1p", Displacement);
}
}
dprintf("\n");
if (CheckControlC()) {
break;
}
}
LocalFree(CallerArray);
}
return S_OK;
}
int __cdecl
HashCompare(
const void * Element1,
const void * Element2
)
/*++
Routine Description:
Provides a comparison of hash elements for the qsort library function
Arguments:
Element1 - Supplies pointer to the key for the search
Element2 - Supplies element to be compared to the key
Return Value:
> 0 - Element1 < Element2
= 0 - Element1 == Element2
< 0 - Element1 > Element2
--*/
{
PCALL_HASH_READ Hash1 = (PCALL_HASH_READ)Element1;
PCALL_HASH_READ Hash2 = (PCALL_HASH_READ)Element2;
if (Hash1->CallCount < Hash2->CallCount) {
return(1);
}
else if (Hash1->CallCount > Hash2->CallCount) {
return(-1);
} else {
return(0);
}
}