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.
433 lines
13 KiB
433 lines
13 KiB
/*++
|
|
|
|
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
|
|
|
|
|