ioassert.c File Reference

#include "iop.h"

Go to the source code of this file.

Classes
struct	_DCERROR_MESSAGE
struct	_DC_OVERRIDE_TABLE
Defines
#define	MAX_NAMED_MAJOR_IRPS   0x1b
#define	MAX_NAMED_PNP_IRP   0x18
#define	MAX_NAMED_WMI_IRP   0x9
#define	MAX_NAMED_POWER_IRP   0x3
Typedefs
typedef _DCERROR_MESSAGE	DCERROR_MESSAGE
typedef _DCERROR_MESSAGE *	PDCERROR_MESSAGE
typedef _DC_OVERRIDE_TABLE	DC_OVERRIDE_TABLE
typedef _DC_OVERRIDE_TABLE *	PDC_OVERRIDE_TABLE
Functions
PCHAR	KeBugCheckUnicodeToAnsi (IN PUNICODE_STRING UnicodeString, OUT PCHAR AnsiBuffer, IN ULONG MaxAnsiLength)
VOID	IopDriverCorrectnessTakeLock (IN PULONG ControlNew, IN LONG StackFramesToSkip)
VOID	IopDriverCorrectnessReleaseLock (VOID)
NTSTATUS	IopDriverCorrectnessCheckUnderLock (IN DCERROR_ID MessageID, IN ULONG MessageParameterMask,...)
VOID	IopDriverCorrectnessProcessParams (IN OUT PULONG Control OPTIONAL, IN LONG StackFramesToSkip, IN DCERROR_ID MessageID, IN ULONG MessageParameterMask, IN va_list *MessageParameters, IN PVOID *DcParamArray, OUT PDC_CHECK_DATA DcCheckData)
BOOLEAN	IopDriverCorrectnessApplyControl (IN OUT PDC_CHECK_DATA DcCheckData)
NTSTATUS	IopDriverCorrectnessProcessMessageText (IN ULONG MaxOutputBufferSize, OUT PSTR OutputBuffer, IN OUT PDC_CHECK_DATA DcCheckData)
VOID	IopDriverCorrectnessThrowBugCheck (IN PDC_CHECK_DATA DcCheckData)
VOID	IopDriverCorrectnessPrintBuffer (IN PDC_CHECK_DATA DcCheckData)
VOID	IopDriverCorrectnessPrintParamData (IN PDC_CHECK_DATA DcCheckData)
VOID	IopDriverCorrectnessPrompt (IN PDC_CHECK_DATA DcCheckData, OUT PBOOLEAN ExitAssertion)
PVOID	IopDriverCorrectnessAddressToFileHeader (IN PVOID Address, OUT PLDR_DATA_TABLE_ENTRY *DataTableEntry)
BOOLEAN	IopIsMemoryRangeReadable (IN PVOID Location, IN size_t Length)
VOID	IopDriverCorrectnessPrintIrp (IN PIRP IrpToFlag)
VOID	IopDriverCorrectnessPrintIrpStack (IN PIO_STACK_LOCATION IrpSp)
Variables
PULONG	IopDcControlCurrent = NULL
LONG	IopDcCurrentFrameSkips = -1
KIRQL	IopDcControlIrql
KSPIN_LOCK	IopDcControlLock
ULONG	IopDcControlInitial = (ULONG) -1
ULONG	IopDcControlOverride = (ULONG) -1
DCPARAM_TYPE_ENTRY	DcParamTable []
DCERROR_CLASS	IopDcWdmDriverErrorFatal
DCERROR_CLASS	IopDcWdmDriverErrorNonFatal
DCERROR_CLASS	IopDcWdmDriverWarning
DCERROR_CLASS	IopDcWdmDriverPostponed = { DIAG_ZAPPED, "POSTPONED WDM DRIVER BUG" }
DCERROR_CLASS	IopDcWdmCoreError = { DIAG_BEEP, "CORE DRIVER ERROR" }
DCERROR_MESSAGE	IopDcMessageTable [DCERROR_MAXIMUM-DCERROR_UNSPECIFIED]
DC_OVERRIDE_TABLE	IopDcOverrideTable []
PCHAR	IrpMajorNames []
PCHAR	PnPIrpNames []
PCHAR	WmiIrpNames []
PCHAR	PowerIrpNames []

---

Define Documentation

#define MAX_NAMED_MAJOR_IRPS   0x1b

Definition at line 1454 of file ioassert.c. Referenced by IopDriverCorrectnessPrintIrpStack().

#define MAX_NAMED_PNP_IRP   0x18

Definition at line 1486 of file ioassert.c. Referenced by IopDriverCorrectnessPrintIrpStack().

#define MAX_NAMED_POWER_IRP   0x3

Definition at line 1512 of file ioassert.c. Referenced by IopDriverCorrectnessPrintIrpStack().

#define MAX_NAMED_WMI_IRP   0x9

Definition at line 1502 of file ioassert.c. Referenced by IopDriverCorrectnessPrintIrpStack().

---

Typedef Documentation

typedef struct _DC_OVERRIDE_TABLE DC_OVERRIDE_TABLE

typedef struct _DCERROR_MESSAGE DCERROR_MESSAGE

typedef struct _DC_OVERRIDE_TABLE * PDC_OVERRIDE_TABLE

typedef struct _DCERROR_MESSAGE * PDCERROR_MESSAGE

---

Function Documentation

PVOID IopDriverCorrectnessAddressToFileHeader (  IN PVOID  Address, OUT PLDR_DATA_TABLE_ENTRY *  DataTableEntry )

Definition at line 1254 of file ioassert.c. References NULL, and PsLoadedModuleList. Referenced by IopDriverCorrectnessProcessParams(). : This function returns the base of an image that contains the specified Address. An image contains the address if the address is within the ImageBase, and the ImageBase plus the size of the virtual image. Arguments: Address - Supplies an address to resolve to a loader entry. DataTableEntry - Suppies a pointer to a variable that receives the address of the data table entry that describes the image. Return Value: NULL - No image was found that contains the passed in address. NON-NULL - Returns the base address of the image that contain the address. --*/ { PLIST_ENTRY ModuleListHead; PLDR_DATA_TABLE_ENTRY Entry; PLIST_ENTRY Next; UINT_PTR Bounds; PVOID ReturnBase=NULL, Base; ModuleListHead = &PsLoadedModuleList; // // It would be nice if we could call MiLookupDataTableEntry, but it's // pageable, so we do what the bugcheck stuff does... // Next = ModuleListHead->Flink; if (Next != NULL) { while (Next != ModuleListHead) { Entry = CONTAINING_RECORD(Next, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks); Next = Next->Flink; Base = Entry->DllBase; Bounds = (UINT_PTR)Base + Entry->SizeOfImage; if ((UINT_PTR)Address >= (UINT_PTR)Base && (UINT_PTR)Address < Bounds) { *DataTableEntry = Entry; ReturnBase = Base; break; } } } return ReturnBase; }

BOOLEAN IopDriverCorrectnessApplyControl (  IN OUT PDC_CHECK_DATA  DcCheckData  )

Definition at line 776 of file ioassert.c. References DIAG_CLEARED, DIAG_FATAL_ERROR, DIAG_IGNORE_DRIVER_LIST, DIAG_INITIALIZED, FALSE, IopDcControlInitial, IopDcControlOverride, KdDebuggerEnabled, and TRUE. Referenced by IopDriverCorrectnessCheckUnderLock(). { ULONG assertionControl; if (IopDcControlOverride) { assertionControl = IopDcControlOverride; } else if (DcCheckData->Control) { // // Initialize the control if appropo // if (!((*DcCheckData->Control)&DIAG_INITIALIZED)) { *DcCheckData->Control |= ( DIAG_INITIALIZED | IopDcControlInitial | DcCheckData->AssertionClass->ClassFlags ); } assertionControl = *DcCheckData->Control; } else { assertionControl = ( IopDcControlInitial | DcCheckData->AssertionClass->ClassFlags ); } if (assertionControl&DIAG_CLEARED) { // // If the breakpoint was cleared, then return, print/rip not. // return FALSE; } if ((!(assertionControl&DIAG_IGNORE_DRIVER_LIST)) && (!DcCheckData->InVerifierList)) { // // Not of interest, skip this one. // return FALSE; } // // If there is no debugger, don't halt the machine. We are probably // ripping like mad and the user just wants to be able to boot. // The one exception is if DIAG_FATAL_ERROR is set. Then we shall // invoke the driver bugcheck... // if ((!KdDebuggerEnabled) && (!(assertionControl&DIAG_FATAL_ERROR))) { return FALSE; } // // Record our intentions and continue. // DcCheckData->AssertionControl = assertionControl; return TRUE; }

NTSTATUS IopDriverCorrectnessCheckUnderLock (  IN DCERROR_ID  MessageID, IN ULONG  MessageParameterMask,   ... )

Definition at line 463 of file ioassert.c. References ASSERT, DC_CHECK_DATA, DCERROR_ID, DcParamTable, IopDcControlCurrent, IopDcCurrentFrameSkips, IopDriverCorrectnessApplyControl(), IopDriverCorrectnessPrintBuffer(), IopDriverCorrectnessPrintParamData(), IopDriverCorrectnessProcessMessageText(), IopDriverCorrectnessProcessParams(), IopDriverCorrectnessPrompt(), IopDriverCorrectnessThrowBugCheck(), NT_SUCCESS, and NTSTATUS(). : This routine displays an assert and provides options for removing the breakpoint, changing to just a text-out, etc. This routine is used as part of a macro for providing "Zappable" traps - IE, users get the option of changing how a specific instance of WDM_DEBUG_OUT in the code is handled (default is spew and break, options are spew or blow away for this boot). Macro must call IopDiagSetAssertLock, IopDiagAssertPrintfUnderLock, and IopDiagReleaseAssertLock in order DCPARAM_IRP*(count)+DCPARAM_ROUTINE*(count)+DCPARAM_DEVOBJ*(count), irp1, irp2, irp3, routine1, .., .., devobj1, count can be a max of 3. Arguments: Control - if present, this variable determines whether we will actually do anything. if DIAG_ZAPPED is set we will print the assert text and return. if DIAG_CLEARED is set, we will neither print or stop. if DIAG_BEEP is set, we will beep if not zapped. StackFramesToSkip - If this parameter is -1, it is not used. Otherwise, the assertion code will attempt to walk back the appropriate number of frames and determine the caller to blame based on return address. IrpToFlag - IRP to print out failure data for if mishandling of this IRP was the source of the error. AddressToFlag - Address that the assert should be blaimed on. This should be null if StackFramesToSkip is not -1. AssertionClass - Text describing the overall class of the assert AssertionText - Text specifically describing the assert. Carriage returns should not be embedded in the text, this routine will automatically ensure words are not split across the screen. Notes: The text will automagically be formatted and printed as such: ASSERTION CLASS: ASSERTION TEXT ASSERTION TEXT ASSERTION TEXT ASSERTION TEXT ... --*/ { va_list arglist; UCHAR finalBuffer[512]; NTSTATUS status; DC_CHECK_DATA dcCheckData; PVOID dcParamArray[3*sizeof(DcParamTable)/sizeof(DCPARAM_TYPE_ENTRY)]; BOOLEAN exitAssertion; va_start(arglist, MessageParameterMask); // // Determine what our basic policy towards this check will be and fill out // the dcCheckData structure as well as we can. // IopDriverCorrectnessProcessParams( IopDcControlCurrent, IopDcCurrentFrameSkips, MessageID, MessageParameterMask, &arglist, dcParamArray, &dcCheckData ); va_end(arglist); if (!IopDriverCorrectnessApplyControl(&dcCheckData)) { // // Nothing to see here, just ignore the assert... // return STATUS_SUCCESS; } // // We are going to express our disatifaction somehow. Expand out the // message we've prepared for this scenario. // status = IopDriverCorrectnessProcessMessageText( sizeof(finalBuffer), finalBuffer, &dcCheckData ); if (!NT_SUCCESS(status)) { ASSERT(0); // // Something went wrong with the index lookup! // return status; } do { IopDriverCorrectnessPrintBuffer(&dcCheckData); IopDriverCorrectnessPrintParamData(&dcCheckData); IopDriverCorrectnessThrowBugCheck(&dcCheckData); IopDriverCorrectnessPrompt(&dcCheckData, &exitAssertion); } while (!exitAssertion); return status; }

VOID IopDriverCorrectnessPrintBuffer (  IN PDC_CHECK_DATA  DcCheckData  )

Definition at line 1016 of file ioassert.c. References DbgPrint, DIAG_FATAL_ERROR, KeBugCheckUnicodeToAnsi(), NULL, sprintf(), and strlen(). Referenced by IopDriverCorrectnessCheckUnderLock(). { UCHAR buffer[82]; UCHAR classBuf[81]; UCHAR callerBuf[81+40]; UCHAR ansiDriverName[81]; LONG lMargin, i, lMarginCur, rMargin=78; PSTR lineStart, lastWord, current, lMarginText; // // Put down a carraige return // DbgPrint("\n") ; // // Drop a banner if this is a fatal assert. // if (DcCheckData->AssertionControl&DIAG_FATAL_ERROR) { DbgPrint( "***********************************************************************\n" "* THIS DRIVER BUG IS FATAL AND WILL CAUSE THE VERIFIER TO HALT *\n" "* WINDOWS (BUGCHECK) WHEN THE MACHINE IS NOT UNDER A KERNEL DEBUGGER! *\n" "***********************************************************************\n" "\n" ); } // // Prepare left margin (ClassText) // if (DcCheckData->ClassText != NULL) { lMargin = strlen(DcCheckData->ClassText)+2; DbgPrint("%s: ", DcCheckData->ClassText); } else { lMargin = 0; } if (lMargin+1>=rMargin) { lMargin=0; } for(i=0; i<lMargin; i++) classBuf[i] = ' '; classBuf[lMargin] = '\0'; lMarginText = classBuf+lMargin; lMarginCur = lMargin; lineStart = lastWord = current = DcCheckData->AssertionText; // // Print out culprit if we have him... // if (DcCheckData->CulpritAddress) { if (DcCheckData->DriverName.Length) { KeBugCheckUnicodeToAnsi( &DcCheckData->DriverName, ansiDriverName, sizeof(ansiDriverName) ); sprintf(callerBuf, "[%s @ 0x%p] ", ansiDriverName, DcCheckData->CulpritAddress ); } else { sprintf(callerBuf, "[0x%p] ", DcCheckData->CulpritAddress); } DbgPrint("%s", callerBuf); lMarginCur += strlen(callerBuf); } // // Format and print our assertion text // while(*current) { if (*current == ' ') { if ((current - lineStart) >= (rMargin-lMarginCur-1)) { DbgPrint("%s", lMarginText); lMarginText = classBuf; lMarginCur = lMargin; if ((lastWord-lineStart)<rMargin) { memcpy(buffer, lineStart, (ULONG)(lastWord-lineStart)*sizeof(UCHAR)); buffer[lastWord-lineStart] = '\0'; DbgPrint("%s\n", buffer); } lineStart = lastWord+1; } lastWord = current; } current++; } if ((current - lineStart) >= (rMargin-lMarginCur-1)) { DbgPrint("%s", lMarginText); lMarginText = classBuf; if ((lastWord-lineStart)<rMargin) { memcpy(buffer, lineStart, (ULONG)(lastWord-lineStart)*sizeof(UCHAR)); buffer[lastWord-lineStart] = '\0'; DbgPrint("%s\n", buffer); } lineStart = lastWord+1; } if (lineStart<current) { DbgPrint("%s%s\n", lMarginText, lineStart); } }

VOID IopDriverCorrectnessPrintIrp (  IN PIRP  IrpToFlag  )

Definition at line 1370 of file ioassert.c. References DbgPrint, IO_STACK_LOCATION, IoGetCurrentIrpStackLocation, IoGetNextIrpStackLocation, IopDriverCorrectnessPrintIrpStack(), IopIsMemoryRangeReadable(), and _IO_STACK_LOCATION::MinorFunction. Referenced by IopDriverCorrectnessPrintParamData(). { PIO_STACK_LOCATION irpSpCur ; PIO_STACK_LOCATION irpSpNxt ; // // First see if we can touch the IRP header // if(!IopIsMemoryRangeReadable(IrpToFlag, sizeof(IRP))) { return ; } // // OK, get the next two stack locations... // irpSpNxt = IoGetNextIrpStackLocation( IrpToFlag ); irpSpCur = IoGetCurrentIrpStackLocation( IrpToFlag ); if (IopIsMemoryRangeReadable(irpSpNxt, 2*sizeof(IO_STACK_LOCATION))) { // // Both are present, print the best one! // if (irpSpNxt->MinorFunction == irpSpCur->MinorFunction) { // // Looks forwarded // IopDriverCorrectnessPrintIrpStack(irpSpNxt) ; } else if (irpSpNxt->MinorFunction == 0) { // // Next location is probably currently zero'd // IopDriverCorrectnessPrintIrpStack(irpSpCur) ; } else { DbgPrint("Next: >") ; IopDriverCorrectnessPrintIrpStack(irpSpNxt) ; DbgPrint("Current: ") ; IopDriverCorrectnessPrintIrpStack(irpSpCur) ; } } else if (IopIsMemoryRangeReadable(irpSpCur, sizeof(IO_STACK_LOCATION))) { IopDriverCorrectnessPrintIrpStack(irpSpCur) ; } else if (IopIsMemoryRangeReadable(irpSpNxt, sizeof(IO_STACK_LOCATION))) { IopDriverCorrectnessPrintIrpStack(irpSpNxt) ; } }

VOID IopDriverCorrectnessPrintIrpStack (  IN PIO_STACK_LOCATION  IrpSp  )

Definition at line 1516 of file ioassert.c. References BusQueryCompatibleIDs, BusQueryDeviceID, BusQueryHardwareIDs, BusQueryInstanceID, BusRelations, DbgPrint, DeviceTextDescription, DeviceTextLocationInformation, DeviceUsageTypeDumpFile, DeviceUsageTypeHibernation, DeviceUsageTypePaging, DeviceUsageTypeUndefined, EjectionRelations, IRP_MJ_INTERNAL_DEVICE_CONTROL, IRP_MJ_PNP, IRP_MJ_POWER, IRP_MJ_SYSTEM_CONTROL, IRP_MN_DEVICE_USAGE_NOTIFICATION, IRP_MN_QUERY_BUS_INFORMATION, IRP_MN_QUERY_DEVICE_RELATIONS, IRP_MN_QUERY_DEVICE_TEXT, IRP_MN_QUERY_ID, IRP_MN_QUERY_INTERFACE, IRP_MN_QUERY_LEGACY_BUS_INFORMATION, IRP_MN_READ_CONFIG, IRP_MN_SCSI_CLASS, IRP_MN_SET_LOCK, IRP_MN_WRITE_CONFIG, IrpMajorNames, MAX_NAMED_MAJOR_IRPS, MAX_NAMED_PNP_IRP, MAX_NAMED_POWER_IRP, MAX_NAMED_WMI_IRP, PnPIrpNames, PowerIrpNames, PowerRelations, RemovalRelations, TargetDeviceRelation, and WmiIrpNames. Referenced by IopDriverCorrectnessPrintIrp(). { if ((IrpSp->MajorFunction==IRP_MJ_INTERNAL_DEVICE_CONTROL)&&(IrpSp->MinorFunction == IRP_MN_SCSI_CLASS)) { DbgPrint("IRP_MJ_SCSI") ; } else if (IrpSp->MajorFunction<=MAX_NAMED_MAJOR_IRPS) { DbgPrint(IrpMajorNames[IrpSp->MajorFunction]) ; } else if (IrpSp->MajorFunction==0xFF) { DbgPrint("IRP_MJ_BOGUS") ; } else { DbgPrint("IRP_MJ_??") ; } switch(IrpSp->MajorFunction) { case IRP_MJ_SYSTEM_CONTROL: DbgPrint(".") ; if (IrpSp->MinorFunction<=MAX_NAMED_WMI_IRP) { DbgPrint(WmiIrpNames[IrpSp->MinorFunction]) ; } else if (IrpSp->MinorFunction==0xFF) { DbgPrint("IRP_MN_BOGUS") ; } else { DbgPrint("(Bogus)\n") ; } DbgPrint("\n") ; break ; case IRP_MJ_PNP: DbgPrint(".") ; if (IrpSp->MinorFunction<=MAX_NAMED_PNP_IRP) { DbgPrint(PnPIrpNames[IrpSp->MinorFunction]) ; } else if (IrpSp->MinorFunction==0xFF) { DbgPrint("IRP_MN_BOGUS") ; } else { DbgPrint("(Bogus)\n") ; } switch(IrpSp->MinorFunction) { case IRP_MN_QUERY_DEVICE_RELATIONS: switch(IrpSp->Parameters.QueryDeviceRelations.Type) { case BusRelations: DbgPrint("(BusRelations)") ; break ; case EjectionRelations: DbgPrint("(EjectionRelations)") ; break ; case PowerRelations: DbgPrint("(PowerRelations)") ; break ; case RemovalRelations: DbgPrint("(RemovalRelations)") ; break ; case TargetDeviceRelation: DbgPrint("(TargetDeviceRelation)") ; break ; default: DbgPrint("(Bogus)\n") ; break ; } break ; case IRP_MN_QUERY_INTERFACE: break ; case IRP_MN_QUERY_DEVICE_TEXT: switch(IrpSp->Parameters.QueryId.IdType) { case DeviceTextDescription: DbgPrint("(DeviceTextDescription)") ; break ; case DeviceTextLocationInformation: DbgPrint("(DeviceTextLocationInformation)") ; break ; default: DbgPrint("(Bogus)\n") ; break ; } break ; case IRP_MN_WRITE_CONFIG: case IRP_MN_READ_CONFIG: DbgPrint("(WhichSpace=%x, Buffer=%x, Offset=%x, Length=%x)", IrpSp->Parameters.ReadWriteConfig.WhichSpace, IrpSp->Parameters.ReadWriteConfig.Buffer, IrpSp->Parameters.ReadWriteConfig.Offset, IrpSp->Parameters.ReadWriteConfig.Length ) ; break ; case IRP_MN_SET_LOCK: if (IrpSp->Parameters.SetLock.Lock) DbgPrint("(True)") ; else DbgPrint("(False)") ; break ; case IRP_MN_QUERY_ID: switch(IrpSp->Parameters.QueryId.IdType) { case BusQueryDeviceID: DbgPrint("(BusQueryDeviceID)") ; break ; case BusQueryHardwareIDs: DbgPrint("(BusQueryHardwareIDs)") ; break ; case BusQueryCompatibleIDs: DbgPrint("(BusQueryCompatibleIDs)") ; break ; case BusQueryInstanceID: DbgPrint("(BusQueryInstanceID)") ; break ; default: DbgPrint("(Bogus)\n") ; break ; } break ; case IRP_MN_QUERY_BUS_INFORMATION: // BUGBUG: Should print out break ; case IRP_MN_DEVICE_USAGE_NOTIFICATION: switch(IrpSp->Parameters.UsageNotification.Type) { case DeviceUsageTypeUndefined: DbgPrint("(DeviceUsageTypeUndefined") ; break ; case DeviceUsageTypePaging: DbgPrint("(DeviceUsageTypePaging") ; break ; case DeviceUsageTypeHibernation: DbgPrint("(DeviceUsageTypeHibernation") ; break ; case DeviceUsageTypeDumpFile: DbgPrint("(DeviceUsageTypeDumpFile") ; break ; default: DbgPrint("(Bogus)\n") ; break ; } if (IrpSp->Parameters.UsageNotification.InPath) { DbgPrint(", InPath=TRUE)") ; } else { DbgPrint(", InPath=FALSE)") ; } break ; case IRP_MN_QUERY_LEGACY_BUS_INFORMATION: // BUGBUG: Should print out break ; default: break ; } DbgPrint("\n") ; break ; case IRP_MJ_POWER: DbgPrint(".") ; if (IrpSp->MinorFunction<=MAX_NAMED_POWER_IRP) { DbgPrint(PowerIrpNames[IrpSp->MinorFunction]) ; } else if (IrpSp->MinorFunction==0xFF) { DbgPrint("IRP_MN_BOGUS") ; } else { DbgPrint("(Bogus)\n") ; } DbgPrint("\n") ; break ; default: DbgPrint("\n") ; break ; } }

VOID IopDriverCorrectnessPrintParamData (  IN PDC_CHECK_DATA  DcCheckData  )

Definition at line 1151 of file ioassert.c. References IopDriverCorrectnessPrintIrp(). Referenced by IopDriverCorrectnessCheckUnderLock(). { if (DcCheckData->DcParamArray[0]) { IopDriverCorrectnessPrintIrp((PIRP) DcCheckData->DcParamArray[0]); } }

NTSTATUS IopDriverCorrectnessProcessMessageText (  IN ULONG  MaxOutputBufferSize, OUT PSTR  OutputBuffer, IN OUT PDC_CHECK_DATA  DcCheckData )

Definition at line 842 of file ioassert.c. References DcParamTable, IopDcMessageTable, _DCERROR_MESSAGE::MessageText, and strlen(). Referenced by IopDriverCorrectnessCheckUnderLock(). { ULONG paramType, maxParameterTypes; ULONG arrayIndex, paramLength; PSTR messageHead, newMessage; LONG charsRemaining, length; // // Get the message text. // messageHead = IopDcMessageTable[DcCheckData->TableIndex].MessageText; // // Now manually build out the message. // newMessage = OutputBuffer; charsRemaining = (MaxOutputBufferSize/sizeof(UCHAR))-1; maxParameterTypes = sizeof(DcParamTable)/sizeof(DCPARAM_TYPE_ENTRY); while(*messageHead != '\0') { if (charsRemaining <= 0) { return STATUS_BUFFER_OVERFLOW; } if (*messageHead != '%') { *newMessage = *messageHead; newMessage++; messageHead++; charsRemaining--; } else { for(paramType = 0; paramType < maxParameterTypes; paramType++) { paramLength = strlen(DcParamTable[paramType].DcParamName); // // Do we have a match? // // N.B. - We don't do any case 'de-sensitizing' anywhere, so // everything's cases must match! // if (RtlCompareMemory( messageHead+1, DcParamTable[paramType].DcParamName, paramLength*sizeof(UCHAR)) == paramLength*sizeof(UCHAR)) { arrayIndex = paramType*3; messageHead += (paramLength+1); // // Was an index passed in (ie, "3rd" irp requested)? // if ((*messageHead >= '1') && (*messageHead <= '3')) { // // Adjust table index appropriately. // arrayIndex += (*messageHead - '1') ; messageHead++; } length = _snprintf( newMessage, charsRemaining+1, "%p", DcCheckData->DcParamArray[arrayIndex] ); if (length == -1) { return STATUS_BUFFER_OVERFLOW; } charsRemaining -= length; newMessage += length; break; } } if (paramType == maxParameterTypes) { // // Either the message we looked up is malformed, we don't recognize // the %thing it is talking about, or this is %%! // *newMessage = *messageHead; messageHead++; newMessage++; charsRemaining--; if (*messageHead == '%') { messageHead++; } } } } // // Null-terminate it (we have room because we took one off the buffer size // above). // *newMessage = '\0'; DcCheckData->ClassText = DcCheckData->AssertionClass->MessageClassText; DcCheckData->AssertionText = OutputBuffer; return STATUS_SUCCESS; }

VOID IopDriverCorrectnessProcessParams (  IN OUT PULONG Control  OPTIONAL, IN LONG  StackFramesToSkip, IN DCERROR_ID  MessageID, IN ULONG  MessageParameterMask, IN va_list *  MessageParameters, IN PVOID *  DcParamArray, OUT PDC_CHECK_DATA  DcCheckData )

Definition at line 599 of file ioassert.c. References ASSERT, DCERROR_UNSPECIFIED, _DCPARAM_TYPE_ENTRY::DcParamMask, DcParamTable, FALSE, IopDcMessageTable, IopDcOverrideTable, IopDriverCorrectnessAddressToFileHeader(), KeBugCheckUnicodeToAnsi(), _DCERROR_MESSAGE::MessageClass, _DC_OVERRIDE_TABLE::MessageID, MmIsAddressValid(), NULL, PDC_CHECK_DATA, _DC_OVERRIDE_TABLE::ReplacementClass, RtlCaptureStackBackTrace(), RtlImageNtHeader(), RtlInitUnicodeString(), and TRUE. Referenced by IopDriverCorrectnessCheckUnderLock(). { PVOID returnAddress[1]; PVOID baseOfImage, culpritAddress; ULONG stackHash; PLDR_DATA_TABLE_ENTRY dataTableEntry; PIMAGE_NT_HEADERS ntHeaders; ULONG i, currentMessageMask, paramType, maxParameterTypes, paramMask; ULONG tableIndex; char ansiDriverName[81]; tableIndex = MessageID - DCERROR_UNSPECIFIED; // // Retrieve a pointer to the appropriate message text. // if (tableIndex >= sizeof(IopDcMessageTable)/sizeof(DCERROR_MESSAGE)) { // // Bogus message index! // ASSERT(0); tableIndex = 0; } ASSERT(IopDcMessageTable[tableIndex].MessageID == MessageID); // // OK, we're going to do *something*. Process the incoming parameters. // maxParameterTypes = sizeof(DcParamTable)/sizeof(DCPARAM_TYPE_ENTRY); // // First we grab parameter off the stack and slot them appropriately into // our array of "things". // // The array is in groups of three for each possible member of a given type // (three irps, three routines, three device objects, etc). Items not // referenced in are set to NULL. // currentMessageMask = MessageParameterMask; for(paramType = 0; paramType < maxParameterTypes; paramType++) { paramMask = DcParamTable[paramType].DcParamMask ; for(i=0; i<3; i++) { if (currentMessageMask&(paramMask*3)) { currentMessageMask -= paramMask; DcParamArray[paramType*3+i] = va_arg(*MessageParameters, PVOID); } else { DcParamArray[paramType*3+i] = NULL; } } } // // If this fires, part of the MessageParameterMask was not understood, // probably a bug by the caller! // ASSERT(currentMessageMask == 0); // // Pre-init unhelpful answers... // culpritAddress = NULL; DcCheckData->OffsetIntoImage = 0; DcCheckData->InVerifierList = TRUE; RtlInitUnicodeString(&DcCheckData->DriverName, NULL); // // Blame caller if appropriate // if (StackFramesToSkip != -1) { if (RtlCaptureStackBackTrace(StackFramesToSkip+2, 1, returnAddress, &stackHash)==1) { culpritAddress = returnAddress[0]; } } else { // // %Routine1 // culpritAddress = DcParamArray[3]; } // // Extract the culprit's name if possible... // if (culpritAddress) { baseOfImage = IopDriverCorrectnessAddressToFileHeader( (PVOID) culpritAddress, &dataTableEntry ); if (baseOfImage != NULL) { // // If we found a match, drill into the dataTableEntry's to get // // if (MmIsAddressValid(dataTableEntry->DllBase) != FALSE) { ntHeaders = RtlImageNtHeader(dataTableEntry->DllBase); RtlCopyMemory( &DcCheckData->DriverName, &dataTableEntry->BaseDllName, sizeof(UNICODE_STRING) ); DcCheckData->OffsetIntoImage = (PUCHAR) culpritAddress - (PUCHAR) baseOfImage; } // // Now record whether this is in the verifying table. // if (!(dataTableEntry->Flags & LDRP_IMAGE_VERIFYING)) { DcCheckData->InVerifierList = FALSE; } } } DcCheckData->CulpritAddress = culpritAddress; DcCheckData->DcParamArray = DcParamArray; DcCheckData->TableIndex = tableIndex; DcCheckData->MessageID = MessageID; DcCheckData->Control = Control; DcCheckData->AssertionClass = IopDcMessageTable[DcCheckData->TableIndex].MessageClass; // // Get an ANSI version of the driver name and root through the override // table. // KeBugCheckUnicodeToAnsi( &DcCheckData->DriverName, ansiDriverName, sizeof(ansiDriverName) ); for(i=0; i<sizeof(IopDcOverrideTable)/sizeof(DC_OVERRIDE_TABLE); i++) { if ((IopDcOverrideTable[i].MessageID == MessageID) || (IopDcOverrideTable[i].MessageID == DCERROR_UNSPECIFIED)) { if (!_stricmp(ansiDriverName, IopDcOverrideTable[i].DriverName)) { // // We have a match, override the error class. Note that as // Control is not per-driver, but per assert, we null out // the passed in Control so that we don't apply this override // policy against every driver! // DcCheckData->Control = NULL; DcCheckData->AssertionClass = IopDcOverrideTable[i].ReplacementClass; } } } }

VOID IopDriverCorrectnessPrompt (  IN PDC_CHECK_DATA  DcCheckData, OUT PBOOLEAN  ExitAssertion )

Definition at line 1162 of file ioassert.c. References DbgPrint, DbgPrompt(), DIAG_BEEP, DIAG_CLEARED, DIAG_ZAPPED, FALSE, IopDcControlOverride, and TRUE. Referenced by IopDriverCorrectnessCheckUnderLock(). { char response[2]; ULONG assertionControl; BOOLEAN waitForInput; assertionControl = DcCheckData->AssertionControl; *ExitAssertion = TRUE; // // Vocalize if so ordered. // if (assertionControl&DIAG_BEEP) { DbgPrint("%c", 7); } if (assertionControl&DIAG_ZAPPED) { return; } // // Wait for input... // waitForInput = TRUE; while(waitForInput) { if (DcCheckData->Control) { DbgPrompt( "Break, Ignore, Zap, Remove, Disable all (bizrd)? ", response, sizeof( response )); } else { DbgPrompt( "Break, Ignore, Disable all (bid)? ", response, sizeof( response )); } switch (response[0]) { case 'B': case 'b': DbgPrint("Breaking in... (press g<enter> to return to assert menu)\n"); DbgBreakPoint(); waitForInput = FALSE; *ExitAssertion = FALSE; break; case 'I': case 'i': waitForInput = FALSE; break; case 'Z': case 'z': if (DcCheckData->Control) { DbgPrint("Breakpoint zapped (OS will print text and return)\n"); assertionControl |= DIAG_ZAPPED; assertionControl &=~ DIAG_BEEP; waitForInput = FALSE; } break; case 'D': case 'd': IopDcControlOverride = DIAG_CLEARED; DbgPrint("Verification asserts disabled.\n"); //assertionControl |= DIAG_CLEARED; waitForInput = FALSE; break; case 'R': case 'r': if (DcCheckData->Control) { DbgPrint("Breakpoint removed\n") ; assertionControl |= DIAG_CLEARED; waitForInput = FALSE; } break; } } if (DcCheckData->Control) { *DcCheckData->Control = assertionControl; } }

VOID IopDriverCorrectnessReleaseLock (  VOID   )

Definition at line 446 of file ioassert.c. References IopDcControlCurrent, IopDcControlIrql, IopDcControlLock, IopDcCurrentFrameSkips, and NULL. : Worker routine for KD_ASSERT_OUT, see IopDiagSetAssertLock --*/ { IopDcControlCurrent = NULL ; IopDcCurrentFrameSkips = -1 ; ExReleaseSpinLock( &IopDcControlLock, IopDcControlIrql ); }

VOID IopDriverCorrectnessTakeLock (  IN PULONG  ControlNew, IN LONG  StackFramesToSkip )

Definition at line 423 of file ioassert.c. References ASSERT, IopDcControlCurrent, IopDcControlIrql, IopDcControlLock, IopDcCurrentFrameSkips, IovpInitCalled, and NULL. Referenced by IoVerifierInit(). : Worker routine for KD_ASSERT_OUT, takes the assertion spinlock. We do this because we *must* use a macro to instantiate a caller-specific tag and we cannot pass in that value along with a variable printf style debug output. Hence we must "pre-program" the output routine with the breakpoint ID, and use a spinlock to protect ourselves --*/ { ASSERT(IovpInitCalled); ExAcquireSpinLock( &IopDcControlLock, &IopDcControlIrql ); ASSERT(IopDcControlCurrent == NULL) ; IopDcControlCurrent = ControlNew ; IopDcCurrentFrameSkips = StackFramesToSkip ; }

VOID IopDriverCorrectnessThrowBugCheck (  IN PDC_CHECK_DATA  DcCheckData  )

Definition at line 960 of file ioassert.c. References DIAG_FATAL_ERROR, KdDebuggerEnabled, KeBugCheckEx(), and KeBugCheckUnicodeToAnsi(). Referenced by IopDriverCorrectnessCheckUnderLock(). { PVOID parameterArray[4]; char captionBuffer[256]; char ansiDriverName[81]; UNICODE_STRING unicodeString; // // Do not bugcheck if a kernel debugger is attached, nor if this isn't a // fatal error. // if (KdDebuggerEnabled || (!(DcCheckData->AssertionControl&DIAG_FATAL_ERROR))) { return; } // // We are here because DIAG_FATAL_ERROR is set. We use // FATAL_UNHANDLED_HARD_ERROR so that we can give a // descriptive text string for the problem. // parameterArray[0] = (PVOID) DcCheckData->MessageID; parameterArray[1] = DcCheckData->CulpritAddress; parameterArray[2] = DcCheckData->DcParamArray[0]; parameterArray[3] = DcCheckData->DcParamArray[6]; KeBugCheckUnicodeToAnsi( &DcCheckData->DriverName, ansiDriverName, sizeof(ansiDriverName) ); _snprintf( captionBuffer, sizeof(captionBuffer), "IO SYSTEM VERIFICATION ERROR in %s (%s %x)\n[%s+%x at %p]\n", ansiDriverName, DcCheckData->ClassText, DcCheckData->MessageID, ansiDriverName, DcCheckData->OffsetIntoImage, DcCheckData->CulpritAddress ); KeBugCheckEx( FATAL_UNHANDLED_HARD_ERROR, DRIVER_VERIFIER_IOMANAGER_VIOLATION, (ULONG_PTR) parameterArray, (ULONG_PTR) captionBuffer, (ULONG_PTR) "" // DcCheckData->AssertionText is too technical ); }

BOOLEAN IopIsMemoryRangeReadable (  IN PVOID  Location, IN size_t  Length )

Definition at line 1320 of file ioassert.c. References FALSE, MmIsAddressValid(), and TRUE. Referenced by IopDriverCorrectnessPrintIrp(), IovpAssertNewRequest(), and IovpSessionDataAttachSurrogate(). { while (((ULONG_PTR)Location & (sizeof(ULONG_PTR)-1)) && (Length > 0)) { // // Check to determine if the move will succeed before actually performing // the operation. // if (MmIsAddressValid(Location)==FALSE) { return FALSE ; } ((PCHAR) Location)++ ; Length-- ; } while (Length > (sizeof(ULONG_PTR)-1)) { // // Check to determine if the move will succeed before actually performing // the operation. // if (MmIsAddressValid(Location)==FALSE) { return FALSE ; } ((PCHAR) Location) += sizeof(ULONG_PTR); Length -= sizeof(ULONG_PTR); } while (Length > 0) { // // Check to determine if the move will succeed before actually performing // the operation. // if (MmIsAddressValid(Location)==FALSE) { return FALSE; } ((PCHAR) Location)++ ; Length-- ; } return TRUE ; }

PCHAR KeBugCheckUnicodeToAnsi (  IN PUNICODE_STRING  UnicodeString, OUT PCHAR  AnsiBuffer, IN ULONG  MaxAnsiLength )

Definition at line 160 of file bugcheck.c. Referenced by IopDriverCorrectnessPrintBuffer(), IopDriverCorrectnessProcessParams(), IopDriverCorrectnessThrowBugCheck(), and KeBugCheckEx(). { PCHAR Dst; PWSTR Src; ULONG Length; Length = UnicodeString->Length / sizeof( WCHAR ); if (Length >= MaxAnsiLength) { Length = MaxAnsiLength - 1; } Src = UnicodeString->Buffer; Dst = AnsiBuffer; while (Length--) { *Dst++ = (UCHAR)*Src++; } *Dst = '\0'; return AnsiBuffer; }

---

Variable Documentation

DCPARAM_TYPE_ENTRY DcParamTable[]

Initial value: { { DCPARAM_IRP, "Irp" }, { DCPARAM_ROUTINE, "Routine" }, { DCPARAM_DEVOBJ, "DevObj" }, { DCPARAM_STATUS, "Status" } } Definition at line 67 of file ioassert.c. Referenced by IopDriverCorrectnessCheckUnderLock(), IopDriverCorrectnessProcessMessageText(), and IopDriverCorrectnessProcessParams().

PULONG IopDcControlCurrent = NULL

Definition at line 52 of file ioassert.c. Referenced by IopDriverCorrectnessCheckUnderLock(), IopDriverCorrectnessReleaseLock(), and IopDriverCorrectnessTakeLock().

ULONG IopDcControlInitial = (ULONG) -1

Definition at line 56 of file ioassert.c. Referenced by IopDriverCorrectnessApplyControl(), and IoVerifierInit().

KIRQL IopDcControlIrql

Definition at line 54 of file ioassert.c. Referenced by IopDriverCorrectnessReleaseLock(), and IopDriverCorrectnessTakeLock().

KSPIN_LOCK IopDcControlLock

Definition at line 55 of file ioassert.c. Referenced by IopDriverCorrectnessReleaseLock(), IopDriverCorrectnessTakeLock(), and IoVerifierInit().

ULONG IopDcControlOverride = (ULONG) -1

Definition at line 57 of file ioassert.c. Referenced by IopDriverCorrectnessApplyControl(), IopDriverCorrectnessPrompt(), and IoVerifierInit().

LONG IopDcCurrentFrameSkips = -1

Definition at line 53 of file ioassert.c. Referenced by IopDriverCorrectnessCheckUnderLock(), IopDriverCorrectnessReleaseLock(), and IopDriverCorrectnessTakeLock().

DCERROR_MESSAGE IopDcMessageTable[DCERROR_MAXIMUM-DCERROR_UNSPECIFIED]

Definition at line 123 of file ioassert.c. Referenced by IopDriverCorrectnessProcessMessageText(), and IopDriverCorrectnessProcessParams().

DC_OVERRIDE_TABLE IopDcOverrideTable[]

Definition at line 347 of file ioassert.c. Referenced by IopDriverCorrectnessProcessParams().

DCERROR_CLASS IopDcWdmCoreError = { DIAG_BEEP, "CORE DRIVER ERROR" }

Definition at line 114 of file ioassert.c.

DCERROR_CLASS IopDcWdmDriverErrorFatal

Initial value: { DIAG_BEEP | DIAG_FATAL_ERROR | DIAG_WDM_ERROR, "WDM DRIVER ERROR" } Definition at line 103 of file ioassert.c.

DCERROR_CLASS IopDcWdmDriverErrorNonFatal

Initial value: { DIAG_BEEP | DIAG_WDM_ERROR, "WDM DRIVER ERROR" } Definition at line 106 of file ioassert.c.

DCERROR_CLASS IopDcWdmDriverPostponed = { DIAG_ZAPPED, "POSTPONED WDM DRIVER BUG" }

Definition at line 112 of file ioassert.c.

DCERROR_CLASS IopDcWdmDriverWarning

Initial value: { DIAG_BEEP | DIAG_ZAPPED, "WDM DRIVER WARNING" } Definition at line 109 of file ioassert.c.

PCHAR IrpMajorNames[]

Definition at line 1422 of file ioassert.c. Referenced by IopDriverCorrectnessPrintIrpStack().

PCHAR PnPIrpNames[]

Initial value: { "IRP_MN_START_DEVICE", "IRP_MN_QUERY_REMOVE_DEVICE", "IRP_MN_REMOVE_DEVICE - ", "IRP_MN_CANCEL_REMOVE_DEVICE", "IRP_MN_STOP_DEVICE", "IRP_MN_QUERY_STOP_DEVICE", "IRP_MN_CANCEL_STOP_DEVICE", "IRP_MN_QUERY_DEVICE_RELATIONS", "IRP_MN_QUERY_INTERFACE", "IRP_MN_QUERY_CAPABILITIES", "IRP_MN_QUERY_RESOURCES", "IRP_MN_QUERY_RESOURCE_REQUIREMENTS", "IRP_MN_QUERY_DEVICE_TEXT", "IRP_MN_FILTER_RESOURCE_REQUIREMENTS", "INVALID_IRP_CODE", "IRP_MN_READ_CONFIG", "IRP_MN_WRITE_CONFIG", "IRP_MN_EJECT", "IRP_MN_SET_LOCK", "IRP_MN_QUERY_ID", "IRP_MN_QUERY_PNP_DEVICE_STATE", "IRP_MN_QUERY_BUS_INFORMATION", "IRP_MN_DEVICE_USAGE_NOTIFICATION", "IRP_MN_SURPRISE_REMOVAL", "IRP_MN_QUERY_LEGACY_BUS_INFORMATION", NULL } Definition at line 1457 of file ioassert.c. Referenced by IopDriverCorrectnessPrintIrpStack().

PCHAR PowerIrpNames[]

Initial value: { "IRP_MN_WAIT_WAKE", "IRP_MN_POWER_SEQUENCE", "IRP_MN_SET_POWER", "IRP_MN_QUERY_POWER", NULL } Definition at line 1504 of file ioassert.c. Referenced by IopDriverCorrectnessPrintIrpStack().

PCHAR WmiIrpNames[]

Initial value: { "IRP_MN_QUERY_ALL_DATA", "IRP_MN_QUERY_SINGLE_INSTANCE", "IRP_MN_CHANGE_SINGLE_INSTANCE", "IRP_MN_CHANGE_SINGLE_ITEM", "IRP_MN_ENABLE_EVENTS", "IRP_MN_DISABLE_EVENTS", "IRP_MN_ENABLE_COLLECTION", "IRP_MN_DISABLE_COLLECTION", "IRP_MN_REGINFO", "IRP_MN_EXECUTE_METHOD", NULL } Definition at line 1488 of file ioassert.c. Referenced by IopDriverCorrectnessPrintIrpStack().

---