/*-- Copyright (C) Microsoft Corporation, 2000 Module Name: mmc.c Abstract: This file is used to extend cdrom.sys to detect and use mmc-compatible drives' capabilities more wisely. Environment: kernel mode only Notes: SCSI Tape, CDRom and Disk class drivers share common routines that can be found in the CLASS directory (..\ntos\dd\class). Revision History: --*/ #include "ntddk.h" #include "classpnp.h" #include "cdrom.h" #include "mmc.tmh" NTSTATUS CdRomGetConfiguration( IN PDEVICE_OBJECT Fdo, OUT PGET_CONFIGURATION_HEADER *Buffer, OUT PULONG BytesReturned, IN FEATURE_NUMBER StartingFeature, IN ULONG RequestedType ); VOID CdRompPrintAllFeaturePages( IN PGET_CONFIGURATION_HEADER Buffer, IN ULONG Usable ); NTSTATUS CdRomUpdateMmcDriveCapabilitiesCompletion( IN PDEVICE_OBJECT Unused, IN PIRP Irp, IN PDEVICE_OBJECT Fdo ); VOID CdRomPrepareUpdateCapabilitiesIrp( PDEVICE_OBJECT Fdo ); /*++ NOT DOCUMENTED YET - may be called at up to DISPATCH_LEVEL if memory is non-paged PRESUMES ALL DATA IS ACCESSIBLE based on FeatureBuffer --*/ VOID CdRomFindProfileInProfiles( IN PFEATURE_DATA_PROFILE_LIST ProfileHeader, IN FEATURE_PROFILE_TYPE ProfileToFind, OUT PBOOLEAN Found ) { PFEATURE_DATA_PROFILE_LIST_EX profile; ULONG numberOfProfiles; ULONG i; ASSERT((ProfileHeader->Header.AdditionalLength % 4) == 0); *Found = FALSE; numberOfProfiles = ProfileHeader->Header.AdditionalLength / 4; profile = ProfileHeader->Profiles; // zero-sized array for (i = 0; i < numberOfProfiles; i++) { FEATURE_PROFILE_TYPE currentProfile; currentProfile = (profile->ProfileNumber[0] << 8) | (profile->ProfileNumber[1] & 0xff); if (currentProfile == ProfileToFind) { *Found = TRUE; } profile++; } return; } /*++ NOT DOCUMENTED YET - may be called at up to DISPATCH_LEVEL if memory is non-paged --*/ PVOID CdRomFindFeaturePage( IN PGET_CONFIGURATION_HEADER FeatureBuffer, IN ULONG Length, IN FEATURE_NUMBER Feature ) { PUCHAR buffer; PUCHAR limit; if (Length < sizeof(GET_CONFIGURATION_HEADER) + sizeof(FEATURE_HEADER)) { return NULL; } // // set limit to point to first illegal address // limit = (PUCHAR)FeatureBuffer; limit += Length; // // set buffer to point to first page // buffer = FeatureBuffer->Data; // // loop through each page until we find the requested one, or // until it's not safe to access the entire feature header // (if equal, have exactly enough for the feature header) // while (buffer + sizeof(FEATURE_HEADER) <= limit) { PFEATURE_HEADER header = (PFEATURE_HEADER)buffer; FEATURE_NUMBER thisFeature; thisFeature = (header->FeatureCode[0] << 8) | (header->FeatureCode[1]); if (thisFeature == Feature) { PUCHAR temp; // // if don't have enough memory to safely access all the feature // information, return NULL // temp = buffer; temp += sizeof(FEATURE_HEADER); temp += header->AdditionalLength; if (temp > limit) { // // this means the transfer was cut-off, an insufficiently // small buffer was given, or other arbitrary error. since // it's not safe to view the amount of data (even though // the header is safe) in this feature, pretend it wasn't // transferred at all... // KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "Feature %x exists, but not safe to access all its " "data. returning NULL\n", Feature)); return NULL; } else { return buffer; } } if (header->AdditionalLength % 4) { ASSERT(!"Feature page AdditionalLength field must be integral multiple of 4!\n"); return NULL; } buffer += sizeof(FEATURE_HEADER); buffer += header->AdditionalLength; } return NULL; } /*++ Private so we can later expose to someone wanting to use a preallocated buffer --*/ NTSTATUS CdRompGetConfiguration( IN PDEVICE_OBJECT Fdo, IN PGET_CONFIGURATION_HEADER Buffer, IN ULONG BufferSize, OUT PULONG ValidBytes, IN FEATURE_NUMBER StartingFeature, IN ULONG RequestedType ) { PFUNCTIONAL_DEVICE_EXTENSION fdoExtension; PCDROM_DATA cdData; SCSI_REQUEST_BLOCK srb; PCDB cdb; ULONG_PTR returned; NTSTATUS status; PAGED_CODE(); ASSERT(Buffer); ASSERT(ValidBytes); *ValidBytes = 0; returned = 0; RtlZeroMemory(&srb, sizeof(SCSI_REQUEST_BLOCK)); RtlZeroMemory(Buffer, BufferSize); fdoExtension = Fdo->DeviceExtension; cdData = (PCDROM_DATA)(fdoExtension->CommonExtension.DriverData); if (TEST_FLAG(cdData->HackFlags, CDROM_HACK_BAD_GET_CONFIG_SUPPORT)) { return STATUS_INVALID_DEVICE_REQUEST; } srb.TimeOutValue = CDROM_GET_CONFIGURATION_TIMEOUT; srb.CdbLength = 10; cdb = (PCDB)srb.Cdb; cdb->GET_CONFIGURATION.OperationCode = SCSIOP_GET_CONFIGURATION; cdb->GET_CONFIGURATION.RequestType = (UCHAR)RequestedType; cdb->GET_CONFIGURATION.StartingFeature[0] = (UCHAR)(StartingFeature >> 8); cdb->GET_CONFIGURATION.StartingFeature[1] = (UCHAR)(StartingFeature & 0xff); cdb->GET_CONFIGURATION.AllocationLength[0] = (UCHAR)(BufferSize >> 8); cdb->GET_CONFIGURATION.AllocationLength[1] = (UCHAR)(BufferSize & 0xff); status = ClassSendSrbSynchronous(Fdo, &srb, Buffer, BufferSize, FALSE); returned = srb.DataTransferLength; KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: Status was %x\n", status)); if (NT_SUCCESS(status) || status == STATUS_BUFFER_OVERFLOW) { // // if returned more than can be stored in a ULONG, return false // if (returned > (ULONG)(-1)) { return STATUS_UNSUCCESSFUL; } ASSERT(returned <= BufferSize); *ValidBytes = (ULONG)returned; return STATUS_SUCCESS; } else { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: failed %x\n", status)); return status; } ASSERT(FALSE); return STATUS_UNSUCCESSFUL; } /*++ Allocates buffer with configuration info, returns STATUS_SUCCESS or an error if one occurred NOTE: does not handle case where more than 65000 bytes are returned, which requires multiple calls with different starting feature numbers. --*/ NTSTATUS CdRomGetConfiguration( IN PDEVICE_OBJECT Fdo, OUT PGET_CONFIGURATION_HEADER *Buffer, OUT PULONG BytesReturned, IN FEATURE_NUMBER StartingFeature, IN ULONG RequestedType ) { PFUNCTIONAL_DEVICE_EXTENSION fdoExtension; GET_CONFIGURATION_HEADER header; // eight bytes, not a lot PGET_CONFIGURATION_HEADER buffer; ULONG returned; ULONG size; ULONG i; NTSTATUS status; PAGED_CODE(); fdoExtension = Fdo->DeviceExtension; *Buffer = NULL; *BytesReturned = 0; buffer = NULL; returned = 0; // // send the first request down to just get the header // status = CdRompGetConfiguration(Fdo, &header, sizeof(header), &returned, StartingFeature, RequestedType); if (!NT_SUCCESS(status)) { return status; } // // now try again, using information returned to allocate // just enough memory // size = header.DataLength[0] << 24 | header.DataLength[1] << 16 | header.DataLength[2] << 8 | header.DataLength[3] << 0 ; for (i = 0; i < 4; i++) { // // the datalength field is the size *following* // itself, so adjust accordingly // size += 4*sizeof(UCHAR); // // make sure the size is reasonable // if (size <= sizeof(FEATURE_HEADER)) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: drive reports only %x bytes?\n", size)); return STATUS_UNSUCCESSFUL; } // // allocate the memory // buffer = (PGET_CONFIGURATION_HEADER) ExAllocatePoolWithTag(NonPagedPoolCacheAligned, size, CDROM_TAG_FEATURE); if (buffer == NULL) { return STATUS_INSUFFICIENT_RESOURCES; } // // send the first request down to just get the header // status = CdRompGetConfiguration(Fdo, buffer, size, &returned, StartingFeature, RequestedType); if (!NT_SUCCESS(status)) { ExFreePool(buffer); return status; } if (returned > size) { ExFreePool(buffer); return STATUS_INTERNAL_ERROR; } returned = buffer->DataLength[0] << 24 | buffer->DataLength[1] << 16 | buffer->DataLength[2] << 8 | buffer->DataLength[3] << 0 ; returned += 4*sizeof(UCHAR); if (returned <= size) { *Buffer = buffer; *BytesReturned = size; // amount of 'safe' memory return STATUS_SUCCESS; } // // else retry using the new size.... // size = returned; ExFreePool(buffer); buffer = NULL; } // // it failed after a number of attempts, so just fail. // KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdRomGetConfiguration: Failed %d attempts to get all feature " "information\n", i)); return STATUS_IO_DEVICE_ERROR; } VOID CdRomIsDeviceMmcDevice( IN PDEVICE_OBJECT Fdo, OUT PBOOLEAN IsMmc ) { PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension; PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension; PCDROM_DATA cdData = commonExtension->DriverData; GET_CONFIGURATION_HEADER localHeader; NTSTATUS status; ULONG usable; ULONG size; ULONG previouslyFailed; PAGED_CODE(); ASSERT( commonExtension->IsFdo ); *IsMmc = FALSE; // // read the registry in case the drive failed previously, // and a timeout is occurring. // previouslyFailed = FALSE; ClassGetDeviceParameter(fdoExtension, CDROM_SUBKEY_NAME, CDROM_NON_MMC_DRIVE_NAME, &previouslyFailed ); if (previouslyFailed) { SET_FLAG(cdData->HackFlags, CDROM_HACK_BAD_GET_CONFIG_SUPPORT); } // // check for the following profiles: // // ProfileList // status = CdRompGetConfiguration(Fdo, &localHeader, sizeof(localHeader), &usable, FeatureProfileList, SCSI_GET_CONFIGURATION_REQUEST_TYPE_ALL); if (status == STATUS_INVALID_DEVICE_REQUEST || status == STATUS_NO_MEDIA_IN_DEVICE || status == STATUS_IO_DEVICE_ERROR || status == STATUS_IO_TIMEOUT) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "GetConfiguration Failed (%x), device %p not mmc-compliant\n", status, Fdo )); previouslyFailed = TRUE; ClassSetDeviceParameter(fdoExtension, CDROM_SUBKEY_NAME, CDROM_NON_MMC_DRIVE_NAME, previouslyFailed ); return; } else if (!NT_SUCCESS(status)) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugError, "GetConfiguration Failed, status %x -- defaulting to -ROM\n", status)); return; } else if (usable < sizeof(GET_CONFIGURATION_HEADER)) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "GetConfiguration Failed, returned only %x bytes!\n", usable)); previouslyFailed = TRUE; ClassSetDeviceParameter(fdoExtension, CDROM_SUBKEY_NAME, CDROM_NON_MMC_DRIVE_NAME, previouslyFailed ); return; } size = (localHeader.DataLength[0] << 24) | (localHeader.DataLength[1] << 16) | (localHeader.DataLength[2] << 8) | (localHeader.DataLength[3] << 0); if(size <= 4) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "GetConfiguration Failed, claims MMC support but doesn't " "correctly return config length!\n")); return; } size += 4; // sizeof the datalength fields #if DBG { PGET_CONFIGURATION_HEADER dbgBuffer; NTSTATUS dbgStatus; dbgBuffer = ExAllocatePoolWithTag(NonPagedPoolCacheAligned, (SIZE_T)size, CDROM_TAG_FEATURE); if (dbgBuffer != NULL) { RtlZeroMemory(dbgBuffer, size); dbgStatus = CdRompGetConfiguration(Fdo, dbgBuffer, size, &size, FeatureProfileList, SCSI_GET_CONFIGURATION_REQUEST_TYPE_ALL); if (NT_SUCCESS(dbgStatus)) { CdRompPrintAllFeaturePages(dbgBuffer, usable); } ExFreePool(dbgBuffer); } } #endif // DBG *IsMmc = TRUE; return; } VOID CdRompPrintAllFeaturePages( IN PGET_CONFIGURATION_HEADER Buffer, IN ULONG Usable ) { PFEATURE_HEADER header; //////////////////////////////////////////////////////////////////////////////// // items expected to ALWAYS be current //////////////////////////////////////////////////////////////////////////////// header = CdRomFindFeaturePage(Buffer, Usable, FeatureProfileList); if (header != NULL) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: CurrentProfile %x " "with %x bytes of data at %p\n", Buffer->CurrentProfile[0] << 8 | Buffer->CurrentProfile[1], Usable, Buffer)); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureCore); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "CORE Features" )); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureMorphing); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Morphing" )); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureMultiRead); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Multi-Read" )); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureRemovableMedium); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Removable Medium" )); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureTimeout); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Timeouts" )); } header = CdRomFindFeaturePage(Buffer, Usable, FeaturePowerManagement); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Power Management" )); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureEmbeddedChanger); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Embedded Changer" )); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureLogicalUnitSerialNumber); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "LUN Serial Number" )); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureMicrocodeUpgrade); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Microcode Update" )); } //////////////////////////////////////////////////////////////////////////////// // items expected not to always be current //////////////////////////////////////////////////////////////////////////////// header = CdRomFindFeaturePage(Buffer, Usable, FeatureCDAudioAnalogPlay); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Analogue CD Audio Operations" )); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureCdRead); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "reading from CD-ROM/R/RW" )); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureCdMastering); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "CD Recording (Mastering)" )); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureCdTrackAtOnce); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "CD Recording (Track At Once)" )); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureDvdCSS); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "DVD CSS" )); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureDvdRead); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "DVD Structure Reads" )); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureDvdRecordableWrite); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "DVD Recording (Mastering)" )); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureDiscControlBlocks); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "DVD Disc Control Blocks" )); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureFormattable); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Formatting" )); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureRandomReadable); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Random Reads" )); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureRandomWritable); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Random Writes" )); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureRestrictedOverwrite); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Restricted Overwrites." )); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureWriteOnce); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Write Once Media" )); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureSectorErasable); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Sector Erasable Media" )); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureIncrementalStreamingWritable); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Incremental Streaming Writing" )); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureRealTimeStreaming); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Real-time Streaming Reads" )); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureSMART); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "S.M.A.R.T." )); } header = CdRomFindFeaturePage(Buffer, Usable, FeatureDefectManagement); if (header) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "defect management" )); } return; } NTSTATUS CdRomUpdateMmcDriveCapabilitiesCompletion( IN PDEVICE_OBJECT Unused, IN PIRP Irp, IN PDEVICE_OBJECT Fdo ) { PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension; PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension; PCDROM_DATA cdData = fdoExtension->CommonExtension.DriverData; PCDROM_MMC_EXTENSION mmcData = &(cdData->Mmc); PSCSI_REQUEST_BLOCK srb = &(mmcData->CapabilitiesSrb); PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp); NTSTATUS status = STATUS_UNSUCCESSFUL; PIRP delayedIrp; // completion routine should retry as neccessary. // when success, clear the flag to allow startio to proceed. // else fail original request when retries are exhausted. ASSERT(mmcData->CapabilitiesIrp == Irp); // for now, if succeeded, just print the new pages. if (SRB_STATUS(srb->SrbStatus) != SRB_STATUS_SUCCESS) { // // ISSUE-2000/4/20-henrygab - should we try to reallocate if size // available became larger than what we // originally allocated? otherwise, it // is possible (not probable) that we // would miss the feature. can check // that by finding out what the last // feature is in the current group. // BOOLEAN retry; ULONG retryInterval; // // Release the queue if it is frozen. // if (srb->SrbStatus & SRB_STATUS_QUEUE_FROZEN) { ClassReleaseQueue(Fdo); } retry = ClassInterpretSenseInfo( Fdo, srb, irpStack->MajorFunction, 0, MAXIMUM_RETRIES - ((ULONG)(ULONG_PTR)irpStack->Parameters.Others.Argument4), &status, &retryInterval); // // DATA_OVERRUN is not an error in this case.... // if (status == STATUS_DATA_OVERRUN) { status = STATUS_SUCCESS; } // // override verify_volume based on original irp's settings // if (TEST_FLAG(irpStack->Flags, SL_OVERRIDE_VERIFY_VOLUME) && status == STATUS_VERIFY_REQUIRED) { status = STATUS_IO_DEVICE_ERROR; retry = TRUE; } if (retry && ((ULONG)(ULONG_PTR)irpStack->Parameters.Others.Argument4)--) { LARGE_INTEGER delay; delay.QuadPart = retryInterval; delay.QuadPart *= (LONGLONG)1000 * 1000 * 10; // // retry the request // KdPrintEx((DPFLTR_CDROM_ID, CdromDebugError, "Not using ClassRetryRequest Yet\n")); KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "Retry update capabilities %p\n", Irp)); CdRomPrepareUpdateCapabilitiesIrp(Fdo); CdRomRetryRequest(fdoExtension, Irp, retryInterval, TRUE); // // ClassRetryRequest(Fdo, Irp, delay); // return STATUS_MORE_PROCESSING_REQUIRED; } } else { status = STATUS_SUCCESS; } Irp->IoStatus.Status = status; KeSetEvent(&mmcData->CapabilitiesEvent, IO_CD_ROM_INCREMENT, FALSE); return STATUS_MORE_PROCESSING_REQUIRED; } VOID CdRomPrepareUpdateCapabilitiesIrp( PDEVICE_OBJECT Fdo ) { PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension; PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension; PCDROM_DATA cdData = fdoExtension->CommonExtension.DriverData; PCDROM_MMC_EXTENSION mmcData = &(cdData->Mmc); PIO_STACK_LOCATION nextStack; PSCSI_REQUEST_BLOCK srb; PCDB cdb; ULONG bufferSize; PIRP irp; ASSERT(mmcData->UpdateState); ASSERT(mmcData->NumDelayedIrps != 0); ASSERT(mmcData->CapabilitiesIrp != NULL); ASSERT(mmcData->CapabilitiesMdl != NULL); ASSERT(mmcData->CapabilitiesBuffer); ASSERT(mmcData->CapabilitiesBufferSize != 0); ASSERT(fdoExtension->SenseData); // // do *NOT* call IoReuseIrp(), since it would zero out our // current irp stack location, which we really don't want // to happen. it would also set the current irp stack location // to one greater than currently exists (to give max irp usage), // but we don't want that either, since we use the top irp stack. // // IoReuseIrp(mmcData->CapabilitiesIrp, STATUS_UNSUCCESSFUL); // irp = mmcData->CapabilitiesIrp; srb = &(mmcData->CapabilitiesSrb); cdb = (PCDB)(srb->Cdb); bufferSize = mmcData->CapabilitiesBufferSize; // // zero stuff out // RtlZeroMemory(srb, sizeof(SCSI_REQUEST_BLOCK)); RtlZeroMemory(fdoExtension->SenseData, sizeof(SENSE_DATA)); RtlZeroMemory(mmcData->CapabilitiesBuffer, bufferSize); // // setup the srb // srb->TimeOutValue = CDROM_GET_CONFIGURATION_TIMEOUT; srb->Length = SCSI_REQUEST_BLOCK_SIZE; srb->Function = SRB_FUNCTION_EXECUTE_SCSI; srb->SenseInfoBufferLength = SENSE_BUFFER_SIZE; srb->SenseInfoBuffer = fdoExtension->SenseData; srb->DataBuffer = mmcData->CapabilitiesBuffer; srb->QueueAction = SRB_SIMPLE_TAG_REQUEST; srb->DataTransferLength = mmcData->CapabilitiesBufferSize; srb->ScsiStatus = 0; srb->SrbStatus = 0; srb->NextSrb = NULL; srb->OriginalRequest = irp; srb->SrbFlags = fdoExtension->SrbFlags; srb->CdbLength = 10; SET_FLAG(srb->SrbFlags, SRB_FLAGS_DATA_IN); SET_FLAG(srb->SrbFlags, SRB_FLAGS_NO_QUEUE_FREEZE); // // setup the cdb // cdb->GET_CONFIGURATION.OperationCode = SCSIOP_GET_CONFIGURATION; cdb->GET_CONFIGURATION.RequestType = SCSI_GET_CONFIGURATION_REQUEST_TYPE_CURRENT; cdb->GET_CONFIGURATION.StartingFeature[0] = 0; cdb->GET_CONFIGURATION.StartingFeature[1] = 0; cdb->GET_CONFIGURATION.AllocationLength[0] = (UCHAR)(bufferSize >> 8); cdb->GET_CONFIGURATION.AllocationLength[1] = (UCHAR)(bufferSize & 0xff); // // setup the irp // nextStack = IoGetNextIrpStackLocation(irp); nextStack->MajorFunction = IRP_MJ_SCSI; nextStack->Parameters.Scsi.Srb = srb; irp->MdlAddress = mmcData->CapabilitiesMdl; irp->AssociatedIrp.SystemBuffer = mmcData->CapabilitiesBuffer; IoSetCompletionRoutine(irp, CdRomUpdateMmcDriveCapabilitiesCompletion, Fdo, TRUE, TRUE, TRUE); return; } VOID CdRomUpdateMmcDriveCapabilities( IN PDEVICE_OBJECT Fdo, IN PVOID Context ) { PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension; PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension; PCDROM_DATA cdData = fdoExtension->CommonExtension.DriverData; PCDROM_MMC_EXTENSION mmcData = &(cdData->Mmc); PIO_STACK_LOCATION thisStack = IoGetCurrentIrpStackLocation(mmcData->CapabilitiesIrp); PSCSI_REQUEST_BLOCK srb = &(mmcData->CapabilitiesSrb); NTSTATUS status; ASSERT(Context == NULL); // // NOTE: a remove lock is unneccessary, since the delayed irp // will have said lock held for itself, preventing a remove. // CdRomPrepareUpdateCapabilitiesIrp(Fdo); ASSERT(thisStack->Parameters.Others.Argument1 == Fdo); ASSERT(thisStack->Parameters.Others.Argument2 == mmcData->CapabilitiesBuffer); ASSERT(thisStack->Parameters.Others.Argument3 == &(mmcData->CapabilitiesSrb)); mmcData->WriteAllowed = FALSE; // default to read-only // // set max retries, and also allow volume verify override based on // original (delayed) irp // thisStack->Parameters.Others.Argument4 = (PVOID)MAXIMUM_RETRIES; // // send to self... note that SL_OVERRIDE_VERIFY_VOLUME is not required, // as this is IRP_MJ_INTERNAL_DEVICE_CONTROL // IoCallDriver(commonExtension->LowerDeviceObject, mmcData->CapabilitiesIrp); KeWaitForSingleObject(&mmcData->CapabilitiesEvent, Executive, KernelMode, FALSE, NULL); status = mmcData->CapabilitiesIrp->IoStatus.Status; if (!NT_SUCCESS(status)) { goto FinishDriveUpdate; } // // we've updated the feature set, so update whether or not reads and writes // are allowed or not. // KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdRomUpdateMmc => Succeeded " "--------------------" "--------------------\n")); /*++ NOTE: It is important to only use srb->DataTransferLength worth of data at this point, since the bufferSize is what is *available* to use, not what was *actually* used. --*/ #if DBG CdRompPrintAllFeaturePages(mmcData->CapabilitiesBuffer, srb->DataTransferLength); #endif // DBG // // update whether or not writes are allowed. this is currently defined // as requiring TargetDefectManagement and RandomWritable features // { PFEATURE_HEADER defectHeader; PFEATURE_HEADER writableHeader; defectHeader = CdRomFindFeaturePage(mmcData->CapabilitiesBuffer, srb->DataTransferLength, FeatureDefectManagement); writableHeader = CdRomFindFeaturePage(mmcData->CapabilitiesBuffer, srb->DataTransferLength, FeatureRandomWritable); if ((defectHeader != NULL) && (writableHeader != NULL) && (defectHeader->Current) && (writableHeader->Current)) { // // this should be the *ONLY* place writes are set to allowed // KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdRomUpdateMmc => Writes *allowed*\n")); mmcData->WriteAllowed = TRUE; } else { if (defectHeader == NULL) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdRomUpdateMmc => No writes - %s = %s\n", "defect management", "DNE")); } else { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdRomUpdateMmc => No writes - %s = %s\n", "defect management", "Not Current")); } if (writableHeader == NULL) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdRomUpdateMmc => No writes - %s = %s\n", "sector writable", "DNE")); } else { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdRomUpdateMmc => No writes - %s = %s\n", "sector writable", "Not Current")); } } // end of feature checking } // end of check for writability // // update the cached partition table information // // NOTE: THIS WILL CURRENTLY CAUSE A DEADLOCK! // // ISSUE-2000/06/20-henrygab - partition support not implemented // IoReadPartitionTable must be done // at PASSIVE level, requiring a thread // or worker item or other such method. // #if 0 status = IoReadPartitionTable(Fdo, 1 << fdoExtension->SectorShift, TRUE, &mmcData->PartitionList); if (!NT_SUCCESS(status)) { goto FinishDriveUpdate; } #endif status = STATUS_SUCCESS; FinishDriveUpdate: CdRompFlushDelayedList(Fdo, mmcData, status, TRUE); return; } VOID CdRompFlushDelayedList( IN PDEVICE_OBJECT Fdo, IN PCDROM_MMC_EXTENSION MmcData, IN NTSTATUS Status, IN BOOLEAN CalledFromWorkItem ) { LIST_ENTRY irpList; PLIST_ENTRY listEntry; KIRQL oldIrql; // NOTE - REF #0002 // // need to set the new state first to prevent deadlocks. // this is only done from the workitem, to prevent any // edge cases where we'd "lose" the UpdateRequired // // then, must ignore the state, since it's not guaranteed to // be the same any longer. the only thing left is to handle // all the delayed irps by flushing the queue and sending them // back onto the StartIo queue for the device. // if (CalledFromWorkItem) { LONG oldState; LONG newState; if (NT_SUCCESS(Status)) { newState = CdromMmcUpdateComplete; } else { newState = CdromMmcUpdateRequired; } oldState = InterlockedCompareExchange(&MmcData->UpdateState, newState, CdromMmcUpdateStarted); ASSERT(oldState == CdromMmcUpdateStarted); } else { // // just flushing the queue if not called from the workitem, // and we don't want to ever fail the queue in those cases. // ASSERT(NT_SUCCESS(Status)); } /* * Get all the delayed IRPs into a private list first to avoid an infinite loop * where irps are added to the DelayedIrpsList while we are siphoning them off. */ InitializeListHead(&irpList); KeAcquireSpinLock(&MmcData->DelayedIrpsLock, &oldIrql); while (!IsListEmpty(&MmcData->DelayedIrpsList)){ listEntry = RemoveHeadList(&MmcData->DelayedIrpsList); InsertTailList(&irpList, listEntry); ASSERT(MmcData->NumDelayedIrps > 0); MmcData->NumDelayedIrps--; } ASSERT(MmcData->NumDelayedIrps == 0); KeReleaseSpinLock(&MmcData->DelayedIrpsLock, oldIrql); // if this assert fires, it means that we have started // a workitem when the previous workitem took the delayed // irp. if this happens, then the logic in HACKHACK #0002 // is either flawed or the rules set within are not being // followed. this would require investigation. ASSERT(!IsListEmpty(&irpList)); // // now either succeed or fail all the delayed irps, according // to the update status. // while (!IsListEmpty(&irpList)){ PIRP irp; listEntry = RemoveHeadList(&irpList); irp = CONTAINING_RECORD(listEntry, IRP, Tail.Overlay.ListEntry); irp->Tail.Overlay.DriverContext[0] = 0; irp->Tail.Overlay.DriverContext[1] = 0; irp->Tail.Overlay.DriverContext[2] = 0; irp->Tail.Overlay.DriverContext[3] = 0; if (NT_SUCCESS(Status)) { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdRomUpdateMmc => Re-sending delayed irp %p\n", irp)); IoStartPacket(Fdo, irp, NULL, NULL); } else { KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures, "CdRomUpdateMmc => Failing delayed irp %p with " " status %x\n", irp, Status)); irp->IoStatus.Information = 0; irp->IoStatus.Status = Status; ClassReleaseRemoveLock(Fdo, irp); IoCompleteRequest(irp, IO_CD_ROM_INCREMENT); } } // while (list) return; } VOID CdRomDeAllocateMmcResources( IN PDEVICE_OBJECT Fdo ) { PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension; PCDROM_DATA cddata = commonExtension->DriverData; PCDROM_MMC_EXTENSION mmcData = &cddata->Mmc; NTSTATUS status; if (mmcData->CapabilitiesWorkItem) { IoFreeWorkItem(mmcData->CapabilitiesWorkItem); mmcData->CapabilitiesWorkItem = NULL; } if (mmcData->CapabilitiesIrp) { IoFreeIrp(mmcData->CapabilitiesIrp); mmcData->CapabilitiesIrp = NULL; } if (mmcData->CapabilitiesMdl) { IoFreeMdl(mmcData->CapabilitiesMdl); mmcData->CapabilitiesMdl = NULL; } if (mmcData->CapabilitiesBuffer) { ExFreePool(mmcData->CapabilitiesBuffer); mmcData->CapabilitiesBuffer = NULL; } mmcData->CapabilitiesBuffer = 0; mmcData->IsMmc = FALSE; mmcData->WriteAllowed = FALSE; return; } NTSTATUS CdRomAllocateMmcResources( IN PDEVICE_OBJECT Fdo ) { PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension; PCDROM_DATA cddata = commonExtension->DriverData; PCDROM_MMC_EXTENSION mmcData = &cddata->Mmc; PIO_STACK_LOCATION irpStack; NTSTATUS status; ASSERT(mmcData->CapabilitiesWorkItem == NULL); ASSERT(mmcData->CapabilitiesIrp == NULL); ASSERT(mmcData->CapabilitiesMdl == NULL); ASSERT(mmcData->CapabilitiesBuffer == NULL); ASSERT(mmcData->CapabilitiesBufferSize == 0); status = CdRomGetConfiguration(Fdo, &mmcData->CapabilitiesBuffer, &mmcData->CapabilitiesBufferSize, FeatureProfileList, SCSI_GET_CONFIGURATION_REQUEST_TYPE_ALL); if (!NT_SUCCESS(status)) { ASSERT(mmcData->CapabilitiesBuffer == NULL); ASSERT(mmcData->CapabilitiesBufferSize == 0); return status; } ASSERT(mmcData->CapabilitiesBuffer != NULL); ASSERT(mmcData->CapabilitiesBufferSize != 0); mmcData->CapabilitiesMdl = IoAllocateMdl(mmcData->CapabilitiesBuffer, mmcData->CapabilitiesBufferSize, FALSE, FALSE, NULL); if (mmcData->CapabilitiesMdl == NULL) { ExFreePool(mmcData->CapabilitiesBuffer); mmcData->CapabilitiesBufferSize = 0; return STATUS_INSUFFICIENT_RESOURCES; } mmcData->CapabilitiesIrp = IoAllocateIrp(Fdo->StackSize + 2, FALSE); if (mmcData->CapabilitiesIrp == NULL) { IoFreeMdl(mmcData->CapabilitiesMdl); ExFreePool(mmcData->CapabilitiesBuffer); mmcData->CapabilitiesBufferSize = 0; return STATUS_INSUFFICIENT_RESOURCES; } mmcData->CapabilitiesWorkItem = IoAllocateWorkItem(Fdo); if (mmcData->CapabilitiesWorkItem == NULL) { IoFreeIrp(mmcData->CapabilitiesIrp); IoFreeMdl(mmcData->CapabilitiesMdl); ExFreePool(mmcData->CapabilitiesBuffer); mmcData->CapabilitiesBufferSize = 0; return STATUS_INSUFFICIENT_RESOURCES; } // // everything has been allocated, so now prepare it all.... // MmBuildMdlForNonPagedPool(mmcData->CapabilitiesMdl); InitializeListHead(&mmcData->DelayedIrpsList); KeInitializeSpinLock(&mmcData->DelayedIrpsLock); mmcData->NumDelayedIrps = 0; // // use the extra stack for internal bookkeeping // IoSetNextIrpStackLocation(mmcData->CapabilitiesIrp); irpStack = IoGetCurrentIrpStackLocation(mmcData->CapabilitiesIrp); irpStack->Parameters.Others.Argument1 = Fdo; irpStack->Parameters.Others.Argument2 = mmcData->CapabilitiesBuffer; irpStack->Parameters.Others.Argument3 = &(mmcData->CapabilitiesSrb); // arg 4 is the retry count // // set the completion event to FALSE for now // KeInitializeEvent(&mmcData->CapabilitiesEvent, SynchronizationEvent, FALSE); return STATUS_SUCCESS; }