407 lines
19 KiB
C
407 lines
19 KiB
C
/**MOD+**********************************************************************/
|
|
/* Module: wtrcapi.c */
|
|
/* */
|
|
/* Purpose: External tracing functions - Windows specific */
|
|
/* */
|
|
/* Copyright(C) Microsoft Corporation 1997 */
|
|
/* */
|
|
/****************************************************************************/
|
|
/** Changes:
|
|
* $Log: Y:/logs/trc/wtrcapi.c_v $
|
|
*
|
|
* Rev 1.7 29 Aug 1997 09:42:02 ENH
|
|
* SFR1259: Changed SystemError
|
|
*
|
|
* Rev 1.6 12 Aug 1997 09:50:52 MD
|
|
* SFR1002: Remove kernel tracing code
|
|
*
|
|
* Rev 1.5 10 Jul 1997 18:04:26 AK
|
|
* SFR1016: Initial changes to support Unicode
|
|
*
|
|
* Rev 1.4 10 Jul 1997 17:34:10 KH
|
|
* SFR1022: Get 16-bit trace working
|
|
*
|
|
* Rev 1.3 03 Jul 1997 13:28:50 AK
|
|
* SFR0000: Initial development completed
|
|
**/
|
|
/**MOD-**********************************************************************/
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* CONTENTS */
|
|
/* ======== */
|
|
/* TRC_SystemError */
|
|
/* TRC_Initialize */
|
|
/* TRC_Terminate */
|
|
/* */
|
|
/****************************************************************************/
|
|
|
|
/****************************************************************************/
|
|
/* Standard includes. */
|
|
/****************************************************************************/
|
|
#include <adcg.h>
|
|
|
|
/****************************************************************************/
|
|
/* Define TRC_FILE and TRC_GROUP. */
|
|
/****************************************************************************/
|
|
#define TRC_FILE "wtrcapi"
|
|
#define TRC_GROUP TRC_GROUP_TRACE
|
|
|
|
/****************************************************************************/
|
|
/* Trace specific includes. */
|
|
/****************************************************************************/
|
|
#include <atrcapi.h>
|
|
#include <atrcint.h>
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* DATA */
|
|
/* */
|
|
/****************************************************************************/
|
|
#define DC_INCLUDE_DATA
|
|
#include <atrcdata.c>
|
|
#undef DC_INCLUDE_DATA
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* FUNCTIONS */
|
|
/* */
|
|
/****************************************************************************/
|
|
|
|
/**PROC+*********************************************************************/
|
|
/* TRC_SystemError(...) */
|
|
/* */
|
|
/* See wtrcapi.h for description. */
|
|
/**PROC-*********************************************************************/
|
|
DCVOID DCAPI DCEXPORT TRC_SystemError(DCUINT traceComponent,
|
|
DCUINT lineNumber,
|
|
PDCTCHAR funcName,
|
|
PDCTCHAR fileName,
|
|
PDCTCHAR string)
|
|
|
|
{
|
|
/************************************************************************/
|
|
/* The process of getting the system error is clearly platform specific */
|
|
/* so we call the platform specific function. */
|
|
/************************************************************************/
|
|
TRCSystemError(traceComponent,
|
|
lineNumber,
|
|
funcName,
|
|
fileName,
|
|
string);
|
|
|
|
return;
|
|
|
|
} /* TRC_SystemError */
|
|
|
|
/**PROC+*********************************************************************/
|
|
/* TRC_Initialize(...) */
|
|
/* */
|
|
/* See atrcapi.h for description. */
|
|
/**PROC-*********************************************************************/
|
|
DCUINT32 DCAPI DCEXPORT TRC_Initialize(DCBOOL initShared)
|
|
{
|
|
DCUINT rc = 0;
|
|
#ifndef OS_WINCE
|
|
SECURITY_ATTRIBUTES sa;
|
|
SECURITY_DESCRIPTOR sd;
|
|
OSVERSIONINFO ver;
|
|
PSID psidEveryone = NULL;
|
|
SID_IDENTIFIER_AUTHORITY sidEveryoneAuthority = SECURITY_WORLD_SID_AUTHORITY;
|
|
DCUINT32 dwDaclLength;
|
|
PACL pDacl = NULL;
|
|
#endif
|
|
|
|
BOOL releaseMutex = FALSE;
|
|
|
|
DC_IGNORE_PARAMETER(initShared);
|
|
|
|
/************************************************************************/
|
|
/* Create the mutex object which protects the shared memory mapped */
|
|
/* file. If the mutex has already been created then CreateMutex simply */
|
|
/* returns a handle to the existing mutex. */
|
|
/* */
|
|
/* The mutex will be created with a NULL Dacl so processes running it in*/
|
|
/* any context can have access. */
|
|
/************************************************************************/
|
|
#ifndef OS_WINCE
|
|
ver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
|
|
GetVersionEx(&ver);
|
|
if (ver.dwPlatformId == VER_PLATFORM_WIN32_NT) {
|
|
|
|
/************************************************************************/
|
|
/* Get the SID for the Everyone group */
|
|
/************************************************************************/
|
|
if (!AllocateAndInitializeSid (
|
|
&sidEveryoneAuthority, // pIdentifierAuthority
|
|
1, // count of subauthorities
|
|
SECURITY_WORLD_RID, // subauthority 0
|
|
0, 0, 0, 0, 0, 0, 0, // subauthorities n
|
|
&psidEveryone)) { // pointer to pointer to SID
|
|
rc = TRC_RC_CREATE_MUTEX_FAILED;
|
|
OutputDebugString(_T("AllocateAndInitializeSid failed.\n"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* Allocate the Dacl */
|
|
/************************************************************************/
|
|
dwDaclLength = sizeof(ACL);
|
|
dwDaclLength += (sizeof(ACCESS_DENIED_ACE) - sizeof(DWORD)) +
|
|
GetLengthSid(psidEveryone);
|
|
dwDaclLength += (sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD)) +
|
|
GetLengthSid(psidEveryone);
|
|
pDacl = (PACL)LocalAlloc(LMEM_FIXED, dwDaclLength);
|
|
if (pDacl == NULL) {
|
|
rc = TRC_RC_CREATE_MUTEX_FAILED;
|
|
OutputDebugString(_T("Can't allocate Dacl.\n"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* Initialize it. */
|
|
/************************************************************************/
|
|
if (!InitializeAcl(pDacl, dwDaclLength, ACL_REVISION)) {
|
|
rc = TRC_RC_CREATE_MUTEX_FAILED;
|
|
OutputDebugString(_T("InitializeAcl failed.\n"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* Allow all access */
|
|
/************************************************************************/
|
|
if (!AddAccessAllowedAce(
|
|
pDacl,
|
|
ACL_REVISION,
|
|
GENERIC_ALL,
|
|
psidEveryone)) {
|
|
rc = TRC_RC_CREATE_MUTEX_FAILED;
|
|
OutputDebugString(_T("AddAccessAllowedAce failed.\n"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* Block Write-DACL Access */
|
|
/************************************************************************/
|
|
if (!AddAccessDeniedAce(
|
|
pDacl,
|
|
ACL_REVISION,
|
|
WRITE_DAC,
|
|
psidEveryone)) {
|
|
rc = TRC_RC_CREATE_MUTEX_FAILED;
|
|
OutputDebugString(_T("AddAccessDeniedAce failed.\n"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* Create the Mutex */
|
|
/************************************************************************/
|
|
InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION);
|
|
SetSecurityDescriptorDacl(&sd, TRUE, pDacl, FALSE);
|
|
sa.lpSecurityDescriptor = &sd;
|
|
trchMutex = TRCCreateMutex(&sa,
|
|
FALSE,
|
|
TRC_MUTEX_NAME);
|
|
|
|
}
|
|
else {
|
|
#endif
|
|
trchMutex = TRCCreateMutex(NULL,
|
|
FALSE,
|
|
TRC_MUTEX_NAME);
|
|
#ifndef OS_WINCE
|
|
}
|
|
#endif
|
|
|
|
/************************************************************************/
|
|
/* Check that we created the mutex successfully. */
|
|
/************************************************************************/
|
|
if (NULL == trchMutex)
|
|
{
|
|
DWORD lastError = GetLastError();
|
|
OutputDebugString(_T("Failed to create mutex.\n"));
|
|
rc = TRC_RC_CREATE_MUTEX_FAILED;
|
|
DC_QUIT;
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* Now that we've created the mutex, grab it. */
|
|
/************************************************************************/
|
|
TRCGrabMutex();
|
|
releaseMutex = TRUE;
|
|
|
|
/************************************************************************/
|
|
/* Check the current trace DLL state. Another thread may have */
|
|
/* concurrently called TRC_Initialize - if it has then we should exit */
|
|
/* as it will perform the initialization. */
|
|
/************************************************************************/
|
|
if (TRC_STATE_UNINITIALIZED != trcState)
|
|
{
|
|
TRCDebugOutput(_T("Trace DLL already initialized!\n"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* We need to open the shared data memory mapped file. */
|
|
/************************************************************************/
|
|
rc = TRCOpenSharedData();
|
|
|
|
/************************************************************************/
|
|
/* Check that the shared data MMF was created and opened successfully. */
|
|
/************************************************************************/
|
|
if (0 != rc)
|
|
{
|
|
DC_QUIT;
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* Now open the memory mapped trace files. */
|
|
/************************************************************************/
|
|
rc = TRCOpenAllFiles();
|
|
|
|
/************************************************************************/
|
|
/* Check that the trace MMFs were opened successfully. */
|
|
/************************************************************************/
|
|
if (0 != rc)
|
|
{
|
|
DC_QUIT;
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* Write out the trace DLL initialized trace line. */
|
|
/************************************************************************/
|
|
TRCInternalTrace(TRC_TRACE_DLL_INITIALIZE);
|
|
|
|
/************************************************************************/
|
|
/* Update our internal state. */
|
|
/************************************************************************/
|
|
trcState = TRC_STATE_INITIALIZED;
|
|
|
|
/************************************************************************/
|
|
/* Load the debug symbols. */
|
|
/************************************************************************/
|
|
rc = TRCSymbolsLoad();
|
|
|
|
if (0 != rc)
|
|
{
|
|
DC_QUIT;
|
|
}
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
|
|
/************************************************************************/
|
|
/* Release the mutex. */
|
|
/************************************************************************/
|
|
if( releaseMutex )
|
|
{
|
|
TRCReleaseMutex();
|
|
}
|
|
|
|
#ifndef OS_WINCE
|
|
if (pDacl) LocalFree(pDacl);
|
|
if (psidEveryone) FreeSid(psidEveryone);
|
|
#endif
|
|
return(rc);
|
|
|
|
} /* TRC_Initialize */
|
|
|
|
/**PROC+*********************************************************************/
|
|
/* TRC_Terminate(...) */
|
|
/* */
|
|
/* See atrcapi.h for description. */
|
|
/**PROC-*********************************************************************/
|
|
DCVOID DCAPI DCEXPORT TRC_Terminate(DCBOOL termShared)
|
|
{
|
|
DC_IGNORE_PARAMETER(termShared);
|
|
|
|
/************************************************************************/
|
|
/* Grab the mutex. Note that this function is only called from the */
|
|
/* process detach case in the <DllMain> function - therefore we can be */
|
|
/* sure that this function gets called only once per process. */
|
|
/************************************************************************/
|
|
TRCGrabMutex();
|
|
|
|
/************************************************************************/
|
|
/* Unload the symbols if we've loaded them. */
|
|
/************************************************************************/
|
|
if (TEST_FLAG(trcProcessStatus, TRC_STATUS_SYMBOLS_LOADED))
|
|
{
|
|
TRCSymbolsUnload();
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* Write out the trace DLL terminated trace line. */
|
|
/************************************************************************/
|
|
TRCInternalTrace(TRC_TRACE_DLL_TERMINATE);
|
|
|
|
/************************************************************************/
|
|
/* Close the trace files. */
|
|
/************************************************************************/
|
|
TRCCloseAllFiles();
|
|
|
|
/************************************************************************/
|
|
/* Now we need to close the shared data area. */
|
|
/************************************************************************/
|
|
TRCCloseSharedData();
|
|
|
|
/************************************************************************/
|
|
/* We're no longer initialized so update our per-process flags. */
|
|
/************************************************************************/
|
|
trcState = TRC_STATE_TERMINATED;
|
|
|
|
/************************************************************************/
|
|
/* Release the mutex. */
|
|
/************************************************************************/
|
|
TRCReleaseMutex();
|
|
|
|
/************************************************************************/
|
|
/* Close the mutex handle. The mutex object is automatically destroyed */
|
|
/* when the last handle is closed. */
|
|
/************************************************************************/
|
|
TRCCloseHandle(trchMutex);
|
|
trchMutex = NULL;
|
|
|
|
return;
|
|
|
|
} /* TRC_Terminate */
|
|
|
|
#if defined(OS_WINCE) || defined(TRC_CONVERTOANSI)
|
|
/**PROC+*********************************************************************/
|
|
/* Name: TRC_ConvertAndSprintf */
|
|
/* */
|
|
/* Purpose: Convert ANSI trace format string to Unicode and do sprintf */
|
|
/* Windows CE only */
|
|
/* */
|
|
/* Returns: None */
|
|
/* */
|
|
/* Params: OUT outBuf - output buffer */
|
|
/* IN format - ANSI format string */
|
|
/* IN ... - parameters */
|
|
/* */
|
|
/**PROC-*********************************************************************/
|
|
DCVOID DCAPI TRC_ConvertAndSprintf(PDCTCHAR outBuf, const PDCACHAR format,...)
|
|
{
|
|
va_list vaArgs;
|
|
DCINT count;
|
|
static DCTCHAR stackBuffer[TRC_LINE_BUFFER_SIZE];
|
|
|
|
count = DC_MIN(mbstowcs(NULL, format, 0), TRC_LINE_BUFFER_SIZE);
|
|
va_start(vaArgs, format);
|
|
|
|
mbstowcs(stackBuffer, format, count);
|
|
vswprintf(outBuf, stackBuffer, vaArgs);
|
|
va_end(vaArgs);
|
|
|
|
return;
|
|
}
|
|
#else
|
|
/****************************************************************************/
|
|
/* Dummy stub function, to enable a common DEF file to be used. */
|
|
/****************************************************************************/
|
|
DCVOID DCAPI TRC_ConvertAndSprintf(DCVOID)
|
|
{
|
|
return;
|
|
}
|
|
#endif // OS_WINCE
|