init.c File Reference

#include "ntddk.h"
#include "ntddstor.h"
#include "ntstrsafe.h"
#include "devpkey.h"
#include "cdrom.h"
#include "scratch.h"
#include "mmc.h"

Include dependency graph for init.c:

Go to the source code of this file.

Functions
	_IRQL_requires_max_ (APC_LEVEL)
NTSTATUS NTAPI	DeviceEvtSelfManagedIoInit (_In_ WDFDEVICE Device)
	_IRQL_requires_max_ (PASSIVE_LEVEL)

Function Documentation

_IRQL_requires_max_() [1/2]

_IRQL_requires_max_

(

APC_LEVEL

)

Definition at line 38 of file init.c.

                       :4152) // nonstandard extension, function/data pointer conversion in expression
#pragma warning(disable:26000) // read overflow reported because of pointer type conversion
 
_IRQL_requires_max_(PASSIVE_LEVEL)
NTSTATUS
DeviceClaimRelease(
    _In_ PCDROM_DEVICE_EXTENSION DeviceExtension,
    _In_ BOOLEAN                 Release
    )
/*++
 
Routine Description:
 
    This function claims a device in the port driver.  The port driver object
    is updated with the correct driver object if the device is successfully
    claimed.
 
Arguments:
 
    Device - The WDFDEVICE that needs to be claimed or released.
 
    Release - Indicates the logical unit should be released rather than claimed.
 
Return Value:
 
    Returns a status indicating success or failure of the operation.
 
--*/
{
    NTSTATUS                status;
    SCSI_REQUEST_BLOCK      srb = {0};
    WDF_MEMORY_DESCRIPTOR   descriptor;
    WDFREQUEST              request;
    WDF_OBJECT_ATTRIBUTES   attributes;
 
    PAGED_CODE();
 
    //Create a request
    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes,
                                            CDROM_REQUEST_CONTEXT);
 
    status = WdfRequestCreate(&attributes,
                              DeviceExtension->IoTarget,
                              &request);
 
    if (NT_SUCCESS(status))
    {
        //fill up srb structure
        srb.OriginalRequest = WdfRequestWdmGetIrp(request);
        NT_ASSERT(srb.OriginalRequest != NULL);
 
        srb.Length = sizeof(SCSI_REQUEST_BLOCK);
 
        srb.Function = Release
                        ? SRB_FUNCTION_RELEASE_DEVICE
                        : SRB_FUNCTION_CLAIM_DEVICE;
 
 
        WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(&descriptor,
                                          &srb,
                                          sizeof(srb));
 
        status = WdfIoTargetSendInternalIoctlOthersSynchronously(DeviceExtension->IoTarget,
                                                                 request,
                                                                 IOCTL_SCSI_EXECUTE_NONE,
                                                                 &descriptor,
                                                                 NULL,
                                                                 NULL,
                                                                 NULL,
                                                                 NULL);
 
        NT_ASSERT(!TEST_FLAG(srb.SrbFlags, SRB_FLAGS_FREE_SENSE_BUFFER));
 
        // The request should be deleted.
        WdfObjectDelete(request);
 
        if (!NT_SUCCESS(status))
        {
            TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_PNP,
                        "DeviceClaimRelease: Failed to %s device, status: 0x%X\n",
                        Release ? "Release" : "Claim",
                        status));
        }
    }
    else
    {
        TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_PNP,
                    "DeviceClaimRelease: Failed to create request, status: 0x%X\n",
                    status));
    }
 
    if (Release)
    {
        // We only release the device when we don't want to manage it.
        // The failure status does not matter.
        status = STATUS_SUCCESS;
    }
 
    return status;
} // end DeviceClaimRelease()

_IRQL_requires_max_() [2/2]

_IRQL_requires_max_

(

PASSIVE_LEVEL

)

Definition at line 726 of file init.c.

{
    NTSTATUS                status;
    WDF_MEMORY_DESCRIPTOR   outputDescriptor;
 
    PAGED_CODE();
 
    if ((DeviceExtension == NULL) ||
        (ScsiAddress == NULL))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    //Get IOTARGET for sending request to port driver.
    WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(&outputDescriptor,
                                      (PVOID)ScsiAddress,
                                      sizeof(SCSI_ADDRESS));
 
    status = WdfIoTargetSendIoctlSynchronously(DeviceExtension->IoTarget,
                                               NULL,
                                               IOCTL_SCSI_GET_ADDRESS,
                                               NULL,
                                               &outputDescriptor,
                                               NULL,
                                               NULL);
 
    if (!NT_SUCCESS(status))
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_INIT,
                    "DeviceRetrieveScsiAddress: Get Address failed %lx\n",
                    status));
    }
    else
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_INIT,
                    "GetAddress: Port %x, Path %x, Target %x, Lun %x\n",
                    ScsiAddress->PortNumber,
                    ScsiAddress->PathId,
                    ScsiAddress->TargetId,
                    ScsiAddress->Lun));
    }
 
    return status;
}

DeviceEvtSelfManagedIoInit()

NTSTATUS NTAPI DeviceEvtSelfManagedIoInit

(

_In_ WDFDEVICE

Device

)

Definition at line 222 of file init.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    PCDROM_DEVICE_EXTENSION deviceExtension = NULL;
 
    PAGED_CODE();
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,
                "DeviceEvtSelfManagedIoInit: WDFDEVICE %p is being started.\n",
                Device));
 
    deviceExtension = DeviceGetExtension(Device);
 
    // 1. Set/retrieve basic information, some of the following operations may depend on it
    if (NT_SUCCESS(status))
    {
        // We do not care if this function fails, SCSI address is mainly for debugging/tracing purposes.
        (VOID) DeviceRetrieveScsiAddress(deviceExtension, &deviceExtension->ScsiAddress);
    }
 
    if (NT_SUCCESS(status))
    {
        status = DeviceRetrieveDescriptorsAndTransferLength(deviceExtension);
    }
 
    if (NT_SUCCESS(status))
    {
        // This function should be called after DeviceRetrieveDescriptorsAndTransferLength()
        // It depends on MaxTransferLenth fields.
        status = DeviceInitAllocateBuffers(deviceExtension);
    }
 
    // 2. The following functions depend on the allocated buffers.
 
    // perf re-enable after failing. Q: Is this one used by cdrom.sys?
    if (NT_SUCCESS(status))
    {
        // allow perf to be re-enabled after a given number of failed IOs
        // require this number to be at least CLASS_PERF_RESTORE_MINIMUM
        ULONG t = CLASS_PERF_RESTORE_MINIMUM;
 
        DeviceGetParameter(deviceExtension,
                           CLASSP_REG_SUBKEY_NAME,
                           CLASSP_REG_PERF_RESTORE_VALUE_NAME,
                           &t);
        if (t >= CLASS_PERF_RESTORE_MINIMUM)
        {
            deviceExtension->PrivateFdoData->Perf.ReEnableThreshhold = t;
        }
    }
 
    // 3. Retrieve information about special devices and hack flags.
    if (NT_SUCCESS(status))
    {
        DeviceRetrieveHackFlagsFromRegistry(deviceExtension);
        // scan for bad items.
        DeviceScanForSpecial(deviceExtension, CdRomBadItems, DeviceHackFlagsScan);
        // Check to see if it's a special device that needs special error process.
        DeviceScanSpecialDevices(deviceExtension);  // may send command to device
    }
 
    // 4. Initialize the hotplug information only after the ScanForSpecial routines,
    // as it relies upon the hack flags - deviceExtension->PrivateFdoData->HackFlags.
    if (NT_SUCCESS(status))
    {
        status = DeviceInitializeHotplugInfo(deviceExtension);
    }
 
    if (NT_SUCCESS(status))
    {
        // cache the device's inquiry data
        status = DeviceCacheDeviceInquiryData(deviceExtension);
        if (!NT_SUCCESS(status))
        {
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_INIT,
                        "Failed to cache the device's inquiry data, failng %!STATUS!\n",
                        status
                        ));
        }
    }
 
    // 5. Initialize MMC context, media change notification stuff and read media capacity
    if (NT_SUCCESS(status))
    {
        status = DeviceInitializeMediaChangeDetection(deviceExtension);
    }
    if (NT_SUCCESS(status))
    {
        status = DeviceInitMmcContext(deviceExtension);
    }
    if (NT_SUCCESS(status))
    {
        status = DeviceInitializeZPODD(deviceExtension);
    }
    if (NT_SUCCESS(status))
    {
        // Do READ CAPACITY. This SCSI command returns the last sector address
        // on the device and the bytes per sector. These are used to calculate
        // the drive capacity in bytes.
        status = MediaReadCapacity(Device);
 
        // If READ CAPACITY succeeded, we can safely conclude that there is a media present
        if (NT_SUCCESS(status))
        {
            DeviceSetMediaChangeStateEx(deviceExtension,
                                        MediaPresent,
                                        NULL);
        }
 
        // READ CAPACITY is not critical for init, ignore all errors occuring during its execution
        status = STATUS_SUCCESS;
    }
 
    // 6. Perform DVD-specific initialization
    if (NT_SUCCESS(status))
    {
        status = DeviceInitializeDvd(Device);
    }
 
    // 7. Miscellaneous initialization actions
    if (NT_SUCCESS(status))
    {
        if (deviceExtension->PrivateFdoData != NULL)
        {
            deviceExtension->PrivateFdoData->Perf.OriginalSrbFlags = deviceExtension->SrbFlags;
        }
 
        if (deviceExtension->DeviceAdditionalData.Mmc.IsWriter)
        {
            // OPC can really take this long per IMAPIv1 timeout....
            deviceExtension->TimeOutValue = max(deviceExtension->TimeOutValue, SCSI_CDROM_OPC_TIMEOUT);
        }
    }
 
    // 8. Enable the main timer, create ARC name as needed
    if (NT_SUCCESS(status))
    {
        // Device successfully added and initialized, increase CdRomCount.
        IoGetConfigurationInformation()->CdRomCount++;
 
        deviceExtension->IsInitialized = TRUE;
 
        DeviceEnableMainTimer(deviceExtension);
 
    }
 
#if (NTDDI_VERSION >= NTDDI_WIN8)
    // 9. Set volume interface properties
    if (NT_SUCCESS(status))
    {
        BOOLEAN isCritical = FALSE;
        BOOLEAN isPortable = FALSE;
        BOOLEAN isRemovable = TEST_FLAG(deviceExtension->DeviceObject->Characteristics, FILE_REMOVABLE_MEDIA);
        DEVPROP_BOOLEAN propCritical = DEVPROP_FALSE;
        DEVPROP_BOOLEAN propPortable = DEVPROP_FALSE;
        DEVPROP_BOOLEAN propRemovable = DEVPROP_FALSE;
 
        status = DeviceIsPortable(deviceExtension, &isPortable);
 
        if (NT_SUCCESS(status))
        {
            if (isPortable) {
                SET_FLAG(deviceExtension->DeviceObject->Characteristics, FILE_PORTABLE_DEVICE);
            }
 
            propPortable = isPortable ? DEVPROP_TRUE : DEVPROP_FALSE;
 
            status = IoSetDeviceInterfacePropertyData(&deviceExtension->MountedDeviceInterfaceName,
                                                      &DEVPKEY_Storage_Portable,
                                                      0,
                                                      0,
                                                      DEVPROP_TYPE_BOOLEAN,
                                                      sizeof(DEVPROP_BOOLEAN),
                                                      &propPortable);
        }
 
        if (NT_SUCCESS(status))
        {
            propRemovable = isRemovable ? DEVPROP_TRUE : DEVPROP_FALSE;
 
            status = IoSetDeviceInterfacePropertyData(&deviceExtension->MountedDeviceInterfaceName,
                                                      &DEVPKEY_Storage_Removable_Media,
                                                      0,
                                                      0,
                                                      DEVPROP_TYPE_BOOLEAN,
                                                      sizeof(DEVPROP_BOOLEAN),
                                                      &propRemovable);
        }
 
        if (NT_SUCCESS(status))
        {
            isCritical = TEST_FLAG(deviceExtension->DeviceObject->Flags,
                                   (DO_SYSTEM_SYSTEM_PARTITION |
                                    DO_SYSTEM_BOOT_PARTITION   |
                                    DO_SYSTEM_CRITICAL_PARTITION));
 
            propCritical = isCritical ? DEVPROP_TRUE : DEVPROP_FALSE;
 
            status = IoSetDeviceInterfacePropertyData(&deviceExtension->MountedDeviceInterfaceName,
                                                      &DEVPKEY_Storage_System_Critical,
                                                      0,
                                                      0,
                                                      DEVPROP_TYPE_BOOLEAN,
                                                      sizeof(DEVPROP_BOOLEAN),
                                                      &propCritical);
        }
 
    }
#endif
 
    return status;
}