Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-03 19:24:20 +00:00
Code Issues Packages Projects Releases Wiki Activity
reactos/drivers/storage/class/cdrom/autorun.c

3081 lines
102 KiB
C
Raw Blame History

/*++
Copyright (C) Microsoft Corporation. All rights reserved.
Module Name:
autorun.c
Abstract:
Code for support of media change detection in the cd/dvd driver
Environment:
kernel mode only
Notes:
Revision History:
--*/
#include "stddef.h"
#include "string.h"
#include "ntddk.h"
#include "ntddstor.h"
#include "cdrom.h"
#include "mmc.h"
#include "ioctl.h"
#include "ntstrsafe.h"
#ifdef DEBUG_USE_WPP
#include "autorun.tmh"
#endif
#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")
//
// Only send polling irp when device is fully powered up and a
// power down irp is not in progress.
//
// NOTE: This helps close a window in time where a polling irp could cause
// a drive to spin up right after it has powered down. The problem is
// that SCSIPORT, ATAPI and SBP2 will be in the process of powering
// down (which may take a few seconds), but won't know that. It would
// then get a polling irp which will be put into its queue since it
// the disk isn't powered down yet. Once the disk is powered down it
// will find the polling irp in the queue and then power up the
// device to do the poll. They do not want to check if the polling
// irp has the SRB_NO_KEEP_AWAKE flag here since it is in a critical
// path and would slow down all I/Os. A better way to fix this
// would be to serialize the polling and power down irps so that
// only one of them is sent to the device at a time.
//
_IRQL_requires_max_(PASSIVE_LEVEL)
BOOLEAN
DeviceIsMediaChangeDisabledDueToHardwareLimitation(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension
);
_IRQL_requires_max_(PASSIVE_LEVEL)
BOOLEAN
DeviceIsMediaChangeDisabledForClass(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension
);
_IRQL_requires_max_(PASSIVE_LEVEL)
NTSTATUS
DeviceMediaChangeDeviceInstanceOverride(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension,
_Out_ PBOOLEAN Enabled
);
_IRQL_requires_max_(PASSIVE_LEVEL)
NTSTATUS
DeviceInitializeMcn(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension,
_In_ BOOLEAN AllowDriveToSleep
);
_IRQL_requires_max_(PASSIVE_LEVEL)
NTSTATUS
DeviceInitializeGesn(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension
);
_IRQL_requires_max_(APC_LEVEL)
NTSTATUS
GesnDataInterpret(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension,
_In_ PNOTIFICATION_EVENT_STATUS_HEADER Header,
_Out_ PBOOLEAN ResendImmediately
);
RTL_QUERY_REGISTRY_ROUTINE DeviceMediaChangeRegistryCallBack;
EVT_WDF_WORKITEM DeviceDisableGesn;
#if ALLOC_PRAGMA
#pragma alloc_text(PAGE, DeviceInitializeMediaChangeDetection)
#pragma alloc_text(PAGE, DeviceEnableMediaChangeDetection)
#pragma alloc_text(PAGE, DeviceDisableMediaChangeDetection)
#pragma alloc_text(PAGE, DeviceSendDelayedMediaChangeNotifications)
#pragma alloc_text(PAGE, DeviceReleaseMcnResources)
#pragma alloc_text(PAGE, DeviceMediaChangeRegistryCallBack)
#pragma alloc_text(PAGE, DeviceInitializeMcn)
#pragma alloc_text(PAGE, DeviceDisableGesn)
#pragma alloc_text(PAGE, DeviceIsMediaChangeDisabledDueToHardwareLimitation)
#pragma alloc_text(PAGE, DeviceMediaChangeDeviceInstanceOverride)
#pragma alloc_text(PAGE, DeviceIsMediaChangeDisabledForClass)
#pragma alloc_text(PAGE, DeviceDisableMainTimer)
#pragma alloc_text(PAGE, GesnDataInterpret)
#pragma alloc_text(PAGE, RequestSetupMcnRequest)
#pragma alloc_text(PAGE, RequestPostWorkMcnRequest)
#pragma alloc_text(PAGE, RequestSendMcnRequest)
//
// DeviceEnableMainTimer is called by EvtDeviceD0Entry which can't be made pageable
// so neither is DeviceEnableMainTimer
//
//#pragma alloc_text(PAGE, DeviceEnableMainTimer)
#pragma alloc_text(PAGE, DeviceInitializeGesn)
#pragma alloc_text(PAGE, RequestHandleMcnControl)
#endif
#pragma warning(push)
#pragma warning(disable: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;
}
VOID
DeviceInternalSetMediaChangeState(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension,
_In_ MEDIA_CHANGE_DETECTION_STATE NewState,
_Inout_opt_ PMEDIA_CHANGE_DETECTION_STATE OldState
)
/*++
Routine Description:
This routine will (if appropriate) set the media change event for the
device. The event will be set if the media state is changed and
media change events are enabled. Otherwise the media state will be
tracked but the event will not be set.
This routine will lock out the other media change routines if possible
but if not a media change notification may be lost after the enable has
been completed.
Arguments:
DeviceExtension - the device extension
NewState - new state for setting
OldState - optional storage for the old state
Return Value:
none
--*/
{
#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()
VOID
DeviceSetMediaChangeStateEx(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension,
_In_ MEDIA_CHANGE_DETECTION_STATE NewState,
_Inout_opt_ PMEDIA_CHANGE_DETECTION_STATE OldState
)
/*++
Routine Description:
This routine will (if appropriate) set the media change event for the
device. The event will be set if the media state is changed and
media change events are enabled. Otherwise the media state will be
tracked but the event will not be set.
Arguments:
DeviceExtension - the device extension
NewState - new state for setting
OldState - optional storage for the old state
Return Value:
none
--*/
{
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()
_IRQL_requires_max_(APC_LEVEL)
VOID
DeviceSendDelayedMediaChangeNotifications(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension
)
/*++
Routine Description:
This routine sends the so-called delayed media change notifications.
These notifications get accumulated while the MCN mechanism is disabled
and need to be sent to the application on MCN enabling, if MCN enabling
happens as a part of exclusive access unlock and the application has not
requested us explicitly to not send the delayed notifications.
Arguments:
DeviceExtension - the device extension
Return Value:
none
--*/
{
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_(APC_LEVEL)
NTSTATUS
RequestSetupMcnRequest(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension,
_In_ BOOLEAN UseGesn
)
/*++
Routine Description:
This routine sets up the fields of the request for MCN
Arguments:
DeviceExtension - device context
UseGesn - If TRUE, the device supports GESN and it's currently the mechanism for MCN
Return Value:
NTSTATUS
--*/
{
NTSTATUS status = STATUS_SUCCESS;
PSCSI_REQUEST_BLOCK srb;
PIRP irp;
PIO_STACK_LOCATION nextIrpStack;
PCDB cdb;
PVOID buffer;
WDF_REQUEST_REUSE_PARAMS params;
PMEDIA_CHANGE_DETECTION_INFO info = DeviceExtension->MediaChangeDetectionInfo;
PAGED_CODE();
irp = WdfRequestWdmGetIrp(info->MediaChangeRequest);
NT_ASSERT(irp != NULL);
// deassign the MdlAddress, this is the value we assign explicitly.
// this is to prevent WdfRequestReuse to release the Mdl unexpectly.
if (irp->MdlAddress)
{
irp->MdlAddress = NULL;
}
if (NT_SUCCESS(status))
{
// Setup the IRP to perform a test unit ready.
WDF_REQUEST_REUSE_PARAMS_INIT(&params,
WDF_REQUEST_REUSE_NO_FLAGS,
STATUS_NOT_SUPPORTED);
status = WdfRequestReuse(info->MediaChangeRequest, &params);
}
if (NT_SUCCESS(status))
{
// Format the request.
status = WdfIoTargetFormatRequestForInternalIoctlOthers(DeviceExtension->IoTarget,
info->MediaChangeRequest,
IOCTL_SCSI_EXECUTE_IN,
NULL, NULL,
NULL, NULL,
NULL, NULL);
if (!NT_SUCCESS(status))
{
TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
"RequestSetupMcnRequest: WdfIoTargetFormatRequestForInternalIoctlOthers failed, %!STATUS!\n",
status));
}
}
if (NT_SUCCESS(status))
{
RequestClearSendTime(info->MediaChangeRequest);
nextIrpStack = IoGetNextIrpStackLocation(irp);
nextIrpStack->Flags = SL_OVERRIDE_VERIFY_VOLUME;
nextIrpStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
nextIrpStack->Parameters.Scsi.Srb = &(info->MediaChangeSrb);
// Prepare the SRB for execution.
srb = nextIrpStack->Parameters.Scsi.Srb;
buffer = info->SenseBuffer;
RtlZeroMemory(srb, sizeof(SCSI_REQUEST_BLOCK));
RtlZeroMemory(buffer, SENSE_BUFFER_SIZE);
srb->QueueTag = SP_UNTAGGED;
srb->QueueAction = SRB_SIMPLE_TAG_REQUEST;
srb->Length = sizeof(SCSI_REQUEST_BLOCK);
srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
srb->SenseInfoBuffer = buffer;
srb->SrbStatus = 0;
srb->ScsiStatus = 0;
srb->OriginalRequest = irp;
srb->SenseInfoBufferLength = SENSE_BUFFER_SIZE;
srb->SrbFlags = DeviceExtension->SrbFlags;
SET_FLAG(srb->SrbFlags, info->SrbFlags);
if (!UseGesn)
{
srb->TimeOutValue = CDROM_TEST_UNIT_READY_TIMEOUT;
srb->CdbLength = 6;
srb->DataTransferLength = 0;
SET_FLAG(srb->SrbFlags, SRB_FLAGS_NO_DATA_TRANSFER);
nextIrpStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_SCSI_EXECUTE_NONE;
srb->DataBuffer = NULL;
srb->DataTransferLength = 0;
irp->MdlAddress = NULL;
cdb = (PCDB) &srb->Cdb[0];
cdb->CDB6GENERIC.OperationCode = SCSIOP_TEST_UNIT_READY;
}
else
{
NT_ASSERT(info->Gesn.Buffer);
srb->TimeOutValue = GESN_TIMEOUT_VALUE; // much shorter timeout for GESN
srb->CdbLength = 10;
SET_FLAG(srb->SrbFlags, SRB_FLAGS_DATA_IN);
nextIrpStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_SCSI_EXECUTE_IN;
srb->DataBuffer = info->Gesn.Buffer;
srb->DataTransferLength = info->Gesn.BufferSize;
irp->MdlAddress = info->Gesn.Mdl;
cdb = (PCDB) &srb->Cdb[0];
cdb->GET_EVENT_STATUS_NOTIFICATION.OperationCode = SCSIOP_GET_EVENT_STATUS;
cdb->GET_EVENT_STATUS_NOTIFICATION.Immediate = 1;
cdb->GET_EVENT_STATUS_NOTIFICATION.EventListLength[0] = (UCHAR)((info->Gesn.BufferSize) >> 8);
cdb->GET_EVENT_STATUS_NOTIFICATION.EventListLength[1] = (UCHAR)((info->Gesn.BufferSize) & 0xff);
cdb->GET_EVENT_STATUS_NOTIFICATION.NotificationClassRequest = info->Gesn.EventMask;
}
}
return status;
}
VOID
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
DeviceDisableGesn(
_In_ WDFWORKITEM WorkItem
)
/*++
Routine Description:
Work item routine to set the hack flag in the registry to disable GESN
This routine is invoked when the device reports TOO many events that affects system
Arguments:
WorkItem - the work item be perfromed.
Return Value:
None
--*/
{
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;
}
_IRQL_requires_max_(APC_LEVEL)
BOOLEAN
RequestPostWorkMcnRequest(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension
)
/*++
Routine Description:
This routine handles the completion of the test unit ready irps used to
determine if the media has changed. If the media has changed, this code
signals the named event to wake up other system services that react to
media change (aka AutoPlay).
Arguments:
DeviceExtension - the device context
Return Value:
BOOLEAN - TRUE (needs retry); FALSE (shoule not retry)
--*/
{
NTSTATUS status = STATUS_SUCCESS;
PMEDIA_CHANGE_DETECTION_INFO info = DeviceExtension->MediaChangeDetectionInfo;
PIRP irp;
BOOLEAN retryImmediately = FALSE;
PAGED_CODE();
NT_ASSERT(info->MediaChangeRequest != NULL);
irp = WdfRequestWdmGetIrp(info->MediaChangeRequest);
NT_ASSERT(!TEST_FLAG(info->MediaChangeSrb.SrbStatus, SRB_STATUS_QUEUE_FROZEN));
// use InterpretSenseInfo routine to check for media state, and also
// to call ClassError() with correct parameters.
if (SRB_STATUS(info->MediaChangeSrb.SrbStatus) != SRB_STATUS_SUCCESS)
{
TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN, "MCN request - failed - srb status=%x, sense=%x/%x/%x.\n",
info->MediaChangeSrb.SrbStatus,
((PSENSE_DATA)(info->MediaChangeSrb.SenseInfoBuffer))->SenseKey,
((PSENSE_DATA)(info->MediaChangeSrb.SenseInfoBuffer))->AdditionalSenseCode,
((PSENSE_DATA)(info->MediaChangeSrb.SenseInfoBuffer))->AdditionalSenseCodeQualifier));
if (SRB_STATUS(info->MediaChangeSrb.SrbStatus) != SRB_STATUS_NOT_POWERED)
{
// Release the queue if it is frozen.
if (info->MediaChangeSrb.SrbStatus & SRB_STATUS_QUEUE_FROZEN)
{
DeviceReleaseQueue(DeviceExtension->Device);
}
RequestSenseInfoInterpret(DeviceExtension,
info->MediaChangeRequest,
&info->MediaChangeSrb,
0,
&status,
NULL);
}
}
else
{
DeviceExtension->PrivateFdoData->LoggedTURFailureSinceLastIO = FALSE;
if (!info->Gesn.Supported)
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"MCN request - succeeded (GESN NOT supported, setting MediaPresent).\n"));
// success != media for GESN case
DeviceSetMediaChangeStateEx(DeviceExtension,
MediaPresent,
NULL);
}
else
{
TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_MCN,
"MCN request - succeeded (GESN supported).\n"));
}
}
if (info->Gesn.Supported)
{
if (status == STATUS_DATA_OVERRUN)
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, "MCN Request - Data Overrun\n"));
status = STATUS_SUCCESS;
}
if (!NT_SUCCESS(status))
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, "MCN Request: GESN failed with status %x\n", status));
}
else
{
// for GESN, need to interpret the results of the data.
// this may also require an immediate retry
if (irp->IoStatus.Information == 8 )
{
GesnDataInterpret(DeviceExtension,
(PVOID)info->Gesn.Buffer,
&retryImmediately);
}
} // end of NT_SUCCESS(status)
} // end of Info->Gesn.Supported
// free port-allocated sense buffer, if any.
if (PORT_ALLOCATED_SENSE(DeviceExtension, &info->MediaChangeSrb))
{
FREE_PORT_ALLOCATED_SENSE_BUFFER(DeviceExtension, &info->MediaChangeSrb);
}
// Remember the IRP and SRB for use the next time.
NT_ASSERT(IoGetNextIrpStackLocation(irp));
IoGetNextIrpStackLocation(irp)->Parameters.Scsi.Srb = &info->MediaChangeSrb;
// run a sanity check to make sure we're not recursing continuously
if (retryImmediately)
{
info->MediaChangeRetryCount++;
if (info->MediaChangeRetryCount > MAXIMUM_IMMEDIATE_MCN_RETRIES)
{
// Disable GESN on this device.
// Create a work item to set the value in the registry
WDF_OBJECT_ATTRIBUTES attributes;
WDF_WORKITEM_CONFIG workitemConfig;
WDFWORKITEM workItem;
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.ParentObject = DeviceExtension->Device;
WDF_WORKITEM_CONFIG_INIT(&workitemConfig, DeviceDisableGesn);
workitemConfig.AutomaticSerialization = FALSE;
status = WdfWorkItemCreate(&workitemConfig,
&attributes,
&workItem);
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, "MCN Request: Disabling GESN for WDFDEVICE %p\n", DeviceExtension->Device));
if (NT_SUCCESS(status))
{
WdfWorkItemEnqueue(workItem);
}
info->Gesn.Supported = FALSE;
info->Gesn.EventMask = 0;
info->Gesn.BufferSize = 0;
info->MediaChangeRetryCount = 0;
retryImmediately = FALSE;
// should we log an error in event log?
}
}
else
{
info->MediaChangeRetryCount = 0;
}
return retryImmediately;
}
_IRQL_requires_max_(APC_LEVEL)
BOOLEAN
RequestSendMcnRequest(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension
)
/*++
Routine Description:
This routine sends the formatted MCN request sychronizely to lower driver.
Arguments:
DeviceExtension - the device context
Return Value:
BOOLEAN - TRUE (requst successfully sent); FALSE (request failed to send)
--*/
{
BOOLEAN requestSent = FALSE;
PMEDIA_CHANGE_DETECTION_INFO info = DeviceExtension->MediaChangeDetectionInfo;
PAGED_CODE();
RequestSend(DeviceExtension,
info->MediaChangeRequest,
DeviceExtension->IoTarget,
WDF_REQUEST_SEND_OPTION_SYNCHRONOUS,
&requestSent);
return requestSent;
} // end RequestSendMcnRequest()
_IRQL_requires_max_(PASSIVE_LEVEL)
NTSTATUS
DeviceInitializeMcn(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension,
_In_ BOOLEAN AllowDriveToSleep
)
/*++
Routine Description:
This routine initialize the contents of MCN structure.
Arguments:
DeviceExtension - the device extension
AllowDriveToSleep - for CDROM, this parameter should be always FALSE
Return Value:
NTSTATUS
--*/
{
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()
_IRQL_requires_max_(PASSIVE_LEVEL)
NTSTATUS
DeviceInitializeGesn(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension
)
/*++
Routine Description:
This routine initialize the contents of GESN structure.
Arguments:
DeviceExtension - the device extension
Return Value:
NTSTATUS
--*/
{
NTSTATUS status = STATUS_SUCCESS;
PNOTIFICATION_EVENT_STATUS_HEADER header = NULL;
CDROM_DETECTION_STATE detectionState = CdromDetectionUnknown;
PSTORAGE_DEVICE_DESCRIPTOR deviceDescriptor = DeviceExtension->DeviceDescriptor;
BOOLEAN retryImmediately = TRUE;
ULONG i = 0;
ULONG atapiResets = 0;
PMEDIA_CHANGE_DETECTION_INFO info = DeviceExtension->MediaChangeDetectionInfo;
PAGED_CODE();
NT_ASSERT(info != NULL);
// read if we already know the abilities of the device
DeviceGetParameter(DeviceExtension,
CLASSP_REG_SUBKEY_NAME,
CLASSP_REG_MMC_DETECTION_VALUE_NAME,
(PULONG)&detectionState);
if (detectionState == CdromDetectionUnsupported)
{
status = STATUS_NOT_SUPPORTED;
}
// check if the device has a hack flag saying never to try this.
if (NT_SUCCESS(status) &&
(TEST_FLAG(DeviceExtension->PrivateFdoData->HackFlags, FDO_HACK_GESN_IS_BAD)) )
{
DeviceSetParameter(DeviceExtension,
CLASSP_REG_SUBKEY_NAME,
CLASSP_REG_MMC_DETECTION_VALUE_NAME,
CdromDetectionUnsupported);
status = STATUS_NOT_SUPPORTED;
}
// else go through the process since we allocate buffers and
// get all sorts of device settings.
if (NT_SUCCESS(status))
{
if (info->Gesn.Buffer == NULL)
{
info->Gesn.Buffer = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
GESN_BUFFER_SIZE,
CDROM_TAG_GESN);
}
if (info->Gesn.Buffer == NULL)
{
status = STATUS_INSUFFICIENT_RESOURCES;
}
}
if (NT_SUCCESS(status))
{
if (info->Gesn.Mdl != NULL)
{
IoFreeMdl(info->Gesn.Mdl);
}
info->Gesn.Mdl = IoAllocateMdl(info->Gesn.Buffer,
GESN_BUFFER_SIZE,
FALSE,
FALSE,
NULL);
if (info->Gesn.Mdl == NULL)
{
status = STATUS_INSUFFICIENT_RESOURCES;
}
}
if (NT_SUCCESS(status))
{
MmBuildMdlForNonPagedPool(info->Gesn.Mdl);
info->Gesn.BufferSize = GESN_BUFFER_SIZE;
info->Gesn.EventMask = 0;
// all items are prepared to use GESN (except the event mask, so don't
// optimize this part out!).
//
// now see if it really works. we have to loop through this because
// many SAMSUNG (and one COMPAQ) drives timeout when requesting
// NOT_READY events, even when the IMMEDIATE bit is set. :(
//
// using a drive list is cumbersome, so this might fix the problem.
for (i = 0; (i < 16) && retryImmediately; i++)
{
status = RequestSetupMcnRequest(DeviceExtension, TRUE);
if (!NT_SUCCESS(status))
{
TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN,
"Setup Mcn request failed %x for WDFDEVICE %p\n",
status, DeviceExtension->Device));
break;
}
NT_ASSERT(TEST_FLAG(info->MediaChangeSrb.SrbFlags, SRB_FLAGS_NO_QUEUE_FREEZE));
status = DeviceSendRequestSynchronously(DeviceExtension->Device, info->MediaChangeRequest, TRUE);
if (SRB_STATUS(info->MediaChangeSrb.SrbStatus) != SRB_STATUS_SUCCESS)
{
// Release the queue if it is frozen.
if (info->MediaChangeSrb.SrbStatus & SRB_STATUS_QUEUE_FROZEN)
{
DeviceReleaseQueue(DeviceExtension->Device);
}
RequestSenseInfoInterpret(DeviceExtension,
info->MediaChangeRequest,
&(info->MediaChangeSrb),
0,
&status,
NULL);
}
if ((deviceDescriptor->BusType == BusTypeAtapi) &&
(info->MediaChangeSrb.SrbStatus == SRB_STATUS_BUS_RESET))
{
//
// ATAPI unfortunately returns SRB_STATUS_BUS_RESET instead
// of SRB_STATUS_TIMEOUT, so we cannot differentiate between
// the two. if we get this status four time consecutively,
// stop trying this command. it is too late to change ATAPI
// at this point, so special-case this here. (07/10/2001)
// NOTE: any value more than 4 may cause the device to be
// marked missing.
//
atapiResets++;
if (atapiResets >= 4)
{
status = STATUS_IO_DEVICE_ERROR;
break;
}
}
if (status == STATUS_DATA_OVERRUN)
{
status = STATUS_SUCCESS;
}
if ((status == STATUS_INVALID_DEVICE_REQUEST) ||
(status == STATUS_TIMEOUT) ||
(status == STATUS_IO_DEVICE_ERROR) ||
(status == STATUS_IO_TIMEOUT))
{
// with these error codes, we don't ever want to try this command
// again on this device, since it reacts poorly.
DeviceSetParameter( DeviceExtension,
CLASSP_REG_SUBKEY_NAME,
CLASSP_REG_MMC_DETECTION_VALUE_NAME,
CdromDetectionUnsupported);
TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN,
"GESN test failed %x for WDFDEVICE %p\n",
status, DeviceExtension->Device));
break;
}
if (!NT_SUCCESS(status))
{
// this may be other errors that should not disable GESN
// for all future start_device calls.
TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN,
"GESN test failed %x for WDFDEVICE %p\n",
status, DeviceExtension->Device));
break;
}
else if (i == 0)
{
// the first time, the request was just retrieving a mask of
// available bits. use this to mask future requests.
header = (PNOTIFICATION_EVENT_STATUS_HEADER)(info->Gesn.Buffer);
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"WDFDEVICE %p supports event mask %x\n",
DeviceExtension->Device, header->SupportedEventClasses));
if (TEST_FLAG(header->SupportedEventClasses,
NOTIFICATION_MEDIA_STATUS_CLASS_MASK))
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"GESN supports MCN\n"));
}
if (TEST_FLAG(header->SupportedEventClasses,
NOTIFICATION_DEVICE_BUSY_CLASS_MASK))
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"GESN supports DeviceBusy\n"));
}
if (TEST_FLAG(header->SupportedEventClasses,
NOTIFICATION_OPERATIONAL_CHANGE_CLASS_MASK))
{
if (TEST_FLAG(DeviceExtension->PrivateFdoData->HackFlags,
FDO_HACK_GESN_IGNORE_OPCHANGE))
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"GESN supports OpChange, but must ignore these events for compatibility\n"));
CLEAR_FLAG(header->SupportedEventClasses,
NOTIFICATION_OPERATIONAL_CHANGE_CLASS_MASK);
}
else
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"GESN supports OpChange\n"));
}
}
info->Gesn.EventMask = header->SupportedEventClasses;
//
// realistically, we are only considering the following events:
// EXTERNAL REQUEST - this is being tested for play/stop/etc.
// MEDIA STATUS - autorun and ejection requests.
// DEVICE BUSY - to allow us to predict when media will be ready.
// therefore, we should not bother querying for the other,
// unknown events. clear all but the above flags.
//
info->Gesn.EventMask &= NOTIFICATION_OPERATIONAL_CHANGE_CLASS_MASK |
NOTIFICATION_EXTERNAL_REQUEST_CLASS_MASK |
NOTIFICATION_MEDIA_STATUS_CLASS_MASK |
NOTIFICATION_DEVICE_BUSY_CLASS_MASK ;
//
// HACKHACK - REF #0001
// Some devices will *never* report an event if we've also requested
// that it report lower-priority events. this is due to a
// misunderstanding in the specification wherein a "No Change" is
// interpreted to be a real event. what should occur is that the
// device should ignore "No Change" events when multiple event types
// are requested unless there are no other events waiting. this
// greatly reduces the number of requests that the host must send
// to determine if an event has occurred. Since we must work on all
// drives, default to enabling the hack until we find evidence of
// proper firmware.
//
if (info->Gesn.EventMask == 0)
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"GESN supported, but not mask we care about (%x) for FDO %p\n",
header->SupportedEventClasses,
DeviceExtension->DeviceObject));
// NOTE: the status is still status_sucess.
break;
}
else if (CountOfSetBitsUChar(info->Gesn.EventMask) == 1)
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"GESN hack not required for FDO %p\n",
DeviceExtension->DeviceObject));
}
else
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"GESN hack enabled for FDO %p\n",
DeviceExtension->DeviceObject));
info->Gesn.HackEventMask = 1;
}
}
else
{
// i > 0; not the first time looping through, so interpret the results.
status = GesnDataInterpret(DeviceExtension,
(PVOID)info->Gesn.Buffer,
&retryImmediately);
if (!NT_SUCCESS(status))
{
// This drive does not support GESN correctly
DeviceSetParameter( DeviceExtension,
CLASSP_REG_SUBKEY_NAME,
CLASSP_REG_MMC_DETECTION_VALUE_NAME,
CdromDetectionUnsupported);
break;
}
}
} // end 'for' loop of GESN requests....
}
if (NT_SUCCESS(status))
{
//
// we can only use this if it can be relied upon for media changes,
// since we are (by definition) no longer going to be polling via
// a TEST_UNIT_READY irp, and drives will not report UNIT ATTENTION
// for this command (although a filter driver, such as one for burning
// cd's, might still fake those errors).
//
// since we also rely upon NOT_READY events to change the cursor
// into a "wait" cursor; GESN is still more reliable than other
// methods, and includes eject button requests, so we'll use it
// without DEVICE_BUSY in Windows Vista.
//
if (TEST_FLAG(info->Gesn.EventMask, NOTIFICATION_MEDIA_STATUS_CLASS_MASK))
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"Enabling GESN support for WDFDEVICE %p\n",
DeviceExtension->Device));
info->Gesn.Supported = TRUE;
DeviceSetParameter( DeviceExtension,
CLASSP_REG_SUBKEY_NAME,
CLASSP_REG_MMC_DETECTION_VALUE_NAME,
CdromDetectionSupported);
}
else
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"GESN available but not enabled for WDFDEVICE %p\n",
DeviceExtension->Device));
status = STATUS_NOT_SUPPORTED;
}
}
if (!NT_SUCCESS(status))
{
TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN,
"GESN support detection failed for WDFDEVICE %p with status %08x\n",
DeviceExtension->Device, status));
if (info->Gesn.Mdl)
{
PIRP irp = WdfRequestWdmGetIrp(info->MediaChangeRequest);
IoFreeMdl(info->Gesn.Mdl);
info->Gesn.Mdl = NULL;
irp->MdlAddress = NULL;
}
FREE_POOL(info->Gesn.Buffer);
info->Gesn.Supported = FALSE;
info->Gesn.EventMask = 0;
info->Gesn.BufferSize = 0;
}
return status;
}
_IRQL_requires_max_(PASSIVE_LEVEL)
NTSTATUS
DeviceInitializeMediaChangeDetection(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension
)
/*++
Routine Description:
This routine checks to see if it is safe to initialize MCN (the back end
to autorun) for a given device. It will then check the device-type wide
key "Autorun" in the service key (for legacy reasons), and then look in
the device-specific key to potentially override that setting.
If MCN is to be enabled, all neccessary structures and memory are
allocated and initialized.
This routine MUST be called only from the DeviceInit...() .
Arguments:
DeviceExtension - the device to initialize MCN for, if appropriate
Return Value:
NTSTATUS
--*/
{
NTSTATUS status = STATUS_SUCCESS;
BOOLEAN disabled = FALSE;
BOOLEAN instanceOverride;
PAGED_CODE();
// NOTE: This assumes that DeviceInitializeMediaChangeDetection is always
// called in the context of the DeviceInitDevicePhase2. If called
// after then this check will have already been made and the
// once a second timer will not have been enabled.
disabled = DeviceIsMediaChangeDisabledDueToHardwareLimitation(DeviceExtension);
if (disabled)
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"DeviceInitializeMediaChangeDetection: Disabled due to hardware"
"limitations for this device\n"));
}
else
{
// autorun should now be enabled by default for all media types.
disabled = DeviceIsMediaChangeDisabledForClass(DeviceExtension);
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"DeviceInitializeMediaChangeDetection: MCN is %s\n",
(disabled ? "disabled" : "enabled")));
status = DeviceMediaChangeDeviceInstanceOverride(DeviceExtension,
&instanceOverride); // default value
if (!NT_SUCCESS(status))
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"DeviceInitializeMediaChangeDetection: Instance using default\n"));
}
else
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"DeviceInitializeMediaChangeDetection: Instance override: %s MCN\n",
(instanceOverride ? "Enabling" : "Disabling")));
disabled = !instanceOverride;
}
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"DeviceInitializeMediaChangeDetection: Instance MCN is %s\n",
(disabled ? "disabled" : "enabled")));
}
if (!disabled)
{
// if the drive is not a CDROM, allow the drive to sleep
status = DeviceInitializeMcn(DeviceExtension, FALSE);
}
return status;
} // end DeviceInitializeMediaChangeDetection()
_IRQL_requires_max_(PASSIVE_LEVEL)
NTSTATUS
DeviceMediaChangeDeviceInstanceOverride(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension,
_Out_ PBOOLEAN Enabled
)
/*++
Routine Description:
The user can override the global setting to enable or disable Autorun on a
specific cdrom device via the control panel. This routine checks and/or
sets this value.
Arguments:
DeviceExtension - the device to set/get the value for
Enabled - TRUE (Autorun is enabled)
FALSE (Autorun is disabled)
Return Value:
NTSTATUS
--*/
{
NTSTATUS status = STATUS_UNSUCCESSFUL;
WDFKEY deviceKey = NULL;
WDFKEY subKey = NULL;
UNICODE_STRING subkeyName;
UNICODE_STRING enableMcnValueName;
UNICODE_STRING disableMcnValueName;
ULONG alwaysEnable = 0;
ULONG alwaysDisable = 0;
PAGED_CODE();
status = WdfDeviceOpenRegistryKey(DeviceExtension->Device,
PLUGPLAY_REGKEY_DEVICE,
KEY_ALL_ACCESS,
WDF_NO_OBJECT_ATTRIBUTES,
&deviceKey);
if (!NT_SUCCESS(status))
{
// this can occur when a new device is added to the system
// this is due to cdrom.sys being an 'essential' driver
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"DeviceMediaChangeDeviceInstanceOverride: "
"Could not open device registry key [%lx]\n", status));
}
else
{
RtlInitUnicodeString(&subkeyName, MCN_REG_SUBKEY_NAME);
status = WdfRegistryOpenKey(deviceKey,
&subkeyName,
KEY_READ,
WDF_NO_OBJECT_ATTRIBUTES,
&subKey);
}
if (!NT_SUCCESS(status))
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"DeviceMediaChangeDeviceInstanceOverride: "
"subkey could not be created. %lx\n", status));
}
else
{
// Default to not changing autorun behavior, based upon setting
// registryValue to zero.
RtlInitUnicodeString(&enableMcnValueName, MCN_REG_AUTORUN_ENABLE_INSTANCE_NAME);
RtlInitUnicodeString(&disableMcnValueName, MCN_REG_AUTORUN_DISABLE_INSTANCE_NAME);
// Ignore failures on reading of subkeys
(VOID) WdfRegistryQueryULong(subKey,
&enableMcnValueName,
&alwaysEnable);
(VOID) WdfRegistryQueryULong(subKey,
&disableMcnValueName,
&alwaysDisable);
}
// set return value and cleanup
if (subKey != NULL)
{
WdfRegistryClose(subKey);
}
if (deviceKey != NULL)
{
WdfRegistryClose(deviceKey);
}
if (alwaysEnable && alwaysDisable)
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"DeviceMediaChangeDeviceInstanceOverride: %s selected\n",
"Both Enable and Disable set -- DISABLE"));
NT_ASSERT(NT_SUCCESS(status));
status = STATUS_SUCCESS;
*Enabled = FALSE;
}
else if (alwaysDisable)
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"DeviceMediaChangeDeviceInstanceOverride: %s selected\n",
"DISABLE"));
NT_ASSERT(NT_SUCCESS(status));
status = STATUS_SUCCESS;
*Enabled = FALSE;
}
else if (alwaysEnable)
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"DeviceMediaChangeDeviceInstanceOverride: %s selected\n",
"ENABLE"));
NT_ASSERT(NT_SUCCESS(status));
status = STATUS_SUCCESS;
*Enabled = TRUE;
}
else
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"DeviceMediaChangeDeviceInstanceOverride: %s selected\n",
"DEFAULT"));
status = STATUS_UNSUCCESSFUL;
}
return status;
} // end DeviceMediaChangeDeviceInstanceOverride()
NTSTATUS
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
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
)
/*++
Routine Description:
This callback for a registry SZ or MULTI_SZ is called once for each
SZ in the value. It will attempt to match the data with the
UNICODE_STRING passed in as Context, and modify EntryContext if a
match is found. Written for ClasspCheckRegistryForMediaChangeCompletion
Arguments:
ValueName - name of the key that was opened
ValueType - type of data stored in the value (REG_SZ for this routine)
ValueData - data in the registry, in this case a wide string
ValueLength - length of the data including the terminating null
Context - unicode string to compare against ValueData
EntryContext - should be initialized to 0, will be set to 1 if match found
Return Value:
STATUS_SUCCESS
EntryContext will be 1 if found
--*/
{
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()
_IRQL_requires_max_(PASSIVE_LEVEL)
BOOLEAN
DeviceIsMediaChangeDisabledDueToHardwareLimitation(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension
)
/*++
Routine Description:
The key AutoRunAlwaysDisable contains a MULTI_SZ of hardware IDs for
which to never enable MediaChangeNotification.
The user can override the global setting to enable or disable Autorun on a
specific cdrom device via the control panel.
NOTE: It's intended that not use WdfRegistryQueryMultiString in this funciton,
as it's much more complicated.(needs WDFCOLLECTION, WDFSTRING other than
UNICODE_STRING)
Arguments:
FdoExtension -
RegistryPath - pointer to the unicode string inside
...\CurrentControlSet\Services\Cdrom
Return Value:
TRUE - no autorun.
FALSE - Autorun may be enabled
--*/
{
NTSTATUS status;
PSTORAGE_DEVICE_DESCRIPTOR deviceDescriptor = DeviceExtension->DeviceDescriptor;
WDFKEY wdfKey;
HANDLE serviceKey = NULL;
RTL_QUERY_REGISTRY_TABLE parameters[2] = {0};
UNICODE_STRING deviceUnicodeString = {0};
ANSI_STRING deviceString = {0};
ULONG mediaChangeNotificationDisabled = 0;
PAGED_CODE();
// open the service key.
status = WdfDriverOpenParametersRegistryKey(WdfGetDriver(),
KEY_ALL_ACCESS,
WDF_NO_OBJECT_ATTRIBUTES,
&wdfKey);
if(!NT_SUCCESS(status))
{
// NT_ASSERT(FALSE); __REACTOS__ : allow to fail (for 1st stage setup)
// always take the safe path. if we can't open the service key, disable autorun
return TRUE;
}
if(NT_SUCCESS(status))
{
// Determine if drive is in a list of those requiring
// autorun to be disabled. this is stored in a REG_MULTI_SZ
// named AutoRunAlwaysDisable. this is required as some autochangers
// must load the disc to reply to ChkVerify request, causing them
// to cycle discs continuously.
PWSTR nullMultiSz;
PUCHAR vendorId = NULL;
PUCHAR productId = NULL;
PUCHAR revisionId = NULL;
size_t length;
size_t offset;
deviceString.Buffer = NULL;
deviceUnicodeString.Buffer = NULL;
serviceKey = WdfRegistryWdmGetHandle(wdfKey);
// there may be nothing to check against
if ((deviceDescriptor->VendorIdOffset == 0) &&
(deviceDescriptor->ProductIdOffset == 0))
{
// no valid data in device extension.
status = STATUS_INTERNAL_ERROR;
}
// build deviceString using VendorId, Model and Revision.
// this string will be used to checked if it's one of devices in registry disable list.
if (NT_SUCCESS(status))
{
length = 0;
if (deviceDescriptor->VendorIdOffset == 0)
{
vendorId = NULL;
}
else
{
vendorId = (PUCHAR) deviceDescriptor + deviceDescriptor->VendorIdOffset;
length = strlen((LPCSTR)vendorId);
}
if ( deviceDescriptor->ProductIdOffset == 0 )
{
productId = NULL;
}
else
{
productId = (PUCHAR) deviceDescriptor + deviceDescriptor->ProductIdOffset;
length += strlen((LPCSTR)productId);
}
if ( deviceDescriptor->ProductRevisionOffset == 0 )
{
revisionId = NULL;
}
else
{
revisionId = (PUCHAR) deviceDescriptor + deviceDescriptor->ProductRevisionOffset;
length += strlen((LPCSTR)revisionId);
}
// allocate a buffer for the string
deviceString.Length = (USHORT)( length );
deviceString.MaximumLength = deviceString.Length + 1;
deviceString.Buffer = (PCHAR)ExAllocatePoolWithTag( NonPagedPoolNx,
deviceString.MaximumLength,
CDROM_TAG_AUTORUN_DISABLE
);
if (deviceString.Buffer == NULL)
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"DeviceIsMediaChangeDisabledDueToHardwareLimitation: Unable to alloc string buffer\n" ));
status = STATUS_INTERNAL_ERROR;
}
}
if (NT_SUCCESS(status))
{
// copy strings to the buffer
offset = 0;
if (vendorId != NULL)
{
RtlCopyMemory(deviceString.Buffer + offset,
vendorId,
strlen((LPCSTR)vendorId));
offset += strlen((LPCSTR)vendorId);
}
if ( productId != NULL )
{
RtlCopyMemory(deviceString.Buffer + offset,
productId,
strlen((LPCSTR)productId));
offset += strlen((LPCSTR)productId);
}
if ( revisionId != NULL )
{
RtlCopyMemory(deviceString.Buffer + offset,
revisionId,
strlen((LPCSTR)revisionId));
offset += strlen((LPCSTR)revisionId);
}
NT_ASSERT(offset == deviceString.Length);
#pragma warning(suppress:6386) // Not an issue as deviceString.Buffer is of size deviceString.MaximumLength, which is equal to (deviceString.Length + 1)
deviceString.Buffer[deviceString.Length] = '\0'; // Null-terminated
// convert to unicode as registry deals with unicode strings
status = RtlAnsiStringToUnicodeString( &deviceUnicodeString,
&deviceString,
TRUE
);
if (!NT_SUCCESS(status))
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"DeviceIsMediaChangeDisabledDueToHardwareLimitation: cannot convert "
"to unicode %lx\n", status));
}
}
if (NT_SUCCESS(status))
{
// query the value, setting valueFound to true if found
nullMultiSz = L"\0";
parameters[0].QueryRoutine = DeviceMediaChangeRegistryCallBack;
parameters[0].Flags = RTL_QUERY_REGISTRY_REQUIRED;
parameters[0].Name = L"AutoRunAlwaysDisable";
parameters[0].EntryContext = &mediaChangeNotificationDisabled;
parameters[0].DefaultType = REG_MULTI_SZ;
parameters[0].DefaultData = nullMultiSz;
parameters[0].DefaultLength = 0;
status = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE,
serviceKey,
parameters,
&deviceUnicodeString,
NULL);
UNREFERENCED_PARAMETER(status); //defensive coding, avoid PREFAST warning.
}
}
// Cleanup
{
FREE_POOL( deviceString.Buffer );
if (deviceUnicodeString.Buffer != NULL)
{
RtlFreeUnicodeString( &deviceUnicodeString );
}
// handle serviceKey will be closed by framework while it closes registry key.
WdfRegistryClose(wdfKey);
}
if (mediaChangeNotificationDisabled > 0)
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"DeviceIsMediaChangeDisabledDueToHardwareLimitation: Device is on MCN disable list\n"));
}
return (mediaChangeNotificationDisabled > 0);
} // end DeviceIsMediaChangeDisabledDueToHardwareLimitation()
_IRQL_requires_max_(PASSIVE_LEVEL)
BOOLEAN
DeviceIsMediaChangeDisabledForClass(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension
)
/*++
Routine Description:
The user must specify that AutoPlay is to run on the platform
by setting the registry value HKEY_LOCAL_MACHINE\System\CurrentControlSet\
Services\<SERVICE>\Autorun:REG_DWORD:1.
The user can override the global setting to enable or disable Autorun on a
specific cdrom device via the control panel.
Arguments:
DeviceExtension - device extension
Return Value:
TRUE - Autorun is disabled for this class
FALSE - Autorun is enabled for this class
--*/
{
NTSTATUS status;
WDFKEY serviceKey = NULL;
WDFKEY parametersKey = NULL;
UNICODE_STRING parameterKeyName;
UNICODE_STRING valueName;
// Default to ENABLING MediaChangeNotification (!)
ULONG mcnRegistryValue = 1;
PAGED_CODE();
// open the service key.
status = WdfDriverOpenParametersRegistryKey(WdfGetDriver(),
KEY_ALL_ACCESS,
WDF_NO_OBJECT_ATTRIBUTES,
&serviceKey);
if(!NT_SUCCESS(status))
{
// return the default value, which is the inverse of the registry setting default
// since this routine asks if it's disabled
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"DeviceIsMediaChangeDisabledForClass: Defaulting to %s\n",
(mcnRegistryValue ? "Enabled" : "Disabled")));
return (BOOLEAN)(mcnRegistryValue == 0);
}
else
{
// Open the parameters key (if any) beneath the services key.
RtlInitUnicodeString(&parameterKeyName, L"Parameters");
status = WdfRegistryOpenKey(serviceKey,
&parameterKeyName,
KEY_READ,
WDF_NO_OBJECT_ATTRIBUTES,
&parametersKey);
}
if (!NT_SUCCESS(status))
{
parametersKey = NULL;
}
RtlInitUnicodeString(&valueName, L"Autorun");
// ignore failures
status = WdfRegistryQueryULong(serviceKey,
&valueName,
&mcnRegistryValue);
if (NT_SUCCESS(status))
{
TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_MCN,
"DeviceIsMediaChangeDisabledForClass: <Service>/Autorun flag = %d\n",
mcnRegistryValue));
}
if (parametersKey != NULL)
{
status = WdfRegistryQueryULong(parametersKey,
&valueName,
&mcnRegistryValue);
if (NT_SUCCESS(status))
{
TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_MCN,
"DeviceIsMediaChangeDisabledForClass: <Service>/Parameters/Autorun flag = %d\n",
mcnRegistryValue));
}
WdfRegistryClose(parametersKey);
}
WdfRegistryClose(serviceKey);
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"DeviceIsMediaChangeDisabledForClass: Autoplay for device %p is %s\n",
DeviceExtension->DeviceObject,
(mcnRegistryValue ? "on" : "off")
));
// return if it is _disabled_, which is the
// inverse of the registry setting
return (BOOLEAN)(!mcnRegistryValue);
} // end DeviceIsMediaChangeDisabledForClass()
_IRQL_requires_max_(APC_LEVEL)
VOID
DeviceEnableMediaChangeDetection(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension,
_Inout_ PFILE_OBJECT_CONTEXT FileObjectContext,
_In_ BOOLEAN IgnorePreviousMediaChanges
)
/*++
Routine Description:
When the disable count decrease to 0, enable the MCN
Arguments:
DeviceExtension - the device context
FileObjectContext - the file object context
IgnorePreviousMediaChanges - ignore all previous media changes
Return Value:
None.
--*/
{
PMEDIA_CHANGE_DETECTION_INFO info = DeviceExtension->MediaChangeDetectionInfo;
LONG oldCount;
PAGED_CODE();
if (FileObjectContext)
{
InterlockedDecrement((PLONG)&(FileObjectContext->McnDisableCount));
}
if (info == NULL)
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"DeviceEnableMediaChangeDetection: not initialized\n"));
return;
}
(VOID) KeWaitForMutexObject(&info->MediaChangeMutex,
UserRequest,
KernelMode,
FALSE,
NULL);
oldCount = --info->MediaChangeDetectionDisableCount;
NT_ASSERT(oldCount >= 0);
TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_MCN,
"DeviceEnableMediaChangeDetection: Disable count reduced to %d - \n",
info->MediaChangeDetectionDisableCount));
if (oldCount == 0)
{
if (IgnorePreviousMediaChanges)
{
info->LastReportedMediaDetectionState = info->LastKnownMediaDetectionState;
}
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, "MCN is enabled\n"));
}
else
{
TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_MCN, "MCD still disabled\n"));
}
// Let something else run.
KeReleaseMutex(&info->MediaChangeMutex, FALSE);
return;
} // end DeviceEnableMediaChangeDetection()
_IRQL_requires_max_(APC_LEVEL)
VOID
DeviceDisableMediaChangeDetection(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension,
_Inout_ PFILE_OBJECT_CONTEXT FileObjectContext
)
/*++
Routine Description:
Increase the disable count.
Arguments:
DeviceExtension - the device context
FileObjectContext - the file object context
Return Value:
None.
--*/
{
PMEDIA_CHANGE_DETECTION_INFO info = DeviceExtension->MediaChangeDetectionInfo;
PAGED_CODE();
if (FileObjectContext)
{
InterlockedIncrement((PLONG)&(FileObjectContext->McnDisableCount));
}
if (info == NULL)
{
return;
}
(VOID) KeWaitForMutexObject(&info->MediaChangeMutex,
UserRequest,
KernelMode,
FALSE,
NULL);
info->MediaChangeDetectionDisableCount++;
TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_MCN,
"DisableMediaChangeDetection: disable count is %d\n",
info->MediaChangeDetectionDisableCount));
KeReleaseMutex(&info->MediaChangeMutex, FALSE);
return;
} // end DeviceDisableMediaChangeDetection()
_IRQL_requires_max_(APC_LEVEL)
VOID
DeviceReleaseMcnResources(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension
)
/*++
Routine Description:
This routine will cleanup any resources allocated for MCN. It is called
by classpnp during remove device, and therefore is not typically required
by external drivers.
Arguments:
DeviceExtension - the device context
Return Value:
None.
--*/
{
PMEDIA_CHANGE_DETECTION_INFO info = DeviceExtension->MediaChangeDetectionInfo;
PAGED_CODE()
if(info == NULL)
{
return;
}
if (info->Gesn.Mdl)
{
PIRP irp = WdfRequestWdmGetIrp(info->MediaChangeRequest);
IoFreeMdl(info->Gesn.Mdl);
irp->MdlAddress = NULL;
}
IoFreeIrp(info->MediaChangeSyncIrp);
FREE_POOL(info->Gesn.Buffer);
FREE_POOL(info->SenseBuffer);
if (info->DisplayStateCallbackHandle)
{
PoUnregisterPowerSettingCallback(info->DisplayStateCallbackHandle);
info->DisplayStateCallbackHandle = NULL;
}
FREE_POOL(info);
DeviceExtension->MediaChangeDetectionInfo = NULL;
return;
} // end DeviceReleaseMcnResources()
IO_COMPLETION_ROUTINE RequestMcnSyncIrpCompletion;
NTSTATUS
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
RequestMcnSyncIrpCompletion(
_In_ PDEVICE_OBJECT DeviceObject,
_In_ PIRP Irp,
_In_reads_opt_(_Inexpressible_("varies")) PVOID Context
)
/*++
Routine Description:
The MCN work finishes, reset the fields to allow another MCN request
be scheduled.
Arguments:
DeviceObject - device that the completion routine fires on.
Irp - The irp to be completed.
Context - IRP context
Return Value:
NTSTATUS
--*/
{
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;
}
VOID
RequestSetupMcnSyncIrp(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension
)
/*++
Routine Description:
setup the MCN synchronization irp.
Arguments:
DeviceExtension - the device context
Return Value:
None
--*/
{
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;
}
VOID
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
DeviceMainTimerTickHandler(
_In_ WDFTIMER Timer
)
/*++
Routine Description:
This routine setup a sync irp and send it to the serial queue.
Serial queue will process MCN when receive this sync irp.
Arguments:
Timer - the timer object that fires.
Return Value:
None
--*/
{
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()
_IRQL_requires_max_(APC_LEVEL)
NTSTATUS
DeviceEnableMainTimer(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension
)
/*++
Routine Description:
This routine will allocate timer related resources on the first time call.
Start the timer.
Arguments:
DeviceExtension - the device context
Return Value:
NTSTATUS
--*/
{
NTSTATUS status = STATUS_SUCCESS;
if ((DeviceExtension->MediaChangeDetectionInfo == NULL) ||
(DeviceExtension->MediaChangeDetectionInfo->AsynchronousNotificationSupported != FALSE))
{
// Asynchronous Notification is enabled, timer not needed.
return status;
}
if (DeviceExtension->MainTimer == NULL)
{
//create main timer object.
WDF_TIMER_CONFIG timerConfig;
WDF_OBJECT_ATTRIBUTES timerAttributes;
WDF_TIMER_CONFIG_INIT(&timerConfig, DeviceMainTimerTickHandler);
// Polling frequently on virtual optical devices created by Hyper-V will
// cause a significant perf / power hit. These devices need to be polled
// less frequently for device state changes.
if (TEST_FLAG(DeviceExtension->DeviceAdditionalData.HackFlags, CDROM_HACK_MSFT_VIRTUAL_ODD))
{
timerConfig.Period = 2000; // 2 seconds, in milliseconds.
}
else
{
timerConfig.Period = 1000; // 1 second, in milliseconds.
}
timerConfig.TolerableDelay = 500; // 0.5 seconds, in milliseconds
//Set the autoSerialization to FALSE, as the parent device's
//execute level is WdfExecutionLevelPassive.
timerConfig.AutomaticSerialization = FALSE;
WDF_OBJECT_ATTRIBUTES_INIT(&timerAttributes);
timerAttributes.ParentObject = DeviceExtension->Device;
timerAttributes.ExecutionLevel = WdfExecutionLevelInheritFromParent;
status = WdfTimerCreate(&timerConfig,
&timerAttributes,
&DeviceExtension->MainTimer);
}
if (NT_SUCCESS(status))
{
WdfTimerStart(DeviceExtension->MainTimer,WDF_REL_TIMEOUT_IN_MS(100));
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"DeviceEnableMainTimer: Once a second timer enabled for WDFDEVICE %p\n",
DeviceExtension->Device));
}
else
{
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"DeviceEnableMainTimer: WDFDEVICE %p, Status %lx initializing timer\n",
DeviceExtension->Device, status));
}
return status;
} // end DeviceEnableMainTimer()
_IRQL_requires_max_(PASSIVE_LEVEL)
VOID
DeviceDisableMainTimer(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension
)
/*++
Routine Description:
stop the timer.
Arguments:
DeviceExtension - device context
Return Value:
None
--*/
{
PAGED_CODE();
if ((DeviceExtension->MediaChangeDetectionInfo == NULL) ||
(DeviceExtension->MediaChangeDetectionInfo->AsynchronousNotificationSupported != FALSE))
{
// Asynchronous Notification is enabled, timer not needed.
return;
}
if (DeviceExtension->MainTimer != NULL)
{
//
// we are only going to stop the actual timer in remove device routine.
// it is the responsibility of the code within the timer routine to
// check if the device is removed and not processing io for the final
// call.
// this keeps the code clean and prevents lots of bugs.
//
WdfTimerStop(DeviceExtension->MainTimer,TRUE);
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
"DeviceDisableMainTimer: Once a second timer disabled for device %p\n",
DeviceExtension->Device));
}
else
{
TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN,
"DeviceDisableMainTimer: Timer never enabled\n"));
}
return;
} // end DeviceDisableMainTimer()
_IRQL_requires_max_(APC_LEVEL)
NTSTATUS
RequestHandleMcnControl(
_In_ PCDROM_DEVICE_EXTENSION DeviceExtension,
_In_ WDFREQUEST Request,
_Out_ size_t * DataLength
)
/*++
Routine Description:
This routine handles the process of IOCTL_STORAGE_MCN_CONTROL
Arguments:
DeviceExtension - device context
Request - request object
RequestParameters - request parameters
DataLength - data transferred
Return Value:
NTSTATUS
--*/
{
NTSTATUS status = STATUS_SUCCESS;
WDFFILEOBJECT fileObject = NULL;
PFILE_OBJECT_CONTEXT fileObjectContext = NULL;
PPREVENT_MEDIA_REMOVAL mediaRemoval = NULL;
PAGED_CODE();
*DataLength = 0;
status = WdfRequestRetrieveInputBuffer(Request,
sizeof(PREVENT_MEDIA_REMOVAL),
&mediaRemoval,
NULL);
if (NT_SUCCESS(status))
{
fileObject = WdfRequestGetFileObject(Request);
// Check to make sure we have a file object extension to keep track of this
// request. If not we'll fail it before synchronizing.
if (fileObject != NULL)
{
fileObjectContext = FileObjectGetContext(fileObject);
}
if ((fileObjectContext == NULL) &&
(WdfRequestGetRequestorMode(Request) == KernelMode))
{
fileObjectContext = &DeviceExtension->KernelModeMcnContext;
}
if (fileObjectContext == NULL)
{
// This handle isn't setup correctly. We can't let the
// operation go.
status = STATUS_INVALID_PARAMETER;
}
}
if (NT_SUCCESS(status))
{
if (mediaRemoval->PreventMediaRemoval)
{
// This is a lock command. Reissue the command in case bus or
// device was reset and the lock was cleared.
DeviceDisableMediaChangeDetection(DeviceExtension, fileObjectContext);
}
else
{
if (fileObjectContext->McnDisableCount == 0)
{
status = STATUS_INVALID_DEVICE_STATE;
}
else
{
DeviceEnableMediaChangeDetection(DeviceExtension, fileObjectContext, TRUE);
}
}
}
return status;
} // end RequestHandleMcnControl()
#pragma warning(pop) // un-sets any local warning changes
Reference in a new issue View git blame Copy permalink