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.
1233 lines
39 KiB
1233 lines
39 KiB
/*++
|
|
|
|
Copyright (C) 1998-1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
provprop.cpp
|
|
|
|
Abstract:
|
|
|
|
Implementation of the trace providers general property page.
|
|
|
|
--*/
|
|
|
|
#include "stdafx.h"
|
|
#include <pdh.h> // For xxx_TIME_VALUE
|
|
#include "smlogs.h"
|
|
#include "smcfgmsg.h"
|
|
#include "provdlg.h"
|
|
#include "warndlg.h"
|
|
#include "enabldlg.h"
|
|
#include "provprop.h"
|
|
#include <pdhp.h>
|
|
#include "dialogs.h"
|
|
#include "smlogres.h"
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
USE_HANDLE_MACROS("SMLOGCFG(provprop.cpp)");
|
|
|
|
static ULONG
|
|
s_aulHelpIds[] =
|
|
{
|
|
IDC_PROV_FILENAME_DISPLAY, IDH_PROV_FILENAME_DISPLAY,
|
|
IDC_PROV_PROVIDER_LIST, IDH_PROV_PROVIDER_LIST,
|
|
IDC_PROV_ADD_BTN, IDH_PROV_ADD_BTN,
|
|
IDC_PROV_REMOVE_BTN, IDH_PROV_REMOVE_BTN,
|
|
IDC_PROV_KERNEL_BTN, IDH_PROV_KERNEL_BTN,
|
|
IDC_PROV_OTHER_BTN, IDH_PROV_OTHER_BTN,
|
|
IDC_PROV_K_PROCESS_CHK, IDH_PROV_K_PROCESS_CHK,
|
|
IDC_PROV_K_THREAD_CHK, IDH_PROV_K_THREAD_CHK,
|
|
IDC_PROV_K_DISK_IO_CHK, IDH_PROV_K_DISK_IO_CHK,
|
|
IDC_PROV_K_NETWORK_CHK, IDH_PROV_K_NETWORK_CHK,
|
|
IDC_PROV_K_SOFT_PF_CHK, IDH_PROV_K_SOFT_PF_CHK,
|
|
IDC_PROV_K_FILE_IO_CHK, IDH_PROV_K_FILE_IO_CHK,
|
|
IDC_PROV_SHOW_PROVIDERS_BTN, IDH_PROV_SHOW_PROVIDERS_BTN,
|
|
IDC_RUNAS_EDIT, IDH_RUNAS_EDIT,
|
|
IDC_SETPWD_BTN, IDH_SETPWD_BTN,
|
|
0,0
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CProvidersProperty property page
|
|
|
|
IMPLEMENT_DYNCREATE(CProvidersProperty, CSmPropertyPage)
|
|
|
|
CProvidersProperty::CProvidersProperty(MMC_COOKIE lCookie, LONG_PTR hConsole)
|
|
: CSmPropertyPage ( CProvidersProperty::IDD, hConsole )
|
|
// lCookie is really the pointer to the Log Query object
|
|
{
|
|
// ::OutputDebugStringA("\nCProvidersProperty::CProvidersProperty");
|
|
|
|
// save pointers from arg list
|
|
m_pTraceLogQuery = reinterpret_cast <CSmTraceLogQuery *>(lCookie);
|
|
ASSERT ( m_pTraceLogQuery->CastToTraceLogQuery() );
|
|
m_pQuery = dynamic_cast <CSmLogQuery*>(m_pTraceLogQuery);
|
|
|
|
m_dwMaxHorizListExtent = 0;
|
|
m_dwTraceMode = eTraceModeApplication;
|
|
|
|
// EnableAutomation();
|
|
//{{AFX_DATA_INIT(CProvidersProperty)
|
|
m_bNonsystemProvidersExist = TRUE;
|
|
m_bEnableProcessTrace = FALSE;
|
|
m_bEnableThreadTrace = FALSE;
|
|
m_bEnableDiskIoTrace = FALSE;
|
|
m_bEnableNetworkTcpipTrace = FALSE;
|
|
m_bEnableMemMgmtTrace = FALSE;
|
|
m_bEnableFileIoTrace = FALSE;
|
|
//}}AFX_DATA_INIT
|
|
}
|
|
|
|
CProvidersProperty::CProvidersProperty() : CSmPropertyPage(CProvidersProperty::IDD)
|
|
{
|
|
ASSERT (FALSE); // the constructor w/ args should be used instead
|
|
|
|
EnableAutomation();
|
|
//{{AFX_DATA_INIT(CProvidersProperty)
|
|
m_bNonsystemProvidersExist = TRUE;
|
|
m_bEnableProcessTrace = FALSE;
|
|
m_bEnableThreadTrace = FALSE;
|
|
m_bEnableDiskIoTrace = FALSE;
|
|
m_bEnableNetworkTcpipTrace = FALSE;
|
|
m_bEnableMemMgmtTrace = FALSE;
|
|
m_bEnableFileIoTrace = FALSE;
|
|
//}}AFX_DATA_INIT
|
|
m_pTraceLogQuery = NULL;
|
|
}
|
|
|
|
CProvidersProperty::~CProvidersProperty()
|
|
{
|
|
// ::OutputDebugStringA("\nCProvidersProperty::~CProvidersProperty");
|
|
}
|
|
|
|
void CProvidersProperty::OnFinalRelease()
|
|
{
|
|
// When the last reference for an automation object is released
|
|
// OnFinalRelease is called. The base class will automatically
|
|
// deletes the object. Add additional cleanup required for your
|
|
// object before calling the base class.
|
|
|
|
CPropertyPage::OnFinalRelease();
|
|
}
|
|
|
|
void CProvidersProperty::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
|
|
DoProvidersDataExchange ( pDX );
|
|
TraceModeRadioExchange ( pDX );
|
|
|
|
CPropertyPage::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CProvidersProperty)
|
|
DDX_Text(pDX, IDC_PROV_LOG_SCHED_TEXT, m_strStartText);
|
|
DDX_Text(pDX, IDC_RUNAS_EDIT, m_strUserDisplay );
|
|
DDX_Check(pDX, IDC_PROV_K_PROCESS_CHK, m_bEnableProcessTrace);
|
|
DDX_Check(pDX, IDC_PROV_K_THREAD_CHK, m_bEnableThreadTrace);
|
|
DDX_Check(pDX, IDC_PROV_K_DISK_IO_CHK, m_bEnableDiskIoTrace);
|
|
DDX_Check(pDX, IDC_PROV_K_NETWORK_CHK, m_bEnableNetworkTcpipTrace);
|
|
DDX_Check(pDX, IDC_PROV_K_SOFT_PF_CHK, m_bEnableMemMgmtTrace);
|
|
DDX_Check(pDX, IDC_PROV_K_FILE_IO_CHK, m_bEnableFileIoTrace);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CProvidersProperty, CSmPropertyPage)
|
|
//{{AFX_MSG_MAP(CProvidersProperty)
|
|
ON_BN_CLICKED(IDC_PROV_KERNEL_BTN, OnProvTraceModeRdo)
|
|
ON_BN_CLICKED(IDC_PROV_OTHER_BTN, OnProvTraceModeRdo)
|
|
ON_BN_CLICKED(IDC_PROV_SHOW_PROVIDERS_BTN, OnProvShowProvBtn)
|
|
ON_BN_CLICKED(IDC_PROV_ADD_BTN, OnProvAddBtn)
|
|
ON_BN_CLICKED(IDC_PROV_REMOVE_BTN, OnProvRemoveBtn)
|
|
ON_LBN_DBLCLK(IDC_PROV_PROVIDER_LIST, OnDblclkProvProviderList)
|
|
ON_LBN_SELCANCEL(IDC_PROV_PROVIDER_LIST, OnSelcancelProvProviderList)
|
|
ON_LBN_SELCHANGE(IDC_PROV_PROVIDER_LIST, OnSelchangeProvProviderList)
|
|
ON_BN_CLICKED(IDC_PROV_K_PROCESS_CHK, OnProvKernelEnableCheck)
|
|
ON_BN_CLICKED(IDC_PROV_K_THREAD_CHK, OnProvKernelEnableCheck)
|
|
ON_EN_CHANGE( IDC_RUNAS_EDIT, OnChangeUser )
|
|
ON_BN_CLICKED(IDC_PROV_K_DISK_IO_CHK, OnProvKernelEnableCheck)
|
|
ON_BN_CLICKED(IDC_PROV_K_NETWORK_CHK, OnProvKernelEnableCheck)
|
|
ON_BN_CLICKED(IDC_PROV_K_FILE_IO_CHK, OnProvKernelEnableCheck)
|
|
ON_BN_CLICKED(IDC_PROV_K_SOFT_PF_CHK, OnProvKernelEnableCheck)
|
|
ON_BN_CLICKED(IDC_SETPWD_BTN, OnPwdBtn)
|
|
ON_WM_DESTROY()
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
BEGIN_DISPATCH_MAP(CProvidersProperty, CSmPropertyPage)
|
|
//{{AFX_DISPATCH_MAP(CProvidersProperty)
|
|
// NOTE - the ClassWizard will add and remove mapping macros here.
|
|
//}}AFX_DISPATCH_MAP
|
|
END_DISPATCH_MAP()
|
|
|
|
// Note: we add support for IID_IProvidersProperty to support typesafe binding
|
|
// from VBA. This IID must match the GUID that is attached to the
|
|
// dispinterface in the .ODL file.
|
|
|
|
// {65154EA9-BDBE-11D1-BF99-00C04F94A83A}
|
|
static const IID IID_IProvidersProperty =
|
|
{ 0x65154ea9, 0xbdbe, 0x11d1, { 0xbf, 0x99, 0x0, 0xc0, 0x4f, 0x94, 0xa8, 0x3a } };
|
|
|
|
BEGIN_INTERFACE_MAP(CProvidersProperty, CSmPropertyPage)
|
|
INTERFACE_PART(CProvidersProperty, IID_IProvidersProperty, Dispatch)
|
|
END_INTERFACE_MAP()
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CProvidersProperty message handlers
|
|
|
|
void
|
|
CProvidersProperty::OnChangeUser()
|
|
{
|
|
//
|
|
// If you can not access remote WBEM, you can not modify RunAs info,
|
|
// changing the user name is not allowed.
|
|
//
|
|
if (m_bCanAccessRemoteWbem) {
|
|
// When the user hits OK in the password dialog,
|
|
// the user name might not have changed.
|
|
UpdateData ( TRUE );
|
|
|
|
m_strUserDisplay.TrimLeft();
|
|
m_strUserDisplay.TrimRight();
|
|
|
|
if ( 0 != m_strUserSaved.Compare ( m_strUserDisplay ) ) {
|
|
m_pTraceLogQuery->m_fDirtyPassword = PASSWORD_DIRTY;
|
|
SetModifiedPage(TRUE);
|
|
}
|
|
else {
|
|
m_pTraceLogQuery->m_fDirtyPassword &= ~PASSWORD_DIRTY;
|
|
}
|
|
//
|
|
// If default user is typed, never need to set password
|
|
//
|
|
if (m_strUserDisplay.IsEmpty() || m_strUserDisplay.GetAt(0) == L'<') {
|
|
if (m_bPwdButtonEnabled) {
|
|
GetDlgItem(IDC_SETPWD_BTN)->EnableWindow(FALSE);
|
|
m_bPwdButtonEnabled = FALSE;
|
|
}
|
|
}
|
|
else {
|
|
if (!m_bPwdButtonEnabled) {
|
|
GetDlgItem(IDC_SETPWD_BTN)->EnableWindow(TRUE);
|
|
m_bPwdButtonEnabled = TRUE;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
//
|
|
// We can not modify the RunAs info, then display
|
|
// an error message and retore the original user name in RunAs
|
|
//
|
|
UpdateData(TRUE);
|
|
if (ConnectRemoteWbemFail(m_pTraceLogQuery, FALSE)) {
|
|
GetDlgItem(IDC_RUNAS_EDIT)->SetWindowText(m_strUserSaved);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CProvidersProperty::OnPwdBtn()
|
|
{
|
|
CString strTempUser;
|
|
|
|
UpdateData();
|
|
|
|
if (!m_bCanAccessRemoteWbem) {
|
|
ConnectRemoteWbemFail(m_pTraceLogQuery, TRUE);
|
|
return;
|
|
}
|
|
|
|
MFC_TRY
|
|
strTempUser = m_strUserDisplay;
|
|
|
|
m_strUserDisplay.TrimLeft();
|
|
m_strUserDisplay.TrimRight();
|
|
|
|
m_pTraceLogQuery->m_strUser = m_strUserDisplay;
|
|
|
|
SetRunAs(m_pTraceLogQuery);
|
|
|
|
m_strUserDisplay = m_pTraceLogQuery->m_strUser;
|
|
|
|
if ( 0 != strTempUser.CompareNoCase ( m_strUserDisplay ) ) {
|
|
SetDlgItemText ( IDC_RUNAS_EDIT, m_strUserDisplay );
|
|
}
|
|
MFC_CATCH_MINIMUM;
|
|
}
|
|
|
|
void
|
|
CProvidersProperty::OnProvAddBtn()
|
|
{
|
|
ImplementAdd();
|
|
}
|
|
|
|
|
|
void
|
|
CProvidersProperty::OnProvRemoveBtn()
|
|
{
|
|
CListBox *plbProviderList;
|
|
CDC* pCDC = NULL;
|
|
LONG lThisItem;
|
|
BOOL bDone;
|
|
LONG lOrigCaret = 0;
|
|
LONG lItemStatus;
|
|
LONG lItemCount;
|
|
BOOL bChanged = FALSE;
|
|
DWORD dwItemExtent;
|
|
CString strItemText;
|
|
|
|
plbProviderList = (CListBox *)GetDlgItem(IDC_PROV_PROVIDER_LIST);
|
|
// delete all selected items in the list box and
|
|
// set the cursor to the item above the original caret position
|
|
// or the first or last if that is out of the new range
|
|
|
|
if ( NULL != plbProviderList ) {
|
|
|
|
pCDC = plbProviderList->GetDC();
|
|
if ( NULL != pCDC ) {
|
|
lOrigCaret = plbProviderList->GetCaretIndex();
|
|
lThisItem = 0;
|
|
bDone = FALSE;
|
|
// clear the max extent
|
|
m_dwMaxHorizListExtent = 0;
|
|
// clear the value
|
|
do {
|
|
lItemStatus = plbProviderList->GetSel(lThisItem);
|
|
if (lItemStatus > 0) {
|
|
// then it's selected so delete it
|
|
INT iProvIndex = (INT)plbProviderList->GetItemData ( lThisItem );
|
|
m_arrGenProviders[iProvIndex] = CSmTraceLogQuery::eNotInQuery;
|
|
plbProviderList->DeleteString ( lThisItem );
|
|
bChanged = TRUE;
|
|
} else if (lItemStatus == 0) {
|
|
// get the text length of this item since it will stay
|
|
plbProviderList->GetText(lThisItem, strItemText);
|
|
dwItemExtent = (DWORD)(pCDC->GetTextExtent(strItemText)).cx;
|
|
if (dwItemExtent > m_dwMaxHorizListExtent) {
|
|
m_dwMaxHorizListExtent = dwItemExtent;
|
|
}
|
|
// then it's not selected so go to the next one
|
|
lThisItem++;
|
|
} else {
|
|
// we've run out so exit
|
|
bDone = TRUE;
|
|
}
|
|
} while (!bDone);
|
|
}
|
|
if ( NULL != pCDC ) {
|
|
plbProviderList->ReleaseDC(pCDC);
|
|
pCDC = NULL;
|
|
}
|
|
|
|
// update the text extent of the list box
|
|
plbProviderList->SetHorizontalExtent(m_dwMaxHorizListExtent);
|
|
|
|
// see how many entries are left and update the
|
|
// caret position and the remove button state
|
|
lItemCount = plbProviderList->GetCount();
|
|
if (lItemCount > 0) {
|
|
// the update the caret
|
|
if (lOrigCaret >= lItemCount) {
|
|
lOrigCaret = lItemCount-1;
|
|
} else {
|
|
// caret should be within the list
|
|
}
|
|
plbProviderList->SetSel(lOrigCaret);
|
|
plbProviderList->SetCaretIndex(lOrigCaret);
|
|
} else {
|
|
// the list is empty so remove caret, selection
|
|
plbProviderList->SetSel(-1);
|
|
if ( eTraceModeApplication == m_dwTraceMode )
|
|
GetDlgItem(IDC_PROV_ADD_BTN)->SetFocus();
|
|
}
|
|
|
|
SetTraceModeState();
|
|
|
|
SetModifiedPage(bChanged);
|
|
}
|
|
}
|
|
|
|
void CProvidersProperty::OnDblclkProvProviderList()
|
|
{
|
|
ImplementAdd();
|
|
}
|
|
|
|
void CProvidersProperty::OnSelcancelProvProviderList()
|
|
{
|
|
SetAddRemoveBtnState();
|
|
}
|
|
|
|
void CProvidersProperty::OnSelchangeProvProviderList()
|
|
{
|
|
SetAddRemoveBtnState();
|
|
}
|
|
|
|
void
|
|
CProvidersProperty::DoProvidersDataExchange ( CDataExchange* pDX)
|
|
{
|
|
CListBox* plbInQueryProviders = (CListBox *)GetDlgItem(IDC_PROV_PROVIDER_LIST);
|
|
long lNumProviders;
|
|
CDC* pCDC = NULL;
|
|
|
|
if ( m_bNonsystemProvidersExist && NULL != plbInQueryProviders ) {
|
|
pCDC = plbInQueryProviders->GetDC();
|
|
if ( NULL != pCDC ) {
|
|
if ( TRUE == pDX->m_bSaveAndValidate ) {
|
|
|
|
// update the provider array based on list box contents.
|
|
|
|
lNumProviders = plbInQueryProviders->GetCount();
|
|
if (lNumProviders != LB_ERR) {
|
|
long lThisProvider;
|
|
INT iProvIndex;
|
|
|
|
// Reset InQuery array, retaining state for eInactive providers.
|
|
m_pTraceLogQuery->GetInQueryProviders ( m_arrGenProviders );
|
|
|
|
// Reset eInQuery to eNotInQuery, in case some were removed from the query.
|
|
for ( iProvIndex = 0; iProvIndex < m_arrGenProviders.GetSize(); iProvIndex++ ) {
|
|
if ( CSmTraceLogQuery::eInQuery == m_arrGenProviders[iProvIndex] )
|
|
m_arrGenProviders[iProvIndex] = CSmTraceLogQuery::eNotInQuery;
|
|
}
|
|
|
|
lThisProvider = 0;
|
|
while (lThisProvider < lNumProviders) {
|
|
iProvIndex = (INT)plbInQueryProviders->GetItemData( lThisProvider );
|
|
m_arrGenProviders[iProvIndex] = CSmTraceLogQuery::eInQuery;
|
|
lThisProvider++;
|
|
}
|
|
}
|
|
} else {
|
|
|
|
// Reset the list box.
|
|
CString strProviderName;
|
|
INT iProvIndex;
|
|
DWORD dwItemExtent;
|
|
|
|
ASSERT( NULL != m_pTraceLogQuery );
|
|
|
|
//load nonsystem provider list box from string in provider list
|
|
plbInQueryProviders->ResetContent();
|
|
|
|
for ( iProvIndex = 0; iProvIndex < m_arrGenProviders.GetSize(); iProvIndex++ ) {
|
|
if ( CSmTraceLogQuery::eInQuery == m_arrGenProviders[iProvIndex] ) {
|
|
INT iAddIndex;
|
|
GetProviderDescription( iProvIndex, strProviderName );
|
|
iAddIndex = plbInQueryProviders->AddString ( strProviderName );
|
|
plbInQueryProviders->SetItemData ( iAddIndex, ( DWORD ) iProvIndex );
|
|
// update list box extent
|
|
dwItemExtent = (DWORD)(pCDC->GetTextExtent(strProviderName)).cx;
|
|
if (dwItemExtent > m_dwMaxHorizListExtent) {
|
|
m_dwMaxHorizListExtent = dwItemExtent;
|
|
plbInQueryProviders->SetHorizontalExtent(dwItemExtent);
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if ( NULL != pCDC ) {
|
|
plbInQueryProviders->ReleaseDC(pCDC);
|
|
pCDC = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
CProvidersProperty::IsValidLocalData( )
|
|
{
|
|
BOOL bIsValid = TRUE;
|
|
ResourceStateManager rsm;
|
|
|
|
if ( eTraceModeKernel == m_dwTraceMode ) {
|
|
DWORD dwKernelFlags = 0;
|
|
|
|
// Ensure that the user has enabled at least one of the 4 basic Kernel traces.
|
|
if ( m_bEnableProcessTrace ) {
|
|
dwKernelFlags |= SLQ_TLI_ENABLE_PROCESS_TRACE;
|
|
}
|
|
|
|
if ( m_bEnableThreadTrace ) {
|
|
dwKernelFlags |= SLQ_TLI_ENABLE_THREAD_TRACE;
|
|
}
|
|
|
|
if ( m_bEnableDiskIoTrace ) {
|
|
dwKernelFlags |= SLQ_TLI_ENABLE_DISKIO_TRACE;
|
|
}
|
|
|
|
if ( m_bEnableNetworkTcpipTrace ) {
|
|
dwKernelFlags |= SLQ_TLI_ENABLE_NETWORK_TCPIP_TRACE;
|
|
}
|
|
|
|
if ( 0 == dwKernelFlags ) {
|
|
CString strMsg;
|
|
|
|
strMsg.LoadString ( IDS_KERNEL_PROVIDERS_REQUIRED );
|
|
|
|
MessageBox ( strMsg, m_pTraceLogQuery->GetLogName(), MB_OK | MB_ICONERROR);
|
|
SetFocusAnyPage ( IDC_PROV_KERNEL_BTN );
|
|
bIsValid = FALSE;
|
|
}
|
|
} else {
|
|
CListBox * plbInQueryProviders = (CListBox *)GetDlgItem(IDC_PROV_PROVIDER_LIST);
|
|
|
|
if ( !m_bNonsystemProvidersExist || 0 == plbInQueryProviders->GetCount() ) {
|
|
CString strMsg;
|
|
|
|
strMsg.LoadString ( IDS_APP_PROVIDERS_REQUIRED );
|
|
|
|
MessageBox ( strMsg, m_pTraceLogQuery->GetLogName(), MB_OK | MB_ICONERROR);
|
|
SetFocusAnyPage ( IDC_PROV_ADD_BTN );
|
|
bIsValid = FALSE;
|
|
}
|
|
}
|
|
|
|
return bIsValid;
|
|
}
|
|
|
|
void
|
|
CProvidersProperty::OnProvTraceModeRdo()
|
|
{
|
|
UpdateData ( TRUE );
|
|
SetModifiedPage ( TRUE );
|
|
}
|
|
|
|
void
|
|
CProvidersProperty::OnCancel()
|
|
{
|
|
m_pTraceLogQuery->SyncPropPageSharedData(); // clear memory shared between property pages.
|
|
}
|
|
|
|
BOOL
|
|
CProvidersProperty::OnApply()
|
|
{
|
|
BOOL bContinue = TRUE;
|
|
|
|
bContinue = UpdateData ( TRUE );
|
|
|
|
if ( bContinue ) {
|
|
bContinue = IsValidData(m_pTraceLogQuery, VALIDATE_APPLY );
|
|
}
|
|
|
|
// Write the data to the query.
|
|
if ( bContinue ) {
|
|
if ( eTraceModeKernel == m_dwTraceMode ) {
|
|
DWORD dwKernelFlags = 0;
|
|
INT iProvIndex;
|
|
|
|
if ( m_bEnableProcessTrace ) {
|
|
dwKernelFlags |= SLQ_TLI_ENABLE_PROCESS_TRACE;
|
|
}
|
|
|
|
if ( m_bEnableThreadTrace ) {
|
|
dwKernelFlags |= SLQ_TLI_ENABLE_THREAD_TRACE;
|
|
}
|
|
|
|
if ( m_bEnableDiskIoTrace ) {
|
|
dwKernelFlags |= SLQ_TLI_ENABLE_DISKIO_TRACE;
|
|
}
|
|
|
|
if ( m_bEnableNetworkTcpipTrace ) {
|
|
dwKernelFlags |= SLQ_TLI_ENABLE_NETWORK_TCPIP_TRACE;
|
|
}
|
|
|
|
// Ensure that the user has enabled at least one of the 4 basic Kernel traces.
|
|
ASSERT ( 0 != dwKernelFlags );
|
|
|
|
if ( m_bEnableMemMgmtTrace ) {
|
|
dwKernelFlags |= SLQ_TLI_ENABLE_MEMMAN_TRACE;
|
|
}
|
|
|
|
if ( m_bEnableFileIoTrace ) {
|
|
dwKernelFlags |= SLQ_TLI_ENABLE_FILEIO_TRACE;
|
|
}
|
|
|
|
m_pTraceLogQuery->SetKernelFlags (dwKernelFlags);
|
|
|
|
// Erase all InQuery providers.
|
|
for ( iProvIndex = 0; iProvIndex < m_arrGenProviders.GetSize(); iProvIndex++ ) {
|
|
if ( CSmTraceLogQuery::eInQuery == m_arrGenProviders[iProvIndex] )
|
|
m_arrGenProviders[iProvIndex] = CSmTraceLogQuery::eNotInQuery;
|
|
}
|
|
|
|
m_pTraceLogQuery->SetInQueryProviders ( m_arrGenProviders );
|
|
|
|
} else {
|
|
CListBox * plbInQueryProviders = (CListBox *)GetDlgItem(IDC_PROV_PROVIDER_LIST);
|
|
|
|
ASSERT ( 0 < plbInQueryProviders->GetCount() );
|
|
m_pTraceLogQuery->SetInQueryProviders ( m_arrGenProviders );
|
|
// Reset kernel flags
|
|
m_pTraceLogQuery->SetKernelFlags (0);
|
|
}
|
|
}
|
|
|
|
if ( bContinue ) {
|
|
// ApplyRunAs must be called before UpdateService
|
|
bContinue = ApplyRunAs(m_pTraceLogQuery);
|
|
}
|
|
|
|
if ( bContinue ){
|
|
bContinue = CSmPropertyPage::OnApply();
|
|
}
|
|
|
|
if ( bContinue ) {
|
|
|
|
// Save property page shared data.
|
|
m_pTraceLogQuery->UpdatePropPageSharedData();
|
|
|
|
bContinue = UpdateService ( m_pTraceLogQuery, TRUE );
|
|
}
|
|
|
|
return bContinue;
|
|
}
|
|
|
|
BOOL CProvidersProperty::OnInitDialog()
|
|
{
|
|
DWORD dwStatus;
|
|
DWORD dwKernelFlags;
|
|
CListBox * plbInQueryProviders;
|
|
BOOL bDeleteInactiveProviders = FALSE;
|
|
INT iIndex;
|
|
ResourceStateManager rsm;
|
|
|
|
//
|
|
// Here m_pTraceLogQuery should not be NULL, if it is,
|
|
// There must be something wrong.
|
|
//
|
|
if ( NULL == m_pTraceLogQuery ) {
|
|
return TRUE;
|
|
}
|
|
|
|
m_bCanAccessRemoteWbem = m_pTraceLogQuery->GetLogService()->CanAccessWbemRemote();
|
|
m_pTraceLogQuery->SetActivePropertyPage( this );
|
|
|
|
dwStatus = m_pTraceLogQuery->InitGenProvidersArray();
|
|
|
|
if ( SMCFG_INACTIVE_PROVIDER == dwStatus ) {
|
|
CString strMessage;
|
|
CString strSysMessage;
|
|
INT_PTR iResult;
|
|
|
|
FormatSmLogCfgMessage (
|
|
strMessage,
|
|
m_hModule,
|
|
SMCFG_INACTIVE_PROVIDER,
|
|
m_pTraceLogQuery->GetLogName() );
|
|
|
|
iIndex = m_pTraceLogQuery->GetFirstInactiveIndex();
|
|
|
|
while ( -1 != iIndex ) {
|
|
CString strNextName;
|
|
|
|
GetProviderDescription( iIndex, strNextName );
|
|
|
|
strMessage += L"\n ";
|
|
strMessage += strNextName;
|
|
iIndex = m_pTraceLogQuery->GetNextInactiveIndex();
|
|
}
|
|
|
|
iResult = MessageBox(
|
|
(LPCWSTR)strMessage,
|
|
m_pTraceLogQuery->GetLogName(),
|
|
MB_YESNO | MB_ICONWARNING
|
|
);
|
|
|
|
if ( IDYES == iResult ) {
|
|
bDeleteInactiveProviders = TRUE;
|
|
}
|
|
}
|
|
|
|
// Continue even if no active providers exist.
|
|
plbInQueryProviders = (CListBox *)GetDlgItem(IDC_PROV_PROVIDER_LIST);
|
|
|
|
// Initialize from model.
|
|
dwStatus = m_pTraceLogQuery->GetInQueryProviders ( m_arrGenProviders );
|
|
|
|
if ( bDeleteInactiveProviders ) {
|
|
// Delete all inactive providers
|
|
iIndex = m_pTraceLogQuery->GetFirstInactiveIndex();
|
|
while ( -1 != iIndex ) {
|
|
m_arrGenProviders[iIndex] = CSmTraceLogQuery::eNotInQuery;
|
|
|
|
iIndex = m_pTraceLogQuery->GetNextInactiveIndex();
|
|
}
|
|
}
|
|
|
|
m_bNonsystemProvidersExist = FALSE;
|
|
for ( iIndex = 0; iIndex < m_arrGenProviders.GetSize(); iIndex++ ) {
|
|
if ( m_pTraceLogQuery->IsActiveProvider ( iIndex ) ) {
|
|
m_bNonsystemProvidersExist = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
m_pTraceLogQuery->GetKernelFlags (dwKernelFlags);
|
|
|
|
if ( (dwKernelFlags & SLQ_TLI_ENABLE_KERNEL_TRACE) != 0) {
|
|
// NT5 Beta2 Kernel trace flag in use to cover all four basic trace.
|
|
m_bEnableProcessTrace = TRUE;
|
|
m_bEnableThreadTrace = TRUE;
|
|
m_bEnableDiskIoTrace = TRUE;
|
|
m_bEnableNetworkTcpipTrace = TRUE;
|
|
} else {
|
|
m_bEnableProcessTrace = (BOOL)((dwKernelFlags & SLQ_TLI_ENABLE_PROCESS_TRACE) != 0);
|
|
m_bEnableThreadTrace = (BOOL)((dwKernelFlags & SLQ_TLI_ENABLE_THREAD_TRACE) != 0);
|
|
m_bEnableDiskIoTrace = (BOOL)((dwKernelFlags & SLQ_TLI_ENABLE_DISKIO_TRACE) != 0);
|
|
m_bEnableNetworkTcpipTrace = (BOOL)((dwKernelFlags & SLQ_TLI_ENABLE_NETWORK_TCPIP_TRACE) != 0);
|
|
}
|
|
m_bEnableMemMgmtTrace = (BOOL)((dwKernelFlags & SLQ_TLI_ENABLE_MEMMAN_TRACE) != 0);
|
|
m_bEnableFileIoTrace = (BOOL)((dwKernelFlags & SLQ_TLI_ENABLE_FILEIO_TRACE) != 0);
|
|
|
|
m_dwTraceMode = ( 0 != dwKernelFlags ) ? eTraceModeKernel : eTraceModeApplication;
|
|
|
|
if ( eTraceModeApplication == m_dwTraceMode ) {
|
|
// If initial mode is set to Application, initialize the Kernel
|
|
// trace events to the default.
|
|
m_bEnableProcessTrace = TRUE;
|
|
m_bEnableThreadTrace = TRUE;
|
|
m_bEnableDiskIoTrace = TRUE;
|
|
m_bEnableNetworkTcpipTrace = TRUE;
|
|
}
|
|
|
|
CSmPropertyPage::OnInitDialog();
|
|
SetHelpIds ( (DWORD*)&s_aulHelpIds );
|
|
Initialize( m_pTraceLogQuery );
|
|
m_strUserDisplay = m_pTraceLogQuery->m_strUser;
|
|
m_strUserSaved = m_strUserDisplay;
|
|
|
|
SetDetailsGroupBoxMode();
|
|
|
|
SetTraceModeState();
|
|
|
|
if ( m_bNonsystemProvidersExist ) {
|
|
if ( 0 < plbInQueryProviders->GetCount() ) {
|
|
// select first entry
|
|
plbInQueryProviders->SetSel (0, TRUE);
|
|
plbInQueryProviders->SetCaretIndex (0, TRUE);
|
|
} else {
|
|
plbInQueryProviders->SetSel (-1, TRUE);
|
|
GetDlgItem(IDC_PROV_ADD_BTN)->SetFocus();
|
|
}
|
|
} else {
|
|
CString strNoProviders;
|
|
|
|
strNoProviders.LoadString( IDS_PROV_NO_PROVIDERS );
|
|
plbInQueryProviders->AddString( strNoProviders );
|
|
plbInQueryProviders->EnableWindow(FALSE);
|
|
|
|
GetDlgItem(IDC_PROV_REMOVE_BTN)->EnableWindow(FALSE);
|
|
GetDlgItem(IDC_PROV_ADD_BTN)->EnableWindow(FALSE);
|
|
}
|
|
|
|
if (m_pTraceLogQuery->GetLogService()->TargetOs() == OS_WIN2K) {
|
|
GetDlgItem(IDC_RUNAS_STATIC)->EnableWindow(FALSE);
|
|
GetDlgItem(IDC_RUNAS_EDIT)->EnableWindow(FALSE);
|
|
}
|
|
|
|
if (m_pTraceLogQuery->GetLogService()->TargetOs() == OS_WIN2K ||
|
|
m_strUserDisplay.IsEmpty() || m_strUserDisplay.GetAt(0) == L'<') {
|
|
|
|
GetDlgItem(IDC_SETPWD_BTN)->EnableWindow(FALSE);
|
|
m_bPwdButtonEnabled = FALSE;
|
|
}
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
void CProvidersProperty::PostNcDestroy()
|
|
{
|
|
// delete this;
|
|
|
|
if ( NULL != m_pTraceLogQuery ) {
|
|
m_pTraceLogQuery->SetActivePropertyPage( NULL );
|
|
}
|
|
|
|
CPropertyPage::PostNcDestroy();
|
|
}
|
|
|
|
//
|
|
// Helper functions.
|
|
//
|
|
void
|
|
CProvidersProperty::SetAddRemoveBtnState ( void )
|
|
{
|
|
if ( m_bNonsystemProvidersExist ) {
|
|
|
|
if ( eTraceModeKernel == m_dwTraceMode ) {
|
|
GetDlgItem(IDC_PROV_REMOVE_BTN)->EnableWindow(FALSE);
|
|
GetDlgItem(IDC_PROV_ADD_BTN)->EnableWindow(FALSE);
|
|
} else {
|
|
CListBox * plbInQueryProviders = (CListBox *)GetDlgItem(IDC_PROV_PROVIDER_LIST);
|
|
INT iTotalCount;
|
|
|
|
iTotalCount = plbInQueryProviders->GetCount();
|
|
|
|
if ( 0 < plbInQueryProviders->GetSelCount() ) {
|
|
GetDlgItem(IDC_PROV_REMOVE_BTN)->EnableWindow(TRUE);
|
|
} else {
|
|
GetDlgItem(IDC_PROV_REMOVE_BTN)->EnableWindow(FALSE);
|
|
}
|
|
|
|
if ( iTotalCount < m_arrGenProviders.GetSize() ) {
|
|
GetDlgItem(IDC_PROV_ADD_BTN)->EnableWindow(TRUE);
|
|
} else {
|
|
GetDlgItem(IDC_PROV_ADD_BTN)->EnableWindow(FALSE);
|
|
}
|
|
|
|
if ( 0 == iTotalCount ) {
|
|
plbInQueryProviders->SetSel(-1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Return the description for the trace provider specified by
|
|
// InQuery array index.
|
|
//
|
|
DWORD
|
|
CProvidersProperty::GetProviderDescription ( INT iProvIndex, CString& rstrDesc )
|
|
{
|
|
ASSERT ( NULL != m_pTraceLogQuery );
|
|
|
|
rstrDesc = m_pTraceLogQuery->GetProviderDescription ( iProvIndex );
|
|
|
|
// If the description is empty, build name from guid.
|
|
if ( rstrDesc.IsEmpty() ) {
|
|
CString strGuid;
|
|
ASSERT( !m_pTraceLogQuery->IsActiveProvider( iProvIndex) );
|
|
strGuid = m_pTraceLogQuery->GetProviderGuid( iProvIndex );
|
|
rstrDesc.Format ( IDS_PROV_UNKNOWN, strGuid );
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
BOOL
|
|
CProvidersProperty::IsEnabledProvider( INT iIndex )
|
|
{
|
|
ASSERT ( NULL != m_pTraceLogQuery );
|
|
return ( m_pTraceLogQuery->IsEnabledProvider ( iIndex ) );
|
|
}
|
|
|
|
BOOL
|
|
CProvidersProperty::IsActiveProvider( INT iIndex )
|
|
{
|
|
ASSERT ( NULL != m_pTraceLogQuery );
|
|
return ( m_pTraceLogQuery->IsActiveProvider ( iIndex ) );
|
|
}
|
|
|
|
LPCWSTR
|
|
CProvidersProperty::GetKernelProviderDescription( void )
|
|
{
|
|
ASSERT ( NULL != m_pTraceLogQuery );
|
|
return ( m_pTraceLogQuery->GetKernelProviderDescription ( ) );
|
|
}
|
|
|
|
BOOL
|
|
CProvidersProperty::GetKernelProviderEnabled( void )
|
|
{
|
|
ASSERT ( NULL != m_pTraceLogQuery );
|
|
return ( m_pTraceLogQuery->GetKernelProviderEnabled ( ) );
|
|
}
|
|
|
|
//
|
|
// Update the provided InQuery array to match the stored version.
|
|
//
|
|
DWORD
|
|
CProvidersProperty::GetInQueryProviders( CArray<CSmTraceLogQuery::eProviderState, CSmTraceLogQuery::eProviderState&>& rarrOut )
|
|
{
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
int iIndex;
|
|
|
|
rarrOut.RemoveAll();
|
|
|
|
rarrOut.SetSize( m_arrGenProviders.GetSize() );
|
|
|
|
for ( iIndex = 0; iIndex < rarrOut.GetSize(); iIndex++ ) {
|
|
rarrOut[iIndex] = m_arrGenProviders[iIndex];
|
|
}
|
|
|
|
return dwStatus;
|
|
}
|
|
|
|
//
|
|
// Load the stored InQuery providers array
|
|
// based on the provided version.
|
|
//
|
|
DWORD
|
|
CProvidersProperty::SetInQueryProviders( CArray<CSmTraceLogQuery::eProviderState, CSmTraceLogQuery::eProviderState&>& rarrIn )
|
|
{
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
int iProvIndex;
|
|
|
|
m_arrGenProviders.RemoveAll();
|
|
|
|
m_arrGenProviders.SetSize( rarrIn.GetSize() );
|
|
|
|
for ( iProvIndex = 0; iProvIndex < m_arrGenProviders.GetSize(); iProvIndex++ ) {
|
|
m_arrGenProviders[iProvIndex] = rarrIn[iProvIndex];
|
|
}
|
|
|
|
return dwStatus;
|
|
}
|
|
|
|
void
|
|
CProvidersProperty::ImplementAdd( void )
|
|
{
|
|
INT_PTR iReturn = IDCANCEL;
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
CProviderListDlg dlgAddProviders(this);
|
|
|
|
// Workaround for popup to store pointer to this page.
|
|
dlgAddProviders.SetProvidersPage( this );
|
|
|
|
iReturn = dlgAddProviders.DoModal();
|
|
}
|
|
|
|
if ( IDOK == iReturn ) {
|
|
LONG lBeforeCount;
|
|
LONG lAfterCount;
|
|
CListBox *plbProviderList;
|
|
|
|
plbProviderList = (CListBox *)GetDlgItem(IDC_PROV_PROVIDER_LIST);
|
|
|
|
// Providers array is modified by the add dialog OnOK procedure.
|
|
lBeforeCount = plbProviderList->GetCount();
|
|
UpdateData ( FALSE );
|
|
lAfterCount = plbProviderList->GetCount();
|
|
|
|
SetAddRemoveBtnState();
|
|
|
|
if ( lAfterCount > lBeforeCount ) {
|
|
SetModifiedPage ( TRUE );
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
CProvidersProperty::UpdateLogStartString ()
|
|
{
|
|
eStartType eCurrentStartType;
|
|
int nResId = 0;
|
|
ResourceStateManager rsm;
|
|
|
|
eCurrentStartType = DetermineCurrentStartType();
|
|
|
|
if ( eStartManually == eCurrentStartType ) {
|
|
nResId = IDS_LOG_START_MANUALLY;
|
|
} else if ( eStartImmediately == eCurrentStartType ) {
|
|
nResId = IDS_LOG_START_IMMED;
|
|
} else if ( eStartSched == eCurrentStartType ) {
|
|
nResId = IDS_LOG_START_SCHED;
|
|
}
|
|
|
|
if ( 0 != nResId ) {
|
|
m_strStartText.LoadString(nResId);
|
|
} else {
|
|
m_strStartText.Empty();
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void
|
|
CProvidersProperty::UpdateFileNameString ()
|
|
{
|
|
m_strFileNameDisplay.Empty();
|
|
|
|
CreateSampleFileName (
|
|
m_pTraceLogQuery->GetLogName(),
|
|
m_pTraceLogQuery->GetLogService()->GetMachineName(),
|
|
m_SharedData.strFolderName,
|
|
m_SharedData.strFileBaseName,
|
|
m_SharedData.strSqlName,
|
|
m_SharedData.dwSuffix,
|
|
m_SharedData.dwLogFileType,
|
|
m_SharedData.dwSerialNumber,
|
|
m_strFileNameDisplay);
|
|
|
|
SetDlgItemText( IDC_PROV_FILENAME_DISPLAY, m_strFileNameDisplay );
|
|
|
|
// Clear the selection
|
|
((CEdit*)GetDlgItem( IDC_PROV_FILENAME_DISPLAY ))->SetSel ( -1, 0 );
|
|
|
|
return;
|
|
}
|
|
|
|
BOOL
|
|
CProvidersProperty::OnSetActive()
|
|
{
|
|
|
|
BOOL bReturn;
|
|
|
|
bReturn = CSmPropertyPage::OnSetActive();
|
|
if (!bReturn) return FALSE;
|
|
|
|
ResourceStateManager rsm;
|
|
|
|
m_pTraceLogQuery->GetPropPageSharedData ( &m_SharedData );
|
|
|
|
UpdateFileNameString();
|
|
|
|
UpdateLogStartString();
|
|
m_strUserDisplay = m_pTraceLogQuery->m_strUser;
|
|
|
|
UpdateData(FALSE); //to load the edit & combo box
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
CProvidersProperty::OnKillActive()
|
|
{
|
|
BOOL bContinue = TRUE;
|
|
|
|
bContinue = CPropertyPage::OnKillActive();
|
|
|
|
if ( bContinue ) {
|
|
m_pTraceLogQuery->m_strUser = m_strUserDisplay;
|
|
bContinue = IsValidData(m_pTraceLogQuery, VALIDATE_FOCUS );
|
|
}
|
|
|
|
// The providers page does not modify shared data, so no reason to update it.
|
|
|
|
if ( bContinue ) {
|
|
SetIsActive ( FALSE );
|
|
}
|
|
|
|
return bContinue;
|
|
}
|
|
|
|
void
|
|
CProvidersProperty::OnProvKernelEnableCheck()
|
|
{
|
|
BOOL bMemFlag = m_bEnableMemMgmtTrace;
|
|
BOOL bFileFlag = m_bEnableFileIoTrace;
|
|
|
|
UpdateData(TRUE);
|
|
SetModifiedPage(TRUE);
|
|
|
|
bMemFlag = (!bMemFlag && m_bEnableMemMgmtTrace);
|
|
bFileFlag = (!bFileFlag && m_bEnableFileIoTrace);
|
|
|
|
if (bMemFlag || bFileFlag) {
|
|
long nErr;
|
|
HKEY hKey = NULL;
|
|
DWORD dwWarnFlag;
|
|
DWORD dwDataType = 0;
|
|
DWORD dwDataSize = 0;
|
|
DWORD dwDisposition;
|
|
|
|
// User has checked expensive file io flag
|
|
// check registry setting to see if we need to pop up warning dialog
|
|
nErr = RegOpenKey( HKEY_CURRENT_USER,
|
|
L"Software\\Microsoft\\PerformanceLogsandAlerts",
|
|
&hKey
|
|
);
|
|
dwWarnFlag = 0;
|
|
if( nErr == ERROR_SUCCESS ) {
|
|
|
|
dwDataSize = sizeof(DWORD);
|
|
nErr = RegQueryValueExW(
|
|
hKey,
|
|
(bMemFlag ? L"NoWarnPageFault" : L"NoWarnFileIo"),
|
|
NULL,
|
|
&dwDataType,
|
|
(LPBYTE) &dwWarnFlag,
|
|
(LPDWORD) &dwDataSize
|
|
);
|
|
if ( (dwDataType != REG_DWORD) || (dwDataSize != sizeof(DWORD)))
|
|
dwWarnFlag = 0;
|
|
|
|
nErr = RegCloseKey( hKey );
|
|
hKey = NULL;
|
|
if( ERROR_SUCCESS != nErr ) {
|
|
DisplayError( GetLastError(), L"Close PerfLog user key failed" );
|
|
}
|
|
}
|
|
if (!dwWarnFlag || nErr != ERROR_SUCCESS) {
|
|
// Pop a dialog here. Need to do a RegQuerySetValue dialog is checked to keep quiet
|
|
// bMemFlag & bFileFlag gives a clue about what it is doing
|
|
|
|
CWarnDlg WarnDlg;
|
|
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
|
|
WarnDlg.SetProvidersPage( this );
|
|
|
|
if (IDOK == WarnDlg.DoModal()){
|
|
if (WarnDlg.m_CheckNoMore){
|
|
dwWarnFlag = WarnDlg.m_CheckNoMore;
|
|
|
|
nErr = RegCreateKeyEx( HKEY_CURRENT_USER,
|
|
L"Software\\Microsoft\\PerformanceLogsAndAlerts",
|
|
0,
|
|
L"REG_DWORD",
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_READ | KEY_WRITE,
|
|
NULL,
|
|
&hKey,
|
|
&dwDisposition);
|
|
/*
|
|
if(ERROR_SUCCESS == nErr){
|
|
if (dwDisposition == REG_CREATED_NEW_KEY){
|
|
//just in case I need this
|
|
}else if (dwDisposition == REG_OPENED_EXISTING_KEY){
|
|
//Just in case I need this
|
|
}
|
|
}
|
|
*/
|
|
if( nErr == ERROR_SUCCESS ) {
|
|
dwDataSize = sizeof(DWORD);
|
|
nErr = RegSetValueEx(hKey,
|
|
(bMemFlag ? L"NoWarnPageFault" : L"NoWarnFileIo" ),
|
|
NULL,
|
|
REG_DWORD,
|
|
(LPBYTE) &dwWarnFlag,
|
|
dwDataSize
|
|
);
|
|
if( ERROR_SUCCESS != nErr ) {
|
|
DisplayError( GetLastError(), L"Set PerfLog User warn value failed" );
|
|
}
|
|
|
|
nErr = RegCloseKey( hKey );
|
|
hKey = NULL;
|
|
if( ERROR_SUCCESS != nErr ) {
|
|
DisplayError( GetLastError(), L"Close PerfLog user key failed" );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
CProvidersProperty::OnProvShowProvBtn()
|
|
{
|
|
CActiveProviderDlg ProvLstDlg;
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
|
|
ProvLstDlg.SetProvidersPage( this );
|
|
|
|
ProvLstDlg.DoModal();
|
|
|
|
}
|
|
/*
|
|
void
|
|
CProvidersProperty::OnProvDetailsBtn()
|
|
{
|
|
SetDetailsGroupBoxMode();
|
|
}
|
|
*/
|
|
BOOL
|
|
CProvidersProperty::SetDetailsGroupBoxMode()
|
|
{
|
|
|
|
UINT nWindowState;
|
|
|
|
ResourceStateManager rsm;
|
|
|
|
nWindowState = SW_SHOW;
|
|
|
|
GetDlgItem(IDC_PROV_K_PROCESS_CHK)->ShowWindow(nWindowState);
|
|
GetDlgItem(IDC_PROV_K_THREAD_CHK)->ShowWindow(nWindowState);
|
|
GetDlgItem(IDC_PROV_K_DISK_IO_CHK)->ShowWindow(nWindowState);
|
|
GetDlgItem(IDC_PROV_K_NETWORK_CHK)->ShowWindow(nWindowState);
|
|
GetDlgItem(IDC_PROV_K_SOFT_PF_CHK)->ShowWindow(nWindowState);
|
|
GetDlgItem(IDC_PROV_K_FILE_IO_CHK)->ShowWindow(nWindowState);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
CProvidersProperty::TraceModeRadioExchange(CDataExchange* pDX)
|
|
{
|
|
if ( !pDX->m_bSaveAndValidate ) {
|
|
// Load control value from data
|
|
|
|
switch ( m_dwTraceMode ) {
|
|
case eTraceModeKernel:
|
|
m_nTraceModeRdo = 0;
|
|
break;
|
|
case eTraceModeApplication:
|
|
m_nTraceModeRdo = 1;
|
|
break;
|
|
default:
|
|
;
|
|
break;
|
|
}
|
|
}
|
|
|
|
DDX_Radio(pDX, IDC_PROV_KERNEL_BTN, m_nTraceModeRdo);
|
|
|
|
if ( pDX->m_bSaveAndValidate ) {
|
|
|
|
switch ( m_nTraceModeRdo ) {
|
|
case 0:
|
|
m_dwTraceMode = eTraceModeKernel;
|
|
break;
|
|
case 1:
|
|
m_dwTraceMode = eTraceModeApplication;
|
|
break;
|
|
default:
|
|
;
|
|
break;
|
|
}
|
|
SetTraceModeState();
|
|
}
|
|
|
|
}
|
|
|
|
void
|
|
CProvidersProperty::SetTraceModeState ( void )
|
|
{
|
|
BOOL bEnable;
|
|
|
|
bEnable = (eTraceModeKernel == m_dwTraceMode) ? TRUE : FALSE;
|
|
// Kernel trace controls
|
|
// GetDlgItem(IDC_PROV_SHOW_ADV_BTN)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_PROV_K_PROCESS_CHK)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_PROV_K_THREAD_CHK)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_PROV_K_DISK_IO_CHK)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_PROV_K_NETWORK_CHK)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_PROV_K_SOFT_PF_CHK)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_PROV_K_FILE_IO_CHK)->EnableWindow(bEnable);
|
|
|
|
if ( m_bNonsystemProvidersExist ) {
|
|
bEnable = !bEnable;
|
|
// Application trace controls
|
|
GetDlgItem(IDC_PROV_PROVIDER_LIST)->EnableWindow(bEnable);
|
|
SetAddRemoveBtnState();
|
|
}
|
|
|
|
}
|
|
|
|
DWORD
|
|
CProvidersProperty::GetGenProviderCount ( INT& iCount )
|
|
{
|
|
return m_pTraceLogQuery->GetGenProviderCount( iCount );
|
|
|
|
}
|
|
|
|
void CProvidersProperty::GetMachineDisplayName ( CString& rstrMachineName )
|
|
{
|
|
m_pTraceLogQuery->GetMachineDisplayName( rstrMachineName );
|
|
return;
|
|
}
|
|
|
|
CSmTraceLogQuery*
|
|
CProvidersProperty::GetTraceQuery ( void )
|
|
{
|
|
return m_pTraceLogQuery;
|
|
}
|