disk.c File Reference

#include "disk.h"
#include "initguid.h"
#include "ntddstor.h"
#include "ntddvol.h"
#include "ioevent.h"

Include dependency graph for disk.c:

Go to the source code of this file.

Classes
struct	_DISK_GEOMETRY_EX_INTERNAL

Macros
#define	DEBUG_MAIN_SOURCE   1
#define	DiskCompareGuid(_First, _Second)   (memcmp ((_First),(_Second), sizeof (GUID)))
#define	TRANSLATE_RETENTION_PRIORITY(_x)
#define	IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS_ADMIN   CTL_CODE(IOCTL_VOLUME_BASE, 0, METHOD_BUFFERED, FILE_READ_ACCESS)

Typedefs
typedef struct _DISK_GEOMETRY_EX_INTERNAL	DISK_GEOMETRY_EX_INTERNAL
typedef struct _DISK_GEOMETRY_EX_INTERNAL *	PDISK_GEOMETRY_EX_INTERNAL

Functions
VOID NTAPI	DiskDriverReinit (IN PDRIVER_OBJECT DriverObject, IN PVOID Nothing, IN ULONG Count)
VOID NTAPI	DiskBootDriverReinit (IN PDRIVER_OBJECT DriverObject, IN PVOID Nothing, IN ULONG Count)
NTSTATUS NTAPI	DriverEntry (IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
VOID NTAPI	DiskUnload (IN PDRIVER_OBJECT DriverObject)
NTSTATUS	DiskCreateFdo (IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT PhysicalDeviceObject, IN PULONG DeviceCount, IN BOOLEAN DasdAccessOnly)
NTSTATUS NTAPI	DiskReadWriteVerification (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	DiskDetermineMediaTypes (IN PDEVICE_OBJECT Fdo, IN PIRP Irp, IN UCHAR MediumType, IN UCHAR DensityCode, IN BOOLEAN MediaPresent, IN BOOLEAN IsWritable)
NTSTATUS NTAPI	DiskDeviceControl (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS NTAPI	DiskShutdownFlush (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID	DiskFlushDispatch (IN PDEVICE_OBJECT Fdo, IN PDISK_GROUP_CONTEXT FlushContext)
NTSTATUS NTAPI	DiskFlushComplete (IN PDEVICE_OBJECT Fdo, IN PIRP Irp, IN PVOID Context)
NTSTATUS	DiskModeSelect (IN PDEVICE_OBJECT Fdo, _In_reads_bytes_(Length) PCHAR ModeSelectBuffer, IN ULONG Length, IN BOOLEAN SavePage)
VOID NTAPI	DisableWriteCache (IN PDEVICE_OBJECT Fdo, IN PVOID Context)
VOID NTAPI	DiskIoctlVerifyThread (IN PDEVICE_OBJECT Fdo, IN PVOID Context)
VOID NTAPI	DiskFdoProcessError (PDEVICE_OBJECT Fdo, PSCSI_REQUEST_BLOCK Srb, NTSTATUS *Status, BOOLEAN *Retry)
VOID NTAPI	DiskSetSpecialHacks (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN ULONG_PTR Data)
VOID	ResetBus (IN PDEVICE_OBJECT Fdo)
VOID	DiskLogCacheInformation (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN PDISK_CACHE_INFORMATION CacheInfo, IN NTSTATUS Status)
NTSTATUS	DiskGetInfoExceptionInformation (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN PMODE_INFO_EXCEPTIONS ReturnPageData)
NTSTATUS	DiskSetInfoExceptionInformation (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN PMODE_INFO_EXCEPTIONS PageData)
NTSTATUS NTAPI	DiskGetCacheInformation (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN PDISK_CACHE_INFORMATION CacheInfo)
NTSTATUS NTAPI	DiskSetCacheInformation (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN PDISK_CACHE_INFORMATION CacheInfo)
NTSTATUS	DiskIoctlGetCacheSetting (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	DiskIoctlSetCacheSetting (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	DiskIoctlGetLengthInfo (IN OUT PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
NTSTATUS	DiskIoctlGetDriveGeometry (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
NTSTATUS	DiskIoctlGetDriveGeometryEx (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
NTSTATUS	DiskIoctlGetCacheInformation (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
NTSTATUS	DiskIoctlSetCacheInformation (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
NTSTATUS	DiskIoctlGetMediaTypesEx (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
NTSTATUS	DiskIoctlPredictFailure (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
NTSTATUS	DiskIoctlEnableFailurePrediction (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
NTSTATUS	DiskIoctlVerify (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
NTSTATUS	DiskIoctlReassignBlocks (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
NTSTATUS	DiskIoctlReassignBlocksEx (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
NTSTATUS	DiskIoctlIsWritable (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
NTSTATUS	DiskIoctlSetVerify (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
NTSTATUS	DiskIoctlClearVerify (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
NTSTATUS	DiskIoctlUpdateDriveSize (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
NTSTATUS	DiskIoctlGetVolumeDiskExtents (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
NTSTATUS	DiskIoctlSmartGetVersion (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
NTSTATUS	DiskIoctlSmartReceiveDriveData (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
NTSTATUS	DiskIoctlSmartSendDriveCommand (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
VOID	DiskEtwEnableCallback (_In_ LPCGUID SourceId, _In_ ULONG IsEnabled, _In_ UCHAR Level, _In_ ULONGLONG MatchAnyKeyword, _In_ ULONGLONG MatchAllKeyword, _In_opt_ PEVENT_FILTER_DESCRIPTOR FilterData, _In_opt_ PVOID CallbackContext)

Variables
BOOLEAN	DiskETWEnabled = FALSE
BOOLEAN	DiskIsPastReinit = FALSE
const GUID	GUID_NULL = { 0 }

Macro Definition Documentation

DEBUG_MAIN_SOURCE

#define DEBUG_MAIN_SOURCE   1

Definition at line 23 of file disk.c.

DiskCompareGuid

#define DiskCompareGuid	(		_First,
			_Second
	)		(memcmp ((_First),(_Second), sizeof (GUID)))

Definition at line 84 of file disk.c.

IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS_ADMIN

#define IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS_ADMIN   CTL_CODE(IOCTL_VOLUME_BASE, 0, METHOD_BUFFERED, FILE_READ_ACCESS)

Definition at line 104 of file disk.c.

TRANSLATE_RETENTION_PRIORITY

#define TRANSLATE_RETENTION_PRIORITY

(

_x

)

Value:

((_x) == 0xf ?  0x2 :           \
            ((_x) == 0x2 ? 0xf : _x)    \
        )

Definition at line 99 of file disk.c.

Typedef Documentation

DISK_GEOMETRY_EX_INTERNAL

typedef struct _DISK_GEOMETRY_EX_INTERNAL DISK_GEOMETRY_EX_INTERNAL

PDISK_GEOMETRY_EX_INTERNAL

typedef struct _DISK_GEOMETRY_EX_INTERNAL * PDISK_GEOMETRY_EX_INTERNAL

Function Documentation

DisableWriteCache()

VOID NTAPI DisableWriteCache	(	IN PDEVICE_OBJECT	Fdo,
		IN PVOID	Context
	)

Definition at line 2012 of file disk.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)Fdo->DeviceExtension;
    DISK_CACHE_INFORMATION cacheInfo = { 0 };
    NTSTATUS status;
    PIO_WORKITEM WorkItem = (PIO_WORKITEM)Context;

    PAGED_CODE();

    NT_ASSERT(WorkItem != NULL);
    _Analysis_assume_(WorkItem != NULL);

    status = DiskGetCacheInformation(fdoExtension, &cacheInfo);

    if (NT_SUCCESS(status) && (cacheInfo.WriteCacheEnabled == TRUE)) {

        cacheInfo.WriteCacheEnabled = FALSE;

        DiskSetCacheInformation(fdoExtension, &cacheInfo);
    }

    IoFreeWorkItem(WorkItem);
}

Referenced by DiskFdoProcessError().

DiskBootDriverReinit()

VOID NTAPI DiskBootDriverReinit	(	IN PDRIVER_OBJECT	DriverObject,
		IN PVOID	Nothing,
		IN ULONG	Count
	)

Definition at line 123 of file disk.c.

{
    IoRegisterDriverReinitialization(DriverObject, DiskDriverReinit, NULL);

#if defined(_X86_) || defined(_AMD64_)

    DiskDriverReinitialization(DriverObject, Nothing, Count);

#else

    UNREFERENCED_PARAMETER(Nothing);
    UNREFERENCED_PARAMETER(Count);

#endif

}

Referenced by DriverEntry().

DiskCreateFdo()

NTSTATUS DiskCreateFdo	(	IN PDRIVER_OBJECT	DriverObject,
		IN PDEVICE_OBJECT	PhysicalDeviceObject,
		IN PULONG	DeviceCount,
		IN BOOLEAN	DasdAccessOnly
	)

Definition at line 307 of file disk.c.

{
    PCCHAR deviceName = NULL;
    HANDLE handle = NULL;
    PDEVICE_OBJECT lowerDevice  = NULL;
    PDEVICE_OBJECT deviceObject = NULL;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension;
    NTSTATUS status;

    PAGED_CODE();

    *DeviceCount = 0;

    //
    // Set up an object directory to contain the objects for this
    // device and all its partitions.
    //

    do {

        WCHAR dirBuffer[64] = { 0 };
        UNICODE_STRING dirName;
        OBJECT_ATTRIBUTES objectAttribs;

        status = RtlStringCchPrintfW(dirBuffer, sizeof(dirBuffer) / sizeof(dirBuffer[0]) - 1, L"\\Device\\Harddisk%d", *DeviceCount);
        if (!NT_SUCCESS(status)) {
            TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_PNP, "DiskCreateFdo: Format symbolic link failed with error: 0x%X\n", status));
            return status;
        }

        RtlInitUnicodeString(&dirName, dirBuffer);

        InitializeObjectAttributes(&objectAttribs,
                                   &dirName,
                                   OBJ_CASE_INSENSITIVE | OBJ_PERMANENT | OBJ_KERNEL_HANDLE,
                                   NULL,
                                   NULL);

        status = ZwCreateDirectoryObject(&handle,
                                         DIRECTORY_ALL_ACCESS,
                                         &objectAttribs);

        (*DeviceCount)++;

    } while((status == STATUS_OBJECT_NAME_COLLISION) ||
            (status == STATUS_OBJECT_NAME_EXISTS));

    if (!NT_SUCCESS(status)) {

        TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_PNP, "DiskCreateFdo: Could not create directory - %lx\n", status));

        return(status);
    }

    //
    // When this loop exits the count is inflated by one - fix that.
    //

    (*DeviceCount)--;

    //
    // Claim the device.
    //

    lowerDevice = IoGetAttachedDeviceReference(PhysicalDeviceObject);

    status = ClassClaimDevice(lowerDevice, FALSE);

    if (!NT_SUCCESS(status)) {
        ZwMakeTemporaryObject(handle);
        ZwClose(handle);
        ObDereferenceObject(lowerDevice);
        return status;
    }

    //
    // Create a device object for this device. Each physical disk will
    // have at least one device object. The required device object
    // describes the entire device. Its directory path is
    // \Device\HarddiskN\Partition0, where N = device number.
    //

    status = DiskGenerateDeviceName(*DeviceCount, &deviceName);

    if(!NT_SUCCESS(status)) {
        TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_PNP, "DiskCreateFdo - couldn't create name %lx\n", status));

        goto DiskCreateFdoExit;

    }

    status = ClassCreateDeviceObject(DriverObject,
                                     deviceName,
                                     PhysicalDeviceObject,
                                     TRUE,
                                     &deviceObject);

    if (!NT_SUCCESS(status)) {
        TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_PNP, "DiskCreateFdo: Can not create device object %s\n", deviceName));
        goto DiskCreateFdoExit;
    }

    FREE_POOL(deviceName);

    //
    // Indicate that IRPs should include MDLs for data transfers.
    //

    SET_FLAG(deviceObject->Flags, DO_DIRECT_IO);

    fdoExtension = deviceObject->DeviceExtension;

    if(DasdAccessOnly) {

        //
        // Inidicate that only RAW should be allowed to mount on the root
        // partition object.  This ensures that a file system can't doubly
        // mount on a super-floppy by mounting once on P0 and once on P1.
        //

#ifdef _MSC_VER
#pragma prefast(suppress:28175);
#endif
        SET_FLAG(deviceObject->Vpb->Flags, VPB_RAW_MOUNT);
    }

    //
    // Initialize lock count to zero. The lock count is used to
    // disable the ejection mechanism on devices that support
    // removable media. Only the lock count in the physical
    // device extension is used.
    //

    fdoExtension->LockCount = 0;

    //
    // Save system disk number.
    //

    fdoExtension->DeviceNumber = *DeviceCount;

    //
    // Set the alignment requirements for the device based on the
    // host adapter requirements
    //

    if (lowerDevice->AlignmentRequirement > deviceObject->AlignmentRequirement) {
        deviceObject->AlignmentRequirement = lowerDevice->AlignmentRequirement;
    }

    //
    // Finally, attach to the pdo
    //

    fdoExtension->LowerPdo = PhysicalDeviceObject;

    fdoExtension->CommonExtension.LowerDeviceObject =
        IoAttachDeviceToDeviceStack(deviceObject, PhysicalDeviceObject);


    if(fdoExtension->CommonExtension.LowerDeviceObject == NULL) {

        //
        // Uh - oh, we couldn't attach
        // cleanup and return
        //

        status = STATUS_UNSUCCESSFUL;
        goto DiskCreateFdoExit;
    }

    //
    // Clear the init flag.
    //

    CLEAR_FLAG(deviceObject->Flags, DO_DEVICE_INITIALIZING);

    //
    // Store a handle to the device object directory for this disk
    //

    fdoExtension->DeviceDirectory = handle;

    ObDereferenceObject(lowerDevice);

    return STATUS_SUCCESS;

DiskCreateFdoExit:

    if (deviceObject != NULL)
    {
        IoDeleteDevice(deviceObject);
    }

    FREE_POOL(deviceName);

    ObDereferenceObject(lowerDevice);

    ZwMakeTemporaryObject(handle);
    ZwClose(handle);

    return status;
}

Referenced by DiskAddDevice().

DiskDetermineMediaTypes()

NTSTATUS DiskDetermineMediaTypes	(	IN PDEVICE_OBJECT	Fdo,
		IN PIRP	Irp,
		IN UCHAR	MediumType,
		IN UCHAR	DensityCode,
		IN BOOLEAN	MediaPresent,
		IN BOOLEAN	IsWritable
	)

Definition at line 655 of file disk.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);

    PGET_MEDIA_TYPES  mediaTypes = Irp->AssociatedIrp.SystemBuffer;
    PDEVICE_MEDIA_INFO mediaInfo = &mediaTypes->MediaInfo[0];
    BOOLEAN deviceMatched = FALSE;

    PAGED_CODE();

    //
    // this should be checked prior to calling into this routine
    // as we use the buffer as mediaTypes
    //

    NT_ASSERT(irpStack->Parameters.DeviceIoControl.OutputBufferLength >=
           sizeof(GET_MEDIA_TYPES));

    //
    // Determine if this device is removable or fixed.
    //

    if (!TEST_FLAG(Fdo->Characteristics, FILE_REMOVABLE_MEDIA)) {

        //
        // Fixed disk.
        //

        mediaTypes->DeviceType = FILE_DEVICE_DISK;
        mediaTypes->MediaInfoCount = 1;

        mediaInfo->DeviceSpecific.DiskInfo.Cylinders.QuadPart   = fdoExtension->DiskGeometry.Cylinders.QuadPart;
        mediaInfo->DeviceSpecific.DiskInfo.MediaType            = FixedMedia;
        mediaInfo->DeviceSpecific.DiskInfo.TracksPerCylinder    = fdoExtension->DiskGeometry.TracksPerCylinder;
        mediaInfo->DeviceSpecific.DiskInfo.SectorsPerTrack      = fdoExtension->DiskGeometry.SectorsPerTrack;
        mediaInfo->DeviceSpecific.DiskInfo.BytesPerSector       = fdoExtension->DiskGeometry.BytesPerSector;
        mediaInfo->DeviceSpecific.DiskInfo.NumberMediaSides     = 1;
        mediaInfo->DeviceSpecific.DiskInfo.MediaCharacteristics = (MEDIA_CURRENTLY_MOUNTED | MEDIA_READ_WRITE);

        if (!IsWritable) {

            SET_FLAG(mediaInfo->DeviceSpecific.DiskInfo.MediaCharacteristics,
                     MEDIA_WRITE_PROTECTED);
        }

    } else {

        PCCHAR vendorId = (PCCHAR) fdoExtension->DeviceDescriptor + fdoExtension->DeviceDescriptor->VendorIdOffset;
        PCCHAR productId = (PCCHAR) fdoExtension->DeviceDescriptor + fdoExtension->DeviceDescriptor->ProductIdOffset;
        PCCHAR productRevision = (PCCHAR) fdoExtension->DeviceDescriptor + fdoExtension->DeviceDescriptor->ProductRevisionOffset;
        DISK_MEDIA_TYPES_LIST const *mediaListEntry;
        ULONG  currentMedia;
        ULONG  i;
        ULONG  j;
        ULONG  sizeNeeded;

        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                   "DiskDetermineMediaTypes: Vendor %s, Product %s\n",
                   vendorId,
                   productId));


        //
        // If there's an entry with such vendorId & ProductId in the DiskMediaTypesExclude list,
        // this device shouldn't be looked up in the DiskMediaTypes list to determine a medium type.
        // The exclude table allows to narrow down the set of devices described by the DiskMediaTypes
        // list (e.g.: DiskMediaTypes says "all HP devices" and DiskMediaTypesExlclude says
        // "except for HP RDX")
        //

        for (i = 0; DiskMediaTypesExclude[i].VendorId != NULL; i++) {
            mediaListEntry = &DiskMediaTypesExclude[i];

            if (strncmp(mediaListEntry->VendorId,vendorId,strlen(mediaListEntry->VendorId))) {
                continue;
            }

            if ((mediaListEntry->ProductId != NULL) &&
                 strncmp(mediaListEntry->ProductId, productId, strlen(mediaListEntry->ProductId))) {
                continue;
            }

            goto SkipTable;
        }

        //
        // Run through the list until we find the entry with a NULL Vendor Id.
        //

        for (i = 0; DiskMediaTypes[i].VendorId != NULL; i++) {

            mediaListEntry = &DiskMediaTypes[i];

            if (strncmp(mediaListEntry->VendorId,vendorId,strlen(mediaListEntry->VendorId))) {
                continue;
            }

            if ((mediaListEntry->ProductId != NULL) &&
                 strncmp(mediaListEntry->ProductId, productId, strlen(mediaListEntry->ProductId))) {
                continue;
            }

            if ((mediaListEntry->Revision != NULL) &&
                 strncmp(mediaListEntry->Revision, productRevision, strlen(mediaListEntry->Revision))) {
                continue;
            }

            deviceMatched = TRUE;

            mediaTypes->DeviceType = FILE_DEVICE_DISK;
            mediaTypes->MediaInfoCount = mediaListEntry->NumberOfTypes;

            //
            // Ensure that buffer is large enough.
            //

            sizeNeeded = FIELD_OFFSET(GET_MEDIA_TYPES, MediaInfo[0]) +
                         (mediaListEntry->NumberOfTypes *
                          sizeof(DEVICE_MEDIA_INFO)
                          );

            if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
                sizeNeeded) {

                //
                // Buffer too small
                //

                Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
                return STATUS_BUFFER_TOO_SMALL;
            }

            for (j = 0; j < mediaListEntry->NumberOfTypes; j++) {

                mediaInfo->DeviceSpecific.RemovableDiskInfo.Cylinders.QuadPart = fdoExtension->DiskGeometry.Cylinders.QuadPart;
                mediaInfo->DeviceSpecific.RemovableDiskInfo.TracksPerCylinder = fdoExtension->DiskGeometry.TracksPerCylinder;
                mediaInfo->DeviceSpecific.RemovableDiskInfo.SectorsPerTrack = fdoExtension->DiskGeometry.SectorsPerTrack;
                mediaInfo->DeviceSpecific.RemovableDiskInfo.BytesPerSector = fdoExtension->DiskGeometry.BytesPerSector;
                mediaInfo->DeviceSpecific.RemovableDiskInfo.NumberMediaSides = mediaListEntry->NumberOfSides;

                //
                // Set the type.
                //

                mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaType = mediaListEntry->MediaTypes[j];

                if (mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaType == MO_5_WO) {
                    mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaCharacteristics = MEDIA_WRITE_ONCE;
                } else {
                    mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaCharacteristics = MEDIA_READ_WRITE;
                }

                //
                // Status will either be success, if media is present, or no media.
                // It would be optimal to base from density code and medium type, but not all devices
                // have values for these fields.
                //

                if (MediaPresent) {

                    //
                    // The usage of MediumType and DensityCode is device specific, so this may need
                    // to be extended to further key off of product/vendor ids.
                    // Currently, the MO units are the only devices that return this information.
                    //

                    if (MediumType == 2) {
                        currentMedia = MO_5_WO;
                    } else if (MediumType == 3) {
                        currentMedia = MO_5_RW;

                        if (DensityCode == 0x87) {

                            //
                            // Indicate that the pinnacle 4.6 G media
                            // is present. Other density codes will default to normal
                            // RW MO media.
                            //

                            currentMedia = PINNACLE_APEX_5_RW;
                        }
                    } else {
                        currentMedia = 0;
                    }

                    if (currentMedia) {
                        if (mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaType == (STORAGE_MEDIA_TYPE)currentMedia) {
                            SET_FLAG(mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaCharacteristics, MEDIA_CURRENTLY_MOUNTED);
                        }

                    } else {
                        SET_FLAG(mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaCharacteristics, MEDIA_CURRENTLY_MOUNTED);
                    }
                }

                if (!IsWritable) {
                    SET_FLAG(mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaCharacteristics, MEDIA_WRITE_PROTECTED);
                }

                //
                // Advance to next entry.
                //

                mediaInfo++;
            }
        }

SkipTable:

        if (!deviceMatched) {

            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                       "DiskDetermineMediaTypes: Unknown device. Vendor: %s Product: %s Revision: %s\n",
                                   vendorId,
                                   productId,
                                   productRevision));
            //
            // Build an entry for unknown.
            //

            mediaTypes->DeviceType = FILE_DEVICE_DISK;
            mediaTypes->MediaInfoCount = 1;

            mediaInfo->DeviceSpecific.RemovableDiskInfo.Cylinders.QuadPart   = fdoExtension->DiskGeometry.Cylinders.QuadPart;
            mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaType            = RemovableMedia;
            mediaInfo->DeviceSpecific.RemovableDiskInfo.TracksPerCylinder    = fdoExtension->DiskGeometry.TracksPerCylinder;
            mediaInfo->DeviceSpecific.RemovableDiskInfo.SectorsPerTrack      = fdoExtension->DiskGeometry.SectorsPerTrack;
            mediaInfo->DeviceSpecific.RemovableDiskInfo.BytesPerSector       = fdoExtension->DiskGeometry.BytesPerSector;
            mediaInfo->DeviceSpecific.RemovableDiskInfo.NumberMediaSides     = 1;
            mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaCharacteristics = MEDIA_READ_WRITE;

            if (MediaPresent) {

                SET_FLAG(mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaCharacteristics, MEDIA_CURRENTLY_MOUNTED);
            }

            if (!IsWritable) {

                SET_FLAG(mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaCharacteristics, MEDIA_WRITE_PROTECTED);
            }
        }
    }

    Irp->IoStatus.Information =
        FIELD_OFFSET(GET_MEDIA_TYPES, MediaInfo[0]) +
        (mediaTypes->MediaInfoCount * sizeof(DEVICE_MEDIA_INFO));

    return STATUS_SUCCESS;
}

Referenced by DiskIoctlGetMediaTypesEx().

DiskDeviceControl()

NTSTATUS NTAPI DiskDeviceControl	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 937 of file disk.c.

{
    PIO_STACK_LOCATION  irpStack = IoGetCurrentIrpStackLocation(Irp);
    NTSTATUS            status = STATUS_SUCCESS;
    ULONG               ioctlCode;

    NT_ASSERT(DeviceObject != NULL);

    Irp->IoStatus.Information = 0;
    ioctlCode = irpStack->Parameters.DeviceIoControl.IoControlCode;

    TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_IOCTL, "DiskDeviceControl: Received IOCTL 0x%X for device %p through IRP %p\n",
                ioctlCode, DeviceObject, Irp));


    switch (ioctlCode) {

        case IOCTL_DISK_GET_CACHE_INFORMATION: {
            status = DiskIoctlGetCacheInformation(DeviceObject, Irp);
            break;
        }

        case IOCTL_DISK_SET_CACHE_INFORMATION: {
            status = DiskIoctlSetCacheInformation(DeviceObject, Irp);
            break;
        }

        case IOCTL_DISK_GET_CACHE_SETTING: {
            status = DiskIoctlGetCacheSetting(DeviceObject, Irp);
            break;
        }

        case IOCTL_DISK_SET_CACHE_SETTING: {
            status = DiskIoctlSetCacheSetting(DeviceObject, Irp);
            break;
        }

        case IOCTL_DISK_GET_DRIVE_GEOMETRY: {
            status = DiskIoctlGetDriveGeometry(DeviceObject, Irp);
            break;
        }

        case IOCTL_DISK_GET_DRIVE_GEOMETRY_EX: {
            status = DiskIoctlGetDriveGeometryEx( DeviceObject, Irp );
            break;
        }

        case IOCTL_DISK_VERIFY: {
            status = DiskIoctlVerify(DeviceObject, Irp);
            break;
        }

        case IOCTL_DISK_GET_LENGTH_INFO: {
            status = DiskIoctlGetLengthInfo(DeviceObject, Irp);
            break;
        }

        case IOCTL_DISK_IS_WRITABLE: {
            status = DiskIoctlIsWritable(DeviceObject, Irp);
            break;
        }

        case IOCTL_DISK_UPDATE_DRIVE_SIZE: {
            status = DiskIoctlUpdateDriveSize(DeviceObject, Irp);
            break;
        }

        case IOCTL_DISK_REASSIGN_BLOCKS: {
            status = DiskIoctlReassignBlocks(DeviceObject, Irp);
            break;
        }

        case IOCTL_DISK_REASSIGN_BLOCKS_EX: {
            status = DiskIoctlReassignBlocksEx(DeviceObject, Irp);
            break;
        }

        case IOCTL_DISK_INTERNAL_SET_VERIFY: {
            status = DiskIoctlSetVerify(DeviceObject, Irp);
            break;
        }

        case IOCTL_DISK_INTERNAL_CLEAR_VERIFY: {
            status = DiskIoctlClearVerify(DeviceObject, Irp);
            break;
        }

        case IOCTL_STORAGE_GET_MEDIA_TYPES_EX: {
            status = DiskIoctlGetMediaTypesEx(DeviceObject, Irp);
            break;
        }

        case IOCTL_STORAGE_PREDICT_FAILURE : {
            status = DiskIoctlPredictFailure(DeviceObject, Irp);
            break;
        }

        #if (NTDDI_VERSION >= NTDDI_WINBLUE)
        case IOCTL_STORAGE_FAILURE_PREDICTION_CONFIG : {
            status = DiskIoctlEnableFailurePrediction(DeviceObject, Irp);
            break;
        }
        #endif

        case SMART_GET_VERSION: {
            status = DiskIoctlSmartGetVersion(DeviceObject, Irp);
            break;
        }

        case SMART_RCV_DRIVE_DATA: {
            status = DiskIoctlSmartReceiveDriveData(DeviceObject, Irp);
            break;
        }

        case SMART_SEND_DRIVE_COMMAND: {
            status = DiskIoctlSmartSendDriveCommand(DeviceObject, Irp);
            break;
        }

        case IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS:
        case IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS_ADMIN: {
            status = DiskIoctlGetVolumeDiskExtents(DeviceObject, Irp);
            break;
        }

        default: {

            //
            // Pass the request to the common device control routine.
            //
            return(ClassDeviceControl(DeviceObject, Irp));
            break;
        }
    } // end switch

    if (!NT_SUCCESS(status)) {

        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskDeviceControl: IOCTL 0x%X to device %p failed with error 0x%X\n",
                    ioctlCode, DeviceObject, status));
        if (IoIsErrorUserInduced(status) &&
            (Irp->Tail.Overlay.Thread != NULL)) {
            IoSetHardErrorOrVerifyDevice(Irp, DeviceObject);
        }
    }

    //
    // DiskIoctlVerify() (IOCTL_DISK_VERIFY) function returns STATUS_PENDING
    // and completes the IRP in the work item. Do not touch or complete
    // the IRP if STATUS_PENDING is returned.
    //

    if (status != STATUS_PENDING) {


        Irp->IoStatus.Status = status;
        ClassReleaseRemoveLock(DeviceObject, Irp);
        ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
    }

    return(status);
} // end DiskDeviceControl()

Referenced by DriverEntry().

DiskDriverReinit()

VOID NTAPI DiskDriverReinit	(	IN PDRIVER_OBJECT	DriverObject,
		IN PVOID	Nothing,
		IN ULONG	Count
	)

Definition at line 108 of file disk.c.

{
    UNREFERENCED_PARAMETER(DriverObject);
    UNREFERENCED_PARAMETER(Nothing);
    UNREFERENCED_PARAMETER(Count);

    DiskIsPastReinit = TRUE;
}

Referenced by DiskBootDriverReinit().

DiskEtwEnableCallback()

VOID DiskEtwEnableCallback	(	_In_ LPCGUID	SourceId,
		_In_ ULONG	IsEnabled,
		_In_ UCHAR	Level,
		_In_ ULONGLONG	MatchAnyKeyword,
		_In_ ULONGLONG	MatchAllKeyword,
		_In_opt_ PEVENT_FILTER_DESCRIPTOR	FilterData,
		_In_opt_ PVOID	CallbackContext
	)

Definition at line 6155 of file disk.c.

{
    //
    // Initialize locals.
    //
    UNREFERENCED_PARAMETER(SourceId);
    UNREFERENCED_PARAMETER(Level);
    UNREFERENCED_PARAMETER(MatchAnyKeyword);
    UNREFERENCED_PARAMETER(MatchAllKeyword);
    UNREFERENCED_PARAMETER(FilterData);
    UNREFERENCED_PARAMETER(CallbackContext);

    //
    // Set the ETW tracing enable state.
    //
    DiskETWEnabled = IsEnabled ? TRUE : FALSE;

    return;
}

DiskFdoProcessError()

VOID NTAPI DiskFdoProcessError	(	PDEVICE_OBJECT	Fdo,
		PSCSI_REQUEST_BLOCK	Srb,
		NTSTATUS *	Status,
		BOOLEAN *	Retry
	)

Definition at line 2276 of file disk.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
    PSTORAGE_REQUEST_BLOCK srbEx;
    PCDB cdb = NULL;
    UCHAR scsiStatus = 0;
    UCHAR senseBufferLength = 0;
    PVOID senseBuffer = NULL;
    CDB noOp = {0};

    //
    // Get relevant fields from SRB
    //
    if (Srb->Function == SRB_FUNCTION_STORAGE_REQUEST_BLOCK) {

        srbEx = (PSTORAGE_REQUEST_BLOCK)Srb;

        //
        // Look for SCSI SRB specific fields
        //
        if ((srbEx->SrbFunction == SRB_FUNCTION_EXECUTE_SCSI) &&
            (srbEx->NumSrbExData > 0)) {
            cdb = GetSrbScsiData(srbEx, NULL, NULL, &scsiStatus, &senseBuffer, &senseBufferLength);

            //
            // cdb and sense buffer should not be NULL
            //
            NT_ASSERT(cdb != NULL);
            NT_ASSERT(senseBuffer != NULL);

        }

        if (cdb == NULL) {

            //
            // Use a cdb that is all 0s
            //
            cdb = &noOp;
        }

    } else {

        cdb = (PCDB)(Srb->Cdb);
        scsiStatus = Srb->ScsiStatus;
        senseBufferLength = Srb->SenseInfoBufferLength;
        senseBuffer = Srb->SenseInfoBuffer;
    }

    if (*Status == STATUS_DATA_OVERRUN &&
        (cdb != NULL) &&
        (IS_SCSIOP_READWRITE(cdb->CDB10.OperationCode))) {

            *Retry = TRUE;

            //
            // Update the error count for the device.
            //

            fdoExtension->ErrorCount++;

    } else if (SRB_STATUS(Srb->SrbStatus) == SRB_STATUS_ERROR &&
               scsiStatus == SCSISTAT_BUSY) {

        //
        // a disk drive should never be busy this long. Reset the scsi bus
        // maybe this will clear the condition.
        //

        ResetBus(Fdo);

        //
        // Update the error count for the device.
        //

        fdoExtension->ErrorCount++;

    } else {

        BOOLEAN invalidatePartitionTable = FALSE;

        //
        // See if this might indicate that something on the drive has changed.
        //

        if ((Srb->SrbStatus & SRB_STATUS_AUTOSENSE_VALID) &&
            (senseBuffer != NULL) && (cdb != NULL)) {

            BOOLEAN validSense = FALSE;
            UCHAR senseKey = 0;
            UCHAR asc = 0;
            UCHAR ascq = 0;

            validSense = ScsiGetSenseKeyAndCodes(senseBuffer,
                                                 senseBufferLength,
                                                 SCSI_SENSE_OPTIONS_FIXED_FORMAT_IF_UNKNOWN_FORMAT_INDICATED,
                                                 &senseKey,
                                                 &asc,
                                                 &ascq);

            if (validSense) {

                switch (senseKey) {

                    case SCSI_SENSE_ILLEGAL_REQUEST: {

                        switch (asc) {

                            case SCSI_ADSENSE_INVALID_CDB:
                            {
                                //
                                // Look to see if this is an Io request with the ForceUnitAccess flag set
                                //
                                if (((cdb->CDB10.OperationCode == SCSIOP_WRITE)   ||
                                    (cdb->CDB10.OperationCode == SCSIOP_WRITE16)) &&
                                    (cdb->CDB10.ForceUnitAccess))
                                {
                                    PDISK_DATA diskData = (PDISK_DATA)fdoExtension->CommonExtension.DriverData;

                                    if (diskData->WriteCacheOverride == DiskWriteCacheEnable)
                                    {
                                        PIO_ERROR_LOG_PACKET logEntry = NULL;

                                        //
                                        // The user has explicitly requested that write caching be turned on.
                                        // Warn the user that writes with FUA enabled are not working and that
                                        // they should disable write cache.
                                        //

                                        logEntry = IoAllocateErrorLogEntry(fdoExtension->DeviceObject,
                                                                           sizeof(IO_ERROR_LOG_PACKET) + (4 * sizeof(ULONG)));

                                        if (logEntry != NULL)
                                        {
                                            logEntry->FinalStatus       = *Status;
                                            logEntry->ErrorCode         = IO_WARNING_WRITE_FUA_PROBLEM;
                                            logEntry->SequenceNumber    = 0;
                                            logEntry->MajorFunctionCode = IRP_MJ_SCSI;
                                            logEntry->IoControlCode     = 0;
                                            logEntry->RetryCount        = 0;
                                            logEntry->UniqueErrorValue  = 0;
                                            logEntry->DumpDataSize      = 4 * sizeof(ULONG);

                                            logEntry->DumpData[0] = diskData->ScsiAddress.PortNumber;
                                            logEntry->DumpData[1] = diskData->ScsiAddress.PathId;
                                            logEntry->DumpData[2] = diskData->ScsiAddress.TargetId;
                                            logEntry->DumpData[3] = diskData->ScsiAddress.Lun;

                                            //
                                            // Write the error log packet.
                                            //

                                            IoWriteErrorLogEntry(logEntry);
                                        }
                                    }
                                    else
                                    {
                                        //
                                        // Turn off write caching on this device. This is so that future
                                        // critical requests need not be sent down with  ForceUnitAccess
                                        //
                                        PIO_WORKITEM workItem = IoAllocateWorkItem(Fdo);

                                        if (workItem)
                                        {
                                            IoQueueWorkItem(workItem, DisableWriteCache, CriticalWorkQueue, workItem);
                                        }
                                    }

                                    SET_FLAG(fdoExtension->ScanForSpecialFlags, CLASS_SPECIAL_FUA_NOT_SUPPORTED);
                                    ADJUST_FUA_FLAG(fdoExtension);


                                    cdb->CDB10.ForceUnitAccess = FALSE;
                                    *Retry = TRUE;

                                } else if ((cdb->CDB6FORMAT.OperationCode == SCSIOP_MODE_SENSE) &&
                                           (cdb->MODE_SENSE.PageCode == MODE_SENSE_RETURN_ALL)) {

                                    //
                                    // Mode sense for all pages failed. This command could fail with
                                    // SCSI_SENSE_ILLEGAL_REQUEST / SCSI_ADSENSE_INVALID_CDB if the data
                                    // to be returned is more than 256 bytes. In which case, try to get
                                    // only MODE_PAGE_CACHING since we only need the block descriptor.
                                    //
                                    // Simply change the page code and retry the request
                                    //

                                    cdb->MODE_SENSE.PageCode = MODE_PAGE_CACHING;
                                    *Retry = TRUE;
                                }

                                break;
                            }
                        } // end switch(asc)
                        break;
                    }

                    case SCSI_SENSE_NOT_READY: {

                        switch (asc) {
                        case SCSI_ADSENSE_LUN_NOT_READY: {
                            switch (ascq) {
                            case SCSI_SENSEQ_BECOMING_READY:
                            case SCSI_SENSEQ_MANUAL_INTERVENTION_REQUIRED:
                            case SCSI_SENSEQ_CAUSE_NOT_REPORTABLE: {
                                invalidatePartitionTable = TRUE;
                                break;
                            }
                            } // end switch(ascq)
                            break;
                        }

                        case SCSI_ADSENSE_NO_MEDIA_IN_DEVICE: {
                            invalidatePartitionTable = TRUE;
                            break;
                        }
                        } // end switch(asc)
                        break;
                    }

                    case SCSI_SENSE_MEDIUM_ERROR: {
                        invalidatePartitionTable = TRUE;
                        break;
                    }

                    case SCSI_SENSE_HARDWARE_ERROR: {
                        invalidatePartitionTable = TRUE;
                        break;
                    }

                    case SCSI_SENSE_UNIT_ATTENTION:
                    {
                        invalidatePartitionTable = TRUE;
                        break;
                    }

                    case SCSI_SENSE_RECOVERED_ERROR: {
                        invalidatePartitionTable = TRUE;
                        break;
                    }

                } // end switch(senseKey)
            } // end if (validSense)
        } else {

            //
            // On any exceptional scsi condition which might indicate that the
            // device was changed we will flush out the state of the partition
            // table.
            //

            switch (SRB_STATUS(Srb->SrbStatus)) {
                case SRB_STATUS_INVALID_LUN:
                case SRB_STATUS_INVALID_TARGET_ID:
                case SRB_STATUS_NO_DEVICE:
                case SRB_STATUS_NO_HBA:
                case SRB_STATUS_INVALID_PATH_ID:
                case SRB_STATUS_COMMAND_TIMEOUT:
                case SRB_STATUS_TIMEOUT:
                case SRB_STATUS_SELECTION_TIMEOUT:
                case SRB_STATUS_REQUEST_FLUSHED:
                case SRB_STATUS_UNEXPECTED_BUS_FREE:
                case SRB_STATUS_PARITY_ERROR:
                {
                    invalidatePartitionTable = TRUE;
                    break;
                }

                case SRB_STATUS_ERROR:
                {
                    if (scsiStatus == SCSISTAT_RESERVATION_CONFLICT)
                    {
                        invalidatePartitionTable = TRUE;
                    }

                    break;
                }
            } // end switch(Srb->SrbStatus)
        }

        if (invalidatePartitionTable && TEST_FLAG(Fdo->Characteristics, FILE_REMOVABLE_MEDIA)) {

            //
            // Inform the upper layers that the volume
            // on this disk is in need of verification
            //

            SET_FLAG(Fdo->Flags, DO_VERIFY_VOLUME);
        }
    }

    return;
}

Referenced by DriverEntry().

DiskFlushComplete()

NTSTATUS NTAPI DiskFlushComplete	(	IN PDEVICE_OBJECT	Fdo,
		IN PIRP	Irp,
		IN PVOID	Context
	)

Definition at line 1699 of file disk.c.

{
    PDISK_GROUP_CONTEXT FlushContext;
    NTSTATUS status;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt;
    PDISK_DATA diskData;
#ifdef _MSC_VER
    #pragma warning(suppress:4311) // pointer truncation from 'PVOID' to 'NTSTATUS'
#endif
    NTSTATUS SyncCacheStatus = (NTSTATUS)(ULONG_PTR)Context;

    TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_GENERAL, "DiskFlushComplete: %p %p\n", Fdo, Irp));

    //
    // Get the flush context from the device extension
    //
    fdoExt = (PFUNCTIONAL_DEVICE_EXTENSION)Fdo->DeviceExtension;
    diskData = (PDISK_DATA)fdoExt->CommonExtension.DriverData;
    NT_ASSERT(diskData != NULL);
    _Analysis_assume_(diskData != NULL);

    FlushContext = &diskData->FlushContext;

    //
    // Make sure everything is in order
    //
    NT_ASSERT(Irp == FlushContext->CurrIrp);

    TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_SCSI, "DiskFlushComplete: completing irp %p\n", Irp));
    status = ClassIoComplete(Fdo, Irp, &FlushContext->Srb.Srb);

    //
    // Make sure that ClassIoComplete did not decide to retry this request
    //
    NT_ASSERT(status != STATUS_MORE_PROCESSING_REQUIRED);

    //
    // If sync cache failed earlier, final status of the flush request needs to be failure
    // even if SRB_FUNCTION_FLUSH srb request succeeded
    //
    if (NT_SUCCESS(status) &&
        (!NT_SUCCESS(SyncCacheStatus))) {
        Irp->IoStatus.Status = status = SyncCacheStatus;
    }

    //
    // Complete the flush requests tagged to this one
    //

    while (!IsListEmpty(&FlushContext->CurrList)) {

        PLIST_ENTRY listEntry = RemoveHeadList(&FlushContext->CurrList);
        PIRP tempIrp = CONTAINING_RECORD(listEntry, IRP, Tail.Overlay.ListEntry);

        InitializeListHead(&tempIrp->Tail.Overlay.ListEntry);
        tempIrp->IoStatus = Irp->IoStatus;

        ClassReleaseRemoveLock(Fdo, tempIrp);
        ClassCompleteRequest(Fdo, tempIrp, IO_NO_INCREMENT);
    }


        //
        // Notify the next group's representative that it may go ahead now
        //
        KeSetEvent(&FlushContext->Event, IO_NO_INCREMENT, FALSE);


    TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_SCSI, "DiskFlushComplete: irp %p status = 0x%x\n", Irp, status));

    return status;
}

Referenced by DiskFlushDispatch().

DiskFlushDispatch()

VOID DiskFlushDispatch	(	IN PDEVICE_OBJECT	Fdo,
		IN PDISK_GROUP_CONTEXT	FlushContext
	)

Definition at line 1534 of file disk.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Fdo->DeviceExtension;
    PSCSI_REQUEST_BLOCK srb = &FlushContext->Srb.Srb;
    PSTORAGE_REQUEST_BLOCK srbEx = &FlushContext->Srb.SrbEx;
    PIO_STACK_LOCATION  irpSp = NULL;
    PSTOR_ADDR_BTL8 storAddrBtl8;
    PSRBEX_DATA_SCSI_CDB16 srbExDataCdb16;
    NTSTATUS SyncCacheStatus = STATUS_SUCCESS;

    //
    // Fill in the srb fields appropriately
    //
    if (fdoExt->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
        RtlZeroMemory(srbEx, sizeof(FlushContext->Srb.SrbExBuffer));

        srbEx->Length = FIELD_OFFSET(STORAGE_REQUEST_BLOCK, Signature);
        srbEx->Function = SRB_FUNCTION_STORAGE_REQUEST_BLOCK;
        srbEx->Signature = SRB_SIGNATURE;
        srbEx->Version = STORAGE_REQUEST_BLOCK_VERSION_1;
        srbEx->SrbLength = sizeof(FlushContext->Srb.SrbExBuffer);
        srbEx->RequestPriority = IoGetIoPriorityHint(FlushContext->CurrIrp);
        srbEx->AddressOffset = sizeof(STORAGE_REQUEST_BLOCK);
        srbEx->TimeOutValue = fdoExt->TimeOutValue * 4;
        srbEx->RequestTag = SP_UNTAGGED;
        srbEx->RequestAttribute  = SRB_SIMPLE_TAG_REQUEST;
        srbEx->SrbFlags = fdoExt->SrbFlags;

        //
        // Set up address fields
        //

        storAddrBtl8 = (PSTOR_ADDR_BTL8) ((PUCHAR)srbEx + srbEx->AddressOffset);
        storAddrBtl8->Type = STOR_ADDRESS_TYPE_BTL8;
        storAddrBtl8->AddressLength = STOR_ADDR_BTL8_ADDRESS_LENGTH;

    } else {
        RtlZeroMemory(srb, SCSI_REQUEST_BLOCK_SIZE);

        srb->Length       = SCSI_REQUEST_BLOCK_SIZE;
        srb->TimeOutValue = fdoExt->TimeOutValue * 4;
        srb->QueueTag     = SP_UNTAGGED;
        srb->QueueAction  = SRB_SIMPLE_TAG_REQUEST;
        srb->SrbFlags     = fdoExt->SrbFlags;
    }

    //
    // If write caching is enabled then send down a synchronize cache request
    //
    if (TEST_FLAG(fdoExt->DeviceFlags, DEV_WRITE_CACHE))
    {

        if (fdoExt->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
            srbEx->SrbFunction = SRB_FUNCTION_EXECUTE_SCSI;
            srbEx->NumSrbExData = 1;

            //
            // Set up SCSI SRB extended data fields
            //

            srbEx->SrbExDataOffset[0] = sizeof(STORAGE_REQUEST_BLOCK) +
                sizeof(STOR_ADDR_BTL8);
            if ((srbEx->SrbExDataOffset[0] + sizeof(SRBEX_DATA_SCSI_CDB16)) <= srbEx->SrbLength) {
                srbExDataCdb16 = (PSRBEX_DATA_SCSI_CDB16)((PUCHAR)srbEx + srbEx->SrbExDataOffset[0]);
                srbExDataCdb16->Type = SrbExDataTypeScsiCdb16;
                srbExDataCdb16->Length = SRBEX_DATA_SCSI_CDB16_LENGTH;
                srbExDataCdb16->CdbLength = 10;
                srbExDataCdb16->Cdb[0] = SCSIOP_SYNCHRONIZE_CACHE;
            } else {
                // Should not happen
                NT_ASSERT(FALSE);
                return;
            }

        } else {
            srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
            srb->CdbLength = 10;
            srb->Cdb[0] = SCSIOP_SYNCHRONIZE_CACHE;
        }

        TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_SCSI, "DiskFlushDispatch: sending sync cache\n"));

        SyncCacheStatus = ClassSendSrbSynchronous(Fdo, srb, NULL, 0, TRUE);
    }

    //
    // Set up a FLUSH SRB
    //
    if (fdoExt->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
        srbEx->SrbFunction = SRB_FUNCTION_FLUSH;
        srbEx->NumSrbExData = 0;
        srbEx->SrbExDataOffset[0] = 0;
        srbEx->OriginalRequest = FlushContext->CurrIrp;
        srbEx->SrbStatus = 0;

        //
        // Make sure that this srb does not get freed
        //
        SET_FLAG(srbEx->SrbFlags, SRB_CLASS_FLAGS_PERSISTANT);

   } else {
        srb->Function  = SRB_FUNCTION_FLUSH;
        srb->CdbLength = 0;
        srb->OriginalRequest = FlushContext->CurrIrp;
        srb->SrbStatus = 0;
        srb->ScsiStatus = 0;

        //
        // Make sure that this srb does not get freed
        //
        SET_FLAG(srb->SrbFlags, SRB_CLASS_FLAGS_PERSISTANT);
    }

    //
    // Make sure that this request does not get retried
    //
    irpSp = IoGetCurrentIrpStackLocation(FlushContext->CurrIrp);

    irpSp->Parameters.Others.Argument4 = (PVOID) 0;

    //
    // Fill in the irp fields appropriately
    //
    irpSp = IoGetNextIrpStackLocation(FlushContext->CurrIrp);

    irpSp->MajorFunction       = IRP_MJ_SCSI;
    irpSp->Parameters.Scsi.Srb = srb;

    IoSetCompletionRoutine(FlushContext->CurrIrp, DiskFlushComplete, (PVOID)(ULONG_PTR)SyncCacheStatus, TRUE, TRUE, TRUE);

    TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_SCSI, "DiskFlushDispatch: sending srb flush on irp %p\n", FlushContext->CurrIrp));

    //
    // Send down the flush request
    //
    IoCallDriver(((PCOMMON_DEVICE_EXTENSION)fdoExt)->LowerDeviceObject, FlushContext->CurrIrp);
}

Referenced by DiskShutdownFlush().

DiskGetCacheInformation()

NTSTATUS NTAPI DiskGetCacheInformation	(	IN PFUNCTIONAL_DEVICE_EXTENSION	FdoExtension,
		IN PDISK_CACHE_INFORMATION	CacheInfo
	)

Definition at line 3019 of file disk.c.

{
    PMODE_PARAMETER_HEADER modeData;
    PMODE_CACHING_PAGE pageData;

    ULONG length;

    PAGED_CODE();



    modeData = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
                                     MODE_DATA_SIZE,
                                     DISK_TAG_DISABLE_CACHE);

    if (modeData == NULL) {

        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskGetSetCacheInformation: Unable to allocate mode "
                       "data buffer\n"));
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    RtlZeroMemory(modeData, MODE_DATA_SIZE);

    length = ClassModeSense(FdoExtension->DeviceObject,
                            (PCHAR) modeData,
                            MODE_DATA_SIZE,
                            MODE_PAGE_CACHING);

    if (length < sizeof(MODE_PARAMETER_HEADER)) {

        //
        // Retry the request in case of a check condition.
        //

        length = ClassModeSense(FdoExtension->DeviceObject,
                                (PCHAR) modeData,
                                MODE_DATA_SIZE,
                                MODE_PAGE_CACHING);

        if (length < sizeof(MODE_PARAMETER_HEADER)) {

            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskGetCacheInformation: Mode Sense failed\n"));

            FREE_POOL(modeData);
            return STATUS_IO_DEVICE_ERROR;
        }
    }

    //
    // If the length is greater than length indicated by the mode data reset
    // the data to the mode data.
    //

    if (length > (ULONG) (modeData->ModeDataLength + 1)) {
        length = modeData->ModeDataLength + 1;
    }

    //
    // Check to see if the write cache is enabled.
    //

    pageData = ClassFindModePage((PCHAR) modeData,
                                 length,
                                 MODE_PAGE_CACHING,
                                 TRUE);

    //
    // Check if valid caching page exists.
    //

    if (pageData == NULL) {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskGetCacheInformation: Unable to find caching mode page.\n"));
        FREE_POOL(modeData);
        return STATUS_NOT_SUPPORTED;
    }

    //
    // Copy the parameters over.
    //

    RtlZeroMemory(CacheInfo, sizeof(DISK_CACHE_INFORMATION));

    CacheInfo->ParametersSavable = pageData->PageSavable;

    CacheInfo->ReadCacheEnabled = !(pageData->ReadDisableCache);
    CacheInfo->WriteCacheEnabled = pageData->WriteCacheEnable;


    //
    // Translate the values in the mode page into the ones defined in
    // ntdddisk.h.
    //

    CacheInfo->ReadRetentionPriority =
        TRANSLATE_RETENTION_PRIORITY(pageData->ReadRetensionPriority);
    CacheInfo->WriteRetentionPriority =
        TRANSLATE_RETENTION_PRIORITY(pageData->WriteRetensionPriority);

    CacheInfo->DisablePrefetchTransferLength =
        ((pageData->DisablePrefetchTransfer[0] << 8) +
         pageData->DisablePrefetchTransfer[1]);

    CacheInfo->ScalarPrefetch.Minimum =
        ((pageData->MinimumPrefetch[0] << 8) + pageData->MinimumPrefetch[1]);

    CacheInfo->ScalarPrefetch.Maximum =
        ((pageData->MaximumPrefetch[0] << 8) + pageData->MaximumPrefetch[1]);

    if(pageData->MultiplicationFactor) {
        CacheInfo->PrefetchScalar = TRUE;
        CacheInfo->ScalarPrefetch.MaximumBlocks =
            ((pageData->MaximumPrefetchCeiling[0] << 8) +
             pageData->MaximumPrefetchCeiling[1]);
    }


    FREE_POOL(modeData);
    return STATUS_SUCCESS;
}

Referenced by DiskIoctlGetCacheInformation(), and DiskStartFdo().

DiskGetInfoExceptionInformation()

NTSTATUS DiskGetInfoExceptionInformation	(	IN PFUNCTIONAL_DEVICE_EXTENSION	FdoExtension,
		IN PMODE_INFO_EXCEPTIONS	ReturnPageData
	)

Definition at line 2896 of file disk.c.

{
    PMODE_PARAMETER_HEADER modeData;
    PMODE_INFO_EXCEPTIONS pageData;
    ULONG length;

    NTSTATUS status;

    PAGED_CODE();

    //
    // ReturnPageData is allocated by the caller
    //

    modeData = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
                                         MODE_DATA_SIZE,
                                         DISK_TAG_INFO_EXCEPTION);

    if (modeData == NULL) {

        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_WMI, "DiskGetInfoExceptionInformation: Unable to allocate mode "
                       "data buffer\n"));
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    RtlZeroMemory(modeData, MODE_DATA_SIZE);

    length = ClassModeSense(FdoExtension->DeviceObject,
                            (PCHAR) modeData,
                            MODE_DATA_SIZE,
                            MODE_PAGE_FAULT_REPORTING);

    if (length < sizeof(MODE_PARAMETER_HEADER)) {

        //
        // Retry the request in case of a check condition.
        //

        length = ClassModeSense(FdoExtension->DeviceObject,
                                (PCHAR) modeData,
                                MODE_DATA_SIZE,
                                MODE_PAGE_FAULT_REPORTING);

        if (length < sizeof(MODE_PARAMETER_HEADER)) {
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_WMI, "DiskGetInfoExceptionInformation: Mode Sense failed\n"));
            FREE_POOL(modeData);
            return STATUS_IO_DEVICE_ERROR;
        }
    }

    //
    // If the length is greater than length indicated by the mode data reset
    // the data to the mode data.
    //

    if (length > (ULONG) (modeData->ModeDataLength + 1)) {
        length = modeData->ModeDataLength + 1;
    }

    //
    // Find the mode page for info exceptions
    //

    pageData = ClassFindModePage((PCHAR) modeData,
                                 length,
                                 MODE_PAGE_FAULT_REPORTING,
                                 TRUE);

    if (pageData != NULL) {
        RtlCopyMemory(ReturnPageData, pageData, sizeof(MODE_INFO_EXCEPTIONS));
        status =  STATUS_SUCCESS;
    } else {
        status = STATUS_NOT_SUPPORTED;
    }

    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "DiskGetInfoExceptionInformation: %s support SMART for device %p\n",
                  NT_SUCCESS(status) ? "does" : "does not",
                  FdoExtension->DeviceObject));

    FREE_POOL(modeData);

    return(status);
}

Referenced by DiskFdoExecuteWmiMethod(), and DiskFdoQueryWmiDataBlock().

DiskIoctlClearVerify()

NTSTATUS DiskIoctlClearVerify	(	IN PDEVICE_OBJECT	DeviceObject,
		IN OUT PIRP	Irp
	)

Definition at line 5313 of file disk.c.

{
    NTSTATUS status = STATUS_NOT_SUPPORTED;

    //
    // Validate the request.
    //

    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DiskIoctlClearVerify: DeviceObject %p Irp %p\n", DeviceObject, Irp));

    //
    // If the caller is kernel mode, set the verify bit.
    //

    if (Irp->RequestorMode == KernelMode) {

        CLEAR_FLAG(DeviceObject->Flags, DO_VERIFY_VOLUME);
        status = STATUS_SUCCESS;

    }
    return status;
}

Referenced by DiskDeviceControl().

DiskIoctlEnableFailurePrediction()

NTSTATUS DiskIoctlEnableFailurePrediction	(	IN PDEVICE_OBJECT	DeviceObject,
		IN OUT PIRP	Irp
	)

Definition at line 4419 of file disk.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    PDISK_DATA diskData = (PDISK_DATA)(commonExtension->DriverData);
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation (Irp);
    NTSTATUS status = STATUS_SUCCESS;
    PSTORAGE_FAILURE_PREDICTION_CONFIG enablePrediction;

    //
    // This function must be called at less than dispatch level.
    // Fail if IRQL >= DISPATCH_LEVEL.
    //
    PAGED_CODE();
    CHECK_IRQL();

    //
    // Validate the request.
    //

    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DiskIoctlEnableFailurePrediction: DeviceObject %p Irp %p\n", DeviceObject, Irp));

    if (irpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(STORAGE_FAILURE_PREDICTION_CONFIG) ||
        irpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(STORAGE_FAILURE_PREDICTION_CONFIG)) {

        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlEnableFailurePrediction: Buffer too small.\n"));
        return STATUS_BUFFER_TOO_SMALL;
    }

    enablePrediction = (PSTORAGE_FAILURE_PREDICTION_CONFIG)Irp->AssociatedIrp.SystemBuffer;

    if (enablePrediction->Version != STORAGE_FAILURE_PREDICTION_CONFIG_V1 ||
        enablePrediction->Size < sizeof(STORAGE_FAILURE_PREDICTION_CONFIG)) {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlEnableFailurePrediction: Buffer version or size is incorrect.\n"));
        status = STATUS_INVALID_PARAMETER;
    }

    if (enablePrediction->Reserved != 0) {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlEnableFailurePrediction: Reserved bytes are not zero!\n"));
        status = STATUS_INVALID_PARAMETER;
    }

    //
    // Default to success.  This might get overwritten on failure below.
    //
    status = STATUS_SUCCESS;

    //
    // If this is a "set" and the current state (enabled/disabled) is
    // different from the sender's desired state,
    //
    if (enablePrediction->Set && enablePrediction->Enabled != diskData->FailurePredictionEnabled) {
        if (diskData->FailurePredictionCapability == FailurePredictionSmart ||
            diskData->FailurePredictionCapability == FailurePredictionIoctl) {
            //
            // SMART or IOCTL based failure prediction is being used so call
            // the generic function that is normally called in the WMI path.
            //
            status = DiskEnableDisableFailurePrediction(fdoExtension, enablePrediction->Enabled);
        } else if (diskData->ScsiInfoExceptionsSupported) {
            //
            // If we know that the device supports the Informational Exceptions
            // mode page, try to enable/disable failure prediction that way.
            //
            status = DiskEnableInfoExceptions(fdoExtension, enablePrediction->Enabled);
        }
    }

    //
    // Return the current state regardless if this was a "set" or a "get".
    //
    enablePrediction->Enabled = diskData->FailurePredictionEnabled;

    if (NT_SUCCESS(status)) {
        Irp->IoStatus.Information = sizeof(STORAGE_FAILURE_PREDICTION_CONFIG);
    }

    return status;
}

Referenced by DiskDeviceControl().

DiskIoctlGetCacheInformation()

NTSTATUS DiskIoctlGetCacheInformation	(	IN PDEVICE_OBJECT	DeviceObject,
		IN OUT PIRP	Irp
	)

Definition at line 3840 of file disk.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation (Irp);
    PDISK_CACHE_INFORMATION cacheInfo = Irp->AssociatedIrp.SystemBuffer;
    NTSTATUS status;

    //
    // This function must be called at less than dispatch level.
    // Fail if IRQL >= DISPATCH_LEVEL.
    //
    PAGED_CODE();
    CHECK_IRQL();

    //
    // Validate the request.
    //

    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DiskIoctlGetCacheInformation: DeviceObject %p Irp %p\n", DeviceObject, Irp));

    if (irpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(DISK_CACHE_INFORMATION)) {

        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlGetCacheInformation: Output buffer too small.\n"));
        return STATUS_BUFFER_TOO_SMALL;
    }

    status = DiskGetCacheInformation(fdoExtension, cacheInfo);

    if (NT_SUCCESS(status)) {
        Irp->IoStatus.Information = sizeof(DISK_CACHE_INFORMATION);

        //
        // Make sure write cache setting is reflected in device extension
        //
        if (cacheInfo->WriteCacheEnabled)
        {
            SET_FLAG(fdoExtension->DeviceFlags, DEV_WRITE_CACHE);
        }
        else
        {
            CLEAR_FLAG(fdoExtension->DeviceFlags, DEV_WRITE_CACHE);
        }
        ADJUST_FUA_FLAG(fdoExtension);

    }
    return status;
}

Referenced by DiskDeviceControl().

DiskIoctlGetCacheSetting()

NTSTATUS DiskIoctlGetCacheSetting	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 3347 of file disk.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp);
    NTSTATUS status = STATUS_SUCCESS;

    PAGED_CODE();

    if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(DISK_CACHE_SETTING))
    {
        status = STATUS_BUFFER_TOO_SMALL;
    }
    else
    {
        PDISK_CACHE_SETTING cacheSetting = (PDISK_CACHE_SETTING)Irp->AssociatedIrp.SystemBuffer;

        cacheSetting->Version = sizeof(DISK_CACHE_SETTING);
        cacheSetting->State   = DiskCacheNormal;

        //
        // Determine whether it is safe to turn on the cache
        //
        if (TEST_FLAG(fdoExtension->ScanForSpecialFlags, CLASS_SPECIAL_FUA_NOT_SUPPORTED))
        {
            cacheSetting->State = DiskCacheWriteThroughNotSupported;
        }

        //
        // Determine whether it is possible to modify the cache setting
        //
        if (TEST_FLAG(fdoExtension->ScanForSpecialFlags, CLASS_SPECIAL_MODIFY_CACHE_UNSUCCESSFUL))
        {
            cacheSetting->State = DiskCacheModifyUnsuccessful;
        }

        cacheSetting->IsPowerProtected = TEST_FLAG(fdoExtension->DeviceFlags, DEV_POWER_PROTECTED);

        Irp->IoStatus.Information = sizeof(DISK_CACHE_SETTING);
    }

    return status;
}

Referenced by DiskDeviceControl().

DiskIoctlGetDriveGeometry()

NTSTATUS DiskIoctlGetDriveGeometry	(	IN PDEVICE_OBJECT	DeviceObject,
		IN OUT PIRP	Irp
	)

Definition at line 3582 of file disk.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    PDISK_DATA diskData = (PDISK_DATA)(commonExtension->DriverData);
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation (Irp);
    NTSTATUS status;

    //
    // This function must be called at less than dispatch level.
    // Fail if IRQL >= DISPATCH_LEVEL.
    //
    PAGED_CODE();
    CHECK_IRQL();

    if (irpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(DISK_GEOMETRY)) {

        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlGetDriveGeometry: Output buffer too small.\n"));
        return STATUS_BUFFER_TOO_SMALL;
    }

    if (TEST_FLAG(DeviceObject->Characteristics, FILE_REMOVABLE_MEDIA)) {

        //
        // Issue ReadCapacity to update device extension
        // with information for current media.
        //

        status = DiskReadDriveCapacity(commonExtension->PartitionZeroExtension->DeviceObject);

        //
        // Note whether the drive is ready.
        //

        diskData->ReadyStatus = status;

        if (!NT_SUCCESS(status)) {
            return status;
        }
    }

    //
    // Copy drive geometry information from device extension.
    //

    RtlMoveMemory(Irp->AssociatedIrp.SystemBuffer,
                  &(fdoExtension->DiskGeometry),
                  sizeof(DISK_GEOMETRY));

    if (((PDISK_GEOMETRY)Irp->AssociatedIrp.SystemBuffer)->BytesPerSector == 0) {
        ((PDISK_GEOMETRY)Irp->AssociatedIrp.SystemBuffer)->BytesPerSector = 512;
    }
    Irp->IoStatus.Information = sizeof(DISK_GEOMETRY);
    return STATUS_SUCCESS;
}

Referenced by DiskDeviceControl().

DiskIoctlGetDriveGeometryEx()

NTSTATUS DiskIoctlGetDriveGeometryEx	(	IN PDEVICE_OBJECT	DeviceObject,
		IN OUT PIRP	Irp
	)

Definition at line 3672 of file disk.c.

{
    NTSTATUS status;
    PIO_STACK_LOCATION irpStack;
    PCOMMON_DEVICE_EXTENSION commonExtension;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension;
    PDISK_DATA diskData;
    PDISK_GEOMETRY_EX_INTERNAL geometryEx;
    ULONG OutputBufferLength;

    //
    // This function must be called at less than dispatch level.
    // Fail if IRQL >= DISPATCH_LEVEL.
    //
    PAGED_CODE();
    CHECK_IRQL();

    //
    // Setup parameters
    //

    commonExtension = DeviceObject->DeviceExtension;
    fdoExtension = DeviceObject->DeviceExtension;
    diskData = (PDISK_DATA)(commonExtension->DriverData);
    irpStack = IoGetCurrentIrpStackLocation ( Irp );
    geometryEx = NULL;
    OutputBufferLength = irpStack->Parameters.DeviceIoControl.OutputBufferLength;

    //
    // Check that the buffer is large enough. It must be large enough
    // to hold at lest the Geometry and DiskSize fields of of the
    // DISK_GEOMETRY_EX structure.
    //

    if ( (LONG)OutputBufferLength < FIELD_OFFSET (DISK_GEOMETRY_EX, Data) ) {

        //
        // Buffer too small. Bail out, telling the caller the required
        // size.
        //

        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlGetDriveGeometryEx: Output buffer too small.\n"));
        status = STATUS_BUFFER_TOO_SMALL;
        return status;
    }

    if (TEST_FLAG (DeviceObject->Characteristics, FILE_REMOVABLE_MEDIA)) {

        //
        // Issue a ReadCapacity to update device extension
        // with information for the current media.
        //

        status = DiskReadDriveCapacity(commonExtension->PartitionZeroExtension->DeviceObject);

        diskData->ReadyStatus = status;

        if (!NT_SUCCESS (status)) {
            return status;
        }
    }

    //
    // Copy drive geometry.
    //

    geometryEx = (PDISK_GEOMETRY_EX_INTERNAL)Irp->AssociatedIrp.SystemBuffer;
    geometryEx->Geometry = fdoExtension->DiskGeometry;
    if (geometryEx->Geometry.BytesPerSector == 0) {
        geometryEx->Geometry.BytesPerSector = 512;
    }
    geometryEx->DiskSize = commonExtension->PartitionZeroExtension->CommonExtension.PartitionLength;

    //
    // If the user buffer is large enough to hold the partition information
    // then add that as well.
    //

    if ((LONG)OutputBufferLength >=  FIELD_OFFSET (DISK_GEOMETRY_EX_INTERNAL, Detection)) {

        geometryEx->Partition.SizeOfPartitionInfo = sizeof (geometryEx->Partition);
        geometryEx->Partition.PartitionStyle = diskData->PartitionStyle;

        switch ( diskData->PartitionStyle ) {

            case PARTITION_STYLE_GPT:

                //
                // Copy GPT signature.
                //

                geometryEx->Partition.Gpt.DiskId = diskData->Efi.DiskId;
                break;

            case PARTITION_STYLE_MBR:

                //
                // Copy MBR signature and checksum.
                //

                geometryEx->Partition.Mbr.Signature = diskData->Mbr.Signature;
                geometryEx->Partition.Mbr.CheckSum = diskData->Mbr.MbrCheckSum;
                break;

            default:

                //
                // This is a raw disk. Zero out the signature area so
                // nobody gets confused.
                //

                RtlZeroMemory(&geometryEx->Partition, sizeof (geometryEx->Partition));
        }
    }

    //
    // If the buffer is large enough to hold the detection information,
    // then also add that.
    //

    if (OutputBufferLength >= sizeof (DISK_GEOMETRY_EX_INTERNAL)) {

        geometryEx->Detection.SizeOfDetectInfo = sizeof (geometryEx->Detection);

        status = DiskGetDetectInfo(fdoExtension, &geometryEx->Detection);

        //
        // Failed to obtain detection information, set to none.
        //

        if (!NT_SUCCESS (status)) {
            geometryEx->Detection.DetectionType = DetectNone;
        }
    }

    status = STATUS_SUCCESS;
    Irp->IoStatus.Information = min (OutputBufferLength, sizeof (DISK_GEOMETRY_EX_INTERNAL));

    return status;
}

Referenced by DiskDeviceControl().

DiskIoctlGetLengthInfo()

NTSTATUS DiskIoctlGetLengthInfo	(	IN OUT PDEVICE_OBJECT	DeviceObject,
		IN OUT PIRP	Irp
	)

Definition at line 3492 of file disk.c.

{
    NTSTATUS status;
    PIO_STACK_LOCATION irpStack;
    PGET_LENGTH_INFORMATION lengthInfo;
    PFUNCTIONAL_DEVICE_EXTENSION p0Extension;
    PCOMMON_DEVICE_EXTENSION commonExtension;
    PDISK_DATA partitionZeroData;
    NTSTATUS oldReadyStatus;

    //
    // This function must be called at less than dispatch level.
    // Fail if IRQL >= DISPATCH_LEVEL.
    //
    PAGED_CODE();
    CHECK_IRQL();

    //
    // Initialization
    //

    commonExtension = DeviceObject->DeviceExtension;
    irpStack = IoGetCurrentIrpStackLocation(Irp);
    p0Extension = commonExtension->PartitionZeroExtension;
    partitionZeroData = ((PDISK_DATA) p0Extension->CommonExtension.DriverData);

    //
    // Check that the buffer is large enough.
    //

    if (irpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(GET_LENGTH_INFORMATION)) {
        return STATUS_BUFFER_TOO_SMALL;
    }

    //
    // Update the geometry in case it has changed
    //

    status = DiskReadDriveCapacity(p0Extension->DeviceObject);

    //
    // Note whether the drive is ready.  If the status has changed then
    // notify pnp.
    //

    oldReadyStatus = InterlockedExchange(&(partitionZeroData->ReadyStatus), status);

    if(partitionZeroData->ReadyStatus != oldReadyStatus) {
        IoInvalidateDeviceRelations(p0Extension->LowerPdo, BusRelations);
    }

    if(!NT_SUCCESS(status)) {
        return status;
    }
    lengthInfo = (PGET_LENGTH_INFORMATION) Irp->AssociatedIrp.SystemBuffer;

    lengthInfo->Length = commonExtension->PartitionLength;

    status = STATUS_SUCCESS;
    Irp->IoStatus.Information = sizeof(GET_LENGTH_INFORMATION);

    return status;
}

Referenced by DiskDeviceControl().

DiskIoctlGetMediaTypesEx()

NTSTATUS DiskIoctlGetMediaTypesEx	(	IN PDEVICE_OBJECT	DeviceObject,
		IN OUT PIRP	Irp
	)

Definition at line 3994 of file disk.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation (Irp);
    NTSTATUS status;

    PMODE_PARAMETER_HEADER modeData;
    PMODE_PARAMETER_BLOCK blockDescriptor;
    PSCSI_REQUEST_BLOCK srb;
    PCDB cdb;
    ULONG modeLength;
    ULONG retries = 4;
    UCHAR densityCode = 0;
    BOOLEAN writable = TRUE;
    BOOLEAN mediaPresent = FALSE;
    ULONG srbSize;
    PSTORAGE_REQUEST_BLOCK srbEx = NULL;
    PSTOR_ADDR_BTL8 storAddrBtl8 = NULL;
    PSRBEX_DATA_SCSI_CDB16 srbExDataCdb16 = NULL;

    //
    // This function must be called at less than dispatch level.
    // Fail if IRQL >= DISPATCH_LEVEL.
    //
    PAGED_CODE();
    CHECK_IRQL();

    //
    // Validate the request.
    //

    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DiskIoctlGetMediaTypesEx: DeviceObject %p Irp %p\n", DeviceObject, Irp));

    if (irpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(GET_MEDIA_TYPES)) {

        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlGetMediaTypesEx: Output buffer too small.\n"));
        return STATUS_BUFFER_TOO_SMALL;
    }

    if (fdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
        srbSize = CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE;
    } else {
        srbSize = SCSI_REQUEST_BLOCK_SIZE;
    }

    srb = ExAllocatePoolWithTag(NonPagedPoolNx,
                                srbSize,
                                DISK_TAG_SRB);

    if (srb == NULL) {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlGetMediaTypesEx: Unable to allocate memory.\n"));
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    RtlZeroMemory(srb, srbSize);

    //
    // Send a TUR to determine if media is present.
    //

    if (fdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
        srbEx = (PSTORAGE_REQUEST_BLOCK)srb;

        //
        // Set up STORAGE_REQUEST_BLOCK fields
        //

        srbEx->Length = FIELD_OFFSET(STORAGE_REQUEST_BLOCK, Signature);
        srbEx->Function = SRB_FUNCTION_STORAGE_REQUEST_BLOCK;
        srbEx->Signature = SRB_SIGNATURE;
        srbEx->Version = STORAGE_REQUEST_BLOCK_VERSION_1;
        srbEx->SrbLength = srbSize;
        srbEx->SrbFunction = SRB_FUNCTION_EXECUTE_SCSI;
        srbEx->RequestPriority = IoGetIoPriorityHint(Irp);
        srbEx->AddressOffset = sizeof(STORAGE_REQUEST_BLOCK);
        srbEx->NumSrbExData = 1;

        // Set timeout value.
        srbEx->TimeOutValue = fdoExtension->TimeOutValue;

        //
        // Set up address fields
        //

        storAddrBtl8 = (PSTOR_ADDR_BTL8) ((PUCHAR)srbEx + srbEx->AddressOffset);
        storAddrBtl8->Type = STOR_ADDRESS_TYPE_BTL8;
        storAddrBtl8->AddressLength = STOR_ADDR_BTL8_ADDRESS_LENGTH;

        //
        // Set up SCSI SRB extended data fields
        //

        srbEx->SrbExDataOffset[0] = sizeof(STORAGE_REQUEST_BLOCK) +
            sizeof(STOR_ADDR_BTL8);
        if ((srbEx->SrbExDataOffset[0] + sizeof(SRBEX_DATA_SCSI_CDB16)) <= srbEx->SrbLength) {
            srbExDataCdb16 = (PSRBEX_DATA_SCSI_CDB16)((PUCHAR)srbEx + srbEx->SrbExDataOffset[0]);
            srbExDataCdb16->Type = SrbExDataTypeScsiCdb16;
            srbExDataCdb16->Length = SRBEX_DATA_SCSI_CDB16_LENGTH;
            srbExDataCdb16->CdbLength = 6;

            cdb = (PCDB)srbExDataCdb16->Cdb;
        } else {
            // Should not happen
            NT_ASSERT(FALSE);

            FREE_POOL(srb);
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlGetMediaTypesEx: Insufficient extended SRB size.\n"));
            return STATUS_INTERNAL_ERROR;
        }

    } else {

        srb->Length = SCSI_REQUEST_BLOCK_SIZE;
        srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
        srb->CdbLength = 6;
        cdb = (PCDB)srb->Cdb;

        //
        // Set timeout value.
        //

        srb->TimeOutValue = fdoExtension->TimeOutValue;

    }
    cdb->CDB6GENERIC.OperationCode = SCSIOP_TEST_UNIT_READY;

    status = ClassSendSrbSynchronous(DeviceObject,
                                     srb,
                                     NULL,
                                     0,
                                     FALSE);

    if (NT_SUCCESS(status)) {
        mediaPresent = TRUE;
    }

    modeLength = MODE_DATA_SIZE;
    modeData = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
                                     modeLength,
                                     DISK_TAG_MODE_DATA);

    if (modeData == NULL) {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlGetMediaTypesEx: Unable to allocate memory.\n"));
        FREE_POOL(srb);
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    RtlZeroMemory(modeData, modeLength);

    //
    // Build the MODE SENSE CDB using previous SRB.
    //

    if (fdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
        srbEx->SrbStatus = 0;
        srbExDataCdb16->ScsiStatus = 0;
        srbExDataCdb16->CdbLength = 6;

        //
        // Set timeout value from device extension.
        //

        srbEx->TimeOutValue = fdoExtension->TimeOutValue;
    } else {
        srb->SrbStatus = 0;
        srb->ScsiStatus = 0;
        srb->CdbLength = 6;

        //
        // Set timeout value from device extension.
        //

        srb->TimeOutValue = fdoExtension->TimeOutValue;
    }

    //
    // Page code of 0x3F will return all pages.
    // This command could fail if the data to be returned is
    // more than 256 bytes. In which case, we should get only
    // the caching page since we only need the block descriptor.
    // DiskFdoProcessError will change the page code to
    // MODE_PAGE_CACHING if there is an error.
    //

    cdb->MODE_SENSE.OperationCode    = SCSIOP_MODE_SENSE;
    cdb->MODE_SENSE.PageCode         = MODE_SENSE_RETURN_ALL;
    cdb->MODE_SENSE.AllocationLength = (UCHAR)modeLength;

Retry:
    status = ClassSendSrbSynchronous(DeviceObject,
                                     srb,
                                     modeData,
                                     modeLength,
                                     FALSE);

    if (status == STATUS_VERIFY_REQUIRED) {

        if (retries--) {

            //
            // Retry request.
            //

            goto Retry;
        }
    } else if (SRB_STATUS(srb->SrbStatus) == SRB_STATUS_DATA_OVERRUN) {
        status = STATUS_SUCCESS;
    }

    if (NT_SUCCESS(status) || (status == STATUS_NO_MEDIA_IN_DEVICE)) {

        //
        // Get the block descriptor.
        //

        if (modeData->BlockDescriptorLength != 0) {

            blockDescriptor = (PMODE_PARAMETER_BLOCK)((ULONG_PTR)modeData + sizeof(MODE_PARAMETER_HEADER));
            densityCode = blockDescriptor->DensityCode;
        }

        if (TEST_FLAG(modeData->DeviceSpecificParameter,
                      MODE_DSP_WRITE_PROTECT)) {

            writable = FALSE;
        }

        status = DiskDetermineMediaTypes(DeviceObject,
                                         Irp,
                                         modeData->MediumType,
                                         densityCode,
                                         mediaPresent,
                                         writable);
        //
        // If the buffer was too small, DetermineMediaTypes updated the status and information and the request will fail.
        //

    } else {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlGetMediaTypesEx: Mode sense for header/bd failed. %lx\n", status));
    }

    FREE_POOL(srb);
    FREE_POOL(modeData);

    return status;
}

Referenced by DiskDeviceControl().

DiskIoctlGetVolumeDiskExtents()

NTSTATUS DiskIoctlGetVolumeDiskExtents	(	IN PDEVICE_OBJECT	DeviceObject,
		IN OUT PIRP	Irp
	)

Definition at line 5461 of file disk.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PDISK_DATA diskData = (PDISK_DATA)(commonExtension->DriverData);
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation (Irp);
    NTSTATUS status = STATUS_INVALID_DEVICE_REQUEST;

    //
    // This function must be called at less than dispatch level.
    // Fail if IRQL >= DISPATCH_LEVEL.
    //
    PAGED_CODE();
    CHECK_IRQL();

    //
    // Validate the request.
    //

    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DiskIoctlGetVolumeDiskExtents: DeviceObject %p Irp %p\n", DeviceObject, Irp));


    if (TEST_FLAG(DeviceObject->Characteristics, FILE_REMOVABLE_MEDIA)) {

        if (irpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(VOLUME_DISK_EXTENTS)) {
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlGetVolumeDiskExtents: Output buffer too small.\n"));
            return STATUS_BUFFER_TOO_SMALL;
        }

        status = DiskReadDriveCapacity(commonExtension->PartitionZeroExtension->DeviceObject);

        //
        // Note whether the drive is ready.
        //

        diskData->ReadyStatus = status;

        if (NT_SUCCESS(status)) {

            PVOLUME_DISK_EXTENTS pVolExt = (PVOLUME_DISK_EXTENTS)Irp->AssociatedIrp.SystemBuffer;

            pVolExt->NumberOfDiskExtents = 1;
            pVolExt->Extents[0].DiskNumber     = commonExtension->PartitionZeroExtension->DeviceNumber;
            pVolExt->Extents[0].StartingOffset = commonExtension->StartingOffset;
            pVolExt->Extents[0].ExtentLength   = commonExtension->PartitionLength;

            Irp->IoStatus.Information = sizeof(VOLUME_DISK_EXTENTS);
        }
    }

    return status;
}

Referenced by DiskDeviceControl().

DiskIoctlIsWritable()

NTSTATUS DiskIoctlIsWritable	(	IN PDEVICE_OBJECT	DeviceObject,
		IN OUT PIRP	Irp
	)

Definition at line 5063 of file disk.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    NTSTATUS status = STATUS_SUCCESS;

    PMODE_PARAMETER_HEADER modeData;
    PSCSI_REQUEST_BLOCK srb;
    PCDB cdb = NULL;
    ULONG modeLength;
    ULONG retries = 4;
    ULONG srbSize;
    PSTORAGE_REQUEST_BLOCK srbEx;
    PSTOR_ADDR_BTL8 storAddrBtl8;
    PSRBEX_DATA_SCSI_CDB16 srbExDataCdb16;

    //
    // This function must be called at less than dispatch level.
    // Fail if IRQL >= DISPATCH_LEVEL.
    //
    PAGED_CODE();
    CHECK_IRQL();

    //
    // Validate the request.
    //

    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DiskIoctlIsWritable: DeviceObject %p Irp %p\n", DeviceObject, Irp));

    if (fdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
        srbSize = CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE;
    } else {
        srbSize = SCSI_REQUEST_BLOCK_SIZE;
    }
    srb = ExAllocatePoolWithTag(NonPagedPoolNx,
                                srbSize,
                                DISK_TAG_SRB);

    if (srb == NULL) {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlIsWritable: Unable to allocate memory.\n"));
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    RtlZeroMemory(srb, srbSize);

    //
    // Allocate memory for a mode header and then some
    // for port drivers that need to convert to MODE10
    // or always return the MODE_PARAMETER_BLOCK (even
    // when memory was not allocated for this purpose)
    //

    modeLength = MODE_DATA_SIZE;
    modeData = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
                                     modeLength,
                                     DISK_TAG_MODE_DATA);

    if (modeData == NULL) {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlIsWritable: Unable to allocate memory.\n"));
        FREE_POOL(srb);
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    RtlZeroMemory(modeData, modeLength);

    //
    // Build the MODE SENSE CDB
    //

    if (fdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
        srbEx = (PSTORAGE_REQUEST_BLOCK)srb;

        //
        // Set up STORAGE_REQUEST_BLOCK fields
        //

        srbEx->Length = FIELD_OFFSET(STORAGE_REQUEST_BLOCK, Signature);
        srbEx->Function = SRB_FUNCTION_STORAGE_REQUEST_BLOCK;
        srbEx->Signature = SRB_SIGNATURE;
        srbEx->Version = STORAGE_REQUEST_BLOCK_VERSION_1;
        srbEx->SrbLength = srbSize;
        srbEx->SrbFunction = SRB_FUNCTION_EXECUTE_SCSI;
        srbEx->RequestPriority = IoGetIoPriorityHint(Irp);
        srbEx->AddressOffset = sizeof(STORAGE_REQUEST_BLOCK);
        srbEx->NumSrbExData = 1;

        // Set timeout value.
        srbEx->TimeOutValue = fdoExtension->TimeOutValue;

        //
        // Set up address fields
        //

        storAddrBtl8 = (PSTOR_ADDR_BTL8) ((PUCHAR)srbEx + srbEx->AddressOffset);
        storAddrBtl8->Type = STOR_ADDRESS_TYPE_BTL8;
        storAddrBtl8->AddressLength = STOR_ADDR_BTL8_ADDRESS_LENGTH;

        //
        // Set up SCSI SRB extended data fields
        //

        srbEx->SrbExDataOffset[0] = sizeof(STORAGE_REQUEST_BLOCK) +
            sizeof(STOR_ADDR_BTL8);
        if ((srbEx->SrbExDataOffset[0] + sizeof(SRBEX_DATA_SCSI_CDB16)) <= srbEx->SrbLength) {
            srbExDataCdb16 = (PSRBEX_DATA_SCSI_CDB16)((PUCHAR)srbEx + srbEx->SrbExDataOffset[0]);
            srbExDataCdb16->Type = SrbExDataTypeScsiCdb16;
            srbExDataCdb16->Length = SRBEX_DATA_SCSI_CDB16_LENGTH;
            srbExDataCdb16->CdbLength = 6;

            cdb = (PCDB)srbExDataCdb16->Cdb;
        } else {
            // Should not happen
            NT_ASSERT(FALSE);

            FREE_POOL(srb);
            FREE_POOL(modeData);
            return STATUS_INTERNAL_ERROR;
        }

    } else {
        srb->Length = SCSI_REQUEST_BLOCK_SIZE;
        srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
        srb->CdbLength = 6;

        //
        // Set timeout value.
        //

        srb->TimeOutValue = fdoExtension->TimeOutValue;

        cdb = (PCDB)srb->Cdb;
    }

    //
    // Page code of 0x3F will return all pages.
    // This command could fail if the data to be returned is
    // more than 256 bytes. In which case, we should get only
    // the caching page since we only need the block descriptor.
    // DiskFdoProcessError will change the page code to
    // MODE_PAGE_CACHING if there is an error.
    //

    cdb->MODE_SENSE.OperationCode    = SCSIOP_MODE_SENSE;
    cdb->MODE_SENSE.PageCode         = MODE_SENSE_RETURN_ALL;
    cdb->MODE_SENSE.AllocationLength = (UCHAR)modeLength;

    while (retries != 0) {

        status = ClassSendSrbSynchronous(DeviceObject,
                                         srb,
                                         modeData,
                                         modeLength,
                                         FALSE);

        if (status != STATUS_VERIFY_REQUIRED) {
            if (SRB_STATUS(srb->SrbStatus) == SRB_STATUS_DATA_OVERRUN) {
                status = STATUS_SUCCESS;
            }
            break;
        }
        retries--;
    }

    if (NT_SUCCESS(status)) {

        if (TEST_FLAG(modeData->DeviceSpecificParameter, MODE_DSP_WRITE_PROTECT)) {
            status = STATUS_MEDIA_WRITE_PROTECTED;
        }
    }

    FREE_POOL(srb);
    FREE_POOL(modeData);
    return status;
}

Referenced by DiskDeviceControl().

DiskIoctlPredictFailure()

NTSTATUS DiskIoctlPredictFailure	(	IN PDEVICE_OBJECT	DeviceObject,
		IN OUT PIRP	Irp
	)

Definition at line 4268 of file disk.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    PDISK_DATA diskData = (PDISK_DATA)(commonExtension->DriverData);
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation (Irp);
    NTSTATUS status = STATUS_SUCCESS;

    PSTORAGE_PREDICT_FAILURE checkFailure;
    STORAGE_FAILURE_PREDICT_STATUS diskSmartStatus;
    IO_STATUS_BLOCK ioStatus = { 0 };
    KEVENT event;

    //
    // This function must be called at less than dispatch level.
    // Fail if IRQL >= DISPATCH_LEVEL.
    //
    PAGED_CODE();
    CHECK_IRQL();

    //
    // Validate the request.
    //

    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DiskIoctlPredictFailure: DeviceObject %p Irp %p\n", DeviceObject, Irp));

    if (irpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(STORAGE_PREDICT_FAILURE)) {

        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlPredictFailure: Output buffer too small.\n"));
        return STATUS_BUFFER_TOO_SMALL;
    }

    //
    // See if the disk is predicting failure
    //

    checkFailure = (PSTORAGE_PREDICT_FAILURE)Irp->AssociatedIrp.SystemBuffer;

    if (diskData->FailurePredictionCapability == FailurePredictionSense) {
        ULONG readBufferSize;
        PUCHAR readBuffer;
        PIRP readIrp;
        PDEVICE_OBJECT topOfStack;

        checkFailure->PredictFailure = 0;

        KeInitializeEvent(&event, SynchronizationEvent, FALSE);

        topOfStack = IoGetAttachedDeviceReference(DeviceObject);

        //
        // SCSI disks need to have a read sent down to provoke any
        // failures to be reported.
        //
        // Issue a normal read operation.  The error-handling code in
        // classpnp will take care of a failure prediction by logging the
        // correct event.
        //

        readBufferSize = fdoExtension->DiskGeometry.BytesPerSector;
        readBuffer = ExAllocatePoolWithTag(NonPagedPoolNx,
                                           readBufferSize,
                                           DISK_TAG_SMART);

        if (readBuffer != NULL) {
            LARGE_INTEGER offset;

            offset.QuadPart = 0;
            readIrp = IoBuildSynchronousFsdRequest(IRP_MJ_READ,
                                                   topOfStack,
                                                   readBuffer,
                                                   readBufferSize,
                                                   &offset,
                                                   &event,
                                                   &ioStatus);

            if (readIrp != NULL) {

                status = IoCallDriver(topOfStack, readIrp);
                if (status == STATUS_PENDING) {
                    KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
                    status = ioStatus.Status;
                }


            } else {
                status = STATUS_INSUFFICIENT_RESOURCES;
            }

            FREE_POOL(readBuffer);
        } else {
            status = STATUS_INSUFFICIENT_RESOURCES;
        }

        ObDereferenceObject(topOfStack);
    }

    if (status != STATUS_INSUFFICIENT_RESOURCES)
    {
        if ((diskData->FailurePredictionCapability == FailurePredictionSmart) ||
            (diskData->FailurePredictionCapability == FailurePredictionSense)) {

            status = DiskReadFailurePredictStatus(fdoExtension, &diskSmartStatus);

            if (NT_SUCCESS(status)) {

                status = DiskReadFailurePredictData(fdoExtension,
                                                    Irp->AssociatedIrp.SystemBuffer);

                if (diskSmartStatus.PredictFailure) {
                    checkFailure->PredictFailure = 1;
                } else {
                    checkFailure->PredictFailure = 0;
                }

                Irp->IoStatus.Information = sizeof(STORAGE_PREDICT_FAILURE);
            }
        } else {
            status = STATUS_INVALID_DEVICE_REQUEST;
        }
    }
    return status;
}

Referenced by DiskDeviceControl().

DiskIoctlReassignBlocks()

NTSTATUS DiskIoctlReassignBlocks	(	IN PDEVICE_OBJECT	DeviceObject,
		IN OUT PIRP	Irp
	)

Definition at line 4648 of file disk.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation (Irp);
    NTSTATUS status;
    PREASSIGN_BLOCKS badBlocks = Irp->AssociatedIrp.SystemBuffer;
    PSCSI_REQUEST_BLOCK srb;
    PCDB cdb;
    ULONG bufferSize;
    ULONG blockNumber;
    ULONG blockCount;
    ULONG srbSize;
    PSTORAGE_REQUEST_BLOCK srbEx;
    PSTOR_ADDR_BTL8 storAddrBtl8;
    PSRBEX_DATA_SCSI_CDB16 srbExDataCdb16;

    //
    // This function must be called at less than dispatch level.
    // Fail if IRQL >= DISPATCH_LEVEL.
    //
    PAGED_CODE();
    CHECK_IRQL();

    //
    // Validate the request.
    //

    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DiskIoctlReassignBlocks: DeviceObject %p Irp %p\n", DeviceObject, Irp));

    if (irpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(REASSIGN_BLOCKS)) {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlReassignBlocks: Input buffer length mismatch.\n"));
        return STATUS_INFO_LENGTH_MISMATCH;
    }

    //
    // Make sure we have some data in the input buffer.
    //

    if (badBlocks->Count == 0) {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlReassignBlocks: Invalid block count\n"));
        return STATUS_INVALID_PARAMETER;
    }

    bufferSize = sizeof(REASSIGN_BLOCKS) + ((badBlocks->Count - 1) * sizeof(ULONG));

    if (irpStack->Parameters.DeviceIoControl.InputBufferLength < bufferSize) {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlReassignBlocks: Input buffer length mismatch for bad blocks.\n"));
        return STATUS_INFO_LENGTH_MISMATCH;
    }

    if (fdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
        srbSize = CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE;
    } else {
        srbSize = SCSI_REQUEST_BLOCK_SIZE;
    }
    srb = ExAllocatePoolWithTag(NonPagedPoolNx,
                                srbSize,
                                DISK_TAG_SRB);

    if (srb == NULL) {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlReassignBlocks: Unable to allocate memory.\n"));
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    RtlZeroMemory(srb, srbSize);

    //
    // Build the data buffer to be transferred in the input buffer.
    // The format of the data to the device is:
    //
    //      2 bytes Reserved
    //      2 bytes Length
    //      x * 4 btyes Block Address
    //
    // All values are big endian.
    //

    badBlocks->Reserved = 0;
    blockCount = badBlocks->Count;

    //
    // Convert # of entries to # of bytes.
    //

    blockCount *= 4;
    badBlocks->Count = (USHORT) ((blockCount >> 8) & 0XFF);
    badBlocks->Count |= (USHORT) ((blockCount << 8) & 0XFF00);

    //
    // Convert back to number of entries.
    //

    blockCount /= 4;

    for (; blockCount > 0; blockCount--) {

        blockNumber = badBlocks->BlockNumber[blockCount-1];
        REVERSE_BYTES((PFOUR_BYTE) &badBlocks->BlockNumber[blockCount-1], (PFOUR_BYTE) &blockNumber);
    }

    //
    // Build a SCSI SRB containing a SCSIOP_REASSIGN_BLOCKS cdb
    //

    if (fdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
        srbEx = (PSTORAGE_REQUEST_BLOCK)srb;

        //
        // Set up STORAGE_REQUEST_BLOCK fields
        //

        srbEx->Length = FIELD_OFFSET(STORAGE_REQUEST_BLOCK, Signature);
        srbEx->Function = SRB_FUNCTION_STORAGE_REQUEST_BLOCK;
        srbEx->Signature = SRB_SIGNATURE;
        srbEx->Version = STORAGE_REQUEST_BLOCK_VERSION_1;
        srbEx->SrbLength = srbSize;
        srbEx->SrbFunction = SRB_FUNCTION_EXECUTE_SCSI;
        srbEx->RequestPriority = IoGetIoPriorityHint(Irp);
        srbEx->AddressOffset = sizeof(STORAGE_REQUEST_BLOCK);
        srbEx->NumSrbExData = 1;

        // Set timeout value.
        srbEx->TimeOutValue = fdoExtension->TimeOutValue;

        //
        // Set up address fields
        //

        storAddrBtl8 = (PSTOR_ADDR_BTL8) ((PUCHAR)srbEx + srbEx->AddressOffset);
        storAddrBtl8->Type = STOR_ADDRESS_TYPE_BTL8;
        storAddrBtl8->AddressLength = STOR_ADDR_BTL8_ADDRESS_LENGTH;

        //
        // Set up SCSI SRB extended data fields
        //

        srbEx->SrbExDataOffset[0] = sizeof(STORAGE_REQUEST_BLOCK) +
            sizeof(STOR_ADDR_BTL8);
        if ((srbEx->SrbExDataOffset[0] + sizeof(SRBEX_DATA_SCSI_CDB16)) <= srbEx->SrbLength) {
            srbExDataCdb16 = (PSRBEX_DATA_SCSI_CDB16)((PUCHAR)srbEx + srbEx->SrbExDataOffset[0]);
            srbExDataCdb16->Type = SrbExDataTypeScsiCdb16;
            srbExDataCdb16->Length = SRBEX_DATA_SCSI_CDB16_LENGTH;
            srbExDataCdb16->CdbLength = 6;

            cdb = (PCDB)srbExDataCdb16->Cdb;
        } else {
            // Should not happen
            NT_ASSERT(FALSE);

            FREE_POOL(srb);
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlReassignBlocks: Insufficient extended SRB size.\n"));
            return STATUS_INTERNAL_ERROR;
        }

    } else {
        srb->Length = SCSI_REQUEST_BLOCK_SIZE;
        srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
        srb->CdbLength = 6;

        //
        // Set timeout value.
        //

        srb->TimeOutValue = fdoExtension->TimeOutValue;

        cdb = (PCDB)srb->Cdb;
    }

    cdb->CDB6GENERIC.OperationCode = SCSIOP_REASSIGN_BLOCKS;

    status = ClassSendSrbSynchronous(DeviceObject,
                                     srb,
                                     badBlocks,
                                     bufferSize,
                                     TRUE);

    FREE_POOL(srb);
    return status;
}

Referenced by DiskDeviceControl().

DiskIoctlReassignBlocksEx()

NTSTATUS DiskIoctlReassignBlocksEx	(	IN PDEVICE_OBJECT	DeviceObject,
		IN OUT PIRP	Irp
	)

Definition at line 4855 of file disk.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation (Irp);
    NTSTATUS status;
    PREASSIGN_BLOCKS_EX badBlocks = Irp->AssociatedIrp.SystemBuffer;
    PSCSI_REQUEST_BLOCK srb;
    PCDB cdb;
    LARGE_INTEGER blockNumber;
    ULONG bufferSize;
    ULONG blockCount;
    ULONG srbSize;
    PSTORAGE_REQUEST_BLOCK srbEx;
    PSTOR_ADDR_BTL8 storAddrBtl8;
    PSRBEX_DATA_SCSI_CDB16 srbExDataCdb16;

    //
    // This function must be called at less than dispatch level.
    // Fail if IRQL >= DISPATCH_LEVEL.
    //