NTSTATUS
NTAPI
DiskEnumerateDevice(
IN PDEVICE_OBJECT Fdo
)
/*++
Routine Description:
This routine is called by the class driver to update the PDO list off
of this FDO. The disk driver also calls it internally to re-create
device objects.
This routine will read the partition table and create new PDO objects as
necessary. PDO's that no longer exist will be pulled out of the PDO list
so that pnp will destroy them.
Arguments:
Fdo - a pointer to the FDO being re-enumerated
Return Value:
status
--*/
{
PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension;
PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
//PPHYSICAL_DEVICE_EXTENSION pdoExtension = NULL;
PDISK_DATA diskData = (PDISK_DATA) commonExtension->DriverData;
//PDEVICE_OBJECT pdo = NULL;
//ULONG numberListElements = 0;
PDRIVE_LAYOUT_INFORMATION_EX partitionList;
NTSTATUS status;
ASSERT(commonExtension->IsFdo);
PAGED_CODE();
//
// Update our image of the size of the drive. This may be necessary if
// the drive size is extended or we just released a reservation to
// ensure the kernel doesn't reject the partition table.
//
DiskReadDriveCapacity(Fdo);
//
// Lock out anyone else trying to repartition the disk.
//
DiskAcquirePartitioningLock(fdoExtension);
//
// Create objects for all the partitions on the device.
//
status = DiskReadPartitionTableEx(fdoExtension, FALSE, &partitionList);
//
// If the I/O read partition table failed and this is a removable device,
// then fix up the partition list to make it look like there is one
// zero length partition.
//
if ((!NT_SUCCESS(status) || partitionList->PartitionCount == 0) &&
Fdo->Characteristics & FILE_REMOVABLE_MEDIA) {
SIZE_T partitionListSize;
//
// Remember whether the drive is ready.
//
diskData->ReadyStatus = status;
//
// Allocate and zero a partition list.
//
partitionListSize =
FIELD_OFFSET(DRIVE_LAYOUT_INFORMATION_EX, PartitionEntry[1]);
partitionList = ExAllocatePoolWithTag(NonPagedPool,
partitionListSize,
DISK_TAG_PART_LIST);
if (partitionList != NULL) {
RtlZeroMemory( partitionList, partitionListSize );
//
// Set the partition count to one and the status to success
// so one device object will be created. Set the partition type
// to a bogus value.
//
partitionList->PartitionStyle = PARTITION_STYLE_MBR;
partitionList->PartitionCount = 1;
status = STATUS_SUCCESS;
} else {
status = STATUS_INSUFFICIENT_RESOURCES;
}
}
if (NT_SUCCESS(status)) {
diskData->UpdatePartitionRoutine(Fdo, partitionList);
//
// Record disk signature.
//
if (partitionList->PartitionStyle == PARTITION_STYLE_MBR) {
diskData->PartitionStyle = PARTITION_STYLE_MBR;
diskData->Mbr.Signature = partitionList->Mbr.Signature;
} else {
diskData->PartitionStyle = PARTITION_STYLE_GPT;
diskData->Efi.DiskId = partitionList->Gpt.DiskId;
}
}
DiskReleasePartitioningLock(fdoExtension);
return(STATUS_SUCCESS);
} // end DiskEnumerateDevice()
NTSTATUS
DiskInitFdo(
IN PDEVICE_OBJECT Fdo
)
/*++
Routine Description:
This routine is called to do one-time initialization of new device objects
Arguments:
Fdo - a pointer to the functional device object for this device
Return Value:
status
--*/
{
PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
PDISK_DATA diskData = (PDISK_DATA) fdoExtension->CommonExtension.DriverData;
ULONG srbFlags = 0;
ULONG timeOut = 0;
ULONG bytesPerSector;
PULONG dmSkew;
NTSTATUS status = STATUS_SUCCESS;
PAGED_CODE();
//
// Build the lookaside list for srb's for the physical disk. Should only
// need a couple. If this fails then we don't have an emergency SRB so
// fail the call to initialize.
//
ClassInitializeSrbLookasideList((PCOMMON_DEVICE_EXTENSION) fdoExtension,
PARTITION0_LIST_SIZE);
if (fdoExtension->DeviceDescriptor->RemovableMedia)
{
SET_FLAG(Fdo->Characteristics, FILE_REMOVABLE_MEDIA);
}
//
// Initialize the srb flags.
//
//
// Because all requests share a common sense buffer, it is possible
// for the buffer to be overwritten if the port driver completes
// multiple failed requests that require a request sense before the
// class driver's completion routine can consume the data in the buffer.
// To prevent this, we allow the port driver to allocate a unique sense
// buffer each time it needs one. We are responsible for freeing this
// buffer. This also allows the adapter to be configured to support
// additional sense data beyond the minimum 18 bytes.
//
SET_FLAG(fdoExtension->SrbFlags, SRB_FLAGS_PORT_DRIVER_ALLOCSENSE);
if (fdoExtension->DeviceDescriptor->CommandQueueing &&
fdoExtension->AdapterDescriptor->CommandQueueing) {
SET_FLAG(fdoExtension->SrbFlags, SRB_FLAGS_QUEUE_ACTION_ENABLE);
}
//
// Look for controllers that require special flags.
//
ClassScanForSpecial(fdoExtension, DiskBadControllers, DiskSetSpecialHacks);
//
// Clear buffer for drive geometry.
//
RtlZeroMemory(&(fdoExtension->DiskGeometry),
sizeof(DISK_GEOMETRY));
//
// Allocate request sense buffer.
//
fdoExtension->SenseData = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
SENSE_BUFFER_SIZE_EX,
DISK_TAG_START);
if (fdoExtension->SenseData == NULL) {
//
// The buffer can not be allocated.
//
TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP, "DiskInitFdo: Can not allocate request sense buffer\n"));
status = STATUS_INSUFFICIENT_RESOURCES;
return status;
}
//
// Set the buffer size of SenseData
//
fdoExtension->SenseDataLength = SENSE_BUFFER_SIZE_EX;
//
// Physical device object will describe the entire
// device, starting at byte offset 0.
//
fdoExtension->CommonExtension.StartingOffset.QuadPart = (LONGLONG)(0);
//
// Set timeout value in seconds.
//
if ( (fdoExtension->MiniportDescriptor != NULL) &&
(fdoExtension->MiniportDescriptor->IoTimeoutValue > 0) ) {
//
// use the value set by Storport miniport driver
//
fdoExtension->TimeOutValue = fdoExtension->MiniportDescriptor->IoTimeoutValue;
} else {
//
// get timeout value from registry
//
timeOut = ClassQueryTimeOutRegistryValue(Fdo);
if (timeOut) {
fdoExtension->TimeOutValue = timeOut;
} else {
fdoExtension->TimeOutValue = SCSI_DISK_TIMEOUT;
}
}
//
// If this is a removable drive, build an entry in devicemap\scsi
// indicating it's physicaldriveN name, set up the appropriate
// update partitions routine and set the flags correctly.
// note: only do this after the timeout value is set, above.
//
if (TEST_FLAG(Fdo->Characteristics, FILE_REMOVABLE_MEDIA)) {
ClassUpdateInformationInRegistry( Fdo,
"PhysicalDrive",
fdoExtension->DeviceNumber,
NULL,
0);
//
// Enable media change notification for removable disks
//
ClassInitializeMediaChangeDetection(fdoExtension,
(PUCHAR)"Disk");
} else {
SET_FLAG(fdoExtension->DeviceFlags, DEV_SAFE_START_UNIT);
SET_FLAG(fdoExtension->SrbFlags, SRB_FLAGS_NO_QUEUE_FREEZE);
}
//
// The commands we send during the init could cause the flags to change
// in case of any error. Save the SRB flags locally and restore it at
// the end of this function, so that the class driver can get it.
//
srbFlags = fdoExtension->SrbFlags;
//
// Read the drive capacity. Don't use the disk version of the routine here
// since we don't know the disk signature yet - the disk version will
// attempt to determine the BIOS reported geometry.
//
(VOID)ClassReadDriveCapacity(Fdo);
//
// Set up sector size fields.
//
// Stack variables will be used to update
// the partition device extensions.
//
// The device extension field SectorShift is
// used to calculate sectors in I/O transfers.
//
// The DiskGeometry structure is used to service
// IOCTls used by the format utility.
//
bytesPerSector = fdoExtension->DiskGeometry.BytesPerSector;
//
// Make sure sector size is not zero.
//
if (bytesPerSector == 0) {
//
// Default sector size for disk is 512.
//
bytesPerSector = fdoExtension->DiskGeometry.BytesPerSector = 512;
fdoExtension->SectorShift = 9;
}
//
// Determine is DM Driver is loaded on an IDE drive that is
// under control of Atapi - this could be either a crashdump or
// an Atapi device is sharing the controller with an IDE disk.
//
HalExamineMBR(fdoExtension->CommonExtension.DeviceObject,
fdoExtension->DiskGeometry.BytesPerSector,
(ULONG)0x54,
&dmSkew);
if (dmSkew) {
//
// Update the device extension, so that the call to IoReadPartitionTable
// will get the correct information. Any I/O to this disk will have
// to be skewed by *dmSkew sectors aka DMByteSkew.
//
fdoExtension->DMSkew = *dmSkew;
fdoExtension->DMActive = TRUE;
fdoExtension->DMByteSkew = fdoExtension->DMSkew * bytesPerSector;
FREE_POOL(dmSkew);
}
#if defined(_X86_) || defined(_AMD64_)
//
// Try to read the signature off the disk and determine the correct drive
// geometry based on that. This requires rereading the disk size to get
// the cylinder count updated correctly.
//
if(!TEST_FLAG(Fdo->Characteristics, FILE_REMOVABLE_MEDIA)) {
DiskReadSignature(Fdo);
DiskReadDriveCapacity(Fdo);
if (diskData->GeometrySource == DiskGeometryUnknown)
{
//
// Neither the BIOS nor the port driver could provide us with a reliable
// geometry. Before we use the default, look to see if it was partitioned
// under Windows NT4 [or earlier] and apply the one that was used back then
//
if (DiskIsNT4Geometry(fdoExtension))
{
diskData->RealGeometry = fdoExtension->DiskGeometry;
diskData->RealGeometry.SectorsPerTrack = 0x20;
diskData->RealGeometry.TracksPerCylinder = 0x40;
fdoExtension->DiskGeometry = diskData->RealGeometry;
diskData->GeometrySource = DiskGeometryFromNT4;
}
}
}
#endif
DiskCreateSymbolicLinks(Fdo);
//
// Get the SCSI address if it's available for use with SMART ioctls.
// SMART ioctls are used for failure prediction, so we need to get
// the SCSI address before initializing failure prediction.
//
{
PIRP irp;
KEVENT event;
IO_STATUS_BLOCK statusBlock = { 0 };
KeInitializeEvent(&event, SynchronizationEvent, FALSE);
irp = IoBuildDeviceIoControlRequest(IOCTL_SCSI_GET_ADDRESS,
fdoExtension->CommonExtension.LowerDeviceObject,
NULL,
0L,
&(diskData->ScsiAddress),
sizeof(SCSI_ADDRESS),
FALSE,
&event,
&statusBlock);
status = STATUS_UNSUCCESSFUL;
if(irp != NULL) {
status = IoCallDriver(fdoExtension->CommonExtension.LowerDeviceObject, irp);
if(status == STATUS_PENDING) {
KeWaitForSingleObject(&event,
Executive,
KernelMode,
FALSE,
NULL);
status = statusBlock.Status;
}
}
}
//
// Determine the type of disk and enable failure prediction in the hardware
// and enable failure prediction polling.
//
if (*InitSafeBootMode == 0)
{
DiskDetectFailurePrediction(fdoExtension,
&diskData->FailurePredictionCapability,
NT_SUCCESS(status));
if (diskData->FailurePredictionCapability != FailurePredictionNone)
{
//
// Cool, we've got some sort of failure prediction, enable it
// at the hardware and then enable polling for it
//
//
// By default we allow performance to be degradeded if failure
// prediction is enabled.
//
diskData->AllowFPPerfHit = TRUE;
//
// Enable polling only after Atapi and SBP2 add support for the new
// SRB flag that indicates that the request should not reset the
// drive spin down idle timer.
//
status = DiskEnableDisableFailurePredictPolling(fdoExtension,
TRUE,
DISK_DEFAULT_FAILURE_POLLING_PERIOD);
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP, "DiskInitFdo: Failure Prediction Poll enabled as "
"%d for device %p, Status = %lx\n",
diskData->FailurePredictionCapability,
Fdo,
status));
}
} else {
//
// In safe boot mode we do not enable failure prediction, as perhaps
// it is the reason why normal boot does not work
//
diskData->FailurePredictionCapability = FailurePredictionNone;
}
//
// Initialize the verify mutex
//
KeInitializeMutex(&diskData->VerifyMutex, MAX_SECTORS_PER_VERIFY);
//
// Initialize the flush group context
//
RtlZeroMemory(&diskData->FlushContext, sizeof(DISK_GROUP_CONTEXT));
InitializeListHead(&diskData->FlushContext.CurrList);
InitializeListHead(&diskData->FlushContext.NextList);
KeInitializeSpinLock(&diskData->FlushContext.Spinlock);
KeInitializeEvent(&diskData->FlushContext.Event, SynchronizationEvent, FALSE);
//
// Restore the saved value
//
fdoExtension->SrbFlags = srbFlags;
return STATUS_SUCCESS;
} // end DiskInitFdo()
NTSTATUS
NTAPI
DiskInitFdo(
IN PDEVICE_OBJECT Fdo
)
/*++
Routine Description:
This routine is called to do one-time initialization of new device objects
Arguments:
Fdo - a pointer to the functional device object for this device
Return Value:
status
--*/
{
PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
PDISK_DATA diskData = (PDISK_DATA) fdoExtension->CommonExtension.DriverData;
//ULONG srbFlags = 0;
ULONG timeOut = 0;
ULONG bytesPerSector;
//UCHAR sectorShift;
//BOOLEAN dmActive = FALSE;
PULONG dmSkew;
//ULONG dmByteSkew;
NTSTATUS status;
PAGED_CODE();
//
// Build the lookaside list for srb's for the physical disk. Should only
// need a couple. If this fails then we don't have an emergency SRB so
// fail the call to initialize.
//
ClassInitializeSrbLookasideList((PCOMMON_DEVICE_EXTENSION) fdoExtension,
PARTITION0_LIST_SIZE);
//
// Because all requests share a common sense buffer, it is possible
// for the buffer to be overwritten if the port driver completes
// multiple failed requests that require a request sense before the
// class driver's completion routine can consume the data in the buffer.
// To prevent this, we allow the port driver to allocate a unique sense
// buffer each time it needs one. We are responsible for freeing this
// buffer. This also allows the adapter to be configured to support
// additional sense data beyond the minimum 18 bytes.
//
fdoExtension->SrbFlags = SRB_FLAGS_PORT_DRIVER_ALLOCSENSE;
//
// Initialize the srb flags.
//
if (fdoExtension->DeviceDescriptor->CommandQueueing &&
fdoExtension->AdapterDescriptor->CommandQueueing) {
fdoExtension->SrbFlags = SRB_FLAGS_QUEUE_ACTION_ENABLE;
}
if (!TEST_FLAG(Fdo->Characteristics, FILE_REMOVABLE_MEDIA)) {
SET_FLAG(fdoExtension->DeviceFlags, DEV_SAFE_START_UNIT);
}
//
// Look for controllers that require special flags.
//
ClassScanForSpecial(fdoExtension, DiskBadControllers, DiskSetSpecialHacks);
//
// Look into the registry to see if this device
// requires special attention - [ like a hack ]
//
DiskScanRegistryForSpecial(fdoExtension);
//srbFlags = fdoExtension->SrbFlags;
//
// Clear buffer for drive geometry.
//
RtlZeroMemory(&(fdoExtension->DiskGeometry),
sizeof(DISK_GEOMETRY));
//
// Allocate request sense buffer.
//
fdoExtension->SenseData = ExAllocatePoolWithTag(NonPagedPoolCacheAligned,
SENSE_BUFFER_SIZE,
DISK_TAG_START);
if (fdoExtension->SenseData == NULL) {
//
// The buffer can not be allocated.
//
DebugPrint((1, "DiskInitFdo: Can not allocate request sense buffer\n"));
status = STATUS_INSUFFICIENT_RESOURCES;
return status;
}
//
// Physical device object will describe the entire
// device, starting at byte offset 0.
//
fdoExtension->CommonExtension.StartingOffset.QuadPart = (LONGLONG)(0);
//
// Set timeout value in seconds.
//
timeOut = ClassQueryTimeOutRegistryValue(Fdo);
if (timeOut) {
fdoExtension->TimeOutValue = timeOut;
} else {
fdoExtension->TimeOutValue = SCSI_DISK_TIMEOUT;
}
//
// If this is a removable drive, build an entry in devicemap\scsi
// indicating it's physicaldriveN name, set up the appropriate
// update partitions routine and set the flags correctly.
// note: only do this after the timeout value is set, above.
//
if (fdoExtension->DeviceDescriptor->RemovableMedia) {
ClassUpdateInformationInRegistry( Fdo,
"PhysicalDrive",
fdoExtension->DeviceNumber,
NULL,
0);
//
// Enable media change notification for removable disks
//
ClassInitializeMediaChangeDetection(fdoExtension,
"Disk");
SET_FLAG(Fdo->Characteristics, FILE_REMOVABLE_MEDIA);
diskData->UpdatePartitionRoutine = DiskUpdateRemovablePartitions;
} else {
SET_FLAG(fdoExtension->SrbFlags, SRB_FLAGS_NO_QUEUE_FREEZE);
diskData->UpdatePartitionRoutine = DiskUpdatePartitions;
}
//
// Read the drive capacity. Don't use the disk version of the routine here
// since we don't know the disk signature yet - the disk version will
// attempt to determine the BIOS reported geometry.
//
status = ClassReadDriveCapacity(Fdo);
//
// If the read capcity failed then just return, unless this is a
// removable disk where a device object partition needs to be created.
//
if (!NT_SUCCESS(status) &&
!(Fdo->Characteristics & FILE_REMOVABLE_MEDIA)) {
DebugPrint((1,
"DiskInitFdo: Can't read capacity for device %p\n",
Fdo));
if (fdoExtension->DeviceDescriptor->RemovableMedia) {
fdoExtension->DiskGeometry.MediaType = RemovableMedia;
Fdo->Flags &= ~DO_VERIFY_VOLUME;
} else {
fdoExtension->DiskGeometry.MediaType = FixedMedia;
}
status = STATUS_SUCCESS;
}
//
// Set up sector size fields.
//
// Stack variables will be used to update
// the partition device extensions.
//
// The device extension field SectorShift is
// used to calculate sectors in I/O transfers.
//
// The DiskGeometry structure is used to service
// IOCTls used by the format utility.
//
bytesPerSector = fdoExtension->DiskGeometry.BytesPerSector;
//
// Make sure sector size is not zero.
//
if (bytesPerSector == 0) {
//
// Default sector size for disk is 512.
//
bytesPerSector = fdoExtension->DiskGeometry.BytesPerSector = 512;
}
//sectorShift = fdoExtension->SectorShift;
//
// Determine is DM Driver is loaded on an IDE drive that is
// under control of Atapi - this could be either a crashdump or
// an Atapi device is sharing the controller with an IDE disk.
//
HalExamineMBR(fdoExtension->CommonExtension.DeviceObject,
fdoExtension->DiskGeometry.BytesPerSector,
(ULONG)0x54,
(PVOID*)&dmSkew);
if (dmSkew) {
//
// Update the device extension, so that the call to IoReadPartitionTable
// will get the correct information. Any I/O to this disk will have
// to be skewed by *dmSkew sectors aka DMByteSkew.
//
fdoExtension->DMSkew = *dmSkew;
fdoExtension->DMActive = TRUE;
fdoExtension->DMByteSkew = fdoExtension->DMSkew * bytesPerSector;
//
// Save away the infomation that we need, since this deviceExtension will soon be
// blown away.
//
//dmActive = TRUE;
//dmByteSkew = fdoExtension->DMByteSkew;
}
#if defined(_X86_)
//
// Try to read the signature off the disk and determine the correct drive
// geometry based on that. This requires rereading the disk size to get
// the cylinder count updated correctly.
//
if(fdoExtension->DeviceDescriptor->RemovableMedia == FALSE) {
DiskReadSignature(Fdo);
DiskReadDriveCapacity(Fdo);
}
#endif
//
// Register interfaces for this device
//
{
UNICODE_STRING interfaceName;
RtlInitUnicodeString(&interfaceName, NULL);
status = IoRegisterDeviceInterface(fdoExtension->LowerPdo,
(LPGUID) &DiskClassGuid,
NULL,
&interfaceName);
if(NT_SUCCESS(status)) {
diskData->DiskInterfaceString = interfaceName;
status = IoSetDeviceInterfaceState(&interfaceName, TRUE);
} else {
interfaceName.Buffer = NULL;
}
if(!NT_SUCCESS(status)) {
DebugPrint((1, "DiskInitFdo: Unable to register or set disk DCA "
"for fdo %p [%lx]\n", Fdo, status));
RtlFreeUnicodeString(&interfaceName);
RtlInitUnicodeString(&(diskData->DiskInterfaceString), NULL);
}
}
DiskCreateSymbolicLinks(Fdo);
//
// Determine the type of disk and enable failure preiction in the hardware
// and enable failure prediction polling.
//
if (InitSafeBootMode == 0)
{
DiskDetectFailurePrediction(fdoExtension,
&diskData->FailurePredictionCapability);
if (diskData->FailurePredictionCapability != FailurePredictionNone)
{
//
// Cool, we've got some sort of failure prediction, enable it
// at the hardware and then enable polling for it
//
//
// By default we allow performance to be degradeded if failure
// prediction is enabled.
//
// TODO: Make a registry entry ?
//
diskData->AllowFPPerfHit = TRUE;
//
// Enable polling only after Atapi and SBP2 add support for the new
// SRB flag that indicates that the request should not reset the
// drive spin down idle timer.
//
status = DiskEnableDisableFailurePredictPolling(fdoExtension,
TRUE,
DISK_DEFAULT_FAILURE_POLLING_PERIOD);
DebugPrint((3, "DiskInitFdo: Failure Prediction Poll enabled as "
"%d for device %p\n",
diskData->FailurePredictionCapability,
Fdo));
}
} else {
//
// In safe boot mode we do not enable failure prediction, as perhaps
// it is the reason why normal boot does not work
//
diskData->FailurePredictionCapability = FailurePredictionNone;
}
//
// Initialize the verify mutex
//
KeInitializeMutex(&diskData->VerifyMutex, MAX_SECTORS_PER_VERIFY);
return(STATUS_SUCCESS);
} // end DiskInitFdo()
