archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
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.
3 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 827363a95b
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '827363a95b'
${ noResults }
windows-server-2003/base/fs/rdr2/rxce/rxlog.c

783 lines
27 KiB
Raw Blame History

/*++
Copyright (c) 1989 Microsoft Corporation
Module Name:
RxLog.c
Abstract:
This module implements the logging system used by the Rx file system.
Author:
JoeLinn [JoeLinn] 1-Dec-94
Revision History:
Balan Sethu Raman [SethuR] 24-April-95
Revised to conform to new log record layout.
--*/
#include "precomp.h"
#pragma hdrstop
#include "stdarg.h"
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "prefix.h"
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, RxUninitializeLog)
#pragma alloc_text(PAGE, RxInitializeLog)
#pragma alloc_text(PAGE, RxPrintLog)
#pragma alloc_text(PAGE, RxpTrackDereference)
#endif
#if !DBG
#undef RDBSSTRACE
#endif
//
// The debug trace level
//
#define Dbg (0)
#define RDBSSHUGELOG
#if DBG
#define RX_LOG_BUFFER_SIZE 5000
#else
#if RDBSSLOG
#define RX_LOG_BUFFER_SIZE 500
#else
#define RX_LOG_BUFFER_SIZE 0
#endif
#endif
#define MAX_RX_LOG_BUFFER_ALLOC (256*1024)
#define RX_LOG_MAX_MDLLIST_LENGTH 100
RX_LOG s_RxLog = {0,RX_LOG_UNINITIALIZED,NULL,NULL,NULL,0,0,0,0};
PUCHAR RxContxOperationNames[] = {
RDBSSLOG_ASYNC_NAME_PREFIX "CREATE", //#define IRP_MJ_CREATE 0x00
RDBSSLOG_ASYNC_NAME_PREFIX "CR_NMPIPE", //#define IRP_MJ_CREATE_NAMED_PIPE 0x01
RDBSSLOG_ASYNC_NAME_PREFIX "CLOSE", //#define IRP_MJ_CLOSE 0x02
RDBSSLOG_ASYNC_NAME_PREFIX "READ", //#define IRP_MJ_READ 0x03
RDBSSLOG_ASYNC_NAME_PREFIX "WRITE", //#define IRP_MJ_WRITE 0x04
RDBSSLOG_ASYNC_NAME_PREFIX "QUERYINFO", //#define IRP_MJ_QUERY_INFORMATION 0x05
RDBSSLOG_ASYNC_NAME_PREFIX "SETINFO", //#define IRP_MJ_SET_INFORMATION 0x06
RDBSSLOG_ASYNC_NAME_PREFIX "QUERYEA", //#define IRP_MJ_QUERY_EA 0x07
RDBSSLOG_ASYNC_NAME_PREFIX "SETEA", //#define IRP_MJ_SET_EA 0x08
RDBSSLOG_ASYNC_NAME_PREFIX "FLUSH", //#define IRP_MJ_FLUSH_BUFFERS 0x09
RDBSSLOG_ASYNC_NAME_PREFIX "QUERYVOL", //#define IRP_MJ_QUERY_VOLUME_INFORMATION 0x0a
RDBSSLOG_ASYNC_NAME_PREFIX "SETVOL", //#define IRP_MJ_SET_VOLUME_INFORMATION 0x0b
RDBSSLOG_ASYNC_NAME_PREFIX "DIRCTRL", //#define IRP_MJ_DIRECTORY_CONTROL 0x0c
RDBSSLOG_ASYNC_NAME_PREFIX "FSCTL", //#define IRP_MJ_FILE_SYSTEM_CONTROL 0x0d
RDBSSLOG_ASYNC_NAME_PREFIX "IOCTL", //#define IRP_MJ_DEVICE_CONTROL 0x0e
RDBSSLOG_ASYNC_NAME_PREFIX "xIOCTL", //#define IRP_MJ_INTERNAL_DEVICE_CONTROL 0x0f
RDBSSLOG_ASYNC_NAME_PREFIX "SHUTDWN", //#define IRP_MJ_SHUTDOWN 0x10
RDBSSLOG_ASYNC_NAME_PREFIX "LOCKCTRL", //#define IRP_MJ_LOCK_CONTROL 0x11
RDBSSLOG_ASYNC_NAME_PREFIX "CLEANUP", //#define IRP_MJ_CLEANUP 0x12
RDBSSLOG_ASYNC_NAME_PREFIX "CR_MLSLOT", //#define IRP_MJ_CREATE_MAILSLOT 0x13
RDBSSLOG_ASYNC_NAME_PREFIX "QUERYSCRTY",//#define IRP_MJ_QUERY_SECURITY 0x14
RDBSSLOG_ASYNC_NAME_PREFIX "SETSCRTY", //#define IRP_MJ_SET_SECURITY 0x15
RDBSSLOG_ASYNC_NAME_PREFIX "QUERYPWR", //#define IRP_MJ_QUERY_POWER 0x16
RDBSSLOG_ASYNC_NAME_PREFIX "NOTDEFND", //#define IRP_MJ_NOT_DEFINED 0x17
RDBSSLOG_ASYNC_NAME_PREFIX "DVCHANGE", //#define IRP_MJ_DEVICE_CHANGE 0x18
RDBSSLOG_ASYNC_NAME_PREFIX "QRYQUOTA", //#define IRP_MJ_QUERY_QUOTA 0x19
RDBSSLOG_ASYNC_NAME_PREFIX "SETQUOTA", //#define IRP_MJ_SET_QUOTA 0x1a
RDBSSLOG_ASYNC_NAME_PREFIX "PNPPOWER", //#define IRP_MJ_PNP_POWER 0x1b
RDBSSLOG_ASYNC_NAME_PREFIX "********", //internal init 0x1c
"XX"
//#define IRP_MJ_MAXIMUM_FUNCTION 0x1b
};
PRX_LOG_ENTRY_HEADER
RxGetNextLogEntry(void)
{
PRX_LOG_ENTRY_HEADER pEntry;
// you have to hold the spinlock for this....
pEntry = s_RxLog.CurrentEntry + 1;
if (pEntry == s_RxLog.EntryLimit){
s_RxLog.NumberOfLogWraps++;
pEntry = s_RxLog.BaseEntry;
}
s_RxLog.CurrentEntry = pEntry;
return pEntry;
}
VOID
RxUninitializeLog ()
{
PRX_LOG_ENTRY_HEADER EntryLimit = s_RxLog.EntryLimit;
PMDL *MdlList = (PMDL *)(EntryLimit+1);
PAGED_CODE();
//NOTE: none of this is happening under spinlock!
//DbgPrint("UninitLog: mdllist=%08lx,*mdllist=%08lx\n",MdlList,*MdlList);
//DbgBreakPoint();
if ((s_RxLog.State == RX_LOG_UNINITIALIZED) ||
(s_RxLog.State == RX_LOG_ERROR)) {
return;
}
s_RxLog.State = RX_LOG_UNINITIALIZED;
for (;;) {
PMDL Mdl = *MdlList;
PUCHAR Buffer;
if (Mdl == NULL) break;
Buffer = MmGetMdlVirtualAddress(Mdl);
//DbgPrint("UninitLog: buffer=%08lx,mdl=%08lx\n",Buffer,Mdl);
MmUnlockPages(Mdl);
IoFreeMdl(Mdl);
RxFreePool(Buffer);
MdlList++;
}
RxFreePool(s_RxLog.BaseEntry);
return;
};
NTSTATUS
RxInitializeLog ()
{
ULONG NumEntries = RX_LOG_BUFFER_SIZE;
ULONG NumEntriesLeft;
ULONG LogSize = (NumEntries+1)*sizeof(RX_LOG_ENTRY_HEADER);
PRX_LOG_ENTRY_HEADER BaseEntry=NULL,EntryLimit=NULL;
PRX_LOG_ENTRY_HEADER p;
PUCHAR NextBuffer;
PMDL *MdlList;
ULONG MdlListLength = RX_LOG_MAX_MDLLIST_LENGTH*sizeof(PMDL);
ULONG MdlsLeft = RX_LOG_MAX_MDLLIST_LENGTH;
ULONG SpaceLeft;
PAGED_CODE();
if (s_RxLog.State != RX_LOG_UNINITIALIZED) {
return (STATUS_SUCCESS);
}
//only do this stuff once
KeInitializeSpinLock( &s_RxLog.SpinLock );
s_RxLog.LogBufferSizeInEntries = NumEntries;
//first allocate the marginal index array
BaseEntry = RxAllocatePoolWithTag(NonPagedPool,LogSize+MdlListLength,'xr');
if (BaseEntry==NULL) {
s_RxLog.State = RX_LOG_ERROR;
DbgPrint("Couldn't initialize log1");
return (STATUS_INSUFFICIENT_RESOURCES);
}
s_RxLog.BaseEntry = BaseEntry;
EntryLimit = s_RxLog.EntryLimit = BaseEntry+NumEntries;
MdlList = (PMDL *)(EntryLimit+1);
*MdlList = 0;
//DbgPrint("InitLog: mdllist=%08lx,*mdllist=%08lx\n",MdlList,*MdlList);
//now allocate wspace for the actual buffers...since we may be asking for a lot
// we allocate from pages pool and lock down.
SpaceLeft = 0;
for ( p=BaseEntry,NumEntriesLeft=NumEntries;
NumEntriesLeft>0;
p++,NumEntriesLeft-- ) {
if (SpaceLeft<sizeof(RX_LOG_ENTRY_HEADER)) {
PMDL Mdl = NULL;
PUCHAR Buffer=NULL;
NTSTATUS Status;
ULONG AllocLength = min(MAX_RX_LOG_BUFFER_ALLOC,
NumEntriesLeft*MAX_RX_LOG_ENTRY_SIZE);
for (;;) {
Buffer = RxAllocatePoolWithTag(PagedPool,AllocLength,'xr');
if (Buffer) break;
DbgPrint("InitLog: failed alloc at %08lx",AllocLength);
if (AllocLength<PAGE_SIZE) break;
AllocLength >>= 3;
NumEntriesLeft = AllocLength / MAX_RX_LOG_ENTRY_SIZE;
}
if (Buffer==NULL) {
s_RxLog.State = RX_LOG_ERROR;
DbgPrint("Couldn't initialize log2");
RxFreePool(BaseEntry);
return (STATUS_INSUFFICIENT_RESOURCES);
}
if (MdlsLeft==0) {
s_RxLog.State = RX_LOG_ERROR;
DbgPrint("Couldn't initialize log3");
RxFreePool(Buffer);
RxFreePool(BaseEntry);
return (STATUS_INSUFFICIENT_RESOURCES);
}
Mdl = RxAllocateMdl(Buffer,AllocLength);
if (Mdl==NULL) {
s_RxLog.State = RX_LOG_ERROR;
DbgPrint("Couldn't initialize log4");
RxFreePool(Buffer);
RxFreePool(BaseEntry);
return (STATUS_INSUFFICIENT_RESOURCES);
}
RxProbeAndLockPages(Mdl,KernelMode,IoModifyAccess,Status);
if (Status!=(STATUS_SUCCESS)) {
s_RxLog.State = RX_LOG_ERROR;
DbgPrint("Couldn't initialize log5");
RxFreePool(Mdl);
RxFreePool(Buffer);
RxFreePool(BaseEntry);
return Status;
}
//DbgPrint("InitLog: newbuf=%08lx,mdl=%08lx,alloc=%08lx\n",Buffer,Mdl,AllocLength);
MdlsLeft--;
*MdlList = Mdl;
MdlList++;
*MdlList = NULL;
NextBuffer = MmGetSystemAddressForMdlSafe(Mdl, LowPagePriority);
if (NextBuffer == NULL) {
s_RxLog.State = RX_LOG_ERROR;
DbgPrint("Couldn't initialize log5");
MmUnlockPages(Mdl);
RxFreePool(Mdl);
RxFreePool(Buffer);
RxFreePool(BaseEntry);
return STATUS_INSUFFICIENT_RESOURCES;
}
SpaceLeft = AllocLength;
}
p->Buffer = NextBuffer;
*((PULONG)NextBuffer) = '###';
NextBuffer += MAX_RX_LOG_ENTRY_SIZE;
SpaceLeft -= MAX_RX_LOG_ENTRY_SIZE;
}
//DbgPrint("Init Log: numeleft,nummleft=%d,%d\n",NumEntriesLeft,MdlsLeft);
p->Buffer = (PUCHAR)IntToPtr(0xf00df00d);
s_RxLog.State = RX_LOG_ENABLED;
s_RxLog.CurrentEntry = EntryLimit-1;
//DbgPrint("Init Log: exit\n");
return((STATUS_SUCCESS));
}
VOID
_RxPauseLog ()
{
KIRQL oldIrql;
KeAcquireSpinLock( &s_RxLog.SpinLock, &oldIrql );
if (s_RxLog.State == RX_LOG_ENABLED) {
s_RxLog.State = RX_LOG_DISABLED;
}
KeReleaseSpinLock( &s_RxLog.SpinLock, oldIrql );
}
VOID
_RxResumeLog()
{
KIRQL oldIrql;
KeAcquireSpinLock( &s_RxLog.SpinLock, &oldIrql );
if (s_RxLog.State == RX_LOG_DISABLED) {
s_RxLog.State = RX_LOG_ENABLED;
}
KeReleaseSpinLock( &s_RxLog.SpinLock, oldIrql );
}
VOID
RxPrintLog (
IN ULONG EntriesToPrint OPTIONAL
)
{
//KIRQL oldIrql;
PRX_LOG_ENTRY_HEADER LogEntry,EntryLimit;
ULONG i=0;
PAGED_CODE();
RxPauseLog();
if (EntriesToPrint==0) {
EntriesToPrint = RX_LOG_BUFFER_SIZE;
}
DbgPrint("\n\n\nLog Print: Entries = %lu \n", EntriesToPrint);
LogEntry = s_RxLog.CurrentEntry-1;
EntryLimit = s_RxLog.EntryLimit;
for (;EntriesToPrint>0;EntriesToPrint--) {
LogEntry++;
if (LogEntry>=EntryLimit) {
LogEntry = s_RxLog.BaseEntry;
}
DbgPrint("%0ld: %s\n",i++,LogEntry->Buffer);
}
RxResumeLog();
}
VOID
_RxLog(char *Format, ...)
{
va_list arglist;
KIRQL oldIrql;
CLONG LogEntryLength = 0;
BOOLEAN fLogNewEntry = TRUE;
PRX_LOG_ENTRY_HEADER LogEntry;
CHAR EntryString[MAX_RX_LOG_ENTRY_SIZE];
PCHAR pEntryString;
CHAR FormatChar;
CHAR FieldString[MAX_RX_LOG_ENTRY_SIZE];
ULONG FieldLength;
char *OriginalFormat = Format;
ULONG BinaryArgs = 0;
ULONG BinaryStringMask = 1; //the first arg is always a string!!!!
//DbgPrint("RxLog: entry\n");
if (s_RxLog.State != RX_LOG_ENABLED) {
return;
}
pEntryString = EntryString;
va_start(arglist, Format);
//DbgBreakPoint();
for (;;) {
// Copy the format string
while ((LogEntryLength < MAX_RX_LOG_ENTRY_SIZE) &&
((FormatChar = *Format++) != '\0') &&
(FormatChar != '%')) {
if (FormatChar != '\n'){
pEntryString[LogEntryLength++] = FormatChar;
}
}
if ((LogEntryLength < MAX_RX_LOG_ENTRY_SIZE) &&
(FormatChar == '%')) {
if ( (*Format == 'l') || (*Format == 'w') ) {
Format++;
}
switch (*Format++) {
case 'N': //binary placement -- don't try to make it foolproof
{
BinaryArgs++;
*((PULONG)(&EntryString[sizeof(ULONG)])+BinaryArgs) = (ULONG)va_arg(arglist,ULONG);
}
break;
case 'S': //binary placement -- don't try to make it foolproof
{
BinaryArgs++;
BinaryStringMask |= 1<<(BinaryArgs-1);
//DbgPrint("BSM %08lx\n",BinaryStringMask);
*((PULONG)(&EntryString[sizeof(ULONG)])+BinaryArgs) = (ULONG)va_arg(arglist,ULONG);
}
break;
case 'd':
{
// _itoa((LONG)va_arg(arglist,LONG),FieldString,10);
// FieldLength = strlen(FieldString);// + 1;
// if ((LogEntryLength + FieldLength) < MAX_RX_LOG_ENTRY_SIZE) {
// strcpy(&pEntryString[LogEntryLength],FieldString);
// LogEntryLength += FieldLength;
// //pEntryString[LogEntryLength - 1] = ' ';
// }
LONG l = (LONG)va_arg(arglist,LONG);
if ((LogEntryLength + 5) < MAX_RX_LOG_ENTRY_SIZE) {
pEntryString[LogEntryLength++] = 0x5;
pEntryString[LogEntryLength++] = (UCHAR)(0xff&(l>>0));
pEntryString[LogEntryLength++] = (UCHAR)(0xff&(l>>8));
pEntryString[LogEntryLength++] = (UCHAR)(0xff&(l>>16));
pEntryString[LogEntryLength++] = (UCHAR)(0xff&(l>>24));
}
}
break;
case 'c':
pEntryString[LogEntryLength++] = (CHAR)va_arg(arglist,char);
break;
case 'x':
{
// _itoa((LONG)va_arg(arglist,LONG),FieldString,16);
// FieldLength = strlen(FieldString);// + 1;
// if ((LogEntryLength + FieldLength) < MAX_RX_LOG_ENTRY_SIZE) {
// strcpy(&pEntryString[LogEntryLength],FieldString);
// LogEntryLength += FieldLength;
// //pEntryString[LogEntryLength - 1] = ' ';
// }
LONG l = (LONG)va_arg(arglist,LONG);
if ((LogEntryLength + 5) < MAX_RX_LOG_ENTRY_SIZE) {
pEntryString[LogEntryLength++] = 0x4;
pEntryString[LogEntryLength++] = (UCHAR)(0xff&(l>>0));
pEntryString[LogEntryLength++] = (UCHAR)(0xff&(l>>8));
pEntryString[LogEntryLength++] = (UCHAR)(0xff&(l>>16));
pEntryString[LogEntryLength++] = (UCHAR)(0xff&(l>>24));
}
}
break;
case 's':
{
PCHAR pString = &pEntryString[LogEntryLength];
PCHAR pArg = (PCHAR)va_arg(arglist, PCHAR);
ASSERT(pArg!=NULL);
FieldLength = strlen(pArg);// + 1;
if ((LogEntryLength + FieldLength) < MAX_RX_LOG_ENTRY_SIZE) {
strcpy(pString,pArg);
LogEntryLength += FieldLength;
//pEntryString[LogEntryLength - 1] = ' ';
}
}
break;
case 'Z':
{
PCHAR pString = &pEntryString[LogEntryLength];
PUNICODE_STRING pArg = (PUNICODE_STRING)va_arg(arglist, PUNICODE_STRING);
PWCHAR Buffer;
ULONG Length;
//this really only works for ascii strings in unicode......
ASSERT(pArg!=NULL);
Buffer = pArg->Buffer;
// Make sure the length is WCHAR aligned
Length = (pArg->Length & ~(sizeof(WCHAR)-1));
//DbgPrint("yaya=%08lx,%08lx,%08lx\n",pArg,Buffer,Length);
for (;Length>0;Length-=sizeof(WCHAR)) {
if (LogEntryLength < MAX_RX_LOG_ENTRY_SIZE) {
pEntryString[LogEntryLength++] = (UCHAR)(*Buffer++);
} else {
break;
}
}
//DbgBreakPoint();
}
break;
default:
fLogNewEntry = FALSE;
break;
}
} else {
break;
}
}
va_end(arglist);
if (BinaryArgs) {
EntryString[0] = '#';
EntryString[1] = '>';
EntryString[2] = '0'+(UCHAR)BinaryArgs;
EntryString[3] = 0;
*((PULONG)(&EntryString[sizeof(ULONG)])) = BinaryStringMask;
LogEntryLength = MAX_RX_LOG_ENTRY_SIZE;
}
KeAcquireSpinLock( &s_RxLog.SpinLock, &oldIrql );
if (fLogNewEntry) {
s_RxLog.NumberOfLogWriteAttempts++;
LogEntry = RxGetNextLogEntry();
} else {
s_RxLog.NumberOfEntriesIgnored++;
DbgPrint("RxLog: Entry exceeds max size, not recorded <%s>\n",OriginalFormat);
if (s_RxLog.NumberOfEntriesIgnored==1) {
//DbgBreakPoint();
}
}
KeReleaseSpinLock( &s_RxLog.SpinLock, oldIrql );
if (fLogNewEntry) {
BOOLEAN OutOfBounds = ((LogEntry<s_RxLog.BaseEntry) || (LogEntry>=s_RxLog.EntryLimit));
if (OutOfBounds) {
DbgPrint("RxLog: wrap logic has fail.....log disabled\n");
s_RxLog.State = RX_LOG_DISABLED;
} else {
if (LogEntryLength >= MAX_RX_LOG_ENTRY_SIZE) {
LogEntryLength = MAX_RX_LOG_ENTRY_SIZE;
if (BinaryArgs == 0) {
pEntryString[MAX_RX_LOG_ENTRY_SIZE-1] = 0;
}
} else {
pEntryString[LogEntryLength++] = 0;
}
RtlCopyMemory(LogEntry->Buffer,pEntryString,LogEntryLength);
}
}
}
#define RxToUpper(CH) ((CH)&~('A'^'a'))
#define RxIsLetter(CH) ((RxToUpper(CH)>='A') && (RxToUpper(CH)<='Z'))
#define RxIsDigit(CH) (((CH)>='0')&&((CH)<='9'))
VOID
RxDebugControlCommand (
IN char *ControlString
)
/*
This routine manipulates the print and log levels and the breakpoint masks. the format is
AAAAA+AAAAA+AAAAA+AAAAA.....
where each AAAAA == <+-!>*<Letter>*<digit>*.
<letter>* designates a control name.....only enuff to disambiguate is needed.
any + turns on tracing globally
any % turns on tracing globally RIGHT NOW!
any - turns off tracing globally
for 0 !s, it means: for the control <letter>*, set the printlevel to <digit>*
for 1 !s, it means: for the control <letter>* set breakmask bit <digit>*. 0 means all bits
for 2 !s, it means: for the control <letter>* clear breakmask bit <digit>*. 0 means all bits
THIS STUFF (I.E. THE ! STUFF) IS ACTUALLY IMPLEMENTED IN RXTRACE.C
@ means printlog
@@ means pauselog
@@@ means resumelog
@@@@ means initialize
@@@@@ means setup to debug by turning off printing
more than @@@@@ means banner
E.G. cle0+clo0+cre1000+!devf3 sets disables printing for cleanup and close, sets the printlevel
for create to 1000, and enables the third bit of the breakmask for devfcb.
the letter string is upcased automatically.
There is usually one control for each file but some controls control stuff from multiple
files (like dispatch)
*/
{
char namebuf[16], numbuf[16], *p, *q, *c;
//long i;
long level,pointcount,atsigncount;
//DEBUG_TRACE_CONTROLS control;
//ASSERTMSG("Here in debug command parser!\n",FALSE);
RxDbgTrace( 0, (DEBUG_TRACE_ALWAYS), ("RxDebugTraceControl %s!!\n", ControlString));
if (!ControlString)
{
return;
}
for (c = ControlString;;) {
if (*c == 0) break;
p=namebuf;q=numbuf; atsigncount=pointcount = 0;
for (;(*c!=0)&&!RxIsLetter(*c)&&!RxIsDigit(*c); c++){ //skip to a letter or digit
if (*c == '!') {
pointcount++;
}
if (*c == '@') {
atsigncount++;
}
#if RDBSSTRACE
if (*c == '+') {
RxNextGlobalTraceSuppress = FALSE;
}
if (*c == '%') {
RxGlobalTraceSuppress = FALSE;
}
if (*c == '-') {
RxNextGlobalTraceSuppress = TRUE;
}
#endif //RDBSSTRACE
}
for (p=namebuf;(*c!=0)&&RxIsLetter(*c); *p++=RxToUpper(*c++) ) ; //copy letters
for (level=0,q=numbuf;(*c!=0)&&RxIsDigit(*c); *q++=*c++){ //copy digits
level = 10*level+((*c)-'0');
}
*p = *q = (char)0;
{if (atsigncount>0) {
if (atsigncount==1) {
RxPrintLog(level);
} else if (atsigncount == 2) {
RxPauseLog();
} else if (atsigncount == 3) {
RxResumeLog();
} else if (atsigncount == 4) {
RxInitializeLog();
} else if (atsigncount == 5){
#if RDBSSTRACE
RxDebugTraceZeroAllPrintLevels();
RxDbgTraceFindControlPoint((DEBUG_TRACE_UNWIND))->PrintLevel = 10000;
RxDbgTraceFindControlPoint((DEBUG_TRACE_READ))->PrintLevel = 10000;
RxDbgTraceFindControlPoint((DEBUG_TRACE_RXCONTX))->PrintLevel = 1000;
RxDbgTraceFindControlPoint((DEBUG_TRACE_DISPATCH))->PrintLevel = 1000;
RxDbgTraceFindControlPoint((DEBUG_TRACE_CREATE))->PrintLevel = 10000;
RxDbgTraceFindControlPoint((DEBUG_TRACE_CLEANUP))->PrintLevel = 10000;
RxDbgTraceFindControlPoint((DEBUG_TRACE_CLOSE))->PrintLevel = 10000;
#endif
} else {
#if RDBSSTRACE
RxDbgTrace(0, (DEBUG_TRACE_ALWAYS), ("\n\n\n\n\n %s %s\n\n\n\n\n", namebuf, numbuf));
#endif
}
continue;
}}
#if RDBSSTRACE
if (((*namebuf)==0||(*numbuf)==0)) {
continue;
}
RxDebugTraceDebugCommand(namebuf,level,pointcount);
#endif
}
return;
}
#ifdef DBG
VOID
RxpTrackReference(
ULONG TraceType,
PCHAR FileName,
ULONG Line,
PVOID pInstance)
{
if (REF_TRACING_ON(TraceType)) {
ULONG RefCount;
PCHAR pTypeName,pLogTypeName;
switch (TraceType) {
case RDBSS_REF_TRACK_SRVCALL :
pTypeName = "SrvCall";
pLogTypeName = "SC";
RefCount = ((PSRV_CALL)pInstance)->NodeReferenceCount;
RxWmiLog(SRVCALL,RxRefSrvcall,LOGPTR(pInstance)LOGULONG(RefCount)LOGULONG(Line)LOGARSTR(FileName));
break;
case RDBSS_REF_TRACK_NETROOT :
pTypeName = "NetRoot";
pLogTypeName = "NR";
RefCount = ((PNET_ROOT)pInstance)->NodeReferenceCount;
RxWmiLog(NETROOT,RxRefNetRoot,LOGPTR(pInstance)LOGULONG(RefCount)LOGULONG(Line)LOGARSTR(FileName));
break;
case RDBSS_REF_TRACK_VNETROOT:
pTypeName = "VNetRoot";
pLogTypeName = "VN";
RefCount = ((PV_NET_ROOT)pInstance)->NodeReferenceCount;
RxWmiLog(VNETROOT,RxRefVNetRoot,LOGPTR(pInstance)LOGULONG(RefCount)LOGULONG(Line)LOGARSTR(FileName));
break;
case RDBSS_REF_TRACK_NETFOBX :
pTypeName = "NetFobx";
pLogTypeName = "FO";
RefCount = ((PFOBX)pInstance)->NodeReferenceCount;
RxWmiLog(FOBX,RxRefFobx,LOGPTR(pInstance)LOGULONG(RefCount)LOGULONG(Line)LOGARSTR(FileName));
break;
case RDBSS_REF_TRACK_NETFCB :
pTypeName = "NetFcb";
pLogTypeName = "FC";
RefCount = ((PFCB)pInstance)->NodeReferenceCount;
RxWmiLog(FCB,RxRefFcb,LOGPTR(pInstance)LOGULONG(RefCount)LOGULONG(Line)LOGARSTR(FileName));
break;
case RDBSS_REF_TRACK_SRVOPEN :
pTypeName = "SrvOpen";
pLogTypeName = "SO";
RefCount = ((PSRV_OPEN)pInstance)->NodeReferenceCount;
RxWmiLog(SRVOPEN,RxRefSrvOpen,LOGPTR(pInstance)LOGULONG(RefCount)LOGULONG(Line)LOGARSTR(FileName));
break;
default:
DbgPrint("Invalid Node Type for referencing\n");
//DbgBreakPoint();
return;
}
if (RdbssReferenceTracingValue & RX_LOG_REF_TRACKING) {
RxLog(("Ref.%s %lx %ld %lx %ld->%ld",pLogTypeName,pInstance,Line,FileName,RefCount,RefCount+1));
}
if (RdbssReferenceTracingValue & RX_PRINT_REF_TRACKING) {
DbgPrint("Reference %s %lx %ld %s\n",pTypeName,pInstance,Line,FileName);
}
}
}
BOOLEAN
RxpTrackDereference(
ULONG TraceType,
PCHAR FileName,
ULONG Line,
PVOID pInstance)
{
PAGED_CODE();
if (REF_TRACING_ON(TraceType)) {
PCHAR pTypeName,pLogTypeName;
ULONG RefCount;
switch (TraceType) {
case RDBSS_REF_TRACK_SRVCALL :
pTypeName = "SrvCall";
pLogTypeName = "SC";
RefCount = ((PSRV_CALL)pInstance)->NodeReferenceCount;
RxWmiLog(SRVCALL,RxDerefSrvcall,LOGPTR(pInstance)LOGULONG(RefCount)LOGULONG(Line)LOGARSTR(FileName));
break;
case RDBSS_REF_TRACK_NETROOT :
pTypeName = "NetRoot";
pLogTypeName = "NR";
RefCount = ((PNET_ROOT)pInstance)->NodeReferenceCount;
RxWmiLog(NETROOT,RxDerefNetRoot,LOGPTR(pInstance)LOGULONG(RefCount)LOGULONG(Line)LOGARSTR(FileName));
break;
case RDBSS_REF_TRACK_VNETROOT:
pTypeName = "VNetRoot";
pLogTypeName = "VN";
RefCount = ((PV_NET_ROOT)pInstance)->NodeReferenceCount;
RxWmiLog(VNETROOT,RxDerefVNetRoot,LOGPTR(pInstance)LOGULONG(RefCount)LOGULONG(Line)LOGARSTR(FileName));
break;
case RDBSS_REF_TRACK_NETFOBX :
pTypeName = "NetFobx";
pLogTypeName = "FO";
RefCount = ((PFOBX)pInstance)->NodeReferenceCount;
RxWmiLog(FOBX,RxDerefFobx,LOGPTR(pInstance)LOGULONG(RefCount)LOGULONG(Line)LOGARSTR(FileName));
break;
case RDBSS_REF_TRACK_NETFCB :
pTypeName = "NetFcb";
pLogTypeName = "FC";
RefCount = ((PFCB)pInstance)->NodeReferenceCount;
RxWmiLog(FCB,RxDerefFcb,LOGPTR(pInstance)LOGULONG(RefCount)LOGULONG(Line)LOGARSTR(FileName));
break;
case RDBSS_REF_TRACK_SRVOPEN :
pTypeName = "SrvOpen";
pLogTypeName = "SO";
RefCount = ((PSRV_OPEN)pInstance)->NodeReferenceCount;
RxWmiLog(SRVOPEN,RxDerefSrvOpen,LOGPTR(pInstance)LOGULONG(RefCount)LOGULONG(Line)LOGARSTR(FileName));
break;
default:
DbgPrint("Invalid Node Type for referencing\n");
//DbgBreakPoint();
return TRUE;
}
if (RdbssReferenceTracingValue & RX_LOG_REF_TRACKING) {
RxLog(("Deref.%s %lx %ld %lx %ld->%ld",pLogTypeName,pInstance,Line,FileName,RefCount,RefCount-1));
}
if (RdbssReferenceTracingValue & RX_PRINT_REF_TRACKING) {
DbgPrint("Dereference %s %lx %ld %s\n",pTypeName,pInstance,Line,FileName);
}
}
return TRUE;
}
#endif