test: ioassert.h File Reference

Main Page | Class Hierarchy | Class List | File List | Class Members | File Members

# ioassert.h File Reference

Go to the source code of this file.

## Classes

struct | _DCPARAM_TYPE_ENTRY
struct | _DCERROR_CLASS
struct | _DC_CHECK_DATA

## Defines

#define | DIAG_INITIALIZED 0x00000001
#define | DIAG_BEEP 0x00000002
#define | DIAG_ZAPPED 0x00000004
#define | DIAG_CLEARED 0x00000008
#define | DIAG_FATAL_ERROR 0x00000010
#define | DIAG_WDM_ERROR 0x00000020
#define | DIAG_IGNORE_DRIVER_LIST 0x00000040
#define | DCPARAM_IRP 0x00000001
#define | DCPARAM_ROUTINE 0x00000008
#define | DCPARAM_DEVOBJ 0x00000040
#define | DCPARAM_STATUS 0x00000200
#define | _DC_ASSERT_OUT(ParenWrappedParamList, Frames)
#define | WDM_CHASTISE_CALLER3(x) _DC_ASSERT_OUT(x, 3)
#define | WDM_CHASTISE_CALLER5(x) _DC_ASSERT_OUT(x, 5)
#define | WDM_FAIL_CALLER(x, depth) _DC_ASSERT_OUT(x, depth)
#define | WDM_FAIL_CALLER1(x) _DC_ASSERT_OUT(x, 1)
#define | WDM_FAIL_CALLER2(x) _DC_ASSERT_OUT(x, 2)
#define | WDM_FAIL_CALLER3(x) _DC_ASSERT_OUT(x, 3)
#define | WDM_FAIL_CALLER4(x) _DC_ASSERT_OUT(x, 4)
#define | WDM_FAIL_CALLER5(x) _DC_ASSERT_OUT(x, 5)
#define | WDM_FAIL_CALLER6(x) _DC_ASSERT_OUT(x, 6)
#define | WDM_FAIL_ROUTINE(x) _DC_ASSERT_OUT(x, -1)
#define | WDM_CHASTISE_ROUTINE(x) _DC_ASSERT_OUT(x, -1)
#define | KDASSERT(x) { if (KdDebuggerEnabled) { ASSERT(x) ; } }
#define | ASSERT_SPINLOCK_HELD(x)

## Typedefs

typedef enum _DCERROR_ID | DCERROR_ID
typedef _DCPARAM_TYPE_ENTRY | DCPARAM_TYPE_ENTRY
typedef _DCPARAM_TYPE_ENTRY * | PDCPARAM_TYPE_ENTRY
typedef _DCERROR_CLASS | DCERROR_CLASS
typedef _DCERROR_CLASS * | PDCERROR_CLASS
typedef const PDCERROR_CLASS | PCDCERROR_CLASS
typedef _DC_CHECK_DATA | DC_CHECK_DATA
typedef _DC_CHECK_DATA * | PDC_CHECK_DATA

## Enumerations

enum

_DCERROR_ID {
DCERROR_UNSPECIFIED = 0x200, DCERROR_DELETE_WHILE_ATTACHED, DCERROR_DETACH_NOT_ATTACHED, DCERROR_CANCELROUTINE_FORWARDED,
DCERROR_NULL_DEVOBJ_FORWARDED, DCERROR_QUEUED_IRP_FORWARDED, DCERROR_NEXTIRPSP_DIRTY, DCERROR_IRPSP_COPIED,
DCERROR_INSUFFICIENT_STACK_LOCATIONS, DCERROR_QUEUED_IRP_COMPLETED, DCERROR_FREE_OF_INUSE_TRACKED_IRP, DCERROR_FREE_OF_INUSE_IRP,
DCERROR_FREE_OF_THREADED_IRP, DCERROR_REINIT_OF_ALLOCATED_IRP_WITH_QUOTA, DCERROR_PNP_IRP_BAD_INITIAL_STATUS, DCERROR_POWER_IRP_BAD_INITIAL_STATUS,
DCERROR_WMI_IRP_BAD_INITIAL_STATUS, DCERROR_SKIPPED_DEVICE_OBJECT, DCERROR_BOGUS_FUNC_TRASHED, DCERROR_BOGUS_STATUS_TRASHED,
DCERROR_BOGUS_INFO_TRASHED, DCERROR_PNP_FAILURE_FORWARDED, DCERROR_PNP_IRP_STATUS_RESET, DCERROR_PNP_IRP_NEEDS_FDO_HANDLING,
DCERROR_PNP_IRP_FDO_HANDS_OFF, DCERROR_POWER_FAILURE_FORWARDED, DCERROR_POWER_IRP_STATUS_RESET, DCERROR_INVALID_STATUS,
DCERROR_UNNECCESSARY_COPY, DCERROR_SHOULDVE_DETACHED, DCERROR_SHOULDVE_DELETED, DCERROR_MISSING_DISPATCH_FUNCTION,
DCERROR_WMI_IRP_NOT_FORWARDED, DCERROR_DELETED_PRESENT_PDO, DCERROR_BUS_FILTER_ERRONEOUSLY_DETACHED, DCERROR_BUS_FILTER_ERRONEOUSLY_DELETED,
DCERROR_INCONSISTANT_STATUS, DCERROR_UNINITIALIZED_STATUS, DCERROR_IRP_RETURNED_WITHOUT_COMPLETION, DCERROR_COMPLETION_ROUTINE_PAGABLE,
DCERROR_PENDING_BIT_NOT_MIGRATED, DCERROR_CANCELROUTINE_ON_FORWARDED_IRP, DCERROR_PNP_IRP_NEEDS_PDO_HANDLING, DCERROR_TARGET_RELATION_LIST_EMPTY,
DCERROR_TARGET_RELATION_NEEDS_REF, DCERROR_BOGUS_PNP_IRP_COMPLETED, DCERROR_SUCCESSFUL_PNP_IRP_NOT_FORWARDED, DCERROR_UNTOUCHED_PNP_IRP_NOT_FORWARDED,
DCERROR_BOGUS_POWER_IRP_COMPLETED, DCERROR_SUCCESSFUL_POWER_IRP_NOT_FORWARDED, DCERROR_UNTOUCHED_POWER_IRP_NOT_FORWARDED, DCERROR_PNP_QUERY_CAP_BAD_VERSION,
DCERROR_PNP_QUERY_CAP_BAD_SIZE, DCERROR_PNP_QUERY_CAP_BAD_ADDRESS, DCERROR_PNP_QUERY_CAP_BAD_UI_NUM, DCERROR_RESTRICTED_IRP,
DCERROR_REINIT_OF_ALLOCATED_IRP_WITHOUT_QUOTA, DCERROR_UNFORWARDED_IRP_COMPLETED, DCERROR_DISPATCH_CALLED_AT_BAD_IRQL, DCERROR_BOGUS_MINOR_STATUS_TRASHED,
DCERROR_MAXIMUM
}

## Functions

VOID | IopDriverCorrectnessTakeLock (IN PULONG ControlNew, IN LONG StackFramesToSkip)
NTSTATUS | IopDriverCorrectnessCheckUnderLock (IN DCERROR_ID MessageIndex, IN ULONG MessageParameterMask,...)
VOID | IopDriverCorrectnessReleaseLock (VOID)
NTSTATUS | IopDriverCorrectnessProcessMessageText (IN ULONG MaxOutputBufferSize, OUT PSTR OutputBuffer, IN OUT PDC_CHECK_DATA DcCheckData)
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)
VOID | IopDriverCorrectnessThrowBugCheck (IN PDC_CHECK_DATA DcCheckData)
VOID | IopDriverCorrectnessPrintBuffer (IN PDC_CHECK_DATA DcCheckData)
VOID | IopDriverCorrectnessPrintParamData (IN PDC_CHECK_DATA DcCheckData)
VOID | IopDriverCorrectnessPrintIrp (IN PIRP IrpToFlag)
VOID | IopDriverCorrectnessPrintIrpStack (IN PIO_STACK_LOCATION IrpSp)
VOID | IopDriverCorrectnessPrompt (IN PDC_CHECK_DATA DcCheckData, OUT PBOOLEAN ExitAssertion)
PVOID | IopDriverCorrectnessAddressToFileHeader (IN PVOID PcValue, OUT PLDR_DATA_TABLE_ENTRY *DataTableEntry)
BOOLEAN | IopIsMemoryRangeReadable (IN PVOID Location, IN size_t Length)

## Variables

LONG | IovpInitCalled
ULONG | IovpVerifierLevel
ULONG | IovpEnforcementLevel
ULONG | IopDcControlInitial
ULONG | IopDcControlOverride
KSPIN_LOCK | IopDcControlLock

## Define Documentation

#define _DC_ASSERT_OUT | ( | ParenWrappedParamList,
|  | Frames |  | ) |

Value:

    { \
        static ULONG Flags=0 ; \
        if (IovpInitCalled) { \
            IopDriverCorrectnessTakeLock(&Flags, Frames) ;\
            IopDriverCorrectnessCheckUnderLock##ParenWrappedParamList;\
            IopDriverCorrectnessReleaseLock() ;\
        } \
    }

Definition at line 135 of file ioassert.h.

#define ASSERT_SPINLOCK_HELD | ( | x |  | ) |

| Definition at line 165 of file ioassert.h. Referenced by IovpSessionDataAttachSurrogate(), IovpSessionDataClose(), IovpSessionDataDereference(), IovpSessionDataReference(), IovpTrackingDataDereference(), IovpTrackingDataFindPointer(), IovpTrackingDataGetCurrentSessionData(), IovpTrackingDataReference(), and IovpTrackingDataReleaseLock().

#define DCPARAM_DEVOBJ 0x00000040

| Definition at line 132 of file ioassert.h. Referenced by IovpAssertIrpStackUpward(), IovpCallDriver2(), and IovpDetachDevice().

#define DCPARAM_IRP 0x00000001

| Definition at line 130 of file ioassert.h. Referenced by IovpAssertIrpStackDownward(), IovpAssertIrpStackUpward(), IovpAssertNewRequest(), IovpCallDriver1(), IovpCallDriver2(), IovpCancelIrp(), IovpCompleteRequest1(), IovpCompleteRequest3(), IovpCompleteRequest4(), IovpExamineIrpStackForwarding(), IovpFreeIrp(), IovpInitializeIrp(), and IovpInternalDeferredCompletion().

#define DCPARAM_ROUTINE 0x00000008

| Definition at line 131 of file ioassert.h. Referenced by IovpAssertIrpStackDownward(), IovpAssertIrpStackUpward(), IovpCallDriver2(), IovpCancelIrp(), IovpCompleteRequest3(), IovpCompleteRequest4(), and IovpInternalDeferredCompletion().

#define DCPARAM_STATUS 0x00000200

| Definition at line 133 of file ioassert.h. Referenced by IovpCallDriver2().

#define DIAG_BEEP 0x00000002

| Definition at line 123 of file ioassert.h. Referenced by IopDriverCorrectnessPrompt().

#define DIAG_CLEARED 0x00000008

| Definition at line 125 of file ioassert.h. Referenced by IopDriverCorrectnessApplyControl(), and IopDriverCorrectnessPrompt().

#define DIAG_FATAL_ERROR 0x00000010

| Definition at line 126 of file ioassert.h. Referenced by IopDriverCorrectnessApplyControl(), IopDriverCorrectnessPrintBuffer(), and IopDriverCorrectnessThrowBugCheck().

#define DIAG_IGNORE_DRIVER_LIST 0x00000040

| Definition at line 128 of file ioassert.h. Referenced by IopDriverCorrectnessApplyControl(), and IoVerifierInit().

#define DIAG_INITIALIZED 0x00000001

| Definition at line 122 of file ioassert.h. Referenced by IopDriverCorrectnessApplyControl().

#define DIAG_WDM_ERROR 0x00000020

| Definition at line 127 of file ioassert.h.

#define DIAG_ZAPPED 0x00000004

| Definition at line 124 of file ioassert.h. Referenced by IopDriverCorrectnessPrompt().

#define KDASSERT | ( | x |  | ) | { if (KdDebuggerEnabled) { ASSERT(x) ; } }

| Definition at line 163 of file ioassert.h. Referenced by IovpInternalDeferredCompletion().

#define WDM_CHASTISE_CALLER3 | ( | x |  | ) | _DC_ASSERT_OUT(x, 3)

| Definition at line 151 of file ioassert.h. Referenced by IovpCompleteRequest1(), and IovpExamineIrpStackForwarding().

#define WDM_CHASTISE_CALLER5 | ( | x |  | ) | _DC_ASSERT_OUT(x, 5)

| Definition at line 152 of file ioassert.h. Referenced by IovpExamineIrpStackForwarding().

#define WDM_CHASTISE_ROUTINE | ( | x |  | ) | _DC_ASSERT_OUT(x, -1)

| Definition at line 161 of file ioassert.h.

#define WDM_FAIL_CALLER | ( | x,
|  | depth |  | ) | _DC_ASSERT_OUT(x, depth)

| Definition at line 153 of file ioassert.h.

#define WDM_FAIL_CALLER1 | ( | x |  | ) | _DC_ASSERT_OUT(x, 1)

| Definition at line 154 of file ioassert.h. Referenced by IovpDeleteDevice().

#define WDM_FAIL_CALLER2 | ( | x |  | ) | _DC_ASSERT_OUT(x, 2)

| Definition at line 155 of file ioassert.h. Referenced by IovpDetachDevice(), IovpFreeIrp(), and IovpInitializeIrp().

#define WDM_FAIL_CALLER3 | ( | x |  | ) | _DC_ASSERT_OUT(x, 3)

| Definition at line 156 of file ioassert.h. Referenced by IovpCompleteRequest1().

#define WDM_FAIL_CALLER4 | ( | x |  | ) | _DC_ASSERT_OUT(x, 4)

| Definition at line 157 of file ioassert.h. Referenced by IovpAssertIrpStackDownward(), and IovpAssertNewRequest().

#define WDM_FAIL_CALLER5 | ( | x |  | ) | _DC_ASSERT_OUT(x, 5)

| Definition at line 158 of file ioassert.h.

#define WDM_FAIL_CALLER6 | ( | x |  | ) | _DC_ASSERT_OUT(x, 6)

| Definition at line 159 of file ioassert.h. Referenced by IovpAssertIrpStackDownward(), and IovpAssertNewRequest().

#define WDM_FAIL_ROUTINE | ( | x |  | ) | _DC_ASSERT_OUT(x, -1)

| Definition at line 160 of file ioassert.h. Referenced by IovpAssertIrpStackDownward(), IovpAssertIrpStackUpward(), IovpCallDriver2(), IovpCancelIrp(), IovpCompleteRequest3(), IovpCompleteRequest4(), and IovpInternalDeferredCompletion().

## Typedef Documentation

typedef struct _DC_CHECK_DATA DC_CHECK_DATA

| Referenced by IopDriverCorrectnessCheckUnderLock().

typedef struct _DCERROR_CLASS DCERROR_CLASS

typedef enum _DCERROR_ID DCERROR_ID

| Referenced by IopDriverCorrectnessCheckUnderLock().

typedef struct _DCPARAM_TYPE_ENTRY DCPARAM_TYPE_ENTRY

typedef const PDCERROR_CLASS PCDCERROR_CLASS

| Definition at line 208 of file ioassert.h.

typedef struct _DC_CHECK_DATA * PDC_CHECK_DATA

| Referenced by IopDriverCorrectnessProcessParams().

typedef struct _DCERROR_CLASS * PDCERROR_CLASS

typedef struct _DCPARAM_TYPE_ENTRY * PDCPARAM_TYPE_ENTRY

## Enumeration Type Documentation

enum _DCERROR_ID

Enumeration values:

  DCERROR_UNSPECIFIED |
  DCERROR_DELETE_WHILE_ATTACHED |
  DCERROR_DETACH_NOT_ATTACHED |
  DCERROR_CANCELROUTINE_FORWARDED |
  DCERROR_NULL_DEVOBJ_FORWARDED |
  DCERROR_QUEUED_IRP_FORWARDED |
  DCERROR_NEXTIRPSP_DIRTY |
  DCERROR_IRPSP_COPIED |
  DCERROR_INSUFFICIENT_STACK_LOCATIONS |
  DCERROR_QUEUED_IRP_COMPLETED |
  DCERROR_FREE_OF_INUSE_TRACKED_IRP |
  DCERROR_FREE_OF_INUSE_IRP |
  DCERROR_FREE_OF_THREADED_IRP |
  DCERROR_REINIT_OF_ALLOCATED_IRP_WITH_QUOTA |
  DCERROR_PNP_IRP_BAD_INITIAL_STATUS |
  DCERROR_POWER_IRP_BAD_INITIAL_STATUS |
  DCERROR_WMI_IRP_BAD_INITIAL_STATUS |
  DCERROR_SKIPPED_DEVICE_OBJECT |
  DCERROR_BOGUS_FUNC_TRASHED |
  DCERROR_BOGUS_STATUS_TRASHED |
  DCERROR_BOGUS_INFO_TRASHED |
  DCERROR_PNP_FAILURE_FORWARDED |
  DCERROR_PNP_IRP_STATUS_RESET |
  DCERROR_PNP_IRP_NEEDS_FDO_HANDLING |
  DCERROR_PNP_IRP_FDO_HANDS_OFF |
  DCERROR_POWER_FAILURE_FORWARDED |
  DCERROR_POWER_IRP_STATUS_RESET |
  DCERROR_INVALID_STATUS |
  DCERROR_UNNECCESSARY_COPY |
  DCERROR_SHOULDVE_DETACHED |
  DCERROR_SHOULDVE_DELETED |
  DCERROR_MISSING_DISPATCH_FUNCTION |
  DCERROR_WMI_IRP_NOT_FORWARDED |
  DCERROR_DELETED_PRESENT_PDO |
  DCERROR_BUS_FILTER_ERRONEOUSLY_DETACHED |
  DCERROR_BUS_FILTER_ERRONEOUSLY_DELETED |
  DCERROR_INCONSISTANT_STATUS |
  DCERROR_UNINITIALIZED_STATUS |
  DCERROR_IRP_RETURNED_WITHOUT_COMPLETION |
  DCERROR_COMPLETION_ROUTINE_PAGABLE |
  DCERROR_PENDING_BIT_NOT_MIGRATED |
  DCERROR_CANCELROUTINE_ON_FORWARDED_IRP |
  DCERROR_PNP_IRP_NEEDS_PDO_HANDLING |
  DCERROR_TARGET_RELATION_LIST_EMPTY |
  DCERROR_TARGET_RELATION_NEEDS_REF |
  DCERROR_BOGUS_PNP_IRP_COMPLETED |
  DCERROR_SUCCESSFUL_PNP_IRP_NOT_FORWARDED |
  DCERROR_UNTOUCHED_PNP_IRP_NOT_FORWARDED |
  DCERROR_BOGUS_POWER_IRP_COMPLETED |
  DCERROR_SUCCESSFUL_POWER_IRP_NOT_FORWARDED |
  DCERROR_UNTOUCHED_POWER_IRP_NOT_FORWARDED |
  DCERROR_PNP_QUERY_CAP_BAD_VERSION |
  DCERROR_PNP_QUERY_CAP_BAD_SIZE |
  DCERROR_PNP_QUERY_CAP_BAD_ADDRESS |
  DCERROR_PNP_QUERY_CAP_BAD_UI_NUM |
  DCERROR_RESTRICTED_IRP |
  DCERROR_REINIT_OF_ALLOCATED_IRP_WITHOUT_QUOTA |
  DCERROR_UNFORWARDED_IRP_COMPLETED |
  DCERROR_DISPATCH_CALLED_AT_BAD_IRQL |
  DCERROR_BOGUS_MINOR_STATUS_TRASHED |
  DCERROR_MAXIMUM |

Definition at line 56 of file ioassert.h.

    00056                          {
    00057
    00058     DCERROR_UNSPECIFIED = 0x200,
    00059     DCERROR_DELETE_WHILE_ATTACHED,
    00060     DCERROR_DETACH_NOT_ATTACHED,
    00061     DCERROR_CANCELROUTINE_FORWARDED,
    00062     DCERROR_NULL_DEVOBJ_FORWARDED,
    00063     DCERROR_QUEUED_IRP_FORWARDED,
    00064     DCERROR_NEXTIRPSP_DIRTY,
    00065     DCERROR_IRPSP_COPIED,
    00066     DCERROR_INSUFFICIENT_STACK_LOCATIONS,
    00067     DCERROR_QUEUED_IRP_COMPLETED,
    00068     DCERROR_FREE_OF_INUSE_TRACKED_IRP,
    00069     DCERROR_FREE_OF_INUSE_IRP,
    00070     DCERROR_FREE_OF_THREADED_IRP,
    00071     DCERROR_REINIT_OF_ALLOCATED_IRP_WITH_QUOTA,
    00072     DCERROR_PNP_IRP_BAD_INITIAL_STATUS,
    00073     DCERROR_POWER_IRP_BAD_INITIAL_STATUS,
    00074     DCERROR_WMI_IRP_BAD_INITIAL_STATUS,
    00075     DCERROR_SKIPPED_DEVICE_OBJECT,
    00076     DCERROR_BOGUS_FUNC_TRASHED,
    00077     DCERROR_BOGUS_STATUS_TRASHED,
    00078     DCERROR_BOGUS_INFO_TRASHED,
    00079     DCERROR_PNP_FAILURE_FORWARDED,
    00080     DCERROR_PNP_IRP_STATUS_RESET,
    00081     DCERROR_PNP_IRP_NEEDS_FDO_HANDLING,
    00082     DCERROR_PNP_IRP_FDO_HANDS_OFF,
    00083     DCERROR_POWER_FAILURE_FORWARDED,
    00084     DCERROR_POWER_IRP_STATUS_RESET,
    00085     DCERROR_INVALID_STATUS,
    00086     DCERROR_UNNECCESSARY_COPY,
    00087     DCERROR_SHOULDVE_DETACHED,
    00088     DCERROR_SHOULDVE_DELETED,
    00089     DCERROR_MISSING_DISPATCH_FUNCTION,
    00090     DCERROR_WMI_IRP_NOT_FORWARDED,
    00091     DCERROR_DELETED_PRESENT_PDO,
    00092     DCERROR_BUS_FILTER_ERRONEOUSLY_DETACHED,
    00093     DCERROR_BUS_FILTER_ERRONEOUSLY_DELETED,
    00094     DCERROR_INCONSISTANT_STATUS,
    00095     DCERROR_UNINITIALIZED_STATUS,
    00096     DCERROR_IRP_RETURNED_WITHOUT_COMPLETION,
    00097     DCERROR_COMPLETION_ROUTINE_PAGABLE,
    00098     DCERROR_PENDING_BIT_NOT_MIGRATED,
    00099     DCERROR_CANCELROUTINE_ON_FORWARDED_IRP,
    00100     DCERROR_PNP_IRP_NEEDS_PDO_HANDLING,
    00101     DCERROR_TARGET_RELATION_LIST_EMPTY,
    00102     DCERROR_TARGET_RELATION_NEEDS_REF,
    00103     DCERROR_BOGUS_PNP_IRP_COMPLETED,
    00104     DCERROR_SUCCESSFUL_PNP_IRP_NOT_FORWARDED,
    00105     DCERROR_UNTOUCHED_PNP_IRP_NOT_FORWARDED,
    00106     DCERROR_BOGUS_POWER_IRP_COMPLETED,
    00107     DCERROR_SUCCESSFUL_POWER_IRP_NOT_FORWARDED,
    00108     DCERROR_UNTOUCHED_POWER_IRP_NOT_FORWARDED,
    00109     DCERROR_PNP_QUERY_CAP_BAD_VERSION,
    00110     DCERROR_PNP_QUERY_CAP_BAD_SIZE,
    00111     DCERROR_PNP_QUERY_CAP_BAD_ADDRESS,
    00112     DCERROR_PNP_QUERY_CAP_BAD_UI_NUM,
    00113     DCERROR_RESTRICTED_IRP,
    00114     DCERROR_REINIT_OF_ALLOCATED_IRP_WITHOUT_QUOTA,
    00115     DCERROR_UNFORWARDED_IRP_COMPLETED,
    00116     DCERROR_DISPATCH_CALLED_AT_BAD_IRQL,
    00117     DCERROR_BOGUS_MINOR_STATUS_TRASHED,
    00118     DCERROR_MAXIMUM
    00119
    00120 } DCERROR_ID ;

## Function Documentation

PVOID IopDriverCorrectnessAddressToFileHeader | ( | IN PVOID | PcValue,
|  | OUT PLDR_DATA_TABLE_ENTRY * | DataTableEntry
| ) |

Definition at line 1254 of file ioassert.c.

References NULL, and PsLoadedModuleList.

Referenced by IopDriverCorrectnessProcessParams().

    01261                    :
    01262
    01263     This function returns the base of an image that contains the
    01264     specified Address. An image contains the address if the address
    01265     is within the ImageBase, and the ImageBase plus the size of the
    01266     virtual image.
    01267
    01268 Arguments:
    01269
    01270     Address - Supplies an address to resolve to a loader entry.
    01271
    01272     DataTableEntry - Suppies a pointer to a variable that receives the
    01273         address of the data table entry that describes the image.
    01274
    01275 Return Value:
    01276
    01277     NULL - No image was found that contains the passed in address.
    01278
    01279     NON-NULL - Returns the base address of the image that contain the
    01280         address.
    01281
    01282 --*/
    01283
    01284 {
    01285
    01286     PLIST_ENTRY ModuleListHead;
    01287     PLDR_DATA_TABLE_ENTRY Entry;
    01288     PLIST_ENTRY Next;
    01289     UINT_PTR Bounds;
    01290     PVOID ReturnBase=NULL, Base;
    01291
    01292     ModuleListHead = &PsLoadedModuleList;
    01293
    01294     //
    01295     // It would be nice if we could call MiLookupDataTableEntry, but it's
    01296     // pageable, so we do what the bugcheck stuff does...
    01297     //
    01298     Next = ModuleListHead->Flink;
    01299     if (Next != NULL) {
    01300         while (Next != ModuleListHead) {
    01301             Entry = CONTAINING_RECORD(Next,
    01302                                       LDR_DATA_TABLE_ENTRY,
    01303                                       InLoadOrderLinks);
    01304
    01305             Next = Next->Flink;
    01306             Base = Entry->DllBase;
    01307             Bounds = (UINT_PTR)Base + Entry->SizeOfImage;
    01308             if ((UINT_PTR)Address >= (UINT_PTR)Base && (UINT_PTR)Address < Bounds) {
    01309                 *DataTableEntry = Entry;
    01310                 ReturnBase = Base;
    01311                 break;
    01312             }
    01313         }
    01314     }
    01315
    01316     return ReturnBase;
    01317 }

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().

    00779 {
    00780     ULONG assertionControl;
    00781
    00782     if (IopDcControlOverride) {
    00783
    00784         assertionControl = IopDcControlOverride;
    00785
    00786     } else if (DcCheckData->Control) {
    00787
    00788         //
    00789         // Initialize the control if appropo
    00790         //
    00791         if (!((*DcCheckData->Control)&DIAG_INITIALIZED)) {
    00792
    00793             *DcCheckData->Control |= (
    00794                 DIAG_INITIALIZED | IopDcControlInitial |
    00795                 DcCheckData->AssertionClass->ClassFlags );
    00796         }
    00797
    00798         assertionControl = *DcCheckData->Control;
    00799
    00800     } else {
    00801
    00802         assertionControl =
    00803             ( IopDcControlInitial | DcCheckData->AssertionClass->ClassFlags );
    00804     }
    00805
    00806     if (assertionControl&DIAG_CLEARED) {
    00807
    00808         //
    00809         // If the breakpoint was cleared, then return, print/rip not.
    00810         //
    00811         return FALSE;
    00812     }
    00813
    00814     if ((!(assertionControl&DIAG_IGNORE_DRIVER_LIST)) &&
    00815         (!DcCheckData->InVerifierList)) {
    00816
    00817         //
    00818         // Not of interest, skip this one.
    00819         //
    00820         return FALSE;
    00821     }
    00822
    00823     //
    00824     // If there is no debugger, don't halt the machine. We are probably
    00825     // ripping like mad and the user just wants to be able to boot.
    00826     // The one exception is if DIAG_FATAL_ERROR is set. Then we shall
    00827     // invoke the driver bugcheck...
    00828     //
    00829     if ((!KdDebuggerEnabled) && (!(assertionControl&DIAG_FATAL_ERROR))) {
    00830
    00831         return FALSE;
    00832     }
    00833
    00834     //
    00835     // Record our intentions and continue.
    00836     //
    00837     DcCheckData->AssertionControl = assertionControl;
    00838     return TRUE;
    00839 }

NTSTATUS IopDriverCorrectnessCheckUnderLock | ( | IN DCERROR_ID | MessageIndex,
|  | 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().

    00470               :
    00471
    00472       This routine displays an assert and provides options for
    00473       removing the breakpoint, changing to just a text-out, etc.
    00474
    00475     This routine is used as part of a macro for providing "Zappable" traps -
    00476     IE, users get the option of changing how a specific instance of
    00477     WDM_DEBUG_OUT in the code is handled (default is spew and break, options
    00478     are spew or blow away for this boot).
    00479
    00480     Macro must call IopDiagSetAssertLock, IopDiagAssertPrintfUnderLock, and
    00481     IopDiagReleaseAssertLock in order
    00482
    00483     DCPARAM_IRP*(count)+DCPARAM_ROUTINE*(count)+DCPARAM_DEVOBJ*(count),
    00484         irp1,
    00485         irp2,
    00486         irp3,
    00487         routine1,
    00488         ..,
    00489         ..,
    00490         devobj1,
    00491
    00492     count can be a max of 3.
    00493
    00494
    00495    Arguments:
    00496
    00497       Control - if present, this variable determines whether we will
    00498                  actually do anything.
    00499
    00500                 if DIAG_ZAPPED is set we will print the assert text and return.
    00501                 if DIAG_CLEARED is set, we will neither print or stop.
    00502                 if DIAG_BEEP is set, we will beep if not zapped.
    00503
    00504       StackFramesToSkip - If this parameter is -1, it is not used.
    00505                           Otherwise, the assertion code will attempt to walk
    00506                           back the appropriate number of frames and
    00507                           determine the caller to blame based on return
    00508                           address.
    00509
    00510       IrpToFlag      - IRP to print out failure data for if mishandling of
    00511                        this IRP was the source of the error.
    00512
    00513       AddressToFlag  - Address that the assert should be blaimed on. This
    00514                        should be null if StackFramesToSkip is not -1.
    00515
    00516       AssertionClass - Text describing the overall class of the assert
    00517
    00518       AssertionText  - Text specifically describing the assert. Carriage
    00519                        returns should not be embedded in the text, this
    00520                        routine will automatically ensure words are not split
    00521                        across the screen.
    00522
    00523    Notes:
    00524
    00525       The text will automagically be formatted and printed as such:
    00526
    00527       ASSERTION CLASS: ASSERTION TEXT ASSERTION TEXT ASSERTION
    00528                        TEXT ASSERTION TEXT ...
    00529
    00530 --*/
    00531
    00532 {
    00533     va_list arglist;
    00534     UCHAR finalBuffer[512];
    00535     NTSTATUS status;
    00536     DC_CHECK_DATA dcCheckData;
    00537     PVOID dcParamArray[3*sizeof(DcParamTable)/sizeof(DCPARAM_TYPE_ENTRY)];
    00538     BOOLEAN exitAssertion;
    00539
    00540     va_start(arglist, MessageParameterMask);
    00541
    00542     //
    00543     // Determine what our basic policy towards this check will be and fill out
    00544     // the dcCheckData structure as well as we can.
    00545     //
    00546     IopDriverCorrectnessProcessParams(
    00547         IopDcControlCurrent,
    00548         IopDcCurrentFrameSkips,
    00549         MessageID,
    00550         MessageParameterMask,
    00551         &arglist,
    00552         dcParamArray,
    00553         &dcCheckData
    00554         );
    00555
    00556     va_end(arglist);
    00557
    00558     if (!IopDriverCorrectnessApplyControl(&dcCheckData)) {
    00559
    00560         //
    00561         // Nothing to see here, just ignore the assert...
    00562         //
    00563         return STATUS_SUCCESS;
    00564     }
    00565
    00566     //
    00567     // We are going to express our disatifaction somehow. Expand out the
    00568     // message we've prepared for this scenario.
    00569     //
    00570     status = IopDriverCorrectnessProcessMessageText(
    00571         sizeof(finalBuffer),
    00572         finalBuffer,
    00573         &dcCheckData
    00574         );
    00575
    00576     if (!NT_SUCCESS(status)) {
    00577
    00578         ASSERT(0);
    00579
    00580         //
    00581         // Something went wrong with the index lookup!
    00582         //
    00583         return status;
    00584     }
    00585
    00586     do {
    00587
    00588         IopDriverCorrectnessPrintBuffer(&dcCheckData);
    00589         IopDriverCorrectnessPrintParamData(&dcCheckData);
    00590         IopDriverCorrectnessThrowBugCheck(&dcCheckData);
    00591         IopDriverCorrectnessPrompt(&dcCheckData, &exitAssertion);
    00592
    00593     } while (!exitAssertion);
    00594
    00595     return status;
    00596 }

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().

    01019 {
    01020     UCHAR buffer[82];
    01021     UCHAR classBuf[81];
    01022     UCHAR callerBuf[81+40];
    01023     UCHAR ansiDriverName[81];
    01024     LONG  lMargin, i, lMarginCur, rMargin=78;
    01025     PSTR lineStart, lastWord, current, lMarginText;
    01026
    01027     //
    01028     // Put down a carraige return
    01029     //
    01030     DbgPrint("\n") ;
    01031
    01032     //
    01033     // Drop a banner if this is a fatal assert.
    01034     //
    01035     if (DcCheckData->AssertionControl&DIAG_FATAL_ERROR) {
    01036
    01037         DbgPrint(
    01038             "***********************************************************************\n"
    01039             "* THIS DRIVER BUG IS FATAL AND WILL CAUSE THE VERIFIER TO HALT        *\n"
    01040             "* WINDOWS (BUGCHECK) WHEN THE MACHINE IS NOT UNDER A KERNEL DEBUGGER! *\n"
    01041             "***********************************************************************\n"
    01042             "\n"
    01043             );
    01044     }
    01045
    01046     //
    01047     // Prepare left margin (ClassText)
    01048     //
    01049     if (DcCheckData->ClassText != NULL) {
    01050
    01051         lMargin = strlen(DcCheckData->ClassText)+2;
    01052
    01053         DbgPrint("%s: ", DcCheckData->ClassText);
    01054
    01055     } else {
    01056
    01057         lMargin = 0;
    01058     }
    01059
    01060     if (lMargin+1>=rMargin) {
    01061
    01062         lMargin=0;
    01063     }
    01064
    01065     for(i=0; i<lMargin; i++) classBuf[i] = ' ';
    01066     classBuf[lMargin] = '\0';
    01067     lMarginText = classBuf+lMargin;
    01068     lMarginCur = lMargin;
    01069
    01070     lineStart = lastWord = current = DcCheckData->AssertionText;
    01071
    01072     //
    01073     // Print out culprit if we have him...
    01074     //
    01075     if (DcCheckData->CulpritAddress) {
    01076
    01077         if (DcCheckData->DriverName.Length) {
    01078
    01079             KeBugCheckUnicodeToAnsi(
    01080                 &DcCheckData->DriverName,
    01081                 ansiDriverName,
    01082                 sizeof(ansiDriverName)
    01083                 );
    01084
    01085             sprintf(callerBuf, "[%s @ 0x%p] ",
    01086                 ansiDriverName,
    01087                 DcCheckData->CulpritAddress
    01088                 );
    01089
    01090         } else {
    01091
    01092             sprintf(callerBuf, "[0x%p] ", DcCheckData->CulpritAddress);
    01093         }
    01094
    01095         DbgPrint("%s", callerBuf);
    01096         lMarginCur += strlen(callerBuf);
    01097     }
    01098
    01099     //
    01100     // Format and print our assertion text
    01101     //
    01102     while(*current) {
    01103
    01104         if (*current == ' ') {
    01105
    01106             if ((current - lineStart) >= (rMargin-lMarginCur-1)) {
    01107
    01108                 DbgPrint("%s", lMarginText);
    01109                 lMarginText = classBuf;
    01110                 lMarginCur = lMargin;
    01111
    01112                 if ((lastWord-lineStart)<rMargin) {
    01113
    01114                     memcpy(buffer, lineStart, (ULONG)(lastWord-lineStart)*sizeof(UCHAR));
    01115                     buffer[lastWord-lineStart] = '\0';
    01116                     DbgPrint("%s\n", buffer);
    01117
    01118                 }
    01119
    01120                 lineStart = lastWord+1;
    01121             }
    01122
    01123             lastWord = current;
    01124         }
    01125
    01126         current++;
    01127     }
    01128
    01129     if ((current - lineStart) >= (rMargin-lMarginCur-1)) {
    01130
    01131         DbgPrint("%s", lMarginText);
    01132         lMarginText = classBuf;
    01133
    01134         if ((lastWord-lineStart)<rMargin) {
    01135
    01136             memcpy(buffer, lineStart, (ULONG)(lastWord-lineStart)*sizeof(UCHAR));
    01137             buffer[lastWord-lineStart] = '\0';
    01138             DbgPrint("%s\n", buffer);
    01139         }
    01140
    01141         lineStart = lastWord+1;
    01142     }
    01143
    01144     if (lineStart<current) {
    01145
    01146         DbgPrint("%s%s\n", lMarginText, lineStart);
    01147     }
    01148 }

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().

    01373 {
    01374     PIO_STACK_LOCATION irpSpCur ;
    01375     PIO_STACK_LOCATION irpSpNxt ;
    01376
    01377     //
    01378     // First see if we can touch the IRP header
    01379     //
    01380     if(!IopIsMemoryRangeReadable(IrpToFlag, sizeof(IRP))) {
    01381         return ;
    01382     }
    01383
    01384     //
    01385     // OK, get the next two stack locations...
    01386     //
    01387     irpSpNxt = IoGetNextIrpStackLocation( IrpToFlag );
    01388     irpSpCur = IoGetCurrentIrpStackLocation( IrpToFlag );
    01389
    01390     if (IopIsMemoryRangeReadable(irpSpNxt, 2*sizeof(IO_STACK_LOCATION))) {
    01391
    01392         //
    01393         // Both are present, print the best one!
    01394         //
    01395         if (irpSpNxt->MinorFunction == irpSpCur->MinorFunction) {
    01396
    01397             //
    01398             // Looks forwarded
    01399             //
    01400             IopDriverCorrectnessPrintIrpStack(irpSpNxt) ;
    01401         } else if (irpSpNxt->MinorFunction == 0) {
    01402
    01403             //
    01404             // Next location is probably currently zero'd
    01405             //
    01406             IopDriverCorrectnessPrintIrpStack(irpSpCur) ;
    01407         } else {
    01408             DbgPrint("Next:    >") ;
    01409             IopDriverCorrectnessPrintIrpStack(irpSpNxt) ;
    01410             DbgPrint("Current:  ") ;
    01411             IopDriverCorrectnessPrintIrpStack(irpSpCur) ;
    01412         }
    01413     } else if (IopIsMemoryRangeReadable(irpSpCur, sizeof(IO_STACK_LOCATION))) {
    01414
    01415         IopDriverCorrectnessPrintIrpStack(irpSpCur) ;
    01416     } else if (IopIsMemoryRangeReadable(irpSpNxt, sizeof(IO_STACK_LOCATION))) {
    01417
    01418         IopDriverCorrectnessPrintIrpStack(irpSpNxt) ;
    01419     }
    01420 }

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().

    01519 {
    01520     if ((IrpSp->MajorFunction==IRP_MJ_INTERNAL_DEVICE_CONTROL)&&(IrpSp->MinorFunction == IRP_MN_SCSI_CLASS)) {
    01521
    01522          DbgPrint("IRP_MJ_SCSI") ;
    01523
    01524     } else if (IrpSp->MajorFunction<=MAX_NAMED_MAJOR_IRPS) {
    01525
    01526          DbgPrint(IrpMajorNames[IrpSp->MajorFunction]) ;
    01527
    01528     } else if (IrpSp->MajorFunction==0xFF) {
    01529
    01530          DbgPrint("IRP_MJ_BOGUS") ;
    01531
    01532     } else {
    01533
    01534          DbgPrint("IRP_MJ_??") ;
    01535     }
    01536
    01537     switch(IrpSp->MajorFunction) {
    01538
    01539          case IRP_MJ_SYSTEM_CONTROL:
    01540              DbgPrint(".") ;
    01541              if (IrpSp->MinorFunction<=MAX_NAMED_WMI_IRP) {
    01542
    01543                  DbgPrint(WmiIrpNames[IrpSp->MinorFunction]) ;
    01544              } else if (IrpSp->MinorFunction==0xFF) {
    01545
    01546                  DbgPrint("IRP_MN_BOGUS") ;
    01547              } else {
    01548                  DbgPrint("(Bogus)\n") ;
    01549              }
    01550              DbgPrint("\n") ;
    01551              break ;
    01552          case IRP_MJ_PNP:
    01553              DbgPrint(".") ;
    01554              if (IrpSp->MinorFunction<=MAX_NAMED_PNP_IRP) {
    01555
    01556                  DbgPrint(PnPIrpNames[IrpSp->MinorFunction]) ;
    01557              } else if (IrpSp->MinorFunction==0xFF) {
    01558
    01559                  DbgPrint("IRP_MN_BOGUS") ;
    01560              } else {
    01561
    01562                  DbgPrint("(Bogus)\n") ;
    01563              }
    01564              switch(IrpSp->MinorFunction) {
    01565                  case IRP_MN_QUERY_DEVICE_RELATIONS:
    01566
    01567                      switch(IrpSp->Parameters.QueryDeviceRelations.Type) {
    01568                          case BusRelations:
    01569                              DbgPrint("(BusRelations)") ;
    01570                              break ;
    01571                          case EjectionRelations:
    01572                              DbgPrint("(EjectionRelations)") ;
    01573                              break ;
    01574                          case PowerRelations:
    01575                              DbgPrint("(PowerRelations)") ;
    01576                              break ;
    01577                          case RemovalRelations:
    01578                              DbgPrint("(RemovalRelations)") ;
    01579                              break ;
    01580                          case TargetDeviceRelation:
    01581                              DbgPrint("(TargetDeviceRelation)") ;
    01582                              break ;
    01583                          default:
    01584                              DbgPrint("(Bogus)\n") ;
    01585                              break ;
    01586                      }
    01587                      break ;
    01588                  case IRP_MN_QUERY_INTERFACE:
    01589                      break ;
    01590                  case IRP_MN_QUERY_DEVICE_TEXT:
    01591                      switch(IrpSp->Parameters.QueryId.IdType) {
    01592                          case DeviceTextDescription:
    01593                              DbgPrint("(DeviceTextDescription)") ;
    01594                              break ;
    01595                          case DeviceTextLocationInformation:
    01596                              DbgPrint("(DeviceTextLocationInformation)") ;
    01597                              break ;
    01598                          default:
    01599                              DbgPrint("(Bogus)\n") ;
    01600                              break ;
    01601                      }
    01602                      break ;
    01603                  case IRP_MN_WRITE_CONFIG:
    01604                  case IRP_MN_READ_CONFIG:
    01605                      DbgPrint("(WhichSpace=%x, Buffer=%x, Offset=%x, Length=%x)",
    01606                          IrpSp->Parameters.ReadWriteConfig.WhichSpace,
    01607                          IrpSp->Parameters.ReadWriteConfig.Buffer,
    01608                          IrpSp->Parameters.ReadWriteConfig.Offset,
    01609                          IrpSp->Parameters.ReadWriteConfig.Length
    01610                          ) ;
    01611                      break ;
    01612                  case IRP_MN_SET_LOCK:
    01613                      if (IrpSp->Parameters.SetLock.Lock) DbgPrint("(True)") ;
    01614                      else DbgPrint("(False)") ;
    01615                      break ;
    01616                  case IRP_MN_QUERY_ID:
    01617                      switch(IrpSp->Parameters.QueryId.IdType) {
    01618                          case BusQueryDeviceID:
    01619                              DbgPrint("(BusQueryDeviceID)") ;
    01620                              break ;
    01621                          case BusQueryHardwareIDs:
    01622                              DbgPrint("(BusQueryHardwareIDs)") ;
    01623                              break ;
    01624                          case BusQueryCompatibleIDs:
    01625                              DbgPrint("(BusQueryCompatibleIDs)") ;
    01626                              break ;
    01627                          case BusQueryInstanceID:
    01628                              DbgPrint("(BusQueryInstanceID)") ;
    01629                              break ;
    01630                          default:
    01631                              DbgPrint("(Bogus)\n") ;
    01632                              break ;
    01633                      }
    01634                      break ;
    01635                  case IRP_MN_QUERY_BUS_INFORMATION:
    01636                      // BUGBUG: Should print out
    01637                      break ;
    01638                  case IRP_MN_DEVICE_USAGE_NOTIFICATION:
    01639                      switch(IrpSp->Parameters.UsageNotification.Type) {
    01640                          case DeviceUsageTypeUndefined:
    01641                              DbgPrint("(DeviceUsageTypeUndefined") ;
    01642                              break ;
    01643                          case DeviceUsageTypePaging:
    01644                              DbgPrint("(DeviceUsageTypePaging") ;
    01645                              break ;
    01646                          case DeviceUsageTypeHibernation:
    01647                              DbgPrint("(DeviceUsageTypeHibernation") ;
    01648                              break ;
    01649                          case DeviceUsageTypeDumpFile:
    01650                              DbgPrint("(DeviceUsageTypeDumpFile") ;
    01651                              break ;
    01652                          default:
    01653                              DbgPrint("(Bogus)\n") ;
    01654                              break ;
    01655                      }
    01656                      if (IrpSp->Parameters.UsageNotification.InPath) {
    01657                          DbgPrint(", InPath=TRUE)") ;
    01658                      } else {
    01659                          DbgPrint(", InPath=FALSE)") ;
    01660                      }
    01661                      break ;
    01662                  case IRP_MN_QUERY_LEGACY_BUS_INFORMATION:
    01663                      // BUGBUG: Should print out
    01664                      break ;
    01665                  default:
    01666                      break ;
    01667              }
    01668              DbgPrint("\n") ;
    01669              break ;
    01670
    01671          case IRP_MJ_POWER:
    01672              DbgPrint(".") ;
    01673              if (IrpSp->MinorFunction<=MAX_NAMED_POWER_IRP) {
    01674
    01675                  DbgPrint(PowerIrpNames[IrpSp->MinorFunction]) ;
    01676              } else if (IrpSp->MinorFunction==0xFF) {
    01677
    01678                  DbgPrint("IRP_MN_BOGUS") ;
    01679              } else {
    01680                  DbgPrint("(Bogus)\n") ;
    01681              }
    01682              DbgPrint("\n") ;
    01683              break ;
    01684
    01685          default:
    01686              DbgPrint("\n") ;
    01687              break ;
    01688     }
    01689 }

VOID IopDriverCorrectnessPrintParamData | ( | IN PDC_CHECK_DATA | DcCheckData | ) |

Definition at line 1151 of file ioassert.c.

References IopDriverCorrectnessPrintIrp().

Referenced by IopDriverCorrectnessCheckUnderLock().

    01154 {
    01155     if (DcCheckData->DcParamArray[0]) {
    01156
    01157         IopDriverCorrectnessPrintIrp((PIRP) DcCheckData->DcParamArray[0]);
    01158     }
    01159 }

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().

    00847 {
    00848     ULONG paramType, maxParameterTypes;
    00849     ULONG arrayIndex, paramLength;
    00850     PSTR messageHead, newMessage;
    00851     LONG charsRemaining, length;
    00852
    00853     //
    00854     // Get the message text.
    00855     //
    00856     messageHead = IopDcMessageTable[DcCheckData->TableIndex].MessageText;
    00857
    00858     //
    00859     // Now manually build out the message.
    00860     //
    00861     newMessage = OutputBuffer;
    00862     charsRemaining = (MaxOutputBufferSize/sizeof(UCHAR))-1;
    00863     maxParameterTypes = sizeof(DcParamTable)/sizeof(DCPARAM_TYPE_ENTRY);
    00864
    00865     while(*messageHead != '\0') {
    00866
    00867         if (charsRemaining <= 0) {
    00868
    00869             return STATUS_BUFFER_OVERFLOW;
    00870         }
    00871
    00872         if (*messageHead != '%') {
    00873
    00874             *newMessage = *messageHead;
    00875             newMessage++;
    00876             messageHead++;
    00877             charsRemaining--;
    00878
    00879         } else {
    00880
    00881             for(paramType = 0; paramType < maxParameterTypes; paramType++) {
    00882
    00883                 paramLength = strlen(DcParamTable[paramType].DcParamName);
    00884
    00885                 //
    00886                 // Do we have a match?
    00887                 //
    00888                 // N.B. - We don't do any case 'de-sensitizing' anywhere, so
    00889                 //        everything's cases must match!
    00890                 //
    00891                 if (RtlCompareMemory(
    00892                     messageHead+1,
    00893                     DcParamTable[paramType].DcParamName,
    00894                     paramLength*sizeof(UCHAR)) == paramLength*sizeof(UCHAR)) {
    00895
    00896                     arrayIndex = paramType*3;
    00897                     messageHead += (paramLength+1);
    00898
    00899                     //
    00900                     // Was an index passed in (ie, "3rd" irp requested)?
    00901                     //
    00902                     if ((*messageHead >= '1') && (*messageHead <= '3')) {
    00903
    00904                         //
    00905                         // Adjust table index appropriately.
    00906                         //
    00907                         arrayIndex += (*messageHead - '1') ;
    00908                         messageHead++;
    00909                     }
    00910
    00911                     length = _snprintf(
    00912                         newMessage,
    00913                         charsRemaining+1,
    00914                         "%p",
    00915                         DcCheckData->DcParamArray[arrayIndex]
    00916                         );
    00917
    00918                     if (length == -1) {
    00919
    00920                         return STATUS_BUFFER_OVERFLOW;
    00921                     }
    00922
    00923                     charsRemaining -= length;
    00924                     newMessage += length;
    00925                     break;
    00926                 }
    00927             }
    00928
    00929             if (paramType == maxParameterTypes) {
    00930
    00931                 //
    00932                 // Either the message we looked up is malformed, we don't recognize
    00933                 // the %thing it is talking about, or this is %%!
    00934                 //
    00935                 *newMessage = *messageHead;
    00936                 messageHead++;
    00937                 newMessage++;
    00938                 charsRemaining--;
    00939
    00940                 if (*messageHead == '%') {
    00941
    00942                     messageHead++;
    00943                 }
    00944             }
    00945         }
    00946     }
    00947
    00948     //
    00949     // Null-terminate it (we have room because we took one off the buffer size
    00950     // above).
    00951     //
    00952     *newMessage = '\0';
    00953
    00954     DcCheckData->ClassText = DcCheckData->AssertionClass->MessageClassText;
    00955     DcCheckData->AssertionText = OutputBuffer;
    00956     return STATUS_SUCCESS;
    00957 }

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().

    00608 {
    00609     PVOID returnAddress[1];
    00610     PVOID baseOfImage, culpritAddress;
    00611     ULONG stackHash;
    00612     PLDR_DATA_TABLE_ENTRY dataTableEntry;
    00613     PIMAGE_NT_HEADERS ntHeaders;
    00614     ULONG i, currentMessageMask, paramType, maxParameterTypes, paramMask;
    00615     ULONG tableIndex;
    00616     char ansiDriverName[81];
    00617
    00618     tableIndex = MessageID - DCERROR_UNSPECIFIED;
    00619
    00620     //
    00621     // Retrieve a pointer to the appropriate message text.
    00622     //
    00623     if (tableIndex >= sizeof(IopDcMessageTable)/sizeof(DCERROR_MESSAGE)) {
    00624
    00625         //
    00626         // Bogus message index!
    00627         //
    00628         ASSERT(0);
    00629         tableIndex = 0;
    00630     }
    00631
    00632     ASSERT(IopDcMessageTable[tableIndex].MessageID == MessageID);
    00633
    00634     //
    00635     // OK, we're going to do *something*. Process the incoming parameters.
    00636     //
    00637     maxParameterTypes = sizeof(DcParamTable)/sizeof(DCPARAM_TYPE_ENTRY);
    00638
    00639     //
    00640     // First we grab parameter off the stack and slot them appropriately into
    00641     // our array of "things".
    00642     //
    00643     // The array is in groups of three for each possible member of a given type
    00644     // (three irps, three routines, three device objects, etc). Items not
    00645     // referenced in are set to NULL.
    00646     //
    00647     currentMessageMask = MessageParameterMask;
    00648
    00649     for(paramType = 0; paramType < maxParameterTypes; paramType++) {
    00650
    00651         paramMask = DcParamTable[paramType].DcParamMask ;
    00652         for(i=0; i<3; i++) {
    00653
    00654             if (currentMessageMask&(paramMask*3)) {
    00655
    00656                 currentMessageMask -= paramMask;
    00657                 DcParamArray[paramType*3+i] = va_arg(*MessageParameters, PVOID);
    00658
    00659             } else {
    00660
    00661                 DcParamArray[paramType*3+i] = NULL;
    00662             }
    00663         }
    00664     }
    00665
    00666     //
    00667     // If this fires, part of the MessageParameterMask was not understood,
    00668     // probably a bug by the caller!
    00669     //
    00670     ASSERT(currentMessageMask == 0);
    00671
    00672     //
    00673     // Pre-init unhelpful answers...
    00674     //
    00675     culpritAddress = NULL;
    00676     DcCheckData->OffsetIntoImage = 0;
    00677     DcCheckData->InVerifierList = TRUE;
    00678     RtlInitUnicodeString(&DcCheckData->DriverName, NULL);
    00679
    00680     //
    00681     // Blame caller if appropriate
    00682     //
    00683     if (StackFramesToSkip != -1) {
    00684
    00685         if (RtlCaptureStackBackTrace(StackFramesToSkip+2, 1, returnAddress,
    00686            &stackHash)==1) {
    00687
    00688             culpritAddress = returnAddress[0];
    00689         }
    00690
    00691     } else {
    00692
    00693         //
    00694         // %Routine1
    00695         //
    00696         culpritAddress = DcParamArray[3];
    00697     }
    00698
    00699     //
    00700     // Extract the culprit's name if possible...
    00701     //
    00702     if (culpritAddress) {
    00703
    00704         baseOfImage = IopDriverCorrectnessAddressToFileHeader(
    00705             (PVOID) culpritAddress,
    00706             &dataTableEntry
    00707             );
    00708
    00709         if (baseOfImage != NULL) {
    00710
    00711             //
    00712             // If we found a match, drill into the dataTableEntry's to get
    00713             //
    00714             //
    00715             if (MmIsAddressValid(dataTableEntry->DllBase) != FALSE) {
    00716
    00717                 ntHeaders = RtlImageNtHeader(dataTableEntry->DllBase);
    00718
    00719                 RtlCopyMemory(
    00720                     &DcCheckData->DriverName,
    00721                     &dataTableEntry->BaseDllName,
    00722                     sizeof(UNICODE_STRING)
    00723                     );
    00724
    00725                 DcCheckData->OffsetIntoImage = (PUCHAR) culpritAddress - (PUCHAR) baseOfImage;
    00726             }
    00727
    00728             //
    00729             // Now record whether this is in the verifying table.
    00730             //
    00731             if (!(dataTableEntry->Flags & LDRP_IMAGE_VERIFYING)) {
    00732
    00733                 DcCheckData->InVerifierList = FALSE;
    00734             }
    00735         }
    00736     }
    00737
    00738     DcCheckData->CulpritAddress = culpritAddress;
    00739     DcCheckData->DcParamArray = DcParamArray;
    00740     DcCheckData->TableIndex = tableIndex;
    00741     DcCheckData->MessageID = MessageID;
    00742     DcCheckData->Control = Control;
    00743     DcCheckData->AssertionClass = IopDcMessageTable[DcCheckData->TableIndex].MessageClass;
    00744
    00745     //
    00746     // Get an ANSI version of the driver name and root through the override
    00747     // table.
    00748     //
    00749     KeBugCheckUnicodeToAnsi(
    00750         &DcCheckData->DriverName,
    00751         ansiDriverName,
    00752         sizeof(ansiDriverName)
    00753         );
    00754
    00755     for(i=0; i<sizeof(IopDcOverrideTable)/sizeof(DC_OVERRIDE_TABLE); i++) {
    00756
    00757         if ((IopDcOverrideTable[i].MessageID == MessageID) ||
    00758            (IopDcOverrideTable[i].MessageID == DCERROR_UNSPECIFIED)) {
    00759
    00760             if (!_stricmp(ansiDriverName, IopDcOverrideTable[i].DriverName)) {
    00761
    00762                 //
    00763                 // We have a match, override the error class. Note that as
    00764                 // Control is not per-driver, but per assert, we null out
    00765                 // the passed in Control so that we don't apply this override
    00766                 // policy against every driver!
    00767                 //
    00768                 DcCheckData->Control = NULL;
    00769                 DcCheckData->AssertionClass = IopDcOverrideTable[i].ReplacementClass;
    00770             }
    00771         }
    00772     }
    00773 }

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().

    01166 {
    01167     char response[2];
    01168     ULONG assertionControl;
    01169     BOOLEAN waitForInput;
    01170
    01171     assertionControl = DcCheckData->AssertionControl;
    01172
    01173     *ExitAssertion = TRUE;
    01174
    01175     //
    01176     // Vocalize if so ordered.
    01177     //
    01178     if (assertionControl&DIAG_BEEP) {
    01179
    01180         DbgPrint("%c", 7);
    01181     }
    01182
    01183     if (assertionControl&DIAG_ZAPPED) {
    01184
    01185         return;
    01186     }
    01187
    01188     //
    01189     // Wait for input...
    01190     //
    01191     waitForInput = TRUE;
    01192     while(waitForInput) {
    01193
    01194         if (DcCheckData->Control) {
    01195
    01196             DbgPrompt( "Break, Ignore, Zap, Remove, Disable all (bizrd)? ", response, sizeof( response ));
    01197         } else {
    01198
    01199             DbgPrompt( "Break, Ignore, Disable all (bid)? ", response, sizeof( response ));
    01200         }
    01201
    01202         switch (response[0]) {
    01203
    01204             case 'B':
    01205             case 'b':
    01206                 DbgPrint("Breaking in... (press g<enter> to return to assert menu)\n");
    01207                 DbgBreakPoint();
    01208                 waitForInput = FALSE;
    01209                 *ExitAssertion = FALSE;
    01210                 break;
    01211
    01212             case 'I':
    01213             case 'i':
    01214                 waitForInput = FALSE;
    01215                 break;
    01216
    01217             case 'Z':
    01218             case 'z':
    01219                 if (DcCheckData->Control) {
    01220
    01221                    DbgPrint("Breakpoint zapped (OS will print text and return)\n");
    01222                    assertionControl |= DIAG_ZAPPED;
    01223                    assertionControl &=~ DIAG_BEEP;
    01224                    waitForInput = FALSE;
    01225                 }
    01226                 break;
    01227
    01228             case 'D':
    01229             case 'd':
    01230                 IopDcControlOverride = DIAG_CLEARED;
    01231                 DbgPrint("Verification asserts disabled.\n");
    01232                 //assertionControl |= DIAG_CLEARED;
    01233                 waitForInput = FALSE;
    01234                 break;
    01235
    01236             case 'R':
    01237             case 'r':
    01238                 if (DcCheckData->Control) {
    01239
    01240                    DbgPrint("Breakpoint removed\n") ;
    01241                    assertionControl |= DIAG_CLEARED;
    01242                    waitForInput = FALSE;
    01243                 }
    01244                 break;
    01245         }
    01246     }
    01247
    01248     if (DcCheckData->Control) {
    01249         *DcCheckData->Control = assertionControl;
    01250     }
    01251 }

VOID IopDriverCorrectnessReleaseLock | ( | VOID |  | ) |

Definition at line 446 of file ioassert.c.

References IopDcControlCurrent, IopDcControlIrql, IopDcControlLock, IopDcCurrentFrameSkips, and NULL.

    00451               :
    00452
    00453       Worker routine for KD_ASSERT_OUT, see IopDiagSetAssertLock
    00454
    00455 --*/
    00456 {
    00457     IopDcControlCurrent = NULL ;
    00458     IopDcCurrentFrameSkips = -1 ;
    00459     ExReleaseSpinLock( &IopDcControlLock, IopDcControlIrql );
    00460 }

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().

    00429               :
    00430
    00431       Worker routine for KD_ASSERT_OUT, takes the assertion spinlock. We do
    00432       this because we *must* use a macro to instantiate a caller-specific
    00433       tag and we cannot pass in that value along with a variable printf style
    00434       debug output. Hence we must "pre-program" the output routine with the
    00435       breakpoint ID, and use a spinlock to protect ourselves
    00436 --*/
    00437 {
    00438     ASSERT(IovpInitCalled);
    00439     ExAcquireSpinLock( &IopDcControlLock, &IopDcControlIrql );
    00440     ASSERT(IopDcControlCurrent == NULL) ;
    00441     IopDcControlCurrent = ControlNew ;
    00442     IopDcCurrentFrameSkips = StackFramesToSkip ;
    00443 }

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().

    00963 {
    00964     PVOID parameterArray[4];
    00965     char captionBuffer[256];
    00966     char ansiDriverName[81];
    00967     UNICODE_STRING unicodeString;
    00968
    00969     //
    00970     // Do not bugcheck if a kernel debugger is attached, nor if this isn't a
    00971     // fatal error.
    00972     //
    00973     if (KdDebuggerEnabled || (!(DcCheckData->AssertionControl&DIAG_FATAL_ERROR))) {
    00974
    00975         return;
    00976     }
    00977
    00978     //
    00979     // We are here because DIAG_FATAL_ERROR is set. We use
    00980     // FATAL_UNHANDLED_HARD_ERROR so that we can give a
    00981     // descriptive text string for the problem.
    00982     //
    00983     parameterArray[0] = (PVOID) DcCheckData->MessageID;
    00984     parameterArray[1] = DcCheckData->CulpritAddress;
    00985     parameterArray[2] = DcCheckData->DcParamArray[0];
    00986     parameterArray[3] = DcCheckData->DcParamArray[6];
    00987
    00988     KeBugCheckUnicodeToAnsi(
    00989         &DcCheckData->DriverName,
    00990         ansiDriverName,
    00991         sizeof(ansiDriverName)
    00992         );
    00993
    00994     _snprintf(
    00995         captionBuffer,
    00996         sizeof(captionBuffer),
    00997         "IO SYSTEM VERIFICATION ERROR in %s (%s %x)\n[%s+%x at %p]\n",
    00998         ansiDriverName,
    00999         DcCheckData->ClassText,
    01000         DcCheckData->MessageID,
    01001         ansiDriverName,
    01002         DcCheckData->OffsetIntoImage,
    01003         DcCheckData->CulpritAddress
    01004         );
    01005
    01006     KeBugCheckEx(
    01007         FATAL_UNHANDLED_HARD_ERROR,
    01008         DRIVER_VERIFIER_IOMANAGER_VIOLATION,
    01009         (ULONG_PTR) parameterArray,
    01010         (ULONG_PTR) captionBuffer,
    01011         (ULONG_PTR) "" // DcCheckData->AssertionText is too technical
    01012         );
    01013 }

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().

    01324 {
    01325    while (((ULONG_PTR)Location & (sizeof(ULONG_PTR)-1)) && (Length > 0)) {
    01326
    01327         //
    01328         // Check to determine if the move will succeed before actually performing
    01329         // the operation.
    01330         //
    01331         if (MmIsAddressValid(Location)==FALSE) {
    01332             return FALSE ;
    01333         }
    01334
    01335         ((PCHAR) Location)++ ;
    01336         Length-- ;
    01337     }
    01338
    01339     while (Length > (sizeof(ULONG_PTR)-1)) {
    01340
    01341         //
    01342         // Check to determine if the move will succeed before actually performing
    01343         // the operation.
    01344         //
    01345         if (MmIsAddressValid(Location)==FALSE) {
    01346             return FALSE ;
    01347         }
    01348         ((PCHAR) Location) += sizeof(ULONG_PTR);
    01349         Length -= sizeof(ULONG_PTR);
    01350
    01351     }
    01352
    01353     while (Length > 0) {
    01354
    01355         //
    01356         // Check to determine if the move will succeed before actually performing
    01357         // the operation.
    01358         //
    01359         if (MmIsAddressValid(Location)==FALSE) {
    01360             return FALSE;
    01361         }
    01362
    01363         ((PCHAR) Location)++ ;
    01364         Length-- ;
    01365     }
    01366     return TRUE ;
    01367 }

## Variable Documentation

ULONG IopDcControlInitial

| Definition at line 52 of file ioassert.h. Referenced by IopDriverCorrectnessApplyControl(), and IoVerifierInit().

KSPIN_LOCK IopDcControlLock

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

ULONG IopDcControlOverride

| Definition at line 53 of file ioassert.h. Referenced by IopDriverCorrectnessApplyControl(), IopDriverCorrectnessPrompt(), and IoVerifierInit().

ULONG IovpEnforcementLevel

| Definition at line 51 of file ioassert.h.

LONG IovpInitCalled

| Definition at line 49 of file ioassert.h. Referenced by IopDriverCorrectnessTakeLock(), and IoVerifierInit().

ULONG IovpVerifierLevel

| Definition at line 50 of file ioassert.h.