#include "ntddk.h"#include "scsi.h"#include <wmidata.h>#include "classpnp.h"#include <wmistr.h>#include "ntstrsafe.h"#include <storswtr.h>
Include dependency graph for disk.h:
This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Classes | |
| struct | _DISK_GROUP_CONTEXT |
| struct | _DISK_DATA |
| struct | _DISK_MEDIA_TYPES_LIST |
| struct | DISKREREGREQUEST |
| struct | _DISK_VERIFY_WORKITEM_CONTEXT |
Typedefs | |
| typedef struct _DISK_GROUP_CONTEXT | DISK_GROUP_CONTEXT |
| typedef struct _DISK_GROUP_CONTEXT * | PDISK_GROUP_CONTEXT |
| typedef enum _DISK_USER_WRITE_CACHE_SETTING | DISK_USER_WRITE_CACHE_SETTING |
| typedef enum _DISK_USER_WRITE_CACHE_SETTING * | PDISK_USER_WRITE_CACHE_SETTING |
| typedef struct _DISK_DATA | DISK_DATA |
| typedef struct _DISK_DATA * | PDISK_DATA |
| typedef struct _DISK_MEDIA_TYPES_LIST | DISK_MEDIA_TYPES_LIST |
| typedef struct _DISK_MEDIA_TYPES_LIST * | PDISK_MEDIA_TYPES_LIST |
| typedef struct DISKREREGREQUEST * | PDISKREREGREQUEST |
| typedef struct _DISK_VERIFY_WORKITEM_CONTEXT | DISK_VERIFY_WORKITEM_CONTEXT |
| typedef struct _DISK_VERIFY_WORKITEM_CONTEXT * | PDISK_VERIFY_WORKITEM_CONTEXT |
Enumerations | |
| enum | _DISK_USER_WRITE_CACHE_SETTING { DiskWriteCacheDisable = 0 , DiskWriteCacheEnable = 1 , DiskWriteCacheDefault = -1 } |
Variables | |
| CLASSPNP_SCAN_FOR_SPECIAL_INFO | DiskBadControllers [] |
| const DISK_MEDIA_TYPES_LIST | DiskMediaTypes [] |
| const DISK_MEDIA_TYPES_LIST | DiskMediaTypesExclude [] |
| DRIVER_INITIALIZE | DriverEntry |
| IO_WORKITEM_ROUTINE | DisableWriteCache |
| IO_WORKITEM_ROUTINE | DiskIoctlVerifyThread |
| IO_COMPLETION_ROUTINE | DiskFlushComplete |
| GUIDREGINFO | DiskWmiFdoGuidList [] |
Macro Definition Documentation
◆ CHECK_IRQL
| #define CHECK_IRQL | ( | ) |
Value:
◆ DEBUG_COMP_ID
| #define DEBUG_COMP_ID DPFLTR_DISK_ID |
◆ DISK_CACHE_MBR_CHECK
◆ DISK_DEFAULT_FAILURE_POLLING_PERIOD
◆ DISK_TAG_CCONTEXT
◆ DISK_TAG_DISABLE_CACHE
◆ DISK_TAG_DISK_GEOM
◆ DISK_TAG_GENERAL
◆ DISK_TAG_INFO_EXCEPTION
◆ DISK_TAG_MODE_DATA
◆ DISK_TAG_NAME
◆ DISK_TAG_PART_LIST
◆ DISK_TAG_PNP_ID
◆ DISK_TAG_READ_CAP
◆ DISK_TAG_SENSE_INFO
◆ DISK_TAG_SMART
◆ DISK_TAG_SRB
◆ DISK_TAG_START
◆ DISK_TAG_UPDATE_CAP
◆ DISK_TAG_UPDATE_GEOM
◆ DISK_TAG_WI_CONTEXT
◆ DiskDeviceCacheIsPowerProtected
| #define DiskDeviceCacheIsPowerProtected L"CacheIsPowerProtected" |
◆ DiskDeviceParameterSubkey
◆ DiskDeviceUserWriteCacheSetting
| #define DiskDeviceUserWriteCacheSetting L"UserWriteCacheSetting" |
◆ DiskGetDetectInfo
| #define DiskGetDetectInfo | ( | FdoExtension, | |
| DetectInfo | |||
| ) | (STATUS_UNSUCCESSFUL) |
◆ DiskHashGuid
◆ DiskIsValidSmartSelfTest
| #define DiskIsValidSmartSelfTest | ( | Subcommand | ) |
Value:
( ((Subcommand) == SMART_OFFLINE_ROUTINE_OFFLINE) || \
((Subcommand) == SMART_SHORT_SELFTEST_OFFLINE) || \
((Subcommand) == SMART_EXTENDED_SELFTEST_OFFLINE) )
◆ DiskReadDriveCapacity
| #define DiskReadDriveCapacity | ( | Fdo | ) | ClassReadDriveCapacity(Fdo) |
◆ FUNCTIONAL_EXTENSION_SIZE
| #define FUNCTIONAL_EXTENSION_SIZE sizeof(FUNCTIONAL_DEVICE_EXTENSION) + sizeof(DISK_DATA) |
◆ HackCauseNotReportableHack
◆ HackDisableSpinDown
◆ HackDisableSynchronousTransfers
◆ HackDisableTaggedQueuing
◆ HackDisableWriteCache
◆ HackRequiresStartUnitCommand
◆ MAX_MEDIA_TYPES
◆ MAX_SECTORS_PER_VERIFY
◆ MODE_DATA_SIZE
◆ ONE_MILLI_SECOND
◆ PARTITION0_LIST_SIZE
◆ SCSI_DISK_TIMEOUT
◆ VALUE_BUFFER_SIZE
◆ WPP_CONTROL_GUIDS
| #define WPP_CONTROL_GUIDS WPP_CONTROL_GUIDS_NORMAL_FLAGS(WPP_GUID_DISK) |
◆ WPP_GUID_DISK
| #define WPP_GUID_DISK (945186BF, 3DD6, 4f3f, 9C8E, 9EDD3FC9D558) |
Typedef Documentation
◆ DISK_DATA
| typedef struct _DISK_DATA DISK_DATA |
◆ DISK_GROUP_CONTEXT
◆ DISK_MEDIA_TYPES_LIST
◆ DISK_USER_WRITE_CACHE_SETTING
◆ DISK_VERIFY_WORKITEM_CONTEXT
◆ PDISK_DATA
| typedef struct _DISK_DATA * PDISK_DATA |
◆ PDISK_GROUP_CONTEXT
| typedef struct _DISK_GROUP_CONTEXT * PDISK_GROUP_CONTEXT |
◆ PDISK_MEDIA_TYPES_LIST
◆ PDISK_USER_WRITE_CACHE_SETTING
◆ PDISK_VERIFY_WORKITEM_CONTEXT
◆ PDISKREREGREQUEST
| typedef struct DISKREREGREQUEST * PDISKREREGREQUEST |
Enumeration Type Documentation
◆ _DISK_USER_WRITE_CACHE_SETTING
| Enumerator | |
|---|---|
| DiskWriteCacheDisable | |
| DiskWriteCacheEnable | |
| DiskWriteCacheDefault | |
Definition at line 177 of file disk.h.
178{
179 DiskWriteCacheDisable = 0,
180 DiskWriteCacheEnable = 1,
181 DiskWriteCacheDefault = -1
182
enum _DISK_USER_WRITE_CACHE_SETTING DISK_USER_WRITE_CACHE_SETTING
enum _DISK_USER_WRITE_CACHE_SETTING * PDISK_USER_WRITE_CACHE_SETTING
Function Documentation
◆ DiskAddDevice()
| NTSTATUS NTAPI DiskAddDevice | ( | IN PDRIVER_OBJECT | DriverObject, |
| IN PDEVICE_OBJECT | Pdo | ||
| ) |
Definition at line 53 of file pnp.c.
78{
80
81 PCONFIGURATION_INFORMATION configurationInformation;
82 ULONG diskCount;
83
85
86 PAGED_CODE();
87
88 //
89 // See if we should be allowing file systems to mount on partition zero.
90 //
91
92 TRY {
94
95 UNICODE_STRING diskKeyName;
96 OBJECT_ATTRIBUTES objectAttributes = {0};
97 HANDLE diskKey;
98
99 RTL_QUERY_REGISTRY_TABLE queryTable[2] = { 0 };
100
103 KEY_READ,
104 &deviceKey);
105
107 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP, "DiskAddDevice: Error %#08lx opening device key "
108 "for pdo %p\n",
110 LEAVE;
111 }
112
114 InitializeObjectAttributes(&objectAttributes,
115 &diskKeyName,
117 deviceKey,
118 NULL);
119
121 ZwClose(deviceKey);
122
125 "for pdo %p device key %p\n",
127 LEAVE;
128 }
129
132 queryTable[0].EntryContext = &(rootPartitionMountable);
134
135#ifdef _MSC_VER
136#pragma prefast(suppress:6309, "We don't have QueryRoutine so Context doesn't make any sense")
137#endif
139 diskKey,
140 queryTable,
141 NULL,
142 NULL);
143
145 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP, "DiskAddDevice: Error %#08lx reading value from "
146 "disk key %p for pdo %p\n",
148 }
149
150 ZwClose(diskKey);
151
152 } FINALLY {
153
154 //
155 // Do nothing.
156 //
157
159 TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_PNP, "DiskAddDevice: Will %sallow file system to mount on "
160 "partition zero of disk %p\n",
161 (rootPartitionMountable ? "" : "not "),
162 PhysicalDeviceObject));
163 }
164 }
165
166 //
167 // Create device objects for disk
168 //
169
170 diskCount = 0;
171
173 DriverObject,
174 PhysicalDeviceObject,
175 &diskCount,
176 (BOOLEAN) !rootPartitionMountable
177 );
178
179 //
180 // Get the number of disks already initialized.
181 //
182
183 configurationInformation = IoGetConfigurationInformation();
184
186
187 //
188 // Increment system disk device count.
189 //
190
191 configurationInformation->DiskCount++;
192
193 }
194
196
197} // end DiskAddDevice()
NTSTATUS DiskCreateFdo(IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT PhysicalDeviceObject, IN PULONG DeviceCount, IN BOOLEAN DasdAccessOnly)
Definition: disk.c:307
NTSYSAPI NTSTATUS WINAPI RtlQueryRegistryValues(ULONG, PCWSTR, PRTL_QUERY_REGISTRY_TABLE, PVOID, PVOID)
Definition: nsiface.idl:2307
PCONFIGURATION_INFORMATION NTAPI IoGetConfigurationInformation(VOID)
Returns a pointer to the I/O manager's global configuration information structure.
Definition: iorsrce.c:998
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
NTSTATUS NTAPI IoOpenDeviceRegistryKey(IN PDEVICE_OBJECT DeviceObject, IN ULONG DevInstKeyType, IN ACCESS_MASK DesiredAccess, OUT PHANDLE DevInstRegKey)
Definition: pnpmgr.c:1621
Definition: iotypes.h:4474
Definition: umtypes.h:182
Definition: nt_native.h:108
Definition: env_spec_w32.h:368
#define TRY(sps, bps)
#define RTL_QUERY_REGISTRY_TYPECHECK
#define RTL_QUERY_REGISTRY_TYPECHECK_SHIFT
Referenced by DriverEntry().
◆ DiskCreateFdo()
| NTSTATUS DiskCreateFdo | ( | IN PDRIVER_OBJECT | DriverObject, |
| IN PDEVICE_OBJECT | LowerDeviceObject, | ||
| IN PULONG | DeviceCount, | ||
| IN BOOLEAN | DasdAccessOnly | ||
| ) |
Definition at line 307 of file disk.c.
340{
341 PCCHAR deviceName = NULL;
345 PFUNCTIONAL_DEVICE_EXTENSION fdoExtension;
347
348 PAGED_CODE();
349
350 *DeviceCount = 0;
351
352 //
353 // Set up an object directory to contain the objects for this
354 // device and all its partitions.
355 //
356
357 do {
358
359 WCHAR dirBuffer[64] = { 0 };
360 UNICODE_STRING dirName;
361 OBJECT_ATTRIBUTES objectAttribs;
362
363 status = RtlStringCchPrintfW(dirBuffer, sizeof(dirBuffer) / sizeof(dirBuffer[0]) - 1, L"\\Device\\Harddisk%d", *DeviceCount);
365 TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_PNP, "DiskCreateFdo: Format symbolic link failed with error: 0x%X\n", status));
367 }
368
369 RtlInitUnicodeString(&dirName, dirBuffer);
370
371 InitializeObjectAttributes(&objectAttribs,
372 &dirName,
374 NULL,
375 NULL);
376
378 DIRECTORY_ALL_ACCESS,
379 &objectAttribs);
380
381 (*DeviceCount)++;
382
385
387
388 TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_PNP, "DiskCreateFdo: Could not create directory - %lx\n", status));
389
391 }
392
393 //
394 // When this loop exits the count is inflated by one - fix that.
395 //
396
397 (*DeviceCount)--;
398
399 //
400 // Claim the device.
401 //
402
404
406
410 ObDereferenceObject(lowerDevice);
412 }
413
414 //
415 // Create a device object for this device. Each physical disk will
416 // have at least one device object. The required device object
417 // describes the entire device. Its directory path is
418 // \Device\HarddiskN\Partition0, where N = device number.
419 //
420
422
424 TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_PNP, "DiskCreateFdo - couldn't create name %lx\n", status));
425
426 goto DiskCreateFdoExit;
427
428 }
429
431 deviceName,
432 PhysicalDeviceObject,
433 TRUE,
434 &deviceObject);
435
437 TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_PNP, "DiskCreateFdo: Can not create device object %s\n", deviceName));
438 goto DiskCreateFdoExit;
439 }
440
441 FREE_POOL(deviceName);
442
443 //
444 // Indicate that IRPs should include MDLs for data transfers.
445 //
446
448
449 fdoExtension = deviceObject->DeviceExtension;
450
451 if(DasdAccessOnly) {
452
453 //
454 // Inidicate that only RAW should be allowed to mount on the root
455 // partition object. This ensures that a file system can't doubly
456 // mount on a super-floppy by mounting once on P0 and once on P1.
457 //
458
459#ifdef _MSC_VER
460#pragma prefast(suppress:28175);
461#endif
463 }
464
465 //
466 // Initialize lock count to zero. The lock count is used to
467 // disable the ejection mechanism on devices that support
468 // removable media. Only the lock count in the physical
469 // device extension is used.
470 //
471
472 fdoExtension->LockCount = 0;
473
474 //
475 // Save system disk number.
476 //
477
479
480 //
481 // Set the alignment requirements for the device based on the
482 // host adapter requirements
483 //
484
487 }
488
489 //
490 // Finally, attach to the pdo
491 //
492
494
497
498
500
501 //
502 // Uh - oh, we couldn't attach
503 // cleanup and return
504 //
505
507 goto DiskCreateFdoExit;
508 }
509
510 //
511 // Clear the init flag.
512 //
513
515
516 //
517 // Store a handle to the device object directory for this disk
518 //
519
521
522 ObDereferenceObject(lowerDevice);
523
525
526DiskCreateFdoExit:
527
529 {
531 }
532
533 FREE_POOL(deviceName);
534
535 ObDereferenceObject(lowerDevice);
536
539
541}
NTSTATUS DiskGenerateDeviceName(IN ULONG DeviceNumber, OUT PCCHAR *RawName)
Definition: pnp.c:612
NTSYSAPI NTSTATUS NTAPI ZwMakeTemporaryObject(_In_ HANDLE Handle)
NTSYSAPI NTSTATUS NTAPI ZwCreateDirectoryObject(_Out_ PHANDLE DirectoryHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes)
PDEVICE_OBJECT NTAPI IoAttachDeviceToDeviceStack(IN PDEVICE_OBJECT SourceDevice, IN PDEVICE_OBJECT TargetDevice)
Definition: device.c:966
PDEVICE_OBJECT NTAPI IoGetAttachedDeviceReference(PDEVICE_OBJECT DeviceObject)
Definition: device.c:1406
NTSTRSAFEVAPI RtlStringCchPrintfW(_Out_writes_(cchDest) _Always_(_Post_z_) NTSTRSAFE_PWSTR pszDest, _In_ size_t cchDest, _In_ _Printf_format_string_ NTSTRSAFE_PCWSTR pszFormat,...)
Definition: ntstrsafe.h:1110
PDEVICE_OBJECT LowerDeviceObject
Definition: classpnp.h:598
Definition: env_spec_w32.h:413
Definition: classpnp.h:867
COMMON_DEVICE_EXTENSION CommonExtension
Definition: classpnp.h:873
Definition: rpc_generic.c:61
Referenced by DiskAddDevice().
◆ DiskCreateSymbolicLinks()
| VOID DiskCreateSymbolicLinks | ( | IN PDEVICE_OBJECT | DeviceObject | ) |
Definition at line 676 of file pnp.c.
702{
705
706 WCHAR wideSourceName[64] = { 0 };
707 UNICODE_STRING unicodeSourceName;
708
710
711 PAGED_CODE();
712
713 //
714 // Build the destination for the link first using the device name
715 // stored in the device object
716 //
717
719
721 //
722 // Put together the source name using the partition and device number
723 // in the device extension and disk data segment
724 //
725
726 status = RtlStringCchPrintfW(wideSourceName, sizeof(wideSourceName) / sizeof(wideSourceName[0]) - 1,
728 commonExtension->PartitionZeroExtension->DeviceNumber);
729
731
732 RtlInitUnicodeString(&unicodeSourceName, wideSourceName);
733
734 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP, "DiskCreateSymbolicLink: Linking %wZ to %wZ\n",
735 &unicodeSourceName,
736 &commonExtension->DeviceName));
737
739 &commonExtension->DeviceName);
740
743 }
744 }
745 }
746
748
749 //
750 // Create a physical drive N link using the device number we saved
751 // away during AddDevice.
752 //
753
754 status = RtlStringCchPrintfW(wideSourceName, sizeof(wideSourceName) / sizeof(wideSourceName[0]) - 1,
756 commonExtension->PartitionZeroExtension->DeviceNumber);
758
759 RtlInitUnicodeString(&unicodeSourceName, wideSourceName);
760
761 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP, "DiskCreateSymbolicLink: Linking %wZ to %wZ\n",
762 &unicodeSourceName,
763 &(commonExtension->DeviceName)));
764
766 &(commonExtension->DeviceName));
767
770 }
771 }
772 }
773
774
775 return;
776}
NTSTATUS NTAPI IoCreateSymbolicLink(IN PUNICODE_STRING SymbolicLinkName, IN PUNICODE_STRING DeviceName)
Definition: symlink.c:23
Definition: pci.h:44
struct _FUNCTIONAL_DEVICE_EXTENSION * PartitionZeroExtension
Definition: classpnp.h:599
Definition: disk.h:185
struct _DISK_DATA::@1057 LinkStatus
Referenced by DiskInitFdo().
◆ DiskDeleteSymbolicLinks()
| VOID DiskDeleteSymbolicLinks | ( | IN PDEVICE_OBJECT | DeviceObject | ) |
Definition at line 780 of file pnp.c.
802{
805
806 WCHAR wideLinkName[64] = { 0 };
807 UNICODE_STRING unicodeLinkName;
809
810 PAGED_CODE();
811
813
816 commonExtension->PartitionZeroExtension->DeviceNumber);
818 RtlInitUnicodeString(&unicodeLinkName, wideLinkName);
819 IoDeleteSymbolicLink(&unicodeLinkName);
820 }
822 }
823
825
828 commonExtension->PartitionZeroExtension->DeviceNumber);
830 RtlInitUnicodeString(&unicodeLinkName, wideLinkName);
831 IoDeleteSymbolicLink(&unicodeLinkName);
832 }
834 }
835
836
837 return;
838}
NTSTATUS NTAPI IoDeleteSymbolicLink(IN PUNICODE_STRING SymbolicLinkName)
Definition: symlink.c:94
Referenced by DiskRemoveDevice().
◆ DiskDetectFailurePrediction()
| NTSTATUS DiskDetectFailurePrediction | ( | PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| PFAILURE_PREDICTION_METHOD | FailurePredictCapability, | ||
| BOOLEAN | ScsiAddressAvailable | ||
| ) |
Definition at line 2230 of file diskwmi.c.
2270{
2273 BOOLEAN supportFP;
2275 STORAGE_PREDICT_FAILURE checkFailure;
2276 STORAGE_FAILURE_PREDICT_STATUS diskSmartStatus;
2277
2278 PAGED_CODE();
2279
2280 //
2281 // Assume no failure predict mechanisms
2282 //
2283 *FailurePredictCapability = FailurePredictionNone;
2284
2285 //
2286 // See if this is an IDE drive that supports SMART. If so enable SMART
2287 // and then ensure that it suports the SMART READ STATUS command
2288 //
2289
2290 if (ScsiAddressAvailable)
2291 {
2293
2294 if (supportFP)
2295 {
2298 {
2299 *FailurePredictCapability = FailurePredictionSmart;
2301
2303 &diskSmartStatus);
2304
2306 FdoExtension->DeviceObject,
2308
2310 {
2311 *FailurePredictCapability = FailurePredictionNone;
2313 }
2314 }
2316 }
2317 }
2318 //
2319 // See if there is a a filter driver to intercept
2320 // IOCTL_STORAGE_PREDICT_FAILURE
2321 //
2323 &checkFailure);
2324
2325 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "Disk: Device %p %s IOCTL_STORAGE_FAILURE_PREDICT\n",
2326 FdoExtension->DeviceObject,
2328
2330 {
2331 *FailurePredictCapability = FailurePredictionIoctl;
2334 {
2335 checkFailure.PredictFailure = 512;
2336 ClassNotifyFailurePredicted(FdoExtension,
2337 (PUCHAR)&checkFailure,
2338 sizeof(checkFailure),
2340 0x11,
2344
2346 }
2348 }
2349
2350 //
2351 // Finally we assume it will not be a scsi smart drive. but
2352 // we'll also send off an asynchronous mode sense so that if
2353 // it is SMART we'll reregister the device object
2354 //
2355
2356 *FailurePredictCapability = FailurePredictionNone;
2357
2359
2361}
NTSTATUS DiskSendFailurePredictIoctl(PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, PSTORAGE_PREDICT_FAILURE checkFailure)
Definition: diskwmi.c:854
static NTSTATUS DiskEnableSmart(PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
Definition: diskwmi.c:271
NTSTATUS DiskInfoExceptionCheck(PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
Definition: diskwmi.c:1922
NTSTATUS DiskGetIdentifyInfo(PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, PBOOLEAN SupportSmart)
Definition: diskwmi.c:813
NTSTATUS DiskReadFailurePredictStatus(PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, PSTORAGE_FAILURE_PREDICT_STATUS DiskSmartStatus)
Definition: diskwmi.c:1251
struct _COMMON_DEVICE_EXTENSION * PCOMMON_DEVICE_EXTENSION
struct _DISK_DATA * PDISK_DATA
Definition: wmidata.h:6126
Definition: ntddstor.h:499
Referenced by DiskInitFdo().
◆ 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.
685{
688
692
693 PAGED_CODE();
694
695 //
696 // this should be checked prior to calling into this routine
697 // as we use the buffer as mediaTypes
698 //
699
702
703 //
704 // Determine if this device is removable or fixed.
705 //
706
708
709 //
710 // Fixed disk.
711 //
712
714 mediaTypes->MediaInfoCount = 1;
715
716 mediaInfo->DeviceSpecific.DiskInfo.Cylinders.QuadPart = fdoExtension->DiskGeometry.Cylinders.QuadPart;
718 mediaInfo->DeviceSpecific.DiskInfo.TracksPerCylinder = fdoExtension->DiskGeometry.TracksPerCylinder;
719 mediaInfo->DeviceSpecific.DiskInfo.SectorsPerTrack = fdoExtension->DiskGeometry.SectorsPerTrack;
722 mediaInfo->DeviceSpecific.DiskInfo.MediaCharacteristics = (MEDIA_CURRENTLY_MOUNTED | MEDIA_READ_WRITE);
723
725
727 MEDIA_WRITE_PROTECTED);
728 }
729
730 } else {
731
732 PCCHAR vendorId = (PCCHAR) fdoExtension->DeviceDescriptor + fdoExtension->DeviceDescriptor->VendorIdOffset;
733 PCCHAR productId = (PCCHAR) fdoExtension->DeviceDescriptor + fdoExtension->DeviceDescriptor->ProductIdOffset;
734 PCCHAR productRevision = (PCCHAR) fdoExtension->DeviceDescriptor + fdoExtension->DeviceDescriptor->ProductRevisionOffset;
736 ULONG currentMedia;
739 ULONG sizeNeeded;
740
741 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
742 "DiskDetermineMediaTypes: Vendor %s, Product %s\n",
743 vendorId,
744 productId));
745
746
747 //
748 // If there's an entry with such vendorId & ProductId in the DiskMediaTypesExclude list,
749 // this device shouldn't be looked up in the DiskMediaTypes list to determine a medium type.
750 // The exclude table allows to narrow down the set of devices described by the DiskMediaTypes
751 // list (e.g.: DiskMediaTypes says "all HP devices" and DiskMediaTypesExlclude says
752 // "except for HP RDX")
753 //
754
757
759 continue;
760 }
761
764 continue;
765 }
766
767 goto SkipTable;
768 }
769
770 //
771 // Run through the list until we find the entry with a NULL Vendor Id.
772 //
773
775
777
779 continue;
780 }
781
784 continue;
785 }
786
789 continue;
790 }
791
792 deviceMatched = TRUE;
793
795 mediaTypes->MediaInfoCount = mediaListEntry->NumberOfTypes;
796
797 //
798 // Ensure that buffer is large enough.
799 //
800
802 (mediaListEntry->NumberOfTypes *
804 );
805
807 sizeNeeded) {
808
809 //
810 // Buffer too small
811 //
812
815 }
816
818
819 mediaInfo->DeviceSpecific.RemovableDiskInfo.Cylinders.QuadPart = fdoExtension->DiskGeometry.Cylinders.QuadPart;
820 mediaInfo->DeviceSpecific.RemovableDiskInfo.TracksPerCylinder = fdoExtension->DiskGeometry.TracksPerCylinder;
821 mediaInfo->DeviceSpecific.RemovableDiskInfo.SectorsPerTrack = fdoExtension->DiskGeometry.SectorsPerTrack;
822 mediaInfo->DeviceSpecific.RemovableDiskInfo.BytesPerSector = fdoExtension->DiskGeometry.BytesPerSector;
824
825 //
826 // Set the type.
827 //
828
830
833 } else {
835 }
836
837 //
838 // Status will either be success, if media is present, or no media.
839 // It would be optimal to base from density code and medium type, but not all devices
840 // have values for these fields.
841 //
842
844
845 //
846 // The usage of MediumType and DensityCode is device specific, so this may need
847 // to be extended to further key off of product/vendor ids.
848 // Currently, the MO units are the only devices that return this information.
849 //
850
851 if (MediumType == 2) {
852 currentMedia = MO_5_WO;
853 } else if (MediumType == 3) {
854 currentMedia = MO_5_RW;
855
856 if (DensityCode == 0x87) {
857
858 //
859 // Indicate that the pinnacle 4.6 G media
860 // is present. Other density codes will default to normal
861 // RW MO media.
862 //
863
864 currentMedia = PINNACLE_APEX_5_RW;
865 }
866 } else {
867 currentMedia = 0;
868 }
869
870 if (currentMedia) {
871 if (mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaType == (STORAGE_MEDIA_TYPE)currentMedia) {
872 SET_FLAG(mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaCharacteristics, MEDIA_CURRENTLY_MOUNTED);
873 }
874
875 } else {
876 SET_FLAG(mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaCharacteristics, MEDIA_CURRENTLY_MOUNTED);
877 }
878 }
879
881 SET_FLAG(mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaCharacteristics, MEDIA_WRITE_PROTECTED);
882 }
883
884 //
885 // Advance to next entry.
886 //
887
888 mediaInfo++;
889 }
890 }
891
892SkipTable:
893
894 if (!deviceMatched) {
895
896 TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
897 "DiskDetermineMediaTypes: Unknown device. Vendor: %s Product: %s Revision: %s\n",
898 vendorId,
899 productId,
900 productRevision));
901 //
902 // Build an entry for unknown.
903 //
904
906 mediaTypes->MediaInfoCount = 1;
907
908 mediaInfo->DeviceSpecific.RemovableDiskInfo.Cylinders.QuadPart = fdoExtension->DiskGeometry.Cylinders.QuadPart;
910 mediaInfo->DeviceSpecific.RemovableDiskInfo.TracksPerCylinder = fdoExtension->DiskGeometry.TracksPerCylinder;
911 mediaInfo->DeviceSpecific.RemovableDiskInfo.SectorsPerTrack = fdoExtension->DiskGeometry.SectorsPerTrack;
912 mediaInfo->DeviceSpecific.RemovableDiskInfo.BytesPerSector = fdoExtension->DiskGeometry.BytesPerSector;
915
917
918 SET_FLAG(mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaCharacteristics, MEDIA_CURRENTLY_MOUNTED);
919 }
920
922
923 SET_FLAG(mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaCharacteristics, MEDIA_WRITE_PROTECTED);
924 }
925 }
926 }
927
928 Irp->IoStatus.Information =
931
933}
static PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(PIRP Irp)
Definition: Bus_PDO_EvalMethod.c:150
int strncmp(const char *String1, const char *String2, ACPI_SIZE Count)
Definition: utclib.c:534
enum _STORAGE_MEDIA_TYPE STORAGE_MEDIA_TYPE
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
struct _DEVICE_MEDIA_INFO DEVICE_MEDIA_INFO
Definition: ntddstor.h:458
struct _DEVICE_MEDIA_INFO::@3170::@3171 DiskInfo
union _DEVICE_MEDIA_INFO::@3170 DeviceSpecific
struct _DEVICE_MEDIA_INFO::@3170::@3172 RemovableDiskInfo
Definition: disk.h:416
PSTORAGE_DEVICE_DESCRIPTOR DeviceDescriptor
Definition: classpnp.h:876
Definition: ntddstor.h:493
Definition: Bus_PDO_EvalMethod.c:93
struct _IO_STACK_LOCATION::@1564::@1565 DeviceIoControl
union _IO_STACK_LOCATION::@1564 Parameters
Referenced by DiskIoctlGetMediaTypesEx().
◆ DiskDeviceControl()
◆ DiskEnableDisableFailurePrediction()
| NTSTATUS DiskEnableDisableFailurePrediction | ( | PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| BOOLEAN | Enable | ||
| ) |
Definition at line 1126 of file diskwmi.c.
1147{
1151
1152 PAGED_CODE();
1153
1155 {
1157 {
1159 {
1161 } else {
1163 }
1164
1167 }
1168
1169 break;
1170 }
1171
1174 {
1175 //
1176 // We assume that the drive is already setup properly for
1177 // failure prediction
1178 //
1180 break;
1181 }
1182
1183 default:
1184 {
1186 }
1187 }
1189}
static NTSTATUS DiskDisableSmart(PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
Definition: diskwmi.c:293
FAILURE_PREDICTION_METHOD FailurePredictionCapability
Definition: disk.h:331
Referenced by DiskEnableDisableFailurePredictPolling(), DiskFdoExecuteWmiMethod(), DiskIoctlEnableFailurePrediction(), and DiskWmiFunctionControl().
◆ DiskEnableDisableFailurePredictPolling()
| NTSTATUS DiskEnableDisableFailurePredictPolling | ( | PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| BOOLEAN | Enable, | ||
| ULONG | PollTimeInSeconds | ||
| ) |
Definition at line 1193 of file diskwmi.c.
1217{
1221
1222 PAGED_CODE();
1223
1225 {
1227 Enable);
1228 } else {
1230 }
1231
1233 {
1236 FailurePredictionNone,
1237 PollTimeInSeconds);
1238
1239 //
1240 // Even if this failed we do not want to disable FP on the
1241 // hardware. FP is only ever disabled on the hardware by
1242 // specific command of the user.
1243 //
1244 }
1245
1247}
NTSTATUS DiskEnableDisableFailurePrediction(PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, BOOLEAN Enable)
Definition: diskwmi.c:1126
Referenced by DiskFdoExecuteWmiMethod(), DiskInitFdo(), and DiskWmiFunctionControl().
◆ DiskEnableInfoExceptions()
| NTSTATUS DiskEnableInfoExceptions | ( | _In_ PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| _In_ BOOLEAN | Enable | ||
| ) |
Definition at line 979 of file diskwmi.c.
983{
986 PMODE_PARAMETER_HEADER modeData;
987 PMODE_INFO_EXCEPTIONS pageData;
988 MODE_INFO_EXCEPTIONS changeablePageData;
989 ULONG modeDataSize;
990
991 PAGED_CODE();
992
993 modeDataSize = MODE_DATA_SIZE;
994
995 modeData = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
996 modeDataSize,
997 DISK_TAG_INFO_EXCEPTION);
998
1000
1001 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_WMI, "DiskEnableInfoExceptions: Unable to allocate mode "
1002 "data buffer\n"));
1004 }
1005
1006 //
1007 // First see which data is actually changeable.
1008 //
1011 1, // Page Control = 1 indicates we want changeable values.
1012 modeData,
1013 &modeDataSize,
1014 (PVOID*)&pageData);
1015
1017 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "DiskEnableInfoExceptions: does NOT support SMART for device %p\n",
1018 FdoExtension->DeviceObject));
1019 FREE_POOL(modeData);
1021 }
1022
1023 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "DiskEnableInfoExceptions: DOES support SMART for device %p\n",
1024 FdoExtension->DeviceObject));
1025
1026 //
1027 // At the very least, the DEXCPT bit must be changeable.
1028 // If it's not, bail out now.
1029 //
1031 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "DiskEnableInfoExceptions: does NOT support DEXCPT bit for device %p\n",
1032 FdoExtension->DeviceObject));
1033 FREE_POOL(modeData);
1035 }
1036
1037 //
1038 // Cache away which values are changeable.
1039 //
1041
1042 //
1043 // Now get the current values.
1044 //
1047 0, // Page Control = 0 indicates we want current values.
1048 modeData,
1049 &modeDataSize,
1050 (PVOID*)&pageData);
1051
1053 //
1054 // At this point we know the device supports this mode page so
1055 // assert if something goes wrong here.
1056 //
1058 FREE_POOL(modeData);
1060 }
1061
1062 //
1063 // If the device is currently configured to not report any informational
1064 // exceptions and we cannot change the value of that field, there's
1065 // nothing to be done.
1066 //
1068 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "DiskEnableInfoExceptions: MRIE field is 0 and is not changeable for device %p\n",
1069 FdoExtension->DeviceObject));
1070 FREE_POOL(modeData);
1072 }
1073
1074 //
1075 // If the PERF bit is changeable, set it now.
1076 //
1079 }
1080
1081 //
1082 // If the MRIE field is changeable, set it to 4 so that informational
1083 // exceptions get reported with the "Recovered Error" sense key.
1084 //
1086 pageData->ReportMethod = 4;
1087 }
1088
1089 //
1090 // Finally, set the DEXCPT bit appropriately to enable/disable
1091 // informational exception reporting and send the Mode Select.
1092 //
1094
1096 (PCHAR)modeData,
1097 modeDataSize,
1098 pageData->PSBit);
1099
1100 //
1101 // Update the failure prediction state. Note that for this particular
1102 // mode FailurePredictionNone is used when it's not enabled.
1103 //
1108 } else {
1111 }
1112 }
1113
1114 FREE_POOL(modeData);
1115
1117}
NTSTATUS DiskGetModePage(_In_ PDEVICE_OBJECT Fdo, _In_ UCHAR PageMode, _In_ UCHAR PageControl, _In_ PMODE_PARAMETER_HEADER ModeData, _Inout_ PULONG ModeDataSize, _Out_ PVOID *PageData)
Definition: diskwmi.c:903
NTSTATUS NTAPI ClassModeSelect(_In_ PDEVICE_OBJECT Fdo, _In_reads_bytes_(Length) PCHAR ModeSelectBuffer, _In_ ULONG Length, _In_ BOOLEAN SavePages)
Definition: class.c:6873
Definition: scsi.h:3010
Definition: cdrw_hw.h:2504
Referenced by DiskIoctlEnableFailurePrediction().
◆ DiskFdoExecuteWmiMethod()
| NTSTATUS NTAPI DiskFdoExecuteWmiMethod | ( | IN PDEVICE_OBJECT | DeviceObject, |
| IN PIRP | Irp, | ||
| IN ULONG | GuidIndex, | ||
| IN ULONG | MethodId, | ||
| IN ULONG | InBufferSize, | ||
| IN ULONG | OutBufferSize, | ||
| IN PUCHAR | Buffer | ||
| ) |
Definition at line 3045 of file diskwmi.c.
3088{
3092 ULONG sizeNeeded = 0;
3094
3095 PAGED_CODE();
3096
3097 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "Disk: DiskExecuteWmiMethod, DeviceObject %p, Irp %p, Guid Id %d, MethodId %d\n"
3098 " InBufferSize %#x, OutBufferSize %#x, Buffer %p\n",
3101
3103 {
3105 {
3106
3108 FailurePredictionSmart) ||
3109 (diskData->FailurePredictionCapability ==
3110 FailurePredictionIoctl) ||
3111 (diskData->FailurePredictionCapability ==
3112 FailurePredictionSense));
3113
3114
3116 {
3117 //
3118 // void AllowPerformanceHit([in] boolean Allow)
3119 //
3121 {
3122 BOOLEAN allowPerfHit;
3123
3124 sizeNeeded = 0;
3126 {
3128
3131 {
3132 diskData->AllowFPPerfHit = allowPerfHit;
3134 FailurePredictionSense)
3135 {
3136 MODE_INFO_EXCEPTIONS modeInfo;
3137
3139 &modeInfo);
3141 {
3142 modeInfo.Perf = allowPerfHit ? 0 : 1;
3144 &modeInfo);
3145 }
3146 }
3147 else
3148 {
3150 }
3151 }
3152
3153 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "DiskFdoWmiExecuteMethod: AllowPerformanceHit %x for device %p --> %lx\n",
3154 allowPerfHit,
3155 fdoExtension->DeviceObject,
3156 status));
3157 } else {
3159 }
3160 break;
3161 }
3162
3163 //
3164 // void EnableDisableHardwareFailurePrediction([in] boolean Enable)
3165 //
3167 {
3169
3170 sizeNeeded = 0;
3172 {
3176 {
3177 //
3178 // If we are disabling we need to also disable
3179 // polling
3180 //
3182 fdoExtension,
3183 enable,
3184 0);
3185 }
3186
3188 fdoExtension,
3189 enable);
3190
3191 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "DiskFdoWmiExecuteMethod: EnableDisableHardwareFailurePrediction: %x for device %p --> %lx\n",
3192 enable,
3193 fdoExtension->DeviceObject,
3194 status));
3195 } else {
3197 }
3198 break;
3199 }
3200
3201 //
3202 // void EnableDisableFailurePredictionPolling(
3203 // [in] uint32 Period,
3204 // [in] boolean Enable)
3205 //
3207 {
3209 ULONG period;
3210
3211 sizeNeeded = 0;
3213 {
3217
3219 fdoExtension,
3220 enable,
3221 period);
3222
3223 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "DiskFdoWmiExecuteMethod: EnableDisableFailurePredictionPolling: %x %x for device %p --> %lx\n",
3224 enable,
3225 period,
3226 fdoExtension->DeviceObject,
3227 status));
3228 } else {
3230 }
3231 break;
3232 }
3233
3234 //
3235 // void GetFailurePredictionCapability([out] uint32 Capability)
3236 //
3238 {
3241 {
3244 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "DiskFdoWmiExecuteMethod: GetFailurePredictionCapability: %x for device %p --> %lx\n",
3246 fdoExtension->DeviceObject,
3247 status));
3248 } else {
3250 }
3251 break;
3252 }
3253
3254 //
3255 // void EnableOfflineDiags([out] boolean Success);
3256 //
3258 {
3261 {
3263 FailurePredictionSmart)
3264 {
3265 //
3266 // Initiate or resume offline diagnostics.
3267 // This may cause a loss of performance
3268 // to the disk, but mayincrease the amount
3269 // of disk checking.
3270 //
3272 0);
3273
3274 } else {
3276 }
3277
3279
3280 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "DiskFdoWmiExecuteMethod: EnableOfflineDiags for device %p --> %lx\n",
3281 fdoExtension->DeviceObject,
3282 status));
3283 } else {
3285 }
3286 break;
3287 }
3288
3289 //
3290 // void ReadLogSectors([in] uint8 LogAddress,
3291 // [in] uint8 SectorCount,
3292 // [out] uint32 Length,
3293 // [out, WmiSizeIs("Length")] uint8 LogSectors[]
3294 // );
3295 //
3297 {
3299 FailurePredictionSmart)
3300 {
3302 {
3303 PREAD_LOG_SECTORS_IN inParams;
3304 PREAD_LOG_SECTORS_OUT outParams;
3305 ULONG readSize;
3306
3310 LogSectors) + readSize;
3311
3313 {
3316 inParams->SectorCount,
3317 inParams->LogAddress,
3318 outParams->LogSectors);
3319
3321 {
3322 outParams->Length = readSize;
3323 } else {
3324 //
3325 // SMART command failure is
3326 // indicated by successful
3327 // execution, but no data returned
3328 //
3329 outParams->Length = 0;
3331 }
3332 } else {
3334 }
3335
3336 } else {
3338 }
3339 } else {
3341 }
3342 break;
3343 }
3344
3345 // void WriteLogSectors([in] uint8 LogAddress,
3346 // [in] uint8 SectorCount,
3347 // [in] uint32 Length,
3348 // [in, WmiSizeIs("Length")] uint8 LogSectors[],
3349 // [out] boolean Success
3350 // );
3352 {
3354 FailurePredictionSmart)
3355 {
3357 LogSectors))
3358 {
3359 PWRITE_LOG_SECTORS_IN inParams;
3360 PWRITE_LOG_SECTORS_OUT outParams;
3361 ULONG writeSize;
3362
3366 LogSectors) +
3367 writeSize))
3368 {
3370
3372 {
3375 inParams->SectorCount,
3376 inParams->LogAddress,
3377 inParams->LogSectors);
3378
3380 {
3382 } else {
3385 }
3386 } else {
3388 }
3389 } else {
3391 }
3392 } else {
3394 }
3395 } else {
3397 }
3398 break;
3399 }
3400
3401 // void ExecuteSelfTest([in] uint8 Subcommand,
3402 // [out,
3403 // Values{"0", "1", "2"},
3404 // ValueMap{"Successful Completion",
3405 // "Captive Mode Required",
3406 // "Unsuccessful Completion"}
3407 // ]
3408 // uint32 ReturnCode);
3410 {
3412 FailurePredictionSmart)
3413 {
3415 {
3418 {
3419 PEXECUTE_SELF_TEST_IN inParam;
3420 PEXECUTE_SELF_TEST_OUT outParam;
3421
3424
3426 {
3428 inParam->Subcommand);
3430 {
3431 //
3432 // Return self test executed
3433 // without a problem
3434 //
3435 outParam->ReturnCode = 0;
3436 } else {
3437 //
3438 // Return Self test execution
3439 // failed status
3440 //
3441 outParam->ReturnCode = 2;
3443 }
3444 } else {
3445 //
3446 // If self test subcommand requires
3447 // captive mode then return that
3448 // status
3449 //
3450 outParam->ReturnCode = 1;
3452 }
3453
3454 } else {
3456 }
3457
3458 } else {
3460 }
3461 } else {
3463 }
3464
3465 break;
3466 }
3467
3468 default :
3469 {
3470 sizeNeeded = 0;
3472 break;
3473 }
3474 }
3475
3476 break;
3477 }
3478
3485 {
3486 sizeNeeded = 0;
3488 break;
3489 }
3490
3491 default:
3492 {
3493 sizeNeeded = 0;
3495 }
3496 }
3497
3498 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "Disk: DiskExecuteMethod Device %p, Irp %p returns %lx\n",
3500
3502 Irp,
3503 status,
3504 sizeNeeded,
3505 IO_NO_INCREMENT);
3506
3508}
Definition: bufpool.h:45
enum FAILURE_PREDICTION_METHOD * PFAILURE_PREDICTION_METHOD
SCSIPORT_API NTSTATUS NTAPI ClassWmiCompleteRequest(_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp, _In_ NTSTATUS Status, _In_ ULONG BufferUsed, _In_ CCHAR PriorityBoost)
Definition: classwmi.c:1009
NTSTATUS DiskWriteSmartLog(IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN UCHAR SectorCount, IN UCHAR LogAddress, IN PUCHAR Buffer)
Definition: diskwmi.c:429
#define EnableDisableFailurePredictionPolling
Definition: diskwmi.c:146
#define EnableDisableHardwareFailurePrediction
Definition: diskwmi.c:145
static NTSTATUS DiskExecuteSmartDiagnostics(PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, UCHAR Subcommand)
Definition: diskwmi.c:359
NTSTATUS DiskEnableDisableFailurePredictPolling(PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, BOOLEAN Enable, ULONG PollTimeInSeconds)
Definition: diskwmi.c:1193
NTSTATUS DiskReadSmartLog(IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN UCHAR SectorCount, IN UCHAR LogAddress, OUT PUCHAR Buffer)
Definition: diskwmi.c:379
NTSTATUS DiskGetInfoExceptionInformation(IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN PMODE_INFO_EXCEPTIONS ReturnPageData)
Definition: disk.c:2896
NTSTATUS DiskSetInfoExceptionInformation(IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN PMODE_INFO_EXCEPTIONS PageData)
Definition: disk.c:2985
Definition: wmidata.h:6205
Definition: wmidata.h:6209
Definition: wmidata.h:6184
Definition: wmidata.h:6189
Definition: wmidata.h:6194
Definition: wmidata.h:6201
struct _EXECUTE_SELF_TEST_IN * PEXECUTE_SELF_TEST_IN
struct _WRITE_LOG_SECTORS_OUT WRITE_LOG_SECTORS_OUT
struct _WRITE_LOG_SECTORS_IN * PWRITE_LOG_SECTORS_IN
struct _READ_LOG_SECTORS_IN * PREAD_LOG_SECTORS_IN
struct _EXECUTE_SELF_TEST_OUT * PEXECUTE_SELF_TEST_OUT
struct _EXECUTE_SELF_TEST_OUT EXECUTE_SELF_TEST_OUT
struct _WRITE_LOG_SECTORS_OUT * PWRITE_LOG_SECTORS_OUT
struct _READ_LOG_SECTORS_OUT * PREAD_LOG_SECTORS_OUT
Referenced by DriverEntry().
◆ DiskFdoProcessError()
| VOID NTAPI DiskFdoProcessError | ( | PDEVICE_OBJECT | DeviceObject, |
| PSCSI_REQUEST_BLOCK | Srb, | ||
| NTSTATUS * | Status, | ||
| BOOLEAN * | Retry | ||
| ) |
Definition at line 2276 of file disk.c.
2306{
2308 PSTORAGE_REQUEST_BLOCK srbEx;
2310 UCHAR scsiStatus = 0;
2311 UCHAR senseBufferLength = 0;
2313 CDB noOp = {0};
2314
2315 //
2316 // Get relevant fields from SRB
2317 //
2319
2321
2322 //
2323 // Look for SCSI SRB specific fields
2324 //
2326 (srbEx->NumSrbExData > 0)) {
2328
2329 //
2330 // cdb and sense buffer should not be NULL
2331 //
2334
2335 }
2336
2338
2339 //
2340 // Use a cdb that is all 0s
2341 //
2342 cdb = &noOp;
2343 }
2344
2345 } else {
2346
2351 }
2352
2354 (cdb != NULL) &&
2356
2358
2359 //
2360 // Update the error count for the device.
2361 //
2362
2363 fdoExtension->ErrorCount++;
2364
2366 scsiStatus == SCSISTAT_BUSY) {
2367
2368 //
2369 // a disk drive should never be busy this long. Reset the scsi bus
2370 // maybe this will clear the condition.
2371 //
2372
2374
2375 //
2376 // Update the error count for the device.
2377 //
2378
2379 fdoExtension->ErrorCount++;
2380
2381 } else {
2382
2384
2385 //
2386 // See if this might indicate that something on the drive has changed.
2387 //
2388
2391
2394 UCHAR asc = 0;
2395 UCHAR ascq = 0;
2396
2397 validSense = ScsiGetSenseKeyAndCodes(senseBuffer,
2398 senseBufferLength,
2400 &senseKey,
2401 &asc,
2402 &ascq);
2403
2405
2407
2409
2410 switch (asc) {
2411
2413 {
2414 //
2415 // Look to see if this is an Io request with the ForceUnitAccess flag set
2416 //
2419 (cdb->CDB10.ForceUnitAccess))
2420 {
2422
2424 {
2426
2427 //
2428 // The user has explicitly requested that write caching be turned on.
2429 // Warn the user that writes with FUA enabled are not working and that
2430 // they should disable write cache.
2431 //
2432
2435
2437 {
2440 logEntry->SequenceNumber = 0;
2442 logEntry->IoControlCode = 0;
2443 logEntry->RetryCount = 0;
2444 logEntry->UniqueErrorValue = 0;
2446
2451
2452 //
2453 // Write the error log packet.
2454 //
2455
2456 IoWriteErrorLogEntry(logEntry);
2457 }
2458 }
2459 else
2460 {
2461 //
2462 // Turn off write caching on this device. This is so that future
2463 // critical requests need not be sent down with ForceUnitAccess
2464 //
2466
2467 if (workItem)
2468 {
2470 }
2471 }
2472
2474 ADJUST_FUA_FLAG(fdoExtension);
2475
2476
2479
2482
2483 //
2484 // Mode sense for all pages failed. This command could fail with
2485 // SCSI_SENSE_ILLEGAL_REQUEST / SCSI_ADSENSE_INVALID_CDB if the data
2486 // to be returned is more than 256 bytes. In which case, try to get
2487 // only MODE_PAGE_CACHING since we only need the block descriptor.
2488 //
2489 // Simply change the page code and retry the request
2490 //
2491
2494 }
2495
2496 break;
2497 }
2498 } // end switch(asc)
2499 break;
2500 }
2501
2503
2504 switch (asc) {
2506 switch (ascq) {
2510 invalidatePartitionTable = TRUE;
2511 break;
2512 }
2513 } // end switch(ascq)
2514 break;
2515 }
2516
2518 invalidatePartitionTable = TRUE;
2519 break;
2520 }
2521 } // end switch(asc)
2522 break;
2523 }
2524
2526 invalidatePartitionTable = TRUE;
2527 break;
2528 }
2529
2531 invalidatePartitionTable = TRUE;
2532 break;
2533 }
2534
2536 {
2537 invalidatePartitionTable = TRUE;
2538 break;
2539 }
2540
2542 invalidatePartitionTable = TRUE;
2543 break;
2544 }
2545
2546 } // end switch(senseKey)
2547 } // end if (validSense)
2548 } else {
2549
2550 //
2551 // On any exceptional scsi condition which might indicate that the
2552 // device was changed we will flush out the state of the partition
2553 // table.
2554 //
2555
2568 {
2569 invalidatePartitionTable = TRUE;
2570 break;
2571 }
2572
2574 {
2576 {
2577 invalidatePartitionTable = TRUE;
2578 }
2579
2580 break;
2581 }
2582 } // end switch(Srb->SrbStatus)
2583 }
2584
2586
2587 //
2588 // Inform the upper layers that the volume
2589 // on this disk is in need of verification
2590 //
2591
2593 }
2594 }
2595
2596 return;
2597}
#define SCSI_SENSEQ_MANUAL_INTERVENTION_REQUIRED
Definition: cdrw_hw.h:1315
union _CDB * PCDB
FORCEINLINE PCDB GetSrbScsiData(_In_ PSTORAGE_REQUEST_BLOCK SrbEx, _In_opt_ PUCHAR CdbLength8, _In_opt_ PULONG CdbLength32, _In_opt_ PUCHAR ScsiStatus, _In_opt_ PVOID *SenseInfoBuffer, _In_opt_ PUCHAR SenseInfoBufferLength)
Definition: disk.h:994
VOID NTAPI IoQueueWorkItem(IN PIO_WORKITEM IoWorkItem, IN PIO_WORKITEM_ROUTINE WorkerRoutine, IN WORK_QUEUE_TYPE QueueType, IN PVOID Context)
Definition: iowork.c:40
PIO_WORKITEM NTAPI IoAllocateWorkItem(IN PDEVICE_OBJECT DeviceObject)
Definition: iowork.c:75
PVOID NTAPI IoAllocateErrorLogEntry(IN PVOID IoObject, IN UCHAR EntrySize)
Definition: error.c:528
#define SCSI_SENSE_OPTIONS_FIXED_FORMAT_IF_UNKNOWN_FORMAT_INDICATED
Definition: scsi.h:3839
DISK_USER_WRITE_CACHE_SETTING WriteCacheOverride
Definition: disk.h:385
ULONG ScanForSpecialFlags
Definition: classpnp.h:925
Definition: iotypes.h:2000
Definition: io.h:311
Definition: cdrw_hw.h:28
struct _CDB::_CDB10 CDB10
struct _CDB::_CDB6FORMAT CDB6FORMAT
struct _CDB::_MODE_SENSE MODE_SENSE
#define IRP_MJ_SCSI
Referenced by DriverEntry().
◆ DiskFdoQueryWmiDataBlock()
| NTSTATUS NTAPI DiskFdoQueryWmiDataBlock | ( | IN PDEVICE_OBJECT | DeviceObject, |
| IN PIRP | Irp, | ||
| IN ULONG | GuidIndex, | ||
| IN ULONG | BufferAvail, | ||
| OUT PUCHAR | Buffer | ||
| ) |
Definition at line 2638 of file diskwmi.c.
2674{
2679 ULONG sizeNeeded;
2680
2681 PAGED_CODE();
2682
2683 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "Disk: DiskQueryWmiDataBlock, Device %p, Irp %p, GuiIndex %d\n"
2684 " BufferAvail %lx Buffer %p\n",
2687
2689 {
2691 {
2694 {
2696 {
2697 //
2698 // Issue ReadCapacity to update device extension
2699 // with information for current media.
2701
2702 //
2703 // Note whether the drive is ready.
2705
2707 {
2708 break;
2709 }
2710 }
2711
2712 //
2713 // Copy drive geometry information from device extension.
2715 &(fdoExtension->DiskGeometry),
2717
2719 } else {
2721 }
2722 break;
2723 }
2724
2726 {
2727 PSTORAGE_FAILURE_PREDICT_STATUS diskSmartStatus;
2728
2730
2733 {
2734 STORAGE_PREDICT_FAILURE checkFailure;
2735
2737
2739 &checkFailure);
2740
2742 {
2744 FailurePredictionSense)
2745 {
2747 } else {
2749 }
2750
2752 }
2753 } else {
2755 }
2756 break;
2757 }
2758
2760 {
2761 PSTORAGE_FAILURE_PREDICT_DATA diskSmartData;
2762
2764 FailurePredictionSmart) ||
2765 (diskData->FailurePredictionCapability ==
2766 FailurePredictionIoctl));
2767
2770 {
2772
2774
2776 checkFailure);
2777
2779 {
2780 diskSmartData->Length = 512;
2781 }
2782 } else {
2784 }
2785
2786 break;
2787 }
2788
2790 {
2791 PSTORAGE_FAILURE_PREDICT_THRESHOLDS diskSmartThresholds;
2792
2794 FailurePredictionSmart));
2795
2798 {
2801 diskSmartThresholds);
2802 } else {
2804 }
2805
2806 break;
2807 }
2808
2810 {
2811 sizeNeeded = 0;
2813 break;
2814 }
2815
2817 {
2818 PSTORAGE_SCSI_INFO_EXCEPTIONS infoExceptions;
2819 MODE_INFO_EXCEPTIONS modeInfo;
2820
2822 FailurePredictionSense));
2823
2826 {
2829 &modeInfo);
2831 {
2835 infoExceptions->Padding = 0;
2837 &modeInfo.IntervalTimer);
2839 &modeInfo.ReportCount)
2840 }
2841 } else {
2843 }
2844
2845 break;
2846 }
2847
2848 default:
2849 {
2850 sizeNeeded = 0;
2852 }
2853 }
2854 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "Disk: DiskQueryWmiDataBlock Device %p, Irp %p returns %lx\n",
2856
2858 Irp,
2859 status,
2860 sizeNeeded,
2861 IO_NO_INCREMENT);
2862
2864}
NTSTATUS DiskReadFailurePredictThresholds(PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, PSTORAGE_FAILURE_PREDICT_THRESHOLDS DiskSmartThresholds)
Definition: diskwmi.c:1417
struct _DISK_GEOMETRY DISK_GEOMETRY
struct _STORAGE_PREDICT_FAILURE * PSTORAGE_PREDICT_FAILURE
Definition: ntdddisk.h:404
Definition: wmidata.h:6131
Definition: wmidata.h:6213
struct _STORAGE_FAILURE_PREDICT_DATA * PSTORAGE_FAILURE_PREDICT_DATA
struct _STORAGE_FAILURE_PREDICT_STATUS * PSTORAGE_FAILURE_PREDICT_STATUS
struct _STORAGE_SCSI_INFO_EXCEPTIONS * PSTORAGE_SCSI_INFO_EXCEPTIONS
struct _STORAGE_FAILURE_PREDICT_THRESHOLDS STORAGE_FAILURE_PREDICT_THRESHOLDS
struct _STORAGE_FAILURE_PREDICT_STATUS STORAGE_FAILURE_PREDICT_STATUS
struct _STORAGE_FAILURE_PREDICT_THRESHOLDS * PSTORAGE_FAILURE_PREDICT_THRESHOLDS
struct _STORAGE_FAILURE_PREDICT_DATA STORAGE_FAILURE_PREDICT_DATA
struct _STORAGE_SCSI_INFO_EXCEPTIONS STORAGE_SCSI_INFO_EXCEPTIONS
Referenced by DriverEntry().
◆ DiskFdoQueryWmiRegInfo()
| NTSTATUS NTAPI DiskFdoQueryWmiRegInfo | ( | IN PDEVICE_OBJECT | DeviceObject, |
| OUT ULONG * | RegFlags, | ||
| OUT PUNICODE_STRING | InstanceName | ||
| ) |
Definition at line 2479 of file diskwmi.c.
2517{
2520
2521 PAGED_CODE();
2523
2526
2528 {
2530 {
2532 //
2533 // Fall Through
2534 //
2535 }
2537 {
2542
2543 break;
2544 }
2545
2547 {
2553 break;
2554 }
2555
2556
2557 default:
2558 {
2563 break;
2564 }
2565 }
2566
2567 //
2568 // Use devnode for FDOs
2570
2572}
_Must_inspect_result_ _Inout_ PFLT_VOLUME _In_opt_ PCUNICODE_STRING InstanceName
Definition: fltkernel.h:1163
Referenced by DiskFdoQueryWmiRegInfoEx(), and DriverEntry().
◆ DiskFdoQueryWmiRegInfoEx()
| NTSTATUS NTAPI DiskFdoQueryWmiRegInfoEx | ( | IN PDEVICE_OBJECT | DeviceObject, |
| OUT ULONG * | RegFlags, | ||
| OUT PUNICODE_STRING | InstanceName, | ||
| OUT PUNICODE_STRING | MofName | ||
| ) |
Definition at line 2577 of file diskwmi.c.
2620{
2622
2623 UNREFERENCED_PARAMETER(MofName);
2624
2626 RegFlags,
2627 InstanceName);
2628
2629 //
2630 // Leave MofName alone since disk doesn't have one
2631 //
2633}
NTSTATUS NTAPI DiskFdoQueryWmiRegInfo(IN PDEVICE_OBJECT DeviceObject, OUT ULONG *RegFlags, OUT PUNICODE_STRING InstanceName)
Definition: diskwmi.c:2479
Referenced by DriverEntry().
◆ DiskFdoSetWmiDataBlock()
| NTSTATUS NTAPI DiskFdoSetWmiDataBlock | ( | IN PDEVICE_OBJECT | DeviceObject, |
| IN PIRP | Irp, | ||
| IN ULONG | GuidIndex, | ||
| IN ULONG | BufferSize, | ||
| IN PUCHAR | Buffer | ||
| ) |
Definition at line 2869 of file diskwmi.c.
2904{
2909
2910 PAGED_CODE();
2911
2912 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "Disk: DiskSetWmiDataBlock, Device %p, Irp %p, GuiIndex %d\n"
2913 " BufferSize %#x Buffer %p\n",
2916
2918 {
2919 PSTORAGE_SCSI_INFO_EXCEPTIONS infoExceptions;
2920 MODE_INFO_EXCEPTIONS modeInfo = {0};
2921
2923 {
2925
2928
2929 modeInfo.PSBit = 0;
2931
2933
2935 &infoExceptions->IntervalTimer);
2936
2938 &infoExceptions->ReportCount);
2939
2941 {
2943 } else {
2945 }
2946
2948 &modeInfo);
2949 } else {
2951 }
2952
2954 {
2956 } else {
2958 }
2959
2960 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "Disk: DiskSetWmiDataBlock Device %p, Irp %p returns %lx\n",
2962
2964 Irp,
2965 status,
2966 0,
2967 IO_NO_INCREMENT);
2968
2970}
struct _MODE_INFO_EXCEPTIONS MODE_INFO_EXCEPTIONS
Referenced by DriverEntry().
◆ DiskFdoSetWmiDataItem()
| NTSTATUS NTAPI DiskFdoSetWmiDataItem | ( | IN PDEVICE_OBJECT | DeviceObject, |
| IN PIRP | Irp, | ||
| IN ULONG | GuidIndex, | ||
| IN ULONG | DataItemId, | ||
| IN ULONG | BufferSize, | ||
| IN PUCHAR | Buffer | ||
| ) |
Definition at line 2975 of file diskwmi.c.
3013{
3015
3016 PAGED_CODE();
3017
3018 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "Disk: DiskSetWmiDataItem, Device %p, Irp %p, GuiIndex %d, DataId %d\n"
3019 " BufferSize %#x Buffer %p\n",
3022
3024 {
3026 } else {
3028 }
3029
3030 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "Disk: DiskSetWmiDataItem Device %p, Irp %p returns %lx\n",
3032
3034 Irp,
3035 status,
3036 0,
3037 IO_NO_INCREMENT);
3038
3040}
Referenced by DriverEntry().
◆ DiskFlushDispatch()
| VOID DiskFlushDispatch | ( | IN PDEVICE_OBJECT | Fdo, |
| IN PDISK_GROUP_CONTEXT | FlushContext | ||
| ) |
Definition at line 1534 of file disk.c.
1558{
1560 PSCSI_REQUEST_BLOCK srb = &FlushContext->Srb.Srb;
1561 PSTORAGE_REQUEST_BLOCK srbEx = &FlushContext->Srb.SrbEx;
1563 PSTOR_ADDR_BTL8 storAddrBtl8;
1564 PSRBEX_DATA_SCSI_CDB16 srbExDataCdb16;
1566
1567 //
1568 // Fill in the srb fields appropriately
1569 //
1572
1574 srbEx->Function = SRB_FUNCTION_STORAGE_REQUEST_BLOCK;
1575 srbEx->Signature = SRB_SIGNATURE;
1576 srbEx->Version = STORAGE_REQUEST_BLOCK_VERSION_1;
1577 srbEx->SrbLength = sizeof(FlushContext->Srb.SrbExBuffer);
1578 srbEx->RequestPriority = IoGetIoPriorityHint(FlushContext->CurrIrp);
1580 srbEx->TimeOutValue = fdoExt->TimeOutValue * 4;
1581 srbEx->RequestTag = SP_UNTAGGED;
1582 srbEx->RequestAttribute = SRB_SIMPLE_TAG_REQUEST;
1583 srbEx->SrbFlags = fdoExt->SrbFlags;
1584
1585 //
1586 // Set up address fields
1587 //
1588
1590 storAddrBtl8->Type = STOR_ADDRESS_TYPE_BTL8;
1591 storAddrBtl8->AddressLength = STOR_ADDR_BTL8_ADDRESS_LENGTH;
1592
1593 } else {
1595
1601 }
1602
1603 //
1604 // If write caching is enabled then send down a synchronize cache request
1605 //
1607 {
1608
1610 srbEx->SrbFunction = SRB_FUNCTION_EXECUTE_SCSI;
1611 srbEx->NumSrbExData = 1;
1612
1613 //
1614 // Set up SCSI SRB extended data fields
1615 //
1616
1621 srbExDataCdb16->Type = SrbExDataTypeScsiCdb16;
1622 srbExDataCdb16->Length = SRBEX_DATA_SCSI_CDB16_LENGTH;
1623 srbExDataCdb16->CdbLength = 10;
1624 srbExDataCdb16->Cdb[0] = SCSIOP_SYNCHRONIZE_CACHE;
1625 } else {
1626 // Should not happen
1628 return;
1629 }
1630
1631 } else {
1633 srb->CdbLength = 10;
1635 }
1636
1638
1640 }
1641
1642 //
1643 // Set up a FLUSH SRB
1644 //
1646 srbEx->SrbFunction = SRB_FUNCTION_FLUSH;
1647 srbEx->NumSrbExData = 0;
1648 srbEx->SrbExDataOffset[0] = 0;
1649 srbEx->OriginalRequest = FlushContext->CurrIrp;
1650 srbEx->SrbStatus = 0;
1651
1652 //
1653 // Make sure that this srb does not get freed
1654 //
1656
1657 } else {
1659 srb->CdbLength = 0;
1660 srb->OriginalRequest = FlushContext->CurrIrp;
1661 srb->SrbStatus = 0;
1662 srb->ScsiStatus = 0;
1663
1664 //
1665 // Make sure that this srb does not get freed
1666 //
1668 }
1669
1670 //
1671 // Make sure that this request does not get retried
1672 //
1674
1676
1677 //
1678 // Fill in the irp fields appropriately
1679 //
1681
1683 irpSp->Parameters.Scsi.Srb = srb;
1684
1685 IoSetCompletionRoutine(FlushContext->CurrIrp, DiskFlushComplete, (PVOID)(ULONG_PTR)SyncCacheStatus, TRUE, TRUE, TRUE);
1686
1687 TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_SCSI, "DiskFlushDispatch: sending srb flush on irp %p\n", FlushContext->CurrIrp));
1688
1689 //
1690 // Send down the flush request
1691 //
1693}
NTSTATUS NTAPI ClassSendSrbSynchronous(_In_ PDEVICE_OBJECT Fdo, _Inout_ PSCSI_REQUEST_BLOCK _Srb, _In_reads_bytes_opt_(BufferLength) PVOID BufferAddress, _In_ ULONG BufferLength, _In_ BOOLEAN WriteToDevice)
Definition: class.c:4042
#define IoSetCompletionRoutine(_Irp, _CompletionRoutine, _Context, _InvokeOnSuccess, _InvokeOnError, _InvokeOnCancel)
Definition: irp.cpp:490
struct STOR_ADDRESS_ALIGN _STOR_ADDR_BTL8 * PSTOR_ADDR_BTL8
struct STOR_ADDRESS_ALIGN _STOR_ADDR_BTL8 STOR_ADDR_BTL8
struct SRB_ALIGN _SRBEX_DATA_SCSI_CDB16 SRBEX_DATA_SCSI_CDB16
struct SRB_ALIGN _SRBEX_DATA_SCSI_CDB16 * PSRBEX_DATA_SCSI_CDB16
PSTORAGE_ADAPTER_DESCRIPTOR AdapterDescriptor
Definition: classpnp.h:877
Definition: srb.h:248
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetNextIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2695
NTKRNLVISTAAPI IO_PRIORITY_HINT NTAPI IoGetIoPriorityHint(_In_ PIRP Irp)
Definition: io.c:123
Referenced by DiskShutdownFlush().
◆ DiskGenerateDeviceName()
Definition at line 612 of file pnp.c.
641{
642 CHAR rawName[64] = { 0 };
644
645 PAGED_CODE();
646
648 diskDeviceSequenceNumber++);
650 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP, "DiskGenerateDeviceName: Format FDO name failed with error: 0x%X\n", status));
652 }
653
655 strlen(rawName) + 1,
656 DISK_TAG_NAME);
657
660 }
661
664 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP, "DiskGenerateDeviceName: Device name copy failed with error: 0x%X\n", status));
665 FREE_POOL(*RawName);
667 }
668
669 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP, "DiskGenerateDeviceName: generated \"%s\"\n", rawName));
670
672}
#define FDO_NAME_FORMAT
NTSTRSAFEAPI RtlStringCchCopyA(_Out_writes_(cchDest) _Always_(_Post_z_) NTSTRSAFE_PSTR pszDest, _In_ size_t cchDest, _In_ NTSTRSAFE_PCSTR pszSrc)
Definition: ntstrsafe.h:110
NTSTRSAFEVAPI RtlStringCchPrintfA(_Out_writes_(cchDest) _Always_(_Post_z_) NTSTRSAFE_PSTR pszDest, _In_ size_t cchDest, _In_ _Printf_format_string_ NTSTRSAFE_PCSTR pszFormat,...)
Definition: ntstrsafe.h:1085
Referenced by DiskCreateFdo().
◆ DiskGetCacheInformation()
| NTSTATUS NTAPI DiskGetCacheInformation | ( | IN PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| IN PDISK_CACHE_INFORMATION | CacheInfo | ||
| ) |
Definition at line 3019 of file disk.c.
3044{
3045 PMODE_PARAMETER_HEADER modeData;
3046 PMODE_CACHING_PAGE pageData;
3047
3049
3050 PAGED_CODE();
3051
3052
3053
3054 modeData = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
3055 MODE_DATA_SIZE,
3056 DISK_TAG_DISABLE_CACHE);
3057
3059
3060 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskGetSetCacheInformation: Unable to allocate mode "
3061 "data buffer\n"));
3063 }
3064
3066
3068 (PCHAR) modeData,
3069 MODE_DATA_SIZE,
3070 MODE_PAGE_CACHING);
3071
3073
3074 //
3075 // Retry the request in case of a check condition.
3076 //
3077
3079 (PCHAR) modeData,
3080 MODE_DATA_SIZE,
3081 MODE_PAGE_CACHING);
3082
3084
3085 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskGetCacheInformation: Mode Sense failed\n"));
3086
3087 FREE_POOL(modeData);
3089 }
3090 }
3091
3092 //
3093 // If the length is greater than length indicated by the mode data reset
3094 // the data to the mode data.
3095 //
3096
3099 }
3100
3101 //
3102 // Check to see if the write cache is enabled.
3103 //
3104
3106 length,
3107 MODE_PAGE_CACHING,
3108 TRUE);
3109
3110 //
3111 // Check if valid caching page exists.
3112 //
3113
3115 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskGetCacheInformation: Unable to find caching mode page.\n"));
3116 FREE_POOL(modeData);
3118 }
3119
3120 //
3121 // Copy the parameters over.
3122 //
3123
3125
3126 CacheInfo->ParametersSavable = pageData->PageSavable;
3127
3128 CacheInfo->ReadCacheEnabled = !(pageData->ReadDisableCache);
3129 CacheInfo->WriteCacheEnabled = pageData->WriteCacheEnable;
3130
3131
3132 //
3133 // Translate the values in the mode page into the ones defined in
3134 // ntdddisk.h.
3135 //
3136
3137 CacheInfo->ReadRetentionPriority =
3139 CacheInfo->WriteRetentionPriority =
3141
3142 CacheInfo->DisablePrefetchTransferLength =
3143 ((pageData->DisablePrefetchTransfer[0] << 8) +
3144 pageData->DisablePrefetchTransfer[1]);
3145
3146 CacheInfo->ScalarPrefetch.Minimum =
3148
3149 CacheInfo->ScalarPrefetch.Maximum =
3151
3153 CacheInfo->PrefetchScalar = TRUE;
3154 CacheInfo->ScalarPrefetch.MaximumBlocks =
3155 ((pageData->MaximumPrefetchCeiling[0] << 8) +
3156 pageData->MaximumPrefetchCeiling[1]);
3157 }
3158
3159
3160 FREE_POOL(modeData);
3162}
PVOID NTAPI ClassFindModePage(_In_reads_bytes_(Length) PCHAR ModeSenseBuffer, _In_ ULONG Length, _In_ UCHAR PageMode, _In_ BOOLEAN Use6Byte)
Definition: class.c:6798
ULONG NTAPI ClassModeSense(_In_ PDEVICE_OBJECT Fdo, _In_reads_bytes_(Length) PCHAR ModeSenseBuffer, _In_ ULONG Length, _In_ UCHAR PageMode)
Definition: class.c:6637
Definition: winioctl.h:488
Definition: cdrw_hw.h:2770
UCHAR DisablePrefetchTransfer[2]
Definition: cdrw_hw.h:2785
Referenced by DiskIoctlGetCacheInformation(), and DiskStartFdo().
◆ DiskGetInfoExceptionInformation()
| NTSTATUS DiskGetInfoExceptionInformation | ( | IN PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| OUT PMODE_INFO_EXCEPTIONS | ReturnPageData | ||
| ) |
◆ DiskGetModePage()
| NTSTATUS DiskGetModePage | ( | _In_ PDEVICE_OBJECT | Fdo, |
| _In_ UCHAR | PageMode, | ||
| _In_ UCHAR | PageControl, | ||
| _In_ PMODE_PARAMETER_HEADER | ModeData, | ||
| _Inout_ PULONG | ModeDataSize, | ||
| _Out_ PVOID * | PageData | ||
| ) |
Definition at line 903 of file diskwmi.c.
911{
914
915 PAGED_CODE();
916
918 ModeDataSize == NULL ||
920 PageData == NULL) {
922 }
923
924 RtlZeroMemory (ModeData, *ModeDataSize);
925
927 (PCHAR) ModeData,
928 *ModeDataSize,
929 PageMode,
930 PageControl);
931
933
934 //
935 // Retry the request in case of a check condition.
936 //
938 (PCHAR) ModeData,
939 *ModeDataSize,
940 PageMode,
941 PageControl);
942
944 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_WMI, "DiskGetModePage: Mode Sense for Page Mode %d with Page Control %d failed\n",
946 *ModeDataSize = 0;
948 }
949 }
950
951 //
952 // If the length is greater than length indicated by the mode data reset
953 // the data to the mode data.
954 //
956 size = ModeData->ModeDataLength + 1;
957 }
958
959 *ModeDataSize = size;
960
961 //
962 // Find the mode page
963 //
965 size,
966 PageMode,
967 TRUE);
968
969 if (pageData) {
970 *PageData = pageData;
972 } else {
973 *PageData = NULL;
975 }
976}
ULONG NTAPI ClassModeSenseEx(_In_ PDEVICE_OBJECT Fdo, _In_reads_bytes_(Length) PCHAR ModeSenseBuffer, _In_ ULONG Length, _In_ UCHAR PageMode, _In_ UCHAR PageControl)
Definition: class.c:6656
Referenced by DiskEnableInfoExceptions().
◆ DiskInitFdo()
| NTSTATUS NTAPI DiskInitFdo | ( | IN PDEVICE_OBJECT | Fdo | ) |
Definition at line 202 of file pnp.c.
223{
226
227 ULONG srbFlags = 0;
228 ULONG timeOut = 0;
229 ULONG bytesPerSector;
230
231 PULONG dmSkew;
232
234
235 PAGED_CODE();
236
237 //
238 // Build the lookaside list for srb's for the physical disk. Should only
239 // need a couple. If this fails then we don't have an emergency SRB so
240 // fail the call to initialize.
241 //
242
243 ClassInitializeSrbLookasideList((PCOMMON_DEVICE_EXTENSION) fdoExtension,
244 PARTITION0_LIST_SIZE);
245
247 {
249 }
250
251 //
252 // Initialize the srb flags.
253 //
254
255 //
256 // Because all requests share a common sense buffer, it is possible
257 // for the buffer to be overwritten if the port driver completes
258 // multiple failed requests that require a request sense before the
259 // class driver's completion routine can consume the data in the buffer.
260 // To prevent this, we allow the port driver to allocate a unique sense
261 // buffer each time it needs one. We are responsible for freeing this
262 // buffer. This also allows the adapter to be configured to support
263 // additional sense data beyond the minimum 18 bytes.
264 //
265
267
269 fdoExtension->AdapterDescriptor->CommandQueueing) {
270
272
273 }
274
275 //
276 // Look for controllers that require special flags.
277 //
278
280
281 //
282 // Clear buffer for drive geometry.
283 //
284
287
288 //
289 // Allocate request sense buffer.
290 //
291
293 SENSE_BUFFER_SIZE_EX,
294 DISK_TAG_START);
295
297
298 //
299 // The buffer can not be allocated.
300 //
301
302 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP, "DiskInitFdo: Can not allocate request sense buffer\n"));
303
306 }
307
308 //
309 // Set the buffer size of SenseData
310 //
311
313
314 //
315 // Physical device object will describe the entire
316 // device, starting at byte offset 0.
317 //
318
320
321 //
322 // Set timeout value in seconds.
323 //
325 (fdoExtension->MiniportDescriptor->IoTimeoutValue > 0) ) {
326 //
327 // use the value set by Storport miniport driver
328 //
329 fdoExtension->TimeOutValue = fdoExtension->MiniportDescriptor->IoTimeoutValue;
330 } else {
331 //
332 // get timeout value from registry
333 //
334 timeOut = ClassQueryTimeOutRegistryValue(Fdo);
335
336 if (timeOut) {
337 fdoExtension->TimeOutValue = timeOut;
338 } else {
340 }
341 }
342 //
343 // If this is a removable drive, build an entry in devicemap\scsi
344 // indicating it's physicaldriveN name, set up the appropriate
345 // update partitions routine and set the flags correctly.
346 // note: only do this after the timeout value is set, above.
347 //
348
350
351 ClassUpdateInformationInRegistry( Fdo,
352 "PhysicalDrive",
353 fdoExtension->DeviceNumber,
354 NULL,
355 0);
356 //
357 // Enable media change notification for removable disks
358 //
359 ClassInitializeMediaChangeDetection(fdoExtension,
361
362 } else {
363
366
367 }
368
369 //
370 // The commands we send during the init could cause the flags to change
371 // in case of any error. Save the SRB flags locally and restore it at
372 // the end of this function, so that the class driver can get it.
373 //
374
375 srbFlags = fdoExtension->SrbFlags;
376
377
378 //
379 // Read the drive capacity. Don't use the disk version of the routine here
380 // since we don't know the disk signature yet - the disk version will
381 // attempt to determine the BIOS reported geometry.
382 //
383
385
386 //
387 // Set up sector size fields.
388 //
389 // Stack variables will be used to update
390 // the partition device extensions.
391 //
392 // The device extension field SectorShift is
393 // used to calculate sectors in I/O transfers.
394 //
395 // The DiskGeometry structure is used to service
396 // IOCTls used by the format utility.
397 //
398
400
401 //
402 // Make sure sector size is not zero.
403 //
404
405 if (bytesPerSector == 0) {
406
407 //
408 // Default sector size for disk is 512.
409 //
410
412 fdoExtension->SectorShift = 9;
413 }
414
415 //
416 // Determine is DM Driver is loaded on an IDE drive that is
417 // under control of Atapi - this could be either a crashdump or
418 // an Atapi device is sharing the controller with an IDE disk.
419 //
420
423 (ULONG)0x54,
424 (PVOID *)&dmSkew);
425
426 if (dmSkew) {
427
428 //
429 // Update the device extension, so that the call to IoReadPartitionTable
430 // will get the correct information. Any I/O to this disk will have
431 // to be skewed by *dmSkew sectors aka DMByteSkew.
432 //
433
434 fdoExtension->DMSkew = *dmSkew;
437
438 FREE_POOL(dmSkew);
439 }
440
441#if defined(_X86_) || defined(_AMD64_)
442
443 //
444 // Try to read the signature off the disk and determine the correct drive
445 // geometry based on that. This requires rereading the disk size to get
446 // the cylinder count updated correctly.
447 //
448
450
451 DiskReadSignature(Fdo);
453
454 if (diskData->GeometrySource == DiskGeometryUnknown)
455 {
456 //
457 // Neither the BIOS nor the port driver could provide us with a reliable
458 // geometry. Before we use the default, look to see if it was partitioned
459 // under Windows NT4 [or earlier] and apply the one that was used back then
460 //
461
462 if (DiskIsNT4Geometry(fdoExtension))
463 {
464 diskData->RealGeometry = fdoExtension->DiskGeometry;
465 diskData->RealGeometry.SectorsPerTrack = 0x20;
466 diskData->RealGeometry.TracksPerCylinder = 0x40;
467 fdoExtension->DiskGeometry = diskData->RealGeometry;
468
469 diskData->GeometrySource = DiskGeometryFromNT4;
470 }
471 }
472 }
473
474#endif
475
477
478 //
479 // Get the SCSI address if it's available for use with SMART ioctls.
480 // SMART ioctls are used for failure prediction, so we need to get
481 // the SCSI address before initializing failure prediction.
482 //
483
484 {
487 IO_STATUS_BLOCK statusBlock = { 0 };
488
490
493 NULL,
494 0L,
495 &(diskData->ScsiAddress),
497 FALSE,
498 &event,
499 &statusBlock);
500
502
504
506
509 Executive,
510 KernelMode,
511 FALSE,
512 NULL);
514 }
515 }
516 }
517
518 //
519 // Determine the type of disk and enable failure prediction in the hardware
520 // and enable failure prediction polling.
521 //
522
524 {
525 DiskDetectFailurePrediction(fdoExtension,
526 &diskData->FailurePredictionCapability,
528
530 {
531 //
532 // Cool, we've got some sort of failure prediction, enable it
533 // at the hardware and then enable polling for it
534 //
535
536 //
537 // By default we allow performance to be degradeded if failure
538 // prediction is enabled.
539 //
540
542
543 //
544 // Enable polling only after Atapi and SBP2 add support for the new
545 // SRB flag that indicates that the request should not reset the
546 // drive spin down idle timer.
547 //
548
550 TRUE,
552
553 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP, "DiskInitFdo: Failure Prediction Poll enabled as "
554 "%d for device %p, Status = %lx\n",
555 diskData->FailurePredictionCapability,
556 Fdo,
557 status));
558 }
559 } else {
560
561 //
562 // In safe boot mode we do not enable failure prediction, as perhaps
563 // it is the reason why normal boot does not work
564 //
565
567
568 }
569
570 //
571 // Initialize the verify mutex
572 //
573
575
576 //
577 // Initialize the flush group context
578 //
579
581
584
587
588
589 //
590 // Restore the saved value
591 //
592 fdoExtension->SrbFlags = srbFlags;
593
595
596} // end DiskInitFdo()
_Must_inspect_result_ NTSTATUS NTAPI ClassReadDriveCapacity(_In_ PDEVICE_OBJECT Fdo)
Definition: class.c:2742
VOID NTAPI DiskSetSpecialHacks(IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN ULONG_PTR Data)
Definition: disk.c:2602
NTSTATUS DiskDetectFailurePrediction(PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, PFAILURE_PREDICTION_METHOD FailurePredictCapability, BOOLEAN ScsiAddressAvailable)
Definition: diskwmi.c:2230
#define DISK_DEFAULT_FAILURE_POLLING_PERIOD
Definition: disk.h:456
NTSTATUS DiskEnableDisableFailurePredictPolling(PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, BOOLEAN Enable, ULONG PollTimeInSeconds)
Definition: diskwmi.c:1193
VOID DiskCreateSymbolicLinks(IN PDEVICE_OBJECT DeviceObject)
Definition: pnp.c:676
#define KeWaitForSingleObject(pEvt, foo, a, b, c)
Definition: env_spec_w32.h:478
PIRP NTAPI IoBuildDeviceIoControlRequest(IN ULONG IoControlCode, IN PDEVICE_OBJECT DeviceObject, IN PVOID InputBuffer, IN ULONG InputBufferLength, IN PVOID OutputBuffer, IN ULONG OutputBufferLength, IN BOOLEAN InternalDeviceIoControl, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:881
VOID NTAPI KeInitializeMutex(IN PKMUTEX Mutex, IN ULONG Level)
Definition: mutex.c:67
Definition: disk.h:104
Definition: env_spec_w32.h:870
Definition: Bus_PDO_EvalMethod.c:105
Definition: ketypes.h:811
Definition: scsi_port.h:146
Referenced by DriverEntry().
◆ DiskInitializeReregistration()
Definition at line 1560 of file diskwmi.c.
1563{
1564 PAGED_CODE();
1565
1566 //
1567 // Initialize the spinlock used to manage the
1568 // list of disks reregistering their guids
1569 //
1571
1573}
Referenced by DriverEntry().
◆ DiskIoctlClearVerify()
Definition at line 5313 of file disk.c.
5339{
5341
5342 //
5343 // Validate the request.
5344 //
5345
5346 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DiskIoctlClearVerify: DeviceObject %p Irp %p\n", DeviceObject, Irp));
5347
5348 //
5349 // If the caller is kernel mode, set the verify bit.
5350 //
5351
5353
5356
5357 }
5359}
Referenced by DiskDeviceControl().
◆ DiskIoctlEnableFailurePrediction()
Definition at line 4419 of file disk.c.
4445{
4451 PSTORAGE_FAILURE_PREDICTION_CONFIG enablePrediction;
4452
4453 //
4454 // This function must be called at less than dispatch level.
4455 // Fail if IRQL >= DISPATCH_LEVEL.
4456 //
4457 PAGED_CODE();
4458 CHECK_IRQL();
4459
4460 //
4461 // Validate the request.
4462 //
4463
4464 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DiskIoctlEnableFailurePrediction: DeviceObject %p Irp %p\n", DeviceObject, Irp));
4465
4466 if (irpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(STORAGE_FAILURE_PREDICTION_CONFIG) ||
4467 irpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(STORAGE_FAILURE_PREDICTION_CONFIG)) {
4468
4469 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlEnableFailurePrediction: Buffer too small.\n"));
4471 }
4472
4473 enablePrediction = (PSTORAGE_FAILURE_PREDICTION_CONFIG)Irp->AssociatedIrp.SystemBuffer;
4474
4475 if (enablePrediction->Version != STORAGE_FAILURE_PREDICTION_CONFIG_V1 ||
4476 enablePrediction->Size < sizeof(STORAGE_FAILURE_PREDICTION_CONFIG)) {
4477 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlEnableFailurePrediction: Buffer version or size is incorrect.\n"));
4479 }
4480
4481 if (enablePrediction->Reserved != 0) {
4482 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlEnableFailurePrediction: Reserved bytes are not zero!\n"));
4484 }
4485
4486 //
4487 // Default to success. This might get overwritten on failure below.
4488 //
4490
4491 //
4492 // If this is a "set" and the current state (enabled/disabled) is
4493 // different from the sender's desired state,
4494 //
4495 if (enablePrediction->Set && enablePrediction->Enabled != diskData->FailurePredictionEnabled) {
4498 //
4499 // SMART or IOCTL based failure prediction is being used so call
4500 // the generic function that is normally called in the WMI path.
4501 //
4504 //
4505 // If we know that the device supports the Informational Exceptions
4506 // mode page, try to enable/disable failure prediction that way.
4507 //
4509 }
4510 }
4511
4512 //
4513 // Return the current state regardless if this was a "set" or a "get".
4514 //
4515 enablePrediction->Enabled = diskData->FailurePredictionEnabled;
4516
4519 }
4520
4522}
NTSTATUS DiskEnableDisableFailurePrediction(PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, BOOLEAN Enable)
Definition: diskwmi.c:1126
NTSTATUS DiskEnableInfoExceptions(_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _In_ BOOLEAN Enable)
Definition: diskwmi.c:979
Referenced by DiskDeviceControl().
◆ DiskIoctlGetCacheInformation()
Definition at line 3840 of file disk.c.
3868{
3873
3874 //
3875 // This function must be called at less than dispatch level.
3876 // Fail if IRQL >= DISPATCH_LEVEL.
3877 //
3878 PAGED_CODE();
3879 CHECK_IRQL();
3880
3881 //
3882 // Validate the request.
3883 //
3884
3885 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DiskIoctlGetCacheInformation: DeviceObject %p Irp %p\n", DeviceObject, Irp));
3886
3887 if (irpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(DISK_CACHE_INFORMATION)) {
3888
3889 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlGetCacheInformation: Output buffer too small.\n"));
3891 }
3892
3894
3897
3898 //
3899 // Make sure write cache setting is reflected in device extension
3900 //
3902 {
3904 }
3905 else
3906 {
3908 }
3909 ADJUST_FUA_FLAG(fdoExtension);
3910
3911 }
3913}
NTSTATUS NTAPI DiskGetCacheInformation(IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN PDISK_CACHE_INFORMATION CacheInfo)
Definition: disk.c:3019
struct _DISK_CACHE_INFORMATION DISK_CACHE_INFORMATION
Referenced by DiskDeviceControl().
◆ DiskIoctlGetCacheSetting()
| NTSTATUS DiskIoctlGetCacheSetting | ( | IN PDEVICE_OBJECT | DeviceObject, |
| IN PIRP | Irp | ||
| ) |
Definition at line 3347 of file disk.c.
3371{
3375
3376 PAGED_CODE();
3377
3379 {
3381 }
3382 else
3383 {
3385
3388
3389 //
3390 // Determine whether it is safe to turn on the cache
3391 //
3393 {
3395 }
3396
3397 //
3398 // Determine whether it is possible to modify the cache setting
3399 //
3401 {
3403 }
3404
3406
3408 }
3409
3411}
#define CLASS_SPECIAL_MODIFY_CACHE_UNSUCCESSFUL
Definition: classpnp.h:173
struct _DISK_CACHE_SETTING * PDISK_CACHE_SETTING
struct _DISK_CACHE_SETTING DISK_CACHE_SETTING
Definition: ntdddisk.h:834
Referenced by DiskDeviceControl().
◆ DiskIoctlGetDriveGeometry()
Definition at line 3582 of file disk.c.
3609{
3615
3616 //
3617 // This function must be called at less than dispatch level.
3618 // Fail if IRQL >= DISPATCH_LEVEL.
3619 //
3620 PAGED_CODE();
3621 CHECK_IRQL();
3622
3624
3625 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlGetDriveGeometry: Output buffer too small.\n"));
3627 }
3628
3630
3631 //
3632 // Issue ReadCapacity to update device extension
3633 // with information for current media.
3634 //
3635
3637
3638 //
3639 // Note whether the drive is ready.
3640 //
3641
3643
3646 }
3647 }
3648
3649 //
3650 // Copy drive geometry information from device extension.
3651 //
3652
3654 &(fdoExtension->DiskGeometry),
3656
3659 }
3662}
struct _DISK_GEOMETRY * PDISK_GEOMETRY
Referenced by DiskDeviceControl().
◆ DiskIoctlGetDriveGeometryEx()
| NTSTATUS DiskIoctlGetDriveGeometryEx | ( | IN PDEVICE_OBJECT | DeviceObject, |
| IN PIRP | Irp | ||
| ) |
◆ DiskIoctlGetLengthInfo()
| NTSTATUS DiskIoctlGetLengthInfo | ( | IN PDEVICE_OBJECT | DeviceObject, |
| IN PIRP | Irp | ||
| ) |
◆ DiskIoctlGetMediaTypesEx()
Definition at line 3994 of file disk.c.
4021{
4025
4026 PMODE_PARAMETER_HEADER modeData;
4027 PMODE_PARAMETER_BLOCK blockDescriptor;
4028 PSCSI_REQUEST_BLOCK srb;
4029 PCDB cdb;
4030 ULONG modeLength;
4031 ULONG retries = 4;
4032 UCHAR densityCode = 0;
4035 ULONG srbSize;
4039
4040 //
4041 // This function must be called at less than dispatch level.
4042 // Fail if IRQL >= DISPATCH_LEVEL.
4043 //
4044 PAGED_CODE();
4045 CHECK_IRQL();
4046
4047 //
4048 // Validate the request.
4049 //
4050
4051 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DiskIoctlGetMediaTypesEx: DeviceObject %p Irp %p\n", DeviceObject, Irp));
4052
4054
4055 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlGetMediaTypesEx: Output buffer too small.\n"));
4057 }
4058
4060 srbSize = CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE;
4061 } else {
4062 srbSize = SCSI_REQUEST_BLOCK_SIZE;
4063 }
4064
4065 srb = ExAllocatePoolWithTag(NonPagedPoolNx,
4066 srbSize,
4067 DISK_TAG_SRB);
4068
4070 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlGetMediaTypesEx: Unable to allocate memory.\n"));
4072 }
4073
4074 RtlZeroMemory(srb, srbSize);
4075
4076 //
4077 // Send a TUR to determine if media is present.
4078 //
4079
4081 srbEx = (PSTORAGE_REQUEST_BLOCK)srb;
4082
4083 //
4084 // Set up STORAGE_REQUEST_BLOCK fields
4085 //
4086
4088 srbEx->Function = SRB_FUNCTION_STORAGE_REQUEST_BLOCK;
4089 srbEx->Signature = SRB_SIGNATURE;
4090 srbEx->Version = STORAGE_REQUEST_BLOCK_VERSION_1;
4091 srbEx->SrbLength = srbSize;
4092 srbEx->SrbFunction = SRB_FUNCTION_EXECUTE_SCSI;
4095 srbEx->NumSrbExData = 1;
4096
4097 // Set timeout value.
4098 srbEx->TimeOutValue = fdoExtension->TimeOutValue;
4099
4100 //
4101 // Set up address fields
4102 //
4103
4105 storAddrBtl8->Type = STOR_ADDRESS_TYPE_BTL8;
4106 storAddrBtl8->AddressLength = STOR_ADDR_BTL8_ADDRESS_LENGTH;
4107
4108 //
4109 // Set up SCSI SRB extended data fields
4110 //
4111
4116 srbExDataCdb16->Type = SrbExDataTypeScsiCdb16;
4117 srbExDataCdb16->Length = SRBEX_DATA_SCSI_CDB16_LENGTH;
4118 srbExDataCdb16->CdbLength = 6;
4119
4120 cdb = (PCDB)srbExDataCdb16->Cdb;
4121 } else {
4122 // Should not happen
4124
4125 FREE_POOL(srb);
4126 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlGetMediaTypesEx: Insufficient extended SRB size.\n"));
4128 }
4129
4130 } else {
4131
4134 srb->CdbLength = 6;
4136
4137 //
4138 // Set timeout value.
4139 //
4140
4142
4143 }
4145
4147 srb,
4148 NULL,
4149 0,
4150 FALSE);
4151
4153 mediaPresent = TRUE;
4154 }
4155
4156 modeLength = MODE_DATA_SIZE;
4157 modeData = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
4158 modeLength,
4159 DISK_TAG_MODE_DATA);
4160
4162 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlGetMediaTypesEx: Unable to allocate memory.\n"));
4163 FREE_POOL(srb);
4165 }
4166
4167 RtlZeroMemory(modeData, modeLength);
4168
4169 //
4170 // Build the MODE SENSE CDB using previous SRB.
4171 //
4172
4174 srbEx->SrbStatus = 0;
4175 srbExDataCdb16->ScsiStatus = 0;
4176 srbExDataCdb16->CdbLength = 6;
4177
4178 //
4179 // Set timeout value from device extension.
4180 //
4181
4182 srbEx->TimeOutValue = fdoExtension->TimeOutValue;
4183 } else {
4184 srb->SrbStatus = 0;
4185 srb->ScsiStatus = 0;
4186 srb->CdbLength = 6;
4187
4188 //
4189 // Set timeout value from device extension.
4190 //
4191
4193 }
4194
4195 //
4196 // Page code of 0x3F will return all pages.
4197 // This command could fail if the data to be returned is
4198 // more than 256 bytes. In which case, we should get only
4199 // the caching page since we only need the block descriptor.
4200 // DiskFdoProcessError will change the page code to
4201 // MODE_PAGE_CACHING if there is an error.
4202 //
4203
4207
4208Retry:
4210 srb,
4211 modeData,
4212 modeLength,
4213 FALSE);
4214
4216
4217 if (retries--) {
4218
4219 //
4220 // Retry request.
4221 //
4222
4224 }
4227 }
4228
4230
4231 //
4232 // Get the block descriptor.
4233 //
4234
4236
4237 blockDescriptor = (PMODE_PARAMETER_BLOCK)((ULONG_PTR)modeData + sizeof(MODE_PARAMETER_HEADER));
4238 densityCode = blockDescriptor->DensityCode;
4239 }
4240
4242 MODE_DSP_WRITE_PROTECT)) {
4243
4244 writable = FALSE;
4245 }
4246
4248 Irp,
4249 modeData->MediumType,
4250 densityCode,
4251 mediaPresent,
4252 writable);
4253 //
4254 // If the buffer was too small, DetermineMediaTypes updated the status and information and the request will fail.
4255 //
4256
4257 } else {
4258 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlGetMediaTypesEx: Mode sense for header/bd failed. %lx\n", status));
4259 }
4260
4261 FREE_POOL(srb);
4262 FREE_POOL(modeData);
4263
4265}
struct _MODE_PARAMETER_HEADER MODE_PARAMETER_HEADER
struct _MODE_PARAMETER_BLOCK * PMODE_PARAMETER_BLOCK
#define CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE
Definition: classpnp.h:695
NTSTATUS DiskDetermineMediaTypes(IN PDEVICE_OBJECT Fdo, IN PIRP Irp, IN UCHAR MediumType, IN UCHAR DensityCode, IN BOOLEAN MediaPresent, IN BOOLEAN IsWritable)
Definition: disk.c:655
Definition: cdrw_hw.h:2527
UCHAR DeviceSpecificParameter
Definition: cdrw_hw.h:2507
struct _CDB::_CDB6GENERIC CDB6GENERIC
Referenced by DiskDeviceControl().
◆ DiskIoctlGetVolumeDiskExtents()
Definition at line 5461 of file disk.c.
5488{
5493
5494 //
5495 // This function must be called at less than dispatch level.
5496 // Fail if IRQL >= DISPATCH_LEVEL.
5497 //
5498 PAGED_CODE();
5499 CHECK_IRQL();
5500
5501 //
5502 // Validate the request.
5503 //
5504
5505 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DiskIoctlGetVolumeDiskExtents: DeviceObject %p Irp %p\n", DeviceObject, Irp));
5506
5507
5509
5511 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlGetVolumeDiskExtents: Output buffer too small.\n"));
5513 }
5514
5516
5517 //
5518 // Note whether the drive is ready.
5519 //
5520
5522
5524
5526
5527 pVolExt->NumberOfDiskExtents = 1;
5531
5533 }
5534 }
5535
5537}
struct _VOLUME_DISK_EXTENTS * PVOLUME_DISK_EXTENTS
Definition: ntddvol.h:118
Referenced by DiskDeviceControl().
◆ DiskIoctlIsWritable()
Definition at line 5063 of file disk.c.
5090{
5093
5094 PMODE_PARAMETER_HEADER modeData;
5095 PSCSI_REQUEST_BLOCK srb;
5097 ULONG modeLength;
5098 ULONG retries = 4;
5099 ULONG srbSize;
5100 PSTORAGE_REQUEST_BLOCK srbEx;
5101 PSTOR_ADDR_BTL8 storAddrBtl8;
5102 PSRBEX_DATA_SCSI_CDB16 srbExDataCdb16;
5103
5104 //
5105 // This function must be called at less than dispatch level.
5106 // Fail if IRQL >= DISPATCH_LEVEL.
5107 //
5108 PAGED_CODE();
5109 CHECK_IRQL();
5110
5111 //
5112 // Validate the request.
5113 //
5114
5115 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DiskIoctlIsWritable: DeviceObject %p Irp %p\n", DeviceObject, Irp));
5116
5118 srbSize = CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE;
5119 } else {
5120 srbSize = SCSI_REQUEST_BLOCK_SIZE;
5121 }
5122 srb = ExAllocatePoolWithTag(NonPagedPoolNx,
5123 srbSize,
5124 DISK_TAG_SRB);
5125
5127 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlIsWritable: Unable to allocate memory.\n"));
5129 }
5130
5131 RtlZeroMemory(srb, srbSize);
5132
5133 //
5134 // Allocate memory for a mode header and then some
5135 // for port drivers that need to convert to MODE10
5136 // or always return the MODE_PARAMETER_BLOCK (even
5137 // when memory was not allocated for this purpose)
5138 //
5139
5140 modeLength = MODE_DATA_SIZE;
5141 modeData = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
5142 modeLength,
5143 DISK_TAG_MODE_DATA);
5144
5146 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlIsWritable: Unable to allocate memory.\n"));
5147 FREE_POOL(srb);
5149 }
5150
5151 RtlZeroMemory(modeData, modeLength);
5152
5153 //
5154 // Build the MODE SENSE CDB
5155 //
5156
5158 srbEx = (PSTORAGE_REQUEST_BLOCK)srb;
5159
5160 //
5161 // Set up STORAGE_REQUEST_BLOCK fields
5162 //
5163
5165 srbEx->Function = SRB_FUNCTION_STORAGE_REQUEST_BLOCK;
5166 srbEx->Signature = SRB_SIGNATURE;
5167 srbEx->Version = STORAGE_REQUEST_BLOCK_VERSION_1;
5168 srbEx->SrbLength = srbSize;
5169 srbEx->SrbFunction = SRB_FUNCTION_EXECUTE_SCSI;
5172 srbEx->NumSrbExData = 1;
5173
5174 // Set timeout value.
5175 srbEx->TimeOutValue = fdoExtension->TimeOutValue;
5176
5177 //
5178 // Set up address fields
5179 //
5180
5182 storAddrBtl8->Type = STOR_ADDRESS_TYPE_BTL8;
5183 storAddrBtl8->AddressLength = STOR_ADDR_BTL8_ADDRESS_LENGTH;
5184
5185 //
5186 // Set up SCSI SRB extended data fields
5187 //
5188
5193 srbExDataCdb16->Type = SrbExDataTypeScsiCdb16;
5194 srbExDataCdb16->Length = SRBEX_DATA_SCSI_CDB16_LENGTH;
5195 srbExDataCdb16->CdbLength = 6;
5196
5197 cdb = (PCDB)srbExDataCdb16->Cdb;
5198 } else {
5199 // Should not happen
5201
5202 FREE_POOL(srb);
5203 FREE_POOL(modeData);
5205 }
5206
5207 } else {
5210 srb->CdbLength = 6;
5211
5212 //
5213 // Set timeout value.
5214 //
5215
5217
5219 }
5220
5221 //
5222 // Page code of 0x3F will return all pages.
5223 // This command could fail if the data to be returned is
5224 // more than 256 bytes. In which case, we should get only
5225 // the caching page since we only need the block descriptor.
5226 // DiskFdoProcessError will change the page code to
5227 // MODE_PAGE_CACHING if there is an error.
5228 //
5229
5233
5234 while (retries != 0) {
5235
5237 srb,
5238 modeData,
5239 modeLength,
5240 FALSE);
5241
5245 }
5246 break;
5247 }
5248 retries--;
5249 }
5250
5252
5255 }
5256 }
5257
5258 FREE_POOL(srb);
5259 FREE_POOL(modeData);
5261}
Referenced by DiskDeviceControl().
◆ DiskIoctlPredictFailure()
Definition at line 4268 of file disk.c.
4294{
4300
4301 PSTORAGE_PREDICT_FAILURE checkFailure;
4302 STORAGE_FAILURE_PREDICT_STATUS diskSmartStatus;
4303 IO_STATUS_BLOCK ioStatus = { 0 };
4305
4306 //
4307 // This function must be called at less than dispatch level.
4308 // Fail if IRQL >= DISPATCH_LEVEL.
4309 //
4310 PAGED_CODE();
4311 CHECK_IRQL();
4312
4313 //
4314 // Validate the request.
4315 //
4316
4317 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DiskIoctlPredictFailure: DeviceObject %p Irp %p\n", DeviceObject, Irp));
4318
4319 if (irpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(STORAGE_PREDICT_FAILURE)) {
4320
4321 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlPredictFailure: Output buffer too small.\n"));
4323 }
4324
4325 //
4326 // See if the disk is predicting failure
4327 //
4328
4330
4332 ULONG readBufferSize;
4333 PUCHAR readBuffer;
4334 PIRP readIrp;
4335 PDEVICE_OBJECT topOfStack;
4336
4337 checkFailure->PredictFailure = 0;
4338
4340
4342
4343 //
4344 // SCSI disks need to have a read sent down to provoke any
4345 // failures to be reported.
4346 //
4347 // Issue a normal read operation. The error-handling code in
4348 // classpnp will take care of a failure prediction by logging the
4349 // correct event.
4350 //
4351
4353 readBuffer = ExAllocatePoolWithTag(NonPagedPoolNx,
4354 readBufferSize,
4355 DISK_TAG_SMART);
4356
4359
4360 offset.QuadPart = 0;
4362 topOfStack,
4363 readBuffer,
4364 readBufferSize,
4365 &offset,
4366 &event,
4367 &ioStatus);
4368
4370
4375 }
4376
4377
4378 } else {
4380 }
4381
4382 FREE_POOL(readBuffer);
4383 } else {
4385 }
4386
4387 ObDereferenceObject(topOfStack);
4388 }
4389
4391 {
4394
4396
4398
4400 Irp->AssociatedIrp.SystemBuffer);
4401
4403 checkFailure->PredictFailure = 1;
4404 } else {
4405 checkFailure->PredictFailure = 0;
4406 }
4407
4409 }
4410 } else {
4412 }
4413 }
4415}
NTSTATUS DiskReadFailurePredictStatus(PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, PSTORAGE_FAILURE_PREDICT_STATUS DiskSmartStatus)
Definition: diskwmi.c:1251
NTSTATUS DiskReadFailurePredictData(PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, PSTORAGE_FAILURE_PREDICT_DATA DiskSmartData)
Definition: diskwmi.c:1327
struct _STORAGE_PREDICT_FAILURE STORAGE_PREDICT_FAILURE
PIRP NTAPI IoBuildSynchronousFsdRequest(IN ULONG MajorFunction, IN PDEVICE_OBJECT DeviceObject, IN PVOID Buffer, IN ULONG Length, IN PLARGE_INTEGER StartingOffset, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:1069
Definition: typedefs.h:103
Referenced by DiskDeviceControl().
◆ DiskIoctlReassignBlocks()
Definition at line 4648 of file disk.c.
4675{
4680 PSCSI_REQUEST_BLOCK srb;
4681 PCDB cdb;
4683 ULONG blockNumber;
4684 ULONG blockCount;
4685 ULONG srbSize;
4686 PSTORAGE_REQUEST_BLOCK srbEx;
4687 PSTOR_ADDR_BTL8 storAddrBtl8;
4688 PSRBEX_DATA_SCSI_CDB16 srbExDataCdb16;
4689
4690 //
4691 // This function must be called at less than dispatch level.
4692 // Fail if IRQL >= DISPATCH_LEVEL.
4693 //
4694 PAGED_CODE();
4695 CHECK_IRQL();
4696
4697 //
4698 // Validate the request.
4699 //
4700
4701 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DiskIoctlReassignBlocks: DeviceObject %p Irp %p\n", DeviceObject, Irp));
4702
4704 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlReassignBlocks: Input buffer length mismatch.\n"));
4706 }
4707
4708 //
4709 // Make sure we have some data in the input buffer.
4710 //
4711
4713 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlReassignBlocks: Invalid block count\n"));
4715 }
4716
4718
4720 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlReassignBlocks: Input buffer length mismatch for bad blocks.\n"));
4722 }
4723
4725 srbSize = CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE;
4726 } else {
4727 srbSize = SCSI_REQUEST_BLOCK_SIZE;
4728 }
4729 srb = ExAllocatePoolWithTag(NonPagedPoolNx,
4730 srbSize,
4731 DISK_TAG_SRB);
4732
4734 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlReassignBlocks: Unable to allocate memory.\n"));
4736 }
4737
4738 RtlZeroMemory(srb, srbSize);
4739
4740 //
4741 // Build the data buffer to be transferred in the input buffer.
4742 // The format of the data to the device is:
4743 //
4744 // 2 bytes Reserved
4745 // 2 bytes Length
4746 // x * 4 btyes Block Address
4747 //
4748 // All values are big endian.
4749 //
4750
4751 badBlocks->Reserved = 0;
4752 blockCount = badBlocks->Count;
4753
4754 //
4755 // Convert # of entries to # of bytes.
4756 //
4757
4758 blockCount *= 4;
4761
4762 //
4763 // Convert back to number of entries.
4764 //
4765
4766 blockCount /= 4;
4767
4768 for (; blockCount > 0; blockCount--) {
4769
4770 blockNumber = badBlocks->BlockNumber[blockCount-1];
4772 }
4773
4774 //
4775 // Build a SCSI SRB containing a SCSIOP_REASSIGN_BLOCKS cdb
4776 //
4777
4779 srbEx = (PSTORAGE_REQUEST_BLOCK)srb;
4780
4781 //
4782 // Set up STORAGE_REQUEST_BLOCK fields
4783 //
4784
4786 srbEx->Function = SRB_FUNCTION_STORAGE_REQUEST_BLOCK;
4787 srbEx->Signature = SRB_SIGNATURE;
4788 srbEx->Version = STORAGE_REQUEST_BLOCK_VERSION_1;
4789 srbEx->SrbLength = srbSize;
4790 srbEx->SrbFunction = SRB_FUNCTION_EXECUTE_SCSI;
4793 srbEx->NumSrbExData = 1;
4794
4795 // Set timeout value.
4796 srbEx->TimeOutValue = fdoExtension->TimeOutValue;
4797
4798 //
4799 // Set up address fields
4800 //
4801
4803 storAddrBtl8->Type = STOR_ADDRESS_TYPE_BTL8;
4804 storAddrBtl8->AddressLength = STOR_ADDR_BTL8_ADDRESS_LENGTH;
4805
4806 //
4807 // Set up SCSI SRB extended data fields
4808 //
4809
4814 srbExDataCdb16->Type = SrbExDataTypeScsiCdb16;
4815 srbExDataCdb16->Length = SRBEX_DATA_SCSI_CDB16_LENGTH;
4816 srbExDataCdb16->CdbLength = 6;
4817
4818 cdb = (PCDB)srbExDataCdb16->Cdb;
4819 } else {
4820 // Should not happen
4822
4823 FREE_POOL(srb);
4824 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlReassignBlocks: Insufficient extended SRB size.\n"));
4826 }
4827
4828 } else {
4831 srb->CdbLength = 6;
4832
4833 //
4834 // Set timeout value.
4835 //
4836
4838
4840 }
4841
4843
4845 srb,
4846 badBlocks,
4847 bufferSize,
4848 TRUE);
4849
4850 FREE_POOL(srb);
4852}
struct _REASSIGN_BLOCKS REASSIGN_BLOCKS
Definition: tools.h:15
Definition: ntdddisk.h:643
Referenced by DiskDeviceControl().
◆ DiskIoctlReassignBlocksEx()
Definition at line 4855 of file disk.c.
4882{
4887 PSCSI_REQUEST_BLOCK srb;
4888 PCDB cdb;
4889 LARGE_INTEGER blockNumber;
4891 ULONG blockCount;
4892 ULONG srbSize;
4893 PSTORAGE_REQUEST_BLOCK srbEx;
4894 PSTOR_ADDR_BTL8 storAddrBtl8;
4895 PSRBEX_DATA_SCSI_CDB16 srbExDataCdb16;
4896
4897 //
4898 // This function must be called at less than dispatch level.
4899 // Fail if IRQL >= DISPATCH_LEVEL.
4900 //
4901 PAGED_CODE();
4902 CHECK_IRQL();
4903
4904 //
4905 // Validate the request.
4906 //
4907
4908 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DiskIoctlReassignBlocksEx: DeviceObject %p Irp %p\n", DeviceObject, Irp));
4909
4911 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlReassignBlocksEx: Input buffer length mismatch.\n"));
4913 }
4914
4915 //
4916 // Make sure we have some data in the input buffer.
4917 //
4918
4920 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlReassignBlocksEx: Invalid block count\n"));
4922 }
4923
4925
4927 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlReassignBlocksEx: Input buffer length mismatch for bad blocks.\n"));
4929 }
4930
4932 srbSize = CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE;
4933 } else {
4934 srbSize = SCSI_REQUEST_BLOCK_SIZE;
4935 }
4936 srb = ExAllocatePoolWithTag(NonPagedPoolNx,
4937 srbSize,
4938 DISK_TAG_SRB);
4939
4941 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlReassignBlocks: Unable to allocate memory.\n"));
4943 }
4944
4945 RtlZeroMemory(srb, srbSize);
4946
4947 //
4948 // Build the data buffer to be transferred in the input buffer.
4949 // The format of the data to the device is:
4950 //
4951 // 2 bytes Reserved
4952 // 2 bytes Length
4953 // x * 8 btyes Block Address
4954 //
4955 // All values are big endian.
4956 //
4957
4958 badBlocks->Reserved = 0;
4959 blockCount = badBlocks->Count;
4960
4961 //
4962 // Convert # of entries to # of bytes.
4963 //
4964
4965 blockCount *= 8;
4968
4969 //
4970 // Convert back to number of entries.
4971 //
4972
4973 blockCount /= 8;
4974
4975 for (; blockCount > 0; blockCount--) {
4976
4977 blockNumber = badBlocks->BlockNumber[blockCount-1];
4979 }
4980
4981 //
4982 // Build a SCSI SRB containing a SCSIOP_REASSIGN_BLOCKS cdb
4983 //
4984
4986 srbEx = (PSTORAGE_REQUEST_BLOCK)srb;
4987
4988 //
4989 // Set up STORAGE_REQUEST_BLOCK fields
4990 //
4991
4993 srbEx->Function = SRB_FUNCTION_STORAGE_REQUEST_BLOCK;
4994 srbEx->Signature = SRB_SIGNATURE;
4995 srbEx->Version = STORAGE_REQUEST_BLOCK_VERSION_1;
4996 srbEx->SrbLength = srbSize;
4997 srbEx->SrbFunction = SRB_FUNCTION_EXECUTE_SCSI;
5000 srbEx->NumSrbExData = 1;
5001
5002 // Set timeout value.
5003 srbEx->TimeOutValue = fdoExtension->TimeOutValue;
5004
5005 //
5006 // Set up address fields
5007 //
5008
5010 storAddrBtl8->Type = STOR_ADDRESS_TYPE_BTL8;
5011 storAddrBtl8->AddressLength = STOR_ADDR_BTL8_ADDRESS_LENGTH;
5012
5013 //
5014 // Set up SCSI SRB extended data fields
5015 //
5016
5021 srbExDataCdb16->Type = SrbExDataTypeScsiCdb16;
5022 srbExDataCdb16->Length = SRBEX_DATA_SCSI_CDB16_LENGTH;
5023 srbExDataCdb16->CdbLength = 6;
5024
5025 cdb = (PCDB)srbExDataCdb16->Cdb;
5026 } else {
5027 // Should not happen
5029
5030 FREE_POOL(srb);
5031 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlReassignBlocks: Insufficient extended SRB size.\n"));
5033 }
5034
5035 } else {
5038 srb->CdbLength = 6;
5039
5040 //
5041 // Set timeout value.
5042 //
5043
5045
5047 }
5048
5051
5053 srb,
5054 badBlocks,
5055 bufferSize,
5056 TRUE);
5057
5058 FREE_POOL(srb);
5060}
struct _REASSIGN_BLOCKS_EX REASSIGN_BLOCKS_EX
Definition: ntdddisk.h:649
union _LARGE_INTEGER LARGE_INTEGER
Referenced by DiskDeviceControl().
◆ DiskIoctlSetCacheInformation()
Definition at line 3917 of file disk.c.
3946{
3953
3954 //
3955 // This function must be called at less than dispatch level.
3956 // Fail if IRQL is equal or above DISPATCH_LEVEL.
3957 //
3958
3959 PAGED_CODE();
3960 CHECK_IRQL();
3961
3962 //
3963 // Validate the request.
3964 //
3965
3966 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DiskIoctlSetCacheInformation: DeviceObject %p Irp %p\n", DeviceObject, Irp));
3967
3969
3970 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlSetCacheInformation: Input buffer length mismatch.\n"));
3972 }
3973
3975
3976 //
3977 // Save away the user-defined override in our extension and the registry
3978 //
3981 } else {
3983 }
3984
3985 ClassSetDeviceParameter(fdoExtension, DiskDeviceParameterSubkey,
3987
3989
3991}
NTSTATUS NTAPI DiskSetCacheInformation(IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN PDISK_CACHE_INFORMATION CacheInfo)
Definition: disk.c:3167
VOID DiskLogCacheInformation(IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN PDISK_CACHE_INFORMATION CacheInfo, IN NTSTATUS Status)
Definition: disk.c:2856
Referenced by DiskDeviceControl().
◆ DiskIoctlSetCacheSetting()
| NTSTATUS DiskIoctlSetCacheSetting | ( | IN PDEVICE_OBJECT | DeviceObject, |
| IN PIRP | Irp | ||
| ) |
Definition at line 3415 of file disk.c.
3441{
3445
3446 //
3447 // This function must be called at less than dispatch level.
3448 // Fail if IRQL >= DISPATCH_LEVEL.
3449 //
3450 PAGED_CODE();
3451 CHECK_IRQL();
3452
3454 {
3456 }
3457 else
3458 {
3460
3462 {
3463 ULONG isPowerProtected;
3464
3465 //
3466 // Save away the user-defined override in our extension and the registry
3467 //
3469 {
3471 isPowerProtected = 1;
3472 }
3473 else
3474 {
3476 isPowerProtected = 0;
3477 }
3478 ADJUST_FUA_FLAG(fdoExtension);
3479
3480 ClassSetDeviceParameter(fdoExtension, DiskDeviceParameterSubkey, DiskDeviceCacheIsPowerProtected, isPowerProtected);
3481 }
3482 else
3483 {
3485 }
3486 }
3487
3489}
Referenced by DiskDeviceControl().
◆ DiskIoctlSetVerify()
Definition at line 5264 of file disk.c.
5290{
5292
5293 //
5294 // Validate the request.
5295 //
5296
5297 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DiskIoctlSetVerify: DeviceObject %p Irp %p\n", DeviceObject, Irp));
5298
5299 //
5300 // If the caller is kernel mode, set the verify bit.
5301 //
5302
5304
5307
5308 }
5310}
Referenced by DiskDeviceControl().
◆ DiskIoctlSmartGetVersion()
Definition at line 5540 of file disk.c.
5566{
5572
5573 PGETVERSIONINPARAMS versionParams;
5574 PSRB_IO_CONTROL srbControl;
5575 IO_STATUS_BLOCK ioStatus = { 0 };
5577
5578 //
5579 // This function must be called at less than dispatch level.
5580 // Fail if IRQL >= DISPATCH_LEVEL.
5581 //
5582 PAGED_CODE();
5583 CHECK_IRQL();
5584
5585 //
5586 // Validate the request.
5587 //
5588
5589 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DiskIoctlSmartGetVersion: DeviceObject %p Irp %p\n", DeviceObject, Irp));
5590
5591
5593 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlSmartGetVersion: Output buffer too small.\n"));
5595 }
5596
5597 srbControl = ExAllocatePoolWithTag(NonPagedPoolNx,
5600 DISK_TAG_SMART);
5601
5603 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlSmartGetVersion: Unable to allocate memory.\n"));
5605 }
5606
5608
5609 //
5610 // fill in srbControl fields
5611 //
5612
5618
5619 //
5620 // Point to the 'buffer' portion of the SRB_CONTROL
5621 //
5622
5624
5625 //
5626 // Ensure correct target is set in the cmd parameters.
5627 //
5628
5631
5633 IOCTL_SCSI_MINIPORT,
5634 commonExtension->LowerDeviceObject,
5635 srbControl,
5638 FALSE,
5639 &ioStatus);
5640
5642
5643 //
5644 // If successful, copy the data received into the output buffer.
5645 // This should only fail in the event that the IDE driver is older
5646 // than this driver.
5647 //
5648
5650
5652
5655 }
5656
5657 FREE_POOL(srbControl);
5658
5660}
#define IOCTL_SCSI_MINIPORT_SMART_VERSION
Definition: cdrw_hw.h:1457
VOID NTAPI ClassSendDeviceIoControlSynchronous(_In_ ULONG IoControlCode, _In_ PDEVICE_OBJECT TargetDeviceObject, _Inout_updates_opt_(_Inexpressible_(max(InputBufferLength, OutputBufferLength))) PVOID Buffer, _In_ ULONG InputBufferLength, _In_ ULONG OutputBufferLength, _In_ BOOLEAN InternalDeviceIoControl, _Out_ PIO_STATUS_BLOCK IoStatus)
Definition: class.c:11065
struct _GETVERSIONINPARAMS GETVERSIONINPARAMS
struct _SRB_IO_CONTROL SRB_IO_CONTROL
Definition: ntdddisk.h:665
Definition: scsi_port.h:124
Referenced by DiskDeviceControl().
◆ DiskIoctlSmartReceiveDriveData()
Definition at line 5663 of file disk.c.
5689{
5695
5697 PSRB_IO_CONTROL srbControl;
5698 IO_STATUS_BLOCK ioStatus = { 0 };
5699 ULONG controlCode = 0;
5701 PIRP irp2;
5704
5705 //
5706 // This function must be called at less than dispatch level.
5707 // Fail if IRQL >= DISPATCH_LEVEL.
5708 //
5709 PAGED_CODE();
5710 CHECK_IRQL();
5711
5712 //
5713 // Validate the request.
5714 //
5715
5716 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DiskIoctlSmartReceiveDriveData: DeviceObject %p Irp %p\n", DeviceObject, Irp));
5717
5719 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlSmartReceiveDriveData: Input buffer length invalid.\n"));
5721 }
5722
5723 if (irpStack->Parameters.DeviceIoControl.OutputBufferLength < (sizeof(SENDCMDOUTPARAMS) + 512 - 1)) {
5724 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlSmartReceiveDriveData: Output buffer too small.\n"));
5726 }
5727
5728 //
5729 // Create notification event object to be used to signal the
5730 // request completion.
5731 //
5732
5734
5735 //
5736 // use controlCode as a sort of 'STATUS_SUCCESS' to see if it's
5737 // a valid request type
5738 //
5739
5741
5743 controlCode = IOCTL_SCSI_MINIPORT_IDENTIFY;
5744
5746
5748
5750 controlCode = IOCTL_SCSI_MINIPORT_READ_SMART_ATTRIBS;
5752 break;
5753
5755 controlCode = IOCTL_SCSI_MINIPORT_READ_SMART_THRESHOLDS;
5757 break;
5758
5760
5762 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlSmartReceiveDriveData: SMART failure prediction not supported.\n"));
5764 }
5765
5766 //
5767 // Calculate additional length based on number of sectors to be read.
5768 // Then verify the output buffer is large enough.
5769 //
5770
5772
5773 //
5774 // Ensure at least 1 sector is going to be read
5775 //
5778 }
5779
5781
5783 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlSmartReceiveDriveData: Output buffer too small for SMART_READ_LOG.\n"));
5785 }
5786
5787 controlCode = IOCTL_SCSI_MINIPORT_READ_SMART_LOG;
5788 break;
5789 }
5790 }
5791 }
5792
5793 if (controlCode == 0) {
5794 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlSmartReceiveDriveData: Invalid request.\n"));
5796 }
5797
5798 srbControl = ExAllocatePoolWithTag(NonPagedPoolNx,
5800 DISK_TAG_SMART);
5801
5803 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlSmartReceiveDriveData: Unable to allocate memory.\n"));
5805 }
5806
5807 //
5808 // fill in srbControl fields
5809 //
5810
5815 srbControl->ControlCode = controlCode;
5816
5817 //
5818 // Point to the 'buffer' portion of the SRB_CONTROL
5819 //
5820
5822
5823 //
5824 // Ensure correct target is set in the cmd parameters.
5825 //
5826
5828
5829 //
5830 // Copy the IOCTL parameters to the srb control buffer area.
5831 //
5832
5834 Irp->AssociatedIrp.SystemBuffer,
5836
5838 commonExtension->LowerDeviceObject,
5839 srbControl,
5841 srbControl,
5843 FALSE,
5844 &event,
5845 &ioStatus);
5846
5848 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlSmartReceiveDriveData: Unable to allocate IRP.\n"));
5849 FREE_POOL(srbControl);
5851 }
5852
5853 //
5854 // Call the port driver with the request and wait for it to complete.
5855 //
5856
5858
5862 }
5863
5864 //
5865 // Copy the data received into the output buffer. Since the status buffer
5866 // contains error information also, always perform this copy. IO will
5867 // either pass this back to the app, or zero it, in case of error.
5868 //
5869
5871
5873
5876
5877 } else {
5878
5881
5882 }
5883
5884 FREE_POOL(srbControl);
5885
5887}
struct _SENDCMDOUTPARAMS SENDCMDOUTPARAMS
struct _SENDCMDINPARAMS * PSENDCMDINPARAMS
#define IOCTL_SCSI_MINIPORT_READ_SMART_ATTRIBS
Definition: cdrw_hw.h:1459
#define IOCTL_SCSI_MINIPORT_READ_SMART_THRESHOLDS
Definition: cdrw_hw.h:1460
Definition: helper.h:30
Definition: helper.h:24
Referenced by DiskDeviceControl().
◆ DiskIoctlSmartSendDriveCommand()
Definition at line 5890 of file disk.c.
5916{
5922
5924 PSRB_IO_CONTROL srbControl;
5925 IO_STATUS_BLOCK ioStatus = { 0 };
5926 ULONG controlCode = 0;
5928 PIRP irp2;
5931
5932 //
5933 // This function must be called at less than dispatch level.
5934 // Fail if IRQL >= DISPATCH_LEVEL.
5935 //
5936 PAGED_CODE();
5937 CHECK_IRQL();
5938
5939 //
5940 // Validate the request.
5941 //
5942
5943 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DiskIoctlSmartSendDriveCommand: DeviceObject %p Irp %p\n", DeviceObject, Irp));
5944
5946 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlSmartSendDriveCommand: Input buffer size invalid.\n"));
5948 }
5949
5950 if (irpStack->Parameters.DeviceIoControl.OutputBufferLength < (sizeof(SENDCMDOUTPARAMS) - 1)) {
5951 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlSmartSendDriveCommand: Output buffer too small.\n"));
5953 }
5954
5955 //
5956 // Create notification event object to be used to signal the
5957 // request completion.
5958 //
5959
5961
5963
5965
5967
5969
5970 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlSmartSendDriveCommand: SMART failure prediction not supported.\n"));
5972 }
5973
5974 //
5975 // Calculate additional length based on number of sectors to be written.
5976 // Then verify the input buffer is large enough.
5977 //
5978
5980
5981 //
5982 // Ensure at least 1 sector is going to be written
5983 //
5984
5987 }
5988
5991
5992 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlSmartSendDriveCommand: Input buffer too small for SMART_WRITE_LOG.\n"));
5994 }
5995
5996 controlCode = IOCTL_SCSI_MINIPORT_WRITE_SMART_LOG;
5997 break;
5998 }
5999
6001 controlCode = IOCTL_SCSI_MINIPORT_ENABLE_SMART;
6002 break;
6003
6005 controlCode = IOCTL_SCSI_MINIPORT_DISABLE_SMART;
6006 break;
6007
6009
6010 //
6011 // Ensure bBuffer is at least 2 bytes (to hold the values of
6012 // cylinderLow and cylinderHigh).
6013 //
6014
6017
6019 break;
6020 }
6021
6022 controlCode = IOCTL_SCSI_MINIPORT_RETURN_STATUS;
6024 break;
6025
6027 controlCode = IOCTL_SCSI_MINIPORT_ENABLE_DISABLE_AUTOSAVE;
6028 break;
6029
6031 controlCode = IOCTL_SCSI_MINIPORT_SAVE_ATTRIBUTE_VALUES;
6032 break;
6033
6035 //
6036 // Validate that this is an ok self test command
6037 //
6039
6040 controlCode = IOCTL_SCSI_MINIPORT_EXECUTE_OFFLINE_DIAGS;
6041 }
6042 break;
6043
6045 controlCode = IOCTL_SCSI_MINIPORT_ENABLE_DISABLE_AUTO_OFFLINE;
6046 break;
6047 }
6048 }
6049
6050 if (controlCode == 0) {
6051 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlSmartSendDriveCommand: Invalid request.\n"));
6053 }
6054
6056 srbControl = ExAllocatePoolWithTag(NonPagedPoolNx,
6058 DISK_TAG_SMART);
6059
6061 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlSmartSendDriveCommand: Unable to allocate memory.\n"));
6063 }
6064
6065 //
6066 // fill in srbControl fields
6067 //
6068
6073 srbControl->ControlCode = controlCode;
6074
6075 //
6076 // Point to the 'buffer' portion of the SRB_CONTROL
6077 //
6078
6080
6081 //
6082 // Ensure correct target is set in the cmd parameters.
6083 //
6084
6086
6087 //
6088 // Copy the IOCTL parameters to the srb control buffer area.
6089 //
6090
6093 Irp->AssociatedIrp.SystemBuffer,
6096 } else {
6098 }
6099
6101 commonExtension->LowerDeviceObject,
6102 srbControl,
6104 srbControl,
6106 FALSE,
6107 &event,
6108 &ioStatus);
6109
6111 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlSmartSendDriveCommand: Unable to allocate IRP.\n"));
6112 FREE_POOL(srbControl);
6114 }
6115
6116 //
6117 // Call the port driver with the request and wait for it to complete.
6118 //
6119
6121
6125 }
6126
6127 //
6128 // Copy the data received into the output buffer. Since the status buffer
6129 // contains error information also, always perform this copy. IO will
6130 // either pass this back to the app, or zero it, in case of error.
6131 //
6132
6134
6135 //
6136 // Update the return buffer size based on the sub-command.
6137 //
6138
6141 } else {
6143 }
6144
6147
6148 FREE_POOL(srbControl);
6149
6151}
struct _IDEREGS IDEREGS
#define IOCTL_SCSI_MINIPORT_SAVE_ATTRIBUTE_VALUES
Definition: cdrw_hw.h:1465
#define IOCTL_SCSI_MINIPORT_DISABLE_SMART
Definition: cdrw_hw.h:1462
#define IOCTL_SCSI_MINIPORT_ENABLE_DISABLE_AUTOSAVE
Definition: cdrw_hw.h:1464
#define IOCTL_SCSI_MINIPORT_EXECUTE_OFFLINE_DIAGS
Definition: cdrw_hw.h:1466
#define IOCTL_SCSI_MINIPORT_RETURN_STATUS
Definition: cdrw_hw.h:1463
#define IOCTL_SCSI_MINIPORT_WRITE_SMART_LOG
Definition: scsi.h:1421
#define IOCTL_SCSI_MINIPORT_ENABLE_DISABLE_AUTO_OFFLINE
Definition: scsi.h:1419
Definition: helper.h:8
Referenced by DiskDeviceControl().
◆ DiskIoctlUpdateDriveSize()
Definition at line 5362 of file disk.c.
5391{
5398
5399 //
5400 // This function must be called at less than dispatch level.
5401 // Fail if IRQL >= DISPATCH_LEVEL.
5402 //
5403 PAGED_CODE();
5404 CHECK_IRQL();
5405
5406 //
5407 // Validate the request.
5408 //
5409
5410 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DiskIoctlUpdateDriveSize: DeviceObject %p Irp %p\n", DeviceObject, Irp));
5411
5413
5414 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlUpdateDriveSize: Output buffer too small.\n"));
5416 }
5417
5419
5420 //
5421 // Note whether the drive is ready.
5422 //
5423
5425
5427
5428 //
5429 // Copy drive geometry information from the device extension.
5430 //
5431
5433 &(fdoExtension->DiskGeometry),
5435
5438 }
5441
5442 //
5443 // Notify everyone that the disk layout may have changed
5444 //
5445
5446 Notification.Event = GUID_IO_DISK_LAYOUT_CHANGE;
5447 Notification.Version = 1;
5450 Notification.NameBufferOffset = -1;
5451
5453 &Notification,
5454 NULL,
5455 NULL);
5456 }
5458}
NTSTATUS NTAPI IoReportTargetDeviceChangeAsynchronous(IN PDEVICE_OBJECT PhysicalDeviceObject, IN PVOID NotificationStructure, IN PDEVICE_CHANGE_COMPLETE_CALLBACK Callback OPTIONAL, IN PVOID Context OPTIONAL)
Definition: pnpreport.c:498
Definition: iotypes.h:1008
_In_ PWDFDEVICE_INIT _In_ PFN_WDF_DEVICE_SHUTDOWN_NOTIFICATION Notification
Definition: wdfcontrol.h:115
Referenced by DiskDeviceControl().
◆ DiskIoctlVerify()
Definition at line 4526 of file disk.c.
4551{
4557 PSCSI_REQUEST_BLOCK srb;
4558 LARGE_INTEGER byteOffset;
4559 ULONG srbSize;
4560
4561 //
4562 // Validate the request.
4563 //
4564
4565 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DiskIoctlVerify: DeviceObject %p Irp %p\n", DeviceObject, Irp));
4566
4568 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlVerify: Input buffer length mismatch.\n"));
4570 }
4571
4573 srbSize = CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE;
4574 } else {
4575 srbSize = SCSI_REQUEST_BLOCK_SIZE;
4576 }
4577 srb = ExAllocatePoolWithTag(NonPagedPoolNx,
4578 srbSize,
4579 DISK_TAG_SRB);
4580
4582 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlVerify: Unable to allocate memory.\n"));
4584 }
4585
4586 RtlZeroMemory(srb, srbSize);
4587
4588 //
4589 // Add disk offset to starting sector.
4590 //
4591
4594
4595 //
4596 // Perform a bounds check on the sector range
4597 //
4598
4601
4602 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlVerify: Verify request to invalid sector.\n"));
4603 FREE_POOL(srb)
4605 } else {
4606
4607 ULONGLONG bytesRemaining = commonExtension->PartitionLength.QuadPart - verifyInfo->StartingOffset.QuadPart;
4608
4610
4611 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskIoctlVerify: Verify request to invalid sector.\n"));
4612 FREE_POOL(srb)
4614 }
4615 }
4616
4619 DISK_TAG_WI_CONTEXT);
4621
4623 Context->Srb = srb;
4625
4627
4628 //
4629 // Queue the work item and return.
4630 //
4631
4633
4635 DiskIoctlVerifyThread,
4636 DelayedWorkQueue,
4637 Context);
4638
4640 }
4642 }
4643 FREE_POOL(srb)
4645}
IoMarkIrpPending(Irp)
Definition: compobj.c:4795
Definition: disk.h:446
Definition: ntdddisk.h:655
Referenced by DiskDeviceControl().
◆ DiskLogCacheInformation()
| VOID DiskLogCacheInformation | ( | IN PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| IN PDISK_CACHE_INFORMATION | CacheInfo, | ||
| IN NTSTATUS | Status | ||
| ) |
Definition at line 2856 of file disk.c.
2861{
2863
2864 PAGED_CODE();
2865
2866 logEntry = IoAllocateErrorLogEntry(FdoExtension->DeviceObject, sizeof(IO_ERROR_LOG_PACKET) + (4 * sizeof(ULONG)));
2867
2869 {
2872
2875 logEntry->SequenceNumber = 0;
2877 logEntry->IoControlCode = 0;
2878 logEntry->RetryCount = 0;
2879 logEntry->UniqueErrorValue = 0x1;
2881
2885 logEntry->DumpData[3] = CacheInfo->WriteCacheEnabled;
2886
2887 //
2888 // Write the error log packet.
2889 //
2890
2891 IoWriteErrorLogEntry(logEntry);
2892 }
2893}
Referenced by DiskIoctlSetCacheInformation().
◆ DiskModeSelect()
| NTSTATUS DiskModeSelect | ( | IN PDEVICE_OBJECT | DeviceObject, |
| _In_reads_bytes_(Length) PCHAR | ModeSelectBuffer, | ||
| IN ULONG | Length, | ||
| IN BOOLEAN | SavePage | ||
| ) |
Definition at line 1802 of file disk.c.
1831{
1833 PCDB cdb;
1834 SCSI_REQUEST_BLOCK srb = {0};
1835 ULONG retries = 1;
1836 ULONG length2;
1839 PMODE_PARAMETER_BLOCK blockDescriptor;
1842 PSTOR_ADDR_BTL8 storAddrBtl8;
1843 PSRBEX_DATA_SCSI_CDB16 srbExDataCdb16;
1844 PSCSI_REQUEST_BLOCK srbPtr;
1845
1846 PAGED_CODE();
1847
1848 //
1849 // Check whether block length is available
1850 //
1851
1853
1854 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskModeSelect: Block length is not available. Unable to send mode select\n"));
1857 }
1858
1859
1860
1862
1863 //
1864 // Allocate buffer for mode select header, block descriptor, and mode page.
1865 //
1866
1868 length2,
1869 DISK_TAG_MODE_DATA);
1870
1873 }
1874
1876
1877 //
1878 // Set length in header to size of mode page.
1879 //
1880
1882
1884
1885 //
1886 // Set block length from the cached disk geometry
1887 //
1888
1892
1893 //
1894 // Copy mode page to buffer.
1895 //
1896
1898
1899 //
1900 // Build the MODE SELECT CDB.
1901 //
1902
1904
1905 //
1906 // Set up STORAGE_REQUEST_BLOCK fields
1907 //
1908
1910 srbEx->Function = SRB_FUNCTION_STORAGE_REQUEST_BLOCK;
1911 srbEx->Signature = SRB_SIGNATURE;
1912 srbEx->Version = STORAGE_REQUEST_BLOCK_VERSION_1;
1913 srbEx->SrbLength = sizeof(srbExBuffer);
1914 srbEx->SrbFunction = SRB_FUNCTION_EXECUTE_SCSI;
1915 srbEx->RequestPriority = IoPriorityNormal;
1917 srbEx->NumSrbExData = 1;
1918
1919 // Set timeout value from device extension.
1920 srbEx->TimeOutValue = fdoExtension->TimeOutValue * 2;
1921
1922 //
1923 // Set up address fields
1924 //
1925
1927 storAddrBtl8->Type = STOR_ADDRESS_TYPE_BTL8;
1928 storAddrBtl8->AddressLength = STOR_ADDR_BTL8_ADDRESS_LENGTH;
1929
1930 //
1931 // Set up SCSI SRB extended data fields
1932 //
1933
1938 srbExDataCdb16->Type = SrbExDataTypeScsiCdb16;
1939 srbExDataCdb16->Length = SRBEX_DATA_SCSI_CDB16_LENGTH;
1940 srbExDataCdb16->CdbLength = 6;
1941
1942 cdb = (PCDB)srbExDataCdb16->Cdb;
1943 } else {
1944 // Should not happen
1946
1948 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskModeSelect: Insufficient extended SRB size\n"));
1950 }
1951
1952 srbPtr = (PSCSI_REQUEST_BLOCK)srbEx;
1953
1954 } else {
1955
1956 srb.CdbLength = 6;
1958
1959 //
1960 // Set timeout value from device extension.
1961 //
1962
1964
1965 srbPtr = &srb;
1966 }
1967
1969 cdb->MODE_SELECT.SPBit = SavePage;
1970 cdb->MODE_SELECT.PFBit = 1;
1972
1973Retry:
1974
1976 srbPtr,
1977 buffer,
1978 length2,
1979 TRUE);
1980
1982
1983 //
1984 // Routine ClassSendSrbSynchronous does not retry requests returned with
1985 // this status.
1986 //
1987
1988 if (retries--) {
1989
1990 //
1991 // Retry request.
1992 //
1993
1995 }
1996
1999 }
2000
2002
2004} // end DiskModeSelect()
struct _MODE_PARAMETER_BLOCK MODE_PARAMETER_BLOCK
struct _MODE_PARAMETER_HEADER * PMODE_PARAMETER_HEADER
struct _SCSI_REQUEST_BLOCK * PSCSI_REQUEST_BLOCK
struct _CDB::_MODE_SELECT MODE_SELECT
Referenced by DiskSetCacheInformation(), and DiskSetInfoExceptionInformation().
◆ DiskPerformSmartCommand()
| NTSTATUS DiskPerformSmartCommand | ( | IN PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| IN ULONG | SrbControlCode, | ||
| IN UCHAR | Command, | ||
| IN UCHAR | Feature, | ||
| IN UCHAR | SectorCount, | ||
| IN UCHAR | SectorNumber, | ||
| IN OUT PSRB_IO_CONTROL | SrbControl, | ||
| OUT PULONG | BufferSize | ||
| ) |
Definition at line 476 of file diskwmi.c.
518{
522 PSENDCMDINPARAMS cmdInParameters;
524 ULONG availableBufferSize;
527 IO_STATUS_BLOCK ioStatus = { 0 };
528 SCSI_REQUEST_BLOCK srb = {0};
529 LARGE_INTEGER startingOffset;
531 PIO_STACK_LOCATION irpStack;
534 PSTOR_ADDR_BTL8 storAddrBtl8;
535
536 PAGED_CODE();
537
538 //
539 // Point to the 'buffer' portion of the SRB_CONTROL and compute how
540 // much room we have left in the srb control. Abort if the buffer
541 // isn't at least the size of SRB_IO_CONTROL.
542 //
543
545
547
550 } else {
552 }
553
554#if DBG
555
556 //
557 // Ensure control codes and buffer lengths passed are correct
558 //
559 {
560 ULONG controlCode = 0;
562
564 {
566 {
568 {
569 controlCode = IOCTL_SCSI_MINIPORT_ENABLE_SMART;
570 break;
571 }
572
574 {
575 controlCode = IOCTL_SCSI_MINIPORT_DISABLE_SMART;
576 break;
577 }
578
580 {
581 controlCode = IOCTL_SCSI_MINIPORT_RETURN_STATUS;
583 break;
584 }
585
587 {
588 controlCode = IOCTL_SCSI_MINIPORT_ENABLE_DISABLE_AUTOSAVE;
589 break;
590 }
591
593 {
594 controlCode = IOCTL_SCSI_MINIPORT_SAVE_ATTRIBUTE_VALUES;
595 break;
596 }
597
598
600 {
601 controlCode = IOCTL_SCSI_MINIPORT_EXECUTE_OFFLINE_DIAGS;
602 break;
603 }
604
606 {
607 controlCode = IOCTL_SCSI_MINIPORT_READ_SMART_ATTRIBS;
609 break;
610 }
611
613 {
614 controlCode = IOCTL_SCSI_MINIPORT_READ_SMART_THRESHOLDS;
616 break;
617 }
618
620 {
621 controlCode = IOCTL_SCSI_MINIPORT_READ_SMART_LOG;
622 lengthNeeded = max( lengthNeeded, sizeof(SENDCMDOUTPARAMS) - 1 + (SectorCount * SMART_LOG_SECTOR_SIZE) );
623 break;
624 }
625
627 {
628 controlCode = IOCTL_SCSI_MINIPORT_WRITE_SMART_LOG;
630 break;
631 }
632
633 }
634
636
637 controlCode = IOCTL_SCSI_MINIPORT_IDENTIFY;
639
640 } else {
641
643 }
644
645 NT_ASSERT(controlCode == SrbControlCode);
646 NT_ASSERT(availableBufferSize >= lengthNeeded);
647 }
648
649#endif
650
651 //
652 // Build SrbControl and input to SMART command
653 //
656 SrbControl->Timeout = FdoExtension->TimeOutValue;
657 SrbControl->Length = availableBufferSize;
658 SrbControl->ControlCode = SrbControlCode;
659
668
669 //
670 // Create and send irp
671 //
673
675
676 length = SrbControl->HeaderLength + SrbControl->Length;
677
679 IRP_MJ_SCSI,
680 commonExtension->LowerDeviceObject,
681 SrbControl,
682 length,
683 &startingOffset,
684 &event,
685 &ioStatus);
686
689 }
690
692
693 //
694 // Set major and minor codes.
695 //
696
698 irpStack->MinorFunction = 1;
699
700 //
701 // Fill in SRB fields.
702 //
703
706
707 //
708 // Set up STORAGE_REQUEST_BLOCK fields
709 //
710
712 srbEx->Function = SRB_FUNCTION_STORAGE_REQUEST_BLOCK;
713 srbEx->Signature = SRB_SIGNATURE;
714 srbEx->Version = STORAGE_REQUEST_BLOCK_VERSION_1;
715 srbEx->SrbLength = sizeof(srbExBuffer);
716 srbEx->SrbFunction = SRB_FUNCTION_IO_CONTROL;
719
720 srbEx->SrbFlags = FdoExtension->SrbFlags;
724
725 srbEx->RequestAttribute = SRB_SIMPLE_TAG_REQUEST;
726 srbEx->RequestTag = SP_UNTAGGED;
727
728 srbEx->OriginalRequest = irp;
729
730 //
731 // Set timeout to requested value.
732 //
733
734 srbEx->TimeOutValue = SrbControl->Timeout;
735
736 //
737 // Set the data buffer.
738 //
739
740 srbEx->DataBuffer = SrbControl;
741 srbEx->DataTransferLength = length;
742
743 //
744 // Set up address fields
745 //
746
748 storAddrBtl8->Type = STOR_ADDRESS_TYPE_BTL8;
749 storAddrBtl8->AddressLength = STOR_ADDR_BTL8_ADDRESS_LENGTH;
753
754 } else {
756
760
763
768
771
773
774 //
775 // Set timeout to requested value.
776 //
777
778 srb.TimeOutValue = SrbControl->Timeout;
779
780 //
781 // Set the data buffer.
782 //
783
784 srb.DataBuffer = SrbControl;
786 }
787
788 //
789 // Flush the data buffer for output. This will insure that the data is
790 // written back to memory. Since the data-in flag is the the port driver
791 // will flush the data again for input which will ensure the data is not
792 // in the cache.
793 //
794
796
797 //
798 // Call port driver to handle this request.
799 //
800
802
806 }
807
809}
struct _SENDCMDINPARAMS SENDCMDINPARAMS
#define CLASS_SRBEX_NO_SRBEX_DATA_BUFFER_SIZE
Definition: classpnp.h:696
struct _SCSI_REQUEST_BLOCK SCSI_REQUEST_BLOCK
Definition: shell.h:41
struct _IO_STACK_LOCATION::@3978::@4017 Others
Referenced by DiskDisableSmart(), DiskDisableSmartAttributeAutosave(), DiskEnableSmart(), DiskEnableSmartAttributeAutosave(), DiskExecuteSmartDiagnostics(), DiskReadSmartLog(), and DiskWriteSmartLog().
◆ DiskReadFailurePredictData()
| NTSTATUS DiskReadFailurePredictData | ( | PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| PSTORAGE_FAILURE_PREDICT_DATA | DiskSmartData | ||
| ) |
Definition at line 1327 of file diskwmi.c.
1349{
1353
1354 PAGED_CODE();
1355
1357 {
1359 {
1361 ULONG outBufferSize;
1362 PSENDCMDOUTPARAMS cmdOutParameters;
1363
1364 outBufferSize = sizeof(SRB_IO_CONTROL) + max( sizeof(SENDCMDINPARAMS), sizeof(SENDCMDOUTPARAMS) - 1 + READ_ATTRIBUTE_BUFFER_SIZE );
1365
1367 outBufferSize,
1368 DISK_TAG_SMART);
1369
1371 {
1374 &outBufferSize);
1375
1377 {
1380
1383 cmdOutParameters->bBuffer,
1385 }
1387 } else {
1389 }
1390
1391 break;
1392 }
1393
1395 {
1398
1400 break;
1401 }
1402
1405 default:
1406 {
1408 break;
1409 }
1410 }
1411
1413}
struct _SENDCMDOUTPARAMS * PSENDCMDOUTPARAMS
#define DiskReadSmartData(FdoExtension, SrbControl, BufferSize)
Definition: diskwmi.c:200
Referenced by DiskIoctlPredictFailure().
◆ DiskReadFailurePredictStatus()
| NTSTATUS DiskReadFailurePredictStatus | ( | PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| PSTORAGE_FAILURE_PREDICT_STATUS | DiskSmartStatus | ||
| ) |
Definition at line 1251 of file diskwmi.c.
1272{
1276
1277 PAGED_CODE();
1278
1280
1282 {
1284 {
1285 UCHAR outBuffer[sizeof(SRB_IO_CONTROL) + max( sizeof(SENDCMDINPARAMS), sizeof(SENDCMDOUTPARAMS) - 1 + sizeof(IDEREGS) )] = {0};
1287 PSENDCMDOUTPARAMS cmdOutParameters;
1288
1291 &outBufferSize);
1292
1294 {
1297
1300 (cmdOutParameters->bBuffer[4] == 0x2c));
1301 }
1302 break;
1303 }
1304
1306 {
1310 break;
1311 }
1312
1315 default:
1316 {
1318 break;
1319 }
1320 }
1321
1323}
#define DiskReadSmartStatus(FdoExtension, SrbControl, BufferSize)
Definition: diskwmi.c:236
Referenced by DiskDetectFailurePrediction(), and DiskIoctlPredictFailure().
◆ DiskReadWriteVerification()
Definition at line 546 of file disk.c.
568{
571 ULONG residualBytes;
572 ULONG residualOffset;
574
575 //
576 // Make sure that the request is within the bounds of the partition,
577 // the number of bytes to transfer and the byte offset are a
578 // multiple of the sector size.
579 //
580
581 residualBytes = irpSp->Parameters.Read.Length & (commonExtension->PartitionZeroExtension->DiskGeometry.BytesPerSector - 1);
582 residualOffset = irpSp->Parameters.Read.ByteOffset.LowPart & (commonExtension->PartitionZeroExtension->DiskGeometry.BytesPerSector - 1);
583
585 (irpSp->Parameters.Read.ByteOffset.QuadPart < 0) ||
586 (residualBytes != 0) ||
587 (residualOffset != 0))
588 {
589 NT_ASSERT(residualOffset == 0);
591 }
592 else
593 {
594 ULONGLONG bytesRemaining = commonExtension->PartitionLength.QuadPart - irpSp->Parameters.Read.ByteOffset.QuadPart;
595
597 {
599 }
600 }
601
603 {
604 //
605 // This error may be caused by the fact that the drive is not ready.
606 //
607
609
611
612 //
613 // Flag this as a user error so that a popup is generated.
614 //
615
616 TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_RW, "DiskReadWriteVerification: ReadyStatus is %lx\n", status));
617
620 }
621
622 //
623 // status will keep the current error
624 //
625
626 } else if ((residualBytes == 0) && (residualOffset == 0)) {
627
628 //
629 // This failed because we think the physical disk is too small.
630 // Send it down to the drive and let the hardware decide for
631 // itself.
632 //
633
635
636 } else {
637
638 //
639 // Note fastfat depends on this parameter to determine when to
640 // remount due to a sector size change.
641 //
642
644 }
645 }
646
648
650
651} // end DiskReadWrite()
VOID NTAPI IoSetHardErrorOrVerifyDevice(IN PIRP Irp, IN PDEVICE_OBJECT DeviceObject)
Definition: util.c:316
Referenced by DriverEntry().
◆ DiskRemoveDevice()
Definition at line 843 of file pnp.c.
865{
868
869 PAGED_CODE();
870
871 //
872 // Handle query and cancel
873 //
874
878 }
879
880 //
881 // Delete our object directory.
882 //
883
888 }
889
891
893
895
896 }
897
899
901 {
902 ClassDeleteSrbLookasideList(commonExtension);
903 }
904
906}
VOID DiskDeleteSymbolicLinks(IN PDEVICE_OBJECT DeviceObject)
Definition: pnp.c:780
#define IRP_MN_REMOVE_DEVICE
#define IRP_MN_CANCEL_REMOVE_DEVICE
#define IRP_MN_QUERY_REMOVE_DEVICE
Referenced by DriverEntry().
◆ DiskSetCacheInformation()
| NTSTATUS NTAPI DiskSetCacheInformation | ( | IN PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| IN PDISK_CACHE_INFORMATION | CacheInfo | ||
| ) |
Definition at line 3167 of file disk.c.
3190{
3191 PMODE_PARAMETER_HEADER modeData;
3193 PMODE_CACHING_PAGE pageData;
3196
3197 PAGED_CODE();
3198
3199 modeData = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
3200 MODE_DATA_SIZE,
3201 DISK_TAG_DISABLE_CACHE);
3202
3204
3205 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskSetCacheInformation: Unable to allocate mode "
3206 "data buffer\n"));
3208 }
3209
3211
3213 (PCHAR) modeData,
3214 MODE_DATA_SIZE,
3215 MODE_PAGE_CACHING);
3216
3218
3219 //
3220 // Retry the request in case of a check condition.
3221 //
3222
3224 (PCHAR) modeData,
3225 MODE_DATA_SIZE,
3226 MODE_PAGE_CACHING);
3227
3229
3230 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "DiskSetCacheInformation: Mode Sense failed\n"));
3231
3232 FREE_POOL(modeData);
3234 }
3235 }
3236
3237 //
3238 // If the length is greater than length indicated by the mode data reset
3239 // the data to the mode data.
3240 //
3241
3244 }
3245
3246 //
3247 // Check to see if the write cache is enabled.
3248 //
3249
3251 length,
3252 MODE_PAGE_CACHING,
3253 TRUE);
3254
3255 //
3256 // Check if valid caching page exists.
3257 //
3258
3260 FREE_POOL(modeData);
3262 }
3263
3264 //
3265 // Don't touch any of the normal parameters - not all drives actually
3266 // use the correct size of caching mode page. Just change the things
3267 // which the user could have modified.
3268 //
3269
3271
3272 pageData->ReadDisableCache = !(CacheInfo->ReadCacheEnabled);
3273 pageData->MultiplicationFactor = CacheInfo->PrefetchScalar;
3274 pageData->WriteCacheEnable = CacheInfo->WriteCacheEnabled;
3275
3277 TRANSLATE_RETENTION_PRIORITY(CacheInfo->WriteRetentionPriority);
3279 TRANSLATE_RETENTION_PRIORITY(CacheInfo->ReadRetentionPriority);
3280
3281 pageData->DisablePrefetchTransfer[0] =
3282 (UCHAR) (CacheInfo->DisablePrefetchTransferLength >> 8);
3283 pageData->DisablePrefetchTransfer[1] =
3284 (UCHAR) (CacheInfo->DisablePrefetchTransferLength & 0x00ff);
3285
3286 pageData->MinimumPrefetch[0] =
3287 (UCHAR) (CacheInfo->ScalarPrefetch.Minimum >> 8);
3288 pageData->MinimumPrefetch[1] =
3289 (UCHAR) (CacheInfo->ScalarPrefetch.Minimum & 0x00ff);
3290
3291 pageData->MaximumPrefetch[0] =
3292 (UCHAR) (CacheInfo->ScalarPrefetch.Maximum >> 8);
3293 pageData->MaximumPrefetch[1] =
3294 (UCHAR) (CacheInfo->ScalarPrefetch.Maximum & 0x00ff);
3295
3297
3298 pageData->MaximumPrefetchCeiling[0] =
3299 (UCHAR) (CacheInfo->ScalarPrefetch.MaximumBlocks >> 8);
3300 pageData->MaximumPrefetchCeiling[1] =
3301 (UCHAR) (CacheInfo->ScalarPrefetch.MaximumBlocks & 0x00ff);
3302 }
3303
3304 //
3305 // We will attempt (twice) to issue the mode select with the page.
3306 //
3307
3309
3311 (PCHAR) pageData,
3312 (pageData->PageLength + 2),
3313 CacheInfo->ParametersSavable);
3314
3316
3317 if (CacheInfo->WriteCacheEnabled)
3318 {
3320 }
3321 else
3322 {
3324 }
3326
3327 break;
3328 }
3329 }
3330
3332 {
3333 } else {
3334
3335 //
3336 // We were unable to modify the disk write cache setting
3337 //
3338
3340 }
3341
3342 FREE_POOL(modeData);
3344}
NTSTATUS DiskModeSelect(IN PDEVICE_OBJECT Fdo, _In_reads_bytes_(Length) PCHAR ModeSelectBuffer, IN ULONG Length, IN BOOLEAN SavePage)
Definition: disk.c:1802
Referenced by DiskIoctlSetCacheInformation(), and DiskStartFdo().
◆ DiskSetInfoExceptionInformation()
| NTSTATUS DiskSetInfoExceptionInformation | ( | IN PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| IN PMODE_INFO_EXCEPTIONS | PageData | ||
| ) |
Definition at line 2985 of file disk.c.
2990{
2993
2994 PAGED_CODE();
2995
2996 //
2997 // We will attempt (twice) to issue the mode select with the page.
2998 // Make the setting persistant so that we don't have to turn it back
2999 // on after a bus reset.
3000 //
3001
3003 {
3005 (PCHAR) PageData,
3007 TRUE);
3008 }
3009
3010 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "DiskSetInfoExceptionInformation: %s for device %p\n",
3012 FdoExtension->DeviceObject));
3013
3015}
Referenced by DiskFdoExecuteWmiMethod(), and DiskFdoSetWmiDataBlock().
◆ DiskSetSpecialHacks()
Definition at line 2602 of file disk.c.
2628{
2630
2631 PAGED_CODE();
2632
2633 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT, "Disk SetSpecialHacks, Setting Hacks %p\n", (void*) Data));
2634
2635 //
2636 // Found a listed controller. Determine what must be done.
2637 //
2638
2640
2641 //
2642 // Disable tagged queuing.
2643 //
2644
2646 }
2647
2649
2650 //
2651 // Disable synchronous data transfers.
2652 //
2653
2655
2656 }
2657
2659
2660 //
2661 // Disable spinning down of drives.
2662 //
2663
2666
2667 }
2668
2670
2671 //
2672 // Disable the drive's write cache
2673 //
2674
2677
2678 }
2679
2681
2684 }
2685
2688 ) {
2689
2690 //
2691 // this is a list of vendors who require the START_UNIT command
2692 //
2693
2694 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT, "DiskScanForSpecial (%p) => This unit requires "
2695 " START_UNITS\n", fdo));
2697
2698 }
2699
2700 return;
2701}
#define CLASS_SPECIAL_DISABLE_WRITE_CACHE
Definition: classpnp.h:168
#define CLASS_SPECIAL_CAUSE_NOT_REPORTABLE_HACK
Definition: scsi_port.h:175
Definition: sort_test.cpp:77
Referenced by DiskInitFdo().
◆ DiskShutdownFlush()
Definition at line 1122 of file disk.c.
1150{
1154 PIO_STACK_LOCATION irpStack;
1156 ULONG srbSize;
1157 PSCSI_REQUEST_BLOCK srb;
1161 PCDB cdb;
1163
1164 //
1165 // Flush requests are combined and need to be handled in a special manner
1166 //
1167
1169
1171
1173
1174 //
1175 // We've been assured that both the disk
1176 // and adapter caches are battery-backed
1177 //
1178
1183 }
1184
1186
1187 TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_SCSI, "DiskShutdownFlush: IRP %p flags = 0x%x\n", Irp, irpStack->Flags));
1188
1189 //
1190 // This request will most likely be completed asynchronously
1191 //
1193
1194 //
1195 // Look to see if a flush is in progress
1196 //
1197
1199
1200 //
1201 // There is an outstanding flush. Queue this
1202 // request to the group that is next in line
1203 //
1204
1206
1207 #if DBG
1208 diskData->FlushContext.DbgTagCount++;
1209 #endif
1210
1212
1214
1215 //
1216 // This request will be completed by its representative
1217 //
1218
1219 } else {
1220
1221 #if DBG
1223
1225 }
1226
1228 diskData->FlushContext.DbgTagCount = 0;
1229 #endif
1230
1233
1234
1236
1237
1239
1240 //
1241 // Wait for the outstanding flush to complete
1242 //
1244
1246
1247 //
1248 // Make this group the outstanding one and free up the next slot
1249 //
1250
1252
1254
1256
1259 }
1260
1261#ifndef __REACTOS__
1262 // ReactOS hits this assert, because CurrIrp can already be freed at this point
1263 // and it's possible that NextIrp has the same pointer value
1265#endif
1268
1270
1271 //
1272 // Send this request down to the device
1273 //
1275 }
1276
1277 } else {
1278
1281
1284
1285
1287
1289 }
1290
1291 } else {
1292
1293 //
1294 // Allocate SCSI request block.
1295 //
1296
1298 srbSize = CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE;
1299 } else {
1301 }
1302
1303 srb = ExAllocatePoolWithTag(NonPagedPoolNx,
1304 srbSize,
1305 DISK_TAG_SRB);
1307
1308 //
1309 // Set the status and complete the request.
1310 //
1311
1316 }
1317
1318 RtlZeroMemory(srb, srbSize);
1320
1321 srbEx = (PSTORAGE_REQUEST_BLOCK)srb;
1322
1323 //
1324 // Set up STORAGE_REQUEST_BLOCK fields
1325 //
1326
1328 srbEx->Function = SRB_FUNCTION_STORAGE_REQUEST_BLOCK;
1329 srbEx->Signature = SRB_SIGNATURE;
1330 srbEx->Version = STORAGE_REQUEST_BLOCK_VERSION_1;
1331 srbEx->SrbLength = srbSize;
1332 srbEx->SrbFunction = SRB_FUNCTION_EXECUTE_SCSI;
1335 srbEx->NumSrbExData = 1;
1336
1337 // Set timeout value and mark the request as not being a tagged request.
1338 srbEx->TimeOutValue = fdoExtension->TimeOutValue * 4;
1339 srbEx->RequestTag = SP_UNTAGGED;
1340 srbEx->RequestAttribute = SRB_SIMPLE_TAG_REQUEST;
1341 srbEx->SrbFlags = fdoExtension->SrbFlags;
1342
1343 //
1344 // Set up address fields
1345 //
1346
1348 storAddrBtl8->Type = STOR_ADDRESS_TYPE_BTL8;
1349 storAddrBtl8->AddressLength = STOR_ADDR_BTL8_ADDRESS_LENGTH;
1350
1351 //
1352 // Set up SCSI SRB extended data fields
1353 //
1354
1359 srbExDataCdb16->Type = SrbExDataTypeScsiCdb16;
1360 srbExDataCdb16->Length = SRBEX_DATA_SCSI_CDB16_LENGTH;
1361
1362 cdb = (PCDB)srbExDataCdb16->Cdb;
1363 } else {
1364 // Should not happen
1366
1367 //
1368 // Set the status and complete the request.
1369 //
1370
1375 }
1376
1377 } else {
1378
1379 //
1380 // Write length to SRB.
1381 //
1382
1383 srb->Length = SCSI_REQUEST_BLOCK_SIZE;
1384
1385 //
1386 // Set timeout value and mark the request as not being a tagged request.
1387 //
1388
1389 srb->TimeOutValue = fdoExtension->TimeOutValue * 4;
1390 srb->QueueTag = SP_UNTAGGED;
1391 srb->QueueAction = SRB_SIMPLE_TAG_REQUEST;
1392 srb->SrbFlags = fdoExtension->SrbFlags;
1393 srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
1394
1395 cdb = (PCDB)srb->Cdb;
1396 }
1397
1398 //
1399 // If the write cache is enabled then send a synchronize cache request.
1400 //
1401
1403
1405 srbExDataCdb16->CdbLength = 10;
1406 } else {
1407 srb->CdbLength = 10;
1408 }
1409
1410 cdb->CDB10.OperationCode = SCSIOP_SYNCHRONIZE_CACHE;
1411
1413 srb,
1414 NULL,
1415 0,
1416 TRUE);
1417
1418 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL, "DiskShutdownFlush: Synchonize cache sent. Status = %lx\n", status));
1419 }
1420
1421 //
1422 // Unlock the device if it contains removable media
1423 //
1424
1426 {
1427
1429
1430 //
1431 // Reinitialize status fields to 0 in case there was a previous request
1432 //
1433
1434 srbEx->SrbStatus = 0;
1435 srbExDataCdb16->ScsiStatus = 0;
1436
1437 srbExDataCdb16->CdbLength = 6;
1438
1439 //
1440 // Set timeout value
1441 //
1442
1443 srbEx->TimeOutValue = fdoExtension->TimeOutValue;
1444
1445 } else {
1446
1447 //
1448 // Reinitialize status fields to 0 in case there was a previous request
1449 //
1450
1451 srb->SrbStatus = 0;
1452 srb->ScsiStatus = 0;
1453
1454 srb->CdbLength = 6;
1455
1456 //
1457 // Set timeout value.
1458 //
1459
1460 srb->TimeOutValue = fdoExtension->TimeOutValue;
1461 }
1462
1463 cdb->MEDIA_REMOVAL.OperationCode = SCSIOP_MEDIUM_REMOVAL;
1464 cdb->MEDIA_REMOVAL.Prevent = FALSE;
1465
1467 srb,
1468 NULL,
1469 0,
1470 TRUE);
1471
1472 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL, "DiskShutdownFlush: Unlock device request sent. Status = %lx\n", status));
1473 }
1474
1475 //
1476 // Set up a SHUTDOWN SRB
1477 //
1478
1480 srbEx->NumSrbExData = 0;
1481 srbEx->SrbExDataOffset[0] = 0;
1482 srbEx->SrbFunction = SRB_FUNCTION_SHUTDOWN;
1483 srbEx->OriginalRequest = Irp;
1484 srbEx->SrbLength = CLASS_SRBEX_NO_SRBEX_DATA_BUFFER_SIZE;
1485 srbEx->SrbStatus = 0;
1486 } else {
1487 srb->CdbLength = 0;
1488 srb->Function = SRB_FUNCTION_SHUTDOWN;
1489 srb->SrbStatus = 0;
1490 srb->OriginalRequest = Irp;
1491 }
1492
1493 //
1494 // Set the retry count to zero.
1495 //
1496
1497 irpStack->Parameters.Others.Argument4 = (PVOID) 0;
1498
1499 //
1500 // Set up IoCompletion routine address.
1501 //
1502
1504
1505 //
1506 // Get next stack location and
1507 // set major function code.
1508 //
1509
1511
1512 irpStack->MajorFunction = IRP_MJ_SCSI;
1513
1514 //
1515 // Set up SRB for execute scsi request.
1516 // Save SRB address in next stack for port driver.
1517 //
1518
1519 irpStack->Parameters.Scsi.Srb = srb;
1520
1521 //
1522 // Call the port driver to process the request.
1523 //
1524
1527 }
1528
1530}
NTSTATUS NTAPI ClassIoComplete(IN PDEVICE_OBJECT Fdo, IN PIRP Irp, IN PVOID Context)
Definition: class.c:3768
VOID NTAPI ClassCompleteRequest(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_ CCHAR PriorityBoost)
Definition: lock.c:401
VOID NTAPI ClassReleaseRemoveLock(_In_ PDEVICE_OBJECT DeviceObject, _In_opt_ PIRP Tag)
Definition: lock.c:251
VOID DiskFlushDispatch(IN PDEVICE_OBJECT Fdo, IN PDISK_GROUP_CONTEXT FlushContext)
Definition: disk.c:1534
Definition: typedefs.h:120
#define IRP_MJ_FLUSH_BUFFERS
Referenced by DriverEntry().
◆ DiskStartFdo()
| NTSTATUS NTAPI DiskStartFdo | ( | IN PDEVICE_OBJECT | Fdo | ) |
Definition at line 911 of file pnp.c.
939{
943 STORAGE_HOTPLUG_INFO hotplugInfo = { 0 };
944 DISK_CACHE_INFORMATION cacheInfo = { 0 };
945 ULONG isPowerProtected = 0;
947
948 PAGED_CODE();
949
950 //
951 // Get the hotplug information, so we can turn off write cache if needed
952 //
953 // NOTE: Capabilities info is not good enough to determine hotplugedness
954 // as we cannot determine device relations information and other
955 // dependencies. Get the hotplug info instead
956 //
957
958 {
961 IO_STATUS_BLOCK statusBlock = { 0 };
962
964
966 Fdo,
967 NULL,
968 0L,
969 &hotplugInfo,
971 FALSE,
972 &event,
973 &statusBlock);
974
976
977 // send to self -- classpnp handles this
981 Executive,
982 KernelMode,
983 FALSE,
984 NULL);
985
987 }
989 }
990 }
991
992 //
993 // Clear the DEV_WRITE_CACHE flag now and set
994 // it below only if we read that from the disk
995 //
997 ADJUST_FUA_FLAG(fdoExtension);
998
1000
1001 //
1002 // Look into the registry to see if the user
1003 // has chosen to override the default setting
1004 //
1005 ClassGetDeviceParameter(fdoExtension,
1009
1011 {
1012 //
1013 // The user has not overridden the default settings
1014 //
1016 {
1017 //
1018 // This flag indicates that we have faulty firmware and this
1019 // may cause the filesystem to refuse to mount on this media
1020 //
1021 TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_PNP, "DiskStartFdo: Turning off write cache for %p due to a firmware issue\n", Fdo));
1022
1024 }
1026 {
1027 //
1028 // This flag indicates that the device is hotpluggable making it unsafe to enable caching
1029 //
1030 TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_PNP, "DiskStartFdo: Turning off write cache for %p due to hotpluggable device\n", Fdo));
1031
1033 }
1035 {
1036 //
1037 // This flag indicates that the media in the device cannot be reliably locked
1038 //
1039 TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_PNP, "DiskStartFdo: Turning off write cache for %p due to unlockable media\n", Fdo));
1040
1042 }
1043 else
1044 {
1045 //
1046 // Even though the device does not seem to have any obvious problems
1047 // we leave it to the user to modify the previous write cache setting
1048 //
1049 }
1050 }
1051
1052 //
1053 // Query the disk to see if write cache is enabled
1054 // and set the DEV_WRITE_CACHE flag appropriately
1055 //
1056
1058
1060 {
1062 {
1064 ADJUST_FUA_FLAG(fdoExtension);
1065
1067 {
1068 //
1069 // Write cache is currently enabled on this
1070 // device, but we would like to turn it off
1071 //
1073
1074 DiskSetCacheInformation(fdoExtension, &cacheInfo);
1075 }
1076 }
1077 else
1078 {
1080 {
1081 //
1082 // Write cache is currently disabled on this
1083 // device, but we would like to turn it on
1084 //
1086
1087 DiskSetCacheInformation(fdoExtension, &cacheInfo);
1088 }
1089 }
1090 }
1091
1092 //
1093 // Query the registry to see if this disk is power-protected or not
1094 //
1095
1097
1098 ClassGetDeviceParameter(fdoExtension, DiskDeviceParameterSubkey, DiskDeviceCacheIsPowerProtected, &isPowerProtected);
1099
1100 if (isPowerProtected == 1)
1101 {
1103 }
1104
1105 ADJUST_FUA_FLAG(fdoExtension);
1106
1108
1109} // end DiskStartFdo()
Definition: imports.h:244
BOOLEAN WriteCacheEnableOverride
Definition: imports.h:249
Referenced by DriverEntry().
◆ DiskStopDevice()
◆ DiskUnload()
| VOID NTAPI DiskUnload | ( | IN PDRIVER_OBJECT | DriverObject | ) |
Definition at line 281 of file disk.c.
284{
285 PAGED_CODE();
286
287#if defined(_X86_) || defined(_AMD64_)
288 DiskCleanupDetectInfo(DriverObject);
289#else
290 // NB: Need to use UNREFERENCED_PARAMETER to prevent build error
291 // DriverObject is not referenced below in WPP_CLEANUP.
292 // WPP_CLEANUP is currently an "NOOP" marco.
294#endif
295
296
297 //
298 // Cleans up tracing
299 //
301
302 return;
303}
Referenced by DriverEntry().
◆ DiskWmiFunctionControl()
| NTSTATUS NTAPI DiskWmiFunctionControl | ( | IN PDEVICE_OBJECT | DeviceObject, |
| IN PIRP | Irp, | ||
| IN ULONG | GuidIndex, | ||
| IN CLASSENABLEDISABLEFUNCTION | Function, | ||
| IN BOOLEAN | Enable | ||
| ) |
Definition at line 2366 of file diskwmi.c.
2412{
2415
2416 PAGED_CODE();
2417
2419 {
2424 {
2426 TRUE);
2427 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "Disk: DeviceObject %p, Irp %p Enable -> %lx\n",
2428 DeviceObject,
2429 Irp,
2430 status));
2431
2432 } else {
2433 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "Disk: DeviceObject %p, Irp %p, GuidIndex %d %s for Collection\n",
2435 GuidIndex,
2437 }
2439 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "Disk: DeviceObject %p, Irp %p, GuidIndex %d %s for Event Generation\n",
2441 GuidIndex,
2443
2444
2446 {
2448 Enable,
2449 0);
2450 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "Disk: DeviceObject %p, Irp %p %s -> %lx\n",
2451 DeviceObject,
2452 Irp,
2454 status));
2455 }
2456
2457#if DBG
2458 } else {
2459 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_WMI, "Disk: DeviceObject %p, Irp %p, GuidIndex %d %s for function %d\n",
2461 GuidIndex,
2463 Function));
2464#endif
2465 }
2466
2468 Irp,
2469 status,
2470 0,
2471 IO_NO_INCREMENT);
2473}
_In_ CDROM_SCAN_FOR_SPECIAL_INFO _In_ PCDROM_SCAN_FOR_SPECIAL_HANDLER Function
Definition: cdrom.h:1156
Referenced by DriverEntry().
◆ GetSrbScsiData()
| FORCEINLINE PCDB GetSrbScsiData | ( | _In_ PSTORAGE_REQUEST_BLOCK | SrbEx, |
| _In_opt_ PUCHAR | CdbLength8, | ||
| _In_opt_ PULONG | CdbLength32, | ||
| _In_opt_ PUCHAR | ScsiStatus, | ||
| _In_opt_ PVOID * | SenseInfoBuffer, | ||
| _In_opt_ PUCHAR | SenseInfoBufferLength | ||
| ) |
Definition at line 994 of file disk.h.
1030{
1035
1037 (SrbEx->SrbFunction == SRB_FUNCTION_EXECUTE_SCSI)) {
1038 NT_ASSERT(SrbEx->NumSrbExData > 0);
1039
1041
1042 // Skip any invalid offsets
1044 (SrbEx->SrbExDataOffset[i] > SrbEx->SrbLength)){
1045 // Catch any invalid offsets
1047 continue;
1048 }
1049
1051
1052 switch (SrbExData->Type) {
1053
1056 FoundEntry = TRUE;
1057 if (CdbLength8) {
1058 *CdbLength8 = ((PSRBEX_DATA_SCSI_CDB16) SrbExData)->CdbLength;
1059 }
1060
1063 }
1064
1065 if (ScsiStatus) {
1066 *ScsiStatus =
1067 ((PSRBEX_DATA_SCSI_CDB16) SrbExData)->ScsiStatus;
1068 }
1069
1070 if (SenseInfoBuffer) {
1071 *SenseInfoBuffer =
1072 ((PSRBEX_DATA_SCSI_CDB16) SrbExData)->SenseInfoBuffer;
1073 }
1074
1076 *SenseInfoBufferLength =
1077 ((PSRBEX_DATA_SCSI_CDB16) SrbExData)->SenseInfoBufferLength;
1078 }
1079
1080 } else {
1081 // Catch invalid offset
1083 }
1084 break;
1085
1088 FoundEntry = TRUE;
1089 if (CdbLength8) {
1090 *CdbLength8 = ((PSRBEX_DATA_SCSI_CDB32) SrbExData)->CdbLength;
1091 }
1092
1095 }
1096
1097 if (ScsiStatus) {
1098 *ScsiStatus =
1099 ((PSRBEX_DATA_SCSI_CDB32) SrbExData)->ScsiStatus;
1100 }
1101
1102 if (SenseInfoBuffer) {
1103 *SenseInfoBuffer =
1104 ((PSRBEX_DATA_SCSI_CDB32) SrbExData)->SenseInfoBuffer;
1105 }
1106
1108 *SenseInfoBufferLength =
1109 ((PSRBEX_DATA_SCSI_CDB32) SrbExData)->SenseInfoBufferLength;
1110 }
1111
1112 } else {
1113 // Catch invalid offset
1115 }
1116 break;
1117
1120 FoundEntry = TRUE;
1121 if (CdbLength32) {
1122 *CdbLength32 = ((PSRBEX_DATA_SCSI_CDB_VAR) SrbExData)->CdbLength;
1123 }
1124
1127 }
1128
1129 if (ScsiStatus) {
1130 *ScsiStatus =
1131 ((PSRBEX_DATA_SCSI_CDB_VAR) SrbExData)->ScsiStatus;
1132 }
1133
1134 if (SenseInfoBuffer) {
1135 *SenseInfoBuffer =
1136 ((PSRBEX_DATA_SCSI_CDB_VAR) SrbExData)->SenseInfoBuffer;
1137 }
1138
1140 *SenseInfoBufferLength =
1141 ((PSRBEX_DATA_SCSI_CDB_VAR) SrbExData)->SenseInfoBufferLength;
1142 }
1143
1144 } else {
1145 // Catch invalid offset
1147 }
1148 break;
1149 }
1150
1151 if (FoundEntry) {
1152 break;
1153 }
1154 }
1155
1156 } else {
1157
1158 if (CdbLength8) {
1159 *CdbLength8 = 0;
1160 }
1161
1162 if (CdbLength32) {
1163 *CdbLength32 = 0;
1164 }
1165
1166 if (ScsiStatus) {
1167 *ScsiStatus = 0;
1168 }
1169
1170 if (SenseInfoBuffer) {
1171 *SenseInfoBuffer = NULL;
1172 }
1173
1175 *SenseInfoBufferLength = 0;
1176 }
1177 }
1178
1180}
struct SRB_ALIGN _SRBEX_DATA_SCSI_CDB_VAR SRBEX_DATA_SCSI_CDB_VAR
struct SRB_ALIGN _SRBEX_DATA_SCSI_CDB_VAR * PSRBEX_DATA_SCSI_CDB_VAR
struct SRB_ALIGN _SRBEX_DATA * PSRBEX_DATA
struct SRB_ALIGN _SRBEX_DATA_SCSI_CDB32 * PSRBEX_DATA_SCSI_CDB32
struct SRB_ALIGN _SRBEX_DATA_SCSI_CDB32 SRBEX_DATA_SCSI_CDB32
Referenced by DiskFdoProcessError(), and DiskInfoExceptionComplete().
◆ ResetBus()
| VOID ResetBus | ( | IN PDEVICE_OBJECT | DeviceObject | ) |
Definition at line 2705 of file disk.c.
2725{
2726 PIO_STACK_LOCATION irpStack;
2728
2730 PSCSI_REQUEST_BLOCK srb;
2734
2735 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL, "Disk ResetBus: Sending reset bus request to port driver.\n"));
2736
2737 //
2738 // Allocate Srb from nonpaged pool.
2739 //
2740
2743 DISK_TAG_CCONTEXT);
2744
2746 return;
2747 }
2748
2749 //
2750 // Save the device object in the context for use by the completion
2751 // routine.
2752 //
2753
2755 srb = &context->Srb.Srb;
2756
2758 srbEx = &context->Srb.SrbEx;
2759
2760 //
2761 // Zero out srb
2762 //
2763
2765
2766 //
2767 // Set up STORAGE_REQUEST_BLOCK fields
2768 //
2769
2771 srbEx->Function = SRB_FUNCTION_STORAGE_REQUEST_BLOCK;
2772 srbEx->Signature = SRB_SIGNATURE;
2773 srbEx->Version = STORAGE_REQUEST_BLOCK_VERSION_1;
2775 srbEx->SrbFunction = SRB_FUNCTION_RESET_BUS;
2777
2778 //
2779 // Set up address fields
2780 //
2781
2783 storAddrBtl8->Type = STOR_ADDRESS_TYPE_BTL8;
2784 storAddrBtl8->AddressLength = STOR_ADDR_BTL8_ADDRESS_LENGTH;
2785
2786 } else {
2787
2788 //
2789 // Zero out srb.
2790 //
2791
2793
2794 //
2795 // Write length to SRB.
2796 //
2797
2799
2801
2802 }
2803
2804 //
2805 // Build the asynchronous request to be sent to the port driver.
2806 // Since this routine is called from a DPC the IRP should always be
2807 // available.
2808 //
2809
2811
2814 return;
2815 }
2816
2818
2821 context,
2822 TRUE,
2823 TRUE,
2824 TRUE);
2825
2827
2829
2832 srbEx->OriginalRequest = irp;
2833 } else {
2835 }
2836
2837 //
2838 // Store the SRB address in next stack for port driver.
2839 //
2840
2842
2843 //
2844 // Call the port driver with the IRP.
2845 //
2846
2848
2849 return;
2850
2851} // end ResetBus()
NTSTATUS NTAPI ClassAsynchronousCompletion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
Definition: class.c:3246
PIRP NTAPI IoAllocateIrp(IN CCHAR StackSize, IN BOOLEAN ChargeQuota)
Definition: irp.c:615
Definition: cdrom.h:673
struct _IO_STACK_LOCATION::@3978::@4000 Scsi
Definition: http.c:7252
Referenced by DiskFdoProcessError().
◆ SetSrbScsiData()
| FORCEINLINE VOID SetSrbScsiData | ( | _In_ PSTORAGE_REQUEST_BLOCK | SrbEx, |
| _In_ UCHAR | CdbLength8, | ||
| _In_ ULONG | CdbLength32, | ||
| _In_ UCHAR | ScsiStatus, | ||
| _In_opt_ PVOID | SenseInfoBuffer, | ||
| _In_ UCHAR | SenseInfoBufferLength | ||
| ) |
Definition at line 1184 of file disk.h.
1220{
1224
1226 (SrbEx->SrbFunction == SRB_FUNCTION_EXECUTE_SCSI)) {
1227 NT_ASSERT(SrbEx->NumSrbExData > 0);
1228
1230
1231 // Skip any invalid offsets
1233 (SrbEx->SrbExDataOffset[i] > SrbEx->SrbLength)){
1234 // Catch any invalid offsets
1236 continue;
1237 }
1238
1240
1241 switch (SrbExData->Type) {
1242
1245 FoundEntry = TRUE;
1246 ((PSRBEX_DATA_SCSI_CDB16) SrbExData)->CdbLength = CdbLength8;
1247 ((PSRBEX_DATA_SCSI_CDB16) SrbExData)->ScsiStatus = ScsiStatus;
1248 ((PSRBEX_DATA_SCSI_CDB16) SrbExData)->SenseInfoBuffer = SenseInfoBuffer;
1250 } else {
1251 // Catch invalid offset
1253 }
1254 break;
1255
1258 FoundEntry = TRUE;
1259 ((PSRBEX_DATA_SCSI_CDB32) SrbExData)->CdbLength = CdbLength8;
1260 ((PSRBEX_DATA_SCSI_CDB32) SrbExData)->ScsiStatus = ScsiStatus;
1261 ((PSRBEX_DATA_SCSI_CDB32) SrbExData)->SenseInfoBuffer = SenseInfoBuffer;
1263 } else {
1264 // Catch invalid offset
1266 }
1267 break;
1268
1271 FoundEntry = TRUE;
1272 ((PSRBEX_DATA_SCSI_CDB_VAR) SrbExData)->CdbLength = CdbLength32;
1273 ((PSRBEX_DATA_SCSI_CDB_VAR) SrbExData)->ScsiStatus = ScsiStatus;
1274 ((PSRBEX_DATA_SCSI_CDB_VAR) SrbExData)->SenseInfoBuffer = SenseInfoBuffer;
1276 } else {
1277 // Catch invalid offset
1279 }
1280 break;
1281 }
1282
1283 if (FoundEntry) {
1284 break;
1285 }
1286 }
1287
1288 }
1289
1290 return;
1291}
Referenced by DiskInfoExceptionComplete().
Variable Documentation
◆ DisableWriteCache
| IO_WORKITEM_ROUTINE DisableWriteCache |
Definition at line 589 of file disk.h.
Referenced by DiskFdoProcessError().
◆ DiskBadControllers
|
extern |
Definition at line 42 of file data.c.
Referenced by DiskInitFdo().
◆ DiskFlushComplete
| IO_COMPLETION_ROUTINE DiskFlushComplete |
Definition at line 599 of file disk.h.
Referenced by DiskFlushDispatch().
◆ DiskIoctlVerifyThread
| IO_WORKITEM_ROUTINE DiskIoctlVerifyThread |
Definition at line 591 of file disk.h.
Referenced by DiskIoctlVerify().
◆ DiskMediaTypes
|
extern |
Definition at line 82 of file data.c.
Referenced by DiskDetermineMediaTypes().
◆ DiskMediaTypesExclude
|
extern |
Definition at line 74 of file data.c.
Referenced by DiskDetermineMediaTypes().
◆ DiskWmiFdoGuidList
|
extern |
Definition at line 92 of file diskwmi.c.
Referenced by DiskFdoQueryWmiRegInfo(), and DriverEntry().
