894 lines
25 KiB
C
894 lines
25 KiB
C
/*++
|
|
|
|
Copyright (c) 2001 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
omlog.c
|
|
|
|
Abstract:
|
|
|
|
logging routines for the object log stream
|
|
|
|
this code was jumpstarted from the clusrtl logging code. Most notably, it
|
|
is UTF-8 encoded which allows full Unicode without the cost of writing
|
|
16b. for each character.
|
|
|
|
remaining issues to solve: proper truncation of log file based on current
|
|
starting session. We'd like to remember as many sessions as possible but
|
|
since I've chosen UTF-8, I can't jump to the middle of the file and start
|
|
looking around. One possibility strategy is using an alternate NTFS stream
|
|
to record the starting offsets of sessions. If that stream didn't exist or
|
|
we're on a FAT FS, then we'll continue with the current strategy.
|
|
|
|
Author:
|
|
|
|
Charlie Wickham (charlwi) 07-May-2001
|
|
|
|
Environment:
|
|
|
|
User Mode
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "omp.h"
|
|
|
|
//
|
|
// when this sequence is at the beginning of the file, it indicates that the
|
|
// file is UTF8 encoded
|
|
//
|
|
#define UTF8_BOM "\x0EF\x0BB\x0BF"
|
|
|
|
//
|
|
// Private Data
|
|
//
|
|
|
|
DWORD OmpLogFileLimit;
|
|
DWORD OmpCurrentSessionStart;
|
|
BOOL OmpLogToFile = FALSE;
|
|
HANDLE OmpLogFileHandle = NULL;
|
|
DWORD OmpProcessId;
|
|
DWORD OmpCurrentSessionOffset;
|
|
|
|
PCLRTL_WORK_QUEUE OmpLoggerWorkQueue;
|
|
|
|
//
|
|
// structure used to pass formatted buffers to work queue routine
|
|
//
|
|
typedef struct _OM_LOG_BUFFER_DESC {
|
|
DWORD TimeBytes;
|
|
DWORD MsgBytes;
|
|
PCHAR TimeBuffer;
|
|
PCHAR MsgBuffer;
|
|
} OM_LOG_BUFFER_DESC, *POM_LOG_BUFFER_DESC;
|
|
|
|
#define MAX_NUMBER_LENGTH 20
|
|
|
|
// Specify maximum file size ( DWORD / 1MB )
|
|
|
|
#define MAX_FILE_SIZE ( 0xFFFFF000 / ( 1024 * 1024 ) )
|
|
|
|
DWORD OmpLogFileLimit = ( 1 * 1024 * 1024 ); // 1 MB default
|
|
DWORD OmpLogFileLoWater = 0;
|
|
|
|
//
|
|
// internal functions
|
|
//
|
|
DWORD
|
|
OmpTruncateFile(
|
|
IN HANDLE FileHandle,
|
|
IN DWORD FileSize,
|
|
IN LPDWORD LastPosition
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Truncate a file by copying the portion starting at LastPosition and ending
|
|
at EOF to the front of the file and setting the file's EOF pointer to the
|
|
end of the new chunk. We always keep the current session even that means
|
|
growing larger than the file limit.
|
|
|
|
For now, we have no good way of finding all the sessions within the file,
|
|
so if the file must be truncated, we whack it back to the beginning of the
|
|
current session. If time permits, I'll add something more intelligent
|
|
later on.
|
|
|
|
Arguments:
|
|
|
|
FileHandle - File handle.
|
|
|
|
FileSize - Current End of File.
|
|
|
|
LastPosition - On input, specifies the starting position in the file from
|
|
which the copy begins. On output, it is set to the new EOF
|
|
|
|
Return Value:
|
|
|
|
New end of file.
|
|
|
|
--*/
|
|
|
|
{
|
|
//
|
|
// The following buffer size should never be more than 1/4 the size of the
|
|
// file.
|
|
//
|
|
#define BUFFER_SIZE ( 64 * 1024 )
|
|
DWORD bytesLeft;
|
|
DWORD endPosition = sizeof( UTF8_BOM ) - 1;
|
|
DWORD bufferSize;
|
|
DWORD bytesRead;
|
|
DWORD bytesWritten;
|
|
DWORD fileSizeHigh = 0;
|
|
DWORD readPosition;
|
|
DWORD writePosition;
|
|
PVOID dataBuffer;
|
|
|
|
//
|
|
// current session is already at beginning of file so bale now...
|
|
//
|
|
if ( OmpCurrentSessionOffset == sizeof( UTF8_BOM ) - 1) {
|
|
return FileSize;
|
|
}
|
|
|
|
//
|
|
// don't truncate the current session, i.e., always copy from the start of
|
|
// the current session
|
|
//
|
|
if ( *LastPosition > OmpCurrentSessionOffset ) {
|
|
*LastPosition = OmpCurrentSessionOffset;
|
|
}
|
|
|
|
if ( *LastPosition > FileSize ) {
|
|
//
|
|
// something's confused; the spot we're supposed to copy from is at or
|
|
// past the current EOF. reset the entire file
|
|
//
|
|
goto error_exit;
|
|
}
|
|
|
|
dataBuffer = LocalAlloc( LMEM_FIXED, BUFFER_SIZE );
|
|
if ( !dataBuffer ) {
|
|
goto error_exit;
|
|
}
|
|
|
|
//
|
|
// calc number of bytes to move
|
|
//
|
|
bytesLeft = FileSize - *LastPosition;
|
|
endPosition = bytesLeft + sizeof( UTF8_BOM ) - 1;
|
|
|
|
//
|
|
// Point back to last position for reading.
|
|
//
|
|
readPosition = *LastPosition;
|
|
writePosition = sizeof( UTF8_BOM ) - 1;
|
|
|
|
while ( bytesLeft ) {
|
|
if ( bytesLeft >= BUFFER_SIZE ) {
|
|
bufferSize = BUFFER_SIZE;
|
|
} else {
|
|
bufferSize = bytesLeft;
|
|
}
|
|
bytesLeft -= bufferSize;
|
|
|
|
SetFilePointer( FileHandle,
|
|
readPosition,
|
|
&fileSizeHigh,
|
|
FILE_BEGIN );
|
|
|
|
if ( ReadFile( FileHandle,
|
|
dataBuffer,
|
|
bufferSize,
|
|
&bytesRead,
|
|
NULL ) )
|
|
{
|
|
SetFilePointer( FileHandle,
|
|
writePosition,
|
|
&fileSizeHigh,
|
|
FILE_BEGIN );
|
|
WriteFile( FileHandle,
|
|
dataBuffer,
|
|
bytesRead,
|
|
&bytesWritten,
|
|
NULL );
|
|
} else {
|
|
endPosition = sizeof( UTF8_BOM ) - 1;
|
|
break;
|
|
}
|
|
readPosition += bytesRead;
|
|
writePosition += bytesWritten;
|
|
}
|
|
|
|
LocalFree( dataBuffer );
|
|
|
|
//
|
|
// for now, we only only one truncate by setting the current position to
|
|
// the beginning of file.
|
|
//
|
|
OmpCurrentSessionOffset = sizeof( UTF8_BOM ) - 1;
|
|
|
|
error_exit:
|
|
|
|
//
|
|
// Force end of file to get set.
|
|
//
|
|
SetFilePointer( FileHandle,
|
|
endPosition,
|
|
&fileSizeHigh,
|
|
FILE_BEGIN );
|
|
|
|
SetEndOfFile( FileHandle );
|
|
|
|
*LastPosition = endPosition;
|
|
|
|
return(endPosition);
|
|
|
|
} // OmpTruncateFile
|
|
|
|
VOID
|
|
OmpLoggerWorkThread(
|
|
IN PCLRTL_WORK_ITEM WorkItem,
|
|
IN DWORD Status,
|
|
IN DWORD BytesTransferred,
|
|
IN ULONG_PTR IoContext
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
work queue worker routine. actually does the write to the file.
|
|
|
|
Arguments:
|
|
|
|
standard ClRtl thread args; we only care about WorkItem
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD fileSize;
|
|
DWORD fileSizeHigh;
|
|
DWORD tsBytesWritten;
|
|
DWORD msgBytesWritten;
|
|
|
|
POM_LOG_BUFFER_DESC bufDesc = (POM_LOG_BUFFER_DESC)(WorkItem->Context);
|
|
|
|
fileSize = GetFileSize( OmpLogFileHandle, &fileSizeHigh );
|
|
ASSERT( fileSizeHigh == 0 ); // We're only using DWORDs!
|
|
|
|
if ( fileSize > OmpLogFileLimit ) {
|
|
fileSize = OmpTruncateFile( OmpLogFileHandle, fileSize, &OmpLogFileLoWater );
|
|
}
|
|
|
|
SetFilePointer( OmpLogFileHandle,
|
|
fileSize,
|
|
&fileSizeHigh,
|
|
FILE_BEGIN );
|
|
|
|
WriteFile(OmpLogFileHandle,
|
|
bufDesc->TimeBuffer,
|
|
bufDesc->TimeBytes,
|
|
&tsBytesWritten,
|
|
NULL);
|
|
|
|
WriteFile(OmpLogFileHandle,
|
|
bufDesc->MsgBuffer,
|
|
bufDesc->MsgBytes,
|
|
&msgBytesWritten,
|
|
NULL);
|
|
|
|
//
|
|
// if we haven't set the lo water mark, wait until the file size has
|
|
// crossed the halfway mark and set it to the beginning of the line we
|
|
// just wrote.
|
|
//
|
|
if ( OmpLogFileLoWater == 0 && (fileSize > (OmpLogFileLimit / 2)) ) {
|
|
OmpLogFileLoWater = fileSize;
|
|
|
|
ASSERT( OmpLogFileLoWater >= OmpCurrentSessionOffset );
|
|
}
|
|
|
|
} // OmpLoggerWorkThread
|
|
|
|
VOID
|
|
OmpLogPrint(
|
|
LPWSTR FormatString,
|
|
...
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Prints a message to the object config log file.
|
|
|
|
Arguments:
|
|
|
|
FormatString - The initial message string to print.
|
|
|
|
Any FormatMessage-compatible arguments to be inserted in the message
|
|
before it is logged.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PWCHAR unicodeOutput = NULL;
|
|
PCHAR timestampBuffer;
|
|
DWORD timestampBytes;
|
|
PCHAR utf8Buffer;
|
|
DWORD utf8Bytes;
|
|
PWCHAR unicodeBuffer;
|
|
DWORD unicodeBytes;
|
|
DWORD status = ERROR_SUCCESS;
|
|
|
|
SYSTEMTIME Time;
|
|
ULONG_PTR ArgArray[9];
|
|
va_list ArgList;
|
|
|
|
//
|
|
// init the variable arg list
|
|
//
|
|
va_start(ArgList, FormatString);
|
|
|
|
if ( !OmpLogToFile ) {
|
|
va_end(ArgList);
|
|
return;
|
|
}
|
|
|
|
GetSystemTime(&Time);
|
|
|
|
ArgArray[0] = OmpProcessId;
|
|
ArgArray[1] = GetCurrentThreadId();
|
|
ArgArray[2] = Time.wYear;
|
|
ArgArray[3] = Time.wMonth;
|
|
ArgArray[4] = Time.wDay;
|
|
ArgArray[5] = Time.wHour;
|
|
ArgArray[6] = Time.wMinute;
|
|
ArgArray[7] = Time.wSecond;
|
|
ArgArray[8] = Time.wMilliseconds;
|
|
|
|
//
|
|
// we can get away with formatting it as ANSI since our data is all numbers
|
|
//
|
|
timestampBytes = FormatMessageA(FORMAT_MESSAGE_FROM_STRING |
|
|
FORMAT_MESSAGE_ARGUMENT_ARRAY |
|
|
FORMAT_MESSAGE_ALLOCATE_BUFFER,
|
|
"%1!08lx!.%2!08lx!::%3!02d!/%4!02d!/%5!02d!-%6!02d!:%7!02d!:%8!02d!.%9!03d! ",
|
|
0,
|
|
0,
|
|
(LPSTR)×tampBuffer,
|
|
50,
|
|
(va_list*)&ArgArray);
|
|
|
|
if ( timestampBytes == 0 ) {
|
|
va_end(ArgList);
|
|
// WmiTrace("Prefix format failed, %d: %!ARSTR!", GetLastError(), FormatString);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// format the message in unicode
|
|
//
|
|
try {
|
|
unicodeBytes = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER
|
|
| FORMAT_MESSAGE_FROM_STRING,
|
|
FormatString,
|
|
0,
|
|
0,
|
|
(LPWSTR)&unicodeOutput,
|
|
512,
|
|
&ArgList);
|
|
}
|
|
except ( EXCEPTION_EXECUTE_HANDLER ) {
|
|
unicodeBytes = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER
|
|
| FORMAT_MESSAGE_FROM_STRING
|
|
| FORMAT_MESSAGE_ARGUMENT_ARRAY,
|
|
L"LOGERROR(exception): Could not print message: %1!ws!",
|
|
0,
|
|
0,
|
|
(LPWSTR)&unicodeOutput,
|
|
512,
|
|
(va_list *) &FormatString );
|
|
}
|
|
va_end(ArgList);
|
|
|
|
if (unicodeBytes != 0) {
|
|
PCLRTL_WORK_ITEM workQItem;
|
|
|
|
//
|
|
// convert the output to UTF-8; first get the size to see if it will
|
|
// fit in our stack buffer.
|
|
//
|
|
utf8Bytes = WideCharToMultiByte(CP_UTF8,
|
|
0, // dwFlags
|
|
unicodeOutput,
|
|
unicodeBytes,
|
|
NULL,
|
|
0,
|
|
NULL, // lpDefaultChar
|
|
NULL); // lpUsedDefaultChar
|
|
|
|
utf8Buffer = LocalAlloc( LMEM_FIXED, utf8Bytes );
|
|
if ( utf8Buffer == NULL ) {
|
|
status = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto error_exit;
|
|
}
|
|
|
|
utf8Bytes = WideCharToMultiByte(CP_UTF8,
|
|
0, // dwFlags
|
|
unicodeOutput,
|
|
unicodeBytes,
|
|
utf8Buffer,
|
|
utf8Bytes,
|
|
NULL, // lpDefaultChar
|
|
NULL); // lpUsedDefaultChar
|
|
|
|
workQItem = (PCLRTL_WORK_ITEM)LocalAlloc(LMEM_FIXED,
|
|
sizeof( CLRTL_WORK_ITEM ) + sizeof( OM_LOG_BUFFER_DESC ));
|
|
|
|
if ( workQItem != NULL ) {
|
|
POM_LOG_BUFFER_DESC bufDesc = (POM_LOG_BUFFER_DESC)(workQItem + 1);
|
|
|
|
bufDesc->TimeBytes = timestampBytes;
|
|
bufDesc->TimeBuffer = timestampBuffer;
|
|
bufDesc->MsgBytes = utf8Bytes;
|
|
bufDesc->MsgBuffer = utf8Buffer;
|
|
|
|
ClRtlInitializeWorkItem( workQItem, OmpLoggerWorkThread, bufDesc );
|
|
status = ClRtlPostItemWorkQueue( OmpLoggerWorkQueue, workQItem, 0, 0 );
|
|
|
|
} else {
|
|
status = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto error_exit;
|
|
}
|
|
// WmiTrace("%!level! %!ARSTR!", *(UCHAR*)&LogLevel, AnsiString.Buffer + timestampBytes);
|
|
} else {
|
|
// WmiTrace("Format returned 0 bytes: %!ARSTR!", FormatString);
|
|
status = GetLastError();
|
|
}
|
|
|
|
error_exit:
|
|
if ( unicodeOutput != NULL ) {
|
|
LocalFree( unicodeOutput );
|
|
}
|
|
|
|
return;
|
|
|
|
} // OmpLogPrint
|
|
|
|
|
|
//
|
|
// exported (within OM) functions
|
|
//
|
|
|
|
VOID
|
|
OmpOpenObjectLog(
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Use the clusterlog environment variable to open another file that contains
|
|
object mgr name to ID mapping info. If the routine fails, the failure is
|
|
logged in the cluster log but no logging will be done to the object log
|
|
file.
|
|
|
|
NOTE: access to the file is synchronized since this routine is assumed to
|
|
be called only once by OmInit. Arguments:
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
WCHAR logFileBuffer[MAX_PATH];
|
|
LPWSTR logFileName = NULL;
|
|
LPWSTR objectLogExtension = L".obj";
|
|
DWORD status = ERROR_SUCCESS;
|
|
DWORD defaultLogSize = 1; // in MB
|
|
DWORD envLength;
|
|
WCHAR logFileSize[MAX_NUMBER_LENGTH];
|
|
DWORD logSize;
|
|
LPWSTR lpszBakFileName = NULL;
|
|
DWORD fileSizeHigh = 0;
|
|
DWORD fileSizeLow;
|
|
DWORD bytesWritten;
|
|
PWCHAR dot;
|
|
|
|
UNICODE_STRING logFileString;
|
|
|
|
//
|
|
// see if logging has been specified; get a buffer big enough that will
|
|
// hold the object log name
|
|
//
|
|
envLength = GetEnvironmentVariable(L"ClusterLog",
|
|
logFileBuffer,
|
|
sizeof(logFileBuffer)/sizeof(WCHAR));
|
|
if ( envLength > (( sizeof(logFileBuffer) + sizeof(objectLogExtension)) / sizeof(WCHAR)) ) {
|
|
//
|
|
// allocate a larger buffer since our static one wasn't big enough
|
|
//
|
|
logFileName = LocalAlloc( LMEM_FIXED,
|
|
envLength * sizeof( WCHAR ) );
|
|
if ( logFileName == NULL ) {
|
|
ClRtlLogPrint(LOG_UNUSUAL,
|
|
"[OM] Unable to get memory for Object log filename buffer\n");
|
|
return;
|
|
}
|
|
|
|
envLength = GetEnvironmentVariable(L"ClusterLog",
|
|
logFileName,
|
|
envLength);
|
|
if ( envLength == 0 ) {
|
|
ClRtlLogPrint(LOG_UNUSUAL,
|
|
"[OM] Unable to read ClusterLog environment variable\n");
|
|
|
|
goto error_exit;
|
|
}
|
|
} else if ( envLength != 0 ) {
|
|
logFileName = logFileBuffer;
|
|
}
|
|
|
|
if ( logFileName == NULL ) {
|
|
//
|
|
// logging is turned off or we can't determine where to put the file.
|
|
//
|
|
goto error_exit;
|
|
}
|
|
|
|
//
|
|
// Try to get a limit on the log file size. This number is the number of
|
|
// MB.
|
|
//
|
|
envLength = GetEnvironmentVariable(L"ClusterLogSize",
|
|
logFileSize,
|
|
sizeof(logFileSize)/sizeof(WCHAR));
|
|
|
|
if ( envLength != 0 && envLength < MAX_NUMBER_LENGTH ) {
|
|
RtlInitUnicodeString( &logFileString, logFileSize );
|
|
status = RtlUnicodeStringToInteger( &logFileString,
|
|
10,
|
|
&logSize );
|
|
if ( NT_SUCCESS( status ) ) {
|
|
OmpLogFileLimit = logSize;
|
|
}
|
|
} else {
|
|
OmpLogFileLimit = defaultLogSize;
|
|
}
|
|
|
|
status = ERROR_SUCCESS;
|
|
|
|
if ( OmpLogFileLimit == 0 ) {
|
|
goto error_exit;
|
|
}
|
|
|
|
//
|
|
// make the file size no bigger than one-eighth the size of the normal log
|
|
// file but no less than 256KB
|
|
//
|
|
if ( OmpLogFileLimit > MAX_FILE_SIZE ) {
|
|
OmpLogFileLimit = MAX_FILE_SIZE;
|
|
}
|
|
OmpLogFileLimit = ( OmpLogFileLimit * ( 1024 * 1024 )) / 8;
|
|
if ( OmpLogFileLimit < ( 256 * 1024 )) {
|
|
OmpLogFileLimit = 256 * 1024;
|
|
}
|
|
|
|
//
|
|
// replace the filename with the object log name; deal with the use of
|
|
// forward slashes
|
|
//
|
|
dot = wcsrchr( logFileName, L'.' );
|
|
|
|
if ( dot != NULL ) {
|
|
wcscpy( dot, objectLogExtension );
|
|
} else {
|
|
wcscat( logFileName, objectLogExtension );
|
|
}
|
|
|
|
OmpLogFileHandle = CreateFile(logFileName,
|
|
GENERIC_READ | GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_ALWAYS,
|
|
0,
|
|
NULL );
|
|
|
|
if ( OmpLogFileHandle == INVALID_HANDLE_VALUE ) {
|
|
status = GetLastError();
|
|
|
|
ClRtlLogPrint(LOG_UNUSUAL,
|
|
"[OM] Open of object log file failed. Error %1!u!\n",
|
|
status);
|
|
goto error_exit;
|
|
} else {
|
|
|
|
//
|
|
// write UTF-8 header to beginning of file and get the offset of the
|
|
// EOF; we never want to reset the start of the file after this point.
|
|
//
|
|
WriteFile( OmpLogFileHandle, UTF8_BOM, sizeof( UTF8_BOM ) - 1, &bytesWritten, NULL );
|
|
|
|
OmpCurrentSessionOffset = SetFilePointer( OmpLogFileHandle, 0, NULL, FILE_END );
|
|
if ( OmpCurrentSessionOffset == INVALID_SET_FILE_POINTER ) {
|
|
ClRtlLogPrint(LOG_UNUSUAL,
|
|
"[OM] Unable to get object log end of file position. error %1!u!.\n",
|
|
GetLastError());
|
|
|
|
CloseHandle( OmpLogFileHandle );
|
|
goto error_exit;
|
|
}
|
|
|
|
OmpLogToFile = TRUE;
|
|
OmpProcessId = GetCurrentProcessId();
|
|
|
|
//
|
|
// determine the initial low water mark. We have 3 cases
|
|
// we need to handle:
|
|
// 1) log size is less than 1/2 limit
|
|
// 2) log size is within limit but more than 1/2 limit
|
|
// 3) log size is greater than limit
|
|
//
|
|
// case 1 requires nothing special; the low water mark will be updated
|
|
// on the next log write.
|
|
//
|
|
// for case 2, we need to find the beginning of a line near 1/2 the
|
|
// current limit. for case 3, the place to start looking is current
|
|
// log size - 1/2 limit. In this case, the log will be truncated
|
|
// before the first write occurs, so we need to take the last 1/2
|
|
// limit bytes and copy them down to the front.
|
|
//
|
|
|
|
//
|
|
// For now, set the low water mark to be the current offset. When it
|
|
// is time to wrap, we'll lose everything but the current session.
|
|
//
|
|
// the problem is that we're dealing with UTF8 and we can't just jump
|
|
// in the middle of the file and start looking around (we might hit
|
|
// the 2nd byte of a DBCS sequence). For now, we'll leave
|
|
// OmpLogFileLoWater set to zero. It will get updated when the 1/2 way
|
|
// threshold is crossed.
|
|
//
|
|
OmpLogFileLoWater = OmpCurrentSessionOffset;
|
|
#if 0
|
|
|
|
fileSizeLow = GetFileSize( OmpLogFileHandle, &fileSizeHigh );
|
|
if ( fileSizeLow < ( OmpLogFileLimit / 2 )) {
|
|
//
|
|
// case 1: leave low water at zero; it will be updated with next
|
|
// log write
|
|
//
|
|
;
|
|
} else {
|
|
#define LOGBUF_SIZE 1024
|
|
CHAR buffer[LOGBUF_SIZE];
|
|
LONG currentPosition;
|
|
DWORD bytesRead;
|
|
|
|
if ( fileSizeLow < OmpLogFileLimit ) {
|
|
//
|
|
// case 2; start looking at the 1/2 the current limit to find
|
|
// the starting position
|
|
//
|
|
currentPosition = OmpLogFileLimit / 2;
|
|
} else {
|
|
//
|
|
// case 3: start at current size minus 1/2 limit to find our
|
|
// starting position.
|
|
//
|
|
currentPosition = fileSizeLow - ( OmpLogFileLimit / 2 );
|
|
}
|
|
|
|
//
|
|
// backup from the initial file position, read in a block and look
|
|
// for the start of a session. When we find one, backup to the
|
|
// beginning of that line. Use that as the initial starting
|
|
// position when we finally truncate the file.
|
|
//
|
|
OmpLogFileLoWater = 0;
|
|
currentPosition -= LOGBUF_SIZE;
|
|
|
|
SetFilePointer(OmpLogFileHandle,
|
|
currentPosition,
|
|
&fileSizeHigh,
|
|
FILE_BEGIN);
|
|
|
|
do {
|
|
|
|
if ( ReadFile(OmpLogFileHandle,
|
|
buffer,
|
|
LOGBUF_SIZE - 1,
|
|
&bytesRead,
|
|
NULL ) )
|
|
{
|
|
PCHAR p = buffer;
|
|
PCHAR newp;
|
|
|
|
buffer[ bytesRead ] = NULL;
|
|
while ( *p != 'S' && bytesRead-- != 0 ) {
|
|
newp = CharNextExA( CP_UTF8, p, 0 );
|
|
if ( newp == p ) {
|
|
break;
|
|
}
|
|
p = newp;
|
|
}
|
|
|
|
if ( p != newp ) {
|
|
if ( strchr( p, "START" )) {
|
|
//
|
|
// set pointer to beginning of line
|
|
//
|
|
p = currentLine;
|
|
break;
|
|
}
|
|
} else {
|
|
//
|
|
// not found in this block; read in the next one
|
|
//
|
|
|
|
}
|
|
}
|
|
} while ( TRUE );
|
|
|
|
if ( *p == '\n' ) {
|
|
OmpLogFileLoWater = (DWORD)(currentPosition + ( p - buffer + 1 ));
|
|
}
|
|
|
|
if ( OmpLogFileLoWater == 0 ) {
|
|
//
|
|
// couldn't find any reasonable data. just set it to
|
|
// initial current position.
|
|
//
|
|
OmpLogFileLoWater = currentPosition + LOGBUF_SIZE;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
//
|
|
// finally, create the threadq that will handle the IO to the file
|
|
//
|
|
OmpLoggerWorkQueue = ClRtlCreateWorkQueue( 1, THREAD_PRIORITY_BELOW_NORMAL );
|
|
if ( OmpLoggerWorkQueue == NULL ) {
|
|
CloseHandle( OmpLogFileHandle );
|
|
|
|
ClRtlLogPrint(LOG_UNUSUAL,
|
|
"[OM] Unable to logger work queue. error %1!u!.\n",
|
|
GetLastError());
|
|
}
|
|
|
|
error_exit:
|
|
if ( logFileName != logFileBuffer && logFileName != NULL ) {
|
|
LocalFree( logFileName );
|
|
}
|
|
|
|
} // OmpOpenObjectLog
|
|
|
|
VOID
|
|
OmpLogStartRecord(
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Description
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
OSVERSIONINFOEXW version;
|
|
BOOL success;
|
|
PWCHAR suiteAbbrev;
|
|
SYSTEMTIME localTime;
|
|
|
|
GetLocalTime( &localTime );
|
|
|
|
version.dwOSVersionInfoSize = sizeof(version);
|
|
success = GetVersionExW((POSVERSIONINFOW)&version);
|
|
|
|
if ( success ) {
|
|
//
|
|
// Log the System version number
|
|
//
|
|
if ( version.wSuiteMask & VER_SUITE_DATACENTER ) {
|
|
suiteAbbrev = L"DTC";
|
|
} else if ( version.wSuiteMask & VER_SUITE_ENTERPRISE ) {
|
|
suiteAbbrev = L"ADS";
|
|
} else if ( version.wSuiteMask & VER_SUITE_EMBEDDEDNT ) {
|
|
suiteAbbrev = L"EMB";
|
|
} else if ( version.wProductType & VER_NT_WORKSTATION ) {
|
|
suiteAbbrev = L"WS";
|
|
} else if ( version.wProductType & VER_NT_DOMAIN_CONTROLLER ) {
|
|
suiteAbbrev = L"DC";
|
|
} else if ( version.wProductType & VER_NT_SERVER ) {
|
|
suiteAbbrev = L"SRV"; // otherwise - some non-descript Server
|
|
} else {
|
|
suiteAbbrev = L"";
|
|
}
|
|
|
|
OmpLogPrint(L"START %1!02d!/%2!02d!/%3!02d!-%4!02d!:%5!02d!:%6!02d!.%7!03d! %8!u! %9!u! "
|
|
L"%10!u! %11!u! %12!u! %13!u! \"%14!ws!\" "
|
|
L"%15!u! %16!u! %17!04X! (%18!ws!) %19!u!\n",
|
|
localTime.wYear,
|
|
localTime.wMonth,
|
|
localTime.wDay,
|
|
localTime.wHour,
|
|
localTime.wMinute,
|
|
localTime.wSecond,
|
|
localTime.wMilliseconds,
|
|
CLUSTER_GET_MAJOR_VERSION( CsMyHighestVersion ),
|
|
CLUSTER_GET_MINOR_VERSION( CsMyHighestVersion ),
|
|
version.dwMajorVersion, // param 10
|
|
version.dwMinorVersion,
|
|
version.dwBuildNumber,
|
|
version.dwPlatformId,
|
|
version.szCSDVersion,
|
|
version.wServicePackMajor, // param 15
|
|
version.wServicePackMinor,
|
|
version.wSuiteMask,
|
|
suiteAbbrev,
|
|
version.wProductType);
|
|
}
|
|
|
|
} // OmpLogStartRecord
|
|
|
|
VOID
|
|
OmpLogStopRecord(
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Description
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
OmpLogPrint( L"STOP\n" );
|
|
|
|
} // OmpLogStopRecord
|
|
|
|
|
|
/* end omlog.c */
|