You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2554 lines
66 KiB
2554 lines
66 KiB
/*++
|
|
|
|
Copyright (c) 1997-2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
process.c
|
|
|
|
Abstract:
|
|
|
|
Manipulation routines for cpdata structures.
|
|
|
|
Author:
|
|
|
|
Melur Raghuraman (mraghu) 03-Oct-1997
|
|
|
|
Environment:
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include "cpdata.h"
|
|
#include "tracectr.h"
|
|
#include "item.h"
|
|
|
|
extern PTRACE_CONTEXT_BLOCK TraceContext;
|
|
extern PWCHAR CpdiGuidToString(PWCHAR s, ULONG len, LPGUID piid);
|
|
extern LIST_ENTRY g_ValueMapTable;
|
|
|
|
VOID
|
|
Aggregate(
|
|
IN PTHREAD_RECORD pThread
|
|
);
|
|
|
|
ULONG
|
|
CPDAPI
|
|
GetTempName( LPTSTR strFile, size_t cchSize )
|
|
{
|
|
HRESULT hr;
|
|
DWORD dwStatus;
|
|
GUID guid;
|
|
WCHAR strGUID[128];
|
|
DWORD nChar = 0;
|
|
|
|
dwStatus = UuidCreate( &guid );
|
|
if( dwStatus == RPC_S_OK || dwStatus == RPC_S_UUID_LOCAL_ONLY ){
|
|
nChar = StringFromGUID2( (const GUID*)&guid, strGUID, 128 );
|
|
dwStatus = ERROR_SUCCESS;
|
|
}
|
|
|
|
if( 0 == nChar ){
|
|
hr = StringCchPrintf( strGUID, 128, L"{d41c99ea-c303-4d06-b779-f9e8e20acb8f}.%08d", rand() );
|
|
}
|
|
|
|
nChar = GetTempPath( cchSize, strFile );
|
|
if( 0 == nChar ){
|
|
dwStatus = GetLastError();
|
|
}
|
|
|
|
if( ERROR_SUCCESS == dwStatus ){
|
|
hr = StringCchCat( strFile, cchSize, strGUID );
|
|
}
|
|
|
|
return dwStatus;
|
|
}
|
|
|
|
__inline
|
|
USHORT
|
|
UrlHashKey(
|
|
PUCHAR UrlStr,
|
|
ULONG StrSize
|
|
)
|
|
{
|
|
USHORT i, l, key = 0;
|
|
i = (USHORT)(StrSize - 1);
|
|
// Use only the last 25 chars
|
|
l = (StrSize > 25) ? (USHORT)(StrSize - 25) : 0;
|
|
|
|
// UrlStr cannot be NULL when this function is called.
|
|
for ( ; i >= l; i--) {
|
|
key = 37 * key + (USHORT)(*(UrlStr + i));
|
|
if (i == 0) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
key = key % (URL_HASH_TABLESIZE);
|
|
|
|
return key;
|
|
}
|
|
|
|
VOID
|
|
InitDiskRecord(
|
|
PTDISK_RECORD pDisk,
|
|
ULONG DiskNumber
|
|
)
|
|
{
|
|
PWCHAR name;
|
|
if (pDisk == NULL){
|
|
return;
|
|
}
|
|
memset(pDisk, 0, sizeof(TDISK_RECORD));
|
|
InitializeListHead(&pDisk->ProcessListHead);
|
|
InitializeListHead(&pDisk->FileListHead);
|
|
pDisk->DiskNumber = DiskNumber;
|
|
|
|
name = (PWCHAR)malloc(16 * sizeof(WCHAR));
|
|
if (name != NULL) {
|
|
StringCbPrintfW(name, 16 * sizeof(WCHAR), L"Disk%d", DiskNumber);
|
|
}
|
|
pDisk->DiskName = name;
|
|
}
|
|
|
|
VOID
|
|
InitFileRecord(
|
|
PFILE_RECORD pFile
|
|
)
|
|
{
|
|
if (pFile == NULL){
|
|
return;
|
|
}
|
|
memset(pFile, 0, sizeof(FILE_RECORD));
|
|
InitializeListHead(&pFile->ProtoProcessListHead);
|
|
}
|
|
|
|
VOID
|
|
InitThreadRecord(
|
|
PTHREAD_RECORD pThread
|
|
)
|
|
{
|
|
if (pThread == NULL)
|
|
return;
|
|
memset(pThread, 0, sizeof(THREAD_RECORD));
|
|
InitializeListHead( &pThread->DiskListHead );
|
|
InitializeListHead( &pThread->TransListHead );
|
|
InitializeListHead( &pThread->HPFReadListHead );
|
|
InitializeListHead( &pThread->HPFWriteListHead );
|
|
}
|
|
|
|
PTRANS_RECORD
|
|
CreateTransRecord()
|
|
{
|
|
PLIST_ENTRY Head, Next;
|
|
PTRANS_RECORD pTrans = NULL;
|
|
|
|
EnterTracelibCritSection();
|
|
Head = &CurrentSystem.FreeTransListHead;
|
|
|
|
Next = Head->Flink;
|
|
|
|
if (Next != Head) {
|
|
pTrans = CONTAINING_RECORD ( Next, TRANS_RECORD, Entry );
|
|
RemoveEntryList( &pTrans->Entry );
|
|
}
|
|
LeaveTracelibCritSection();
|
|
|
|
if (pTrans == NULL) {
|
|
pTrans = malloc(sizeof(TRANS_RECORD));
|
|
if (pTrans == NULL) {
|
|
SetLastError(ERROR_OUTOFMEMORY);
|
|
return NULL;
|
|
}
|
|
}
|
|
memset(pTrans, 0, sizeof(TRANS_RECORD));
|
|
InitializeListHead(&pTrans->SubTransListHead);
|
|
return pTrans;
|
|
}
|
|
|
|
VOID
|
|
InitMofData(
|
|
PMOF_DATA pMofData
|
|
)
|
|
{
|
|
if (pMofData == NULL)
|
|
return;
|
|
memset(pMofData, 0, sizeof(MOF_DATA));
|
|
pMofData->MaxKCpu = -1;
|
|
pMofData->MinKCpu = -1;
|
|
pMofData->MaxUCpu = -1;
|
|
pMofData->MinUCpu = -1;
|
|
}
|
|
|
|
VOID
|
|
InitProcessRecord(
|
|
PPROCESS_RECORD pProcess
|
|
)
|
|
{
|
|
if (pProcess == NULL)
|
|
return;
|
|
memset(pProcess, 0, sizeof(PROCESS_RECORD));
|
|
InitializeListHead( &pProcess->ThreadListHead );
|
|
InitializeListHead( &pProcess->DiskListHead );
|
|
InitializeListHead( &pProcess->FileListHead );
|
|
InitializeListHead( &pProcess->ModuleListHead );
|
|
InitializeListHead( &pProcess->HPFListHead );
|
|
}
|
|
|
|
BOOLEAN AddModuleRecord(PMODULE_RECORD * ppModule,
|
|
ULONG lBaseAddress,
|
|
ULONG lModuleSize,
|
|
WCHAR * strModuleName)
|
|
{
|
|
PMODULE_RECORD pModule;
|
|
|
|
if ( (ppModule == NULL) || (strModuleName == NULL) ) {
|
|
return FALSE;
|
|
}
|
|
|
|
pModule = (PMODULE_RECORD)malloc(sizeof(MODULE_RECORD));
|
|
|
|
if(NULL != pModule){
|
|
memset(pModule, 0, sizeof(MODULE_RECORD));
|
|
|
|
pModule->strModuleName =
|
|
malloc(sizeof(WCHAR) * (lstrlenW(strModuleName) + 1));
|
|
|
|
if (pModule->strModuleName == NULL)
|
|
{
|
|
free(pModule);
|
|
pModule = NULL;
|
|
}
|
|
else
|
|
{
|
|
StringCchCopyW(pModule->strModuleName, (lstrlenW(strModuleName) + 1), strModuleName);
|
|
|
|
pModule->lBaseAddress = lBaseAddress;
|
|
pModule->lModuleSize = lModuleSize;
|
|
}
|
|
}
|
|
|
|
* ppModule = pModule;
|
|
|
|
return (BOOLEAN) (* ppModule != NULL);
|
|
}
|
|
|
|
BOOLEAN AddHPFFileRecord(
|
|
PHPF_FILE_RECORD * ppHPFFileRecord,
|
|
ULONG RecordID,
|
|
ULONG IrpFlags,
|
|
ULONG DiskNumber,
|
|
ULONGLONG ByteOffset,
|
|
ULONG BytesCount,
|
|
PVOID fDO
|
|
)
|
|
{
|
|
PHPF_FILE_RECORD pHPFFileRecord = malloc(sizeof(HPF_FILE_RECORD));
|
|
|
|
if (pHPFFileRecord)
|
|
{
|
|
pHPFFileRecord->RecordID = RecordID;
|
|
pHPFFileRecord->IrpFlags = IrpFlags;
|
|
pHPFFileRecord->DiskNumber = DiskNumber;
|
|
pHPFFileRecord->ByteOffset = ByteOffset;
|
|
pHPFFileRecord->BytesCount = BytesCount;
|
|
pHPFFileRecord->fDO = fDO;
|
|
}
|
|
|
|
* ppHPFFileRecord = pHPFFileRecord;
|
|
return (BOOLEAN) (* ppHPFFileRecord != NULL);
|
|
}
|
|
|
|
BOOLEAN AddHPFRecord(
|
|
PHPF_RECORD * ppHPFRecord,
|
|
ULONG lFaultAddress,
|
|
PVOID fDO,
|
|
LONG ByteCount,
|
|
LONGLONG ByteOffset
|
|
)
|
|
{
|
|
PHPF_RECORD pHPFRecord = malloc(sizeof(HPF_RECORD));
|
|
|
|
if (pHPFRecord)
|
|
{
|
|
pHPFRecord->fDO = fDO;
|
|
pHPFRecord->lFaultAddress = lFaultAddress;
|
|
pHPFRecord->lByteCount = ByteCount;
|
|
pHPFRecord->lByteOffset = ByteOffset;
|
|
InitializeListHead(& pHPFRecord->HPFReadListHead);
|
|
}
|
|
|
|
* ppHPFRecord = pHPFRecord;
|
|
return (BOOLEAN) (* ppHPFRecord != NULL);
|
|
}
|
|
|
|
void DeleteHPFRecord(
|
|
PHPF_RECORD pHPFRecord
|
|
)
|
|
{
|
|
PLIST_ENTRY pHead;
|
|
PLIST_ENTRY pNext;
|
|
PHPF_FILE_RECORD pHPFFileRecord;
|
|
|
|
if (!pHPFRecord)
|
|
return;
|
|
|
|
RemoveEntryList(& pHPFRecord->Entry);
|
|
pHead = & pHPFRecord->HPFReadListHead;
|
|
pNext = pHead->Flink;
|
|
while (pNext != pHead)
|
|
{
|
|
pHPFFileRecord = CONTAINING_RECORD(pNext, HPF_FILE_RECORD, Entry);
|
|
pNext = pNext->Flink;
|
|
RemoveEntryList(& pHPFFileRecord->Entry);
|
|
free(pHPFFileRecord);
|
|
}
|
|
free(pHPFRecord);
|
|
return;
|
|
}
|
|
|
|
VOID
|
|
InitWorkloadRecord(
|
|
PWORKLOAD_RECORD pWorkload
|
|
)
|
|
{
|
|
if (pWorkload == NULL)
|
|
return;
|
|
memset(pWorkload, 0, sizeof(WORKLOAD_RECORD));
|
|
InitializeListHead( &pWorkload->DiskListHead );
|
|
}
|
|
|
|
VOID
|
|
DeleteWorkloadRecord(
|
|
PWORKLOAD_RECORD pWorkload
|
|
)
|
|
{
|
|
if (pWorkload == NULL)
|
|
return;
|
|
|
|
}
|
|
|
|
PPROTO_PROCESS_RECORD
|
|
AddProtoProcess(
|
|
PFILE_RECORD pFile,
|
|
PPROCESS_RECORD pProcess
|
|
)
|
|
{
|
|
PPROTO_PROCESS_RECORD pProto;
|
|
|
|
if (pFile == NULL || pProcess == NULL)
|
|
return NULL;
|
|
|
|
pProto = malloc(sizeof(PROTO_PROCESS_RECORD));
|
|
if (pProto == NULL) {
|
|
return NULL;
|
|
}
|
|
memset(pProto, 0, sizeof(PROTO_PROCESS_RECORD));
|
|
|
|
pProto->ProcessRecord = pProcess;
|
|
InsertHeadList( &pFile->ProtoProcessListHead, &pProto->Entry );
|
|
return pProto;
|
|
}
|
|
|
|
PPROTO_PROCESS_RECORD
|
|
FindProtoProcessRecord(
|
|
PFILE_RECORD pFile,
|
|
PPROCESS_RECORD pProcess
|
|
)
|
|
{
|
|
PLIST_ENTRY Next, Head;
|
|
PPROTO_PROCESS_RECORD pProto;
|
|
if (pFile == NULL || pProcess == NULL)
|
|
return NULL;
|
|
|
|
Head = &pFile->ProtoProcessListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
pProto = CONTAINING_RECORD(Next, PROTO_PROCESS_RECORD, Entry);
|
|
if (pProcess == pProto->ProcessRecord)
|
|
return pProto;
|
|
Next = Next->Flink;
|
|
}
|
|
return (AddProtoProcess(pFile, pProcess));
|
|
}
|
|
|
|
BOOLEAN
|
|
AddProcess(
|
|
ULONG ProcessId,
|
|
PPROCESS_RECORD *ReturnedProcess
|
|
)
|
|
{
|
|
PPROCESS_RECORD Process;
|
|
PMODULE_RECORD pModule = NULL;
|
|
|
|
Process = malloc(sizeof(PROCESS_RECORD));
|
|
if (Process == NULL) {
|
|
return FALSE;
|
|
}
|
|
|
|
InitProcessRecord( Process );
|
|
Process->PID = ProcessId;
|
|
if (!AddModuleRecord(& pModule, 0, 0, L"other")) {
|
|
free(Process);
|
|
return FALSE;
|
|
}
|
|
|
|
pModule->pProcess = Process;
|
|
|
|
EnterTracelibCritSection();
|
|
InsertHeadList( &CurrentSystem.ProcessListHead, &Process->Entry );
|
|
InsertHeadList(& Process->ModuleListHead, & pModule->Entry);
|
|
LeaveTracelibCritSection();
|
|
*ReturnedProcess = Process;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOLEAN
|
|
DeleteProcess(
|
|
PPROCESS_RECORD Process
|
|
)
|
|
{
|
|
PLIST_ENTRY Next, Head;
|
|
PTHREAD_RECORD Thread;
|
|
PTDISK_RECORD Disk;
|
|
PFILE_RECORD pFile;
|
|
PMODULE_RECORD pModule;
|
|
PHPF_RECORD pHPFRecord;
|
|
|
|
if (Process == NULL)
|
|
return FALSE;
|
|
|
|
EnterTracelibCritSection();
|
|
RemoveEntryList( &Process->Entry );
|
|
LeaveTracelibCritSection();
|
|
|
|
Head = &Process->ThreadListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
Thread = CONTAINING_RECORD( Next, THREAD_RECORD, Entry );
|
|
Next = Next->Flink;
|
|
DeleteThread( Thread );
|
|
}
|
|
|
|
Head = &Process->DiskListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
Disk = CONTAINING_RECORD( Next, TDISK_RECORD, Entry );
|
|
Next = Next->Flink;
|
|
DeleteDisk( Disk );
|
|
}
|
|
|
|
Head = &Process->HPFListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
pHPFRecord = CONTAINING_RECORD(Next, HPF_RECORD, Entry);
|
|
Next = Next->Flink;
|
|
DeleteHPFRecord(pHPFRecord);
|
|
}
|
|
|
|
Head = &Process->FileListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
pFile = CONTAINING_RECORD( Next, FILE_RECORD, Entry );
|
|
Next = Next->Flink;
|
|
RemoveEntryList( &pFile->Entry );
|
|
if (pFile->FileName != NULL)
|
|
free(pFile->FileName);
|
|
free(pFile);
|
|
}
|
|
|
|
Head = &Process->ModuleListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head)
|
|
{
|
|
pModule = CONTAINING_RECORD(Next, MODULE_RECORD, Entry);
|
|
Next = Next->Flink;
|
|
RemoveEntryList(& pModule->Entry);
|
|
if(pModule->strModuleName)
|
|
{
|
|
free(pModule->strModuleName);
|
|
}
|
|
free(pModule);
|
|
}
|
|
|
|
if (Process->ImageName != NULL)
|
|
free(Process->ImageName);
|
|
if (Process->UserName != NULL)
|
|
free(Process->UserName);
|
|
|
|
free( Process );
|
|
return TRUE;
|
|
}
|
|
|
|
BOOLEAN
|
|
AddThread(
|
|
ULONG ThreadId,
|
|
PEVENT_TRACE pEvent,
|
|
PTHREAD_RECORD * ResultThread
|
|
)
|
|
{
|
|
PTHREAD_RECORD Thread = NULL;
|
|
PEVENT_TRACE_HEADER pHeader = (PEVENT_TRACE_HEADER) & pEvent->Header;
|
|
int i;
|
|
|
|
Thread = malloc(sizeof(THREAD_RECORD));
|
|
if (Thread == NULL) {
|
|
return FALSE;
|
|
}
|
|
|
|
InitThreadRecord(Thread);
|
|
|
|
Thread->TimeStart = Thread->TimeEnd
|
|
= (ULONGLONG) pHeader->TimeStamp.QuadPart;
|
|
Thread->TID = ThreadId;
|
|
Thread->ProcessorID = pEvent->ClientContext & 0x000000FF;
|
|
i = (int)Thread->TID;
|
|
i = i % THREAD_HASH_TABLESIZE;
|
|
InsertHeadList(&CurrentSystem.ThreadHashList[i], &Thread->Entry);
|
|
*ResultThread = Thread;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOLEAN
|
|
DeleteThread(
|
|
PTHREAD_RECORD Thread
|
|
)
|
|
{
|
|
PLIST_ENTRY pHead;
|
|
PLIST_ENTRY pNext;
|
|
PHPF_FILE_RECORD pHPFFileRecord;
|
|
|
|
if (Thread == NULL) {
|
|
return FALSE;
|
|
}
|
|
|
|
RemoveEntryList( &Thread->Entry );
|
|
DeleteTransList( &Thread->TransListHead, 0 );
|
|
|
|
pHead = & Thread->HPFReadListHead;
|
|
pNext = pHead->Flink;
|
|
while (pNext != pHead)
|
|
{
|
|
pHPFFileRecord = CONTAINING_RECORD(pNext, HPF_FILE_RECORD, Entry);
|
|
pNext = pNext->Flink;
|
|
RemoveEntryList(& pHPFFileRecord->Entry);
|
|
free(pHPFFileRecord);
|
|
}
|
|
pHead = & Thread->HPFWriteListHead;
|
|
pNext = pHead->Flink;
|
|
while (pNext != pHead)
|
|
{
|
|
pHPFFileRecord = CONTAINING_RECORD(pNext, HPF_FILE_RECORD, Entry);
|
|
pNext = pNext->Flink;
|
|
RemoveEntryList(& pHPFFileRecord->Entry);
|
|
free(pHPFFileRecord);
|
|
}
|
|
|
|
free( Thread );
|
|
return TRUE;
|
|
}
|
|
|
|
PTRANS_RECORD
|
|
FindTransByList(
|
|
PLIST_ENTRY Head,
|
|
LPGUID pGuid,
|
|
ULONG level
|
|
)
|
|
{
|
|
PLIST_ENTRY Next;
|
|
PTRANS_RECORD pTrans = NULL;
|
|
|
|
// Recursively look for the list that does
|
|
// not contain a running guid
|
|
//
|
|
if (level <= MAX_TRANS_LEVEL && Head != NULL)
|
|
{
|
|
Next = Head->Flink;
|
|
while (Next != Head)
|
|
{
|
|
pTrans = CONTAINING_RECORD(Next, TRANS_RECORD, Entry);
|
|
if (pTrans->bStarted)
|
|
{
|
|
if ( (level == 0 || level == 1)
|
|
&& IsEqualGUID(pTrans->pGuid, pGuid))
|
|
{
|
|
return pTrans;
|
|
}
|
|
else if (level > 0)
|
|
{
|
|
return FindTransByList(& pTrans->SubTransListHead,
|
|
pGuid,
|
|
level - 1);
|
|
}
|
|
}
|
|
Next = Next->Flink;
|
|
}
|
|
}
|
|
|
|
// Found the correct list; now find
|
|
// the matching transaction
|
|
//
|
|
if (level == 0 && Head != NULL)
|
|
{
|
|
Next = Head->Flink;
|
|
while (Next != Head)
|
|
{
|
|
pTrans = CONTAINING_RECORD(Next, TRANS_RECORD, Entry);
|
|
if (IsEqualGUID( pTrans->pGuid, pGuid))
|
|
{
|
|
return pTrans;
|
|
}
|
|
Next = Next->Flink;
|
|
}
|
|
//
|
|
// If not Found, go ahead and add it.
|
|
//
|
|
pTrans = CreateTransRecord();
|
|
if (pTrans != NULL) {
|
|
pTrans->pGuid = pGuid;
|
|
InsertHeadList( Head, &pTrans->Entry );
|
|
}
|
|
}
|
|
return pTrans;
|
|
}
|
|
|
|
PMOF_DATA
|
|
FindMofData(
|
|
PMOF_INFO pMofInfo,
|
|
PWCHAR strSortKey
|
|
)
|
|
{
|
|
PLIST_ENTRY Next;
|
|
PLIST_ENTRY Head;
|
|
PMOF_DATA pMofData = NULL;
|
|
|
|
if (pMofInfo == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
Head = &pMofInfo->DataListHead;
|
|
|
|
if (Head != NULL)
|
|
{
|
|
Next = Head->Flink;
|
|
while (Next != Head)
|
|
{
|
|
pMofData = CONTAINING_RECORD(Next, MOF_DATA, Entry);
|
|
if (strSortKey == NULL && pMofData->strSortKey == NULL)
|
|
{
|
|
return pMofData;
|
|
}
|
|
else if ( strSortKey != NULL
|
|
&& pMofData->strSortKey != NULL
|
|
&& !wcscmp(pMofData->strSortKey, strSortKey))
|
|
{
|
|
return pMofData;
|
|
}
|
|
Next = Next->Flink;
|
|
}
|
|
|
|
// If not Found, go ahead and add it.
|
|
//
|
|
pMofData = (PMOF_DATA)malloc(sizeof(MOF_DATA));
|
|
if (pMofData == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
InitMofData(pMofData);
|
|
if (strSortKey != NULL)
|
|
{
|
|
pMofData->strSortKey =
|
|
(PWCHAR) malloc((lstrlenW(strSortKey) + 1) * sizeof(WCHAR));
|
|
if (pMofData->strSortKey != NULL) {
|
|
StringCchCopyW(pMofData->strSortKey, (lstrlenW(strSortKey) + 1), strSortKey);
|
|
}
|
|
}
|
|
InsertHeadList(Head, &pMofData->Entry);
|
|
}
|
|
return pMofData;
|
|
}
|
|
|
|
BOOLEAN
|
|
DeleteTrans(
|
|
PTRANS_RECORD Trans
|
|
)
|
|
{
|
|
if (Trans == NULL)
|
|
return FALSE;
|
|
EnterTracelibCritSection();
|
|
RemoveEntryList( &Trans->Entry );
|
|
InsertHeadList( &CurrentSystem.FreeTransListHead, &Trans->Entry );
|
|
LeaveTracelibCritSection();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOLEAN
|
|
DeleteTransList(
|
|
PLIST_ENTRY Head,
|
|
ULONG level
|
|
)
|
|
{
|
|
PLIST_ENTRY Next;
|
|
PTRANS_RECORD pTrans;
|
|
|
|
if( Head == NULL || level > MAX_TRANS_LEVEL )
|
|
return FALSE;
|
|
|
|
Next = Head->Flink;
|
|
|
|
while(Next != Head){
|
|
pTrans = CONTAINING_RECORD( Next, TRANS_RECORD, Entry );
|
|
Next = Next->Flink;
|
|
DeleteTransList( &pTrans->SubTransListHead, level+1);
|
|
DeleteTrans( pTrans );
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
PPROCESS_RECORD
|
|
FindProcessById(
|
|
ULONG Id,
|
|
BOOLEAN CheckAlive
|
|
)
|
|
{
|
|
PLIST_ENTRY Next, Head;
|
|
PPROCESS_RECORD Process=NULL;
|
|
|
|
EnterTracelibCritSection();
|
|
|
|
Head = &CurrentSystem.ProcessListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
Process = CONTAINING_RECORD( Next, PROCESS_RECORD, Entry );
|
|
if (Process->PID == Id) {
|
|
LeaveTracelibCritSection();
|
|
if ((Process->DeadFlag) && (CheckAlive))
|
|
return NULL;
|
|
else
|
|
return Process;
|
|
}
|
|
|
|
Next = Next->Flink;
|
|
}
|
|
LeaveTracelibCritSection();
|
|
return NULL;
|
|
}
|
|
|
|
PTHREAD_RECORD
|
|
FindGlobalThreadById(
|
|
ULONG ThreadId,
|
|
PEVENT_TRACE pEvent
|
|
)
|
|
{
|
|
PLIST_ENTRY Next,
|
|
Head;
|
|
PTHREAD_RECORD Thread;
|
|
PEVENT_TRACE_HEADER pHeader = (PEVENT_TRACE_HEADER) & pEvent->Header;
|
|
ULONG i = ThreadId;
|
|
ULONG Depth = 0;
|
|
|
|
i = i % THREAD_HASH_TABLESIZE;
|
|
|
|
Head = &CurrentSystem.ThreadHashList[i];
|
|
Next = Head->Flink;
|
|
while (Next != Head)
|
|
{
|
|
Thread = CONTAINING_RECORD(Next, THREAD_RECORD, Entry);
|
|
Next = Next->Flink;
|
|
Depth++;
|
|
|
|
if (Thread->TID == ThreadId)
|
|
{
|
|
if (ThreadId == 0)
|
|
{
|
|
ULONG ProcessorId = pEvent->ClientContext & 0x000000FF;
|
|
if (ProcessorId != Thread->ProcessorID)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
if (!Thread->DeadFlag)
|
|
{
|
|
if (Depth > 40) {
|
|
RemoveEntryList( &Thread->Entry );
|
|
InsertHeadList( Head, &Thread->Entry );
|
|
}
|
|
return Thread;
|
|
}
|
|
else if ( Thread->TimeEnd
|
|
== (ULONGLONG) pHeader->TimeStamp.QuadPart)
|
|
{
|
|
if (Depth > 40) {
|
|
RemoveEntryList( &Thread->Entry );
|
|
InsertHeadList( Head, &Thread->Entry );
|
|
}
|
|
return Thread;
|
|
}
|
|
else
|
|
{
|
|
// The alive thead must be at the head of the list
|
|
// otherwise bail
|
|
//
|
|
return NULL;
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
PWORKLOAD_RECORD
|
|
FindWorkloadById(
|
|
ULONG Id
|
|
)
|
|
{
|
|
PLIST_ENTRY Next, Head;
|
|
PWORKLOAD_RECORD Workload = NULL;
|
|
|
|
Head = &CurrentSystem.WorkloadListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
Workload = CONTAINING_RECORD( Next, WORKLOAD_RECORD, Entry );
|
|
if (Workload->ClassNumber == Id) {
|
|
return Workload;
|
|
}
|
|
|
|
Next = Next->Flink;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
BOOLEAN
|
|
AddDisk(
|
|
ULONG DiskNumber,
|
|
PTDISK_RECORD *ReturnedDisk
|
|
)
|
|
{
|
|
PTDISK_RECORD Disk;
|
|
|
|
Disk = malloc(sizeof(TDISK_RECORD));
|
|
if (Disk == NULL) {
|
|
return FALSE;
|
|
}
|
|
InitDiskRecord(Disk, DiskNumber);
|
|
Disk->DiskNumber = DiskNumber;
|
|
|
|
InsertHeadList( &CurrentSystem.GlobalDiskListHead, &Disk->Entry );
|
|
*ReturnedDisk = Disk;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
DeleteDisk(
|
|
PTDISK_RECORD Disk
|
|
)
|
|
{
|
|
PLIST_ENTRY Head, Next;
|
|
PPROCESS_RECORD Process;
|
|
PFILE_RECORD File;
|
|
if (Disk == NULL)
|
|
return FALSE;
|
|
RemoveEntryList( &Disk->Entry );
|
|
|
|
if (Disk->DiskName != NULL)
|
|
free(Disk->DiskName);
|
|
|
|
Head = &Disk->ProcessListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
Process = CONTAINING_RECORD( Next, PROCESS_RECORD, Entry );
|
|
Next = Next->Flink;
|
|
DeleteProcess( Process );
|
|
}
|
|
Head = &Disk->FileListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
File = CONTAINING_RECORD( Next, FILE_RECORD, Entry );
|
|
Next = Next->Flink;
|
|
DeleteFileRecord( File );
|
|
}
|
|
|
|
free( Disk );
|
|
return TRUE;
|
|
}
|
|
|
|
PTDISK_RECORD
|
|
FindLocalDiskById(
|
|
PLIST_ENTRY Head,
|
|
ULONG Id
|
|
)
|
|
{
|
|
PLIST_ENTRY Next;
|
|
PTDISK_RECORD Disk = NULL;
|
|
|
|
if (Head == NULL)
|
|
return NULL;
|
|
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
Disk = CONTAINING_RECORD( Next, TDISK_RECORD, Entry );
|
|
if (Disk->DiskNumber == Id) {
|
|
return Disk;
|
|
}
|
|
Next = Next->Flink;
|
|
}
|
|
|
|
// If not Found, go ahead and add it.
|
|
//
|
|
Disk = malloc(sizeof(TDISK_RECORD));
|
|
if (Disk == NULL) {
|
|
return FALSE;
|
|
}
|
|
InitDiskRecord(Disk, Id);
|
|
|
|
Disk->DiskNumber = Id;
|
|
InsertHeadList( Head, &Disk->Entry );
|
|
return Disk;
|
|
}
|
|
|
|
PTDISK_RECORD
|
|
FindProcessDiskById(
|
|
PPROCESS_RECORD pProcess,
|
|
ULONG Id
|
|
)
|
|
{
|
|
PLIST_ENTRY Next, Head;
|
|
PTDISK_RECORD Disk = NULL;
|
|
|
|
if (pProcess == NULL)
|
|
return NULL;
|
|
|
|
Head = &pProcess->DiskListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
Disk = CONTAINING_RECORD( Next, TDISK_RECORD, Entry );
|
|
if (Disk->DiskNumber == Id) {
|
|
return Disk;
|
|
}
|
|
Next = Next->Flink;
|
|
}
|
|
|
|
// If not Found, go ahead and add it.
|
|
//
|
|
Disk = malloc(sizeof(TDISK_RECORD));
|
|
if (Disk == NULL) {
|
|
return NULL;
|
|
}
|
|
InitDiskRecord(Disk, Id);
|
|
|
|
Disk->DiskNumber = Id;
|
|
InsertHeadList( &pProcess->DiskListHead, &Disk->Entry );
|
|
return Disk;
|
|
}
|
|
|
|
PPROCESS_RECORD
|
|
FindDiskProcessById(
|
|
PTDISK_RECORD pDisk,
|
|
ULONG Id
|
|
)
|
|
{
|
|
PLIST_ENTRY Next, Head;
|
|
PPROCESS_RECORD Process = NULL;
|
|
PPROCESS_RECORD gProcess = NULL;
|
|
|
|
if (pDisk == NULL)
|
|
return NULL;
|
|
|
|
Head = &pDisk->ProcessListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
Process = CONTAINING_RECORD( Next, PROCESS_RECORD, Entry );
|
|
if (Process->PID == Id) {
|
|
return Process;
|
|
}
|
|
Next = Next->Flink;
|
|
}
|
|
|
|
// If not Found, go ahead and add it.
|
|
//
|
|
Process = malloc(sizeof(PROCESS_RECORD));
|
|
if (Process == NULL) {
|
|
return FALSE;
|
|
}
|
|
InitProcessRecord(Process);
|
|
|
|
Process->PID = Id;
|
|
|
|
// Find the global Process Record and copy the UserName and Image.
|
|
//
|
|
gProcess = FindProcessById(Id, FALSE);
|
|
if (gProcess != NULL) {
|
|
if ( IsNotEmpty( gProcess->UserName ) ) {
|
|
Process->UserName = (LPWSTR)malloc( (wcslen(gProcess->UserName) + 1) * sizeof(WCHAR) );
|
|
if (NULL != Process->UserName) {
|
|
StringCchCopyW(Process->UserName, (wcslen(gProcess->UserName) + 1), gProcess->UserName);
|
|
}
|
|
}
|
|
if ( IsNotEmpty( gProcess->ImageName ) ) {
|
|
Process->ImageName = (LPWSTR)malloc( (wcslen(gProcess->ImageName) + 1) * sizeof(WCHAR) );
|
|
if (NULL != Process->ImageName) {
|
|
StringCchCopyW(Process->ImageName, (wcslen(gProcess->ImageName) + 1), gProcess->ImageName);
|
|
}
|
|
}
|
|
}
|
|
InsertHeadList( &pDisk->ProcessListHead, &Process->Entry );
|
|
return Process;
|
|
}
|
|
|
|
PTDISK_RECORD
|
|
FindGlobalDiskById(
|
|
ULONG Id
|
|
)
|
|
{
|
|
PLIST_ENTRY Next, Head;
|
|
PTDISK_RECORD Disk = NULL;
|
|
|
|
Head = &CurrentSystem.GlobalDiskListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
Disk = CONTAINING_RECORD( Next, TDISK_RECORD, Entry );
|
|
if (Disk->DiskNumber == Id) {
|
|
return Disk;
|
|
}
|
|
Next = Next->Flink;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
VOID
|
|
DeleteMofVersion(
|
|
PMOF_VERSION pMofVersion,
|
|
FILE* file
|
|
)
|
|
{
|
|
PLIST_ENTRY Next, Head;
|
|
PITEM_DESC pMofItem;
|
|
|
|
|
|
//
|
|
// Traverse through the MOF_VERSION list and
|
|
// delete each one
|
|
//
|
|
if (pMofVersion == NULL)
|
|
return;
|
|
if( NULL != file ){
|
|
fwprintf( file, L" %s (Type:%d Level:%d Version:%d)\n",
|
|
pMofVersion->strType ? pMofVersion->strType : L"Default",
|
|
pMofVersion->TypeIndex,
|
|
pMofVersion->Level,
|
|
pMofVersion->Version
|
|
);
|
|
}
|
|
Head = &pMofVersion->ItemHeader;
|
|
Next = Head->Flink;
|
|
while (Head != Next) {
|
|
pMofItem = CONTAINING_RECORD(Next, ITEM_DESC, Entry);
|
|
Next = Next->Flink;
|
|
RemoveEntryList( &pMofItem->Entry );
|
|
if (pMofItem->strDescription != NULL){
|
|
if( NULL != file ){
|
|
fwprintf( file, L" %s\n",
|
|
pMofItem->strDescription
|
|
);
|
|
}
|
|
free (pMofItem->strDescription);
|
|
}
|
|
|
|
free (pMofItem);
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
DeleteMofInfo(
|
|
PMOF_INFO pMofInfo,
|
|
FILE* f
|
|
)
|
|
{
|
|
PLIST_ENTRY Next, Head;
|
|
PMOF_VERSION pMofVersion;
|
|
|
|
//
|
|
// Traverse through the MOF_VERSION list and
|
|
// delete each one
|
|
//
|
|
|
|
if (pMofInfo == NULL){
|
|
return;
|
|
}
|
|
|
|
if( NULL != f ){
|
|
WCHAR buffer[MAXSTR];
|
|
fwprintf( f, L"%s\n",
|
|
pMofInfo->strDescription ? pMofInfo->strDescription : CpdiGuidToString( buffer, MAXSTR, &pMofInfo->Guid ) );
|
|
}
|
|
|
|
Head = &pMofInfo->VersionHeader;
|
|
Next = Head->Flink;
|
|
while (Head != Next) {
|
|
pMofVersion = CONTAINING_RECORD(Next, MOF_VERSION, Entry);
|
|
Next = Next->Flink;
|
|
RemoveEntryList( &pMofVersion->Entry );
|
|
|
|
DeleteMofVersion( pMofVersion, f );
|
|
}
|
|
|
|
//
|
|
// Delete any strings allocated for this structure
|
|
//
|
|
if (pMofInfo->strDescription){
|
|
free(pMofInfo->strDescription);
|
|
}
|
|
|
|
//
|
|
// Finally delete the object
|
|
//
|
|
free(pMofInfo);
|
|
}
|
|
|
|
VOID
|
|
Cleanup()
|
|
{
|
|
PTDISK_RECORD Disk;
|
|
PTHREAD_RECORD Thread;
|
|
PPROCESS_RECORD Process;
|
|
PFILE_RECORD FileRec;
|
|
PWORKLOAD_RECORD pWorkload;
|
|
PMODULE_RECORD pModule;
|
|
PTRANS_RECORD pTrans;
|
|
PMOF_INFO pMofInfo;
|
|
PPRINT_JOB_RECORD pJob;
|
|
PHTTP_REQUEST_RECORD pReq;
|
|
PURL_RECORD pUrl;
|
|
PCLIENT_RECORD pClient;
|
|
PSITE_RECORD pSite;
|
|
PLOGICAL_DRIVE_RECORD pLogDrive;
|
|
PVALUEMAP pValueMap;
|
|
|
|
PLIST_ENTRY Next, Head;
|
|
PLIST_ENTRY EventListHead;
|
|
FILE* f = NULL;
|
|
|
|
ULONG i;
|
|
|
|
// Clean up the Global Disk List for now.
|
|
//
|
|
EventListHead = &CurrentSystem.EventListHead;
|
|
Head = EventListHead;
|
|
Next = Head->Flink;
|
|
|
|
if( (TraceContext->Flags & TRACE_INTERPRET) && NULL != TraceContext->CompFileName ){
|
|
f = _wfopen( TraceContext->CompFileName, L"w" );
|
|
}
|
|
|
|
while (Head != Next) {
|
|
pMofInfo = CONTAINING_RECORD(Next, MOF_INFO, Entry);
|
|
Next = Next->Flink;
|
|
RemoveEntryList( &pMofInfo->Entry );
|
|
DeleteMofInfo(pMofInfo, f);
|
|
}
|
|
|
|
if( NULL != f ){
|
|
fclose( f );
|
|
f = NULL;
|
|
}
|
|
|
|
Head = &CurrentSystem.GlobalDiskListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
Disk = CONTAINING_RECORD( Next, TDISK_RECORD, Entry );
|
|
Next = Next->Flink;
|
|
DeleteDisk( Disk );
|
|
}
|
|
|
|
// Clean up the Global Thread List for now.
|
|
//
|
|
Head = &CurrentSystem.GlobalThreadListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
Thread = CONTAINING_RECORD( Next, THREAD_RECORD, Entry );
|
|
Next = Next->Flink;
|
|
DeleteThread( Thread );
|
|
}
|
|
Head = &CurrentSystem.ProcessListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
Process = CONTAINING_RECORD( Next, PROCESS_RECORD, Entry );
|
|
Next = Next->Flink;
|
|
DeleteProcess( Process );
|
|
}
|
|
Head = &CurrentSystem.GlobalModuleListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head)
|
|
{
|
|
pModule = CONTAINING_RECORD(Next, MODULE_RECORD, Entry);
|
|
Next = Next->Flink;
|
|
RemoveEntryList(& pModule->Entry);
|
|
if(pModule->strModuleName)
|
|
{
|
|
free(pModule->strModuleName);
|
|
}
|
|
free(pModule);
|
|
}
|
|
|
|
Head = &CurrentSystem.HotFileListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
FileRec = CONTAINING_RECORD( Next, FILE_RECORD, Entry );
|
|
Next = Next->Flink;
|
|
DeleteFileRecord( FileRec );
|
|
}
|
|
// Cleanup workload structures
|
|
//
|
|
Head = &CurrentSystem.WorkloadListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
pWorkload = CONTAINING_RECORD( Next, WORKLOAD_RECORD, Entry );
|
|
Next = Next->Flink;
|
|
DeleteWorkloadRecord( pWorkload );
|
|
}
|
|
//
|
|
// Cleanup the Print Job List structures
|
|
//
|
|
Head = &CurrentSystem.PrintJobListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
pJob = CONTAINING_RECORD( Next, PRINT_JOB_RECORD, Entry );
|
|
Next = Next->Flink;
|
|
RemoveEntryList(&pJob->Entry);
|
|
free(pJob);
|
|
}
|
|
//
|
|
// Cleanup the Http Request List structures
|
|
//
|
|
Head = &CurrentSystem.HttpReqListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
pReq = CONTAINING_RECORD( Next, HTTP_REQUEST_RECORD, Entry );
|
|
Next = Next->Flink;
|
|
RemoveEntryList(&pReq->Entry);
|
|
if (pReq->URL != NULL) {
|
|
free(pReq->URL);
|
|
}
|
|
free(pReq);
|
|
}
|
|
//
|
|
// Cleanup the Pending Http Request List structures
|
|
//
|
|
Head = &CurrentSystem.PendingHttpReqListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
pReq = CONTAINING_RECORD( Next, HTTP_REQUEST_RECORD, Entry );
|
|
Next = Next->Flink;
|
|
RemoveEntryList(&pReq->Entry);
|
|
if (pReq->URL != NULL) {
|
|
free(pReq->URL);
|
|
}
|
|
free(pReq);
|
|
}
|
|
//
|
|
// Cleanup the URL List structures
|
|
//
|
|
for (i = 0; i < URL_HASH_TABLESIZE; i++) {
|
|
Head = &CurrentSystem.URLHashList[i];
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
pUrl = CONTAINING_RECORD( Next, URL_RECORD, Entry );
|
|
Next = Next->Flink;
|
|
RemoveEntryList(&pUrl->Entry);
|
|
free(pUrl);
|
|
}
|
|
}
|
|
//
|
|
// Cleanup the Client List structures
|
|
//
|
|
Head = &CurrentSystem.ClientListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
pClient = CONTAINING_RECORD( Next, CLIENT_RECORD, Entry );
|
|
Next = Next->Flink;
|
|
RemoveEntryList(&pClient->Entry);
|
|
free(pClient);
|
|
}
|
|
//
|
|
// Cleanup the Site List structures
|
|
//
|
|
Head = &CurrentSystem.SiteListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
pSite = CONTAINING_RECORD( Next, SITE_RECORD, Entry );
|
|
Next = Next->Flink;
|
|
RemoveEntryList(&pSite->Entry);
|
|
free(pSite);
|
|
}
|
|
//
|
|
// Cleanup the Logical Drive structures
|
|
//
|
|
Head = &CurrentSystem.LogicalDriveHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
pLogDrive = CONTAINING_RECORD( Next, LOGICAL_DRIVE_RECORD, Entry );
|
|
Next = Next->Flink;
|
|
RemoveEntryList(&pLogDrive->Entry);
|
|
if (NULL != pLogDrive->DriveLetterString) {
|
|
free(pLogDrive->DriveLetterString);
|
|
}
|
|
free(pLogDrive);
|
|
}
|
|
|
|
//
|
|
// Clean up recyled memory structures
|
|
//
|
|
Head = &CurrentSystem.FreePrintJobListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
pJob = CONTAINING_RECORD( Next, PRINT_JOB_RECORD, Entry );
|
|
Next = Next->Flink;
|
|
RemoveEntryList(&pJob->Entry);
|
|
free(pJob);
|
|
}
|
|
Head = &CurrentSystem.FreeTransListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
pTrans = CONTAINING_RECORD( Next, TRANS_RECORD, Entry );
|
|
Next = Next->Flink;
|
|
RemoveEntryList(&pTrans->Entry);
|
|
free(pTrans);
|
|
}
|
|
Head = &CurrentSystem.FreeHttpReqListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
pReq = CONTAINING_RECORD( Next, HTTP_REQUEST_RECORD, Entry );
|
|
Next = Next->Flink;
|
|
RemoveEntryList(&pReq->Entry);
|
|
free(pReq);
|
|
}
|
|
Head = &CurrentSystem.FreeURLListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
pUrl = CONTAINING_RECORD( Next, URL_RECORD, Entry );
|
|
Next = Next->Flink;
|
|
RemoveEntryList(&pUrl->Entry);
|
|
free(pUrl);
|
|
}
|
|
|
|
Head = &g_ValueMapTable;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
pValueMap = CONTAINING_RECORD( Next, VALUEMAP, Entry );
|
|
Next = Next->Flink;
|
|
RemoveEntryList(&pValueMap->Entry);
|
|
if( NULL != pValueMap->saValueMap ){
|
|
SafeArrayDestroy( pValueMap->saValueMap );
|
|
}
|
|
if( NULL != pValueMap->saValues ){
|
|
SafeArrayDestroy( pValueMap->saValues );
|
|
}
|
|
|
|
free( pValueMap );
|
|
}
|
|
}
|
|
|
|
PLOGICAL_DRIVE_RECORD
|
|
FindLogicalDrive(
|
|
ULONGLONG AccessedOffset,
|
|
ULONG DiskNumber
|
|
)
|
|
{
|
|
PLOGICAL_DRIVE_RECORD pLogDrive = NULL;
|
|
PLIST_ENTRY Next, Head;
|
|
|
|
EnterTracelibCritSection();
|
|
// Find drive letter when logical drive info is available.
|
|
Head = &CurrentSystem.LogicalDriveHead;
|
|
Next = Head->Flink;
|
|
if (Next != Head) {
|
|
while (Next != Head) {
|
|
pLogDrive = CONTAINING_RECORD( Next, LOGICAL_DRIVE_RECORD, Entry );
|
|
if (DiskNumber == pLogDrive->DiskNumber &&
|
|
AccessedOffset < pLogDrive->StartOffset &&
|
|
Next->Blink != Head) {
|
|
pLogDrive = CONTAINING_RECORD( Next->Blink, LOGICAL_DRIVE_RECORD, Entry );
|
|
break;
|
|
}
|
|
Next = Next->Flink;
|
|
}
|
|
}
|
|
LeaveTracelibCritSection();
|
|
if (NULL != pLogDrive && DiskNumber == pLogDrive->DiskNumber) {
|
|
return pLogDrive;
|
|
}
|
|
else {
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
BOOLEAN
|
|
AddFile(
|
|
WCHAR* fileName,
|
|
PFILE_RECORD *ReturnedFile,
|
|
PLOGICAL_DRIVE_RECORD pLogDrive
|
|
)
|
|
{
|
|
PFILE_RECORD fileRec;
|
|
PLIST_ENTRY Next, Head;
|
|
|
|
if (fileName == NULL)
|
|
return FALSE;
|
|
|
|
fileRec = malloc(sizeof(FILE_RECORD));
|
|
if (fileRec == NULL) {
|
|
return FALSE;
|
|
}
|
|
InitFileRecord( fileRec );
|
|
fileRec->FileName = malloc( (lstrlenW(fileName)+ 1) * sizeof(WCHAR));
|
|
if (fileRec->FileName != NULL) {
|
|
StringCchCopyW(fileRec->FileName, (lstrlenW(fileName)+ 1), fileName);
|
|
}
|
|
if (NULL != pLogDrive) {
|
|
fileRec->DiskNumber = pLogDrive->DiskNumber;
|
|
if (NULL != pLogDrive->DriveLetterString) {
|
|
fileRec->Drive = malloc( (lstrlenW(pLogDrive->DriveLetterString)+ 1) * sizeof(WCHAR));
|
|
if (fileRec->Drive != NULL) {
|
|
StringCchCopyW(fileRec->Drive, lstrlenW(pLogDrive->DriveLetterString)+ 1, pLogDrive->DriveLetterString);
|
|
}
|
|
}
|
|
}
|
|
EnterTracelibCritSection();
|
|
InsertHeadList( &CurrentSystem.HotFileListHead, &fileRec->Entry );
|
|
LeaveTracelibCritSection();
|
|
*ReturnedFile = fileRec;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOLEAN
|
|
DeleteFileRecord(
|
|
PFILE_RECORD fileRec
|
|
)
|
|
{
|
|
PLIST_ENTRY Next, Head;
|
|
PPROTO_PROCESS_RECORD pProto;
|
|
|
|
if (fileRec == NULL)
|
|
return FALSE;
|
|
|
|
EnterTracelibCritSection();
|
|
RemoveEntryList( &fileRec->Entry );
|
|
LeaveTracelibCritSection();
|
|
|
|
if (fileRec->FileName != NULL)
|
|
free(fileRec->FileName);
|
|
if (fileRec->Drive != NULL)
|
|
free(fileRec->Drive);
|
|
|
|
Head = &fileRec->ProtoProcessListHead;
|
|
Next = Head->Flink;
|
|
while (Head != Next) {
|
|
pProto = CONTAINING_RECORD( Next, PROTO_PROCESS_RECORD, Entry);
|
|
Next = Next->Flink;
|
|
RemoveEntryList( &pProto->Entry );
|
|
free(pProto);
|
|
}
|
|
free( fileRec );
|
|
return TRUE;
|
|
}
|
|
|
|
PFILE_RECORD
|
|
FindFileRecordByName(
|
|
WCHAR* fileName,
|
|
PLOGICAL_DRIVE_RECORD pLogDrive
|
|
)
|
|
{
|
|
PLIST_ENTRY Next, Head;
|
|
PFILE_RECORD fileRec = NULL;
|
|
|
|
if (fileName == NULL)
|
|
return NULL;
|
|
EnterTracelibCritSection();
|
|
Head = &CurrentSystem.HotFileListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
fileRec = CONTAINING_RECORD( Next, FILE_RECORD, Entry );
|
|
if (!wcscmp(fileName, fileRec->FileName)) {
|
|
if (NULL != pLogDrive && pLogDrive->DiskNumber == fileRec->DiskNumber) {
|
|
if (NULL != pLogDrive->DriveLetterString &&
|
|
NULL != fileRec->Drive &&
|
|
!wcscmp(pLogDrive->DriveLetterString, fileRec->Drive)) {
|
|
LeaveTracelibCritSection();
|
|
return fileRec;
|
|
}
|
|
else if (NULL == pLogDrive->DriveLetterString &&
|
|
NULL == fileRec->Drive) {
|
|
LeaveTracelibCritSection();
|
|
return fileRec;
|
|
}
|
|
}
|
|
else if (NULL == pLogDrive) {
|
|
LeaveTracelibCritSection();
|
|
return fileRec;
|
|
}
|
|
}
|
|
Next = Next->Flink;
|
|
}
|
|
LeaveTracelibCritSection();
|
|
return NULL;
|
|
}
|
|
|
|
PFILE_RECORD
|
|
FindFileInProcess(
|
|
PPROCESS_RECORD pProcess,
|
|
WCHAR* fileName
|
|
)
|
|
{
|
|
PLIST_ENTRY Next, Head;
|
|
PFILE_RECORD fileRec = NULL;
|
|
if (pProcess == NULL || fileName == NULL)
|
|
return NULL;
|
|
EnterTracelibCritSection();
|
|
Head = &pProcess->FileListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
fileRec = CONTAINING_RECORD( Next, FILE_RECORD, Entry );
|
|
if (!wcscmp(fileName, fileRec->FileName)) {
|
|
//ReleaseMutex(CurrentSystem.HotFileListMutex);
|
|
LeaveTracelibCritSection();
|
|
return fileRec;
|
|
}
|
|
Next = Next->Flink;
|
|
}
|
|
LeaveTracelibCritSection();
|
|
return NULL;
|
|
}
|
|
|
|
VOID
|
|
AddLogicalDrive(
|
|
ULONGLONG StartOffset,
|
|
ULONGLONG PartitionSize,
|
|
ULONG DiskNumber,
|
|
ULONG Size,
|
|
ULONG DriveType,
|
|
PWCHAR DriveLetterString
|
|
)
|
|
{
|
|
PLOGICAL_DRIVE_RECORD pLogDrive = NULL, pTempLogDrive = NULL;
|
|
PLIST_ENTRY Next, Head;
|
|
|
|
pLogDrive = malloc(sizeof(LOGICAL_DRIVE_RECORD));
|
|
if (pLogDrive == NULL) {
|
|
SetLastError(ERROR_OUTOFMEMORY);
|
|
return;
|
|
}
|
|
|
|
RtlZeroMemory(pLogDrive, sizeof(LOGICAL_DRIVE_RECORD));
|
|
pLogDrive->StartOffset = StartOffset;
|
|
pLogDrive->PartitionSize = PartitionSize;
|
|
pLogDrive->DiskNumber = DiskNumber;
|
|
pLogDrive->Size = Size;
|
|
pLogDrive->DriveType = DriveType;
|
|
if (DriveLetterString != NULL) {
|
|
pLogDrive->DriveLetterString = malloc( (lstrlenW(DriveLetterString)+ 1) * sizeof(WCHAR));
|
|
if (pLogDrive->DriveLetterString != NULL) {
|
|
StringCchCopyW(pLogDrive->DriveLetterString, lstrlenW(DriveLetterString)+ 1, DriveLetterString);
|
|
}
|
|
}
|
|
EnterTracelibCritSection();
|
|
// When inserting logical drives, do it in StartOffset order.
|
|
Head = &CurrentSystem.LogicalDriveHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
pTempLogDrive = CONTAINING_RECORD( Next, LOGICAL_DRIVE_RECORD, Entry );
|
|
if (pLogDrive->StartOffset < pTempLogDrive->StartOffset) {
|
|
break;
|
|
}
|
|
Next = Next->Flink;
|
|
}
|
|
InsertTailList( Next, &pLogDrive->Entry );
|
|
LeaveTracelibCritSection();
|
|
|
|
}
|
|
|
|
VOID
|
|
AssignClass(
|
|
PPROCESS_RECORD pProcess,
|
|
PTHREAD_RECORD pThread
|
|
)
|
|
{
|
|
UNREFERENCED_PARAMETER(pProcess);
|
|
|
|
pThread->ClassNumber = 1; // For the Time being make it single class.
|
|
}
|
|
|
|
VOID
|
|
Classify()
|
|
{
|
|
// Assign Class to each Thread or Process.
|
|
//
|
|
PLIST_ENTRY Head, Next;
|
|
PTHREAD_RECORD pThread;
|
|
|
|
Head = &CurrentSystem.GlobalThreadListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
pThread = CONTAINING_RECORD( Next, THREAD_RECORD, Entry );
|
|
|
|
AssignClass(NULL, pThread);
|
|
|
|
Aggregate(pThread);
|
|
|
|
Next = Next->Flink;
|
|
}
|
|
}
|
|
|
|
// Given the number of classes this routine
|
|
// creates and initializes the workload object
|
|
//
|
|
VOID
|
|
InitClass()
|
|
{
|
|
PWORKLOAD_RECORD pWorkload;
|
|
ULONG nclass;
|
|
ULONG i;
|
|
|
|
// Create the Class records here.
|
|
//
|
|
nclass = 1;
|
|
CurrentSystem.NumberOfWorkloads = 1;
|
|
for (i = 1; i <= nclass; i++) {
|
|
|
|
pWorkload = malloc(sizeof(WORKLOAD_RECORD));
|
|
if (pWorkload == NULL) {
|
|
return;
|
|
}
|
|
InitWorkloadRecord( pWorkload );
|
|
pWorkload->ClassNumber = i;
|
|
InsertHeadList( &CurrentSystem.WorkloadListHead, &pWorkload->Entry );
|
|
}
|
|
}
|
|
|
|
PTDISK_RECORD
|
|
FindDiskInList(
|
|
IN PLIST_ENTRY Head,
|
|
IN ULONG Id
|
|
)
|
|
{
|
|
PLIST_ENTRY Next;
|
|
PTDISK_RECORD pDisk = NULL;
|
|
|
|
if (Head != NULL) {
|
|
|
|
Next = Head->Flink;
|
|
|
|
while (Next != Head) {
|
|
pDisk = CONTAINING_RECORD ( Next, TDISK_RECORD, Entry );
|
|
if (pDisk->DiskNumber == Id) {
|
|
return pDisk;
|
|
}
|
|
Next = Next->Flink;
|
|
}
|
|
|
|
pDisk = malloc(sizeof(TDISK_RECORD));
|
|
if (pDisk == NULL) {
|
|
return NULL;
|
|
}
|
|
InitDiskRecord( pDisk, Id );
|
|
|
|
InsertHeadList( Head, &pDisk->Entry );
|
|
}
|
|
return pDisk;
|
|
}
|
|
|
|
VOID
|
|
Aggregate(
|
|
IN PTHREAD_RECORD pThread
|
|
)
|
|
{
|
|
PWORKLOAD_RECORD pWorkload;
|
|
PTDISK_RECORD pDisk, pClassDisk;
|
|
PLIST_ENTRY Next, Head;
|
|
|
|
// Aggregate the metrics over each class.
|
|
//
|
|
if ((pWorkload = FindWorkloadById(pThread->ClassNumber)) != NULL) {
|
|
pWorkload->UserCPU += (pThread->UCPUEnd - pThread->UCPUStart)
|
|
* CurrentSystem.TimerResolution;
|
|
pWorkload->KernelCPU += (pThread->KCPUEnd - pThread->KCPUStart)
|
|
* CurrentSystem.TimerResolution;
|
|
//
|
|
// Walk through the Thread Disk records and aggregate them
|
|
// to the class
|
|
|
|
Head = &pThread->DiskListHead;
|
|
Next = Head->Flink;
|
|
while (Next != Head) {
|
|
pDisk = CONTAINING_RECORD( Next, TDISK_RECORD, Entry );
|
|
Next = Next->Flink;
|
|
|
|
pClassDisk = FindDiskInList(&pWorkload->DiskListHead,
|
|
pDisk->DiskNumber) ;
|
|
if (pClassDisk != NULL) {
|
|
pClassDisk->ReadCount += pDisk->ReadCount;
|
|
pClassDisk->WriteCount += pDisk->WriteCount;
|
|
pClassDisk->ReadSize += (pDisk->ReadCount * pDisk->ReadSize);
|
|
pClassDisk->WriteSize += (pDisk->WriteCount * pDisk->WriteSize);
|
|
|
|
pWorkload->ReadCount += pDisk->ReadCount;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ULONGLONG
|
|
CalculateProcessLifeTime(
|
|
PPROCESS_RECORD pProcess
|
|
)
|
|
{
|
|
BOOLEAN fFirst = TRUE;
|
|
ULONGLONG TimeStart = 0;
|
|
ULONGLONG TimeEnd = 0;
|
|
PLIST_ENTRY pHead = &pProcess->ThreadListHead;
|
|
PLIST_ENTRY pNext = pHead->Flink;
|
|
PTHREAD_RECORD pThread;
|
|
|
|
while (pNext != pHead)
|
|
{
|
|
pThread = CONTAINING_RECORD(pNext, THREAD_RECORD, Entry);
|
|
pNext = pNext->Flink;
|
|
|
|
if (fFirst)
|
|
{
|
|
TimeStart = pThread->TimeStart;
|
|
TimeEnd = pThread->TimeEnd;
|
|
fFirst = FALSE;
|
|
}
|
|
else if (pThread->TimeStart < TimeStart)
|
|
{
|
|
TimeStart = pThread->TimeStart;
|
|
}
|
|
else if (pThread->TimeEnd > TimeEnd)
|
|
{
|
|
TimeEnd = pThread->TimeEnd;
|
|
}
|
|
}
|
|
return (TimeEnd - TimeStart);
|
|
}
|
|
|
|
ULONG
|
|
CalculateProcessKCPU(
|
|
PPROCESS_RECORD pProcess
|
|
)
|
|
{
|
|
ULONG KCPUTotal = 0;
|
|
ULONG KCPUMissing = 0;
|
|
PLIST_ENTRY pHead = &pProcess->ThreadListHead;
|
|
PLIST_ENTRY pNext = pHead->Flink;
|
|
PTHREAD_RECORD pThread;
|
|
|
|
while (pNext != pHead)
|
|
{
|
|
pThread = CONTAINING_RECORD(pNext, THREAD_RECORD, Entry);
|
|
pNext = pNext->Flink;
|
|
|
|
if (pThread->KCPUEnd > pThread->KCPUStart)
|
|
{
|
|
|
|
if ((pProcess->PID != 0) ||
|
|
((pProcess->PID == 0) && (pThread->TID == 0)) ){
|
|
|
|
KCPUTotal += pThread->KCPUEnd - pThread->KCPUStart;
|
|
}
|
|
else {
|
|
KCPUMissing += pThread->KCPUEnd - pThread->KCPUStart;
|
|
}
|
|
}
|
|
}
|
|
return (ULONG) (KCPUTotal * CurrentSystem.TimerResolution);
|
|
}
|
|
|
|
ULONG
|
|
CalculateProcessUCPU(
|
|
PPROCESS_RECORD pProcess
|
|
)
|
|
{
|
|
ULONG UCPUTotal = 0;
|
|
ULONG UCPUMissing = 0;
|
|
PLIST_ENTRY pHead = &pProcess->ThreadListHead;
|
|
PLIST_ENTRY pNext = pHead->Flink;
|
|
PTHREAD_RECORD pThread;
|
|
|
|
|
|
while (pNext != pHead)
|
|
{
|
|
pThread = CONTAINING_RECORD(pNext, THREAD_RECORD, Entry);
|
|
pNext = pNext->Flink;
|
|
|
|
if (pThread->UCPUEnd > pThread->UCPUStart)
|
|
{
|
|
if ((pProcess->PID != 0) ||
|
|
((pProcess->PID == 0) && (pThread->TID == 0)) ) {
|
|
UCPUTotal += pThread->UCPUEnd - pThread->UCPUStart;
|
|
}
|
|
else {
|
|
UCPUMissing += pThread->UCPUEnd - pThread->UCPUStart;
|
|
}
|
|
}
|
|
}
|
|
return (ULONG) (UCPUTotal * CurrentSystem.TimerResolution);
|
|
}
|
|
|
|
PPRINT_JOB_RECORD
|
|
FindPrintJobRecord(
|
|
ULONG JobId
|
|
)
|
|
{
|
|
PLIST_ENTRY Head, Next;
|
|
PPRINT_JOB_RECORD pJob;
|
|
|
|
EnterTracelibCritSection();
|
|
Head = &CurrentSystem.PrintJobListHead;
|
|
|
|
Next = Head->Flink;
|
|
|
|
while (Next != Head) {
|
|
pJob = CONTAINING_RECORD ( Next, PRINT_JOB_RECORD, Entry );
|
|
if (pJob->JobId == JobId) {
|
|
LeaveTracelibCritSection();
|
|
return pJob;
|
|
}
|
|
Next = Next->Flink;
|
|
}
|
|
LeaveTracelibCritSection();
|
|
|
|
return NULL;
|
|
}
|
|
|
|
PHTTP_REQUEST_RECORD
|
|
FindHttpReqRecord(
|
|
ULONGLONG RequestId
|
|
)
|
|
{
|
|
PLIST_ENTRY Head, Next;
|
|
PHTTP_REQUEST_RECORD pReq;
|
|
ULONG Depth = 0;
|
|
|
|
EnterTracelibCritSection();
|
|
Head = &CurrentSystem.HttpReqListHead;
|
|
|
|
Next = Head->Flink;
|
|
|
|
while (Next != Head) {
|
|
pReq = CONTAINING_RECORD ( Next, HTTP_REQUEST_RECORD, Entry );
|
|
if (pReq->RequestId == RequestId) {
|
|
if (Depth > 40) {
|
|
RemoveEntryList( &pReq->Entry );
|
|
InsertHeadList( Head, &pReq->Entry );
|
|
}
|
|
LeaveTracelibCritSection();
|
|
return pReq;
|
|
}
|
|
Next = Next->Flink;
|
|
Depth++;
|
|
}
|
|
LeaveTracelibCritSection();
|
|
|
|
return NULL;
|
|
}
|
|
|
|
PHTTP_REQUEST_RECORD
|
|
FindHttpReqRecordByConId(
|
|
ULONGLONG ConId,
|
|
PHTTP_REQUEST_RECORD pPrevReq
|
|
)
|
|
{
|
|
PLIST_ENTRY Head, Next;
|
|
PHTTP_REQUEST_RECORD pReq;
|
|
ULONG Depth = 0;
|
|
|
|
EnterTracelibCritSection();
|
|
|
|
Head = &CurrentSystem.HttpReqListHead;
|
|
Next = Head->Flink;
|
|
|
|
while (Next != Head) {
|
|
pReq = CONTAINING_RECORD ( Next, HTTP_REQUEST_RECORD, Entry );
|
|
if (pReq->ConId == ConId) {
|
|
if (pPrevReq == NULL || pPrevReq != pReq) {
|
|
if (Depth > 40) {
|
|
RemoveEntryList( &pReq->Entry );
|
|
InsertHeadList( Head, &pReq->Entry );
|
|
}
|
|
LeaveTracelibCritSection();
|
|
return pReq;
|
|
}
|
|
}
|
|
Next = Next->Flink;
|
|
Depth++;
|
|
}
|
|
|
|
Depth = 0;
|
|
Head = &CurrentSystem.PendingHttpReqListHead;
|
|
Next = Head->Flink;
|
|
|
|
while (Next != Head) {
|
|
pReq = CONTAINING_RECORD ( Next, HTTP_REQUEST_RECORD, Entry );
|
|
if (pReq->ConId == ConId) {
|
|
if (pPrevReq == NULL || pPrevReq != pReq) {
|
|
if (Depth > 40) {
|
|
RemoveEntryList( &pReq->Entry );
|
|
InsertHeadList( Head, &pReq->Entry );
|
|
}
|
|
LeaveTracelibCritSection();
|
|
return pReq;
|
|
}
|
|
}
|
|
Next = Next->Flink;
|
|
Depth++;
|
|
}
|
|
|
|
LeaveTracelibCritSection();
|
|
|
|
return NULL;
|
|
}
|
|
|
|
PHTTP_REQUEST_RECORD
|
|
FindPendingHttpReqRecord(
|
|
ULONGLONG RequestId
|
|
)
|
|
{
|
|
PLIST_ENTRY Head, Next;
|
|
PHTTP_REQUEST_RECORD pReq;
|
|
ULONG Depth = 0;
|
|
|
|
EnterTracelibCritSection();
|
|
Head = &CurrentSystem.PendingHttpReqListHead;
|
|
|
|
Next = Head->Flink;
|
|
|
|
while (Next != Head) {
|
|
pReq = CONTAINING_RECORD ( Next, HTTP_REQUEST_RECORD, Entry );
|
|
if (pReq->RequestId == RequestId) {
|
|
if (Depth > 40) {
|
|
RemoveEntryList( &pReq->Entry );
|
|
InsertHeadList( Head, &pReq->Entry );
|
|
}
|
|
LeaveTracelibCritSection();
|
|
return pReq;
|
|
}
|
|
Next = Next->Flink;
|
|
Depth++;
|
|
}
|
|
LeaveTracelibCritSection();
|
|
|
|
return NULL;
|
|
}
|
|
|
|
PURL_RECORD
|
|
FindUrlRecord(
|
|
PUCHAR Url
|
|
)
|
|
{
|
|
PLIST_ENTRY Head, Next;
|
|
PURL_RECORD pUrl;
|
|
ULONG Depth = 0;
|
|
ULONG UrlStrSize;
|
|
PUCHAR UrlChar;
|
|
BOOL bMatch;
|
|
UCHAR TempEndChar;
|
|
USHORT HashKey;
|
|
|
|
if (Url == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
UrlStrSize = 0;
|
|
UrlChar = Url;
|
|
while (*UrlChar != '\0' && *UrlChar != '?') {
|
|
UrlStrSize++;
|
|
UrlChar++;
|
|
}
|
|
|
|
// No URL will end with '/'
|
|
if (*(UrlChar - 1) == '/') {
|
|
UrlStrSize--;
|
|
}
|
|
TempEndChar = *(Url + UrlStrSize);
|
|
*(Url + UrlStrSize) = '\0';
|
|
HashKey = UrlHashKey(Url, UrlStrSize);
|
|
|
|
EnterTracelibCritSection();
|
|
Head = &CurrentSystem.URLHashList[HashKey];
|
|
|
|
Next = Head->Flink;
|
|
|
|
while (Next != Head) {
|
|
|
|
pUrl = CONTAINING_RECORD ( Next, URL_RECORD, Entry );
|
|
// pUrl->URL cannot be NULL. If it is, it shouldn't even be created.
|
|
|
|
if ( _stricmp( Url, pUrl->URL ) == 0 ) {
|
|
if (Depth > 20) {
|
|
RemoveEntryList( &pUrl->Entry );
|
|
InsertHeadList( Head, &pUrl->Entry );
|
|
}
|
|
LeaveTracelibCritSection();
|
|
return pUrl;
|
|
}
|
|
Next = Next->Flink;
|
|
Depth++;
|
|
}
|
|
LeaveTracelibCritSection();
|
|
|
|
*(Url + UrlStrSize) = TempEndChar;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
PCLIENT_RECORD
|
|
FindClientRecord(
|
|
USHORT IpAddrType,
|
|
ULONG IpAddrV4,
|
|
USHORT *IpAddrV6
|
|
)
|
|
{
|
|
PLIST_ENTRY Head, Next;
|
|
PCLIENT_RECORD pClient;
|
|
|
|
if (IpAddrV6 == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
EnterTracelibCritSection();
|
|
Head = &CurrentSystem.ClientListHead;
|
|
|
|
Next = Head->Flink;
|
|
|
|
while (Next != Head) {
|
|
pClient = CONTAINING_RECORD ( Next, CLIENT_RECORD, Entry );
|
|
if (pClient->IpAddrType == IpAddrType &&
|
|
pClient->IpAddrV4 == IpAddrV4 &&
|
|
RtlCompareMemory(IpAddrV6, pClient->IpAddrV6, sizeof(USHORT) * 8) == sizeof(USHORT) * 8) {
|
|
LeaveTracelibCritSection();
|
|
return pClient;
|
|
}
|
|
Next = Next->Flink;
|
|
}
|
|
LeaveTracelibCritSection();
|
|
|
|
return NULL;
|
|
}
|
|
|
|
PSITE_RECORD
|
|
FindSiteRecord(
|
|
ULONG SiteId
|
|
)
|
|
{
|
|
PLIST_ENTRY Head, Next;
|
|
PSITE_RECORD pSite;
|
|
|
|
EnterTracelibCritSection();
|
|
Head = &CurrentSystem.SiteListHead;
|
|
|
|
Next = Head->Flink;
|
|
|
|
while (Next != Head) {
|
|
pSite = CONTAINING_RECORD ( Next, SITE_RECORD, Entry );
|
|
if (pSite->SiteId == SiteId) {
|
|
LeaveTracelibCritSection();
|
|
return pSite;
|
|
}
|
|
Next = Next->Flink;
|
|
}
|
|
LeaveTracelibCritSection();
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// A New Job with a JobId has been found. This routine will create a
|
|
// new job record to track it through various threads in the system
|
|
//
|
|
|
|
PPRINT_JOB_RECORD
|
|
AddPrintJobRecord(
|
|
ULONG JobId
|
|
)
|
|
{
|
|
PLIST_ENTRY Head, Next;
|
|
PPRINT_JOB_RECORD pJob = NULL;
|
|
|
|
EnterTracelibCritSection();
|
|
Head = &CurrentSystem.FreePrintJobListHead;
|
|
|
|
Next = Head->Flink;
|
|
|
|
if (Next != Head) {
|
|
pJob = CONTAINING_RECORD ( Next, PRINT_JOB_RECORD, Entry );
|
|
RemoveEntryList( &pJob->Entry );
|
|
}
|
|
LeaveTracelibCritSection();
|
|
|
|
if (pJob == NULL) {
|
|
pJob = malloc(sizeof(PRINT_JOB_RECORD));
|
|
if (pJob == NULL) {
|
|
SetLastError( ERROR_OUTOFMEMORY);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
RtlZeroMemory(pJob, sizeof(PRINT_JOB_RECORD));
|
|
pJob->JobId = JobId;
|
|
|
|
EnterTracelibCritSection();
|
|
InsertHeadList( &CurrentSystem.PrintJobListHead, &pJob->Entry );
|
|
LeaveTracelibCritSection();
|
|
|
|
return pJob;
|
|
}
|
|
|
|
PHTTP_REQUEST_RECORD
|
|
AddHttpReqRecord(
|
|
ULONGLONG RequestId,
|
|
USHORT IpAddrType,
|
|
ULONG IpAddrV4,
|
|
USHORT *IpAddrV6
|
|
)
|
|
{
|
|
PLIST_ENTRY Head, Next;
|
|
PHTTP_REQUEST_RECORD pReq = NULL;
|
|
|
|
EnterTracelibCritSection();
|
|
Head = &CurrentSystem.FreeHttpReqListHead;
|
|
|
|
Next = Head->Flink;
|
|
|
|
if (Next != Head) {
|
|
pReq = CONTAINING_RECORD ( Next, HTTP_REQUEST_RECORD, Entry );
|
|
RemoveEntryList( &pReq->Entry );
|
|
}
|
|
LeaveTracelibCritSection();
|
|
|
|
if (pReq == NULL) {
|
|
pReq = malloc(sizeof(HTTP_REQUEST_RECORD));
|
|
if (pReq == NULL) {
|
|
SetLastError(ERROR_OUTOFMEMORY);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
RtlZeroMemory(pReq, sizeof(HTTP_REQUEST_RECORD));
|
|
pReq->RequestId = RequestId;
|
|
pReq->IpAddrType = IpAddrType;
|
|
pReq->IpAddrV4 = IpAddrV4;
|
|
if (IpAddrV6 != NULL && IpAddrType == TDI_ADDRESS_TYPE_IP6) {
|
|
RtlCopyMemory(&pReq->IpAddrV6, IpAddrV6, sizeof(USHORT) * 8);
|
|
}
|
|
|
|
EnterTracelibCritSection();
|
|
InsertHeadList( &CurrentSystem.HttpReqListHead, &pReq->Entry );
|
|
LeaveTracelibCritSection();
|
|
|
|
return pReq;
|
|
}
|
|
|
|
PURL_RECORD
|
|
AddUrlRecord(
|
|
PUCHAR Url
|
|
)
|
|
{
|
|
PLIST_ENTRY Head, Next;
|
|
PUCHAR UrlStr = NULL, UrlChar;
|
|
PURL_RECORD pUrl = NULL;
|
|
ULONG UrlStrSize;
|
|
USHORT HashKey;
|
|
|
|
if (Url == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
EnterTracelibCritSection();
|
|
Head = &CurrentSystem.FreeURLListHead;
|
|
|
|
Next = Head->Flink;
|
|
|
|
if (Next != Head) {
|
|
pUrl = CONTAINING_RECORD ( Next, URL_RECORD, Entry );
|
|
RemoveEntryList( &pUrl->Entry );
|
|
}
|
|
LeaveTracelibCritSection();
|
|
|
|
if (pUrl == NULL) {
|
|
pUrl = malloc(sizeof(URL_RECORD));
|
|
if (pUrl == NULL) {
|
|
SetLastError(ERROR_OUTOFMEMORY);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
UrlStrSize = 0;
|
|
UrlChar = Url;
|
|
while (*UrlChar != '\0' && *UrlChar != '?') {
|
|
UrlStrSize++;
|
|
UrlChar++;
|
|
}
|
|
|
|
// No URL will end with '/'
|
|
if (*(UrlChar - 1) == '/') {
|
|
*(UrlChar - 1) = '\0';
|
|
UrlStrSize--;
|
|
}
|
|
|
|
RtlZeroMemory(pUrl, sizeof(URL_RECORD));
|
|
pUrl->URL = (PUCHAR)malloc(UrlStrSize + 1);
|
|
if (pUrl->URL == NULL) {
|
|
EnterTracelibCritSection();
|
|
InsertHeadList( &CurrentSystem.FreeURLListHead, &pUrl->Entry );
|
|
LeaveTracelibCritSection();
|
|
return NULL;
|
|
}
|
|
strncpy(pUrl->URL, Url, UrlStrSize);
|
|
*(pUrl->URL + UrlStrSize) = '\0';
|
|
HashKey = UrlHashKey(pUrl->URL, UrlStrSize);
|
|
EnterTracelibCritSection();
|
|
InsertHeadList( &CurrentSystem.URLHashList[HashKey], &pUrl->Entry );
|
|
LeaveTracelibCritSection();
|
|
|
|
return pUrl;
|
|
}
|
|
|
|
PURL_RECORD
|
|
FindOrAddUrlRecord(
|
|
PUCHAR Url
|
|
)
|
|
{
|
|
PURL_RECORD pUrl = NULL;
|
|
|
|
pUrl = FindUrlRecord(Url);
|
|
if (pUrl == NULL) {
|
|
pUrl = AddUrlRecord(Url);
|
|
}
|
|
return pUrl;
|
|
}
|
|
|
|
PCLIENT_RECORD
|
|
AddClientRecord(
|
|
USHORT IpAddrType,
|
|
ULONG IpAddrV4,
|
|
USHORT *IpAddrV6
|
|
)
|
|
{
|
|
PCLIENT_RECORD pClient = NULL;
|
|
|
|
pClient = malloc(sizeof(CLIENT_RECORD));
|
|
if (pClient == NULL) {
|
|
SetLastError(ERROR_OUTOFMEMORY);
|
|
return NULL;
|
|
}
|
|
|
|
RtlZeroMemory(pClient, sizeof(CLIENT_RECORD));
|
|
pClient->IpAddrType = IpAddrType;
|
|
pClient->IpAddrV4 = IpAddrV4;
|
|
if (IpAddrV6 != NULL && IpAddrType == TDI_ADDRESS_TYPE_IP6) {
|
|
RtlCopyMemory(pClient->IpAddrV6, IpAddrV6, sizeof(USHORT) * 8);
|
|
}
|
|
|
|
EnterTracelibCritSection();
|
|
InsertHeadList( &CurrentSystem.ClientListHead, &pClient->Entry );
|
|
LeaveTracelibCritSection();
|
|
|
|
return pClient;
|
|
}
|
|
|
|
PCLIENT_RECORD
|
|
FindOrAddClientRecord(
|
|
USHORT IpAddrType,
|
|
ULONG IpAddrV4,
|
|
USHORT *IpAddrV6
|
|
)
|
|
{
|
|
PCLIENT_RECORD pClient = NULL;
|
|
|
|
pClient = FindClientRecord(IpAddrType, IpAddrV4, IpAddrV6);
|
|
if (pClient == NULL) {
|
|
pClient = AddClientRecord(IpAddrType, IpAddrV4, IpAddrV6);
|
|
}
|
|
return pClient;
|
|
}
|
|
|
|
PSITE_RECORD
|
|
AddSiteRecord(
|
|
ULONG SiteId
|
|
)
|
|
{
|
|
PSITE_RECORD pSite = NULL;
|
|
|
|
pSite = malloc(sizeof(SITE_RECORD));
|
|
if (pSite == NULL) {
|
|
SetLastError(ERROR_OUTOFMEMORY);
|
|
return NULL;
|
|
}
|
|
|
|
RtlZeroMemory(pSite, sizeof(SITE_RECORD));
|
|
pSite->SiteId = SiteId;
|
|
|
|
EnterTracelibCritSection();
|
|
InsertHeadList( &CurrentSystem.SiteListHead, &pSite->Entry );
|
|
LeaveTracelibCritSection();
|
|
|
|
return pSite;
|
|
}
|
|
|
|
PSITE_RECORD
|
|
FindOrAddSiteRecord(
|
|
ULONG SiteId
|
|
)
|
|
{
|
|
PSITE_RECORD pSite = NULL;
|
|
|
|
pSite = FindSiteRecord(SiteId);
|
|
if (pSite == NULL) {
|
|
pSite = AddSiteRecord(SiteId);
|
|
}
|
|
return pSite;
|
|
}
|
|
|
|
PURL_RECORD
|
|
GetHeadUrlRecord(
|
|
ULONG index
|
|
)
|
|
{
|
|
PLIST_ENTRY Head, Next;
|
|
PURL_RECORD pUrl = NULL;
|
|
|
|
EnterTracelibCritSection();
|
|
Head = &CurrentSystem.URLHashList[index];
|
|
Next = Head->Flink;
|
|
|
|
if (Next != Head) {
|
|
pUrl = CONTAINING_RECORD ( Next, URL_RECORD, Entry );
|
|
RemoveEntryList( &pUrl->Entry );
|
|
}
|
|
LeaveTracelibCritSection();
|
|
return pUrl;
|
|
}
|
|
|
|
PCLIENT_RECORD
|
|
GetHeadClientRecord()
|
|
{
|
|
PLIST_ENTRY Head, Next;
|
|
PCLIENT_RECORD pClient = NULL;
|
|
|
|
EnterTracelibCritSection();
|
|
Head = &CurrentSystem.ClientListHead;
|
|
|
|
Next = Head->Flink;
|
|
|
|
if (Next != Head) {
|
|
pClient = CONTAINING_RECORD ( Next, CLIENT_RECORD, Entry );
|
|
RemoveEntryList( &pClient->Entry );
|
|
}
|
|
LeaveTracelibCritSection();
|
|
return pClient;
|
|
}
|
|
|
|
PSITE_RECORD
|
|
GetHeadSiteRecord()
|
|
{
|
|
PLIST_ENTRY Head, Next;
|
|
PSITE_RECORD pSite = NULL;
|
|
|
|
EnterTracelibCritSection();
|
|
Head = &CurrentSystem.SiteListHead;
|
|
|
|
Next = Head->Flink;
|
|
|
|
if (Next != Head) {
|
|
pSite = CONTAINING_RECORD ( Next, SITE_RECORD, Entry );
|
|
RemoveEntryList( &pSite->Entry );
|
|
}
|
|
LeaveTracelibCritSection();
|
|
return pSite;
|
|
}
|
|
|
|
//
|
|
// Deletes a Job record with the JobId. Before deleting the contents
|
|
// of the job record is dumped to a temp file for later reporting.
|
|
//
|
|
ULONG
|
|
DeletePrintJobRecord(
|
|
PPRINT_JOB_RECORD pJob,
|
|
ULONG bSave
|
|
)
|
|
{
|
|
if (pJob == NULL)
|
|
return ERROR_INVALID_PARAMETER;
|
|
|
|
//
|
|
// Print the Contents of pJob to file.
|
|
//
|
|
|
|
// If the -spooler option isn't given to the reducer this fprintf causes the
|
|
// program to crash. Maybe TRACE_SPOOLER should alway be set.
|
|
|
|
if (CurrentSystem.TempPrintFile != NULL && bSave) {
|
|
fprintf(CurrentSystem.TempPrintFile, "%d, ", pJob->JobId);
|
|
fprintf(CurrentSystem.TempPrintFile, "%d, ", pJob->KCPUTime);
|
|
fprintf(CurrentSystem.TempPrintFile, "%d, ", pJob->UCPUTime);
|
|
fprintf(CurrentSystem.TempPrintFile, "%d, ", pJob->ReadIO);
|
|
fprintf(CurrentSystem.TempPrintFile, "%I64u, ", pJob->StartTime);
|
|
fprintf(CurrentSystem.TempPrintFile, "%I64u, ", pJob->EndTime);
|
|
fprintf(CurrentSystem.TempPrintFile, "%I64u, ", (pJob->ResponseTime - pJob->PauseTime));
|
|
fprintf(CurrentSystem.TempPrintFile, "%I64u, ", pJob->PrintJobTime);
|
|
fprintf(CurrentSystem.TempPrintFile, "%d, ", pJob->WriteIO);
|
|
fprintf(CurrentSystem.TempPrintFile, "%d, ", pJob->DataType);
|
|
fprintf(CurrentSystem.TempPrintFile, "%d, ", pJob->JobSize);
|
|
fprintf(CurrentSystem.TempPrintFile, "%d, ", pJob->Pages);
|
|
fprintf(CurrentSystem.TempPrintFile, "%d, ", pJob->PagesPerSide);
|
|
fprintf(CurrentSystem.TempPrintFile, "%hd, ", pJob->FilesOpened);
|
|
fprintf(CurrentSystem.TempPrintFile, "%d, ", pJob->GdiJobSize);
|
|
fprintf(CurrentSystem.TempPrintFile, "%hd, ", pJob->Color);
|
|
fprintf(CurrentSystem.TempPrintFile, "%hd, ", pJob->XRes);
|
|
fprintf(CurrentSystem.TempPrintFile, "%hd, ", pJob->YRes);
|
|
fprintf(CurrentSystem.TempPrintFile, "%hd, ", pJob->Quality);
|
|
fprintf(CurrentSystem.TempPrintFile, "%hd, ", pJob->Copies);
|
|
fprintf(CurrentSystem.TempPrintFile, "%hd, ", pJob->TTOption);
|
|
fprintf(CurrentSystem.TempPrintFile, "%d\n", pJob->NumberOfThreads);
|
|
}
|
|
|
|
EnterTracelibCritSection();
|
|
RemoveEntryList( &pJob->Entry );
|
|
InsertHeadList( &CurrentSystem.FreePrintJobListHead, &pJob->Entry );
|
|
LeaveTracelibCritSection();
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
ULONG
|
|
DeleteHttpReqRecord(
|
|
PHTTP_REQUEST_RECORD pReq,
|
|
ULONG bSave
|
|
)
|
|
{
|
|
if (pReq == NULL)
|
|
return ERROR_INVALID_PARAMETER;
|
|
|
|
//
|
|
// Print the Contents of pReq to file.
|
|
//
|
|
|
|
if (CurrentSystem.TempIisFile != NULL && bSave) {
|
|
fprintf(CurrentSystem.TempIisFile, "%I64u, ", pReq->RequestId);
|
|
fprintf(CurrentSystem.TempIisFile, "%d, ", pReq->SiteId);
|
|
fprintf(CurrentSystem.TempIisFile, "%d, ", pReq->KCPUTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%d, ", pReq->UCPUTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%d, ", pReq->ReadIO);
|
|
fprintf(CurrentSystem.TempIisFile, "%d, ", pReq->WriteIO);
|
|
fprintf(CurrentSystem.TempIisFile, "%I64u, ", pReq->ULStartTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%I64u, ", pReq->ULEndTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%I64u, ", pReq->ULResponseTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%I64u, ", pReq->ULParseTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%I64u, ", pReq->ULDeliverTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%I64u, ", pReq->ULReceiveTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%hd, ", pReq->ULReceiveType);
|
|
fprintf(CurrentSystem.TempIisFile, "%hd, ", pReq->ULEndType);
|
|
fprintf(CurrentSystem.TempIisFile, "%I64u, ", pReq->W3StartTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%I64u, ", pReq->W3EndTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%I64u, ", pReq->W3FilterResponseTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%hd, ", pReq->W3ProcessType);
|
|
fprintf(CurrentSystem.TempIisFile, "%hd, ", pReq->W3EndType);
|
|
fprintf(CurrentSystem.TempIisFile, "%I64u, ", pReq->FileReqTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%I64u, ", pReq->CGIStartTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%I64u, ", pReq->CGIEndTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%I64u, ", pReq->ISAPIStartTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%I64u, ", pReq->ISAPIEndTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%I64u, ", pReq->ASPStartTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%I64u, ", pReq->ASPEndTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%I64u, ", pReq->SSLResponseTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%I64u, ", pReq->StrmFltrResponseTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%hd, ", pReq->HttpStatus);
|
|
fprintf(CurrentSystem.TempIisFile, "%hd, ", pReq->IsapiExt);
|
|
fprintf(CurrentSystem.TempIisFile, "%hd, ", pReq->IpAddrType);
|
|
fprintf(CurrentSystem.TempIisFile, "%d, ", pReq->IpAddrV4);
|
|
fprintf(CurrentSystem.TempIisFile, "%hd, ", pReq->IpAddrV6[0]);
|
|
fprintf(CurrentSystem.TempIisFile, "%hd, ", pReq->IpAddrV6[1]);
|
|
fprintf(CurrentSystem.TempIisFile, "%hd, ", pReq->IpAddrV6[2]);
|
|
fprintf(CurrentSystem.TempIisFile, "%hd, ", pReq->IpAddrV6[3]);
|
|
fprintf(CurrentSystem.TempIisFile, "%hd, ", pReq->IpAddrV6[4]);
|
|
fprintf(CurrentSystem.TempIisFile, "%hd, ", pReq->IpAddrV6[5]);
|
|
fprintf(CurrentSystem.TempIisFile, "%hd, ", pReq->IpAddrV6[6]);
|
|
fprintf(CurrentSystem.TempIisFile, "%hd, ", pReq->IpAddrV6[7]);
|
|
fprintf(CurrentSystem.TempIisFile, "%d, ", pReq->NumberOfThreads);
|
|
fprintf(CurrentSystem.TempIisFile, "%d, ", pReq->BytesSent);
|
|
fprintf(CurrentSystem.TempIisFile, "%d, ", pReq->ULCPUTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%d, ", pReq->W3CPUTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%d, ", pReq->W3FltrCPUTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%d, ", pReq->ISAPICPUTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%d, ", pReq->ASPCPUTime);
|
|
fprintf(CurrentSystem.TempIisFile, "%d,", pReq->CGICPUTime);
|
|
if (pReq->URL != NULL) {
|
|
fprintf(CurrentSystem.TempIisFile, "%s\n", pReq->URL);
|
|
free(pReq->URL);
|
|
}
|
|
else {
|
|
fprintf(CurrentSystem.TempIisFile, "Unknown\n");
|
|
}
|
|
}
|
|
|
|
EnterTracelibCritSection();
|
|
RemoveEntryList( &pReq->Entry );
|
|
InsertHeadList( &CurrentSystem.FreeHttpReqListHead, &pReq->Entry );
|
|
LeaveTracelibCritSection();
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
ULONG
|
|
DeleteUrlRecord(
|
|
PURL_RECORD pUrl
|
|
)
|
|
{
|
|
if (pUrl == NULL)
|
|
return ERROR_INVALID_PARAMETER;
|
|
if (pUrl->URL != NULL) {
|
|
free(pUrl->URL);
|
|
}
|
|
EnterTracelibCritSection();
|
|
RemoveEntryList( &pUrl->Entry );
|
|
InsertHeadList( &CurrentSystem.FreeURLListHead, &pUrl->Entry );
|
|
LeaveTracelibCritSection();
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
ULONG
|
|
DeleteClientRecord(
|
|
PCLIENT_RECORD pClient
|
|
)
|
|
{
|
|
if (pClient == NULL)
|
|
return ERROR_INVALID_PARAMETER;
|
|
EnterTracelibCritSection();
|
|
RemoveEntryList( &pClient->Entry );
|
|
LeaveTracelibCritSection();
|
|
free(pClient);
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
ULONG
|
|
DeleteSiteRecord(
|
|
PSITE_RECORD pSite
|
|
)
|
|
{
|
|
if (pSite == NULL)
|
|
return ERROR_INVALID_PARAMETER;
|
|
EnterTracelibCritSection();
|
|
RemoveEntryList( &pSite->Entry );
|
|
LeaveTracelibCritSection();
|
|
free(pSite);
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|