windows-xp/Source/XPSP1/NT/base/ntos/verifier/vfbugcheck.c

/*++

Copyright (c) 2000  Microsoft Corporation

Module Name:

    vfbugcheck.c

Abstract:

    This module implements support for verifier bugchecks.

Author:

    Adrian J. Oney (adriao) 20-Apr-1998

Environment:

    Kernel mode

Revision History:

    AdriaO  02/21/2000  - Moved from ntos\io\ioassert.c

--*/

//
// Disable W4 level warnings generated by public headers.
//

#include "vfpragma.h"


#include "..\io\iop.h" // Includes vfdef.h
#include "vibugcheck.h"

#ifdef ALLOC_PRAGMA
#pragma alloc_text(INIT,     VfBugcheckInit)
#pragma alloc_text(PAGEVRFY, VfBugcheckThrowIoException)
#pragma alloc_text(PAGEVRFY, VfBugcheckThrowException)
#pragma alloc_text(PAGEVRFY, ViBucheckProcessParams)
#pragma alloc_text(PAGEVRFY, ViBugcheckProcessMessageText)
#pragma alloc_text(PAGEVRFY, ViBugcheckApplyControl)
#pragma alloc_text(PAGEVRFY, ViBugcheckHalt)
#pragma alloc_text(PAGEVRFY, ViBugcheckPrintBuffer)
#pragma alloc_text(PAGEVRFY, ViBugcheckPrintParamData)
#pragma alloc_text(PAGEVRFY, ViBugcheckPrintUrl)
#pragma alloc_text(PAGEVRFY, ViBugcheckPrompt)
#endif // ALLOC_PRAGMA

#ifdef ALLOC_DATA_PRAGMA
#pragma data_seg("PAGEVRFD")
#endif

ULONG           ViBugCheckInitialControl;
ULONG           ViBugCheckControlOverride;
UNICODE_STRING  ViBugCheckEmptyString;

#ifdef ALLOC_DATA_PRAGMA
#pragma const_seg("PAGEVRFC")
#endif

//
// When invoking the driver check macro's, pass Irps first, Routines second,
// DevObj's third, and any Status's last...
//
const DCPARAM_TYPE_ENTRY ViBugCheckParamTable[] = {
    { DCPARAM_ROUTINE, "Routine"    },
    { DCPARAM_IRP,     "Irp"        },
    { DCPARAM_IRPSNAP, "Snapshot"   },
    { DCPARAM_DEVOBJ,  "DevObj"     },
    { DCPARAM_STATUS,  "Status"     },
    { DCPARAM_ULONG,   "Ulong"      },
    { DCPARAM_PVOID,   "Pvoid"      }
};


VOID
FASTCALL
VfBugcheckInit(
    VOID
    )
/*++

Routine Description:

    This routine initializes the verifier bugcheck support routines.

Arguments:

    None.

Return Value:

    None.

--*/
{
    ViBugCheckInitialControl = 0;
    ViBugCheckControlOverride = 0;
    RtlInitUnicodeString(&ViBugCheckEmptyString, NULL);
}


NTSTATUS
VfBugcheckThrowIoException(
    IN DCERROR_ID           MessageID,
    IN ULONG                MessageParameterMask,
    ...
    )
/*++

   Description:

      This routine processes an assert and provides options for removing the
      breakpoint, changing to just a text-out, etc.

    DCPARAM_IRP*(count)+DCPARAM_ROUTINE*(count)+DCPARAM_DEVOBJ*(count),
        irp1,
        irp2,
        irp3,
        routine1,
        ..,
        ..,
        devobj1,

    count can be a max of 3.

   Notes:

      The text will automagically be formatted and printed as such:

      ASSERTION CLASS: ASSERTION TEXT ASSERTION TEXT ASSERTION
                       TEXT ASSERTION TEXT ...

--*/
{
    PVFMESSAGE_TEMPLATE_TABLE ioVerifierTable;
    UCHAR paramFormat[9*3*ARRAY_COUNT(ViBugCheckParamTable)+1];
    ULONG paramType, paramMask, curMask;
    NTSTATUS status;
    va_list arglist;

    curMask = MessageParameterMask;
    paramFormat[0] = '\0';

    for(paramType=0; paramType<ARRAY_COUNT(ViBugCheckParamTable); paramType++) {

        paramMask = ViBugCheckParamTable[paramType].DcParamMask;
        while(curMask & (paramMask*3)) {

            strcat(
                (char *) paramFormat,
                ViBugCheckParamTable[paramType].DcParamName
                );

            curMask -= paramMask;
        }
    }

    VfMessageRetrieveInternalTable(
        VFMESSAGE_TABLE_IOVERIFIER,
        &ioVerifierTable
        );

    va_start(arglist, MessageParameterMask);

    status = VfBugcheckThrowException(
        ioVerifierTable,
        (VFMESSAGE_ERRORID) MessageID,
        (PCSTR) paramFormat,
        &arglist
        );

    va_end(arglist);

    return status;
}


NTSTATUS
VfBugcheckThrowException(
    IN PVFMESSAGE_TEMPLATE_TABLE    MessageTable        OPTIONAL,
    IN VFMESSAGE_ERRORID            MessageID,
    IN PCSTR                        MessageParamFormat,
    IN va_list *                    MessageParameters
    )
/*++

   Description:

      This routine displays an assert and provides options for
      removing the breakpoint, changing to just a text-out, etc.

   Arguments:

   Notes:

      The text will automagically be formatted and printed as such:

      ASSERTION CLASS: ASSERTION TEXT ASSERTION TEXT ASSERTION
                       TEXT ASSERTION TEXT ...

--*/
{
    UCHAR finalBuffer[512];
    NTSTATUS status;
    DC_CHECK_DATA dcCheckData;
    PVOID dcParamArray[3*ARRAY_COUNT(ViBugCheckParamTable)];
    BOOLEAN exitAssertion;

    //
    // Preinit
    //
    RtlZeroMemory(dcParamArray, sizeof(dcParamArray));

    //
    // Determine what our basic policy towards this check will be and fill out
    // the dcCheckData structure as well as we can.
    //
    ViBucheckProcessParams(
        MessageTable,
        MessageID,
        MessageParamFormat,
        MessageParameters,
        dcParamArray,
        &dcCheckData
        );

    if (!ViBugcheckApplyControl(&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 = ViBugcheckProcessMessageText(
        sizeof(finalBuffer),
        (PSTR)finalBuffer,
        &dcCheckData
        );

    if (!NT_SUCCESS(status)) {

        ASSERT(0);

        //
        // Something went wrong with the index lookup!
        //
        return status;
    }

    do {

        ViBugcheckPrintBuffer(&dcCheckData);
        ViBugcheckPrintParamData(&dcCheckData);
        ViBugcheckPrintUrl(&dcCheckData);
        ViBugcheckHalt(&dcCheckData);
        ViBugcheckPrompt(&dcCheckData, &exitAssertion);

    } while (!exitAssertion);

    return status;
}


VOID
ViBucheckProcessParams(
    IN  PVFMESSAGE_TEMPLATE_TABLE   MessageTable        OPTIONAL,
    IN  VFMESSAGE_ERRORID           MessageID,
    IN  PCSTR                       MessageParamFormat,
    IN  va_list *                   MessageParameters,
    IN  PVOID *                     DcParamArray,
    OUT PDC_CHECK_DATA              DcCheckData
    )
{
    PVOID culpritAddress;
    ULONG i, paramType, paramLen;
    char ansiDriverName[81];
    NTSTATUS status;
    ULONG paramIndices[ARRAY_COUNT(ViBugCheckParamTable)];
    PCSTR format;

    //
    // 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.
    //
    RtlZeroMemory(paramIndices, sizeof(paramIndices));
    format = MessageParamFormat;
    while(*format) {

        if ((format[0] == ' ')||(format[0] == '%')) {

            format++;
            continue;
        }

        for(paramType = 0;
            paramType < ARRAY_COUNT(ViBugCheckParamTable);
            paramType++) {

            paramLen = (ULONG)strlen(ViBugCheckParamTable[paramType].DcParamName);

            if (!_strnicmp(ViBugCheckParamTable[paramType].DcParamName, format, paramLen)) {

                //
                // Match! Advance the pointer...
                //
                format += paramLen;

                //
                // If the caller specified an index, grab it. Otherwise infer.
                //
                if ((format[0] >= '1') && (format[0] <= '3')) {

                    i = format[0] - '1';
                    format++;

                } else {

                    i = paramIndices[paramType];
                    ASSERT(i < 3);
                }

                if (i < 3) {

                    //
                    // Param number is within bounds.
                    //
                    DcParamArray[paramType*3+i] = va_arg(*MessageParameters, PVOID);
                }

                //
                // Update the current parameter index for the given type.
                //
                paramIndices[paramType] = i+1;

                //
                // Get out early
                //
                break;
            }
        }

        if (paramType == ARRAY_COUNT(ViBugCheckParamTable)) {

            //
            // We could'nt find an entry matching the format text. Bail.
            //
            ASSERT(paramType != ARRAY_COUNT(ViBugCheckParamTable));
            break;
        }
    }

    //
    // Pre-init unhelpful answers...
    //
    DcCheckData->DriverName = &ViBugCheckEmptyString;
    DcCheckData->OffsetIntoImage = 0;
    DcCheckData->InVerifierList = TRUE;
    culpritAddress = DcParamArray[0];

    //
    // Extract the culprit's name if possible...
    //
    if (culpritAddress) {

        status = KevUtilAddressToFileHeader(
            (PVOID) culpritAddress,
            (PUINT_PTR)(&DcCheckData->OffsetIntoImage),
            &DcCheckData->DriverName,
            &DcCheckData->InVerifierList
            );

        if (!NT_SUCCESS(status)) {

            //
            // IF we don't know who it is, assert anyway.
            //
            DcCheckData->InVerifierList = TRUE;
        }
    }

    //
    // Record
    //
    DcCheckData->CulpritAddress = culpritAddress;
    DcCheckData->DcParamArray = DcParamArray;
    DcCheckData->MessageID = MessageID;

    //
    // Get an ANSI version of the driver name.
    //
    KeBugCheckUnicodeToAnsi(
        DcCheckData->DriverName,
        ansiDriverName,
        sizeof(ansiDriverName)
        );

    //
    // Retrieve a pointer to the appropriate message data.
    //
    VfMessageRetrieveErrorData(
        MessageTable,
        MessageID,
        ansiDriverName,
        &DcCheckData->BugCheckMajor,
        &DcCheckData->AssertionClass,
        &DcCheckData->MessageTextTemplate,
        &DcCheckData->Control
        );
}


NTSTATUS
FASTCALL
ViBugcheckProcessMessageText(
    IN ULONG               MaxOutputBufferSize,
    OUT PSTR               OutputBuffer,
    IN OUT PDC_CHECK_DATA  DcCheckData
    )
{
    ULONG paramType, maxParameterTypes;
    ULONG arrayIndex, paramLength;
    char const* messageHead;
    PSTR newMessage;
    LONG charsRemaining, length;

    //
    // Get the message text.
    //
    messageHead = DcCheckData->MessageTextTemplate;

    //
    // Now manually build out the message.
    //
    newMessage = OutputBuffer;
    charsRemaining = (MaxOutputBufferSize/sizeof(UCHAR))-1;
    maxParameterTypes = ARRAY_COUNT(ViBugCheckParamTable);

    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 = (ULONG)strlen(ViBugCheckParamTable[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,
                    ViBugCheckParamTable[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++;
                    }

                    if ((arrayIndex < 6) || (arrayIndex >=9)) {

                        //
                        // Normal param, print the pointer
                        //
                        length = _snprintf(
                            newMessage,
                            charsRemaining+1,
                            "%p",
                            DcCheckData->DcParamArray[arrayIndex]
                            );

                    } else {

                        //
                        // IRP Snapshot, extract the IRP and print that
                        //
                        length = _snprintf(
                            newMessage,
                            charsRemaining+1,
                            "%p",
                            ((PIRP_SNAPSHOT) DcCheckData->DcParamArray[arrayIndex])->Irp
                            );
                    }

                    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;
}


BOOLEAN
FASTCALL
ViBugcheckApplyControl(
    IN OUT PDC_CHECK_DATA  DcCheckData
    )
{
    ULONG assertionControl;

    if (ViBugCheckControlOverride) {

        assertionControl = ViBugCheckControlOverride;

    } else if (DcCheckData->Control) {

        //
        // Initialize the control if appropo
        //
        if (!((*DcCheckData->Control) & VFM_FLAG_INITIALIZED)) {

            *DcCheckData->Control |= (
                VFM_FLAG_INITIALIZED | ViBugCheckInitialControl |
                DcCheckData->AssertionClass->ClassFlags );
        }

        assertionControl = *DcCheckData->Control;

    } else {

        assertionControl =
            ( ViBugCheckInitialControl |
              DcCheckData->AssertionClass->ClassFlags );
    }

    if (assertionControl & VFM_FLAG_CLEARED) {

        //
        // If the breakpoint was cleared, then return, print/rip not.
        //
        return FALSE;
    }

    if ((!(assertionControl & VFM_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 VFM_DEPLOYMENT_FAILURE is set. Then we shall
    // invoke the driver bugcheck...
    //
    if ((!KdDebuggerEnabled) && (!(assertionControl & VFM_DEPLOYMENT_FAILURE))) {

        return FALSE;
    }

    //
    // Record our intentions and continue.
    //
    DcCheckData->AssertionControl = assertionControl;
    return TRUE;
}


VOID
FASTCALL
ViBugcheckHalt(
    IN PDC_CHECK_DATA DcCheckData
    )
{
    PVOID parameterArray[4];
    char captionBuffer[256];
    char ansiDriverName[81];

    //
    // Do not bugcheck if a kernel debugger is attached, nor if this isn't a
    // fatal error.
    //
    if (KdDebuggerEnabled ||
        (!(DcCheckData->AssertionControl & VFM_DEPLOYMENT_FAILURE))) {

        return;
    }

    //
    // We are here because VFM_DEPLOYMENT_FAILURE is set. We use
    // FATAL_UNHANDLED_HARD_ERROR so that we can give a
    // descriptive text string for the problem.
    //
    parameterArray[0] = (PVOID)(ULONG_PTR)(DcCheckData->MessageID);
    parameterArray[1] = DcCheckData->CulpritAddress;
    parameterArray[2] = DcCheckData->DcParamArray[3];
    parameterArray[3] = DcCheckData->DcParamArray[9];

    if (DcCheckData->BugCheckMajor == DRIVER_VERIFIER_IOMANAGER_VIOLATION) {

        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,
            DcCheckData->BugCheckMajor,
            (ULONG_PTR) parameterArray,
            (ULONG_PTR) captionBuffer,
            (ULONG_PTR) "" // DcCheckData->AssertionText is too technical
            );

    } else {

        KeBugCheckEx(
            DcCheckData->BugCheckMajor,
            DcCheckData->MessageID,
            (ULONG_PTR) DcCheckData->DcParamArray[9],
            (ULONG_PTR) DcCheckData->DcParamArray[15],
            (ULONG_PTR) DcCheckData->DcParamArray[16]
            );
    }
}


VOID
FASTCALL
ViBugcheckPrintBuffer(
    IN PDC_CHECK_DATA DcCheckData
    )
{
    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 carriage return
    //
    DbgPrint("\n") ;

    //
    // Drop a banner if this is a fatal assert or a logo failure.
    //
    if (DcCheckData->AssertionControl &
        (VFM_DEPLOYMENT_FAILURE | VFM_LOGO_FAILURE)) {

        DbgPrint(
            "***********************************************************************\n"
            "* THIS VALIDATION 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 = (LONG)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 = (PSTR)(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,
                (PSTR)ansiDriverName,
                sizeof(ansiDriverName)
                );

            sprintf((PCHAR)callerBuf, "[%s @ 0x%p] ",
                ansiDriverName,
                DcCheckData->CulpritAddress
                );

        } else {

            sprintf((PCHAR)callerBuf, "[0x%p] ", DcCheckData->CulpritAddress);
        }

        DbgPrint("%s", callerBuf);
        lMarginCur += (LONG)strlen((PCHAR)callerBuf);
    }

    //
    // Format and print our assertion text
    //
    while(*current) {

        if (*current == ' ') {

            if ((current - lineStart) >= (rMargin-lMarginCur-1)) {

                DbgPrint("%s", lMarginText);
                lMarginText = (PSTR)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 = (PSTR)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
FASTCALL
ViBugcheckPrintParamData(
    IN PDC_CHECK_DATA DcCheckData
    )
{
    if (DcCheckData->DcParamArray[3]) {

        VfPrintDumpIrp((PIRP) DcCheckData->DcParamArray[3]);
    }

    if (DcCheckData->DcParamArray[6]) {

        VfPrintDumpIrpStack(
            &((PIRP_SNAPSHOT) DcCheckData->DcParamArray[6])->IoStackLocation
            );
    }
}


VOID
FASTCALL
ViBugcheckPrintUrl(
    IN PDC_CHECK_DATA DcCheckData
    )
{
    DbgPrint(
        "http://www.microsoft.com/hwdq/bc/default.asp?os=%d.%d.%d&major=0x%x&minor=0x%x&lang=0x%x\n",
        VER_PRODUCTMAJORVERSION,
        VER_PRODUCTMINORVERSION,
        VER_PRODUCTBUILD,
        DcCheckData->BugCheckMajor,
        DcCheckData->MessageID,
        9 // English
        );
}


VOID
FASTCALL
ViBugcheckPrompt(
    IN      PDC_CHECK_DATA  DcCheckData,
    OUT     PBOOLEAN        ExitAssertion
    )
{
    char response[2];
    ULONG assertionControl;
    BOOLEAN waitForInput;

    assertionControl = DcCheckData->AssertionControl;

    *ExitAssertion = TRUE;

    //
    // Vocalize if so ordered.
    //
    if (assertionControl & VFM_FLAG_BEEP) {

        DbgPrint("%c", 7);
    }

    if (assertionControl & VFM_FLAG_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 |= VFM_FLAG_ZAPPED;
                   assertionControl &=~ VFM_FLAG_BEEP;
                   waitForInput = FALSE;
                }
                break;

            case 'D':
            case 'd':
                ViBugCheckControlOverride = VFM_FLAG_CLEARED;
                DbgPrint("Verification asserts disabled.\n");
                waitForInput = FALSE;
                break;

            case 'R':
            case 'r':
                if (DcCheckData->Control) {

                   DbgPrint("Breakpoint removed\n") ;
                   assertionControl |= VFM_FLAG_CLEARED;
                   waitForInput = FALSE;
                }
                break;
        }
    }

    if (DcCheckData->Control) {
        *DcCheckData->Control = assertionControl;
    }
}