434 lines
12 KiB
C
434 lines
12 KiB
C
/*++
|
||
|
||
Copyright (c) 1989 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
RxData.c
|
||
|
||
Abstract:
|
||
|
||
This module declares the global data used by the Rx file system.
|
||
|
||
Author:
|
||
|
||
JoeLinn [JoeLinn] 1-Dec-94
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
#include "precomp.h"
|
||
#pragma hdrstop
|
||
#include "stdarg.h"
|
||
#include "stdio.h"
|
||
#include "string.h"
|
||
#include "prefix.h"
|
||
|
||
#if DBG
|
||
|
||
LONG RxDebugTraceIndent = 0;
|
||
|
||
#endif
|
||
|
||
#if RDBSSTRACE
|
||
|
||
BOOLEAN RxGlobalTraceSuppress = FALSE;
|
||
BOOLEAN RxNextGlobalTraceSuppress = FALSE;
|
||
|
||
#define MAXIMUM_DEBUGTRACE_CONTROLS 200
|
||
ULONG RxMaximumTraceControl;
|
||
RX_DEBUG_TRACE_CONTROL RxDebugTraceControl[MAXIMUM_DEBUGTRACE_CONTROLS];
|
||
|
||
#define DEBUGTRACE_NAMEBUFFERSIZE 800
|
||
CHAR RxDebugTraceNameBuffer[DEBUGTRACE_NAMEBUFFERSIZE];
|
||
ULONG RxDTNMptr = 0;
|
||
BOOLEAN RxDTNMCopy = FALSE;
|
||
|
||
|
||
PCHAR RxStorageTypeNames[256];
|
||
PCHAR RxIrpCodeToName[IRP_MJ_MAXIMUM_FUNCTION+1];
|
||
ULONG RxIrpCodeCount[IRP_MJ_MAXIMUM_FUNCTION+1];
|
||
|
||
#endif // RDBSSTRACE
|
||
|
||
|
||
#if RDBSSTRACE
|
||
|
||
//we declare controlpoints differently in the rdbss than in a minirdr. at some point,
|
||
// minirdrs may come and go. for this reason we have to save the name text in
|
||
// a nontransient rdbss storage. for rdbss controlpoints, we just use the name
|
||
// pointer we're given since it is just as persistent as the copy. whether we copy
|
||
// or just point is controlled
|
||
|
||
#define RXDT_Declare(__x) DEBUG_TRACE_CONTROLPOINT RX_DEBUG_TRACE_##__x
|
||
RXDT_Declare(ERROR);
|
||
RXDT_Declare(HOOKS);
|
||
RXDT_Declare(CATCH_EXCEPTIONS);
|
||
RXDT_Declare(UNWIND);
|
||
RXDT_Declare(CLEANUP);
|
||
RXDT_Declare(CLOSE);
|
||
RXDT_Declare(CREATE);
|
||
RXDT_Declare(DIRCTRL);
|
||
RXDT_Declare(EA);
|
||
RXDT_Declare(FILEINFO);
|
||
RXDT_Declare(FSCTRL);
|
||
RXDT_Declare(LOCKCTRL);
|
||
RXDT_Declare(READ);
|
||
RXDT_Declare(VOLINFO);
|
||
RXDT_Declare(WRITE);
|
||
RXDT_Declare(FLUSH);
|
||
RXDT_Declare(DEVCTRL);
|
||
RXDT_Declare(SHUTDOWN);
|
||
RXDT_Declare(PREFIX);
|
||
RXDT_Declare(DEVFCB);
|
||
RXDT_Declare(ACCHKSUP);
|
||
RXDT_Declare(ALLOCSUP);
|
||
RXDT_Declare(DIRSUP);
|
||
RXDT_Declare(FILOBSUP);
|
||
RXDT_Declare(NAMESUP);
|
||
RXDT_Declare(VERFYSUP);
|
||
RXDT_Declare(CACHESUP);
|
||
RXDT_Declare(SPLAYSUP);
|
||
RXDT_Declare(DEVIOSUP);
|
||
RXDT_Declare(FCBSTRUCTS);
|
||
RXDT_Declare(STRUCSUP);
|
||
RXDT_Declare(FSP_DISPATCHER);
|
||
RXDT_Declare(FSP_DUMP);
|
||
RXDT_Declare(RXCONTX);
|
||
RXDT_Declare(DISPATCH);
|
||
RXDT_Declare(NTFASTIO);
|
||
RXDT_Declare(LOWIO);
|
||
RXDT_Declare(MINIRDR);
|
||
RXDT_Declare(DISCCODE); //for the browser interface stuff
|
||
RXDT_Declare(BROWSER);
|
||
RXDT_Declare(CONNECT);
|
||
RXDT_Declare(NTTIMER);
|
||
RXDT_Declare(SCAVTHRD);
|
||
RXDT_Declare(SCAVENGER);
|
||
RXDT_Declare(SHAREACCESS);
|
||
RXDT_Declare(NAMECACHE);
|
||
|
||
// connection engine stuff
|
||
RXDT_Declare(RXCEBINDING);
|
||
RXDT_Declare(RXCEDBIMPLEMENTATION);
|
||
RXDT_Declare(RXCEMANAGEMENT);
|
||
RXDT_Declare(RXCEXMIT);
|
||
RXDT_Declare(RXCEPOOL);
|
||
RXDT_Declare(RXCETDI);
|
||
|
||
|
||
VOID
|
||
RxInitializeDebugTraceControlPoint(
|
||
PSZ Name,
|
||
PDEBUG_TRACE_CONTROLPOINT ControlPoint
|
||
)
|
||
{
|
||
ULONG i;
|
||
|
||
RxMaximumTraceControl++;
|
||
i = RxMaximumTraceControl;
|
||
ASSERT(i<MAXIMUM_DEBUGTRACE_CONTROLS);
|
||
RxDebugTraceControl[i].PrintLevel = 1000;
|
||
RxDebugTraceControl[i].BreakMask = 0xf0000000;
|
||
if (RxDTNMCopy) {
|
||
ULONG len = strlen(Name)+1;
|
||
ASSERT (RxDTNMptr+len<DEBUGTRACE_NAMEBUFFERSIZE);
|
||
RxDebugTraceControl[i].Name= &RxDebugTraceNameBuffer[RxDTNMptr];
|
||
RtlCopyMemory(RxDebugTraceControl[i].Name,Name,len);
|
||
RxDTNMptr += len;
|
||
} else {
|
||
RxDebugTraceControl[i].Name=Name;
|
||
}
|
||
RxDebugTraceControl[i+1].Name=NULL;
|
||
ControlPoint->Name=RxDebugTraceControl[i].Name;
|
||
ControlPoint->ControlPointNumber = i;
|
||
}
|
||
|
||
|
||
#ifdef RxInitializeDebugTrace
|
||
#undef RxInitializeDebugTrace
|
||
#endif
|
||
VOID RxInitializeDebugTrace(void){
|
||
int i;
|
||
|
||
RxDebugTraceIndent = 0;
|
||
RxGlobalTraceSuppress = TRUE;
|
||
RxNextGlobalTraceSuppress = TRUE;
|
||
RxExports.pRxDebugTraceIndent = &RxDebugTraceIndent;
|
||
|
||
|
||
for (i=0;i<=IRP_MJ_MAXIMUM_FUNCTION;i++) {
|
||
RxIrpCodeCount[i] = 0;
|
||
}
|
||
|
||
#if RDBSSTRACE
|
||
#define OneName(x) { RxInitializeDebugTraceControlPoint(#x, &RX_DEBUG_TRACE_##x); }
|
||
RxMaximumTraceControl=0;
|
||
OneName(ACCHKSUP);
|
||
OneName(ALLOCSUP);
|
||
OneName(BROWSER);
|
||
OneName(CACHESUP);
|
||
OneName(CATCH_EXCEPTIONS);
|
||
OneName(CLEANUP);
|
||
OneName(CLOSE);
|
||
OneName(CONNECT);
|
||
OneName(CREATE);
|
||
OneName(HOOKS);
|
||
OneName(DEVCTRL);
|
||
OneName(DEVFCB);
|
||
OneName(DEVIOSUP);
|
||
OneName(DIRCTRL);
|
||
OneName(DIRSUP);
|
||
OneName(DISCCODE);
|
||
OneName(DISPATCH);
|
||
OneName(EA);
|
||
OneName(ERROR);
|
||
OneName(FCBSTRUCTS);
|
||
OneName(FILEINFO);
|
||
OneName(FILOBSUP);
|
||
OneName(FLUSH);
|
||
OneName(FSCTRL);
|
||
OneName(FSP_DISPATCHER);
|
||
OneName(FSP_DUMP);
|
||
OneName(RXCONTX);
|
||
OneName(LOCKCTRL);
|
||
OneName(LOWIO);
|
||
OneName(MINIRDR);
|
||
OneName(NAMESUP);
|
||
OneName(NTFASTIO);
|
||
OneName(NTTIMER);
|
||
OneName(PREFIX);
|
||
OneName(READ);
|
||
OneName(SCAVTHRD);
|
||
OneName(SHUTDOWN);
|
||
OneName(SPLAYSUP);
|
||
OneName(STRUCSUP);
|
||
OneName(UNWIND);
|
||
OneName(VERFYSUP);
|
||
OneName(VOLINFO);
|
||
OneName(WRITE);
|
||
OneName(SCAVENGER);
|
||
OneName(SHAREACCESS);
|
||
OneName(NAMECACHE);
|
||
OneName(RXCEBINDING); //connection engine
|
||
OneName(RXCEDBIMPLEMENTATION);
|
||
OneName(RXCEMANAGEMENT);
|
||
OneName(RXCEXMIT);
|
||
OneName(RXCEPOOL);
|
||
OneName(RXCETDI);
|
||
|
||
RxDTNMCopy = FALSE; // from now on, copy the name
|
||
|
||
RxDebugTraceControl[RX_DEBUG_TRACE_ALLOCSUP.ControlPointNumber].PrintLevel = 0; //get rid of annoying logof msg
|
||
RxDebugTraceControl[RX_DEBUG_TRACE_DISCCODE.ControlPointNumber].PrintLevel = 0; //it's just too much
|
||
RxDebugTraceControl[RX_DEBUG_TRACE_BROWSER.ControlPointNumber].PrintLevel = 0; //it's just too much
|
||
//RxDebugTraceControl[RX_DEBUG_TRACE_CREATE.ControlPointNumber].PrintLevel = 0;
|
||
#endif //rdbsstrace
|
||
|
||
|
||
RxIrpCodeToName[IRP_MJ_CREATE] = "CREATE";
|
||
RxIrpCodeToName[IRP_MJ_CREATE_NAMED_PIPE] = "CREATE_NAMED_PIPE";
|
||
RxIrpCodeToName[IRP_MJ_CLOSE] = "CLOSE";
|
||
RxIrpCodeToName[IRP_MJ_READ] = "READ";
|
||
RxIrpCodeToName[IRP_MJ_WRITE] = "WRITE";
|
||
RxIrpCodeToName[IRP_MJ_QUERY_INFORMATION] = "QUERY_INFORMATION";
|
||
RxIrpCodeToName[IRP_MJ_SET_INFORMATION] = "SET_INFORMATION";
|
||
RxIrpCodeToName[IRP_MJ_QUERY_EA] = "QUERY_EA";
|
||
RxIrpCodeToName[IRP_MJ_SET_EA] = "SET_EA";
|
||
RxIrpCodeToName[IRP_MJ_FLUSH_BUFFERS] = "FLUSH_BUFFERS";
|
||
RxIrpCodeToName[IRP_MJ_QUERY_VOLUME_INFORMATION] = "QUERY_VOLUME_INFORMATION";
|
||
RxIrpCodeToName[IRP_MJ_SET_VOLUME_INFORMATION] = "SET_VOLUME_INFORMATION";
|
||
RxIrpCodeToName[IRP_MJ_DIRECTORY_CONTROL] = "DIRECTORY_CONTROL";
|
||
RxIrpCodeToName[IRP_MJ_FILE_SYSTEM_CONTROL] = "FILE_SYSTEM_CONTROL";
|
||
RxIrpCodeToName[IRP_MJ_DEVICE_CONTROL] = "DEVICE_CONTROL";
|
||
RxIrpCodeToName[IRP_MJ_INTERNAL_DEVICE_CONTROL] = "INTERNAL_DEVICE_CONTROL";
|
||
RxIrpCodeToName[IRP_MJ_SHUTDOWN] = "SHUTDOWN";
|
||
RxIrpCodeToName[IRP_MJ_LOCK_CONTROL] = "LOCK_CONTROL";
|
||
RxIrpCodeToName[IRP_MJ_CLEANUP] = "CLEANUP";
|
||
RxIrpCodeToName[IRP_MJ_CREATE_MAILSLOT] = "CREATE_MAILSLOT";
|
||
RxIrpCodeToName[IRP_MJ_QUERY_SECURITY] = "QUERY_SECURITY";
|
||
RxIrpCodeToName[IRP_MJ_SET_SECURITY] = "SET_SECURITY";
|
||
RxIrpCodeToName[IRP_MJ_POWER] = "POWER";
|
||
RxIrpCodeToName[IRP_MJ_SYSTEM_CONTROL] = "SYSTEM_CONTROL";
|
||
RxIrpCodeToName[IRP_MJ_DEVICE_CHANGE] = "DEVICE_CHANGE";
|
||
RxIrpCodeToName[IRP_MJ_QUERY_QUOTA] = "QUERY_QUOTA";
|
||
RxIrpCodeToName[IRP_MJ_SET_QUOTA] = "SET_QUOTA";
|
||
RxIrpCodeToName[IRP_MJ_PNP_POWER] = "PNP";
|
||
|
||
}
|
||
|
||
VOID
|
||
RxDebugTraceDebugCommand(
|
||
PSZ name,
|
||
ULONG level,
|
||
ULONG pointcount
|
||
)
|
||
{
|
||
ULONG i,mask;
|
||
|
||
|
||
//RxDbgTrace( 0, (DEBUG_TRACE_ALWAYS), ("name/num/!c %s/%lu/%lu!!\n", name, level, pointcount));
|
||
|
||
for (i=1;i<RxMaximumTraceControl;i++) {
|
||
PRX_DEBUG_TRACE_CONTROL control = &RxDebugTraceControl[i];
|
||
ULONG l = strlen(name);
|
||
//RxDbgTrace(0, (DEBUG_TRACE_ALWAYS), ("----->checking %s\n",control->Name));
|
||
if (strncmp(name,control->Name,l)) continue;
|
||
RxDbgTrace( 0, (DEBUG_TRACE_ALWAYS), ("---> got it %s/%lu/%lu !!\n", control->Name, level, pointcount));
|
||
if (pointcount==0) {
|
||
control->PrintLevel = level;
|
||
} else if (pointcount <= 2) {
|
||
if (level==0) {
|
||
mask = 0xffffffff;
|
||
} else {
|
||
mask = 1 << (level-1);
|
||
}
|
||
if (pointcount==1) {
|
||
control->BreakMask |= mask;
|
||
} else {
|
||
control->BreakMask &= ~mask;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
#ifdef RxDbgTraceDisableGlobally
|
||
#undef RxDbgTraceDisableGlobally
|
||
#endif
|
||
BOOLEAN
|
||
RxDbgTraceDisableGlobally(void)
|
||
{
|
||
BOOLEAN flag = RxGlobalTraceSuppress;
|
||
RxGlobalTraceSuppress = TRUE;
|
||
return flag;
|
||
}
|
||
|
||
#ifdef RxDbgTraceEnableGlobally
|
||
#undef RxDbgTraceEnableGlobally
|
||
#endif
|
||
VOID
|
||
RxDbgTraceEnableGlobally(BOOLEAN flag)
|
||
{
|
||
RxNextGlobalTraceSuppress = RxGlobalTraceSuppress = flag;
|
||
}
|
||
|
||
|
||
VOID
|
||
RxDebugTraceZeroAllPrintLevels(
|
||
void
|
||
)
|
||
{
|
||
ULONG i;
|
||
|
||
for (i=1;i<RxMaximumTraceControl;i++) {
|
||
PRX_DEBUG_TRACE_CONTROL control = &RxDebugTraceControl[i];
|
||
control->PrintLevel = 0; // disable output
|
||
}
|
||
}
|
||
|
||
|
||
BOOLEAN
|
||
RxDbgTraceActualNew (
|
||
IN ULONG NewMask,
|
||
IN OUT PDEBUG_TRACE_CONTROLPOINT ControlPoint
|
||
)
|
||
{
|
||
/*
|
||
This routine has the responsibility to determine if a particular dbgprint is going to be printed and ifso to
|
||
fiddle with the indent. so the return value is whether to print; it is also used for just fiddling with the indent
|
||
by setting the highoredr bit of the mask.
|
||
|
||
The Mask is now very complicated owing to the large number of dbgprints i'm trying to control...sigh.
|
||
The low order byte is the controlpoint....usually the file. each controlpoint has a current level associated
|
||
with it. if the level of a a debugtrace is less that then current control level then the debug is printed.
|
||
The next byte is the level of this particular call; again if the level is <= the current level for the control
|
||
you get printed. The next byte is the indent. indents are only processed if printing is done.
|
||
*/
|
||
LONG Indent = ((NewMask>>RxDT_INDENT_SHIFT)&RxDT_INDENT_MASK) - RxDT_INDENT_EXCESS;
|
||
LONG LevelOfThisWrite = (NewMask) & RxDT_LEVEL_MASK;
|
||
BOOLEAN PrintIt = (NewMask&RxDT_SUPPRESS_PRINT)==0;
|
||
BOOLEAN OverrideReturn = (NewMask&RxDT_OVERRIDE_RETURN)!=0;
|
||
LONG _i;
|
||
|
||
ASSERT (Indent==1 || Indent==0 || (Indent==-1));
|
||
|
||
if (RxGlobalTraceSuppress) return FALSE;
|
||
|
||
#if 0
|
||
if (ControlPoint!=NULL){
|
||
ULONG ControlPointNumber = ControlPoint->ControlPointNumber;
|
||
if (ControlPointNumber==0) {
|
||
if (!RxDbgTraceFindControlPointActual(ControlPoint)){
|
||
//couldnt find or initialize the control point text.....hmmmmmmmmmmm
|
||
ASSERT(!"bad return from findcontrolpoint");
|
||
return(FALSE);
|
||
}
|
||
ControlPointNumber = ControlPoint->ControlPointNumber;
|
||
}
|
||
|
||
ASSERT(ControlPointNumber && ControlPointNumber<=RxMaximumTraceControl);
|
||
|
||
if (LevelOfThisWrite > RxDebugTraceControl[ControlPointNumber].PrintLevel ) return FALSE;
|
||
}
|
||
#else
|
||
PrintIt = TRUE;
|
||
#endif
|
||
|
||
|
||
if ((Indent) > 0) {
|
||
RxDebugTraceIndent += (Indent);
|
||
}
|
||
|
||
if (PrintIt) {
|
||
_i = (ULONG)((ULONG_PTR)PsGetCurrentThread());
|
||
|
||
if (RxDebugTraceIndent < 0) {
|
||
RxDebugTraceIndent = 0;
|
||
}
|
||
DbgPrint("%08lx:%-*s",_i,(int)(RxDebugTraceIndent),"");
|
||
}
|
||
|
||
if (Indent < 0) {
|
||
RxDebugTraceIndent += (Indent);
|
||
}
|
||
|
||
ASSERT (RxDebugTraceIndent <= 0x40);
|
||
|
||
return PrintIt||OverrideReturn;
|
||
}
|
||
|
||
PRX_DEBUG_TRACE_CONTROL
|
||
RxDbgTraceFindControlPointActual(
|
||
IN OUT PDEBUG_TRACE_CONTROLPOINT ControlPoint
|
||
)
|
||
{
|
||
ULONG i,ControlPointNumber;
|
||
PUCHAR name;
|
||
|
||
ASSERT (ControlPoint);
|
||
ControlPointNumber = ControlPoint->ControlPointNumber;
|
||
|
||
if (ControlPointNumber) return (&RxDebugTraceControl[ControlPointNumber]);
|
||
|
||
//otherwise, we have to look it up..........
|
||
name = ControlPoint->Name;
|
||
for (i=1;i<RxMaximumTraceControl;i++) {
|
||
PRX_DEBUG_TRACE_CONTROL control = &RxDebugTraceControl[i];
|
||
ULONG l = strlen(name);
|
||
//RxDbgTrace(0, (DEBUG_TRACE_ALWAYS), ("----->checking %s\n",control->Name));
|
||
if (strncmp(name,control->Name,l)) continue;
|
||
DbgPrint("Controlpointlookup=%08lx<%s> to %08lx\n",
|
||
ControlPoint,ControlPoint->Name,i);
|
||
ControlPoint->ControlPointNumber = i;
|
||
return(control);
|
||
}
|
||
DbgPrint("Couldn't find ControlPointName=%s...inserting\n",name);
|
||
RxInitializeDebugTraceControlPoint(name,ControlPoint); //actually copies the name
|
||
return (&RxDebugTraceControl[ControlPoint->ControlPointNumber]);
|
||
}
|
||
|
||
#endif // RDBSSTRACE
|
||
|
||
|