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_ (_IRQL_requires_max_() VOIDDeviceScanSpecialDevices(_In_ PCDROM_DEVICE_EXTENSION DeviceExtension) APC_LEVEL)
NTSTATUS NTAPI	DeviceEvtSelfManagedIoInit (_In_ WDFDEVICE Device)
	_IRQL_requires_max_ (APC_LEVEL)
	_IRQL_requires_max_ (PASSIVE_LEVEL)

Function Documentation

_IRQL_requires_max_() [1/3]

_IRQL_requires_max_

(

_IRQL_requires_max_()VOIDDeviceScanSpecialDevices( _In_ PCDROM_DEVICE_EXTENSION DeviceExtension )

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/3]

_IRQL_requires_max_

(

APC_LEVEL

)

Definition at line 455 of file init.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    WDF_OBJECT_ATTRIBUTES   attributes;

    PAGED_CODE();

    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes,
                                            CDROM_REQUEST_CONTEXT);
    attributes.ParentObject = DeviceExtension->Device;

    status = WdfRequestCreate(&attributes,
                              DeviceExtension->IoTarget,
                              &(DeviceExtension->ReleaseQueueRequest));

    if (!NT_SUCCESS(status))
    {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP,  "Cannot create the release queue request\n"));

        return status;
    }

    // Initialize ReleaseQueueInputMemory, a wrapper around ReleaseQueueSrb
    WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
    attributes.ParentObject = DeviceExtension->ReleaseQueueRequest;

    status = WdfMemoryCreatePreallocated(&attributes,
                                         &DeviceExtension->ReleaseQueueSrb,
                                         sizeof(SCSI_REQUEST_BLOCK),
                                         &DeviceExtension->ReleaseQueueInputMemory);
    if (!NT_SUCCESS(status))
    {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP,  "Failed to allocate ReleaseQueueSrb.\n"));

        return status;
    }

    // Preformat the release queue request here to ensure that this call will never
    // fail during an actual release of the queue.
    if (NT_SUCCESS(status))
    {
        status = WdfIoTargetFormatRequestForInternalIoctlOthers(DeviceExtension->IoTarget,
                                                                DeviceExtension->ReleaseQueueRequest,
                                                                IOCTL_SCSI_EXECUTE_NONE,
                                                                DeviceExtension->ReleaseQueueInputMemory,
                                                                NULL,
                                                                NULL,
                                                                NULL,
                                                                NULL,
                                                                NULL);
    }

    // Set a CompletionRoutine callback function for ReleaseQueueRequest.
    if (NT_SUCCESS(status))
    {
        WdfRequestSetCompletionRoutine(DeviceExtension->ReleaseQueueRequest,
                                       DeviceReleaseQueueCompletion,
                                       DeviceExtension->Device);
    }

    // Create a spinlock for ReleaseQueueRequest
    WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
    attributes.ParentObject = DeviceExtension->Device;

    status = WdfSpinLockCreate(&attributes,
                               &(DeviceExtension->ReleaseQueueSpinLock));

    if (!NT_SUCCESS(status))
    {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP,
                    "DeviceInitReleaseQueueContext: Cannot create the release queue spinlock\n"));

        return status;
    }

    // Initialize miscellaneous ReleaseQueue related fields
    DeviceExtension->ReleaseQueueNeeded = FALSE;
    DeviceExtension->ReleaseQueueInProgress = FALSE;
    DeviceExtension->ReleaseQueueSrb.Length = sizeof(SCSI_REQUEST_BLOCK);

    return status;
}

_IRQL_requires_max_() [3/3]

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