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.
1344 lines
34 KiB
1344 lines
34 KiB
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
//
|
|
// HTTPXPC.CXX
|
|
//
|
|
// Copyright 1986-1997 Microsoft Corporation, All Rights Reserved
|
|
//
|
|
// Monitor-side for W3 integration.
|
|
//
|
|
|
|
#include "w3p.hxx" // W3SVC Precompiled header
|
|
|
|
#include <windows.h>
|
|
#include <winperf.h>
|
|
#include "pclib.hxx"
|
|
#include "httpxctr.hxx" // Perf counter title index #defines
|
|
#include "caldbg.h" // For DebugTrace()/Assert()
|
|
|
|
|
|
EXTERN_C const WCHAR gc_wszSignature[] = L"HTTPEXT";
|
|
EXTERN_C const CHAR gc_szDbgIni[] = "HTTPXPC.INI";
|
|
EXTERN_C const INT gc_cchDbgIni = 11;
|
|
EXTERN_C const CHAR gc_szSignature[] = "HTTPXPC";
|
|
|
|
//
|
|
// This is declared here because the shared memory library
|
|
// now requires any dll or exe using it to define this function.
|
|
// However this function is only used for the shared lock cache
|
|
// so we do not need to actually implement it for perf counters.
|
|
//
|
|
namespace IMPLSTUB
|
|
{
|
|
VOID __fastcall SaveHandle(HANDLE hHandle);
|
|
}
|
|
|
|
VOID __fastcall
|
|
IMPLSTUB::SaveHandle(HANDLE h)
|
|
{
|
|
Assert ( FALSE );
|
|
return;
|
|
}
|
|
// end of hack working around shared lock cache.
|
|
|
|
|
|
//
|
|
// The following macros, templates and classes are derived from
|
|
// sources in the DAV project.
|
|
//
|
|
|
|
// ========================================================================
|
|
//
|
|
// TEMPLATE CLASS Singleton
|
|
//
|
|
// Use this template to implement classes that can only have one instance.
|
|
// NOTE: For ref-counted or on-demand global objects, see below
|
|
// (RefCountedGlobal and OnDemandGlobal).
|
|
//
|
|
// The Singleton template provides the following:
|
|
//
|
|
// o a common memory layout for singleton classes which
|
|
// allows template folding to reduce overall code size.
|
|
//
|
|
// o an instantiation mechanism that verifies (asserts)
|
|
// that only instance of your class ever exists.
|
|
//
|
|
// o asserts to catch any code which attempts to use
|
|
// your class when it's not initialized.
|
|
//
|
|
// To use this template, declare your class like this:
|
|
//
|
|
// class YourClass : private Singleton<YourClass>
|
|
// {
|
|
// //
|
|
// // Declare Singleton as a friend of YourClass
|
|
// // if YourClass's constructor is private (which it
|
|
// // should be since YourClass is a singleton and
|
|
// // should not be allowed to arbitrarily create
|
|
// // instances of it).
|
|
// //
|
|
// friend class Singleton<YourClass>;
|
|
//
|
|
// //
|
|
// // YourClass private members. Since the 'staticness'
|
|
// // of YourClass is provided entirely by this template,
|
|
// // you do not need to declare your members as 'static'
|
|
// // and you should use standard Hungarian class member
|
|
// // naming conventions (e.g. m_dwShoeSize).
|
|
// //
|
|
// [...]
|
|
//
|
|
// public:
|
|
// //
|
|
// // Public declarations for YourClass. Among these should
|
|
// // be static functions to init and deinit YourClass which
|
|
// // would call CreateInstance() and DestroyInstance()
|
|
// // respectively. Or, you could just expose these functions
|
|
// // directly to clients of YourClass with using declarations:
|
|
// //
|
|
// // using Singleton<YourClass>::CreateInstance;
|
|
// // using Singleton<YourClass>::DestroyInstance;
|
|
// //
|
|
// // Similarly, YourClass will probably have additional
|
|
// // static methods which access or operate on the
|
|
// // singleton instance. These will call Instance()
|
|
// // to get at the global instance. Or, though it's
|
|
// // not recommended from an encapsulation standpoint,
|
|
// // you could expose the global instance directly to
|
|
// // clients with:
|
|
// //
|
|
// // using Singleton<YourClass>::Instance;
|
|
// //
|
|
// [...]
|
|
// };
|
|
//
|
|
template<class _X>
|
|
class Singleton
|
|
{
|
|
//
|
|
// Space for the sole instance
|
|
//
|
|
static BYTE sm_rgbInstance[];
|
|
|
|
//
|
|
// Pointer to the instance
|
|
//
|
|
static _X * sm_pInstance;
|
|
|
|
public:
|
|
// STATICS
|
|
//
|
|
|
|
//
|
|
// Create the single, global instance of class _X.
|
|
//
|
|
static _X& CreateInstance()
|
|
{
|
|
//
|
|
// This actually calls Singleton::new()
|
|
// (defined below), but calls to new()
|
|
// must always be unqualified.
|
|
//
|
|
return *(new _X());
|
|
}
|
|
|
|
//
|
|
// Destroy the single, global instance of class _X.
|
|
//
|
|
static VOID DestroyInstance()
|
|
{
|
|
//
|
|
// This actually calls Singleton::delete()
|
|
// (defined below), but calls to delete()
|
|
// must always be unqualified.
|
|
//
|
|
delete sm_pInstance;
|
|
}
|
|
|
|
//
|
|
// Provide access to the single, global instance of class _X.
|
|
//
|
|
static _X& Instance()
|
|
{
|
|
Assert( sm_pInstance );
|
|
|
|
return *sm_pInstance;
|
|
}
|
|
|
|
//
|
|
// Singleton operator new and operator delete "allocate"
|
|
// space for the object in static memory. These must be
|
|
// defined public for syntactic reasons. Do NOT call them
|
|
// directly!! Use CreateInstance()/DestroyInstance().
|
|
//
|
|
static void * operator new(size_t)
|
|
{
|
|
Assert( !sm_pInstance );
|
|
|
|
//
|
|
// Just return a pointer to the space
|
|
// in which to instantiate the object.
|
|
//
|
|
sm_pInstance = reinterpret_cast<_X *>(sm_rgbInstance);
|
|
return sm_pInstance;
|
|
}
|
|
|
|
static void operator delete(void *, size_t)
|
|
{
|
|
Assert( sm_pInstance );
|
|
|
|
//
|
|
// Since nothing was done to allocate space
|
|
// for the instance, we don't do anything
|
|
// here to free it.
|
|
//
|
|
sm_pInstance = NULL;
|
|
}
|
|
|
|
};
|
|
|
|
//
|
|
// Space for the sole instance of class _X
|
|
//
|
|
template<class _X>
|
|
BYTE Singleton<_X>::sm_rgbInstance[sizeof(_X)];
|
|
|
|
//
|
|
// Pointer to the instance
|
|
//
|
|
template<class _X>
|
|
_X * Singleton<_X>::sm_pInstance = NULL;
|
|
|
|
|
|
// ========================================================================
|
|
//
|
|
// CLASS _Empty
|
|
//
|
|
// A completely empty, but instantiatable class. Use the _Empty class
|
|
// to get around the syntactic inability to instantiate anything of
|
|
// type void (or VOID).
|
|
//
|
|
// In retail builds, _Empty has the same memory footprint and code
|
|
// impact as void -- none.
|
|
//
|
|
// See the RefCountedGlobal template below for a usage example.
|
|
//
|
|
class _Empty
|
|
{
|
|
// NOT IMPLEMENTED
|
|
//
|
|
_Empty( const _Empty& );
|
|
_Empty& operator=( const _Empty& );
|
|
|
|
public:
|
|
_Empty() {}
|
|
~_Empty() {}
|
|
};
|
|
|
|
|
|
// ========================================================================
|
|
//
|
|
// TEMPLATE CLASS RefCountedGlobal
|
|
//
|
|
// Use this template as boilerplate for any class that encapsulates
|
|
// a global, refcounted initialization/deinitialization process.
|
|
//
|
|
// This template maintains proper refcounting and synchronization when
|
|
// there are multiple threads trying to initialize and deinitialize
|
|
// references at the same time. And it does so without a critical
|
|
// section.
|
|
//
|
|
// To use this template, declare your class like this:
|
|
//
|
|
// class YourClass : private RefCountedGlobal<YourClass>
|
|
// {
|
|
// //
|
|
// // Declare Singleton and RefCountedGlobal as friends
|
|
// // of YourClass so that they can call your private
|
|
// // initialization functions.
|
|
// //
|
|
// friend class Singleton<YourClass>;
|
|
// friend class RefCountedGlobal<YourClass>;
|
|
//
|
|
// //
|
|
// // Private declarations for YourClass
|
|
// //
|
|
// [...]
|
|
//
|
|
// //
|
|
// // Failable initialization function. This function
|
|
// // should perform any failable initialization of the
|
|
// // instance of YourClass. It should return TRUE
|
|
// // if initialization succeeds, and FALSE otherwise.
|
|
// // If YourClass does not have any initialization that
|
|
// // can fail then you should implement this function inline
|
|
// // to just return TRUE.
|
|
// //
|
|
// BOOL FInit();
|
|
//
|
|
// public:
|
|
// //
|
|
// // Public declarations for YourClass. Among these should
|
|
// // be static functions to init and deinit YourClass. These
|
|
// // functions would call DwInitRef() and DeinitRef() respectively.
|
|
// // Or, you could just expose DwInitRef() and DeinitRef()
|
|
// // directly to clients of YourClass with using declarations:
|
|
// //
|
|
// // using RefCountedGlobal<YourClass>::DwInitRef;
|
|
// // using RefCountedGlobal<YourClass>::DeinitRef;
|
|
// //
|
|
// [...]
|
|
// };
|
|
//
|
|
// If YourClass::FInit() succeeds (returns TRUE), then DwInitRef()
|
|
// returns the new refcount. If YourClass::FInit() fails (returns
|
|
// FALSE), then DwInitRef() returns 0.
|
|
//
|
|
// See \cal\src\inc\memx.h for sample usage.
|
|
//
|
|
// If YourClass::FInit() requires initialization parameters, you can
|
|
// still use the RefCountedGlobal template. You just need to provide
|
|
// your parameter type in the template instantiation and declare your
|
|
// FInit() to take a const reference to a parameter of that type:
|
|
//
|
|
// class YourClass : private RefCountedGlobal<YourClass, YourParameterType>
|
|
// {
|
|
// //
|
|
// // Declare Singleton and RefCountedGlobal as friends
|
|
// // of YourClass so that htey can call your private
|
|
// // initialization functions.
|
|
// //
|
|
// // Note the added parameter type to the RefCountedGlobal
|
|
// // declaration.
|
|
// //
|
|
// friend class Singleton<YourClass>;
|
|
// friend class RefCountedGlobal<YourClass, YourParameterType>;
|
|
//
|
|
// //
|
|
// // Private declarations for YourClass
|
|
// //
|
|
// [...]
|
|
//
|
|
// //
|
|
// // Failable initialization function. This function
|
|
// // now takes a const ref to the initialization parameters.
|
|
// //
|
|
// BOOL FInit( const YourParameterType& initParam );
|
|
//
|
|
// public:
|
|
// //
|
|
// // Public declarations for YourClass
|
|
// //
|
|
// [...]
|
|
// };
|
|
//
|
|
// See \cal\src\httpext\entry.cpp for an example of this usage.
|
|
//
|
|
template<class _X, class _ParmType = _Empty>
|
|
class RefCountedGlobal : private Singleton<_X>
|
|
{
|
|
//
|
|
// The object's reference count.
|
|
//
|
|
static LONG sm_lcRef;
|
|
|
|
//
|
|
// Set of states which describe the object's state
|
|
// of initialization. The object's state is
|
|
// STATE_UNKNOWN while it is being initialized or
|
|
// deinitialized.
|
|
//
|
|
enum
|
|
{
|
|
STATE_UNINITIALIZED,
|
|
STATE_INITIALIZED,
|
|
STATE_UNKNOWN
|
|
};
|
|
|
|
static LONG sm_lState;
|
|
|
|
//
|
|
// Member template that generates an appropriately-typed,
|
|
// (inline) function that calls _X::FInit with initialization
|
|
// parameters.
|
|
//
|
|
template<class _P> static BOOL
|
|
FInit( const _P& parms ) { return Instance().FInit( parms ); }
|
|
|
|
//
|
|
// Specialization of the above member template for
|
|
// the _Empty parameter type, which calls _X::FInit
|
|
// without initialization parameters.
|
|
//
|
|
static BOOL FInit( const _Empty& ) { return Instance().FInit(); }
|
|
|
|
protected:
|
|
//
|
|
// Expose access to the single instance of class _X
|
|
//
|
|
using Singleton<_X>::Instance;
|
|
|
|
//
|
|
// Expose operator new and operator delete from
|
|
// the Singleton template so that they will be
|
|
// used rather than the default new and delete
|
|
// to "allocate" space for the instance of class _X.
|
|
//
|
|
using Singleton<_X>::operator new;
|
|
using Singleton<_X>::operator delete;
|
|
|
|
static BOOL FInitialized()
|
|
{
|
|
return sm_lState == STATE_INITIALIZED;
|
|
}
|
|
|
|
static LONG CRef()
|
|
{
|
|
return sm_lcRef;
|
|
}
|
|
|
|
public:
|
|
static DWORD DwInitRef( const _ParmType& parms )
|
|
{
|
|
LONG lcRef;
|
|
|
|
//
|
|
// Assert the invariant condition that we never have a
|
|
// reference without the state being initialized.
|
|
//
|
|
Assert( sm_lState != STATE_INITIALIZED || sm_lcRef >= 1 );
|
|
|
|
//
|
|
// Add the reference for the instance we're about
|
|
// to initialize. Doing this now simplifies the
|
|
// code below at the expense of having to decrement
|
|
// if first time initialization (FInit()) fails.
|
|
// The only thing critical to the design is that
|
|
// at any point, when sm_lState is STATE_INITIALIZED,
|
|
// sm_lcRef is at least 1.
|
|
//
|
|
lcRef = InterlockedIncrement( &sm_lcRef );
|
|
Assert( lcRef > 0 );
|
|
|
|
//
|
|
// Don't proceed until the object is initialized.
|
|
//
|
|
while ( sm_lState != STATE_INITIALIZED )
|
|
{
|
|
//
|
|
// Simultaneously check whether initialization has
|
|
// started and, if it has not, start it.
|
|
//
|
|
LONG lStatePrev = InterlockedCompareExchange(
|
|
&sm_lState,
|
|
STATE_UNKNOWN,
|
|
STATE_UNINITIALIZED );
|
|
|
|
//
|
|
// If we're starting first time initialization,
|
|
// then create and initialize the sole instance.
|
|
//
|
|
if ( lStatePrev == STATE_UNINITIALIZED )
|
|
{
|
|
CreateInstance();
|
|
|
|
// This calls our private member template FInit()
|
|
// (declared above), which in turn calls _X::Finit()
|
|
// with the appropriate parameters.
|
|
//
|
|
if ( FInit( parms ) )
|
|
{
|
|
sm_lState = STATE_INITIALIZED;
|
|
break;
|
|
}
|
|
|
|
// We failed to init.
|
|
// Tear down now.
|
|
//
|
|
|
|
Assert( lcRef == 1 );
|
|
Assert( sm_lState == STATE_UNKNOWN );
|
|
|
|
// Let go of our ref on the object.
|
|
// Destroy the object.
|
|
// And LAST, set the state to UNINITIALIZED.
|
|
// NOTE: This will let the next caller through the
|
|
// InterlockedCompare above.
|
|
//
|
|
InterlockedDecrement( &sm_lcRef );
|
|
DestroyInstance();
|
|
sm_lState = STATE_UNINITIALIZED;
|
|
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// If first time initialization is in progress on
|
|
// another thread, then get out of the way so
|
|
// it can finish.
|
|
//
|
|
//$OPT We should probably spin rather than Sleep()
|
|
//$OPT on multi-proc machines on the assumption that
|
|
//$OPT we only get here on a processor other than
|
|
//$OPT the one which is doing the initialization
|
|
//$OPT and we don't want to invite a task switch
|
|
//$OPT by calling Sleep() while we are waiting
|
|
//$OPT for initialization to complete.
|
|
//
|
|
if ( lStatePrev == STATE_UNKNOWN )
|
|
Sleep(0);
|
|
}
|
|
|
|
//
|
|
// At this point, there must be at least
|
|
// one initialized reference.
|
|
//
|
|
Assert( sm_lState == STATE_INITIALIZED );
|
|
Assert( sm_lcRef > 0 );
|
|
|
|
return static_cast<DWORD>(lcRef);
|
|
}
|
|
|
|
static VOID DeinitRef()
|
|
{
|
|
//
|
|
// At this point, there must be at least
|
|
// one initialized reference.
|
|
//
|
|
Assert( sm_lState == STATE_INITIALIZED );
|
|
Assert( sm_lcRef > 0 );
|
|
|
|
//
|
|
// Remove that reference. If it is the last
|
|
// then deinit the object.
|
|
//
|
|
if ( 0 == InterlockedDecrement( &sm_lcRef ) )
|
|
{
|
|
//
|
|
// After releasing the last reference, declare that
|
|
// the object is in an unknown state. This prevents
|
|
// other threads trying to re-initialize the object
|
|
// from proceeding until we're done.
|
|
//
|
|
sm_lState = STATE_UNKNOWN;
|
|
|
|
//
|
|
// There is a tiny window between decrementing the
|
|
// refcount and changing the state where another
|
|
// initialization could have come through. Test this
|
|
// by rechecking the refcount.
|
|
//
|
|
if ( 0 == sm_lcRef )
|
|
{
|
|
//
|
|
// If the refcount is still zero, then no
|
|
// initializations happened before we changed
|
|
// states. At this point, if an initialization
|
|
// starts, it will block until we change state,
|
|
// so it is safe to actually destroy the instance.
|
|
//
|
|
DestroyInstance();
|
|
|
|
//
|
|
// Once the object has been deinitialized, update
|
|
// the state information. This unblocks any
|
|
// initializations waiting to happen.
|
|
//
|
|
sm_lState = STATE_UNINITIALIZED;
|
|
}
|
|
else // refcount is now non-zero
|
|
{
|
|
//
|
|
// If the refcount is no longer zero, then an
|
|
// initialization happened between decrementing
|
|
// the refcount above and entering the unknown
|
|
// state. When that happens, DO NOT deinit --
|
|
// there is now another valid reference somewhere.
|
|
// Instead, just restore the object's state to let
|
|
// other references proceed.
|
|
//
|
|
sm_lState = STATE_INITIALIZED;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Assert the invariant condition that we never have a
|
|
// reference without the state being initialized.
|
|
//
|
|
Assert( sm_lState != STATE_INITIALIZED || sm_lcRef >= 1 );
|
|
}
|
|
|
|
// This provides a no-parameter version of DwInitRef
|
|
// for clients that do not need any parameters in FInit().
|
|
//
|
|
static DWORD DwInitRef()
|
|
{
|
|
_Empty e;
|
|
|
|
return DwInitRef( e );
|
|
}
|
|
};
|
|
|
|
template<class _X, class _ParmType>
|
|
LONG RefCountedGlobal<_X, _ParmType>::sm_lcRef = 0;
|
|
|
|
template<class _X, class _ParmType>
|
|
LONG RefCountedGlobal<_X, _ParmType>::sm_lState = STATE_UNINITIALIZED;
|
|
|
|
|
|
// ========================================================================
|
|
// SHARED MEMORY HANDLES
|
|
//
|
|
// They are always defined as 32 bit values
|
|
//
|
|
#ifdef _WIN64
|
|
typedef VOID * __ptr32 SHMEMHANDLE;
|
|
#else
|
|
typedef HANDLE SHMEMHANDLE;
|
|
#endif
|
|
|
|
// ========================================================================
|
|
//
|
|
// NAMESPACE SMH
|
|
//
|
|
// Differentiates the shared memory heap allocation functions
|
|
// from all of the other various heap allocation functions
|
|
// in existence.
|
|
//
|
|
// Yes, this could have been done with a prefix just as easily....
|
|
//
|
|
namespace SMH
|
|
{
|
|
BOOL __fastcall FInitialize( IN LPCWSTR pwszInstanceName );
|
|
VOID __fastcall Deinitialize();
|
|
PVOID __fastcall PvAlloc( IN DWORD cbData, OUT SHMEMHANDLE * phsmba );
|
|
VOID __fastcall Free( IN SHMEMHANDLE hsmba );
|
|
PVOID __fastcall PvFromSMBA( IN SHMEMHANDLE hsmba );
|
|
};
|
|
|
|
|
|
// ========================================================================
|
|
//
|
|
// CLASS CSmhInit
|
|
//
|
|
// Initializer for shared memory heap. Any class containing member objects
|
|
// that reside on the shared memory heap should also include an instance
|
|
// of this class as a member BEFORE the others to ensure that they are
|
|
// properly destroyed before the heap is deinitialized.
|
|
//
|
|
class CSmhInit
|
|
{
|
|
// NOT IMPLEMENTED
|
|
//
|
|
CSmhInit& operator=( const CSmhInit& );
|
|
CSmhInit( const CSmhInit& );
|
|
|
|
public:
|
|
CSmhInit()
|
|
{
|
|
}
|
|
|
|
BOOL FInitialize( LPCWSTR lpwszSignature )
|
|
{
|
|
#ifdef COMPILE_WITHOUT_DAV
|
|
return FALSE;
|
|
#else
|
|
return SMH::FInitialize( lpwszSignature );
|
|
#endif
|
|
}
|
|
|
|
~CSmhInit()
|
|
{
|
|
#ifdef COMPILE_WITHOUT_DAV
|
|
// do nothing
|
|
#else
|
|
SMH::Deinitialize();
|
|
#endif
|
|
}
|
|
};
|
|
|
|
|
|
// ========================================================================
|
|
//
|
|
// TEMPLATE CLASS auto_ptr
|
|
//
|
|
// Stripped down auto_ptr class based on the C++ STL standard one
|
|
//
|
|
template<class X>
|
|
class auto_ptr
|
|
{
|
|
mutable X * owner;
|
|
X * px;
|
|
|
|
public:
|
|
explicit auto_ptr(X* p=0) : owner(p), px(p) {}
|
|
auto_ptr(const auto_ptr<X>& r) : owner(r.owner), px(r.relinquish()) {}
|
|
|
|
auto_ptr& operator=(const auto_ptr<X>& r)
|
|
{
|
|
if ((void*)&r != (void*)this)
|
|
{
|
|
delete owner;
|
|
owner = r.owner;
|
|
px = r.relinquish();
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
// NOTE: This equals operator is meant to be used to load a
|
|
// new pointer (not yet held in any auto-ptr anywhere) into this object.
|
|
auto_ptr& operator=(X* p)
|
|
{
|
|
Assert(!owner); // Scream on overwrite of good data.
|
|
owner = p;
|
|
px = p;
|
|
return *this;
|
|
}
|
|
|
|
~auto_ptr() { delete owner; }
|
|
bool operator!()const { return (px == NULL); }
|
|
operator X*() const { return px; }
|
|
X& operator*() const { return *px; }
|
|
X* operator->() const { return px; }
|
|
X* get() const { return px; }
|
|
X* relinquish() const { owner = 0; return px; }
|
|
|
|
void clear()
|
|
{
|
|
if (owner)
|
|
delete owner;
|
|
owner = 0;
|
|
px = 0;
|
|
}
|
|
};
|
|
|
|
|
|
//
|
|
// From here down implements the performance monitor for HTTPEXT and
|
|
// the functionality necessary to merge perf counters from HTTPEXT
|
|
// into the Web Service object defined by W3CTRS.
|
|
//
|
|
|
|
//
|
|
// The first flag says whether the CW3Monitor instance has been created.
|
|
// The second flag says whether it has been initialized.
|
|
// Since the CW3Monitor is created on-demand by the first call to
|
|
// W3MergeDavPerformanceData(), these flags keep us from continually
|
|
// retrying initialization after it fails the first time.
|
|
//
|
|
BOOL g_fCreatedMonitor = FALSE;
|
|
BOOL g_fInitializedMonitor = FALSE;
|
|
|
|
|
|
// ========================================================================
|
|
//
|
|
// CLASS CW3Monitor
|
|
//
|
|
class CW3Monitor : private Singleton<CW3Monitor>
|
|
{
|
|
//
|
|
// Friend declaration required by Singleton template
|
|
//
|
|
friend class Singleton<CW3Monitor>;
|
|
|
|
//
|
|
// Hint about the size of the buffer to use for perf data coming back
|
|
// from HTTPEXT. The buffer needs to be about 48K per vroot. The
|
|
// initial guess is 48K (one vroot), and scales up geometrically as
|
|
// necessary.
|
|
//
|
|
DWORD m_cbDavDataAlloc;
|
|
|
|
//
|
|
// Shared memory heap initialization. Declare before any member
|
|
// variables which use the shared memory heap to ensure proper
|
|
// order of destruction.
|
|
//
|
|
CSmhInit m_smh;
|
|
|
|
//
|
|
// Perf counter data
|
|
//
|
|
auto_ptr<ICounterData> m_pCounterData;
|
|
|
|
// CREATORS
|
|
//
|
|
CW3Monitor() :
|
|
m_cbDavDataAlloc(48 * 1024)
|
|
{
|
|
}
|
|
BOOL FInitialize();
|
|
|
|
// ACCESSORS
|
|
//
|
|
DWORD DwCollectPerformanceData( LPBYTE lpbPerfData,
|
|
LPDWORD lpdwcbPerfData )
|
|
{
|
|
DWORD dwcObjectTypes;
|
|
|
|
return m_pCounterData->DwCollectData( NULL, // Always query all data
|
|
0, // Use 0-relative indices
|
|
reinterpret_cast<LPVOID *>(&lpbPerfData),
|
|
lpdwcbPerfData,
|
|
&dwcObjectTypes );
|
|
}
|
|
|
|
// NOT IMPLEMENTED
|
|
//
|
|
CW3Monitor& operator=( const CW3Monitor& );
|
|
CW3Monitor( const CW3Monitor& );
|
|
|
|
public:
|
|
static BOOL W3MergeDavPerformanceData( DWORD dwServerId, W3_STATISTICS_1 * pW3Stats );
|
|
static VOID W3CloseDavPerformanceData()
|
|
{
|
|
DestroyInstance();
|
|
g_fCreatedMonitor = FALSE;
|
|
}
|
|
};
|
|
|
|
// ------------------------------------------------------------------------
|
|
//
|
|
// CW3Monitor::FInitialize()
|
|
//
|
|
BOOL
|
|
CW3Monitor::FInitialize()
|
|
{
|
|
|
|
//
|
|
// Initialize the shared memory heap
|
|
//
|
|
if ( !m_smh.FInitialize( gc_wszSignature ) )
|
|
{
|
|
DWORD dwResult = GetLastError();
|
|
|
|
DebugTrace( "CW3Monitor::FInitialize() - Error initializing shared memory heap %d\n", dwResult );
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Bind to the counter data
|
|
//
|
|
#ifdef COMPILE_WITHOUT_DAV
|
|
|
|
#else
|
|
|
|
m_pCounterData = NewCounterMonitor( gc_wszSignature );
|
|
|
|
if ( !m_pCounterData.get() )
|
|
{
|
|
|
|
DWORD dwResult = GetLastError();
|
|
|
|
DebugTrace( "CW3Monitor::FInitialize() - Error binding to counter data %d\n", dwResult );
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
#endif
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
//
|
|
// CW3Monitor::W3MergeDavPerformanceData()
|
|
//
|
|
BOOL
|
|
CW3Monitor::W3MergeDavPerformanceData( DWORD dwServerId, W3_STATISTICS_1 * pW3Stats )
|
|
{
|
|
|
|
BYTE * lpbDavData = NULL;
|
|
PERF_OBJECT_TYPE * ppot = NULL;
|
|
PERF_COUNTER_DEFINITION * rgpcd = NULL;
|
|
DWORD dwibServerId = 0;
|
|
PERF_INSTANCE_DEFINITION * ppid = NULL;
|
|
PERF_COUNTER_BLOCK * ppcb;
|
|
LONG lcInstances;
|
|
DWORD iCtr;
|
|
BOOL fRet = FALSE;
|
|
|
|
//
|
|
// Create the monitor on demand
|
|
//
|
|
|
|
if ( !g_fCreatedMonitor )
|
|
{
|
|
g_fInitializedMonitor = CreateInstance().FInitialize();
|
|
g_fCreatedMonitor = TRUE;
|
|
}
|
|
|
|
//
|
|
// If we failed to init the monitor, then we can't get any
|
|
// performance data. Since we can't fail this call, just leave
|
|
// the existing statistics alone.
|
|
//
|
|
if ( !g_fInitializedMonitor )
|
|
goto ret;
|
|
|
|
|
|
//
|
|
// From here out we always return TRUE
|
|
//
|
|
fRet = TRUE;
|
|
|
|
//
|
|
// Try collecting the data. If our buffer is too small, double
|
|
// its size repeatedly until it's big enough. The initial guess
|
|
// should be large enough to succeed most of the time.
|
|
//
|
|
for ( ;; )
|
|
{
|
|
DWORD cbDavDataAlloc;
|
|
DWORD cbDavData;
|
|
DWORD dwCollectResult;
|
|
|
|
// If we have a buffer from a previous trip around the loop
|
|
// then free it.
|
|
//
|
|
if (lpbDavData)
|
|
delete [] lpbDavData;
|
|
|
|
cbDavDataAlloc = Instance().m_cbDavDataAlloc;
|
|
cbDavData = cbDavDataAlloc;
|
|
lpbDavData = new BYTE[cbDavData];
|
|
if (NULL == lpbDavData)
|
|
{
|
|
DebugTrace( "W3MergeDavPerformanceData() - OOM allocating buffer for DAV perf data\n" );
|
|
goto ret;
|
|
}
|
|
|
|
dwCollectResult = Instance().
|
|
DwCollectPerformanceData( lpbDavData,
|
|
&cbDavData );
|
|
|
|
if ( ERROR_SUCCESS == dwCollectResult )
|
|
{
|
|
if ( 0 != cbDavData )
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
DebugTrace( "W3MergeDavPerformanceData() - No instances from which to collect data\n" );
|
|
goto ret;
|
|
}
|
|
}
|
|
|
|
if ( ERROR_MORE_DATA != dwCollectResult )
|
|
{
|
|
DebugTrace( "W3MergeDavPerformanceData() - Error collecting DAV perf data (%d)\n", dwCollectResult );
|
|
goto ret;
|
|
}
|
|
|
|
Instance().m_cbDavDataAlloc = 2 * cbDavDataAlloc;
|
|
}
|
|
|
|
//
|
|
// Locate the HTTPEXT perf object (should be the first
|
|
// thing returned) and make sure it looks reasonable.
|
|
//
|
|
ppot = reinterpret_cast<PERF_OBJECT_TYPE *>( lpbDavData );
|
|
|
|
if ( ppot->NumCounters < 1 )
|
|
{
|
|
DebugTrace( "W3MergeDavPerformanceData() - NumCounters < 1?" );
|
|
goto ret;
|
|
}
|
|
|
|
if ( ppot->NumInstances < 1 )
|
|
{
|
|
DebugTrace( "W3MergeDavPerformanceData() - NumInstances < 1?" );
|
|
goto ret;
|
|
}
|
|
|
|
//
|
|
// Locate the HTTPEXT counter definitions.
|
|
//
|
|
rgpcd = reinterpret_cast<PERF_COUNTER_DEFINITION *>(
|
|
reinterpret_cast<LPBYTE>(ppot) + ppot->HeaderLength );
|
|
|
|
//
|
|
// Locate the server ID counter. This counter tells us what
|
|
// instance of the W3Ctrs data to merge into, so bail if we can't
|
|
// find it or if it looks wrong.
|
|
//
|
|
for ( iCtr = 0; iCtr < ppot->NumCounters; iCtr++ )
|
|
{
|
|
if ( rgpcd[iCtr].CounterNameTitleIndex == HTTPEXT_COUNTER_SERVER_ID )
|
|
{
|
|
if ( rgpcd[iCtr].CounterSize == sizeof(DWORD) &&
|
|
rgpcd[iCtr].CounterType == (PERF_DISPLAY_NOSHOW |
|
|
PERF_SIZE_DWORD |
|
|
PERF_TYPE_NUMBER) )
|
|
{
|
|
dwibServerId = rgpcd[iCtr].CounterOffset;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
DebugTrace( "W3MergePerformanceData() - Server ID counter doesn't look right. Bailing...\n" );
|
|
goto ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( !dwibServerId )
|
|
{
|
|
DebugTrace( "W3MergePerformanceData() - Couldn't find server ID counter. Bailing...\n" );
|
|
goto ret;
|
|
}
|
|
|
|
//
|
|
// Now go through each instance of the HTTPEXT counters and merge the data
|
|
// from that instance into the correct W3Ctrs counter instance according
|
|
// to server ID.
|
|
//
|
|
ppid = reinterpret_cast<PERF_INSTANCE_DEFINITION *>(
|
|
reinterpret_cast<LPBYTE>(ppot) + ppot->DefinitionLength );
|
|
|
|
for ( lcInstances = ppot->NumInstances;
|
|
lcInstances-- > 0;
|
|
ppid = reinterpret_cast<PERF_INSTANCE_DEFINITION *>(
|
|
reinterpret_cast<LPBYTE>(ppcb) + ppcb->ByteLength ) )
|
|
{
|
|
ppcb = reinterpret_cast<PERF_COUNTER_BLOCK *>(
|
|
reinterpret_cast<LPBYTE>(ppid) + ppid->ByteLength );
|
|
|
|
//
|
|
// Get the server ID of this instance.
|
|
//
|
|
DWORD dwServerIdInstance =
|
|
*reinterpret_cast<LPDWORD>(
|
|
reinterpret_cast<LPBYTE>(ppcb) + dwibServerId);
|
|
|
|
//
|
|
// If the server ID of this instance isn't the one
|
|
// we want then keep looking.
|
|
//
|
|
if ( dwServerIdInstance != dwServerId )
|
|
continue;
|
|
|
|
//
|
|
// The server IDs match, so sum in the info for this instance.
|
|
// NOTE: Since each vroot has its own instance, there may be
|
|
// multiple instances with the same server ID. Sum them all.
|
|
//
|
|
// Go through all the counters in the HTTPEXT instance
|
|
// and update the W3 statistics data.
|
|
//
|
|
for ( DWORD iCounter = 0;
|
|
iCounter < ppot->NumCounters;
|
|
iCounter++ )
|
|
{
|
|
PERF_COUNTER_DEFINITION * ppcd = &rgpcd[iCounter];
|
|
|
|
switch ( ppcd->CounterNameTitleIndex )
|
|
{
|
|
case HTTPEXT_COUNTER_TOTAL_GET_REQUESTS:
|
|
case HTTPEXT_COUNTER_TOTAL_HEAD_REQUESTS:
|
|
case HTTPEXT_COUNTER_TOTAL_POST_REQUESTS:
|
|
case HTTPEXT_COUNTER_TOTAL_DELETE_REQUESTS:
|
|
case HTTPEXT_COUNTER_TOTAL_OTHER_REQUESTS:
|
|
{
|
|
//
|
|
// These values are already recorded
|
|
// in the statistics, so don't do anything
|
|
// more with them here.
|
|
//
|
|
break;
|
|
}
|
|
|
|
case HTTPEXT_COUNTER_TOTAL_PUT_REQUESTS:
|
|
{
|
|
if ( ppcd->CounterType == PERF_COUNTER_RAWCOUNT &&
|
|
ppcd->CounterSize == sizeof(DWORD) )
|
|
{
|
|
DWORD dwValue = *reinterpret_cast<LPDWORD>(
|
|
reinterpret_cast<LPBYTE>(ppcb) + ppcd->CounterOffset );
|
|
|
|
pW3Stats->TotalFilesReceived += dwValue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case HTTPEXT_COUNTER_TOTAL_OPTIONS_REQUESTS:
|
|
{
|
|
if ( ppcd->CounterType == PERF_COUNTER_RAWCOUNT &&
|
|
ppcd->CounterSize == sizeof(DWORD) )
|
|
{
|
|
DWORD dwValue = *reinterpret_cast<LPDWORD>(
|
|
reinterpret_cast<LPBYTE>(ppcb) + ppcd->CounterOffset );
|
|
|
|
pW3Stats->TotalOptions += dwValue;
|
|
pW3Stats->TotalOthers -= dwValue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case HTTPEXT_COUNTER_TOTAL_COPY_REQUESTS:
|
|
{
|
|
if ( ppcd->CounterType == PERF_COUNTER_RAWCOUNT &&
|
|
ppcd->CounterSize == sizeof(DWORD) )
|
|
{
|
|
DWORD dwValue = *reinterpret_cast<LPDWORD>(
|
|
reinterpret_cast<LPBYTE>(ppcb) + ppcd->CounterOffset );
|
|
|
|
pW3Stats->TotalCopy += dwValue;
|
|
pW3Stats->TotalOthers -= dwValue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case HTTPEXT_COUNTER_TOTAL_MOVE_REQUESTS:
|
|
{
|
|
if ( ppcd->CounterType == PERF_COUNTER_RAWCOUNT &&
|
|
ppcd->CounterSize == sizeof(DWORD) )
|
|
{
|
|
DWORD dwValue = *reinterpret_cast<LPDWORD>(
|
|
reinterpret_cast<LPBYTE>(ppcb) + ppcd->CounterOffset );
|
|
|
|
pW3Stats->TotalMove += dwValue;
|
|
pW3Stats->TotalOthers -= dwValue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case HTTPEXT_COUNTER_TOTAL_MKCOL_REQUESTS:
|
|
{
|
|
if ( ppcd->CounterType == PERF_COUNTER_RAWCOUNT &&
|
|
ppcd->CounterSize == sizeof(DWORD) )
|
|
{
|
|
DWORD dwValue = *reinterpret_cast<LPDWORD>(
|
|
reinterpret_cast<LPBYTE>(ppcb) + ppcd->CounterOffset );
|
|
|
|
pW3Stats->TotalMkcol += dwValue;
|
|
pW3Stats->TotalOthers -= dwValue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case HTTPEXT_COUNTER_TOTAL_PROPFIND_REQUESTS:
|
|
{
|
|
if ( ppcd->CounterType == PERF_COUNTER_RAWCOUNT &&
|
|
ppcd->CounterSize == sizeof(DWORD) )
|
|
{
|
|
DWORD dwValue = *reinterpret_cast<LPDWORD>(
|
|
reinterpret_cast<LPBYTE>(ppcb) + ppcd->CounterOffset );
|
|
|
|
pW3Stats->TotalPropfind += dwValue;
|
|
pW3Stats->TotalOthers -= dwValue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case HTTPEXT_COUNTER_TOTAL_PROPPATCH_REQUESTS:
|
|
{
|
|
if ( ppcd->CounterType == PERF_COUNTER_RAWCOUNT &&
|
|
ppcd->CounterSize == sizeof(DWORD) )
|
|
{
|
|
DWORD dwValue = *reinterpret_cast<LPDWORD>(
|
|
reinterpret_cast<LPBYTE>(ppcb) + ppcd->CounterOffset );
|
|
|
|
pW3Stats->TotalProppatch += dwValue;
|
|
pW3Stats->TotalOthers -= dwValue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case HTTPEXT_COUNTER_TOTAL_SEARCH_REQUESTS:
|
|
{
|
|
if ( ppcd->CounterType == PERF_COUNTER_RAWCOUNT &&
|
|
ppcd->CounterSize == sizeof(DWORD) )
|
|
{
|
|
DWORD dwValue = *reinterpret_cast<LPDWORD>(
|
|
reinterpret_cast<LPBYTE>(ppcb) + ppcd->CounterOffset );
|
|
|
|
pW3Stats->TotalSearch += dwValue;
|
|
pW3Stats->TotalOthers -= dwValue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case HTTPEXT_COUNTER_TOTAL_LOCK_REQUESTS:
|
|
{
|
|
if ( ppcd->CounterType == PERF_COUNTER_RAWCOUNT &&
|
|
ppcd->CounterSize == sizeof(DWORD) )
|
|
{
|
|
DWORD dwValue = *reinterpret_cast<LPDWORD>(
|
|
reinterpret_cast<LPBYTE>(ppcb) + ppcd->CounterOffset );
|
|
|
|
pW3Stats->TotalLock += dwValue;
|
|
pW3Stats->TotalOthers -= dwValue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case HTTPEXT_COUNTER_TOTAL_UNLOCK_REQUESTS:
|
|
{
|
|
if ( ppcd->CounterType == PERF_COUNTER_RAWCOUNT &&
|
|
ppcd->CounterSize == sizeof(DWORD) )
|
|
{
|
|
DWORD dwValue = *reinterpret_cast<LPDWORD>(
|
|
reinterpret_cast<LPBYTE>(ppcb) + ppcd->CounterOffset );
|
|
|
|
pW3Stats->TotalUnlock += dwValue;
|
|
pW3Stats->TotalOthers -= dwValue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case HTTPEXT_COUNTER_TOTAL_404_RESPONSES:
|
|
{
|
|
if ( ppcd->CounterType == PERF_COUNTER_RAWCOUNT &&
|
|
ppcd->CounterSize == sizeof(DWORD) )
|
|
{
|
|
DWORD dwValue = *reinterpret_cast<LPDWORD>(
|
|
reinterpret_cast<LPBYTE>(ppcb) + ppcd->CounterOffset );
|
|
|
|
pW3Stats->TotalNotFoundErrors += dwValue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case HTTPEXT_COUNTER_TOTAL_423_RESPONSES:
|
|
{
|
|
if ( ppcd->CounterType == PERF_COUNTER_RAWCOUNT &&
|
|
ppcd->CounterSize == sizeof(DWORD) )
|
|
{
|
|
DWORD dwValue = *reinterpret_cast<LPDWORD>(
|
|
reinterpret_cast<LPBYTE>(ppcb) + ppcd->CounterOffset );
|
|
|
|
pW3Stats->TotalLockedErrors += dwValue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
//
|
|
// We either don't care about or don't understand
|
|
// other counters, so skip them.
|
|
//
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ret:
|
|
if (lpbDavData)
|
|
delete [] lpbDavData;
|
|
|
|
return fRet;
|
|
|
|
}
|
|
|
|
|
|
// ========================================================================
|
|
//
|
|
// CLASS CW3MonitorInit
|
|
//
|
|
// Refcounted global initialization class that controls the lifetime of
|
|
// the singleton CW3Monitor instance. Calls to collect performance data
|
|
// are done in the scope of a reference to this class so that the server
|
|
// can be taken down on one thread while another thread is in the middle
|
|
// of -- or just beginning to -- collect data. Whichever thread releases
|
|
// the last reference to this class will be the one to close the counters.
|
|
//
|
|
class CW3MonitorInit : private RefCountedGlobal<CW3MonitorInit>
|
|
{
|
|
//
|
|
// Friend declarations required by RefCountedGlobal template
|
|
//
|
|
friend class Singleton<CW3MonitorInit>;
|
|
friend class RefCountedGlobal<CW3MonitorInit>;
|
|
|
|
// CREATORS
|
|
//
|
|
// Declared private to ensure that arbitrary instances
|
|
// of this class cannot be created. The Singleton
|
|
// template (declared as a friend above) controls
|
|
// the sole instance of this class.
|
|
//
|
|
CW3MonitorInit()
|
|
{
|
|
}
|
|
|
|
BOOL FInit()
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
~CW3MonitorInit()
|
|
{
|
|
CW3Monitor::W3CloseDavPerformanceData();
|
|
}
|
|
|
|
// NOT IMPLEMENTED
|
|
//
|
|
CW3MonitorInit( const CW3MonitorInit& );
|
|
CW3MonitorInit& operator=( const CW3MonitorInit& );
|
|
|
|
public:
|
|
using RefCountedGlobal<CW3MonitorInit>::DwInitRef;
|
|
using RefCountedGlobal<CW3MonitorInit>::DeinitRef;
|
|
};
|
|
|
|
|
|
// ========================================================================
|
|
//
|
|
// PUBLIC INTERFACE
|
|
//
|
|
|
|
// ------------------------------------------------------------------------
|
|
//
|
|
// W3MergeDavPerformanceData()
|
|
//
|
|
EXTERN_C BOOL __fastcall
|
|
W3MergeDavPerformanceData( DWORD dwServerId, W3_STATISTICS_1 * pW3Stats )
|
|
{
|
|
BOOL fResult;
|
|
|
|
CW3MonitorInit::DwInitRef();
|
|
|
|
fResult = CW3Monitor::W3MergeDavPerformanceData( dwServerId, pW3Stats );
|
|
|
|
CW3MonitorInit::DeinitRef();
|
|
|
|
return fResult;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
//
|
|
// W3OpenDavPerformanceData()
|
|
//
|
|
EXTERN_C VOID __fastcall
|
|
W3OpenDavPerformanceData()
|
|
{
|
|
CW3MonitorInit::DwInitRef();
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
//
|
|
// W3CloseDavPerformanceData()
|
|
//
|
|
EXTERN_C VOID __fastcall
|
|
W3CloseDavPerformanceData()
|
|
{
|
|
CW3MonitorInit::DeinitRef();
|
|
}
|