|
|
//////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2002 Microsoft Corporation. All rights reserved.
// Copyright (c) 2002 OSR Open Systems Resources, Inc.
//
// TraceView.cpp : Defines the class behaviors for the application.
//////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include <tchar.h>
#include <wmistr.h>
#include <initguid.h>
#include <objbase.h>
#include <io.h>
#include <new.h>
#include <fcntl.h>
extern "C" {#include <evntrace.h>
}#include <traceprt.h>
#include <guiddef.h>
#include <wmiguid.h>
#include <iostream.h>
#include <ios>
#include <conio.h>
#include "TraceView.h"
#include "DockDialogBar.h"
#include "LogSession.h"
#include "DisplayDlg.h"
#include "ListCtrlEx.h"
#include "LogSessionDlg.h"
#include "MainFrm.h"
#include "htmlhelp.h"
#include "utils.h"
extern "C" {
#ifdef UNICODE
typedef ULONG(*PFLUSH_TRACE_FUNC)( IN TRACEHANDLE TraceHandle, IN LPCWSTR InstanceName, IN OUT PEVENT_TRACE_PROPERTIES Properties );
#else
typedef ULONG(*PFLUSH_TRACE_FUNC)( IN TRACEHANDLE TraceHandle, IN LPCSTR InstanceName, IN OUT PEVENT_TRACE_PROPERTIES Properties );#endif
typedef ULONG(*PENUMERATE_TRACE_GUIDS_FUNC)( IN OUT PTRACE_GUID_PROPERTIES *GuidPropertiesArray, IN ULONG PropertyArrayCount, OUT PULONG GuidCount );
PENUMERATE_TRACE_GUIDS_FUNC EnumerateTraceGuidsFunction = NULL;
PFLUSH_TRACE_FUNC FlushTraceFunction = NULL;}
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
//
// Global to this module
//
HINSTANCE advapidll=NULL;
// CTraceViewApp
BEGIN_MESSAGE_MAP(CTraceViewApp, CWinApp) ON_COMMAND(ID_APP_ABOUT, OnAppAbout) ON_COMMAND(ID_HELP_HELPTOPICS, OnHelpHelpTopics) ON_COMMAND(ID_HELP, OnHelpHelpTopics)END_MESSAGE_MAP()
// CTraceViewApp construction
CTraceViewApp::CTraceViewApp(){ m_globalLoggerStartValue = 0;}
CTraceViewApp::~CTraceViewApp(){}
// The one and only CTraceViewApp object
CTraceViewApp theApp;
// CTraceViewApp initialization
BOOL CTraceViewApp::InitInstance(){ ULONG length; CString temp; GUID directoryGuid; CString str; STARTUPINFO startupInfo;
//
// Get the temp directory and save it
//
length = GetTempPath(0, NULL);
m_traceDirectory.GetBuffer(MAX_PATH);
if(length < GetTempPath(length, (LPTSTR)(LPCTSTR)m_traceDirectory)) { AfxMessageBox(_T("Failed To Create Temp Directory\nApplication Will Exit")); return FALSE; }
//
// make sure the directory exists
//
CreateDirectory(m_traceDirectory, NULL);
//
// I have to do this cast here
// to get the string to allocate a new buffer
// or the += operation below overwrites the
// existing buffer??
//
m_traceDirectory = (LPCTSTR)m_traceDirectory;
//
// create our own unique directory under the temp directory
//
if(S_OK != CoCreateGuid(&directoryGuid)) { AfxMessageBox(_T("Failed To Create Temp Directory\nApplication Will Exit")); return FALSE; }
GuidToString(directoryGuid, temp);
m_traceDirectory += (LPCTSTR)temp;
m_traceDirectory += (LPCTSTR)_T("\\");
if(!CreateDirectory(m_traceDirectory, NULL) && (GetLastError() != ERROR_ALREADY_EXISTS)) { AfxMessageBox(_T("Failed To Create Temp Directory\nApplication Will Exit")); return FALSE; }
//
// Initialize the trace block ready array mutex
//
m_hTraceBlockMutex = CreateMutex(NULL,TRUE,NULL);
if(m_hTraceBlockMutex == NULL) {
DWORD error = GetLastError();
str.Format(_T("CreateMutex Error %d %x"),error,error);
AfxMessageBox(str);
return FALSE; }
ReleaseMutex(m_hTraceBlockMutex);
advapidll = LoadLibrary(_T("advapi32.dll"));
if (advapidll != NULL) {#ifdef UNICODE
FlushTraceFunction = (PFLUSH_TRACE_FUNC)GetProcAddress(advapidll, "FlushTraceW");#else
FlushTraceFunction = GetProcAddress(advapidll, "FlushTraceA");#endif
EnumerateTraceGuidsFunction = (PENUMERATE_TRACE_GUIDS_FUNC)GetProcAddress(advapidll, "EnumerateTraceGuids"); }
//
// Determine if this is a command line instance or a GUI instance
//
if(__argc > 1) {
//
// Hook up stdout, stdin, and stderr
//
InitializeConsole();
CommandLine();
return FALSE; }
//
// InitCommonControls() is required on Windows XP if an application
// manifest specifies use of ComCtl32.dll version 6 or later to enable
// visual styles. Otherwise, any window creation will fail.
//
InitCommonControls();
CWinApp::InitInstance();
//
// Initialize OLE libraries
//
if (!AfxOleInit()) { AfxMessageBox(IDP_OLE_INIT_FAILED); return FALSE; } AfxEnableControlContainer();
//
// Standard initialization
// If you are not using these features and wish to reduce the size
// of your final executable, you should remove from the following
// the specific initialization routines you do not need
// Change the registry key under which our settings are stored
// TODO: You should modify this string to be something appropriate
// such as the name of your company or organization
//
SetRegistryKey(_T("Local AppWizard-Generated Applications"));
//
// To create the main window, this code creates a new frame window
// object and then sets it as the application's main window object
//
CMainFrame* pFrame = new CMainFrame; m_pMainWnd = pFrame;
//
// create and load the frame with its resources
//
if (!pFrame->LoadFrame(IDR_MAINFRAME)) { return FALSE; }
//
// The one and only window has been initialized, so show and update it
//
pFrame->ShowWindow(SW_SHOW); pFrame->UpdateWindow();
//
// Set the icon
//
AfxGetMainWnd()->SetIcon(AfxGetApp()->LoadIcon(IDR_MAINFRAME), TRUE);
//
// call DragAcceptFiles only if there's a suffix
// In an SDI app, this should occur after ProcessShellCommand
//
return TRUE;}
int CTraceViewApp::ExitInstance() { CTraceMessage *pTraceMessage = NULL; LONG itemCount;
//
// Free the library we loaded earlier
//
FreeLibrary(advapidll);
//
// Free the trace block array
//
//
// Get the free array protection
//
WaitForSingleObject(m_hTraceBlockMutex, INFINITE);
itemCount = m_traceBlockArray.GetSize();
ASSERT(itemCount == 0);
for(LONG ii = 0; ii < itemCount; ii++) { //
// delete the next entry in the list
//
delete m_traceBlockArray.GetAt(ii); }
m_traceBlockArray.RemoveAll();
//
// Release the free array protection
//
ReleaseMutex(m_hTraceBlockMutex);
//
// Remove our temporary directory
//
if(!m_traceDirectory.IsEmpty()) { RemoveDirectory(m_traceDirectory); }
return CWinApp::ExitInstance();}
BOOL CTraceViewApp::InitializeConsole(){ BOOL connected = FALSE; TCHAR outputPipeName[256]; TCHAR inputPipeName[256]; TCHAR errorPipeName[256];
//
// Initialize our console creation flag
//
m_bCreatedConsole = FALSE;
//
// construct named pipe names
//
_stprintf(outputPipeName, _T("\\\\.\\pipe\\%dcout"), GetCurrentProcessId());
_stprintf(inputPipeName, _T("\\\\.\\pipe\\%dcin"), GetCurrentProcessId() );
_stprintf(errorPipeName, _T("\\\\.\\pipe\\%dcerr"), GetCurrentProcessId() );
//
// attach named pipes to stdin/stdout/stderr
//
connected = (_tfreopen( outputPipeName, _T("a"), stdout ) != NULL) && (_tfreopen( inputPipeName, _T("r"), stdin ) != NULL) && (_tfreopen( errorPipeName, _T("a"), stderr ) != NULL);
//
// if unsuccessful, i.e. no console was available
// we need to create a new console
//
if (!connected) {
connected = AllocConsole(); if (connected) { connected = (_tfreopen( _T("CONOUT$"), _T("a"), stdout ) != NULL) && (_tfreopen( _T("CONIN$"), _T("r"), stdin ) != NULL) && (_tfreopen( _T("CONERR$"), _T("a"), stderr ) != NULL);
//
// Indicate that we created a new console
//
m_bCreatedConsole = TRUE; } }
//
// synchronize iostreams with standard io
//
if(connected) { std::ios_base::sync_with_stdio(); }
return connected;}
LONG CTraceViewApp::CommandLine(){ CString str; LONG argc = __argc; LPTSTR loggerName; LONG sizeNeeded; LONG status = ERROR_INVALID_PARAMETER;
//
// dump all arguments
//
//for(LONG ii = 0; ii < argc; ii++) {
// str.Format(_T("%ls"), __wargv[ii]);
// AfxMessageBox(str);
//}
//AfxMessageBox(m_lpCmdLine);
//
// Initialize structure first
//
sizeNeeded = sizeof(EVENT_TRACE_PROPERTIES) + 2 * MAX_STR_LENGTH * sizeof(TCHAR);
sizeNeeded += MAX_ENABLE_FLAGS * sizeof(ULONG); // for extension enable flags
m_pLoggerInfo = (PEVENT_TRACE_PROPERTIES) new char[sizeNeeded]; if (m_pLoggerInfo == NULL) { return (ERROR_OUTOFMEMORY); }
RtlZeroMemory(m_pLoggerInfo, sizeNeeded);
m_pLoggerInfo->Wnode.BufferSize = sizeNeeded; m_pLoggerInfo->Wnode.Flags = WNODE_FLAG_TRACED_GUID; m_pLoggerInfo->LoggerNameOffset = sizeof(EVENT_TRACE_PROPERTIES); m_pLoggerInfo->LogFileNameOffset = m_pLoggerInfo->LoggerNameOffset + (MAX_STR_LENGTH * sizeof(TCHAR));
loggerName = (LPTSTR)((char*)m_pLoggerInfo + m_pLoggerInfo->LoggerNameOffset); _tcscpy(loggerName, KERNEL_LOGGER_NAME);
if(!_tcscmp(__wargv[1], _T("-start") )) { status = StartSession(); }
if(!_tcscmp(__wargv[1], _T("-stop") )) { status = StopSession(); }
if(!_tcscmp(__wargv[1], _T("-update") )) { status = UpdateActiveSession(); }
if(!_tcscmp(__wargv[1], _T("-enable") )) { status = EnableProvider(TRUE); }
if(!_tcscmp(__wargv[1], _T("-disable") )) { status = EnableProvider(FALSE); }
if(!_tcscmp(__wargv[1], _T("-flush") )) { status = FlushActiveBuffers(); }
if(!_tcscmp(__wargv[1], _T("-enumguid") )) { status = EnumerateRegisteredGuids(); }
if(!_tcscmp(__wargv[1], _T("-q") )) { status = QueryActiveSession(); }
if(!_tcscmp(__wargv[1], _T("-l") )) { status = ListActiveSessions(FALSE); }
if(!_tcscmp(__wargv[1], _T("-x") )) { status = ListActiveSessions(TRUE); }
if(!_tcscmp(__wargv[1], _T("-process") )) { status = ConsumeTraceEvents(); }
if(!_tcscmp(__wargv[1], _T("-parsepdb") )) { status = ExtractPdbInfo(); }
if(status == ERROR_INVALID_PARAMETER) { DisplayHelp(); }
if(m_bCreatedConsole) { //
// Prompt user for input so that the console doesn't
// disappear before the user sees what it displays
//
_tprintf(_T("\n\nPress any key to exit\n"));
_getch(); }
return status;}
LONG CTraceViewApp::StartSession(){ CString str; LPTSTR loggerName = NULL; LPTSTR logFileName; LONG start = 2; LONG status; TRACEHANDLE loggerHandle = 0; CString guidFile; CString pdbFile; CString tmcPath; GUID guid; LONG guidCount = 0; ULONG enableFlags = 0; ULONG traceLevel = 0; ULONG specialLogger = 0; USHORT numberOfFlags = 0; USHORT offset; PTRACE_ENABLE_FLAG_EXTENSION flagExt; PULONG pFlags = NULL; LONG i; CFileFind fileFind; TCHAR drive[10]; TCHAR path[MAXSTR]; TCHAR file[MAXSTR]; TCHAR ext[MAXSTR];
pFlags = &m_pLoggerInfo->EnableFlags;
loggerName = (LPTSTR)((char*)m_pLoggerInfo + m_pLoggerInfo->LoggerNameOffset); logFileName = (LPTSTR)((char*)m_pLoggerInfo + m_pLoggerInfo->LogFileNameOffset);
if((__argc > 2) && ((__wargv[2][0] != '-') && (__wargv[2][0] != '/'))) { _tcscpy(loggerName, __wargv[2]);
start = 3; }
for(LONG ii = start; ii < __argc; ii++) { //
// Set the buffer size
//
if(!_tcscmp(__wargv[ii], _T("-b"))) { if((ii + 1) < __argc) { if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { m_pLoggerInfo->BufferSize = _ttoi(__wargv[ii + 1]);/*BUGBUG
if (kdOn && m_pLoggerInfo->BufferSize > 3) { _tprintf(_T("Kernel Debugging has been enabled: Buffer size has been set to 3kBytes\n")); m_pLoggerInfo->BufferSize = 3; }*/ ii++; } } }
//
// Set the minimum number of buffers
//
if(!_tcscmp(__wargv[ii], _T("-min"))) { if((ii + 1) < __argc) { if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { m_pLoggerInfo->MinimumBuffers = _ttoi(__wargv[ii + 1]); ii++; } } }
//
// Set the maximum number of buffers
//
if(!_tcscmp(__wargv[ii], _T("-max"))) { if((ii + 1) < __argc) { if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { m_pLoggerInfo->MaximumBuffers = _ttoi(__wargv[ii + 1]); ii++; } } }
//
// Set the log file name
//
if(!_tcscmp(__wargv[ii], _T("-f"))) { if((ii + 1) < __argc) { if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { _tfullpath(logFileName, __wargv[ii + 1], MAX_STR_LENGTH);
ii++; } } }
//
// Set the log file append setting
//
if(!_tcscmp(__wargv[ii], _T("-append"))) { m_pLoggerInfo->LogFileMode |= EVENT_TRACE_FILE_MODE_APPEND; }
//
// Set the preallocate setting
//
if(!_tcscmp(__wargv[ii], _T("-prealloc"))) { m_pLoggerInfo->LogFileMode |= EVENT_TRACE_FILE_MODE_PREALLOCATE; }
//
// Set the sequential log file setting
//
if(!_tcscmp(__wargv[ii], _T("-seq"))) { if((ii + 1) < __argc) { if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { m_pLoggerInfo->LogFileMode |= EVENT_TRACE_FILE_MODE_SEQUENTIAL; m_pLoggerInfo->MaximumFileSize = _ttoi(__wargv[ii + 1]);
ii++; } } }
//
// Set the sequential log file setting
//
if(!_tcscmp(__wargv[ii], _T("-cir"))) { if((ii + 1) < __argc) { if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { m_pLoggerInfo->LogFileMode |= EVENT_TRACE_FILE_MODE_CIRCULAR; m_pLoggerInfo->MaximumFileSize = _ttoi(__wargv[ii + 1]);
ii++; } } }
//
// Set the new log file size setting
//
if(!_tcscmp(__wargv[ii], _T("-newfile"))) { if((ii + 1) < __argc) { if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { m_pLoggerInfo->LogFileMode |= EVENT_TRACE_FILE_MODE_NEWFILE; m_pLoggerInfo->MaximumFileSize = _ttoi(__wargv[ii + 1]);
ii++; } } }
//
// Set the flush time setting
//
if(!_tcscmp(__wargv[ii], _T("-ft"))) { if((ii + 1) < __argc) { if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { m_pLoggerInfo->FlushTimer = _ttoi(__wargv[ii + 1]);
ii++; } } }
//
// Set the paged setting
//
if(!_tcscmp(__wargv[ii], _T("-paged"))) { m_pLoggerInfo->LogFileMode |= EVENT_TRACE_USE_PAGED_MEMORY; }
//
// Get the control guid(s)
//
if(!_tcscmp(__wargv[ii], _T("-guid"))) { if((ii + 1) < __argc) { if(__wargv[ii + 1][0] == _T('#')) { m_guidArray.Add(__wargv[ii + 1][1]); guidCount++; } else if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { _tfullpath(guidFile.GetBuffer(MAX_STR_LENGTH), __wargv[ii + 1], MAX_STR_LENGTH); // _tprintf(_T("Getting guids from %s\n"), (LPCTSTR)guidFile);
guidCount += GetGuids(guidFile); if (guidCount < 0) { _tprintf( _T("Error: %ls does not exist\n"), (LPCTSTR)guidFile ); } else if (guidCount == 0){ _tprintf( _T("Error: %ls is invalid\n"), (LPCTSTR)guidFile ); status = ERROR_INVALID_PARAMETER; return status; } } ii++; } }
//
// Get the control guid(s) from a PDB file
//
if(!_tcscmp(__wargv[ii], _T("-pdb"))) { if(((ii + 1) < __argc) && ((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/'))) { _tfullpath(pdbFile.GetBuffer(MAX_STR_LENGTH), __wargv[ii + 1], MAX_STR_LENGTH);
pdbFile = (LPCTSTR)pdbFile;
ParsePdb(pdbFile, m_traceDirectory, TRUE);
_tprintf(_T("\n\n"));
tmcPath = (LPCTSTR)m_traceDirectory;
tmcPath +=_T("\\*.tmc");
if(!fileFind.FindFile(tmcPath)) { _tprintf(_T("Failed To Get Control GUID From PDB")); return ERROR_INVALID_PARAMETER; }
while(fileFind.FindNextFile()) { tmcPath = fileFind.GetFileName();
_tsplitpath(tmcPath, drive, path, file, ext );
m_guidArray.Add(file); guidCount++; }
tmcPath = fileFind.GetFileName();
_tsplitpath(tmcPath, drive, path, file, ext );
m_guidArray.Add(file);
guidCount++;
if (guidCount < 0) { _tprintf( _T("Error: %ls does not exist\n"), (LPCTSTR)guidFile ); } else if (guidCount == 0){ _tprintf( _T("Error: %ls is invalid\n"), (LPCTSTR)guidFile ); status = ERROR_INVALID_PARAMETER; return status; } ii++; } }
//
// Check for real-time setting
//
if(!_tcscmp(__wargv[ii], _T("-rt"))) { m_pLoggerInfo->LogFileMode |= EVENT_TRACE_REAL_TIME_MODE;
//
// Did the user specify buffering only?
//
if ((ii + 1) < __argc) { if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { if (__wargv[ii + 1][0] == 'b') m_pLoggerInfo->LogFileMode |= EVENT_TRACE_BUFFERING_MODE; ii++; } } }
//
// Set the debug output setting
//
if(!_tcscmp(__wargv[ii], _T("-kd"))) { m_pLoggerInfo->LogFileMode |= EVENT_TRACE_KD_FILTER_MODE; m_pLoggerInfo->BufferSize = 3; }
//
// Set the age (decay time) setting
//
if(!_tcscmp(__wargv[ii], _T("-age"))) { if((ii + 1) < __argc) { if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { m_pLoggerInfo->AgeLimit = _ttoi(__wargv[ii + 1]);
ii++; } } }
//
// Set the level
//
if(!_tcscmp(__wargv[ii], _T("-level"))) { if((ii + 1) < __argc) { if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { traceLevel = _ttoi(__wargv[ii + 1]);
ii++; } } }
//
// Set the flags
//
if((!_tcscmp(__wargv[ii], _T("-flag"))) || (!_tcscmp(__wargv[ii], _T("-flags")))) { if((ii + 1) < __argc) { if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { //
// Get the flags specified, convert from hex if necessary
//
if(__wargv[ii + 1][1] == _T('x') || __wargv[ii + 1][1] == _T('X')) { m_pLoggerInfo->EnableFlags |= ahextoi(__wargv[ii + 1]); } else { m_pLoggerInfo->EnableFlags |= _ttoi(__wargv[ii + 1]); }
//
// Copy flags for EnableTrace
//
enableFlags = m_pLoggerInfo->EnableFlags;
//
// Do not accept flags with MSB = 1.
//
if (0x80000000 & m_pLoggerInfo->EnableFlags) { _tprintf(_T("Invalid Flags: 0x%0X(%d.)\n"), m_pLoggerInfo->EnableFlags, m_pLoggerInfo->EnableFlags); status = ERROR_INVALID_PARAMETER; return status; }
ii++; } } }
//
// Set the eflags
//
if(!_tcscmp(__wargv[ii], _T("-eflag"))) { if((ii + 2) < __argc) { if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { numberOfFlags = (USHORT)_ttoi(__wargv[ii + 1]);
ii++;
if((numberOfFlags > MAX_ENABLE_FLAGS) || (numberOfFlags < 1)) { _tprintf(_T("Error: Invalid number of enable flags\n")); status = ERROR_INVALID_PARAMETER; return status; }
offset = (USHORT) sizeof(EVENT_TRACE_PROPERTIES) + 2 * MAX_STR_LENGTH * sizeof(TCHAR);
m_pLoggerInfo->EnableFlags = EVENT_TRACE_FLAG_EXTENSION;
flagExt = (PTRACE_ENABLE_FLAG_EXTENSION) &m_pLoggerInfo->EnableFlags;
flagExt->Offset = offset;
flagExt->Length = (UCHAR)numberOfFlags;
pFlags = (PULONG)(offset + (PCHAR) m_pLoggerInfo);
for (i = 0; ((i < numberOfFlags) && ((ii + 1) < __argc)); i++) { if ((__wargv[ii + 1][0] == '-') || (__wargv[ii + 1][0] == '/')) { //
// Correct the number of eflags when the user
// types an incorrect number.
// However, this does not work if the next
// argument is Logger Name.
//
break; }
pFlags[i] = ahextoi(__wargv[ii + 1]); ii++; // _tprintf(_T("Setting logger flags to 0x%0X(%d.)\n"),
// pFlags[i], pFlags[i] );
} numberOfFlags = (USHORT)i; for ( ; i < MAX_ENABLE_FLAGS; i++) { pFlags[i] = 0; } if (flagExt->Length != (UCHAR)numberOfFlags) { // _tprintf(_T("Correcting the number of eflags to %d\n"), i),
flagExt->Length = (UCHAR)numberOfFlags; } } } } }
/*
if (m_pLoggerInfo->LogFileMode & EVENT_TRACE_PRIVATE_LOGGER_MODE) { if (GuidCount != 1) { _tprintf(_T("Need exactly one GUID for PRIVATE loggers\n")); return ERROR_INVALID_PARAMETER; } m_pLoggerInfo->Wnode.Guid = *GuidArray[0]; }
if (m_pLoggerInfo->LogFileMode & EVENT_TRACE_FILE_MODE_PREALLOCATE && m_pLoggerInfo->MaximumFileSize == 0) { _tprintf(_T("Need file size for preallocated log file\n")); return ERROR_INVALID_PARAMETER; }// end_sdk
if (specialLogger == 3) { // Global Logger
status = SetGlobalLoggerSettings(1L, m_pLoggerInfo, m_pLoggerInfo->Wnode.ClientContext); if (status != ERROR_SUCCESS) break; status = GetGlobalLoggerSettings(m_pLoggerInfo, &m_pLoggerInfo->Wnode.ClientContext, &m_globalLoggerStartValue); break; }// begin_sdk
if(m_pLoggerInfo->EnableFlags & EVENT_TRACE_FLAG_EXTENSION){ if(IsEqualGUID(&CritSecGuid,GuidArray[0]) || IsEqualGUID(&HeapGuid,GuidArray[0])){ m_pLoggerInfo->Wnode.HistoricalContext = traceLevel; } }*/ if (!_tcscmp(loggerName, _T("NT Kernel Logger"))) { if (pFlags == &m_pLoggerInfo->EnableFlags) { *pFlags |= EVENT_TRACE_FLAG_PROCESS; *pFlags |= EVENT_TRACE_FLAG_THREAD; *pFlags |= EVENT_TRACE_FLAG_DISK_IO; *pFlags |= EVENT_TRACE_FLAG_NETWORK_TCPIP; }
m_pLoggerInfo->Wnode.Guid = SystemTraceControlGuid; // defaults to OS
}
//
// Set the default log file name if necessary
//
if(!(m_pLoggerInfo->LogFileMode & EVENT_TRACE_REAL_TIME_MODE)) { _tcscpy(logFileName, _T("C:\\LogFile.Etl")); }
status = StartTrace(&loggerHandle, loggerName, m_pLoggerInfo);
if (status != ERROR_SUCCESS) { _tprintf(_T("Could not start logger: %s\n") _T("Operation Status: %uL\n"), loggerName, status); } else { _tprintf(_T("Logger Started...\n")); }
PrintLoggerStatus(status);
if((guidCount > 0) && (specialLogger == 0)) { _tprintf(_T("Enabling trace to logger %d\n"), loggerHandle); for(ULONG ii = 0; ii < (ULONG)guidCount; ii++) { //
// Convert the guid string to a guid
//
StringToGuid(m_guidArray[ii].GetBuffer(0), &guid);
//
// Enable the provider
//
status = EnableTrace ( TRUE, enableFlags, traceLevel, &guid, loggerHandle);
//
// If the Guid can not be enabled, it is a benign
// failure. Print Warning message and continue.
//
if (status == 4317) { _tprintf(_T("WARNING: Could not enable some guids.\n")); _tprintf(_T("Check your Guids file\n")); status = ERROR_SUCCESS; }
if (status != ERROR_SUCCESS) { _tprintf(_T("ERROR: Failed to enable Guid [%d]...\n"), ii); _tprintf(_T("Operation Status: %uL\n"), status); _tprintf(_T("%s\n"),DecodeStatus(status)); break; } } } else if (guidCount > 0) { _tprintf(_T("ERROR: System Logger does not accept application guids...\n")); status = ERROR_INVALID_PARAMETER; }
return status;}
LONG CTraceViewApp::StopSession(){ TRACEHANDLE loggerHandle = 0; LPTSTR loggerName = NULL; LONG start = 2; LONG guidCount = 0; CString guidFile; GUID guid; LONG status; CString pdbFile; CString tmcPath; CFileFind fileFind; TCHAR drive[10]; TCHAR path[MAXSTR]; TCHAR file[MAXSTR]; TCHAR ext[MAXSTR];
//
// Get the logger name string
//
loggerName = (LPTSTR)((char*)m_pLoggerInfo + m_pLoggerInfo->LoggerNameOffset);
if((__argc > 2) && ((__wargv[2][0] != '-') && (__wargv[2][0] != '/'))) { loggerName = (LPTSTR)((char*)m_pLoggerInfo + m_pLoggerInfo->LoggerNameOffset);
_tcscpy(loggerName, __wargv[2]);
start = 3; }
for(LONG ii = start; ii < __argc; ii++) { //
// Get the control guid(s)
//
if(!_tcscmp(__wargv[ii], _T("-guid"))) { if((ii + 1) < __argc) { if(__wargv[ii + 1][0] == _T('#')) { m_guidArray.Add(__wargv[ii + 1][1]); guidCount++; } else if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { _tfullpath(guidFile.GetBuffer(MAX_STR_LENGTH), __wargv[ii + 1], MAX_STR_LENGTH); // _tprintf(_T("Getting guids from %s\n"), (LPCTSTR)guidFile);
guidCount += GetGuids(guidFile); if (guidCount < 0) { _tprintf( _T("Error: %ls does not exist\n"), (LPCTSTR)guidFile ); } else if (guidCount == 0){ _tprintf( _T("Error: %ls is invalid\n"), (LPCTSTR)guidFile ); status = ERROR_INVALID_PARAMETER; return status; } } ii++; } }
//
// Get the control guid(s) from a PDB file
//
if(!_tcscmp(__wargv[ii], _T("-pdb"))) { if(((ii + 1) < __argc) && ((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/'))) { _tfullpath(pdbFile.GetBuffer(MAX_STR_LENGTH), __wargv[ii + 1], MAX_STR_LENGTH);
pdbFile = (LPCTSTR)pdbFile;
ParsePdb(pdbFile, m_traceDirectory, TRUE);
_tprintf(_T("\n\n"));
tmcPath = (LPCTSTR)m_traceDirectory;
tmcPath +=_T("\\*.tmc");
if(!fileFind.FindFile(tmcPath)) { _tprintf(_T("Failed To Get Control GUID From PDB")); return ERROR_INVALID_PARAMETER; }
while(fileFind.FindNextFile()) { tmcPath = fileFind.GetFileName();
_tsplitpath(tmcPath, drive, path, file, ext );
m_guidArray.Add(file); guidCount++; }
tmcPath = fileFind.GetFileName();
_tsplitpath(tmcPath, drive, path, file, ext );
m_guidArray.Add(file);
guidCount++;
if (guidCount < 0) { _tprintf( _T("Error: %ls does not exist\n"), (LPCTSTR)guidFile ); } else if (guidCount == 0){ _tprintf( _T("Error: %ls is invalid\n"), (LPCTSTR)guidFile ); status = ERROR_INVALID_PARAMETER; return status; } ii++; } } }/*
if (m_pLoggerInfo->LogFileMode & EVENT_TRACE_PRIVATE_LOGGER_MODE) { if (guidCount != 1) { _tprintf(_T("Need exactly one GUID for PRIVATE loggers\n")); Status = ERROR_INVALID_PARAMETER; break; } pLoggerInfo->Wnode.Guid = *m_guidArray[0]; }
if (specialLogger == 3) Status = GetGlobalLoggerSettings(pLoggerInfo, &pLoggerInfo->Wnode.ClientContext, &GlobalLoggerStartValue);*/
if(guidCount > 0) {/*
if (pLoggerInfo->LogFileMode & EVENT_TRACE_PRIVATE_LOGGER_MODE) { Status = ControlTrace(loggerHandle, LoggerName, pLoggerInfo, EVENT_TRACE_CONTROL_QUERY); if (Status != ERROR_SUCCESS) break; loggerHandle = pLoggerInfo->Wnode.HistoricalContext; Status = EnableTrace( FALSE, EVENT_TRACE_PRIVATE_LOGGER_MODE, 0, m_guidArray[0], loggerHandle ); } else {*/ status = ControlTrace(loggerHandle, loggerName, m_pLoggerInfo, EVENT_TRACE_CONTROL_QUERY);
if(status == ERROR_WMI_INSTANCE_NOT_FOUND) { return status; }
loggerHandle = m_pLoggerInfo->Wnode.HistoricalContext;
for(ULONG i = 0; i < (ULONG)guidCount; i++) {
//
// Convert the string to a GUID
//
StringToGuid(m_guidArray[i].GetBuffer(0), &guid);
EnableTrace(FALSE, 0, 0, &guid, loggerHandle); }
// }
}
status = ControlTrace(loggerHandle, loggerName, m_pLoggerInfo, EVENT_TRACE_CONTROL_STOP);
PrintLoggerStatus(status);
return status;}
LONG CTraceViewApp::ListActiveSessions(BOOL bKill){ ULONG returnCount ; ULONG listSizeNeeded; PEVENT_TRACE_PROPERTIES pListLoggerInfo[MAX_LOG_SESSIONS]; PEVENT_TRACE_PROPERTIES pStorage; PVOID storage; LONG status; TRACEHANDLE loggerHandle = 0;
listSizeNeeded = MAX_LOG_SESSIONS * (sizeof(EVENT_TRACE_PROPERTIES) + 2 * MAX_STR_LENGTH * sizeof(TCHAR));
storage = malloc(listSizeNeeded); if (storage == NULL) { status = ERROR_OUTOFMEMORY; return status; } RtlZeroMemory(storage, listSizeNeeded);
pStorage = (PEVENT_TRACE_PROPERTIES)storage; for (ULONG i = 0; i < MAX_LOG_SESSIONS; i++) { pStorage->Wnode.BufferSize = sizeof(EVENT_TRACE_PROPERTIES) + 2 * MAX_STR_LENGTH * sizeof(TCHAR); pStorage->LogFileNameOffset = sizeof(EVENT_TRACE_PROPERTIES) + MAX_STR_LENGTH * sizeof(TCHAR); pStorage->LoggerNameOffset = sizeof(EVENT_TRACE_PROPERTIES); pListLoggerInfo[i] = pStorage; pStorage = (PEVENT_TRACE_PROPERTIES) ( (char*)pStorage + pStorage->Wnode.BufferSize); } // if (XP) {
status = QueryAllTraces(pListLoggerInfo, MAX_LOG_SESSIONS, &returnCount);/*
} else { status = QueryAllTraces(pListLoggerInfo, 32, &returnCount); }*/
if (status == ERROR_SUCCESS) { for (ULONG j = 0; j < returnCount; j++) { LPTSTR ListLoggerName; TCHAR asked = _T('?') ; BOOL StatusPrint = FALSE ; if (bKill) {
ListLoggerName = (LPTSTR) ((char*)pListLoggerInfo[j] + pListLoggerInfo[j]->LoggerNameOffset);/*
if (!bForceKill) { while (!(asked == _T('y')) && !(asked == _T('n'))) { ULONG ReadChars = 0; _tprintf(_T("Do you want to kill Logger \"%s\" (Y or N)?"), ListLoggerName); ReadChars = _tscanf(_T(" %c"), &asked); if (ReadChars == 0 || ReadChars == EOF) { continue; } if (asked == _T('Y')) { asked = _T('y') ; } else if (asked == _T('N')) { asked = _T('n') ; } } } else {*/ asked = _T('y');// }
if (asked == _T('y')) { if (!IsEqualGUID(pListLoggerInfo[j]->Wnode.Guid, SystemTraceControlGuid)) { loggerHandle = pListLoggerInfo[j]->Wnode.HistoricalContext; status = EnableTrace( FALSE, (pListLoggerInfo[j]->LogFileMode & EVENT_TRACE_PRIVATE_LOGGER_MODE) ? (EVENT_TRACE_PRIVATE_LOGGER_MODE) : (0), 0, & pListLoggerInfo[j]->Wnode.Guid, loggerHandle); } status = ControlTrace((TRACEHANDLE) 0, ListLoggerName, pListLoggerInfo[j], EVENT_TRACE_CONTROL_STOP); _tprintf(_T("Logger \"%s\" has been killed\n"), ListLoggerName); StatusPrint = TRUE ; } else { _tprintf(_T("Logger \"%s\" has not been killed, current Status is\n"), ListLoggerName); StatusPrint = FALSE ; } }
m_pLoggerInfo = pListLoggerInfo[j];
PrintLoggerStatus(status);
_tprintf(_T("\n")); } }
free(storage);
return status;}
LONG CTraceViewApp::QueryActiveSession(){ TRACEHANDLE loggerHandle = 0; LPTSTR loggerName = NULL; LONG start = 2; LONG guidCount = 0; CString guidFile; GUID guid; LONG status; CString pdbFile; CString tmcPath; CFileFind fileFind; TCHAR drive[10]; TCHAR path[MAXSTR]; TCHAR file[MAXSTR]; TCHAR ext[MAXSTR];
//
// Get the logger name string
//
loggerName = (LPTSTR)((char*)m_pLoggerInfo + m_pLoggerInfo->LoggerNameOffset);
if((__argc > 2) && ((__wargv[2][0] != '-') && (__wargv[2][0] != '/'))) {
_tcscpy(loggerName, __wargv[2]);
start = 3; }
for(LONG ii = start; ii < __argc; ii++) { //
// Get the control guid(s)
//
if(!_tcscmp(__wargv[ii], _T("-guid"))) { if((ii + 1) < __argc) { if(__wargv[ii + 1][0] == _T('#')) { m_guidArray.Add(__wargv[ii + 1][1]); guidCount++; } else if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { _tfullpath(guidFile.GetBuffer(MAX_STR_LENGTH), __wargv[ii + 1], MAX_STR_LENGTH); // _tprintf(_T("Getting guids from %s\n"), (LPCTSTR)guidFile);
guidCount += GetGuids(guidFile); if (guidCount < 0) { _tprintf( _T("Error: %ls does not exist\n"), (LPCTSTR)guidFile ); } else if (guidCount == 0){ _tprintf( _T("Error: %ls is invalid\n"), (LPCTSTR)guidFile ); status = ERROR_INVALID_PARAMETER; return status; } } ii++; } }
//
// Get the control guid(s) from a PDB file
//
if(!_tcscmp(__wargv[ii], _T("-pdb"))) { if(((ii + 1) < __argc) && ((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/'))) { _tfullpath(pdbFile.GetBuffer(MAX_STR_LENGTH), __wargv[ii + 1], MAX_STR_LENGTH);
pdbFile = (LPCTSTR)pdbFile;
ParsePdb(pdbFile, m_traceDirectory, TRUE);
_tprintf(_T("\n\n"));
tmcPath = (LPCTSTR)m_traceDirectory;
tmcPath +=_T("\\*.tmc");
if(!fileFind.FindFile(tmcPath)) { _tprintf(_T("Failed To Get Control GUID From PDB")); return ERROR_INVALID_PARAMETER; }
while(fileFind.FindNextFile()) { tmcPath = fileFind.GetFileName();
_tsplitpath(tmcPath, drive, path, file, ext );
m_guidArray.Add(file); guidCount++; }
tmcPath = fileFind.GetFileName();
_tsplitpath(tmcPath, drive, path, file, ext );
m_guidArray.Add(file);
guidCount++;
if (guidCount < 0) { _tprintf( _T("Error: %ls does not exist\n"), (LPCTSTR)guidFile ); } else if (guidCount == 0){ _tprintf( _T("Error: %ls is invalid\n"), (LPCTSTR)guidFile ); status = ERROR_INVALID_PARAMETER; return status; } ii++; } } }
if (m_pLoggerInfo->LogFileMode & EVENT_TRACE_PRIVATE_LOGGER_MODE) { if (guidCount != 1) { _tprintf(_T("Need exactly one GUID for PRIVATE loggers\n")); status = ERROR_INVALID_PARAMETER; return status; }
StringToGuid(m_guidArray[0].GetBuffer(0), &guid);
m_pLoggerInfo->Wnode.Guid = guid; }/*
if (specialLogger == 3) { status = GetGlobalLoggerSettings(m_pLoggerInfo, &m_pLoggerInfo->Wnode.ClientContext, &GlobalLoggerStartValue); }*/ status = ControlTrace(loggerHandle, loggerName, m_pLoggerInfo, EVENT_TRACE_CONTROL_QUERY);
PrintLoggerStatus(status);
return status;}
LONG CTraceViewApp::FlushActiveBuffers(){ TRACEHANDLE loggerHandle = 0; LPTSTR loggerName = NULL; LONG start = 2; LONG guidCount = 0; CString guidFile; GUID guid; LONG status; CString pdbFile; CString tmcPath; CFileFind fileFind; TCHAR drive[10]; TCHAR path[MAXSTR]; TCHAR file[MAXSTR]; TCHAR ext[MAXSTR];
//
// Get the logger name string
//
loggerName = (LPTSTR)((char*)m_pLoggerInfo + m_pLoggerInfo->LoggerNameOffset);
if((__argc > 2) && ((__wargv[2][0] != '-') && (__wargv[2][0] != '/'))) {
_tcscpy(loggerName, __wargv[2]);
start = 3; }
for(LONG ii = start; ii < __argc; ii++) { //
// Get the control guid(s)
//
if(!_tcscmp(__wargv[ii], _T("-guid"))) { if((ii + 1) < __argc) { if(__wargv[ii + 1][0] == _T('#')) { m_guidArray.Add(__wargv[ii + 1][1]); guidCount++; } else if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { _tfullpath(guidFile.GetBuffer(MAX_STR_LENGTH), __wargv[ii + 1], MAX_STR_LENGTH); // _tprintf(_T("Getting guids from %s\n"), (LPCTSTR)guidFile);
guidCount += GetGuids(guidFile); if (guidCount < 0) { _tprintf( _T("Error: %ls does not exist\n"), (LPCTSTR)guidFile ); } else if (guidCount == 0){ _tprintf( _T("Error: %ls is invalid\n"), (LPCTSTR)guidFile ); status = ERROR_INVALID_PARAMETER; return status; } } ii++; } }
//
// Get the control guid(s) from a PDB file
//
if(!_tcscmp(__wargv[ii], _T("-pdb"))) { if(((ii + 1) < __argc) && ((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/'))) { _tfullpath(pdbFile.GetBuffer(MAX_STR_LENGTH), __wargv[ii + 1], MAX_STR_LENGTH);
pdbFile = (LPCTSTR)pdbFile;
ParsePdb(pdbFile, m_traceDirectory, TRUE);
_tprintf(_T("\n\n"));
tmcPath = (LPCTSTR)m_traceDirectory;
tmcPath +=_T("\\*.tmc");
if(!fileFind.FindFile(tmcPath)) { _tprintf(_T("Failed To Get Control GUID From PDB")); return ERROR_INVALID_PARAMETER; }
while(fileFind.FindNextFile()) { tmcPath = fileFind.GetFileName();
_tsplitpath(tmcPath, drive, path, file, ext );
m_guidArray.Add(file); guidCount++; }
tmcPath = fileFind.GetFileName();
_tsplitpath(tmcPath, drive, path, file, ext );
m_guidArray.Add(file);
guidCount++;
if (guidCount < 0) { _tprintf( _T("Error: %ls does not exist\n"), (LPCTSTR)guidFile ); } else if (guidCount == 0){ _tprintf( _T("Error: %ls is invalid\n"), (LPCTSTR)guidFile ); status = ERROR_INVALID_PARAMETER; return status; } ii++; } } }
if (m_pLoggerInfo->LogFileMode & EVENT_TRACE_PRIVATE_LOGGER_MODE) { if(guidCount != 1) { _tprintf(_T("Need exactly one GUID for PRIVATE loggers\n")); status = ERROR_INVALID_PARAMETER; return status; }
StringToGuid(m_guidArray[0].GetBuffer(0), &guid);
m_pLoggerInfo->Wnode.Guid = guid; }
// status = (ULONG)FlushTrace(loggerHandle, loggerName, m_pLoggerInfo);
status = 1;
if(FlushTraceFunction) { status = (ULONG)(FlushTraceFunction)(loggerHandle, loggerName, m_pLoggerInfo);
PrintLoggerStatus(status); } return status;}
LONG CTraceViewApp::UpdateActiveSession(){ TRACEHANDLE loggerHandle = 0; LPTSTR loggerName = NULL; LPTSTR logFileName = NULL; LONG start = 2; LONG guidCount = 0; CString guidFile; GUID guid; LONG status; ULONG enableFlags = 0; ULONG specialLogger = 0; USHORT numberOfFlags = 0; USHORT offset; PTRACE_ENABLE_FLAG_EXTENSION flagExt; PULONG pFlags = NULL; LONG i; CString pdbFile; CString tmcPath; CFileFind fileFind; TCHAR drive[10]; TCHAR path[MAXSTR]; TCHAR file[MAXSTR]; TCHAR ext[MAXSTR];
//
// Get the logger name string
//
loggerName = (LPTSTR)((char*)m_pLoggerInfo + m_pLoggerInfo->LoggerNameOffset); logFileName = (LPTSTR)((char*)m_pLoggerInfo + m_pLoggerInfo->LogFileNameOffset);
//
// Get the logger name
//
if((__argc > 2) && ((__wargv[2][0] != '-') && (__wargv[2][0] != '/'))) {
_tcscpy(loggerName, __wargv[2]);
start = 3; }
for(LONG ii = start; ii < __argc; ii++) { //
// Set the maximum number of buffers
//
if(!_tcscmp(__wargv[ii], _T("-max"))) { if((ii + 1) < __argc) { if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { m_pLoggerInfo->MaximumBuffers = _ttoi(__wargv[ii + 1]); ii++; } } }
//
// Set the log file name
//
if(!_tcscmp(__wargv[ii], _T("-f"))) { if((ii + 1) < __argc) { if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { _tfullpath(logFileName, __wargv[ii + 1], MAX_STR_LENGTH);
ii++; } } }
//
// Set the flush time setting
//
if(!_tcscmp(__wargv[ii], _T("-ft"))) { if((ii + 1) < __argc) { if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { m_pLoggerInfo->FlushTimer = _ttoi(__wargv[ii + 1]);
ii++; } } }
//
// Get the control guid(s)
//
if(!_tcscmp(__wargv[ii], _T("-guid"))) { if((ii + 1) < __argc) { if(__wargv[ii + 1][0] == _T('#')) { m_guidArray.Add(__wargv[ii + 1][1]); guidCount++; } else if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { _tfullpath(guidFile.GetBuffer(MAX_STR_LENGTH), __wargv[ii + 1], MAX_STR_LENGTH); // _tprintf(_T("Getting guids from %s\n"), (LPCTSTR)guidFile);
guidCount += GetGuids(guidFile); if (guidCount < 0) { _tprintf( _T("Error: %ls does not exist\n"), (LPCTSTR)guidFile ); } else if (guidCount == 0){ _tprintf( _T("Error: %ls is invalid\n"), (LPCTSTR)guidFile ); status = ERROR_INVALID_PARAMETER; return status; } } ii++; } }
//
// Get the control guid(s) from a PDB file
//
if(!_tcscmp(__wargv[ii], _T("-pdb"))) { if(((ii + 1) < __argc) && ((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/'))) { _tfullpath(pdbFile.GetBuffer(MAX_STR_LENGTH), __wargv[ii + 1], MAX_STR_LENGTH);
pdbFile = (LPCTSTR)pdbFile;
ParsePdb(pdbFile, m_traceDirectory, TRUE);
_tprintf(_T("\n\n"));
tmcPath = (LPCTSTR)m_traceDirectory;
tmcPath +=_T("\\*.tmc");
if(!fileFind.FindFile(tmcPath)) { _tprintf(_T("Failed To Get Control GUID From PDB")); return ERROR_INVALID_PARAMETER; }
while(fileFind.FindNextFile()) { tmcPath = fileFind.GetFileName();
_tsplitpath(tmcPath, drive, path, file, ext );
m_guidArray.Add(file); guidCount++; }
tmcPath = fileFind.GetFileName();
_tsplitpath(tmcPath, drive, path, file, ext );
m_guidArray.Add(file);
guidCount++;
if (guidCount < 0) { _tprintf( _T("Error: %ls does not exist\n"), (LPCTSTR)guidFile ); } else if (guidCount == 0){ _tprintf( _T("Error: %ls is invalid\n"), (LPCTSTR)guidFile ); status = ERROR_INVALID_PARAMETER; return status; } ii++; } }
//
// Check for real-time setting
//
if(!_tcscmp(__wargv[ii], _T("-rt"))) { m_pLoggerInfo->LogFileMode |= EVENT_TRACE_REAL_TIME_MODE;
//
// Did the user specify buffering only?
//
if ((ii + 1) < __argc) { if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { if (__wargv[ii + 1][0] == 'b') m_pLoggerInfo->LogFileMode |= EVENT_TRACE_BUFFERING_MODE; ii++; } } }
//
// Set the flags
//
if((!_tcscmp(__wargv[ii], _T("-flag"))) || (!_tcscmp(__wargv[ii], _T("-flags")))) { if((ii + 1) < __argc) { if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { //
// Get the flags specified, convert from hex if necessary
//
if(__wargv[ii + 1][1] == _T('x') || __wargv[ii + 1][1] == _T('X')) { m_pLoggerInfo->EnableFlags |= ahextoi(__wargv[ii + 1]); } else { m_pLoggerInfo->EnableFlags |= _ttoi(__wargv[ii + 1]); }
//
// Copy flags for EnableTrace
//
enableFlags = m_pLoggerInfo->EnableFlags;
//
// Do not accept flags with MSB = 1.
//
if (0x80000000 & m_pLoggerInfo->EnableFlags) { _tprintf(_T("Invalid Flags: 0x%0X(%d.)\n"), m_pLoggerInfo->EnableFlags, m_pLoggerInfo->EnableFlags); status = ERROR_INVALID_PARAMETER; return status; }
ii++; } } }
//
// Set the eflags
//
if(!_tcscmp(__wargv[ii], _T("-eflag"))) { if((ii + 2) < __argc) { if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { numberOfFlags = (USHORT)_ttoi(__wargv[ii + 1]);
ii++;
if((numberOfFlags > MAX_ENABLE_FLAGS) || (numberOfFlags < 1)) { _tprintf(_T("Error: Invalid number of enable flags\n")); status = ERROR_INVALID_PARAMETER; return status; }
offset = (USHORT) sizeof(EVENT_TRACE_PROPERTIES) + 2 * MAX_STR_LENGTH * sizeof(TCHAR);
m_pLoggerInfo->EnableFlags = EVENT_TRACE_FLAG_EXTENSION;
flagExt = (PTRACE_ENABLE_FLAG_EXTENSION) &m_pLoggerInfo->EnableFlags;
flagExt->Offset = offset;
flagExt->Length = (UCHAR)numberOfFlags;
pFlags = (PULONG)(offset + (PCHAR) m_pLoggerInfo);
for (i = 0; ((i < numberOfFlags) && ((ii + 1) < __argc)); i++) { if ((__wargv[ii + 1][0] == '-') || (__wargv[ii + 1][0] == '/')) { //
// Correct the number of eflags when the user
// types an incorrect number.
// However, this does not work if the next
// argument is Logger Name.
//
break; }
pFlags[i] = ahextoi(__wargv[ii + 1]); ii++; // _tprintf(_T("Setting logger flags to 0x%0X(%d.)\n"),
// pFlags[i], pFlags[i] );
} numberOfFlags = (USHORT)i; for ( ; i < MAX_ENABLE_FLAGS; i++) { pFlags[i] = 0; } if (flagExt->Length != (UCHAR)numberOfFlags) { // _tprintf(_T("Correcting the number of eflags to %d\n"), i),
flagExt->Length = (UCHAR)numberOfFlags; } } } } }
if (m_pLoggerInfo->LogFileMode & EVENT_TRACE_PRIVATE_LOGGER_MODE) { if (guidCount != 1) { _tprintf(_T("Need exactly one GUID for PRIVATE loggers\n")); status = ERROR_INVALID_PARAMETER; return status; }
StringToGuid(m_guidArray[0].GetBuffer(0), &guid);
m_pLoggerInfo->Wnode.Guid = guid; }
/*
if (specialLogger == 3) { status = GetGlobalLoggerSettings(m_pLoggerInfo, &m_pLoggerInfo->Wnode.ClientContext, &GlobalLoggerStartValue); }*/
status = ControlTrace(loggerHandle, loggerName, m_pLoggerInfo, EVENT_TRACE_CONTROL_UPDATE);
PrintLoggerStatus(status);
return status;}
LONG CTraceViewApp::EnumerateRegisteredGuids(){ ULONG propertyArrayCount = 10; PTRACE_GUID_PROPERTIES *guidPropertiesArray; ULONG enumGuidCount; ULONG sizeStorage; PVOID storageNeeded; PTRACE_GUID_PROPERTIES cleanStorage; CString str; LONG status; ULONG i;
Retry: sizeStorage = propertyArrayCount * (sizeof(TRACE_GUID_PROPERTIES) + sizeof(PTRACE_GUID_PROPERTIES)); storageNeeded = malloc(sizeStorage); if(storageNeeded == NULL) { status = ERROR_OUTOFMEMORY;
return status; } RtlZeroMemory(storageNeeded, sizeStorage); guidPropertiesArray = (PTRACE_GUID_PROPERTIES *)storageNeeded; cleanStorage = (PTRACE_GUID_PROPERTIES)((char*)storageNeeded + propertyArrayCount * sizeof(PTRACE_GUID_PROPERTIES)); for(i = 0; i < propertyArrayCount; i++) { guidPropertiesArray[i] = cleanStorage; cleanStorage = (PTRACE_GUID_PROPERTIES) ( (char*)cleanStorage + sizeof(TRACE_GUID_PROPERTIES) ); }
//
// V1.0 Note: We are deliberately "breaking" things here, so that
// TraceView will NOT be able to load in Windows 2000. This is because
// very last minute testing indicated that TraceView did not work
// properly on Win2K. This will take some investigating, so the
// work to support Win2K is deferred to a later release.
// (see companion "V1.0 NOTE" in the code below)
//
status = EnumerateTraceGuids(guidPropertiesArray, propertyArrayCount, &enumGuidCount);//
// See V1.0 NOTE, above
//
// if(EnumerateTraceGuidsFunction) {
//
// status = (EnumerateTraceGuidsFunction)(guidPropertiesArray,
// propertyArrayCount,
// &enumGuidCount);
if(status == ERROR_MORE_DATA) { propertyArrayCount = enumGuidCount; free(storageNeeded); goto Retry;
}//
// (see V1.0 NOTE above)
//
// } else {
//
// _tprintf(_T("not supported on Win2K\n"));
// status = 1;
//
// return status;
// }
//
// print the GUID_PROPERTIES and Free Strorage
//
_tprintf(_T(" Guid Enabled LoggerId Level Flags\n")); _tprintf(_T("----------------------------------------------------------\n")); for (i=0; i < enumGuidCount; i++) {
GuidToString(guidPropertiesArray[i]->Guid, str);
_tprintf(_T("%s %5s %d %d %d\n"), (LPCTSTR)str, (guidPropertiesArray[i]->IsEnable) ? _T("TRUE") : _T("FALSE"), guidPropertiesArray[i]->LoggerId, guidPropertiesArray[i]->EnableLevel, guidPropertiesArray[i]->EnableFlags); } free(storageNeeded);
return status;}
LONG CTraceViewApp::EnableProvider(BOOL bEnable){ TRACEHANDLE loggerHandle = 0; LPTSTR loggerName = NULL; LPTSTR logFileName = NULL; LONG start = 2; LONG guidCount = 0; CString guidFile; GUID guid; LONG status; ULONG enableFlags = 0; ULONG traceLevel = 0; ULONG specialLogger = 0; USHORT numberOfFlags = 0; USHORT offset; PTRACE_ENABLE_FLAG_EXTENSION flagExt; PULONG pFlags = NULL; LONG i; CString pdbFile; CString tmcPath; CFileFind fileFind; TCHAR drive[10]; TCHAR path[MAXSTR]; TCHAR file[MAXSTR]; TCHAR ext[MAXSTR];
//
// Get the logger name string
//
loggerName = (LPTSTR)((char*)m_pLoggerInfo + m_pLoggerInfo->LoggerNameOffset);
//
// Get the logger name
//
if((__argc > 2) && ((__wargv[2][0] != '-') && (__wargv[2][0] != '/'))) {
_tcscpy(loggerName, __wargv[2]);
start = 3; }
for(LONG ii = start; ii < __argc; ii++) { //
// Get the control guid(s)
//
if(!_tcscmp(__wargv[ii], _T("-guid"))) { if((ii + 1) < __argc) { if(__wargv[ii + 1][0] == _T('#')) { m_guidArray.Add(__wargv[ii + 1][1]); guidCount++; } else if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { _tfullpath(guidFile.GetBuffer(MAX_STR_LENGTH), __wargv[ii + 1], MAX_STR_LENGTH); // _tprintf(_T("Getting guids from %s\n"), (LPCTSTR)guidFile);
guidCount += GetGuids(guidFile); if (guidCount < 0) { _tprintf( _T("Error: %ls does not exist\n"), (LPCTSTR)guidFile ); } else if (guidCount == 0){ _tprintf( _T("Error: %ls is invalid\n"), (LPCTSTR)guidFile ); status = ERROR_INVALID_PARAMETER; return status; } } ii++; } }
//
// Get the control guid(s) from a PDB file
//
if(!_tcscmp(__wargv[ii], _T("-pdb"))) { if(((ii + 1) < __argc) && ((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/'))) { _tfullpath(pdbFile.GetBuffer(MAX_STR_LENGTH), __wargv[ii + 1], MAX_STR_LENGTH);
pdbFile = (LPCTSTR)pdbFile;
ParsePdb(pdbFile, m_traceDirectory, TRUE);
_tprintf(_T("\n\n"));
tmcPath = (LPCTSTR)m_traceDirectory;
tmcPath +=_T("\\*.tmc");
if(!fileFind.FindFile(tmcPath)) { _tprintf(_T("Failed To Get Control GUID From PDB")); return ERROR_INVALID_PARAMETER; }
while(fileFind.FindNextFile()) { tmcPath = fileFind.GetFileName();
_tsplitpath(tmcPath, drive, path, file, ext );
m_guidArray.Add(file); guidCount++; }
tmcPath = fileFind.GetFileName();
_tsplitpath(tmcPath, drive, path, file, ext );
m_guidArray.Add(file);
guidCount++;
if (guidCount < 0) { _tprintf( _T("Error: %ls does not exist\n"), (LPCTSTR)guidFile ); } else if (guidCount == 0){ _tprintf( _T("Error: %ls is invalid\n"), (LPCTSTR)guidFile ); status = ERROR_INVALID_PARAMETER; return status; } ii++; } }
//
// Set the level
//
if(!_tcscmp(__wargv[ii], _T("-level"))) { if((ii + 1) < __argc) { if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { traceLevel = _ttoi(__wargv[ii + 1]);
ii++; } } }
//
// Set the flags
//
if((!_tcscmp(__wargv[ii], _T("-flag"))) || (!_tcscmp(__wargv[ii], _T("-flags")))) { if((ii + 1) < __argc) { if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { //
// Get the flags specified, convert from hex if necessary
//
if(__wargv[ii + 1][1] == _T('x') || __wargv[ii + 1][1] == _T('X')) { m_pLoggerInfo->EnableFlags |= ahextoi(__wargv[ii + 1]); } else { m_pLoggerInfo->EnableFlags |= _ttoi(__wargv[ii + 1]); }
//
// Copy flags for EnableTrace
//
enableFlags = m_pLoggerInfo->EnableFlags;
//
// Do not accept flags with MSB = 1.
//
if (0x80000000 & m_pLoggerInfo->EnableFlags) { _tprintf(_T("Invalid Flags: 0x%0X(%d.)\n"), m_pLoggerInfo->EnableFlags, m_pLoggerInfo->EnableFlags); status = ERROR_INVALID_PARAMETER; return status; }
ii++; } } }
//
// Set the eflags
//
if(!_tcscmp(__wargv[ii], _T("-eflag"))) { if((ii + 2) < __argc) { if((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/')) { numberOfFlags = (USHORT)_ttoi(__wargv[ii + 1]);
ii++;
if((numberOfFlags > MAX_ENABLE_FLAGS) || (numberOfFlags < 1)) { _tprintf(_T("Error: Invalid number of enable flags\n")); status = ERROR_INVALID_PARAMETER; return status; }
offset = (USHORT) sizeof(EVENT_TRACE_PROPERTIES) + 2 * MAX_STR_LENGTH * sizeof(TCHAR);
m_pLoggerInfo->EnableFlags = EVENT_TRACE_FLAG_EXTENSION;
flagExt = (PTRACE_ENABLE_FLAG_EXTENSION) &m_pLoggerInfo->EnableFlags;
flagExt->Offset = offset;
flagExt->Length = (UCHAR)numberOfFlags;
pFlags = (PULONG)(offset + (PCHAR) m_pLoggerInfo);
for (i = 0; ((i < numberOfFlags) && ((ii + 1) < __argc)); i++) { if ((__wargv[ii + 1][0] == '-') || (__wargv[ii + 1][0] == '/')) { //
// Correct the number of eflags when the user
// types an incorrect number.
// However, this does not work if the next
// argument is Logger Name.
//
break; }
pFlags[i] = ahextoi(__wargv[ii + 1]); ii++; // _tprintf(_T("Setting logger flags to 0x%0X(%d.)\n"),
// pFlags[i], pFlags[i] );
} numberOfFlags = (USHORT)i; for ( ; i < MAX_ENABLE_FLAGS; i++) { pFlags[i] = 0; } if (flagExt->Length != (UCHAR)numberOfFlags) { // _tprintf(_T("Correcting the number of eflags to %d\n"), i),
flagExt->Length = (UCHAR)numberOfFlags; } } } } }
if(m_pLoggerInfo->LogFileMode & EVENT_TRACE_PRIVATE_LOGGER_MODE) { if(guidCount != 1) { _tprintf(_T("Need one GUID for PRIVATE loggers\n")); status = ERROR_INVALID_PARAMETER; return status; }
StringToGuid(m_guidArray[0].GetBuffer(0), &guid);
m_pLoggerInfo->Wnode.Guid = guid; }
status = ControlTrace((TRACEHANDLE) 0, loggerName, m_pLoggerInfo, EVENT_TRACE_CONTROL_QUERY); if(status != ERROR_SUCCESS) {/*
if( IsEqualGUID(&HeapGuid,&m_pLoggerInfo->Wnode.Guid) || IsEqualGUID(&CritSecGuid,&m_pLoggerInfo->Wnode.Guid) ){ //do nothing
} else {*/ _tprintf( _T("ERROR: Logger not started\n") _T("Operation Status: %uL\n") _T("%s\n"), status, DecodeStatus(status)); return status;// }
}
loggerHandle = m_pLoggerInfo->Wnode.HistoricalContext;
if((guidCount > 0) && (specialLogger == 0)) { _tprintf(_T("Enabling trace to logger %d\n"), loggerHandle); for(i = 0; i < (ULONG)guidCount; i++) {
StringToGuid(m_guidArray[i].GetBuffer(0), &guid);
status = EnableTrace ( bEnable, enableFlags, traceLevel, &guid, loggerHandle);
//
// If the Guid can not be enabled, it is a benign
// failure. Print Warning message and continue.
//
if(status == 4317) { _tprintf(_T("WARNING: Could not enable some guids.\n")); _tprintf(_T("Check your Guids file\n")); status = ERROR_SUCCESS; }
if(status != ERROR_SUCCESS) { _tprintf(_T("ERROR: Failed to enable Guid [%d]...\n"), i); _tprintf(_T("Operation Status: %uL\n"), status); _tprintf(_T("%s\n"),DecodeStatus(status)); return status; } } } else if(guidCount > 0) { _tprintf(_T("ERROR: System Logger does not accept application guids...\n")); status = ERROR_INVALID_PARAMETER; }
PrintLoggerStatus(status);
return status;}
LONG CTraceViewApp::ConsumeTraceEvents(){ TCHAR guidFileName[MAXSTR]; TCHAR dumpFileName[MAXSTR]; TCHAR summaryFileName[MAXSTR]; LPTSTR *commandLine; LPTSTR *targv; LPTSTR *cmdargv; LONG argc; PEVENT_TRACE_LOGFILE pLogFile; ULONG status; ULONG guidCount = 0; ULONG i; ULONG j; TRACEHANDLE handleArray[MAXLOGFILES]; CString pdbFile; CString formatOptions;
//
// initialize member variables
//
m_pDumpFile = NULL; m_pSummaryFile = NULL; m_bDebugDisplay = FALSE ; m_bDisplayOnly = FALSE ; m_bSummaryOnly = FALSE ; m_bNoSummary = FALSE ; m_bVerbose = FALSE ; m_bFixUp = FALSE ; m_bODSOutput = FALSE ; m_bTMFSpecified = FALSE ; m_bCSVMode = FALSE ; m_bNoCSVHeader = TRUE ; m_bCSVHeader = FALSE ; m_totalBuffersRead = 0; m_totalEventsLost = 0; m_totalEventCount = 0; m_timerResolution = 10; m_bufferWrap = 0 ; m_eventListHead = NULL; m_logFileCount = 0; m_userMode = FALSE; // TODO: Pick this up from the stream itself.
m_traceMask = NULL;
targv = __wargv; argc = __argc;
_tcscpy(dumpFileName, _T("FmtFile.txt")); _tcscpy(summaryFileName, _T("FmtSum.txt"));
// By default look for Define.guid in the image location
if ((status = GetModuleFileName(NULL, guidFileName, MAXSTR)) == MAXSTR) { guidFileName[MAXSTR-1] = _T('\0'); }
if( status != 0 ){ TCHAR drive[10]; TCHAR path[MAXSTR]; TCHAR file[MAXSTR]; TCHAR ext[MAXSTR];
_tsplitpath( guidFileName, drive, path, file, ext ); _tcscpy(ext, GUID_EXT ); _tcscpy(file, GUID_FILE ); _tmakepath( guidFileName, drive, path, file, ext ); }else{ _tcscpy( guidFileName, GUID_FILE ); _tcscat( guidFileName, _T(".") ); _tcscat( guidFileName, GUID_EXT ); }
while (--argc > 0) { ++targv; if (**targv == '-' || **targv == '/') { // argument found
if( **targv == '/' ){ **targv = '-'; } else if (!_tcsicmp(targv[0], _T("-debug"))) { m_bDebugDisplay = TRUE; } else if (!_tcsicmp(targv[0], _T("-display"))) { m_bDebugDisplay = TRUE ; } else if (!_tcsicmp(targv[0], _T("-displayonly"))) { m_bDisplayOnly = TRUE ; } else if (!_tcsicmp(targv[0], _T("-fixup"))) { m_bFixUp = TRUE; } else if (!_tcsicmp(targv[0], _T("-summary"))) { m_bSummaryOnly = TRUE; } else if (!_tcsicmp(targv[0], _T("-seq"))) { SetTraceFormatParameter(ParameterSEQUENCE, ULongToPtr(1)); } else if (!_tcsicmp(targv[0], _T("-gmt"))) { SetTraceFormatParameter(ParameterGMT, ULongToPtr(1)); } else if (!_tcsicmp(targv[0], _T("-utc"))) { SetTraceFormatParameter(ParameterGMT, ULongToPtr(1)); } else if (!_tcsicmp(targv[0], _T("-nosummary"))) { m_bNoSummary = TRUE; } else if (!_tcsicmp(targv[0], _T("-csv"))) { m_bCSVMode = TRUE ; m_bCSVHeader = TRUE ; SetTraceFormatParameter(ParameterStructuredFormat,UlongToPtr(1)); } else if (!_tcsicmp(targv[0], _T("-nocsvheader"))) { m_bNoCSVHeader = FALSE ; } else if (!_tcsicmp(targv[0], _T("-noprefix"))) { SetTraceFormatParameter(ParameterUsePrefix,UlongToPtr(0)); } else if (!_tcsicmp(targv[0], _T("-rt"))) { TCHAR LoggerName[MAXSTR]; _tcscpy(LoggerName, KERNEL_LOGGER_NAME); if (argc > 1) { if (targv[1][0] != '-' && targv[1][0] != '/') { ++targv; --argc; _tcscpy(LoggerName, targv[0]); } } pLogFile = (PEVENT_TRACE_LOGFILE)malloc(sizeof(EVENT_TRACE_LOGFILE)); if (pLogFile == NULL){ _tprintf(_T("Allocation Failure\n")); goto cleanup; } RtlZeroMemory(pLogFile, sizeof(EVENT_TRACE_LOGFILE)); m_evmFile[m_logFileCount] = pLogFile; m_evmFile[m_logFileCount]->LogFileName = NULL; m_evmFile[m_logFileCount]->LoggerName = (LPTSTR) malloc(MAXSTR*sizeof(TCHAR)); if ( m_evmFile[m_logFileCount]->LoggerName == NULL ) { _tprintf(_T("Allocation Failure\n")); goto cleanup; } _tcscpy(m_evmFile[m_logFileCount]->LoggerName, LoggerName); _tprintf(_T("Setting RealTime mode for %s\n"), m_evmFile[m_logFileCount]->LoggerName); m_evmFile[m_logFileCount]->Context = NULL; m_evmFile[m_logFileCount]->BufferCallback = (PEVENT_TRACE_BUFFER_CALLBACKW)BufferCallback; m_evmFile[m_logFileCount]->BuffersRead = 0; m_evmFile[m_logFileCount]->CurrentTime = 0; m_evmFile[m_logFileCount]->EventCallback = (PEVENT_CALLBACK)&DumpEvent; m_evmFile[m_logFileCount]->LogFileMode = EVENT_TRACE_REAL_TIME_MODE; m_logFileCount++; } else if ( !_tcsicmp(targv[0], _T("-guid")) ) { // maintain for compatabillity
if (argc > 1) { if (targv[1][0] != '-' && targv[1][0] != '/') { _tcscpy(guidFileName, targv[1]); ++targv; --argc; m_bTMFSpecified = TRUE ; } } } else if ( !_tcsicmp(targv[0], _T("-tmf")) ) { if (argc > 1) { if (targv[1][0] != '-' && targv[1][0] != '/') { _tcscpy(guidFileName, targv[1]); ++targv; --argc; m_bTMFSpecified = TRUE ; } } } else if ( !_tcsicmp(targv[0], _T("-pdb")) ) { if (argc > 1) { if (targv[1][0] != '-' && targv[1][0] != '/') { _tfullpath(pdbFile.GetBuffer(MAX_STR_LENGTH), targv[1], MAX_STR_LENGTH);
pdbFile = (LPCTSTR)pdbFile;
if(ParsePdb(pdbFile, m_traceDirectory, TRUE)) { SetTraceFormatParameter(ParameterTraceFormatSearchPath, m_traceDirectory.GetBuffer(0)); }
++targv; --argc; } } } else if ( !_tcsicmp(targv[0], _T("-p")) ){ if (argc > 1) { if (targv[1][0] != '-' && targv[1][0] != '/') { SetTraceFormatParameter(ParameterTraceFormatSearchPath, targv[1]); ++targv; --argc; } } } else if ( !_tcsicmp(targv[0], _T("-format")) ) { if (argc > 1) { if (targv[1][0] != '-' && targv[1][0] != '/') {
for(LONG ii = 0; ii < _tcslen(targv[1]); ii++) { switch(targv[1][ii]) { case 'n': formatOptions += _T("%1!s! "); break; case 'w': formatOptions += _T("%2!s! "); break; case 't': formatOptions += _T("%3!04X! "); break; case 's': formatOptions += _T("%4!s! "); break; case 'k': formatOptions += _T("%5!s! "); break; case 'u': formatOptions += _T("%6!s! "); break; case 'q': formatOptions += _T("%7!d! "); break; case 'p': formatOptions += _T("%8!04X! "); break; case 'c': formatOptions += _T("%9!d! "); break; case 'f': formatOptions += _T("%!FUNC! "); break; default: break; } }
SetEnvironmentVariable(_T("TRACE_FORMAT_PREFIX"), formatOptions);
++targv; --argc; } } } else if ( !_tcsicmp(targv[0], _T("-v")) ) { m_bVerbose = TRUE ; } else if ( !_tcsicmp(targv[0], _T("-ods")) ) { m_bODSOutput = TRUE ; } else if ( !_tcsicmp(targv[0], _T("-onlyshow")) ) { if (argc > 1) { m_traceMask = (TCHAR *)malloc((_tcslen(targv[1])+1) * sizeof(TCHAR)); _tcscpy(m_traceMask, targv[1]); ++targv; --argc; } } else if ( !_tcsicmp(targv[0], _T("-o")) ) { if (argc > 1) {
if (targv[1][0] != '-' && targv[1][0] != '/') { TCHAR drive[10]; TCHAR path[MAXSTR]; TCHAR file[MAXSTR]; TCHAR ext[MAXSTR]; ++targv; --argc;
_tfullpath(dumpFileName, targv[0], MAXSTR); _tsplitpath( dumpFileName, drive, path, file, ext ); _tcscat(ext,_T(".sum")); _tmakepath( summaryFileName, drive, path, file, ext );
} } } } else { pLogFile = (PEVENT_TRACE_LOGFILE)malloc(sizeof(EVENT_TRACE_LOGFILE)); if (pLogFile == NULL){ _tprintf(_T("Allocation Failure(EVENT_TRACE_LOGFILE)\n")); // Need to cleanup better.
goto cleanup; } RtlZeroMemory(pLogFile, sizeof(EVENT_TRACE_LOGFILE)); m_evmFile[m_logFileCount] = pLogFile;
m_evmFile[m_logFileCount]->LoggerName = NULL; m_evmFile[m_logFileCount]->LogFileName = (LPTSTR) malloc(MAXSTR*sizeof(TCHAR)); if (m_evmFile[m_logFileCount]->LogFileName == NULL) { _tprintf(_T("Allocation Failure (LogFileName)\n")); goto cleanup; } _tfullpath(m_evmFile[m_logFileCount]->LogFileName, targv[0], MAXSTR); _tprintf(_T("Setting log file to: %s\n"), m_evmFile[m_logFileCount]->LogFileName); if (!CheckFile(m_evmFile[m_logFileCount]->LogFileName)) { _tprintf(_T("Cannot open logfile for reading\n")); goto cleanup; } m_evmFile[m_logFileCount]->Context = NULL; m_evmFile[m_logFileCount]->BufferCallback = (PEVENT_TRACE_BUFFER_CALLBACKW)BufferCallback; m_evmFile[m_logFileCount]->BuffersRead = 0; m_evmFile[m_logFileCount]->CurrentTime = 0; m_evmFile[m_logFileCount]->EventCallback = (PEVENT_CALLBACK)&DumpEvent; m_logFileCount++; } }
if( _tcslen( guidFileName ) ){ TCHAR str[MAXSTR]; _tfullpath( str, guidFileName, MAXSTR); _tcscpy( guidFileName, str ); _tprintf(_T("Getting guids from %s\n"), guidFileName); guidCount = GetTraceGuids(guidFileName, (PLIST_ENTRY *) &m_eventListHead); if ((guidCount <= 0) && m_bTMFSpecified) { _tprintf(_T("GetTraceGuids returned %d, GetLastError=%d, for %s\n"), guidCount, GetLastError(), guidFileName); } }
if (m_logFileCount <= 0) { pLogFile = (PEVENT_TRACE_LOGFILE)malloc(sizeof(EVENT_TRACE_LOGFILE)); if (pLogFile == NULL){ _tprintf(_T("Allocation Failure\n")); // Need to cleanup better.
goto cleanup; } RtlZeroMemory(pLogFile, sizeof(EVENT_TRACE_LOGFILE)); m_evmFile[0] = pLogFile; m_evmFile[0]->LoggerName = NULL; m_logFileCount = 1; m_evmFile[0]->LogFileName = (LPTSTR) malloc(MAXSTR*sizeof(TCHAR)); if (m_evmFile[0]->LogFileName == NULL) { _tprintf(_T("Allocation Failure\n")); goto cleanup; } _tcscpy(m_evmFile[0]->LogFileName, _T("C:\\Logfile.Etl")); m_evmFile[0]->EventCallback = (PEVENT_CALLBACK)&DumpEvent; }
for (i = 0; i < m_logFileCount; i++) { TRACEHANDLE x; x = OpenTrace(m_evmFile[i]); handleArray[i] = x; if (handleArray[i] == 0) { _tprintf(_T("Error Opening Trace %d with status=%d\n"), i, GetLastError());
for (j = 0; j < i; j++) CloseTrace(handleArray[j]); goto cleanup; } } if (!m_bDisplayOnly) { m_pDumpFile = _tfopen(dumpFileName, _T("w")); if (m_pDumpFile == NULL) { _tprintf(_T("Format File \"%s\" Could not be opened for writing 0X%X\n"), dumpFileName,GetLastError()); goto cleanup; } m_pSummaryFile = NULL ; if (!m_bNoSummary) { m_pSummaryFile = _tfopen(summaryFileName, _T("w")); if (m_pSummaryFile == NULL) { _tprintf(_T("Summary File \"%s\" could not be opened for writing 0X%X\n"), summaryFileName,GetLastError()); goto cleanup; } } } else { m_pDumpFile = stdout; m_pSummaryFile = stdout; }
status = ProcessTrace(handleArray, m_logFileCount, NULL, NULL); if (status != ERROR_SUCCESS) { _tprintf(_T("Error processing trace entry with status=0x%x (GetLastError=0x%x)\n"), status, GetLastError()); }
for (j = 0; j < m_logFileCount; j++){ status = CloseTrace(handleArray[j]); if (status != ERROR_SUCCESS) { _tprintf(_T("Error Closing Trace %d with status=%d\n"), j, status); } }
if (!m_bNoSummary) { _ftprintf(m_pSummaryFile,_T("Files Processed:\n")); for (i=0; i<m_logFileCount; i++) { _ftprintf(m_pSummaryFile,_T("\t%s\n"),m_evmFile[i]->LogFileName); } GetTraceElapseTime(&m_elapseTime); _ftprintf(m_pSummaryFile, _T("Total Buffers Processed %d\n") _T("Total Events Processed %d\n") _T("Total Events Lost %d\n") _T("Elapsed Time %I64d sec\n"), m_totalBuffersRead, m_totalEventCount, m_totalEventsLost, (m_elapseTime / 10000000) ); _ftprintf(m_pSummaryFile, _T("+-----------------------------------------------------------------------------------+\n") _T("|%10s %-20s %-10s %-36s|\n") _T("+-----------------------------------------------------------------------------------+\n"), _T("EventCount"), _T("EventName"), _T("EventType"), _T("Guid") ); SummaryTraceEventList(m_summaryBlock, SIZESUMMARYBLOCK, m_eventListHead); _ftprintf(m_pSummaryFile, _T("%s+-----------------------------------------------------------------------------------+\n"), m_summaryBlock); }
cleanup: CleanupTraceEventList(m_eventListHead); if (m_bVerbose) { _tprintf(_T("\n")); // need a newline after the block updates
} if (m_pDumpFile != NULL) { _tprintf(_T("Event traces dumped to %s\n"), dumpFileName); fclose(m_pDumpFile); }
if(m_pSummaryFile != NULL){ _tprintf(_T("Event Summary dumped to %s\n"), summaryFileName); fclose(m_pSummaryFile); }
for (i = 0; i < m_logFileCount; i ++) { if (m_evmFile[i]->LoggerName != NULL) { free(m_evmFile[i]->LoggerName); m_evmFile[i]->LoggerName = NULL; } if (m_evmFile[i]->LogFileName != NULL) { free(m_evmFile[i]->LogFileName); m_evmFile[i]->LogFileName = NULL; } free(m_evmFile[i]); }
status = GetLastError(); if(status != ERROR_SUCCESS ){ _tprintf(_T("Exit Status: %d\n"), status ); } return 0;}
LONG CTraceViewApp::ExtractPdbInfo(){ DWORD status; CString path; CString pdbName; CHAR pdbNameStr[500]; CHAR pathStr[500]; INT len; INT targv = 0; BOOL bPDBName = FALSE ; LPTSTR dllToLoad = NULL;
/*
TCHAR helptext[] = "Usage: TracePDB -f <pdbname> [-p <path>] [-v]\n" " Options:\n"// " -r recurse into subdirectories\n"
" -f specifies the PDBName from which to extract tmf's\n" " -p specifies the path to create the tmf's,\n" " by default the current directory.\n" " -v verbose, displays actions taken \n" ;*/
if (GetCurrentDirectory(MAX_PATH, path.GetBuffer(MAX_PATH)) == 0 ) { _fputts(_T("TracePDB: no current directory\n"), stdout); return ERROR_PATH_NOT_FOUND; }
path = (LPCTSTR)path;
//
// Get the PDB file name
//
if((__argc > 2) && ((__wargv[2][0] != '-') && (__wargv[2][0] != '/'))) {
if((_tcslen(__wargv[2]) + 1) > MAX_PATH) { _fputts(_T("TracePDB: PDBname too large\n"), stdout); return ERROR_INVALID_PARAMETER; }
pdbName.GetBuffer(_tcslen(__wargv[2]) + 1);
pdbName = __wargv[2];
bPDBName = TRUE ; }
for(LONG ii = 3; ii < __argc; ii++) { if((__argc > 3) && ((__wargv[ii][0] == '-') || (__wargv[ii][0] == '/'))) {
if(__wargv[ii][1] == 'p') { if(((ii + 1) < __argc) && ((__wargv[ii + 1][0] != '-') && (__wargv[ii + 1][0] != '/'))) { if((_tcslen(__wargv[ii + 1]) + 1) > MAX_PATH) { fputs("TracePDB: Path larger than MAX_PATH\n", stdout); return ERROR_INVALID_PARAMETER; } _tcsncpy(path.GetBuffer(_tcslen(__wargv[ii + 1]) + 1), __wargv[ii + 1], _tcslen(__wargv[ii + 1]) + 1);
ii++; } } else { return ERROR_INVALID_PARAMETER; } } }
if (!bPDBName) { _tprintf(_T("TracePDB: No PDB specified?\n\n")); return ERROR_INVALID_PARAMETER; }
if((dllToLoad = (LPTSTR) malloc(MAX_PATH + 1)) == NULL) { _fputts(_T("TracePDB: malloc failed\n"), stdout); return ERROR_OUTOFMEMORY; }
_tcscpy(dllToLoad, _T("mspdb70.dll"));
if(!ParsePdb(pdbName, path, TRUE)) { status = ERROR_INVALID_PARAMETER;
_tprintf(_T("TracePDB: failed with error %d\n"), status); }
return status;}
void CTraceViewApp::DisplayHelp(){ _fputts( _T("\n") _T("\n") _T("\n") _T("Control:\n") _T("Usage: traceview [action] [options] | [-h | -help | -?]\n") _T("\n") _T("Control Actions:\n") _T("\t-start [LoggerName] Starts up the [LoggerName] trace session\n") _T("\t-stop [LoggerName] Stops the [LoggerName] trace session\n") _T("\t-update [LoggerName] Updates the [LoggerName] trace session\n") _T("\t-enable [LoggerName] Enables providers for the [LoggerName] session\n") _T("\t-disable [LoggerName] Disables providers for the [LoggerName] session\n") _T("\t-flush [LoggerName] Flushes the [LoggerName] active buffers\n") _T("\t-enumguid Enumerate Registered Trace Guids\n") _T("\t-q [LoggerName] Query status of [LoggerName] trace session\n") _T("\t-l List all trace sessions\n") _T("\t-x Stops all active trace sessions\n") _T("\n") _T("Control Options:\n") _T("\t-b <n> Sets buffer size to <n> Kbytes\n") _T("\t-min <n> Sets minimum buffers\n") _T("\t-max <n> Sets maximum buffers\n") _T("\t-f <name> Log to file <name>\n") _T("\t-append Append to file\n") _T("\t-prealloc Pre-allocate\n") _T("\t-seq <n> Sequential logfile of up to n Mbytes\n") _T("\t-cir <n> Circular logfile of n Mbytes\n") _T("\t-newfile <n> Log to a new file after every n Mbytes\n") _T("\t-ft <n> Set flush timer to n seconds\n") _T("\t-paged Use pageable memory for buffers\n") _T("\t-guid <file> Start tracing for providers in file\n") _T("\t-pdb <file> Start tracing for provider related to PDB file\n") _T("\t-rt Enable tracing in real time mode\n") _T("\t-kd Enable tracing in kernel debugger\n") _T("\t-age <n> Modify aging decay time to n minutes\n") _T("\t-level <n> Enable Level passed to the providers\n") _T("\t-flag <n> Enable Flags passed to the providers\n") _T("\t-eflag <n> <flag...> Enable flags (several) to providers\n") _T("\n") _T("\n") _T("Consumption:\n") _T("Usage: traceview [action] [options] <evmfile> | [-h | -help | -?]\n") _T("\n") _T("Consumption Actions:\n") _T("\t-process Setup trace event processing for consumer\n") _T("\n") _T("Consumption Options:\n") _T("\t-o <file> Output file\n") _T("\t-csv Format the output as a comma seperated file\n") _T("\t-tmf <file> Format definition file\n") _T("\t-pdb <file> Retrieve format information from PDB file\n") _T("\t-p <path> TMF file search path\n") _T("\t-rt [loggername] Realtime formatting\n") _T("\t-h Display this information\n") _T("\t-display Display output\n") _T("\t-displayonly Display output. Don't write to the file\n") _T("\t-nosummary Don't create the summary file\n") _T("\t-noprefix Suppress any defined TRACE_FORMAT_PREFIX") _T("\t-ods do Display output using OutputDebugString\n") _T("\t-summaryonly Don't create the listing file.\n") _T("\t-v Verbose Display\n") _T("\n") _T("\tDefault evmfile is ") _T("C:\\Logfile.Etl") _T("\n") _T("\tDefault outputfile is ") _T("FmtFile.txt") _T("\n") _T("\tDefault TMF file is ") GUID_FILE _T(".") GUID_EXT _T("\n") _T("\n") _T("\n") _T("Parsing:\n") _T("Usage: traceview [action] <pdbname> [-p <path>] | [-h | -help | -?]\n") _T("\n") _T("Parsing Actions:\n") _T("\t-parsepdb <pdbname> Extract TMF(s) from <pdbname>\n") _T("\n") _T("Parsing Options:\n") _T("\t-p specifies the path to create the tmf's,\n") _T("\t by default the current directory.\n") _T("\n") _T("\n") _T("\n") _T("Examples:\n") _T("\n") _T("Start a log session named foo with the following properties:\n") _T(" - real-time\n") _T(" - flags set to 0x7\n") _T(" - flush time equal to 1\n") _T(" - control GUID information stored in foo.pdb\n") _T("\n") _T("traceview -start foo -rt - flag 0x7 -ft 1 -pdb foo.pdb\n") _T("\n") _T("\n") _T("Consume trace events from a logger named bar with the\n") _T(" following options:\n") _T(" - process events in real-time from real-time logger bar\n") _T(" - display to screen only, no listing file generated\n") _T(" - display process ID, CPU number, and function name\n") _T(" ahead of event message \n") _T(" - extract event format information from bar.pdb\n") _T("\n") _T("traceview -process -pdb bar.pdb -displayonly -rt bar -format pcf\n") _T("\n") _T("\n") _T("Extract the TMF files from a PDB file and place them in \n") _T(" a directory named c:\\foobar\n") _T("\n") _T("traceview -parsepdb bar.pdb -p c:\\foobar\n"), stdout );}
// CTraceViewApp message handlers
// CAboutDlg dialog used for App About
class CAboutDlg : public CDialog{public: CAboutDlg();
// Dialog Data
enum { IDD = IDD_ABOUTBOX };
protected: virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
// Implementation
protected: DECLARE_MESSAGE_MAP()public:};
CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD){}
void CAboutDlg::DoDataExchange(CDataExchange* pDX){ CDialog::DoDataExchange(pDX);}
BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)END_MESSAGE_MAP()
// App command to run the dialog
void CTraceViewApp::OnAppAbout(){ CAboutDlg aboutDlg; aboutDlg.DoModal();}
// CTraceViewApp message handlers
CTraceMessage * CTraceViewApp::AllocateTraceEventBlock(){ CTraceMessage *pTraceMessage = NULL;
//
// Get the array protection
//
WaitForSingleObject(m_hTraceBlockMutex, INFINITE);
if(m_traceBlockArray.GetSize()) {
ASSERT(FALSE);
pTraceMessage = m_traceBlockArray.GetAt(0);
m_traceBlockArray.RemoveAt(0); } else { pTraceMessage = new CTraceMessage(); }
//
// Release the array protection
//
ReleaseMutex(m_hTraceBlockMutex);
return pTraceMessage;}
void CTraceViewApp::FreeTraceEventBlocks(CArray<CTraceMessage*, CTraceMessage*> &TraceArray){ //
// Get the free array protection
//
WaitForSingleObject(m_hTraceBlockMutex, INFINITE);
m_traceBlockArray.Append(TraceArray);
TraceArray.RemoveAll();
//
// Release the free array protection
//
ReleaseMutex(m_hTraceBlockMutex);
}
BOOL CTraceViewApp::OnIdle(LONG lCount){ CTraceMessage *pTraceMessage = NULL;
//
// Get the free array protection
//
WaitForSingleObject(m_hTraceBlockMutex, INFINITE);
for(LONG ii = 0; ii < 1000; ii++) { if(m_traceBlockArray.GetSize() < 100) { break; }
//
// Get the next entry from the list
//
pTraceMessage = m_traceBlockArray.GetAt(0);
m_traceBlockArray.RemoveAt(0);
delete pTraceMessage; }
//
// Release the free array protection
//
ReleaseMutex(m_hTraceBlockMutex);
return CWinApp::OnIdle(lCount);}
void CTraceViewApp::PrintLoggerStatus(ULONG Status){ LPTSTR loggerName; LPTSTR LogFileName; CString errorMsg; if ((m_pLoggerInfo->LoggerNameOffset > 0) && (m_pLoggerInfo->LoggerNameOffset < m_pLoggerInfo->Wnode.BufferSize)) { loggerName = (LPTSTR) ((char*)m_pLoggerInfo + m_pLoggerInfo->LoggerNameOffset); } else loggerName = NULL;
if ((m_pLoggerInfo->LogFileNameOffset > 0) && (m_pLoggerInfo->LogFileNameOffset < m_pLoggerInfo->Wnode.BufferSize)) { LogFileName = (LPTSTR) ((char*)m_pLoggerInfo + m_pLoggerInfo->LogFileNameOffset); } else LogFileName = NULL;
_tprintf(_T("Operation Status: %uL\t"), Status); _tprintf(_T("%s\n"), DecodeStatus(Status)); _tprintf(_T("Logger Name: %s\n"), (loggerName == NULL) ? _T(" ") : loggerName);// end_sdk
if (loggerName == NULL || !_tcscmp(loggerName, _T("GlobalLogger"))) { // Logger ID
_tprintf(_T("Status: %s\n"), m_globalLoggerStartValue ? _T("Registry set to start") : _T("Registry set to stop")); _tprintf(_T("Logger Id: %I64x\n"), m_pLoggerInfo->Wnode.HistoricalContext); _tprintf(_T("Logger Thread Id: %p\n"), m_pLoggerInfo->LoggerThreadId); if (m_pLoggerInfo->BufferSize == 0) _tprintf(_T("Buffer Size: default value\n")); else _tprintf(_T("Buffer Size: %d Kb\n"), m_pLoggerInfo->BufferSize);
if (m_pLoggerInfo->MaximumBuffers == 0) _tprintf(_T("Maximum Buffers: default value\n")); else _tprintf(_T("Maximum Buffers: %d\n"), m_pLoggerInfo->MaximumBuffers); if (m_pLoggerInfo->MinimumBuffers == 0) _tprintf(_T("Minimum Buffers: default value\n")); else _tprintf(_T("Minimum Buffers: %d\n"), m_pLoggerInfo->MinimumBuffers); _tprintf(_T("Number of Buffers: %d\n"), m_pLoggerInfo->NumberOfBuffers); _tprintf(_T("Free Buffers: %d\n"), m_pLoggerInfo->FreeBuffers); _tprintf(_T("Buffers Written: %d\n"), m_pLoggerInfo->BuffersWritten); _tprintf(_T("Events Lost: %d\n"), m_pLoggerInfo->EventsLost); _tprintf(_T("Log Buffers Lost: %d\n"), m_pLoggerInfo->LogBuffersLost); _tprintf(_T("Real Time Buffers Lost: %d\n"), m_pLoggerInfo->RealTimeBuffersLost); _tprintf(_T("AgeLimit: %d\n"), m_pLoggerInfo->AgeLimit);
if (LogFileName == NULL) { _tprintf(_T("Buffering Mode: ")); } else { _tprintf(_T("Log File Mode: ")); } if (m_pLoggerInfo->LogFileMode & EVENT_TRACE_FILE_MODE_APPEND) { _tprintf(_T("Append ")); } if (m_pLoggerInfo->LogFileMode & EVENT_TRACE_FILE_MODE_CIRCULAR) { _tprintf(_T("Circular\n")); } else if (m_pLoggerInfo->LogFileMode & EVENT_TRACE_FILE_MODE_SEQUENTIAL) { _tprintf(_T("Sequential\n")); } else { _tprintf(_T("Sequential\n")); } if (m_pLoggerInfo->MaximumFileSize > 0) { if (m_pLoggerInfo->LogFileMode & EVENT_TRACE_USE_KBYTES_FOR_SIZE) _tprintf(_T("Maximum File Size: %d Kb\n"), m_pLoggerInfo->MaximumFileSize); else _tprintf(_T("Maximum File Size: %d Mb\n"), m_pLoggerInfo->MaximumFileSize); } if (m_pLoggerInfo->FlushTimer > 0) _tprintf(_T("Buffer Flush Timer: %d secs\n"), m_pLoggerInfo->FlushTimer); if (m_pLoggerInfo->EnableFlags != 0) { _tprintf(_T("Enabled tracing: ")); if ((loggerName != NULL) && (!_tcscmp(loggerName, KERNEL_LOGGER_NAME))) {
if (m_pLoggerInfo->EnableFlags & EVENT_TRACE_FLAG_PROCESS) _tprintf(_T("Process ")); if (m_pLoggerInfo->EnableFlags & EVENT_TRACE_FLAG_THREAD) _tprintf(_T("Thread ")); if (m_pLoggerInfo->EnableFlags & EVENT_TRACE_FLAG_DISK_IO) _tprintf(_T("Disk ")); if (m_pLoggerInfo->EnableFlags & EVENT_TRACE_FLAG_DISK_FILE_IO) _tprintf(_T("File ")); if (m_pLoggerInfo->EnableFlags & EVENT_TRACE_FLAG_MEMORY_PAGE_FAULTS) _tprintf(_T("PageFaults ")); if (m_pLoggerInfo->EnableFlags & EVENT_TRACE_FLAG_MEMORY_HARD_FAULTS) _tprintf(_T("HardFaults ")); if (m_pLoggerInfo->EnableFlags & EVENT_TRACE_FLAG_IMAGE_LOAD) _tprintf(_T("ImageLoad ")); if (m_pLoggerInfo->EnableFlags & EVENT_TRACE_FLAG_NETWORK_TCPIP) _tprintf(_T("TcpIp ")); if (m_pLoggerInfo->EnableFlags & EVENT_TRACE_FLAG_REGISTRY) _tprintf(_T("Registry ")); } else { _tprintf(_T("0x%08x"), m_pLoggerInfo->EnableFlags ); } _tprintf(_T("\n")); } if (LogFileName == NULL || _tcslen(LogFileName) == 0) { _tprintf(_T("Log Filename: default location\n")); _tprintf(_T(" %%SystemRoot%%\\System32\\LogFiles\\WMI\\trace.log\n")); } else _tprintf(_T("Log Filename: %s\n"), LogFileName);
if (m_pLoggerInfo->LogFileMode & EVENT_TRACE_USE_LOCAL_SEQUENCE) { _tprintf(_T("Local Sequence numbers in use\n")); } else if (m_pLoggerInfo->LogFileMode & EVENT_TRACE_USE_GLOBAL_SEQUENCE) { _tprintf(_T("Global Sequence numbers in use\n")); } } else {// begin_sdk
_tprintf(_T("Logger Id: %I64x\n"), m_pLoggerInfo->Wnode.HistoricalContext); _tprintf(_T("Logger Thread Id: %p\n"), m_pLoggerInfo->LoggerThreadId); if (Status != 0) return;
_tprintf(_T("Buffer Size: %d Kb"), m_pLoggerInfo->BufferSize); if (m_pLoggerInfo->LogFileMode & EVENT_TRACE_USE_PAGED_MEMORY) { _tprintf(_T(" using paged memory\n")); } else { _tprintf(_T("\n")); } _tprintf(_T("Maximum Buffers: %d\n"), m_pLoggerInfo->MaximumBuffers); _tprintf(_T("Minimum Buffers: %d\n"), m_pLoggerInfo->MinimumBuffers); _tprintf(_T("Number of Buffers: %d\n"), m_pLoggerInfo->NumberOfBuffers); _tprintf(_T("Free Buffers: %d\n"), m_pLoggerInfo->FreeBuffers); _tprintf(_T("Buffers Written: %d\n"), m_pLoggerInfo->BuffersWritten); _tprintf(_T("Events Lost: %d\n"), m_pLoggerInfo->EventsLost); _tprintf(_T("Log Buffers Lost: %d\n"), m_pLoggerInfo->LogBuffersLost); _tprintf(_T("Real Time Buffers Lost: %d\n"), m_pLoggerInfo->RealTimeBuffersLost); _tprintf(_T("AgeLimit: %d\n"), m_pLoggerInfo->AgeLimit);
if (LogFileName == NULL) { _tprintf(_T("Buffering Mode: ")); } else { _tprintf(_T("Log File Mode: ")); } if (m_pLoggerInfo->LogFileMode & EVENT_TRACE_FILE_MODE_APPEND) { _tprintf(_T("Append ")); } if (m_pLoggerInfo->LogFileMode & EVENT_TRACE_FILE_MODE_CIRCULAR) { _tprintf(_T("Circular\n")); } else if (m_pLoggerInfo->LogFileMode & EVENT_TRACE_FILE_MODE_SEQUENTIAL) { _tprintf(_T("Sequential\n")); } else { _tprintf(_T("Sequential\n")); } if (m_pLoggerInfo->LogFileMode & EVENT_TRACE_REAL_TIME_MODE) { _tprintf(_T("Real Time mode enabled"));// end_sdk
if (m_pLoggerInfo->LogFileMode & EVENT_TRACE_BUFFERING_MODE) { _tprintf(_T(": buffering only")); }// begin_sdk
_tprintf(_T("\n")); }
if (m_pLoggerInfo->MaximumFileSize > 0) { if (m_pLoggerInfo->LogFileMode & EVENT_TRACE_USE_KBYTES_FOR_SIZE) _tprintf(_T("Maximum File Size: %d Kb\n"), m_pLoggerInfo->MaximumFileSize); else _tprintf(_T("Maximum File Size: %d Mb\n"), m_pLoggerInfo->MaximumFileSize); }
if (m_pLoggerInfo->FlushTimer > 0) _tprintf(_T("Buffer Flush Timer: %d secs\n"), m_pLoggerInfo->FlushTimer);
if (m_pLoggerInfo->EnableFlags != 0) { _tprintf(_T("Enabled tracing: "));
if ((loggerName != NULL) && (!_tcscmp(loggerName, KERNEL_LOGGER_NAME))) {
if (m_pLoggerInfo->EnableFlags & EVENT_TRACE_FLAG_PROCESS) _tprintf(_T("Process ")); if (m_pLoggerInfo->EnableFlags & EVENT_TRACE_FLAG_THREAD) _tprintf(_T("Thread ")); if (m_pLoggerInfo->EnableFlags & EVENT_TRACE_FLAG_DISK_IO) _tprintf(_T("Disk ")); if (m_pLoggerInfo->EnableFlags & EVENT_TRACE_FLAG_DISK_FILE_IO) _tprintf(_T("File ")); if (m_pLoggerInfo->EnableFlags & EVENT_TRACE_FLAG_MEMORY_PAGE_FAULTS) _tprintf(_T("PageFaults ")); if (m_pLoggerInfo->EnableFlags & EVENT_TRACE_FLAG_MEMORY_HARD_FAULTS) _tprintf(_T("HardFaults ")); if (m_pLoggerInfo->EnableFlags & EVENT_TRACE_FLAG_IMAGE_LOAD) _tprintf(_T("ImageLoad ")); if (m_pLoggerInfo->EnableFlags & EVENT_TRACE_FLAG_NETWORK_TCPIP) _tprintf(_T("TcpIp ")); if (m_pLoggerInfo->EnableFlags & EVENT_TRACE_FLAG_REGISTRY) _tprintf(_T("Registry ")); }else{ _tprintf(_T("0x%08x"), m_pLoggerInfo->EnableFlags ); } _tprintf(_T("\n")); } if (LogFileName != NULL) { _tprintf(_T("Log Filename: %s\n"), LogFileName); }// end_sdk
if (m_pLoggerInfo->LogFileMode & EVENT_TRACE_USE_LOCAL_SEQUENCE) { _tprintf(_T("Local Sequence numbers in use\n")); } else if (m_pLoggerInfo->LogFileMode & EVENT_TRACE_USE_GLOBAL_SEQUENCE) { _tprintf(_T("Global Sequence numbers in use\n")); } }// begin_sdk
}
LPCTSTR CTraceViewApp::DecodeStatus(ULONG Status){ FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, Status, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
m_errorMsg.GetBuffer(MAX_STR_LENGTH), MAX_STR_LENGTH, NULL );
return m_errorMsg;}
LONG CTraceViewApp::GetGuids(LPCTSTR GuidFile){ FILE *f; TCHAR line[MAX_STR_LENGTH]; TCHAR arg[MAX_STR_LENGTH]; LPGUID guid; int i; int n;
f = _tfopen(GuidFile, _T("r"));
if(f == NULL) { return -1; }
n = 0; while(_fgetts(line, MAX_STR_LENGTH, f) != NULL) { if (_tcslen(line) < 36) continue; if (line[0] == ';' || line[0] == '\0' || line[0] == '#' || line[0] == '/') continue; n ++; m_guidArray.Add(line); }
fclose(f); return (ULONG)n;}
void CTraceViewApp::DisplayVersionInfo(){ TCHAR buffer[512]; TCHAR strProgram[MAXSTR]; DWORD dw; BYTE* pVersionInfo; LPTSTR pVersion = NULL; LPTSTR pProduct = NULL; LPTSTR pCopyRight = NULL;
if ((dw = GetModuleFileName(NULL, strProgram, MAXSTR)) == MAXSTR) { strProgram[MAXSTR-1] = _T('\0'); }
if( dw>0 ){
dw = GetFileVersionInfoSize( strProgram, &dw ); if( dw > 0 ){ pVersionInfo = (BYTE*)malloc(dw); if( NULL != pVersionInfo ){ if(GetFileVersionInfo( strProgram, 0, dw, pVersionInfo )){ LPDWORD lptr = NULL; VerQueryValue( pVersionInfo, _T("\\VarFileInfo\\Translation"), (void**)&lptr, (UINT*)&dw ); if( lptr != NULL ){ _stprintf( buffer, _T("\\StringFileInfo\\%04x%04x\\%s"), LOWORD(*lptr), HIWORD(*lptr), _T("ProductVersion") ); VerQueryValue( pVersionInfo, buffer, (void**)&pVersion, (UINT*)&dw ); _stprintf( buffer, _T("\\StringFileInfo\\%04x%04x\\%s"), LOWORD(*lptr), HIWORD(*lptr), _T("OriginalFilename") ); VerQueryValue( pVersionInfo, buffer, (void**)&pProduct, (UINT*)&dw ); _stprintf( buffer, _T("\\StringFileInfo\\%04x%04x\\%s"), LOWORD(*lptr), HIWORD(*lptr), _T("LegalCopyright") ); VerQueryValue( pVersionInfo, buffer, (void**)&pCopyRight, (UINT*)&dw ); } if( pProduct != NULL && pVersion != NULL && pCopyRight != NULL ){ _tprintf( _T("\nMicrosoft (R) %s (%s)\n%s\n\n"), pProduct, pVersion, pCopyRight ); } } free( pVersionInfo ); } } }}
BOOL CTraceViewApp::CheckFile(LPTSTR fileName){ HANDLE hFile; BYTE LogHeaderBuffer[DEFAULT_LOG_BUFFER_SIZE]; ULONG nBytesRead ; ULONG hResult ; PEVENT_TRACE pEvent; PTRACE_LOGFILE_HEADER logfileHeader ; LARGE_INTEGER lFileSize ; LARGE_INTEGER lFileSizeMB ; DWORD dwDesiredAccess , dwShareMode ; FILETIME stdTime, localTime, endlocalTime, endTime; SYSTEMTIME sysTime, endsysTime; PEVENT_TRACE_LOGFILE pLogBuffer ;
if (m_bFixUp) { dwShareMode = 0 ; dwDesiredAccess = GENERIC_READ | GENERIC_WRITE ; } else { dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE ; dwDesiredAccess = GENERIC_READ ; } hFile = CreateFile( fileName, dwDesiredAccess, dwShareMode, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL ); if (hFile == INVALID_HANDLE_VALUE) { if (m_bFixUp) { _tprintf(_T("ERROR: Fixup could not open file, Error = 0x%X\n"),GetLastError()); exit(GetLastError()); } return(FALSE); }
// While we are here we will look to see if the file is ok and fix up
// Circular buffer anomolies
if (((hResult = ReadFile(hFile, (LPVOID)LogHeaderBuffer, DEFAULT_LOG_BUFFER_SIZE, &nBytesRead, NULL)) == 0) || nBytesRead < DEFAULT_LOG_BUFFER_SIZE) { _tprintf(_T("ERROR: Fixup could not read file, Error = 0x%X, bytes read = %d(of %d)\n"), GetLastError(),nBytesRead,DEFAULT_LOG_BUFFER_SIZE); exit(ERROR_BAD_ARGUMENTS); } pEvent = (PEVENT_TRACE)LogHeaderBuffer ; logfileHeader = (PTRACE_LOGFILE_HEADER)&LogHeaderBuffer[sizeof(WMI_BUFFER_HEADER) + sizeof(SYSTEM_TRACE_HEADER)]; if (m_bVerbose) {
_tprintf(_T("Dumping Logfile Header\n")); RtlCopyMemory(&stdTime , &(logfileHeader->StartTime), sizeof(FILETIME)); FileTimeToLocalFileTime(&stdTime, &localTime); FileTimeToSystemTime(&localTime, &sysTime);
RtlCopyMemory(&endTime , &(logfileHeader->EndTime), sizeof(FILETIME)); FileTimeToLocalFileTime(&endTime, &endlocalTime); FileTimeToSystemTime(&endlocalTime, &endsysTime);
_tprintf(_T("\tStart Time %02d/%02d/%04d-%02d:%02d:%02d.%03d\n"), sysTime.wMonth, sysTime.wDay, sysTime.wYear, sysTime.wHour, sysTime.wMinute, sysTime.wSecond, sysTime.wMilliseconds); _tprintf(_T("\tBufferSize %d\n"), logfileHeader->BufferSize); _tprintf(_T("\tVersion %d\n"), logfileHeader->Version); _tprintf(_T("\tProviderVersion %d\n"), logfileHeader->ProviderVersion); _tprintf(_T("\tEnd Time %02d/%02d/%04d-%02d:%02d:%02d.%03d\n"), endsysTime.wMonth, endsysTime.wDay, endsysTime.wYear, endsysTime.wHour, endsysTime.wMinute, endsysTime.wSecond, endsysTime.wMilliseconds); _tprintf(_T("\tTimer Resolution %d\n"), logfileHeader->TimerResolution); _tprintf(_T("\tMaximum File Size %d\n"), logfileHeader->MaximumFileSize); _tprintf(_T("\tBuffers Written %d\n"), logfileHeader->BuffersWritten);
/*
_tprintf(_T("\tLogger Name %ls\n"), logfileHeader->LoggerName); _tprintf(_T("\tLogfile Name %ls\n"), logfileHeader->LogFileName);*/ _tprintf(_T("\tTimezone is %s (Bias is %dmins)\n"), logfileHeader->TimeZone.StandardName,logfileHeader->TimeZone.Bias); _tprintf(_T("\tLogfile Mode %X "), logfileHeader->LogFileMode); if (logfileHeader->LogFileMode == EVENT_TRACE_FILE_MODE_NONE) { _tprintf(_T("Logfile is off(?)\n")); } else if (logfileHeader->LogFileMode == EVENT_TRACE_FILE_MODE_SEQUENTIAL) { _tprintf(_T("Logfile is sequential\n")); } else if (logfileHeader->LogFileMode == EVENT_TRACE_FILE_MODE_CIRCULAR) { _tprintf(_T("Logfile is circular\n")); } _tprintf(_T("\tProcessorCount %d\n"), logfileHeader->NumberOfProcessors); }
if (GetFileSizeEx(hFile, &lFileSize) == 0) { _tprintf(_T("WARNING: Could not get file size, continuing\n")); } else { lFileSizeMB.QuadPart = lFileSize.QuadPart / (1024*1024) ; if (lFileSizeMB.QuadPart > logfileHeader->MaximumFileSize) { _tprintf(_T("WARNING: File size given as %dMB, should be %dMB\n"), logfileHeader->MaximumFileSize,lFileSizeMB.QuadPart); if (lFileSize.HighPart != 0) { _tprintf(_T("WARNING: Log file is TOO big")); } if (m_bFixUp) { logfileHeader->MaximumFileSize = lFileSizeMB.LowPart + 1 ; } } }
if ((logfileHeader->LogFileMode == EVENT_TRACE_FILE_MODE_CIRCULAR) && (logfileHeader->BuffersWritten== 0 )) { _tprintf(_T("WARNING: Circular Trace File did not have 'wrap' address\n")); if (m_bFixUp) { // Figure out the wrap address
INT LowBuff = 1, HighBuff, CurrentBuff, MaxBuff ; FILETIME LowTime, HighTime, CurrentTime, MaxTime ; if (lFileSize.HighPart != 0) { _tprintf(_T("ERROR: File TOO big\n")); exit(-1); } MaxBuff = (LONG)(lFileSize.QuadPart / logfileHeader->BufferSize) - 1 ; _tprintf(_T("MaxBuff=%d\n"),MaxBuff); pLogBuffer = (PEVENT_TRACE_LOGFILE)malloc(logfileHeader->BufferSize); if (SetFilePointer(hFile,0, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER) { _tprintf(_T("ERROR: Could not reset file to beginning for FixUp, Error = 0x%X"), GetLastError()); exit(GetLastError()); } for (CurrentBuff = 1 ; CurrentBuff <= MaxBuff; CurrentBuff++) { if (SetFilePointer(hFile,logfileHeader->BufferSize, NULL, FILE_CURRENT) == INVALID_SET_FILE_POINTER) { _tprintf(_T("ERROR: Could not set file to next buffer for FixUp, Error = 0x%X"), GetLastError()); exit(GetLastError()); } hResult = ReadFile(hFile, (LPVOID)pLogBuffer, logfileHeader->BufferSize, &nBytesRead, NULL); BufferCallback((PEVENT_TRACE_LOGFILE)pLogBuffer); } } } if (m_bFixUp) { if (SetFilePointer(hFile,0, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER) { _tprintf(_T("ERROR: Could not reset file to beginning for FixUp, Error = 0x%X"), GetLastError()); exit(GetLastError()); }
logfileHeader->BuffersWritten = m_bufferWrap;
if (!WriteFile(hFile,(LPVOID)LogHeaderBuffer,DEFAULT_LOG_BUFFER_SIZE,&nBytesRead, NULL)) { _tprintf(_T("ERROR: Could not Write file for FixUp, Error = 0x%X"), GetLastError()); exit(GetLastError()); } _tprintf(_T("INFO: Buffer Wrap reset to %d\n"), m_bufferWrap); }
CloseHandle(hFile);
return (TRUE);}
ULONG CTraceViewApp::BufferCallback(PEVENT_TRACE_LOGFILE pLog){ ULONG i; ULONG Status; EVENT_TRACE_PROPERTIES LoggerProp; CTraceViewApp *pApp = (CTraceViewApp *)AfxGetApp(); pApp->m_totalBuffersRead++; pApp->m_totalEventsLost += pLog->EventsLost;
if (pApp->m_bVerbose) {
FILETIME stdTime, localTime; SYSTEMTIME sysTime;
RtlCopyMemory(&stdTime , &pLog->CurrentTime, sizeof(FILETIME));
FileTimeToSystemTime(&stdTime, &sysTime);
_tprintf(_T("%02d/%02d/%04d-%02d:%02d:%02d.%03d :: %8d: Filled=%8d, Lost=%3d"), sysTime.wMonth, sysTime.wDay, sysTime.wYear, sysTime.wHour, sysTime.wMinute, sysTime.wSecond, sysTime.wMilliseconds, pApp->m_totalBuffersRead, pLog->Filled, pLog->EventsLost); _tprintf(_T(" TotalLost= %d\r"), pApp->m_totalEventsLost);
if (CompareFileTime(&pApp->m_lastTime,&stdTime) == 1) { _tprintf(_T("\nWARNING: time appears to have wrapped here (Block = %d)!\n"), pApp->m_totalBuffersRead); pApp->m_bufferWrap = pApp->m_totalBuffersRead; } pApp->m_lastTime = stdTime ; }
return (TRUE);}
void CTraceViewApp::DumpEvent(PEVENT_TRACE pEvent){ CTraceViewApp *pApp = (CTraceViewApp *)AfxGetApp(); pApp->m_totalEventCount++;
if (pEvent == NULL) { _tprintf(_T("pEvent is NULL\n")); return; } // DumpEvent() is only a wrapper, it calls FormatTraceEvent() in TracePrt.
//
if (FormatTraceEvent(pApp->m_eventListHead, pEvent, pApp->m_eventBuf, SIZEEVENTBUF, NULL) > 0) { TCHAR * eventBufWork = &pApp->m_eventBuf[0] ;#ifdef UNICODE
//sprintf(_T("Name,\"SubName(File+line#)\",ThreadID,ProcessId,SequenceNumber,CPUNumber,Indent,Function,Component,TraceLevel,TraceFlags,Text\n"));
if (pApp->m_bCSVMode) { PSTRUCTUREDMESSAGE pStructuredMessage = (PSTRUCTUREDMESSAGE)&pApp->m_eventBuf[0]; /* if (fCSVHeader && fNoCSVHeader) {
fCSVHeader = FALSE ; _stprintf((TCHAR *)pApp->m_eventBufCSV,_T("GUIDname,TypeName,ThreadId,ProcessId,SequenceNum,CpuNumber,Indent,CompnentName,SubComponentName,FunctionName,LevelName,FlagsName, String")); } */ _stprintf((TCHAR *)pApp->m_eventBufCSV,_T("%s,%s,%08X,%08X,%d,%d,%d,%s,%s,%s,%s,%s,\"%s\""), (pStructuredMessage->GuidName?&pApp->m_eventBuf[pStructuredMessage->GuidName/sizeof(TCHAR)]:_T("")), (pStructuredMessage->GuidTypeName?&pApp->m_eventBuf[pStructuredMessage->GuidTypeName/sizeof(TCHAR)]:_T("")), pStructuredMessage->ThreadId, pStructuredMessage->ProcessId, pStructuredMessage->SequenceNum, pStructuredMessage->CpuNumber, pStructuredMessage->Indent, (pStructuredMessage->ComponentName?&pApp->m_eventBuf[pStructuredMessage->ComponentName/sizeof(TCHAR)]:_T("")), (pStructuredMessage->SubComponentName?&pApp->m_eventBuf[pStructuredMessage->SubComponentName/sizeof(TCHAR)]:_T("")), (pStructuredMessage->FunctionName?&pApp->m_eventBuf[pStructuredMessage->FunctionName/sizeof(TCHAR)]:_T("")), (pStructuredMessage->LevelName?&pApp->m_eventBuf[pStructuredMessage->LevelName/sizeof(TCHAR)]:_T("")), (pStructuredMessage->FlagsName?&pApp->m_eventBuf[pStructuredMessage->FlagsName/sizeof(TCHAR)]:_T("")), (pStructuredMessage->FormattedString?&pApp->m_eventBuf[pStructuredMessage->FormattedString/sizeof(TCHAR)]:_T(""))); eventBufWork = (TCHAR *)&pApp->m_eventBufCSV[0] ;
} //
// Convert Unicode to MultiByte
//
if (WideCharToMultiByte(GetConsoleOutputCP(), 0, eventBufWork, -1, pApp->m_eventBufA, SIZEEVENTBUF * sizeof(WCHAR), NULL, NULL ) == 0 ) { //
// do nothing, let the _ftprintf handle it.
//
} else { if (!pApp->m_bSummaryOnly && !pApp->m_bDisplayOnly) { fprintf(pApp->m_pDumpFile, "%s\n", pApp->m_eventBufA); } if (pApp->m_bDebugDisplay || pApp->m_bDisplayOnly) { if (pApp->m_bODSOutput) { OutputDebugStringA(pApp->m_eventBufA); OutputDebugStringA("\n"); } else { printf("%s\n", pApp->m_eventBufA); } } return ; }#endif
if (!pApp->m_bSummaryOnly && !pApp->m_bDisplayOnly) { _ftprintf(pApp->m_pDumpFile, _T("%s\n"),pApp->m_eventBuf); } if (pApp->m_bDebugDisplay || pApp->m_bDisplayOnly) { if (pApp->m_bODSOutput) { OutputDebugString(pApp->m_eventBuf); OutputDebugString(_T("\n")); } else { _tprintf(_T("%s\n"),pApp->m_eventBuf); } } }}
void CTraceViewApp::OnHelpHelpTopics(){ ::HtmlHelp( 0, _T("traceview.chm"), HH_DISPLAY_TOC, NULL);}
|
