able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/fs/hsm/inc/wsbtrace.h

380 lines
13 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
<EFBFBD> 1998 Seagate Software, Inc. All rights reserved.
Module Name:
WsbTrace.h
Abstract:
This header file defines the part of the platform code that is
responsible for function tracing.
Author:
Chuck Bardeen [cbardeen] 29-Oct-1996
Revision History:
Brian Dodd [brian] 09-May-1996 - Added event logging
--*/
#ifndef _WSBTRACE_
#define _WSBTRACE_
#include "wsb.h"
#include "rsbuild.h"
#include "ntverp.h"
#ifdef __cplusplus
extern "C" {
#endif
// The size of the trace statement buffer including NULL termination
#define WSB_TRACE_BUFF_SIZE 1024
// These define the event log levels
#define WSB_LOG_LEVEL_NONE 0 // Nothing is written the the event log
#define WSB_LOG_LEVEL_ERROR 1 // Errors only (severity 3)
#define WSB_LOG_LEVEL_WARNING 2 // Errors and Warnings (severity 2)
#define WSB_LOG_LEVEL_INFORMATION 3 // Errors, Warnings, and Information (severity 1)
#define WSB_LOG_LEVEL_COMMENT 4 // All Message Types (includes severity 0)
#define WSB_LOG_LEVEL_DEFAULT 3 // Something reasonable.
// These define where the trace output should be written.
#define WSB_TRACE_OUT_NONE 0x00000000L // No output
#define WSB_TRACE_OUT_DEBUG_SCREEN 0x00000001L // Output to the debug screen
#define WSB_TRACE_OUT_FILE 0x00000002L // Output to a file
#define WSB_TRACE_OUT_STDOUT 0x00000004L // Output to standard out
#define WSB_TRACE_OUT_FILE_COPY 0x00000008L // Save copy of trace file
#define WSB_TRACE_OUT_MULTIPLE_FILES 0x00000010L // Output to multiple files
#define WSB_TRACE_OUT_FLAGS_SET 0x00010000L // Indicates other flags are set
#define WSB_TRACE_OUT_ALL 0xffffffffL
// These macros define the module assignments for the bits used to
// control whether tracing is enabled. Each bit should only be used once,
// the granularity will be fairly large.
#define WSB_TRACE_BIT_NONE 0x0000000000000000L
#define WSB_TRACE_BIT_PLATFORM 0x0000000000000001L
#define WSB_TRACE_BIT_RMS 0x0000000000000002L
#define WSB_TRACE_BIT_SEG 0x0000000000000004L // Remove when dependencies are gone
#define WSB_TRACE_BIT_META 0x0000000000000004L
#define WSB_TRACE_BIT_HSMENG 0x0000000000000008L
#define WSB_TRACE_BIT_JOB 0x0000000000000010L
#define WSB_TRACE_BIT_HSMTSKMGR 0x0000000000000020L
#define WSB_TRACE_BIT_FSA 0x0000000000000040L
#define WSB_TRACE_BIT_DATAMIGRATER 0x0000000000000080L
#define WSB_TRACE_BIT_DATARECALLER 0x0000000000000100L
#define WSB_TRACE_BIT_DATAVERIFIER 0x0000000000000200L
#define WSB_TRACE_BIT_UI 0x0000000000000400L
#define WSB_TRACE_BIT_HSMCONN 0x0000000000000800L
#define WSB_TRACE_BIT_DATAMOVER 0x0000000000001000L
#define WSB_TRACE_BIT_IDB 0x0000000000002000L
#define WSB_TRACE_BIT_TEST 0x0000000000004000L
#define WSB_TRACE_BIT_COPYMEDIA 0x0000000000008000L
#define WSB_TRACE_BIT_PERSISTENCE 0x0000000000010000L
#define WSB_TRACE_BIT_HSMSERV 0x0000000000020000L
#define WSB_TRACE_BIT_ALL 0xffffffffffffffffL
// These macros are used to provide function call trace information into
// the log. Each function (method) that wants to be traceable needs at a
// minimum to use the following three macros. The first macro needs to be
// put at the top of the source code file and defines to which module the
// code in that file belongs.
//
// #define WSB_TRACE_IS WSB_TRACE_BIT_PLATFORM
//
// The next two macros are used once per function. They are variable
// macros, which allows the writer of the function to list the values
// of the input and output parameters.
//
// HRESULT CWsbSample::Do(BOOL shouldWrite) {
// HRESULT hr = S_OK;
//
// WsbTraceIn("CWsbSample::Do", "shouldWrite = <%ls>", WsbBoolAsString(shouldWrite));
//
// ... some code ....
//
// WsbTraceOut("CWsbSample::Do", "hr = <%ls>", WsbHrAsString(hr));
//
// return(hr);
// }
//
// Notice that some helper functions have been defined to help provide an
// a written description for the value of certain types. Additional helper
// helper functions should be created as needed.
/*++
Macro Name:
WsbTraceIn
Macro Description:
This macro is used to provide function call trace information into
the log. It should be put at the start of the function.
Arguments:
methodName - The name of the function.
argString - A printf type format string. Additional arguments can
follow.
--*/
#define WsbTraceIn if ((g_WsbTraceEntryExit == TRUE) && ((g_WsbTraceModules & WSB_TRACE_IS) != 0)) WsbTraceEnter
/*++
Macro Name:
WsbTraceOut
Macro Description:
This macro is used to provide function call trace information into
the log. It should be put at the end of the function.
Arguments:
methodName - The name of the function.
argString - A printf type format string. Additional arguments can
follow.
--*/
#define WsbTraceOut if ((g_WsbTraceEntryExit == TRUE) && ((g_WsbTraceModules & WSB_TRACE_IS) != 0)) WsbTraceExit
/*++
Macro Name:
WsbLogEvent
Macro Description:
This routine writes a message into the system event log. The message
is also written to the application trace file.
Arguments:
eventId - The message Id to log.
dataSize - Size of arbitrary data.
data - Arbitrary data buffer to display with the message.
Inserts - Message inserts that are merged with the message description specified by
eventId. The number of inserts must match the number specified by the
message description. The last insert must be NULL to indicate the
end of the insert list.
Notes:
It's a small optimization to check if logging is turned on, first. Determining if the
message is actually logged still requires the first parameter. Unlike trace, log activity
should be minimal and only when there are problems. The overhead of the calls seems
reasonable.
--*/
#define WsbLogEvent \
if ( g_WsbLogLevel ) WsbSetEventInfo( __FILE__, __LINE__, VER_PRODUCTBUILD, RS_BUILD_VERSION ); \
if ( g_WsbLogLevel ) WsbTraceAndLogEvent
/*++
Macro Name:
WsbLogEventV
Macro Description:
This macro is used to write a message into the system event log. The message
is also written to the application trace file.
This macro is similar to WsbLogEvent, but takes a va_list as the fourth argument.
Arguments:
eventId - The message Id to log.
dataSize - Size of arbitrary data.
data - Arbitrary data buffer to display with the message.
inserts - An array of message inserts that are merged with the message description
specified by eventId. The number of inserts must match the number
specified by the message description. The last insert must be NULL,
to indicate the end of the insert list.
Notes:
It's a small optimization to check if logging is turned on, first. Determining if the
message is actually logged still requires the first parameter. Unlike trace, log activity
should be minimal and only when there are problems. The overhead of the calls seems
reasonable.
--*/
#define WsbLogEventV \
if ( g_WsbLogLevel ) WsbSetEventInfo( __FILE__, __LINE__, VER_PRODUCTBUILD, RS_BUILD_VERSION ); \
if ( g_WsbLogLevel ) WsbTraceAndLogEventV
/*++
Macro Name:
WsbTrace
Macro Description:
This macro is used to provide a printf style message into the trace file.
Arguments:
argString - A printf type format string. Additional arguments can
follow.
--*/
#define WsbTrace if ((g_WsbTraceModules & WSB_TRACE_IS) != 0) WsbTracef
/*++
Macro Name:
WsbTraceAlways
Macro Description:
This macro is used to provide a printf style message into the trace file.
The trace is printed if tracing has been started regardless of the
WSB_TRACE_IS settings.
Arguments:
argString - A printf type format string. Additional arguments can
follow.
--*/
#define WsbTraceAlways WsbTracef
/*++
Macro Name:
WsbTraceBuffer
Macro Description:
This macro is used to provide buffer dump to the trace file.
Arguments:
Same as WsbTraceBufferAsBytes
--*/
#define WsbTraceBuffer if ((g_WsbTraceModules & WSB_TRACE_IS) != 0) WsbTraceBufferAsBytes
// The following global variable is used to compare against to determine
// the modules for which debugging should be enabled.
extern WSB_EXPORT LONGLONG g_WsbTraceModules;
extern WSB_EXPORT IWsbTrace *g_pWsbTrace;
extern WSB_EXPORT LONG g_WsbTraceCount;
extern WSB_EXPORT BOOL g_WsbTraceEntryExit;
extern WSB_EXPORT WORD g_WsbLogLevel;
extern WSB_EXPORT BOOL g_WsbLogSnapShotOn;
extern WSB_EXPORT WORD g_WsbLogSnapShotLevel;
extern WSB_EXPORT OLECHAR g_pWsbLogSnapShotPath[];
extern WSB_EXPORT BOOL g_WsbLogSnapShotResetTrace;
// Trace functions
extern WSB_EXPORT void WsbSetEventInfo( char *fileName, DWORD lineNo, DWORD ntBuild, DWORD rsBuild );
extern WSB_EXPORT void WsbTraceInit( void );
extern WSB_EXPORT void WsbTraceCleanupThread(void);
extern WSB_EXPORT void WsbTraceEnter(OLECHAR* methodName, OLECHAR* argString, ...);
extern WSB_EXPORT void WsbTraceExit(OLECHAR* methodName, OLECHAR* argString, ...);
extern WSB_EXPORT void WsbTracef(OLECHAR* argString, ...);
extern WSB_EXPORT void WsbTraceAndLogEvent(DWORD eventId, DWORD dataSize, LPVOID data, ... /* last argument is NULL */);
extern WSB_EXPORT void WsbTraceAndLogEventV(DWORD eventId, DWORD dataSize, LPVOID data, va_list *arguments /* last element is NULL */);
extern WSB_EXPORT void WsbTraceAndPrint(DWORD eventId, ... /* last argument is NULL */);
extern WSB_EXPORT void WsbTraceAndPrintV(DWORD eventId, va_list *arguments /* last element is NULL */);
extern WSB_EXPORT void WsbTraceBufferAsBytes( DWORD size, LPVOID bufferP );
extern WSB_EXPORT void WsbTraceTerminate(void);
extern WSB_EXPORT ULONG WsbTraceThreadOff(void);
extern WSB_EXPORT ULONG WsbTraceThreadOffCount(void);
extern WSB_EXPORT ULONG WsbTraceThreadOn(void);
// Helper Functions
//
// NOTE: Be careful with some of these helper functions, since they
// use static memory and a second call to the function will overwrite
// the results of the first call to the function. Also, some functions
// end up calling each other and sharing memory between them (i.e.
// WsbPtrToGuidAsString() calls WsbGuidAsString()).
extern WSB_EXPORT const OLECHAR* WsbBoolAsString(BOOL boolean);
extern WSB_EXPORT const OLECHAR* WsbFiletimeAsString(BOOL isRelative, FILETIME filetime);
extern WSB_EXPORT const OLECHAR* WsbGuidAsString(GUID guid);
extern WSB_EXPORT const OLECHAR* WsbHrAsString(HRESULT hr);
extern WSB_EXPORT const OLECHAR* WsbLongAsString(LONG inLong);
extern WSB_EXPORT const OLECHAR* WsbLonglongAsString(LONGLONG llong);
extern WSB_EXPORT const OLECHAR* WsbStringAsString(OLECHAR* pStr);
extern WSB_EXPORT const OLECHAR* WsbPtrToBoolAsString(BOOL* pBool);
extern WSB_EXPORT const OLECHAR* WsbPtrToFiletimeAsString(BOOL isRelative, FILETIME *pFiletime);
extern WSB_EXPORT const OLECHAR* WsbPtrToGuidAsString(GUID* pGuid);
extern WSB_EXPORT const OLECHAR* WsbPtrToHrAsString(HRESULT *pHr);
extern WSB_EXPORT const OLECHAR* WsbPtrToLonglongAsString(LONGLONG *pLlong);
extern WSB_EXPORT const OLECHAR* WsbPtrToLongAsString(LONG* pLong);
extern WSB_EXPORT const OLECHAR* WsbPtrToShortAsString(SHORT* pShort);
extern WSB_EXPORT const OLECHAR* WsbPtrToByteAsString(BYTE* pByte);
extern WSB_EXPORT const OLECHAR* WsbPtrToStringAsString(OLECHAR** pString);
extern WSB_EXPORT const OLECHAR* WsbPtrToUliAsString(ULARGE_INTEGER* pUli);
extern WSB_EXPORT const OLECHAR* WsbPtrToUlongAsString(ULONG* pUlong);
extern WSB_EXPORT const OLECHAR* WsbPtrToUshortAsString(USHORT* pUshort);
extern WSB_EXPORT const OLECHAR* WsbPtrToPtrAsString(void** ppVoid);
extern WSB_EXPORT const OLECHAR* WsbAbbreviatePath(const OLECHAR* path, USHORT length);
extern WSB_EXPORT HRESULT WsbShortSizeFormat64(__int64 dw64, LPTSTR szBuf);
#ifdef __cplusplus
/*++
Class Name:
WsbQuickString
Class Description:
Quick string storage class
--*/
class WSB_EXPORT WsbQuickString {
public:
WsbQuickString ( const OLECHAR * sz ) { m_sz = WsbAllocString ( sz ); }
~WsbQuickString ( ) { if ( m_sz ) WsbFreeString ( m_sz ); }
operator OLECHAR * () { return ( m_sz ); }
private:
BSTR m_sz;
WsbQuickString ( ) { m_sz = 0; }
};
#define WsbStringCopy( a ) ((OLECHAR *)WsbQuickString ( a ) )
}
#endif
#endif // _WSBTRACE_
Reference in a new issue Copy permalink