autorun.c File Reference

#include "stddef.h"
#include "string.h"
#include "ntddk.h"
#include "ntddstor.h"
#include "cdrom.h"
#include "mmc.h"
#include "ioctl.h"
#include "ntstrsafe.h"

Include dependency graph for autorun.c:

Go to the source code of this file.

Macros
#define	GESN_TIMEOUT_VALUE   (0x4)
#define	GESN_BUFFER_SIZE   (0x8)
#define	GESN_DEVICE_BUSY_LOWER_THRESHOLD_100_MS   (2)
#define	MAXIMUM_IMMEDIATE_MCN_RETRIES   (0x20)
#define	MCN_REG_SUBKEY_NAME   (L"MediaChangeNotification")
#define	MCN_REG_AUTORUN_DISABLE_INSTANCE_NAME   (L"AlwaysDisableMCN")
#define	MCN_REG_AUTORUN_ENABLE_INSTANCE_NAME   (L"AlwaysEnableMCN")

Functions
	_IRQL_requires_max_ (_IRQL_requires_max_() BOOLEANDeviceIsMediaChangeDisabledForClass(_In_ PCDROM_DEVICE_EXTENSION DeviceExtension) PASSIVE_LEVEL)
VOID	DeviceInternalSetMediaChangeState (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ MEDIA_CHANGE_DETECTION_STATE NewState, _Inout_opt_ PMEDIA_CHANGE_DETECTION_STATE OldState)
VOID	DeviceSetMediaChangeStateEx (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ MEDIA_CHANGE_DETECTION_STATE NewState, _Inout_opt_ PMEDIA_CHANGE_DETECTION_STATE OldState)
	_IRQL_requires_max_ (APC_LEVEL)
VOID NTAPI	DeviceDisableGesn (_In_ WDFWORKITEM WorkItem)
	_IRQL_requires_max_ (PASSIVE_LEVEL)
NTSTATUS NTAPI	DeviceMediaChangeRegistryCallBack (_In_z_ PWSTR ValueName, _In_ ULONG ValueType, _In_reads_bytes_opt_(ValueLength) PVOID ValueData, _In_ ULONG ValueLength, _In_opt_ PVOID Context, _In_opt_ PVOID EntryContext)
NTSTATUS NTAPI	RequestMcnSyncIrpCompletion (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_reads_opt_(_Inexpressible_("varies")) PVOID Context)
VOID	RequestSetupMcnSyncIrp (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension)
VOID NTAPI	DeviceMainTimerTickHandler (_In_ WDFTIMER Timer)

Variables
IO_COMPLETION_ROUTINE	RequestMcnSyncIrpCompletion

Macro Definition Documentation

GESN_BUFFER_SIZE

#define GESN_BUFFER_SIZE   (0x8)

Definition at line 40 of file autorun.c.

GESN_DEVICE_BUSY_LOWER_THRESHOLD_100_MS

#define GESN_DEVICE_BUSY_LOWER_THRESHOLD_100_MS   (2)

Definition at line 41 of file autorun.c.

GESN_TIMEOUT_VALUE

#define GESN_TIMEOUT_VALUE   (0x4)

Definition at line 39 of file autorun.c.

MAXIMUM_IMMEDIATE_MCN_RETRIES

#define MAXIMUM_IMMEDIATE_MCN_RETRIES   (0x20)

Definition at line 43 of file autorun.c.

MCN_REG_AUTORUN_DISABLE_INSTANCE_NAME

#define MCN_REG_AUTORUN_DISABLE_INSTANCE_NAME   (L"AlwaysDisableMCN")

Definition at line 45 of file autorun.c.

MCN_REG_AUTORUN_ENABLE_INSTANCE_NAME

#define MCN_REG_AUTORUN_ENABLE_INSTANCE_NAME   (L"AlwaysEnableMCN")

Definition at line 46 of file autorun.c.

MCN_REG_SUBKEY_NAME

#define MCN_REG_SUBKEY_NAME   (L"MediaChangeNotification")

Definition at line 44 of file autorun.c.

Function Documentation

_IRQL_requires_max_() [1/3]

_IRQL_requires_max_

(

_IRQL_requires_max_()BOOLEANDeviceIsMediaChangeDisabledForClass( _In_ PCDROM_DEVICE_EXTENSION DeviceExtension )

PASSIVE_LEVEL

)

Definition at line 66 of file autorun.c.

                       :4152) // nonstandard extension, function/data pointer conversion in expression


_IRQL_requires_max_(APC_LEVEL)
NTSTATUS
GesnDataInterpret(
    _In_  PCDROM_DEVICE_EXTENSION             DeviceExtension,
    _In_  PNOTIFICATION_EVENT_STATUS_HEADER   Header,
    _Out_ PBOOLEAN                            ResendImmediately
    )
/*++

Routine Description:

    This routine will interpret the data returned for a GESN command, and
    (if appropriate) set the media change event, and broadcast the
    appropriate events to user mode for applications who care.

Arguments:

    DeviceExtension - the device extension

    Header - the resulting data from a GESN event.
        requires at least EIGHT valid bytes (header == 4, data == 4)

    ResendImmediately - whether or not to immediately resend the request.
        this should be FALSE if there was no event, FALSE if the reported
        event was of the DEVICE BUSY class, else true.

Return Value:

    STATUS_SUCCESS if successful, an error code otherwise

Notes:

    DataBuffer must be at least four bytes of valid data (header == 4 bytes),
    and have at least eight bytes of allocated memory (all events == 4 bytes).

    The call to StartNextPacket may occur before this routine is completed.
    the operational change notifications are informational in nature, and
    while useful, are not neccessary to ensure proper operation.  For example,
    if the device morphs to no longer supporting WRITE commands, all further
    write commands will fail.  There exists a small timing window wherein
    IOCTL_IS_DISK_WRITABLE may be called and get an incorrect response.  If
    a device supports software write protect, it is expected that the
    application can handle such a case.

    NOTE: perhaps setting the updaterequired byte to one should be done here.
    if so, it relies upon the setting of a 32-byte value to be an atomic
    operation.  unfortunately, there is no simple way to notify a class driver
    which wants to know that the device behavior requires updating.

    Not ready events may be sent every second.  For example, if we were
    to minimize the number of asynchronous notifications, an application may
    register just after a large busy time was reported.  This would then
    prevent the application from knowing the device was busy until some
    arbitrarily chosen timeout has occurred.  Also, the GESN request would
    have to still occur, since it checks for non-busy events (such as user
    keybutton presses and media change events) as well.  The specification
    states that the lower-numered events get reported first, so busy events,
    while repeating, will only be reported when all other events have been
    cleared from the device.

--*/
{
    NTSTATUS                        status = STATUS_SUCCESS;
    PMEDIA_CHANGE_DETECTION_INFO    info = DeviceExtension->MediaChangeDetectionInfo;
    LONG                            dataLength = 0;
    LONG                            requiredLength = 0;
    BOOLEAN                         inHomePosition = FALSE;

    PAGED_CODE();

    // note: don't allocate anything in this routine so that we can
    //       always just 'return'.
    *ResendImmediately = FALSE;

    if (Header->NEA)
    {
        return status;
    }
    if (Header->NotificationClass == NOTIFICATION_NO_CLASS_EVENTS)
    {
        return status;
    }

    // HACKHACK - REF #0001
    // This loop is only taken initially, due to the inability to reliably
    // auto-detect drives that report events correctly at boot.  When we
    // detect this behavior during the normal course of running, we will
    // disable the hack, allowing more efficient use of the system.  This
    // should occur "nearly" instantly, as the drive should have multiple
    // events queue'd (ie. power, morphing, media).
    if (info->Gesn.HackEventMask)
    {
        // all events use the low four bytes of zero to indicate
        // that there was no change in status.
        UCHAR thisEvent = Header->ClassEventData[0] & 0xf;
        UCHAR lowestSetBit;
        UCHAR thisEventBit = (1 << Header->NotificationClass);

        if (!TEST_FLAG(info->Gesn.EventMask, thisEventBit))
        {
            // The drive is reporting an event that wasn't requested
            return STATUS_DEVICE_PROTOCOL_ERROR;
        }

        // some bit magic here... this results in the lowest set bit only
        lowestSetBit = info->Gesn.EventMask;
        lowestSetBit &= (info->Gesn.EventMask - 1);
        lowestSetBit ^= (info->Gesn.EventMask);

        if (thisEventBit != lowestSetBit)
        {
            // HACKHACK - REF #0001
            // the first time we ever see an event set that is not the lowest
            // set bit in the request (iow, highest priority), we know that the
            // hack is no longer required, as the device is ignoring "no change"
            // events when a real event is waiting in the other requested queues.
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                       "GESN::NONE: Compliant drive found, "
                       "removing GESN hack (%x, %x)\n",
                       thisEventBit, info->Gesn.EventMask));

            info->Gesn.HackEventMask = FALSE;
        }
        else if (thisEvent == 0)  // NOTIFICATION_*_EVENT_NO_CHANGE
        {
            // HACKHACK - REF #0001
            // note: this hack prevents poorly implemented firmware from constantly
            //       returning "No Event".  we do this by cycling through the
            //       supported list of events here.
            SET_FLAG(info->Gesn.NoChangeEventMask, thisEventBit);
            CLEAR_FLAG(info->Gesn.EventMask, thisEventBit);

            // if we have cycled through all supported event types, then
            // we need to reset the events we are asking about. else we
            // want to resend this request immediately in case there was
            // another event pending.
            if (info->Gesn.EventMask == 0)
            {
                info->Gesn.EventMask         = info->Gesn.NoChangeEventMask;
                info->Gesn.NoChangeEventMask = 0;
            }
            else
            {
                *ResendImmediately = TRUE;
            }
            return status;
        }

    } // end if (info->Gesn.HackEventMask)

    dataLength = (Header->EventDataLength[0] << 8) |
                 (Header->EventDataLength[1] & 0xff);
    dataLength -= 2;
    requiredLength = 4; // all events are four bytes

    if (dataLength < requiredLength)
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN,
                   "error - GESN returned only %x bytes data for fdo %p\n",
                   dataLength, DeviceExtension->DeviceObject));

        return STATUS_DEVICE_PROTOCOL_ERROR;
    }

    if (dataLength > requiredLength)
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN,
                   "error - GESN returned too many (%x) bytes data for fdo %p\n",
                   dataLength, DeviceExtension->DeviceObject));
    }

    if ((Header->ClassEventData[0] & 0xf) == 0)
    {
        // a zero event is a "no change event, so do not retry
        return status;
    }

    // because a event other than "no change" occurred,
    // we should immediately resend this request.
    *ResendImmediately = TRUE;

    switch (Header->NotificationClass)
    {

    case NOTIFICATION_OPERATIONAL_CHANGE_CLASS_EVENTS:  // 0x01
    {
        PNOTIFICATION_OPERATIONAL_STATUS opChangeInfo =
                                            (PNOTIFICATION_OPERATIONAL_STATUS)(Header->ClassEventData);
        ULONG event;

        if (opChangeInfo->OperationalEvent == NOTIFICATION_OPERATIONAL_EVENT_CHANGE_REQUESTED)
        {
            break;
        }

        event = (opChangeInfo->Operation[0] << 8) |
                (opChangeInfo->Operation[1]     ) ;

        // Workaround some hardware that is buggy but prevalent in the market
        // This hardware has the property that it will report OpChange events repeatedly,
        // causing us to retry immediately so quickly that we will eventually disable
        // GESN to prevent an infinite loop.
        // (only one valid OpChange event type now, only two ever defined)
        if (info->MediaChangeRetryCount >= 4)
        {
            //
            // HACKHACK - REF #0002
            // Some drives incorrectly report OpChange/Change (001b/0001h) events
            // continuously when the tray has been ejected.  This causes this routine
            // to set ResendImmediately to "TRUE", and that results in our cycling
            // 32 times immediately resending.  At that point, we give up detecting
            // the infinite retry loop, and disable GESN on these drives.  This
            // prevents Media Eject Request (from eject button) from being reported.
            // Thus, instead we should attempt to workaround this issue by detecting
            // this behavior.
            //

            static UCHAR const OpChangeMask = 0x02;

            // At least one device reports "temporarily busy" (which is useless) on eject
            // At least one device reports "OpChange" repeatedly when re-inserting media
            // All seem to work well using this workaround

            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_MCN,
                        "GESN OpChange events are broken.  Working around this problem in software (for WDFDEVICE %p)\n",
                        DeviceExtension->Device));

            // OpChange is not the only bit set -- Media class is required....
            NT_ASSERT(CountOfSetBitsUChar(info->Gesn.EventMask) != 1);

            // Force the use of the hackhack (ref #0001) to workaround the
            // issue noted this hackhack (ref #0002).
            SET_FLAG(info->Gesn.NoChangeEventMask, OpChangeMask);
            CLEAR_FLAG(info->Gesn.EventMask, OpChangeMask);
            info->Gesn.HackEventMask = TRUE;

            // don't request the opChange event again.  use the method
            // defined by hackhack (ref #0001) as the workaround.
            if (info->Gesn.EventMask == 0)
            {
                info->Gesn.EventMask = info->Gesn.NoChangeEventMask;
                info->Gesn.NoChangeEventMask = 0;
                *ResendImmediately = FALSE;
            }
            else
            {
                *ResendImmediately = TRUE;
            }

            break;
        }


        if ((event == NOTIFICATION_OPERATIONAL_OPCODE_FEATURE_ADDED) |
            (event == NOTIFICATION_OPERATIONAL_OPCODE_FEATURE_CHANGE))
        {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                       "GESN says features added/changed for WDFDEVICE %p\n",
                       DeviceExtension->Device));

            // don't notify that new media arrived, just set the
            // DO_VERIFY to force a FS reload.

            if (IsVolumeMounted(DeviceExtension->DeviceObject))
            {
                SET_FLAG(DeviceExtension->DeviceObject->Flags, DO_VERIFY_VOLUME);
            }

            // Call error handler with
            // a "fake" media change error in case it needs to update
            // internal structures as though a media change occurred.
            {
                SCSI_REQUEST_BLOCK  srb = {0};
                SENSE_DATA          sense = {0};
                NTSTATUS            tempStatus;
                BOOLEAN             retry;

                tempStatus = STATUS_MEDIA_CHANGED;
                retry = FALSE;

                srb.CdbLength = 6;
                srb.Length    = sizeof(SCSI_REQUEST_BLOCK);
                srb.SrbStatus = SRB_STATUS_AUTOSENSE_VALID | SRB_STATUS_ERROR;
                srb.SenseInfoBuffer = &sense;
                srb.SenseInfoBufferLength = sizeof(SENSE_DATA);

                sense.AdditionalSenseLength = sizeof(SENSE_DATA) -
                                            RTL_SIZEOF_THROUGH_FIELD(SENSE_DATA, AdditionalSenseLength);

                sense.SenseKey = SCSI_SENSE_UNIT_ATTENTION;
                sense.AdditionalSenseCode = SCSI_ADSENSE_MEDIUM_CHANGED;

                if (DeviceExtension->DeviceAdditionalData.ErrorHandler)
                {
                    DeviceExtension->DeviceAdditionalData.ErrorHandler(DeviceExtension,
                                                                       &srb,
                                                                       &tempStatus,
                                                                       &retry);
                }
            } // end error handler

        }
        break;
    }

    case NOTIFICATION_EXTERNAL_REQUEST_CLASS_EVENTS:  // 0x3
    {
        PNOTIFICATION_EXTERNAL_STATUS externalInfo =
                                        (PNOTIFICATION_EXTERNAL_STATUS)(Header->ClassEventData);
        DEVICE_EVENT_EXTERNAL_REQUEST externalData = {0};

        // unfortunately, due to time constraints, we will only notify
        // about keys being pressed, and not released.  this makes keys
        // single-function, but simplifies the code significantly.
        if (externalInfo->ExternalEvent != NOTIFICATION_EXTERNAL_EVENT_BUTTON_DOWN)
        {
            break;
        }

        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                   "GESN::EXTERNAL: Event: %x Status %x Req %x\n",
                   externalInfo->ExternalEvent, externalInfo->ExternalStatus,
                   (externalInfo->Request[0] << 8) | externalInfo->Request[1]
                   ));

        externalData.Version = 1;
        externalData.DeviceClass = 0;
        externalData.ButtonStatus = externalInfo->ExternalEvent;
        externalData.Request = (externalInfo->Request[0] << 8) |
                               (externalInfo->Request[1] & 0xff);
        KeQuerySystemTime(&(externalData.SystemTime));
        externalData.SystemTime.QuadPart *= (LONGLONG)KeQueryTimeIncrement();

        DeviceSendNotification(DeviceExtension,
                               &GUID_IO_DEVICE_EXTERNAL_REQUEST,
                               sizeof(DEVICE_EVENT_EXTERNAL_REQUEST),
                               &externalData);

        return status;
    }

    case NOTIFICATION_MEDIA_STATUS_CLASS_EVENTS:  // 0x4
    {
        PNOTIFICATION_MEDIA_STATUS mediaInfo =
                                    (PNOTIFICATION_MEDIA_STATUS)(Header->ClassEventData);

        if ((mediaInfo->MediaEvent == NOTIFICATION_MEDIA_EVENT_NEW_MEDIA) ||
            (mediaInfo->MediaEvent == NOTIFICATION_MEDIA_EVENT_MEDIA_CHANGE))
        {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                       "GESN::MEDIA ARRIVAL, Status %x\n",
                       mediaInfo->MediaStatus));

            if (IsVolumeMounted(DeviceExtension->DeviceObject))
            {
                SET_FLAG(DeviceExtension->DeviceObject->Flags, DO_VERIFY_VOLUME);
            }
            DeviceSetMediaChangeStateEx(DeviceExtension,
                                        MediaPresent,
                                        NULL);

            // If media is inserted into slot loading type, mark the device active
            // to not power off.
            if ((DeviceExtension->ZeroPowerODDInfo != NULL) &&
                (DeviceExtension->ZeroPowerODDInfo->LoadingMechanism == LOADING_MECHANISM_CADDY) &&
                (DeviceExtension->ZeroPowerODDInfo->Load == 0))                                     // Slot
            {
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_POWER,
                           "GesnDataInterpret: MediaArrival event detected, device marked as active\n"));

                DeviceMarkActive(DeviceExtension, TRUE, FALSE);
            }
        }
        else if (mediaInfo->MediaEvent == NOTIFICATION_MEDIA_EVENT_MEDIA_REMOVAL)
        {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                       "GESN::MEDIA REMOVAL, Status %x\n",
                       mediaInfo->MediaStatus));

            DeviceSetMediaChangeStateEx(DeviceExtension,
                                        MediaNotPresent,
                                        NULL);

            // If media is removed from slot loading type, start powering off the device
            // if it is ZPODD capable.
            if ((DeviceExtension->ZeroPowerODDInfo != NULL) &&
                (DeviceExtension->ZeroPowerODDInfo->LoadingMechanism == LOADING_MECHANISM_CADDY) &&
                (DeviceExtension->ZeroPowerODDInfo->Load == 0))                                    // Slot
            {
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_POWER,
                           "GesnDataInterpret: MediaRemoval event detected, device marked as idle\n"));

                DeviceMarkActive(DeviceExtension, FALSE, FALSE);
            }
        }
        else if (mediaInfo->MediaEvent == NOTIFICATION_MEDIA_EVENT_EJECT_REQUEST)
        {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                       "GESN::MEDIA EJECTION, Status %x\n",
                       mediaInfo->MediaStatus));

            DeviceSendNotification(DeviceExtension,
                                   &GUID_IO_MEDIA_EJECT_REQUEST,
                                   0,
                                   NULL);
        }

        break;
    }

    case NOTIFICATION_DEVICE_BUSY_CLASS_EVENTS:  // lowest priority events...
    {
        PNOTIFICATION_BUSY_STATUS busyInfo =
                                    (PNOTIFICATION_BUSY_STATUS)(Header->ClassEventData);
        DEVICE_EVENT_BECOMING_READY busyData = {0};

        // else we want to report the approximated time till it's ready.
        busyData.Version = 1;
        busyData.Reason = busyInfo->DeviceBusyStatus;
        busyData.Estimated100msToReady = (busyInfo->Time[0] << 8) |
                                         (busyInfo->Time[1] & 0xff);

        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                   "GESN::BUSY: Event: %x Status %x Time %x\n",
                   busyInfo->DeviceBusyEvent, busyInfo->DeviceBusyStatus,
                   busyData.Estimated100msToReady
                   ));

        // Ignore the notification if the time is small
        if (busyData.Estimated100msToReady >= GESN_DEVICE_BUSY_LOWER_THRESHOLD_100_MS)
        {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                       "GesnDataInterpret: media BECOMING_READY\n"));

            DeviceSendNotification(DeviceExtension,
                                   &GUID_IO_DEVICE_BECOMING_READY,
                                   sizeof(DEVICE_EVENT_BECOMING_READY),
                                   &busyData);
        }

        // If manual loading operation is observed for slot loading type, start powering off the device
        // if it is ZPODD capable.
        if ((DeviceExtension->ZeroPowerODDInfo != NULL) &&
            (DeviceExtension->ZeroPowerODDInfo->LoadingMechanism == LOADING_MECHANISM_TRAY) &&
            (DeviceExtension->ZeroPowerODDInfo->Load == 0) &&                                   // Drawer
            (busyInfo->DeviceBusyEvent == NOTIFICATION_BUSY_EVENT_LO_CHANGE) &&
            (busyInfo->DeviceBusyStatus == NOTIFICATION_BUSY_STATUS_NO_EVENT))
        {
            inHomePosition = DeviceZPODDIsInHomePosition(DeviceExtension);

            if (inHomePosition == FALSE)
            {
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_POWER,
                           "GesnDataInterpret: LoChange event detected, device marked as active\n"));

                DeviceMarkActive(DeviceExtension, TRUE, FALSE);
            }
            else
            {
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_POWER,
                           "GesnDataInterpret: LoChange event detected, device marked as idle\n"));

                DeviceMarkActive(DeviceExtension, FALSE, FALSE);
            }
        }

        break;
    }

    default:
    {
        break;
    }

    } // end switch on notification class

    return status;
}

_IRQL_requires_max_() [2/3]

_IRQL_requires_max_

(

APC_LEVEL

)

Definition at line 812 of file autorun.c.

{
    PMEDIA_CHANGE_DETECTION_INFO info = DeviceExtension->MediaChangeDetectionInfo;
    LARGE_INTEGER                zero;
    NTSTATUS                     status;

    PAGED_CODE();

    zero.QuadPart = 0;

    if (info == NULL)
    {
        return;
    }

    status = KeWaitForMutexObject(&info->MediaChangeMutex,
                                  Executive,
                                  KernelMode,
                                  FALSE,
                                  &zero);

    if (status == STATUS_TIMEOUT)
    {
        // Someone else is in the process of setting the media state.
        // That's totally okay, we'll send delayed notifications later.
        return;
    }

    // If the last reported state and the last known state are different and
    // MCN is enabled, generate a notification based on the last known state.
    if ((info->LastKnownMediaDetectionState != info->LastReportedMediaDetectionState) &&
        (info->MediaChangeDetectionDisableCount == 0))
    {
        DeviceInternalSetMediaChangeState(DeviceExtension, info->LastKnownMediaDetectionState, NULL);
    }

    KeReleaseMutex(&info->MediaChangeMutex, FALSE);

    return;
}

_IRQL_requires_max_() [3/3]

_IRQL_requires_max_

(

PASSIVE_LEVEL

)

Definition at line 1258 of file autorun.c.

{
    NTSTATUS                        status = STATUS_SUCCESS;
    PMEDIA_CHANGE_DETECTION_INFO    mediaChangeInfo = NULL;
    PIRP                            irp = NULL;
    PVOID                           senseBuffer = NULL;
    WDF_OBJECT_ATTRIBUTES           attributes;

    PAGED_CODE();

    if (DeviceExtension->MediaChangeDetectionInfo != NULL)
    {
        //Already initialized.
        return STATUS_SUCCESS;
    }

    DeviceExtension->KernelModeMcnContext.FileObject      = (PVOID)-1;
    DeviceExtension->KernelModeMcnContext.DeviceObject    = (PVOID)-1;
    DeviceExtension->KernelModeMcnContext.LockCount       = 0;
    DeviceExtension->KernelModeMcnContext.McnDisableCount = 0;

    mediaChangeInfo = ExAllocatePoolWithTag(NonPagedPoolNx,
                                            sizeof(MEDIA_CHANGE_DETECTION_INFO),
                                            CDROM_TAG_MEDIA_CHANGE_DETECTION);

    if (mediaChangeInfo == NULL)
    {
        status = STATUS_INSUFFICIENT_RESOURCES;
    }
    else
    {
        RtlZeroMemory(mediaChangeInfo, sizeof(MEDIA_CHANGE_DETECTION_INFO));
    }

    if (NT_SUCCESS(status))
    {
        if ((DeviceExtension->PowerDescriptor != NULL) &&
            (DeviceExtension->PowerDescriptor->AsynchronousNotificationSupported != FALSE) &&
            (!TEST_FLAG(DeviceExtension->PrivateFdoData->HackFlags, FDO_HACK_NO_ASYNCHRONOUS_NOTIFICATION)))
        {
            mediaChangeInfo->AsynchronousNotificationSupported = TRUE;
        }
    }

    //  Allocate an IRP to carry the IOCTL_MCN_SYNC_FAKE_IOCTL.
    if (NT_SUCCESS(status))
    {
        irp = IoAllocateIrp(DeviceExtension->DeviceObject->StackSize, FALSE);

        if (irp == NULL)
        {
            status = STATUS_INSUFFICIENT_RESOURCES;
        }
    }

    if (NT_SUCCESS(status))
    {
        WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes,
                                                CDROM_REQUEST_CONTEXT);
        attributes.ParentObject = DeviceExtension->Device;
        status = WdfRequestCreate(&attributes,
                                  DeviceExtension->IoTarget,
                                  &mediaChangeInfo->MediaChangeRequest);
    }

    if (NT_SUCCESS(status))
    {
        // Preformat the media change request. With this being done, we never need to worry about
        // WdfIoTargetFormatRequestForInternalIoctlOthers ever failing later.
        status = WdfIoTargetFormatRequestForInternalIoctlOthers(DeviceExtension->IoTarget,
                                                                mediaChangeInfo->MediaChangeRequest,
                                                                IOCTL_SCSI_EXECUTE_IN,
                                                                NULL, NULL,
                                                                NULL, NULL,
                                                                NULL, NULL);
    }

    if (NT_SUCCESS(status))
    {
        senseBuffer = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
                                            SENSE_BUFFER_SIZE,
                                            CDROM_TAG_MEDIA_CHANGE_DETECTION);
        if (senseBuffer == NULL)
        {
            status = STATUS_INSUFFICIENT_RESOURCES;
        }
    }

    if (NT_SUCCESS(status))
    {
        mediaChangeInfo->MediaChangeSyncIrp = irp;
        mediaChangeInfo->SenseBuffer = senseBuffer;

        // Set default values for the media change notification
        // configuration.
        mediaChangeInfo->MediaChangeDetectionDisableCount = 0;

        // Assume that there is initially no media in the device
        // only notify upper layers if there is something there
        mediaChangeInfo->LastKnownMediaDetectionState = MediaUnknown;
        mediaChangeInfo->LastReportedMediaDetectionState = MediaUnknown;

        // setup all extra flags we'll be setting for this irp
        mediaChangeInfo->SrbFlags = 0;

        SET_FLAG(mediaChangeInfo->SrbFlags, SRB_CLASS_FLAGS_LOW_PRIORITY);
        SET_FLAG(mediaChangeInfo->SrbFlags, SRB_FLAGS_NO_QUEUE_FREEZE);
        SET_FLAG(mediaChangeInfo->SrbFlags, SRB_FLAGS_DISABLE_SYNCH_TRANSFER);

        if (AllowDriveToSleep)  //FALSE for CD/DVD devices
        {
            SET_FLAG(mediaChangeInfo->SrbFlags, SRB_FLAGS_NO_KEEP_AWAKE);
        }

        KeInitializeMutex(&mediaChangeInfo->MediaChangeMutex, 0x100);

        // It is ok to support media change events on this device.
        DeviceExtension->MediaChangeDetectionInfo = mediaChangeInfo;

        // check the device supports GESN or not, initialize GESN structure if it supports.
        {
            // This is only valid for type5 devices.
            NTSTATUS tempStatus = STATUS_SUCCESS;

            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                       "DeviceInitializeMcn: Testing for GESN\n"));
            tempStatus = DeviceInitializeGesn(DeviceExtension);

            if (NT_SUCCESS(tempStatus))
            {
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                           "DeviceInitializeMcn: GESN available for %p\n",
                           DeviceExtension->DeviceObject));
                NT_ASSERT(mediaChangeInfo->Gesn.Supported );
                NT_ASSERT(mediaChangeInfo->Gesn.Buffer     != NULL);
                NT_ASSERT(mediaChangeInfo->Gesn.BufferSize != 0);
                NT_ASSERT(mediaChangeInfo->Gesn.EventMask  != 0);
            }
            else
            {
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                           "DeviceInitializeMcn: GESN *NOT* available for %p\n",
                           DeviceExtension->DeviceObject));
                NT_ASSERT(!mediaChangeInfo->Gesn.Supported);
                NT_ASSERT(mediaChangeInfo->Gesn.Buffer == NULL);
                NT_ASSERT(mediaChangeInfo->Gesn.BufferSize == 0);
                NT_ASSERT(mediaChangeInfo->Gesn.EventMask  == 0);
                mediaChangeInfo->Gesn.Supported = FALSE; // just in case....
            }
        }
    }

    if (NT_SUCCESS(status))
    {
        // Register for display state change on AOAC capable systems so we can put the
        // device to low power state when not required.
        if (mediaChangeInfo->DisplayStateCallbackHandle == NULL)
        {
            POWER_PLATFORM_INFORMATION PlatformInfo = {0};

            status = ZwPowerInformation(PlatformInformation,
                                        NULL,
                                        0,
                                        &PlatformInfo,
                                        sizeof(PlatformInfo));

            if (NT_SUCCESS(status) && PlatformInfo.AoAc)
            {
                PoRegisterPowerSettingCallback(DeviceExtension->DeviceObject,
                                               &GUID_CONSOLE_DISPLAY_STATE,
                                               &DevicePowerSettingCallback,
                                               DeviceExtension,
                                               &mediaChangeInfo->DisplayStateCallbackHandle);
            }

            // Ignore any failures above.
            status = STATUS_SUCCESS;
        }
    }

    if (!NT_SUCCESS(status))
    {
        if (irp != NULL)
        {
            IoFreeIrp(irp);
        }
        FREE_POOL(senseBuffer);
        FREE_POOL(mediaChangeInfo);
    }

    return status;

} // end DeviceInitializeMcn()

DeviceDisableGesn()

VOID NTAPI DeviceDisableGesn

(

_In_ WDFWORKITEM

WorkItem

)

Definition at line 1019 of file autorun.c.

{
    WDFDEVICE               device = WdfWorkItemGetParentObject(WorkItem);
    PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(device);

    PAGED_CODE();

    //
    // Set the hack flag in the registry
    //
    DeviceSetParameter(deviceExtension,
                       CLASSP_REG_SUBKEY_NAME,
                       CLASSP_REG_MMC_DETECTION_VALUE_NAME,
                       CdromDetectionUnsupported);

    WdfObjectDelete(WorkItem);

    return;
}

DeviceInternalSetMediaChangeState()

VOID DeviceInternalSetMediaChangeState	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ MEDIA_CHANGE_DETECTION_STATE	NewState,
		_Inout_opt_ PMEDIA_CHANGE_DETECTION_STATE	OldState
	)

Definition at line 630 of file autorun.c.

{
#if DBG
    LPCSTR states[] = {"Unknown", "Present", "Not Present", "Unavailable"};
#endif
    MEDIA_CHANGE_DETECTION_STATE oldMediaState;
    PMEDIA_CHANGE_DETECTION_INFO info = DeviceExtension->MediaChangeDetectionInfo;
    CLASS_MEDIA_CHANGE_CONTEXT   mcnContext;

    if (!((NewState >= MediaUnknown) && (NewState <= MediaUnavailable)))
    {
        return;
    }

    if (info == NULL)
    {
        return;
    }

    oldMediaState = info->LastKnownMediaDetectionState;
    if (OldState)
    {
        *OldState = oldMediaState;
    }

    info->LastKnownMediaDetectionState = NewState;

    // Increment MediaChangeCount on transition to MediaPresent
    if (NewState == MediaPresent && oldMediaState != NewState)
    {
        InterlockedIncrement((PLONG)&DeviceExtension->MediaChangeCount);
    }

    if (info->MediaChangeDetectionDisableCount != 0)
    {
#if DBG
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                    "DeviceInternalSetMediaChangeState: MCN not enabled, state "
                    "changed from %s to %s\n",
                    states[oldMediaState], states[NewState]));
#endif
        return;
    }
#if DBG
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                "DeviceInternalSetMediaChangeState: State change from %s to %s\n",
                states[oldMediaState], states[NewState]));
#endif

    if (info->LastReportedMediaDetectionState == info->LastKnownMediaDetectionState)
    {
        // Media is in the same state as we reported last time, no need to report again.
        return;
    }

    // make the data useful -- it used to always be zero.
    mcnContext.MediaChangeCount = DeviceExtension->MediaChangeCount;
    mcnContext.NewState = NewState;

    if (NewState == MediaPresent)
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                   "DeviceInternalSetMediaChangeState: Reporting media ARRIVAL\n"));

        DeviceSendNotification(DeviceExtension,
                               &GUID_IO_MEDIA_ARRIVAL,
                               sizeof(CLASS_MEDIA_CHANGE_CONTEXT),
                               &mcnContext);
    }
    else if ((NewState == MediaNotPresent) || (NewState == MediaUnavailable))
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                   "DeviceInternalSetMediaChangeState: Reporting media REMOVAL\n"));
        DeviceSendNotification(DeviceExtension,
                               &GUID_IO_MEDIA_REMOVAL,
                               sizeof(CLASS_MEDIA_CHANGE_CONTEXT),
                               &mcnContext);
    }
    else
    {
        // Don't notify of changed going to unknown.
        return;
    }

    info->LastReportedMediaDetectionState = info->LastKnownMediaDetectionState;

    return;
} // end DeviceInternalSetMediaChangeState()

Referenced by _IRQL_requires_max_(), and DeviceSetMediaChangeStateEx().

DeviceMainTimerTickHandler()

VOID NTAPI DeviceMainTimerTickHandler

(

_In_ WDFTIMER

Timer

)

Definition at line 2820 of file autorun.c.

{
    PCDROM_DEVICE_EXTENSION      deviceExtension = NULL;
    size_t                       dataLength = 0;

    deviceExtension = WdfObjectGetTypedContext(WdfTimerGetParentObject(Timer), CDROM_DEVICE_EXTENSION);

    (void) RequestHandleEventNotification(deviceExtension, NULL, NULL, &dataLength);

    return;
} // end DeviceMainTimerTickHandler()

DeviceMediaChangeRegistryCallBack()

NTSTATUS NTAPI DeviceMediaChangeRegistryCallBack	(	_In_z_ PWSTR	ValueName,
		_In_ ULONG	ValueType,
		_In_reads_bytes_opt_(ValueLength) PVOID	ValueData,
		_In_ ULONG	ValueLength,
		_In_opt_ PVOID	Context,
		_In_opt_ PVOID	EntryContext
	)

Definition at line 2058 of file autorun.c.

{
    PULONG          valueFound;
    PUNICODE_STRING deviceString;
    PWSTR           keyValue;

    PAGED_CODE();

    UNREFERENCED_PARAMETER(ValueName);

    if ((Context == NULL) || (EntryContext == NULL))
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN,
                   "DeviceMediaChangeRegistryCallBack: NULL context should never be passed to registry call-back!\n"));

        return STATUS_SUCCESS;
    }

    // if we have already set the value to true, exit
    valueFound = EntryContext;
    if ((*valueFound) != 0)
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                   "DeviceMediaChangeRegistryCallBack: already set to true\n"));
        return STATUS_SUCCESS;
    }

    if (ValueLength == sizeof(WCHAR))
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN,
                   "DeviceMediaChangeRegistryCallBack: NULL string should never be passed to registry call-back!\n"));
        return STATUS_SUCCESS;
    }

    // if the data is not a terminated string, exit
    if (ValueType != REG_SZ)
    {
        return STATUS_SUCCESS;
    }

    deviceString = Context;
    keyValue = ValueData;
    ValueLength -= sizeof(WCHAR); // ignore the null character

    // do not compare more memory than is in deviceString
    if (ValueLength > deviceString->Length)
    {
        ValueLength = deviceString->Length;
    }

    if (keyValue == NULL)
    {
        return STATUS_SUCCESS;
    }

    // if the strings match, disable autorun
    if (RtlCompareMemory(deviceString->Buffer, keyValue, ValueLength) == ValueLength)
    {
        TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_MCN, "DeviceMediaChangeRegistryCallBack: Match found\n"));
        TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_MCN, "DeviceMediaChangeRegistryCallBack: DeviceString at %p\n",
                    deviceString->Buffer));
        TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_MCN,
                    "DeviceMediaChangeRegistryCallBack: KeyValue at %p\n",
                    keyValue));
        (*valueFound) = TRUE;
    }

    return STATUS_SUCCESS;
} // end DeviceMediaChangeRegistryCallBack()

DeviceSetMediaChangeStateEx()

VOID DeviceSetMediaChangeStateEx	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ MEDIA_CHANGE_DETECTION_STATE	NewState,
		_Inout_opt_ PMEDIA_CHANGE_DETECTION_STATE	OldState
	)

Definition at line 751 of file autorun.c.

{
    PMEDIA_CHANGE_DETECTION_INFO info = DeviceExtension->MediaChangeDetectionInfo;
    LARGE_INTEGER                zero;
    NTSTATUS                     status;

    // timeout value must be 0, as this function can be called at DISPATCH_LEVEL.
    zero.QuadPart = 0;

    if (info == NULL)
    {
        return;
    }

    status = KeWaitForMutexObject(&info->MediaChangeMutex,
                                Executive,
                                KernelMode,
                                FALSE,
                                &zero);

    if (status == STATUS_TIMEOUT)
    {
        // Someone else is in the process of setting the media state.
        return;
    }

    // Change the media present state and signal an event, if applicable
    DeviceInternalSetMediaChangeState(DeviceExtension, NewState, OldState);

    KeReleaseMutex(&info->MediaChangeMutex, FALSE);

    return;
} // end DeviceSetMediaChangeStateEx()

Referenced by DeviceEvtSelfManagedIoInit(), and SenseInfoInterpretByAdditionalSenseCode().

RequestMcnSyncIrpCompletion()

NTSTATUS NTAPI RequestMcnSyncIrpCompletion	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp,
		_In_reads_opt_(_Inexpressible_("varies")) PVOID	Context
	)

Definition at line 2695 of file autorun.c.

{
    PCDROM_DEVICE_EXTENSION DeviceExtension = NULL;
    PMEDIA_CHANGE_DETECTION_INFO info = NULL;

    if (Context == NULL)
    {
        // this will never happen, but code must be there to prevent OACR warnings.
        return STATUS_MORE_PROCESSING_REQUIRED;
    }

    DeviceExtension = (PCDROM_DEVICE_EXTENSION) Context;
    info = DeviceExtension->MediaChangeDetectionInfo;

#ifndef DEBUG
    UNREFERENCED_PARAMETER(Irp);
#endif
    UNREFERENCED_PARAMETER(DeviceObject);

    NT_ASSERT(Irp == info->MediaChangeSyncIrp);

    IoReuseIrp(info->MediaChangeSyncIrp, STATUS_NOT_SUPPORTED);

    // reset the value to let timer routine be able to send the next request.
    InterlockedCompareExchange((PLONG)&(info->MediaChangeRequestInUse), 0, 1);

    return STATUS_MORE_PROCESSING_REQUIRED;
}

RequestSetupMcnSyncIrp()

VOID RequestSetupMcnSyncIrp

(

_In_ PCDROM_DEVICE_EXTENSION

DeviceExtension

)

Definition at line 2749 of file autorun.c.

{
    PIRP                irp = NULL;
    PIO_STACK_LOCATION  irpStack = NULL;
    PIO_STACK_LOCATION  nextIrpStack = NULL;

    irp = DeviceExtension->MediaChangeDetectionInfo->MediaChangeSyncIrp;
    NT_ASSERT(irp != NULL);

    //
    //  For the driver that creates an IRP, there is no 'current' stack location.
    //  Step down one IRP stack location so that the extra top one
    //  becomes our 'current' one.
    //
    IoSetNextIrpStackLocation(irp);

    /*
     *  Cache our device object in the extra top IRP stack location
     *  so we have it in our completion routine.
     */
    irpStack = IoGetCurrentIrpStackLocation(irp);
    irpStack->DeviceObject = DeviceExtension->DeviceObject;

    //
    // If the irp is sent down when the volume needs to be
    // verified, CdRomUpdateGeometryCompletion won't complete
    // it since it's not associated with a thread.  Marking
    // it to override the verify causes it always be sent
    // to the port driver
    //
    nextIrpStack = IoGetNextIrpStackLocation(irp);

    SET_FLAG(nextIrpStack->Flags, SL_OVERRIDE_VERIFY_VOLUME);

    nextIrpStack->MajorFunction = IRP_MJ_DEVICE_CONTROL;
    // pick up this IOCTL code as it's not normaly seen for CD/DVD drive and does not require input.
    // set other fields to make this IOCTL recognizable by CDROM.SYS
    nextIrpStack->Parameters.Others.Argument1 = RequestSetupMcnSyncIrp;
    nextIrpStack->Parameters.Others.Argument2 = RequestSetupMcnSyncIrp;
    nextIrpStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_MCN_SYNC_FAKE_IOCTL; //Argument3.
    nextIrpStack->Parameters.Others.Argument4 = RequestSetupMcnSyncIrp;

    IoSetCompletionRoutine(irp,
                           RequestMcnSyncIrpCompletion,
                           DeviceExtension,
                           TRUE,
                           TRUE,
                           TRUE);

    return;
}

Referenced by RequestDispatchSpecialIoctls(), and RequestSetupMcnSyncIrp().

Variable Documentation

RequestMcnSyncIrpCompletion

IO_COMPLETION_ROUTINE RequestMcnSyncIrpCompletion

Definition at line 2691 of file autorun.c.

Referenced by RequestSetupMcnSyncIrp().