#include <stddef.h>#include <stdarg.h>#include <stdlib.h>#include <ntddk.h>#include <scsi.h>#include <wmidata.h>#include <classpnp.h>#include <storduid.h>#include <mountdev.h>#include <ioevent.h>#include <ntstrsafe.h>#include <ntintsafe.h>#include <wdmguid.h>#include <ntpoapi.h>#include <srbhelper.h>#include <storswtr.h>
Include dependency graph for classp.h:
This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Classes | |
| struct | _MEDIA_CHANGE_DETECTION_INFO |
| struct | _FAILURE_PREDICTION_INFO |
| struct | _CLASS_RETRY_INFO |
| struct | _CSCAN_LIST |
| struct | _CLASS_ERROR_LOG_DATA |
| struct | _TRANSFER_PACKET |
| struct | _PNL_SLIST_HEADER |
| struct | _CLASS_PRIVATE_FDO_DATA |
| struct | _CLASS_PRIVATE_COMMON_DATA |
| struct | _IDLE_POWER_FDO_LIST_ENTRY |
| struct | _OFFLOAD_READ_CONTEXT |
| struct | _OFFLOAD_WRITE_CONTEXT |
| struct | _OPCODE_SENSE_DATA_IO_LOG_MESSAGE_CONTEXT_HEADER |
| struct | _IO_RETRIED_LOG_MESSAGE_CONTEXT |
Enumerations | |
| enum | MEDIA_LOCK_TYPE { SimpleMediaLock , SecureMediaLock , InternalMediaLock , SimpleMediaLock , SecureMediaLock , InternalMediaLock } |
| enum | _CLASS_DETECTION_STATE { ClassDetectionUnknown = 0 , ClassDetectionUnsupported = 1 , ClassDetectionSupported = 2 } |
Macro Definition Documentation
◆ Add2Ptr
◆ CLASS_ERROR_LEVEL_1
◆ CLASS_ERROR_LEVEL_2
◆ CLASS_FILE_OBJECT_EXTENSION_KEY
◆ CLASS_IDLE_INTERVAL
◆ CLASS_IDLE_INTERVAL_MIN
◆ CLASS_MAX_INTERLEAVE_PER_CRITICAL_IO
◆ CLASS_PERF_RESTORE_MINIMUM
◆ CLASS_STARVATION_INTERVAL
◆ CLASS_TAG_PRIVATE_DATA
◆ CLASS_TAG_SENSE2
◆ CLASS_TAG_WORKING_SET
◆ CLASSP_REG_ACCESS_ALIGNMENT_NOT_SUPPORTED
| #define CLASSP_REG_ACCESS_ALIGNMENT_NOT_SUPPORTED (L"AccessAlignmentQueryNotSupported") |
◆ CLASSP_REG_COPY_OFFLOAD_MAX_TARGET_DURATION
| #define CLASSP_REG_COPY_OFFLOAD_MAX_TARGET_DURATION (L"CopyOffloadMaxTargetDuration") |
◆ CLASSP_REG_DISABLE_D3COLD
◆ CLASSP_REG_DISBALE_IDLE_POWER_NAME
| #define CLASSP_REG_DISBALE_IDLE_POWER_NAME (L"DisableIdlePowerManagement") |
◆ CLASSP_REG_HACK_VALUE_NAME
◆ CLASSP_REG_IDLE_ACTIVE_MAX
| #define CLASSP_REG_IDLE_ACTIVE_MAX (L"IdleOutstandingIoMax") |
◆ CLASSP_REG_IDLE_INTERVAL_NAME
◆ CLASSP_REG_IDLE_PRIORITY_SUPPORTED
| #define CLASSP_REG_IDLE_PRIORITY_SUPPORTED (L"IdlePrioritySupported") |
◆ CLASSP_REG_IDLE_TIMEOUT_IN_SECONDS
| #define CLASSP_REG_IDLE_TIMEOUT_IN_SECONDS (L"IdleTimeoutInSeconds") |
◆ CLASSP_REG_LEGACY_ERROR_HANDLING
| #define CLASSP_REG_LEGACY_ERROR_HANDLING (L"LegacyErrorHandling") |
◆ CLASSP_REG_MMC_DETECTION_VALUE_NAME
| #define CLASSP_REG_MMC_DETECTION_VALUE_NAME (L"MMCDetectionState") |
◆ CLASSP_REG_PERF_RESTORE_VALUE_NAME
| #define CLASSP_REG_PERF_RESTORE_VALUE_NAME (L"RestorePerfAtCount") |
◆ CLASSP_REG_QERR_OVERRIDE_MODE
| #define CLASSP_REG_QERR_OVERRIDE_MODE (L"QERROverrideMode") |
◆ CLASSP_REG_REMOVAL_POLICY_VALUE_NAME
| #define CLASSP_REG_REMOVAL_POLICY_VALUE_NAME (L"UserRemovalPolicy") |
◆ CLASSP_REG_SUBKEY_NAME
◆ CLASSP_REG_WRITE_CACHE_VALUE_NAME
| #define CLASSP_REG_WRITE_CACHE_VALUE_NAME (L"WriteCacheEnableOverride") |
◆ CLASSP_VOLUME_VERIFY_CHECKED
◆ CLASSPNP_POOL_TAG_ADDITIONAL_DATA
◆ CLASSPNP_POOL_TAG_FIRMWARE
◆ CLASSPNP_POOL_TAG_GENERIC
◆ CLASSPNP_POOL_TAG_LOG_MESSAGE
◆ CLASSPNP_POOL_TAG_SRB
◆ CLASSPNP_POOL_TAG_TOKEN_OPERATION
◆ CLASSPNP_POOL_TAG_VPD
◆ CONST_MSECS_PER_SEC
◆ Convert100nsToMilliseconds
| #define Convert100nsToMilliseconds | ( | LARGE_INTEGER | ) |
Value:
◆ ConvertMillisecondsTo100ns
| #define ConvertMillisecondsTo100ns | ( | MILLISECONDS | ) |
Value:
◆ DBG_NUM_PACKET_LOG_ENTRIES
◆ DEBUG_COMP_ID
| #define DEBUG_COMP_ID DPFLTR_CLASSPNP_ID |
◆ DEFAULT_MAX_NUMBER_BYTES_PER_SYNC_WRITE_USING_TOKEN
◆ DEFAULT_MAX_TARGET_DURATION
◆ FDO_HACK_CANNOT_LOCK_MEDIA
◆ FDO_HACK_GESN_IGNORE_OPCHANGE
◆ FDO_HACK_GESN_IS_BAD
◆ FDO_HACK_INVALID_FLAGS
| #define FDO_HACK_INVALID_FLAGS (~FDO_HACK_VALID_FLAGS) |
◆ FDO_HACK_NO_RESERVE6
◆ FDO_HACK_NO_SYNC_CACHE
◆ FDO_HACK_VALID_FLAGS
◆ FIFTY_MS_IN_100NS_UNITS
◆ GET_LBA_STATUS_RETRY_COUNT_MAX
◆ HISTORYINITIALIZERETRYLOGS
| #define HISTORYINITIALIZERETRYLOGS | ( | _packet | ) |
Value:
{ \
if (_packet->RetryHistory != NULL) \
{ \
HistoryInitializeRetryLogs( \
_packet->RetryHistory, \
_packet->RetryHistory->TotalHistoryCount \
); \
} \
}
◆ HISTORYLOGRETURNEDPACKET
| #define HISTORYLOGRETURNEDPACKET | ( | _packet | ) |
◆ HISTORYLOGSENDPACKET
| #define HISTORYLOGSENDPACKET | ( | _packet | ) |
◆ LEGACY_NUM_IO_RETRIES
◆ MAX
◆ MAX_CLEANUP_TRANSFER_PACKETS_AT_ONCE
◆ MAX_LIST_IDENTIFIER
◆ MAX_NUMBER_BLOCK_DEVICE_DESCRIPTORS
◆ MAX_NUMBER_BLOCKS_PER_BLOCK_DEVICE_RANGE_DESCRIPTOR
◆ MAX_NUMBER_BYTES_PER_SYNC_WRITE_USING_TOKEN
◆ MAX_OUTSTANDING_IO_PER_LUN_DEFAULT
◆ MAX_RECEIVE_TOKEN_INFORMATION_PARAMETER_DATA_LENGTH
◆ MAX_TOKEN_LIST_IDENTIFIERS
◆ MAX_TOKEN_OPERATION_PARAMETER_DATA_LENGTH
◆ MAX_TOKEN_TRANSFER_SIZE
◆ MAX_WORKINGSET_TRANSFER_PACKETS_Client
◆ MAX_WORKINGSET_TRANSFER_PACKETS_Server
◆ MAX_WORKINGSET_TRANSFER_PACKETS_SPACES
◆ MIN
◆ MIN_INITIAL_TRANSFER_PACKETS
◆ MIN_TOKEN_LIST_IDENTIFIERS
◆ MIN_WORKINGSET_TRANSFER_PACKETS_Client
◆ MIN_WORKINGSET_TRANSFER_PACKETS_Server_LowerBound
| #define MIN_WORKINGSET_TRANSFER_PACKETS_Server_LowerBound 32 |
◆ MIN_WORKINGSET_TRANSFER_PACKETS_Server_UpperBound
| #define MIN_WORKINGSET_TRANSFER_PACKETS_Server_UpperBound 256 |
◆ MIN_WORKINGSET_TRANSFER_PACKETS_SPACES
◆ MINIMUM_RETRY_UNITS
◆ MODE_PAGE_DATA_SIZE
◆ NOT_READY_RETRY_INTERVAL
◆ NUM_DRIVECAPACITY_RETRIES
◆ NUM_ERROR_LOG_ENTRIES
◆ NUM_IO_RETRIES
| #define NUM_IO_RETRIES MAXIMUM_RETRIES |
◆ NUM_LOCKMEDIAREMOVAL_RETRIES
◆ NUM_MODESELECT_RETRIES
◆ NUM_MODESENSE_RETRIES
◆ NUM_POPULATE_TOKEN_RETRIES
◆ NUM_RECEIVE_TOKEN_INFORMATION_RETRIES
◆ NUM_THIN_PROVISIONING_RETRIES
◆ NUM_WRITE_USING_TOKEN_RETRIES
◆ PTRALIGN
◆ QERR_SET_ZERO_ALWAYS
◆ QERR_SET_ZERO_NEVER
◆ QERR_SET_ZERO_ODX_OR_TP_ONLY
◆ REG_DISK_CLASS_CONTROL
| #define REG_DISK_CLASS_CONTROL L"\\REGISTRY\\MACHINE\\SYSTEM\\CurrentControlSet\\Control\\DISK" |
◆ REG_MAX_LIST_IDENTIFIER_VALUE
| #define REG_MAX_LIST_IDENTIFIER_VALUE L"MaximumListIdentifier" |
◆ RTL_USE_AVL_TABLES
◆ SHIFT10000
◆ TRACKING_FORWARD_PROGRESS_PATH1
◆ TRACKING_FORWARD_PROGRESS_PATH2
◆ TRACKING_FORWARD_PROGRESS_PATH3
◆ VPD_PAGE_HEADER_SIZE
◆ WPP_CONTROL_GUIDS
| #define WPP_CONTROL_GUIDS WPP_CONTROL_GUIDS_NORMAL_FLAGS(WPP_GUID_CLASSPNP) |
◆ WPP_GUID_CLASSPNP
| #define WPP_GUID_CLASSPNP (FA8DE7C4, ACDE, 4443, 9994, C4E2359A9EDB) |
Typedef Documentation
◆ CLASS_DETECTION_STATE
◆ CLASS_ERROR_LOG_DATA
◆ CLASS_RETRY_INFO
| typedef struct _CLASS_RETRY_INFO CLASS_RETRY_INFO |
◆ CSCAN_LIST
| typedef struct _CSCAN_LIST CSCAN_LIST |
◆ FAILURE_PREDICTION_INFO
◆ IDLE_POWER_FDO_LIST_ENTRY
◆ IO_RETRIED_LOG_MESSAGE_CONTEXT
◆ MEDIA_CHANGE_DETECTION_INFO
◆ OFFLOAD_READ_CONTEXT
◆ OFFLOAD_WRITE_CONTEXT
◆ OPCODE_SENSE_DATA_IO_LOG_MESSAGE_CONTEXT_HEADER
| typedef struct _OPCODE_SENSE_DATA_IO_LOG_MESSAGE_CONTEXT_HEADER OPCODE_SENSE_DATA_IO_LOG_MESSAGE_CONTEXT_HEADER |
◆ PCLASS_DETECTION_STATE
| typedef enum _CLASS_DETECTION_STATE * PCLASS_DETECTION_STATE |
◆ PCLASS_ERROR_LOG_DATA
| typedef struct _CLASS_ERROR_LOG_DATA * PCLASS_ERROR_LOG_DATA |
◆ PCLASS_RETRY_INFO
| typedef struct _CLASS_RETRY_INFO * PCLASS_RETRY_INFO |
◆ PCONTINUATION_ROUTINE
◆ PCSCAN_LIST
| typedef struct _CSCAN_LIST * PCSCAN_LIST |
◆ PFAILURE_PREDICTION_INFO
◆ PIDLE_POWER_FDO_LIST_ENTRY
◆ PIO_RETRIED_LOG_MESSAGE_CONTEXT
◆ PMEDIA_CHANGE_DETECTION_INFO
◆ PMEDIA_LOCK_TYPE
| typedef enum MEDIA_LOCK_TYPE * PMEDIA_LOCK_TYPE |
◆ PNL_SLIST_HEADER
| typedef struct _PNL_SLIST_HEADER PNL_SLIST_HEADER |
◆ POFFLOAD_READ_CONTEXT
| typedef struct _OFFLOAD_READ_CONTEXT * POFFLOAD_READ_CONTEXT |
◆ POFFLOAD_WRITE_CONTEXT
◆ POPCODE_SENSE_DATA_IO_LOG_MESSAGE_CONTEXT_HEADER
| typedef struct _OPCODE_SENSE_DATA_IO_LOG_MESSAGE_CONTEXT_HEADER * POPCODE_SENSE_DATA_IO_LOG_MESSAGE_CONTEXT_HEADER |
◆ PPNL_SLIST_HEADER
| typedef struct _PNL_SLIST_HEADER * PPNL_SLIST_HEADER |
◆ PSRB_ALLOCATE_ROUTINE
◆ PTRANSFER_PACKET
| typedef struct _TRANSFER_PACKET * PTRANSFER_PACKET |
◆ TRANSFER_PACKET
| typedef struct _TRANSFER_PACKET TRANSFER_PACKET |
Enumeration Type Documentation
◆ _CLASS_DETECTION_STATE
| Enumerator | |
|---|---|
| ClassDetectionUnknown | |
| ClassDetectionUnsupported | |
| ClassDetectionSupported | |
Definition at line 444 of file classp.h.
444 {
445 ClassDetectionUnknown = 0,
446 ClassDetectionUnsupported = 1,
447 ClassDetectionSupported = 2
enum _CLASS_DETECTION_STATE CLASS_DETECTION_STATE
enum _CLASS_DETECTION_STATE * PCLASS_DETECTION_STATE
◆ MEDIA_LOCK_TYPE
| Enumerator | |
|---|---|
| SimpleMediaLock | |
| SecureMediaLock | |
| InternalMediaLock | |
| SimpleMediaLock | |
| SecureMediaLock | |
| InternalMediaLock | |
Function Documentation
◆ __drv_allocatesMem()
◆ _Dispatch_type_() [1/7]
| _Dispatch_type_ | ( | IRP_MJ_CREATE | ) |
◆ _Dispatch_type_() [2/7]
| _Dispatch_type_ | ( | IRP_MJ_DEVICE_CONTROL | ) |
Definition at line 1376 of file isapnp.c.
1387{
1389
1390 PAGED_CODE();
1391
1394
1396 {
1399 }
1400 else
1401 {
1403
1406 }
1407}
static PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(PIRP Irp)
Definition: Bus_PDO_EvalMethod.c:152
Definition: isapnp.h:42
Definition: isapnp.h:49
◆ _Dispatch_type_() [3/7]
| _Dispatch_type_ | ( | IRP_MJ_PNP | ) |
Definition at line 1331 of file isapnp.c.
1341{
1344
1345 PAGED_CODE();
1346
1349 else
1351}
NTSTATUS IsaFdoPnp(_In_ PISAPNP_FDO_EXTENSION FdoExt, _Inout_ PIRP Irp, _In_ PIO_STACK_LOCATION IrpSp)
Definition: fdo.c:147
NTSTATUS IsaPdoPnp(_In_ PISAPNP_PDO_EXTENSION PdoDeviceExtension, _Inout_ PIRP Irp, _In_ PIO_STACK_LOCATION IrpSp)
Definition: pdo.c:867
Definition: Bus_PDO_EvalMethod.c:95
Definition: isapnp.h:70
◆ _Dispatch_type_() [4/7]
| _Dispatch_type_ | ( | IRP_MJ_POWER | ) |
◆ _Dispatch_type_() [5/7]
| _Dispatch_type_ | ( | IRP_MJ_READ | ) |
Definition at line 3505 of file read.c.
3507 {
3511 ULONG bytes_read = 0;
3513 bool top_level;
3516 bool acquired_fcb_lock = false, wait;
3517
3518 FsRtlEnterFileSystem();
3519
3521
3523
3526 goto exit2;
3530 }
3531
3532 Irp->IoStatus.Information = 0;
3533
3536
3539
3541 }
3542
3544
3549 }
3550
3552
3557 }
3558
3563 }
3564
3567
3569
3571
3572 goto exit2;
3573 }
3574
3577
3579
3580 // Don't offload jobs when doing paging IO - otherwise this can lead to
3581 // deadlocks in CcCopyRead.
3583 wait = true;
3584
3585 if (!(Irp->Flags & IRP_PAGING_IO) && FileObject->SectionObjectPointer && FileObject->SectionObjectPointer->DataSectionObject) {
3587
3588 CcFlushCache(FileObject->SectionObjectPointer, &IrpSp->Parameters.Read.ByteOffset, IrpSp->Parameters.Read.Length, &iosb);
3592 }
3593 }
3594
3600 }
3601
3602 acquired_fcb_lock = true;
3603 }
3604
3606
3607 if (acquired_fcb_lock)
3609
3610exit:
3612 FileObject->CurrentByteOffset.QuadPart = IrpSp->Parameters.Read.ByteOffset.QuadPart + (NT_SUCCESS(Status) ? bytes_read : 0);
3613
3614end:
3616
3620
3623 else {
3626 }
3627
3628exit2:
3629 if (top_level)
3631
3632 FsRtlExitFileSystem();
3633
3635}
struct _ccb ccb
VOID NTAPI CcMdlReadComplete(IN PFILE_OBJECT FileObject, IN PMDL MdlChain)
Definition: mdlsup.c:75
VOID NTAPI CcFlushCache(IN PSECTION_OBJECT_POINTERS SectionObjectPointer, IN OPTIONAL PLARGE_INTEGER FileOffset, IN ULONG Length, OUT OPTIONAL PIO_STATUS_BLOCK IoStatus)
Definition: cachesub.c:222
#define ExAcquireResourceSharedLite(res, wait)
Definition: env_spec_w32.h:621
#define FsRtlEnterFileSystem
#define FsRtlExitFileSystem
IoMarkIrpPending(Irp)
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1822
ULONG NTAPI ExIsResourceAcquiredSharedLite(IN PERESOURCE Resource)
Definition: resource.c:1663
NTSTATUS NTAPI FsRtlCheckOplock(IN POPLOCK Oplock, IN PIRP Irp, IN PVOID Context, IN POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine OPTIONAL, IN POPLOCK_FS_PREPOST_IRP PostIrpRoutine OPTIONAL)
Definition: oplock.c:1170
union _IO_STACK_LOCATION::@1823 Parameters
struct _IO_STACK_LOCATION::@5136::@5140 Read
Definition: env_spec_w32.h:870
Definition: btrfs_drv.h:370
Definition: btrfs_drv.h:758
Definition: btrfs_drv.h:282
#define IRP_PAGING_IO
◆ _Dispatch_type_() [6/7]
| _Dispatch_type_ | ( | IRP_MJ_SHUTDOWN | ) |
Definition at line 5510 of file btrfs.c.
5512 {
5514 bool top_level;
5516
5517 FsRtlEnterFileSystem();
5518
5520
5522
5526 }
5527
5529
5531
5532end:
5534 Irp->IoStatus.Information = 0;
5535
5537
5538 if (top_level)
5540
5541 FsRtlExitFileSystem();
5542
5544}
◆ _Dispatch_type_() [7/7]
| _Dispatch_type_ | ( | IRP_MJ_SYSTEM_CONTROL | ) |
Definition at line 5748 of file btrfs.c.
5750 {
5753 bool top_level;
5754
5755 FsRtlEnterFileSystem();
5756
5758
5759 Irp->IoStatus.Information = 0;
5760
5763
5765
5767
5771
5773
5777
5779
5781
5783 }
5784
5787
5788exit:
5789 if (top_level)
5791
5792 FsRtlExitFileSystem();
5793
5795}
Definition: btrfs_drv.h:872
Definition: btrfs_drv.h:846
◆ _In_reads_bytes_()
| _In_ PTRANSFER_PACKET _In_ ULONG _In_reads_bytes_ | ( | Length | ) |
◆ _IRQL_requires_()
| _IRQL_requires_ | ( | PASSIVE_LEVEL | ) |
Sends a synchronous IOCTL to the specified device object.
- Parameters
-
[in] IoControlCode The IOCTL to send to the device. [in] DeviceObject Pointer to the device object that will handle the IOCTL. [in] InputBuffer Optional pointer to a buffer containing input data for the IOCTL. When specified, the buffer should be at least of InputBufferLength size. [in] InputBufferLength Size in bytes, of the buffer pointed by InputBuffer. [out] OutputBuffer Optional pointer to a buffer that will receive output data from the IOCTL. When specified, the buffer should be at least of OutputBufferLength size. [in] OutputBufferLength Size in bytes, of the buffer pointed by OutputBuffer. [in] FileObject Optional pointer to a file object that may be necessary for the IOCTL.
- Returns
- An NTSTATUS code indicating success or failure of this function.
- Note
- Must be called at PASSIVE_LEVEL with all APCs enabled.
Nothing is found unless the PCI bus driver publishes the properties.
The root hub name without its prefix; NULL when the PDO has no name.
Grows a private buffer to what the helper asks for.
Lets KMDF handle the IRP, then hands it back here still uncompleted.
Waits for the device machine to answer a PnP or power event; returns the PnP status.
Deletes the UCX endpoints of the disabled pipes, then the interface record.
One 4 byte value; the registry type is not checked.
Reread whenever user experience settings change; the open status is returned.
Sends a synchronous IOCTL to the specified device object.
STATUS_SUCCESS when the caller's token is an administrator's.
Sends a synchronous IOCTL to the specified device object.
Reads one value of a walk. A missing value only clears Present; FALSE means stop.
Reads up to Size bytes of a value into a zeroed buffer; the type is not checked.
Writes a REG_BINARY value into the device's usbflags subkey.
Sets or clears ExtPropertiesInstalled from ExtPropDescSemaphore in the hardware key.
Fails only when a port cannot be bound to the USB4 host router its ACPI node names.
Assigns device, hardware, compatible, container and instance ids to a new child PDO.
Answers IRP_MN_QUERY_DEVICE_TEXT on a child PDO; always completes the IRP.
Takes the connector map lock, needed around HubConnectorFindCompanion.
Device hardware key values read at PDO prepare hardware.
Saves the MS OS 2.0 set info in usbflags when the set asks for alternate enumeration.
MsOs20Flags and EnumerationRetryCount, written at PDO start.
Rereads the UXD record; UpdateRequired says whether the device id changes.
Replacement PnP id of a UXD reserved device, or an empty String. Always succeeds.
Telemetry values under the device's Ceip subkey.
BootPathSurpriseRemovalCount + 1.
This machine's dual role features for a dual role partner.
Tells UCX the WDM PDO of the device; call right after the child PDO was created.
IOCTL_INTERNAL_USB_GET_CONTROLLER_NAME: Argument1 and its length Argument2.
IOCTL_INTERNAL_USB_GET_BUS_INFO for the device: the 16 byte USB_BUS_NOTIFICATION at Argument1.
Registers the GUID_USB_WMI_NODE_INFO instance of a child PDO (not for hubs or composites).
Registers the boot device surprise removal event on an external, non hub boot PDO.
Fires the boot device surprise removal event, if one is registered.
Sends a synchronous IOCTL to the specified device object.
Publishes "<port>#<host>" for every bound port on the hub's PDO. QUIRK: with no bound port an older value is left in place.
Binds USB 3 ports to the host routers named by the USB4 DVSEC; an earlier ACPI mapping wins.
Waits on a PnP handshake event with no timeout, printing a watchdog line every minute so a stuck machine is visible in the debugger.
Copies up to Size bytes of a device property; a failed query leaves the field zero.
Only the controller name length is real; both bandwidth fields read 0.
The answer overlays a USB_HUB_NAME on TotalSize, so TotalSize comes back as the name length + 4.
Evaluates a method without arguments into Output.
Drops every MSI descriptor and keeps only lists that still offer a line interrupt.
Picks the list with the best MSI offer: MSI-X first, then the most messages.
Keeps message descriptors covering Wanted messages and removes the others.
Evaluates _DSM on the controller ACPI object with a buffer as Arg3; returns up to 8 result bytes, 0 on failure.
Lets UCX hook the controller device init. Call before WdfDeviceCreate.
Definition at line 13147 of file class.c.
13175{
13177
13178 PAGED_CODE();
13179
13180 TracePrint((TRACE_LEVEL_VERBOSE,
13181 TRACE_FLAG_PNP,
13182 "ClassDetermineTokenOperationCommandSupport (%p): Entering function.\n",
13183 DeviceObject));
13184
13185 //
13186 // Send down Inquiry for VPD_THIRD_PARTY_COPY_PAGE and cache away the device parameters
13187 // from WINDOWS_BLOCK_DEVICE_TOKEN_LIMITS_DESCRIPTOR.
13188 //
13190
13192
13194
13195 //
13196 // Query the maximum list identifier to use for TokenOperation commands.
13197 //
13198 if (NT_SUCCESS(ClasspGetMaximumTokenListIdentifier(DeviceObject, REG_DISK_CLASS_CONTROL, &maxListIdentifier))) {
13200
13202 MaxTokenOperationListIdentifier = maxListIdentifier;
13203 }
13204 }
13205
13206 }
13207
13208 TracePrint((TRACE_LEVEL_VERBOSE,
13209 TRACE_FLAG_PNP,
13210 "ClassDetermineTokenOperationCommandSupport (%p): Exiting function with status %x.\n",
13211 DeviceObject,
13212 status));
13213
13215}
_IRQL_requires_same_ NTSTATUS ClasspGetBlockDeviceTokenLimitsInfo(_Inout_ PDEVICE_OBJECT DeviceObject)
Definition: class.c:13220
◆ _IRQL_requires_max_() [1/2]
| _IRQL_requires_max_ | ( | APC_LEVEL | ) |
Definition at line 37 of file cddata.c.
254{
255 THREAD_CONTEXT ThreadContext = {0};
258
259#ifdef CD_SANITY
260 PVOID PreviousTopLevel;
261#endif
262
264
265#if DBG
266
268
269#endif
270
272
274
275 FsRtlEnterFileSystem();
276
277#ifdef CD_SANITY
278 PreviousTopLevel = IoGetTopLevelIrp();
279#endif
280
281 //
282 // Loop until this request has been completed or posted.
283 //
284
285 do {
286
287 //
288 // Use a try-except to handle the exception cases.
289 //
290
291 _SEH2_TRY {
292
293 //
294 // If the IrpContext is NULL then this is the first pass through
295 // this loop.
296 //
297
299
300 //
301 // Decide if this request is waitable an allocate the IrpContext.
302 // If the file object in the stack location is NULL then this
303 // is a mount which is always waitable. Otherwise we look at
304 // the file object flags.
305 //
306
308
310
311 } else {
312
314 }
315
317
318 //
319 // Update the thread context information.
320 //
321
322 CdSetThreadContext( IrpContext, &ThreadContext );
323
324#ifdef CD_SANITY
325 NT_ASSERT( !CdTestTopLevel ||
327#endif
328
329 //
330 // Otherwise cleanup the IrpContext for the retry.
331 //
332
333 } else {
334
335 //
336 // Set the MORE_PROCESSING flag to make sure the IrpContext
337 // isn't inadvertently deleted here. Then cleanup the
338 // IrpContext to perform the retry.
339 //
340
343 }
344
345 //
346 // Case on the major irp code.
347 //
348
349 switch (IrpContext->MajorFunction) {
350
352
354 break;
355
357
359 break;
360
362
363 //
364 // If this is an Mdl complete request, don't go through
365 // common read.
366 //
367
369
371
372 } else {
373
375 }
376
377 break;
378
380
382 break;
383
385
387 break;
388
390
392 break;
393
395
397 break;
398
400
402 break;
403
405
407 break;
408
410
412 break;
413
415
417 break;
418
420
422 break;
423
425
427 break;
428
430
432 break;
433
434 default :
435
438 }
439
441
443 } _SEH2_END;
444
446
447#ifdef CD_SANITY
448 NT_ASSERT( !CdTestTopLevel ||
449 (PreviousTopLevel == IoGetTopLevelIrp()) );
450#endif
451
452 FsRtlExitFileSystem();
453
455
457}
VOID CdCompleteRequest(_Inout_opt_ PIRP_CONTEXT IrpContext, _Inout_opt_ PIRP Irp, _In_ NTSTATUS Status)
Definition: cddata.c:914
LONG CdExceptionFilter(_Inout_ PIRP_CONTEXT IrpContext, _In_ PEXCEPTION_POINTERS ExceptionPointer)
Definition: cddata.c:525
VOID CdSetThreadContext(_Inout_ PIRP_CONTEXT IrpContext, _In_ PTHREAD_CONTEXT ThreadContext)
Definition: cddata.c:981
NTSTATUS CdCompleteMdl(_In_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp)
Definition: cachesup.c:411
VOID CdCleanupIrpContext(_In_ PIRP_CONTEXT IrpContext, _In_ BOOLEAN Post)
Definition: strucsup.c:1733
NTSTATUS CdCommonLockControl(_Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp)
Definition: lockctrl.c:35
NTSTATUS CdCommonDevControl(_Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp)
Definition: devctrl.c:46
_Ret_valid_ PIRP_CONTEXT CdCreateIrpContext(_In_ PIRP Irp, _In_ BOOLEAN Wait)
Definition: strucsup.c:1573
Definition: nsiface.idl:2307
Definition: usbstor.h:98
Definition: cdstruc.h:1363
#define IRP_MJ_FILE_SYSTEM_CONTROL
#define IRP_MJ_SHUTDOWN
#define IRP_MJ_CLEANUP
◆ _IRQL_requires_max_() [2/2]
| _IRQL_requires_max_ | ( | PASSIVE_LEVEL | ) |
Definition at line 923 of file Messaging.c.
75{
76 PFLT_SERVER_PORT_OBJECT PortObject;
78
79 /* The caller must allow at least one connection */
81 {
83 }
84
85 /* The request must be for a kernel handle */
87 {
89 }
90
91 /*
92 * Get rundown protection on the target to stop the owner
93 * from unloading whilst this port object is open. It gets
94 * removed in the FltpServerPortClose callback
95 */
98 {
100 }
101
102 /* Create the server port object for this filter */
104 ServerPortObjectType,
105 ObjectAttributes,
106 KernelMode,
107 NULL,
109 0,
110 0,
111 (PVOID *)&PortObject);
113 {
114 /* Zero out the struct */
116
117 /* Increment the ref count on the target filter */
119
120 /* Setup the filter port object */
127
128 /* Insert the object */
130 NULL,
132 0,
133 NULL,
136 {
137 /* Lock the connection list */
139
140 /* Add the new port object to the connection list and increment the count */
142 Filter->ConnectionList.mCount++;
143
144 /* Unlock the connection list*/
146 }
147 }
148
150 {
151 /* Allow the filter to be cleaned up */
153 }
154
156}
_Must_inspect_result_ _Outptr_ PFLT_PORT _In_ POBJECT_ATTRIBUTES _In_opt_ PVOID _In_ PFLT_CONNECT_NOTIFY _In_ PFLT_DISCONNECT_NOTIFY _In_opt_ PFLT_MESSAGE_NOTIFY MessageNotifyCallback
Definition: fltkernel.h:1877
_Must_inspect_result_ _Outptr_ PFLT_PORT _In_ POBJECT_ATTRIBUTES _In_opt_ PVOID _In_ PFLT_CONNECT_NOTIFY ConnectNotifyCallback
Definition: fltkernel.h:1875
_Must_inspect_result_ _Outptr_ PFLT_PORT _In_ POBJECT_ATTRIBUTES _In_opt_ PVOID ServerPortCookie
Definition: fltkernel.h:1874
_Must_inspect_result_ _Outptr_ PFLT_PORT _In_ POBJECT_ATTRIBUTES _In_opt_ PVOID _In_ PFLT_CONNECT_NOTIFY _In_ PFLT_DISCONNECT_NOTIFY DisconnectNotifyCallback
Definition: fltkernel.h:1876
ULONG FltpObjectPointerReference(_In_ PFLT_OBJECT Object)
Definition: Object.c:322
NTSTATUS NTAPI ObInsertObject(IN PVOID Object, IN PACCESS_STATE AccessState OPTIONAL, IN ACCESS_MASK DesiredAccess, IN ULONG ObjectPointerBias, OUT PVOID *NewObject OPTIONAL, OUT PHANDLE Handle)
Definition: obhandle.c:2962
NTSTATUS NTAPI ObCreateObject(IN KPROCESSOR_MODE ProbeMode OPTIONAL, IN POBJECT_TYPE Type, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN KPROCESSOR_MODE AccessMode, IN OUT PVOID ParseContext OPTIONAL, IN ULONG ObjectSize, IN ULONG PagedPoolCharge OPTIONAL, IN ULONG NonPagedPoolCharge OPTIONAL, OUT PVOID *Object)
Definition: oblife.c:1049
Definition: fltmgrint.h:26
Definition: fltmgrint.h:189
PFLT_DISCONNECT_NOTIFY DisconnectNotify
Definition: fltmgrint.h:192
◆ AllocateDictionaryEntry()
| NTSTATUS AllocateDictionaryEntry | ( | IN PDICTIONARY | Dictionary, |
| IN ULONGLONG | Key, | ||
| IN ULONG | Size, | ||
| IN ULONG | Tag, | ||
| OUT PVOID * | Entry | ||
| ) |
Referenced by ClasspCreateClose().
◆ BuildDeviceInputMdl()
Definition at line 609 of file utils.c.
610{
612}
Definition: bufpool.h:45
PMDL ClasspBuildDeviceMdl(PVOID Buffer, ULONG BufferLen, BOOLEAN WriteToDevice)
Definition: utils.c:582
Referenced by ClasspModeSelect(), ClasspModeSense(), and ClassReadDriveCapacity().
◆ C_ASSERT()
| C_ASSERT | ( | (sizeof(struct _CLASS_PRIVATE_COMMON_DATA) % sizeof(PVOID)) | = =0 | ) |
◆ ClassAddChild()
| VOID ClassAddChild | ( | _In_ PFUNCTIONAL_DEVICE_EXTENSION | Parent, |
| _In_ PPHYSICAL_DEVICE_EXTENSION | Child, | ||
| _In_ BOOLEAN | AcquireLock | ||
| ) |
Definition at line 12058 of file class.c.
12063{
12065 ClassAcquireChildLock(Parent);
12066 }
12067
12068 #if DBG
12069 //
12070 // Make sure this child's not already in the list.
12071 //
12072 {
12073 PPHYSICAL_DEVICE_EXTENSION testChild;
12074
12076 testChild != NULL;
12078
12080 }
12081 }
12082 #endif
12083
12086
12089 }
12090 return;
12091} // end ClassAddChild()
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn UINT32 *TableIdx UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER void *Data ACPI_OBJECT_HANDLER void **Data ACPI_STRING ACPI_OBJECT_LIST ACPI_BUFFER *ReturnObjectBuffer ACPI_DEVICE_INFO **ReturnBuffer ACPI_HANDLE Parent
Definition: acpixf.h:732
VOID NTAPI ClassReleaseChildLock(_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
Definition: class.c:12019
pPkgPnp m_DeviceInterfaceLock AcquireLock(pFxDriverGlobals)
struct _PHYSICAL_DEVICE_EXTENSION * ChildList
Definition: classpnp.h:616
Definition: classpnp.h:646
COMMON_DEVICE_EXTENSION CommonExtension
Definition: classpnp.h:652
◆ ClassDeviceGetLBProvisioningResources()
| NTSTATUS ClassDeviceGetLBProvisioningResources | ( | _In_ PDEVICE_OBJECT | DeviceObject, |
| _Inout_ PIRP | Irp, | ||
| _Inout_ PSCSI_REQUEST_BLOCK | Srb | ||
| ) |
Definition at line 5087 of file utils.c.
5113{
5116 PSTORAGE_LB_PROVISIONING_MAP_RESOURCES mapResources = (PSTORAGE_LB_PROVISIONING_MAP_RESOURCES)Irp->AssociatedIrp.SystemBuffer;
5117
5119 Srb,
5121 mapResources);
5122
5125 } else {
5126 Irp->IoStatus.Information = 0;
5127 }
5128
5132
5134}
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
NTSTATUS ClassGetLBProvisioningResources(_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PSCSI_REQUEST_BLOCK Srb, _In_ ULONG ResourcesSize, _Inout_ PSTORAGE_LB_PROVISIONING_MAP_RESOURCES Resources)
Definition: utils.c:4958
struct _STORAGE_LB_PROVISIONING_MAP_RESOURCES * PSTORAGE_LB_PROVISIONING_MAP_RESOURCES
struct _IO_STACK_LOCATION::@1823::@1824 DeviceIoControl
Referenced by ClassDeviceControl().
◆ ClassDeviceHwFirmwareActivateProcess()
| NTSTATUS ClassDeviceHwFirmwareActivateProcess | ( | _In_ PDEVICE_OBJECT | DeviceObject, |
| _Inout_ PIRP | Irp, | ||
| _Inout_ PSCSI_REQUEST_BLOCK | Srb | ||
| ) |
Definition at line 8902 of file utils.c.
8907{
8909
8910#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
8911
8914
8916 PSTORAGE_HW_FIRMWARE_ACTIVATE firmwareActivate = (PSTORAGE_HW_FIRMWARE_ACTIVATE)Irp->AssociatedIrp.SystemBuffer;
8921 KLOCK_QUEUE_HANDLE lockHandle;
8922
8923
8924 //
8925 // Input buffer is not big enough to contain required input information.
8926 //
8927 if (irpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(STORAGE_HW_FIRMWARE_ACTIVATE)) {
8928
8930 goto Exit_Firmware_Activate;
8931 }
8932
8933 //
8934 // Input buffer basic validation.
8935 //
8936 if ((firmwareActivate->Version < sizeof(STORAGE_HW_FIRMWARE_ACTIVATE)) ||
8938
8940 goto Exit_Firmware_Activate;
8941 }
8942
8943 //
8944 // Only process the request for a supported port driver.
8945 //
8948 goto Exit_Firmware_Activate;
8949 }
8950
8951 //
8952 // Buffer "FunctionSupportInfo" is allocated during start device process. Following check defends against the situation
8953 // of receiving this IOCTL when the device is created but not started, or device start failed but did not get removed yet.
8954 //
8956
8958 goto Exit_Firmware_Activate;
8959 }
8960
8961 //
8962 // Process the situation that request should be forwarded to lower level.
8963 //
8965 passDown = TRUE;
8966 }
8967
8968 if ((firmwareActivate->Flags & STORAGE_HW_FIRMWARE_REQUEST_FLAG_CONTROLLER) != 0) {
8969 passDown = TRUE;
8970 }
8971
8972 if (passDown) {
8973
8975
8980 }
8981
8982 //
8983 // If firmware information hasn't been cached in classpnp, retrieve it.
8984 //
8988 goto Exit_Firmware_Activate;
8989 } else {
8990 //
8991 // If this is the first time of retrieving firmware information,
8992 // send request to lower level to get it.
8993 //
8995
8997 goto Exit_Firmware_Activate;
8998 }
8999 }
9000 }
9001
9002 //
9003 // Fail the request if the firmware information cannot be retrieved.
9004 //
9008 } else {
9010 }
9011
9012 goto Exit_Firmware_Activate;
9013 }
9014
9015 //
9016 // Acquire the SyncLock to ensure the HwFirmwareInfo pointer doesn't change
9017 // while we're dereferencing it.
9018 //
9019 lockHeld = TRUE;
9020 KeAcquireInStackQueuedSpinLock(&fdoExtension->FunctionSupportInfo->SyncLock, &lockHandle);
9021
9022 //
9023 // Validate the device support
9024 //
9027 goto Exit_Firmware_Activate;
9028 }
9029
9030 //
9031 // Check if the slot number is valid.
9032 //
9034 if (fdoExtension->FunctionSupportInfo->HwFirmwareInfo->Slot[i].SlotNumber == firmwareActivate->Slot) {
9035 break;
9036 }
9037 }
9038
9040 //
9041 // Either the slot number is out of scope or the slot is read-only.
9042 //
9044 goto Exit_Firmware_Activate;
9045 }
9046
9047 //
9048 // We're done accessing HwFirmwareInfo at this point so we can release
9049 // the SyncLock.
9050 //
9051 NT_ASSERT(lockHeld);
9052 KeReleaseInStackQueuedSpinLock(&lockHandle);
9053 lockHeld = FALSE;
9054
9055 //
9056 // Process the request by translating it into WRITE BUFFER command.
9057 //
9058 //
9059 // Setup the CDB. This should be an untagged request.
9060 //
9063 cdb->WRITE_BUFFER.OperationCode = SCSIOP_WRITE_DATA_BUFF;
9064 cdb->WRITE_BUFFER.Mode = SCSI_WRITE_BUFFER_MODE_ACTIVATE_DEFERRED_MICROCODE;
9065 cdb->WRITE_BUFFER.ModeSpecific = 0; //Reserved for Mode 0x0F
9066 cdb->WRITE_BUFFER.BufferID = firmwareActivate->Slot; //NOTE: this field will be ignored by SCSI device.
9067
9068 //
9069 // Set timeout value.
9070 //
9072
9073 //
9074 // This routine uses a completion routine - ClassIoComplete() so we don't want to release
9075 // the remove lock until then.
9076 //
9078 Srb,
9079 Irp,
9080 NULL,
9081 0,
9082 FALSE);
9083
9085 //
9086 // If the irp cannot be sent down, the Srb has been freed. NULL it to prevent from freeing it again.
9087 //
9089
9090 goto Exit_Firmware_Activate;
9091 }
9092
9094
9095Exit_Firmware_Activate:
9096
9097 //
9098 // Release the SyncLock if it's still held.
9099 // This should only happen in the failure path.
9100 //
9101 if (lockHeld) {
9102 KeReleaseInStackQueuedSpinLock(&lockHandle);
9103 lockHeld = FALSE;
9104 }
9105
9106 //
9107 // Firmware Activate request will be failed.
9108 //
9110
9112
9113#else
9116#endif // #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
9117
9120
9123}
SCSIPORT_API NTSTATUS NTAPI ClassSendSrbAsynchronous(_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PSCSI_REQUEST_BLOCK Srb, _In_ PIRP Irp, _In_reads_bytes_opt_(BufferLength) __drv_aliasesMem PVOID BufferAddress, _In_ ULONG BufferLength, _In_ BOOLEAN WriteToDevice)
NTSTATUS ClasspGetHwFirmwareInfo(_In_ PDEVICE_OBJECT DeviceObject)
Definition: utils.c:8190
__inline BOOLEAN ClassDeviceHwFirmwareIsPortDriverSupported(_In_ PDEVICE_OBJECT DeviceObject)
Definition: utils.c:8330
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
VOID FASTCALL KeAcquireInStackQueuedSpinLock(IN PKSPIN_LOCK SpinLock, IN PKLOCK_QUEUE_HANDLE LockHandle)
Definition: spinlock.c:130
VOID FASTCALL KeReleaseInStackQueuedSpinLock(IN PKLOCK_QUEUE_HANDLE LockHandle)
Definition: spinlock.c:166
#define IoCopyCurrentIrpStackLocationToNext(Irp)
Definition: ntifs_ex.h:413
FORCEINLINE VOID SrbSetCdbLength(_In_ PVOID Srb, _In_ UCHAR CdbLength)
Definition: srbhelper.h:1101
FORCEINLINE VOID SrbSetTimeOutValue(_In_ PVOID Srb, _In_ ULONG TimeOutValue)
Definition: srbhelper.h:829
#define SCSI_WRITE_BUFFER_MODE_ACTIVATE_DEFERRED_MICROCODE
Definition: storport.h:672
Definition: pci.h:44
PDEVICE_OBJECT LowerDeviceObject
Definition: pciidex.h:371
Definition: classpnp.h:867
Definition: ketypes.h:694
Definition: cdrw_hw.h:28
Referenced by ClassDeviceControl().
◆ ClassDeviceHwFirmwareDownloadProcess()
| NTSTATUS ClassDeviceHwFirmwareDownloadProcess | ( | _In_ PDEVICE_OBJECT | DeviceObject, |
| _Inout_ PIRP | Irp, | ||
| _Inout_ PSCSI_REQUEST_BLOCK | Srb | ||
| ) |
Definition at line 8541 of file utils.c.
8546{
8548
8549#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
8550
8553
8555 PSTORAGE_HW_FIRMWARE_DOWNLOAD firmwareDownload = (PSTORAGE_HW_FIRMWARE_DOWNLOAD)Irp->AssociatedIrp.SystemBuffer;
8564 KLOCK_QUEUE_HANDLE lockHandle;
8565
8566
8567 //
8568 // Input buffer is not big enough to contain required input information.
8569 //
8570 if (irpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(STORAGE_HW_FIRMWARE_DOWNLOAD)) {
8571
8573 goto Exit_Firmware_Download;
8574 }
8575
8576 //
8577 // Input buffer basic validation.
8578 //
8579 if ((firmwareDownload->Version < sizeof(STORAGE_HW_FIRMWARE_DOWNLOAD)) ||
8581 ((firmwareDownload->BufferSize + FIELD_OFFSET(STORAGE_HW_FIRMWARE_DOWNLOAD, ImageBuffer)) > firmwareDownload->Size)) {
8582
8584 goto Exit_Firmware_Download;
8585 }
8586
8587 //
8588 // Only process the request for a supported port driver.
8589 //
8592 goto Exit_Firmware_Download;
8593 }
8594
8595 //
8596 // Buffer "FunctionSupportInfo" is allocated during start device process. Following check defends against the situation
8597 // of receiving this IOCTL when the device is created but not started, or device start failed but did not get removed yet.
8598 //
8600
8602 goto Exit_Firmware_Download;
8603 }
8604
8605 //
8606 // Process the situation that request should be forwarded to lower level.
8607 //
8609 passDown = TRUE;
8610 }
8611
8612 if ((firmwareDownload->Flags & STORAGE_HW_FIRMWARE_REQUEST_FLAG_CONTROLLER) != 0) {
8613 passDown = TRUE;
8614 }
8615
8616 if (passDown) {
8617
8619
8624 }
8625
8626 //
8627 // If firmware information hasn't been cached in classpnp, retrieve it.
8628 //
8632 goto Exit_Firmware_Download;
8633 } else {
8634 //
8635 // If this is the first time of retrieving firmware information,
8636 // send request to lower level to get it.
8637 //
8639
8641 goto Exit_Firmware_Download;
8642 }
8643 }
8644 }
8645
8646 //
8647 // Fail the request if the firmware information cannot be retrieved.
8648 //
8652 } else {
8654 }
8655
8656 goto Exit_Firmware_Download;
8657 }
8658
8659 //
8660 // Acquire the SyncLock to ensure the HwFirmwareInfo pointer doesn't change
8661 // while we're dereferencing it.
8662 //
8663 lockHeld = TRUE;
8664 KeAcquireInStackQueuedSpinLock(&fdoExtension->FunctionSupportInfo->SyncLock, &lockHandle);
8665
8666 //
8667 // Validate the device support
8668 //
8670 (fdoExtension->FunctionSupportInfo->HwFirmwareInfo->ImagePayloadAlignment == 0)) {
8672 goto Exit_Firmware_Download;
8673 }
8674
8675 //
8676 // Check if the slot can be used to hold firmware image.
8677 //
8679 if (fdoExtension->FunctionSupportInfo->HwFirmwareInfo->Slot[i].SlotNumber == firmwareDownload->Slot) {
8680 break;
8681 }
8682 }
8683
8686 //
8687 // Either the slot number is out of scope or the slot is read-only.
8688 //
8690 goto Exit_Firmware_Download;
8691 }
8692
8693 //
8694 // Buffer size and alignment validation.
8695 // Max Offset and Buffer Size can be represented by SCSI command is max value for 3 bytes.
8696 //
8697 if ((firmwareDownload->BufferSize == 0) ||
8698 ((firmwareDownload->BufferSize % fdoExtension->FunctionSupportInfo->HwFirmwareInfo->ImagePayloadAlignment) != 0) ||
8699 (firmwareDownload->BufferSize > fdoExtension->FunctionSupportInfo->HwFirmwareInfo->ImagePayloadMaxSize) ||
8701 ((firmwareDownload->Offset % fdoExtension->FunctionSupportInfo->HwFirmwareInfo->ImagePayloadAlignment) != 0) ||
8702 (firmwareDownload->Offset > 0xFFFFFF) ||
8703 (firmwareDownload->BufferSize > 0xFFFFFF)) {
8704
8706 goto Exit_Firmware_Download;
8707 }
8708
8709
8710 //
8711 // Process the request by translating it into WRITE BUFFER command.
8712 //
8713 if (((ULONG_PTR)firmwareDownload->ImageBuffer % fdoExtension->FunctionSupportInfo->HwFirmwareInfo->ImagePayloadAlignment) != 0) {
8714 //
8715 // Allocate buffer aligns to ImagePayloadAlignment to accommodate the alignment requirement.
8716 //
8717 bufferSize = ALIGN_UP_BY(firmwareDownload->BufferSize, fdoExtension->FunctionSupportInfo->HwFirmwareInfo->ImagePayloadAlignment);
8718
8719 //
8720 // We're done accessing HwFirmwareInfo at this point so we can release
8721 // the SyncLock.
8722 //
8723 NT_ASSERT(lockHeld);
8724 KeReleaseInStackQueuedSpinLock(&lockHandle);
8725 lockHeld = FALSE;
8726
8727#ifdef _MSC_VER
8728#pragma prefast(suppress:6014, "The allocated memory that firmwareImageBuffer points to will be freed in ClassHwFirmwareDownloadComplete().")
8729#endif
8730 firmwareImageBuffer = ExAllocatePoolWithTag(NonPagedPoolNx, bufferSize, CLASSPNP_POOL_TAG_FIRMWARE);
8731
8734 goto Exit_Firmware_Download;
8735 }
8736
8738
8739 RtlCopyMemory(firmwareImageBuffer, firmwareDownload->ImageBuffer, (ULONG)firmwareDownload->BufferSize);
8740
8741 } else {
8742 NT_ASSERT(lockHeld);
8743 KeReleaseInStackQueuedSpinLock(&lockHandle);
8744 lockHeld = FALSE;
8745
8746 firmwareImageBuffer = firmwareDownload->ImageBuffer;
8748 }
8749
8750 //
8751 // Allocate a new irp to send the WRITE BUFFER command down.
8752 // Similar process as IOCTL_STORAGE_CHECK_VERIFY.
8753 //
8755
8758
8759 if (firmwareImageBuffer != firmwareDownload->ImageBuffer) {
8760 FREE_POOL(firmwareImageBuffer);
8761 }
8762
8763 goto Exit_Firmware_Download;
8764 }
8765
8766 //
8767 // Make sure to acquire the lock for the new irp.
8768 //
8770
8771 irp2->Tail.Overlay.Thread = Irp->Tail.Overlay.Thread;
8772 IoSetNextIrpStackLocation(irp2);
8773
8774 //
8775 // Set the top stack location and shove the master Irp into the
8776 // top location
8777 //
8778 newStack = IoGetCurrentIrpStackLocation(irp2);
8779 newStack->Parameters.Others.Argument1 = Irp;
8780 newStack->DeviceObject = DeviceObject;
8781
8782 //
8783 // Stick the firmware download completion routine onto the stack
8784 // and prepare the irp for the port driver
8785 //
8786 IoSetCompletionRoutine(irp2,
8787 ClassHwFirmwareDownloadComplete,
8788 (firmwareImageBuffer != firmwareDownload->ImageBuffer) ? firmwareImageBuffer : NULL,
8789 TRUE,
8790 TRUE,
8791 TRUE);
8792
8793 IoSetNextIrpStackLocation(irp2);
8794 newStack = IoGetCurrentIrpStackLocation(irp2);
8795 newStack->DeviceObject = DeviceObject;
8796 newStack->MajorFunction = irpStack->MajorFunction;
8797 newStack->MinorFunction = irpStack->MinorFunction;
8798 newStack->Flags = irpStack->Flags;
8799
8800
8801 //
8802 // Mark the master irp as pending - whether the lower level
8803 // driver completes it immediately or not this should allow it
8804 // to go all the way back up.
8805 //
8807
8808 //
8809 // Setup the CDB.
8810 //
8813 cdb->WRITE_BUFFER.OperationCode = SCSIOP_WRITE_DATA_BUFF;
8814 cdb->WRITE_BUFFER.Mode = SCSI_WRITE_BUFFER_MODE_DOWNLOAD_MICROCODE_WITH_OFFSETS_SAVE_DEFER_ACTIVATE;
8815 cdb->WRITE_BUFFER.ModeSpecific = 0; //Reserved for Mode 0x0E
8816 cdb->WRITE_BUFFER.BufferID = firmwareDownload->Slot;
8817
8818 cdb->WRITE_BUFFER.BufferOffset[0] = *((PCHAR)&firmwareDownload->Offset + 2);
8819 cdb->WRITE_BUFFER.BufferOffset[1] = *((PCHAR)&firmwareDownload->Offset + 1);
8820 cdb->WRITE_BUFFER.BufferOffset[2] = *((PCHAR)&firmwareDownload->Offset);
8821
8825
8826 //
8827 // Send as a tagged command.
8828 //
8831
8832 //
8833 // Set timeout value.
8834 //
8836
8837 //
8838 // This routine uses a completion routine so we don't want to release
8839 // the remove lock until then.
8840 //
8842 Srb,
8843 irp2,
8844 firmwareImageBuffer,
8845 bufferSize,
8846 TRUE);
8847
8849 //
8850 // If the new irp cannot be sent down, free allocated memory and bail out.
8851 //
8852 if (firmwareImageBuffer != firmwareDownload->ImageBuffer) {
8853 FREE_POOL(firmwareImageBuffer);
8854 }
8855
8856 //
8857 // If the irp cannot be sent down, the Srb has been freed. NULL it to prevent from freeing it again.
8858 //
8860
8862
8863 IoFreeIrp(irp2);
8864
8865 goto Exit_Firmware_Download;
8866 }
8867
8869
8870Exit_Firmware_Download:
8871
8872 //
8873 // Release the SyncLock if it's still held.
8874 // This should only happen in the failure path.
8875 //
8876 if (lockHeld) {
8877 KeReleaseInStackQueuedSpinLock(&lockHandle);
8878 lockHeld = FALSE;
8879 }
8880
8881 //
8882 // Firmware Download request will be failed.
8883 //
8885
8887
8888#else
8891#endif // #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
8892
8895
8897
8899}
#define IoSetCompletionRoutine(_Irp, _CompletionRoutine, _Context, _InvokeOnSuccess, _InvokeOnError, _InvokeOnCancel)
Definition: irp.cpp:490
PIRP NTAPI IoAllocateIrp(IN CCHAR StackSize, IN BOOLEAN ChargeQuota)
Definition: irp.c:647
FORCEINLINE VOID SrbSetSrbFlags(_In_ PVOID Srb, _In_ ULONG Flags)
Definition: srbhelper.h:972
FORCEINLINE VOID SrbSetRequestAttribute(_In_ PVOID Srb, _In_ UCHAR RequestAttribute)
Definition: srbhelper.h:1139
#define SCSI_WRITE_BUFFER_MODE_DOWNLOAD_MICROCODE_WITH_OFFSETS_SAVE_DEFER_ACTIVATE
Definition: storport.h:671
PSTORAGE_ADAPTER_DESCRIPTOR AdapterDescriptor
Definition: classpnp.h:877
Definition: Bus_PDO_EvalMethod.c:107
ULONG MaximumTransferLength
Definition: ntddstor.h:306
FORCEINLINE VOID IoSetNextIrpStackLocation(_Inout_ PIRP Irp)
Definition: iofuncs.h:2706
Referenced by ClassDeviceControl().
◆ ClassDeviceHwFirmwareGetInfoProcess()
| NTSTATUS ClassDeviceHwFirmwareGetInfoProcess | ( | _In_ PDEVICE_OBJECT | DeviceObject, |
| _Inout_ PIRP | Irp | ||
| ) |
Definition at line 8366 of file utils.c.
8385{
8387
8388#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
8389
8393 PSTORAGE_HW_FIRMWARE_INFO_QUERY query = (PSTORAGE_HW_FIRMWARE_INFO_QUERY)Irp->AssociatedIrp.SystemBuffer;
8396
8397
8398 //
8399 // Input buffer is not big enough to contain required input information.
8400 //
8401 if (irpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(STORAGE_HW_FIRMWARE_INFO_QUERY)) {
8402
8404 goto Exit_Firmware_Get_Info;
8405 }
8406
8407 //
8408 // Output buffer is too small to contain return data.
8409 //
8410 if (irpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(STORAGE_HW_FIRMWARE_INFO)) {
8411
8413 goto Exit_Firmware_Get_Info;
8414 }
8415
8416 //
8417 // Only process the request for a supported port driver.
8418 //
8421 goto Exit_Firmware_Get_Info;
8422 }
8423
8424 //
8425 // Buffer "FunctionSupportInfo" is allocated during start device process. Following check defends against the situation
8426 // of receiving this IOCTL when the device is created but not started, or device start failed but did not get removed yet.
8427 //
8429
8431 goto Exit_Firmware_Get_Info;
8432 }
8433
8434 //
8435 // Process the situation that request should be forwarded to lower level.
8436 //
8438 passDown = TRUE;
8439 }
8440
8442 passDown = TRUE;
8443 }
8444
8445 if (passDown) {
8446
8448
8452 }
8453
8454 //
8455 // The request is for a FDO. Process the request.
8456 //
8459 goto Exit_Firmware_Get_Info;
8460 } else {
8461 //
8462 // Retrieve information from lower layer for the request. The cached information is not used
8463 // in case device firmware information changed.
8464 //
8467 }
8468
8469Exit_Firmware_Get_Info:
8470
8471 if (copyData) {
8472 //
8473 // Firmware information is already cached in classpnp. Return a copy.
8474 //
8475 KLOCK_QUEUE_HANDLE lockHandle;
8476 KeAcquireInStackQueuedSpinLock(&fdoExtension->FunctionSupportInfo->SyncLock, &lockHandle);
8477
8478 ULONG dataLength = min(irpStack->Parameters.DeviceIoControl.OutputBufferLength, fdoExtension->FunctionSupportInfo->HwFirmwareInfo->Size);
8479
8480 memcpy(Irp->AssociatedIrp.SystemBuffer, fdoExtension->FunctionSupportInfo->HwFirmwareInfo, dataLength);
8481
8482 KeReleaseInStackQueuedSpinLock(&lockHandle);
8483
8485 }
8486
8488
8489#else
8492#endif // #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
8493
8496
8498}
Definition: pdh_main.c:113
Referenced by ClassDeviceControl().
◆ ClassFreeOrReuseSrb()
| VOID ClassFreeOrReuseSrb | ( | IN PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| IN __drv_freesMem(mem) PSCSI_REQUEST_BLOCK | Srb | ||
| ) |
Definition at line 882 of file obsolete.c.
905{
907
908 // This function is obsolete, but still called by DISK.SYS .
909 // TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL, "ClassFreeOrReuseSrb is OBSOLETE !"));
910
911 //
912 // safety net. this should never occur. if it does, it's a potential
913 // memory leak.
914 //
916
918 /*
919 * Put the SRB back in our lookaside list.
920 *
921 * Note: Some class drivers use ClassIoComplete
922 * to complete SRBs that they themselves allocated.
923 * So we may be putting a "foreign" SRB
924 * (e.g. with a different pool tag) into our lookaside list.
925 */
927 }
928 else {
929 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,"ClassFreeOrReuseSrb: someone is trying to use an uninitialized SrbLookasideList !!!"));
931 }
932}
BOOLEAN IsSrbLookasideListInitialized
Definition: classpnp.h:610
Referenced by _Success_(), ClassIoComplete(), ClassIoCompleteAssociated(), and ClasspEjectionControl().
◆ ClassGetPdoId()
| NTSTATUS ClassGetPdoId | ( | IN PDEVICE_OBJECT | Pdo, |
| IN BUS_QUERY_ID_TYPE | IdType, | ||
| IN PUNICODE_STRING | IdString | ||
| ) |
Definition at line 10151 of file class.c.
10156{
10157#ifdef _MSC_VER
10158#pragma warning(suppress:4054) // okay to type cast function pointer as data pointer for this use case
10159#endif
10160 PCLASS_DRIVER_EXTENSION driverExtension = IoGetDriverObjectExtension(Pdo->DriverObject, CLASS_DRIVER_EXTENSION_KEY);
10161
10163
10166
10167 PAGED_CODE();
10168
10170} // end ClassGetPdoId()
PVOID NTAPI IoGetDriverObjectExtension(IN PDRIVER_OBJECT DriverObject, IN PVOID ClientIdentificationAddress)
Definition: driver.c:1925
Definition: kbdclass.h:32
Referenced by ClassDispatchPnp().
◆ ClassInitializeDispatchTables()
| VOID ClassInitializeDispatchTables | ( | PCLASS_DRIVER_EXTENSION | DriverExtension | ) |
Definition at line 38 of file dispatch.c.
41{
43
44 PAGED_CODE();
45
46 //
47 // Initialize the standard device dispatch table
48 //
49
52 }
53
65
66
67 return;
68}
NTSTATUS NTAPI ClassSystemControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: classwmi.c:221
NTSTATUS NTAPI ClassInternalIoControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: class.c:9394
NTSTATUS NTAPI ClassReadWrite(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: class.c:2431
NTSTATUS NTAPI ClassDeviceControlDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
Definition: class.c:7258
NTSTATUS NTAPI ClassDispatchPnp(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: class.c:894
NTSTATUS NTAPI ClassShutdownFlush(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: class.c:8773
NTSTATUS NTAPI ClassCreateClose(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: create.c:57
NTSTATUS NTAPI ClassDispatchPower(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: power.c:105
#define IRP_MJ_SCSI
#define IRP_MJ_SYSTEM_CONTROL
#define IRP_MJ_FLUSH_BUFFERS
#define IRP_MJ_POWER
#define IRP_MJ_MAXIMUM_FUNCTION
Referenced by _IRQL_requires_max_().
◆ ClassIoCompletion()
◆ ClassMinimalPowerHandler()
Definition at line 1890 of file power.c.
1894{
1898
1901
1903 {
1905 {
1907 {
1911 {
1913 {
1915 {
1916 //
1917 // This flag will cause the filesystem to verify the
1918 // volume when coming out of hibernation or standby or runtime power
1919 //
1921 }
1922 }
1923 }
1924 break;
1925 }
1926 }
1927
1928 //
1929 // Fall through
1930 //
1931
1933 {
1935 {
1937 Irp->IoStatus.Information = 0;
1938 }
1939 }
1940 break;
1941 }
1942
1944 {
1947 }
1948 else
1949 {
1952 }
1953
1955} // end ClassMinimalPowerHandler()
struct _IO_STACK_LOCATION::@5136::@5172 Power
Referenced by _IRQL_requires_max_().
◆ ClasspAccessAlignmentProperty()
| NTSTATUS ClasspAccessAlignmentProperty | ( | _In_ PDEVICE_OBJECT | DeviceObject, |
| _In_ PIRP | Irp, | ||
| _Inout_ PSCSI_REQUEST_BLOCK | Srb | ||
| ) |
Definition at line 1700 of file utils.c.
1709{
1711
1712 PCOMMON_DEVICE_EXTENSION commonExtension = (PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
1713 PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
1718
1719 PSTORAGE_ACCESS_ALIGNMENT_DESCRIPTOR accessAlignment;
1720
1721 //
1722 // check registry setting and fail the IOCTL if it's required.
1723 // this registry setting can be used to work around issues which upper layer doesn't support large physical sector size.
1724 //
1725 if (fdoExtension->FunctionSupportInfo->RegAccessAlignmentQueryNotSupported) {
1728 }
1729
1732 (fdoExtension->FunctionSupportInfo->LowerLayerSupport.AccessAlignmentProperty == Supported) ) {
1733 // if it's not disk, forward the request to lower layer,
1734 // if the IOCTL is supported by lower stack, forward it down.
1736
1740 }
1741
1742 //
1743 // Check proper query type.
1744 //
1745
1752 }
1753
1754 //
1755 // Request validation.
1756 // Note that InputBufferLength and IsFdo have been validated before entering this routine.
1757 //
1758
1763 }
1764
1765 // do not touch this buffer because it can still be used as input buffer for lower layer in 'SupportUnknown' case.
1767
1768 length = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
1769
1771
1773
1779 }
1780
1783 }
1784
1785 // not support Cache Line,
1786 // 'BytesPerCacheLine' and 'BytesOffsetForCacheAlignment' fields are zero-ed.
1787
1788 //
1789 // note that 'Supported' case has been handled at the beginning of this function.
1790 //
1791 switch (fdoExtension->FunctionSupportInfo->LowerLayerSupport.AccessAlignmentProperty) {
1793 // send down request and wait for the request to complete.
1795
1797 // case 1: the request is not supported by lower layer, sends down command
1798 // some port drivers (or filter drivers) return STATUS_INVALID_DEVICE_REQUEST if a request is not supported.
1799
1800 // ClassReadCapacity16() will either return status from cached data or send command to retrieve the information.
1803 } else {
1804 fdoExtension->FunctionSupportInfo->ReadCapacity16Data.CommandStatus = status;
1805 }
1806
1807 // data is ready in fdoExtension
1808 // set the support status after the SCSI command is executed to avoid racing condition between multiple same type of requests.
1809 fdoExtension->FunctionSupportInfo->LowerLayerSupport.AccessAlignmentProperty = NotSupported;
1810
1812 // fill output buffer
1816 accessAlignment->BytesPerLogicalSector = fdoExtension->FunctionSupportInfo->ReadCapacity16Data.BytesPerLogicalSector;
1817 accessAlignment->BytesPerPhysicalSector = fdoExtension->FunctionSupportInfo->ReadCapacity16Data.BytesPerPhysicalSector;
1818 accessAlignment->BytesOffsetForSectorAlignment = fdoExtension->FunctionSupportInfo->ReadCapacity16Data.BytesOffsetForSectorAlignment;
1819
1820 // set returned data length
1822 } else {
1823 information = 0;
1824 }
1825
1826 } else {
1827 // case 2: the request is supported and it completes successfully
1828 // case 3: the request is supported by lower stack but other failure status is returned.
1829 // from now on, the same request will be send down to lower stack directly.
1830 fdoExtension->FunctionSupportInfo->LowerLayerSupport.AccessAlignmentProperty = Supported;
1832
1833
1834 }
1835
1836
1838
1839 break;
1840 }
1841
1843
1844 // ClassReadCapacity16() will either return status from cached data or send command to retrieve the information.
1846
1851 accessAlignment->BytesPerLogicalSector = fdoExtension->FunctionSupportInfo->ReadCapacity16Data.BytesPerLogicalSector;
1852 accessAlignment->BytesPerPhysicalSector = fdoExtension->FunctionSupportInfo->ReadCapacity16Data.BytesPerPhysicalSector;
1853 accessAlignment->BytesOffsetForSectorAlignment = fdoExtension->FunctionSupportInfo->ReadCapacity16Data.BytesOffsetForSectorAlignment;
1854
1856 } else {
1857 information = 0;
1858 }
1860
1861 break;
1862 }
1863
1867 break;
1868 }
1869
1870 } // end of switch (fdoExtension->FunctionSupportInfo->LowerLayerSupport.AccessAlignmentProperty)
1871
1872Exit:
1873
1874 //
1875 // Set the size and status in IRP
1876 //
1879
1882
1884}
FORCEINLINE BOOLEAN ClasspLowerLayerNotSupport(_In_ NTSTATUS Status)
Definition: classp.h:2638
FORCEINLINE BOOLEAN ClasspIsObsoletePortDriver(_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
Definition: classp.h:1335
struct _COMMON_DEVICE_EXTENSION * PCOMMON_DEVICE_EXTENSION
NTSTATUS NTAPI ClassForwardIrpSynchronous(_In_ PCOMMON_DEVICE_EXTENSION CommonExtension, _In_ PIRP Irp)
Definition: class.c:11343
NTSTATUS ClassReadCapacity16(_Inout_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _Inout_ PSCSI_REQUEST_BLOCK Srb)
Definition: utils.c:1568
* PSTORAGE_ACCESS_ALIGNMENT_DESCRIPTOR
Definition: ntddstor.h:609
struct _STORAGE_PROPERTY_QUERY * PSTORAGE_PROPERTY_QUERY
Definition: ntddstor.h:269
Definition: ntddstor.h:551
struct _STORAGE_DESCRIPTOR_HEADER STORAGE_DESCRIPTOR_HEADER
Referenced by ClassDeviceControl().
◆ ClasspAllocatePowerProcessIrp()
| NTSTATUS ClasspAllocatePowerProcessIrp | ( | IN PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension | ) |
◆ ClasspAllocateReleaseQueueIrp()
| NTSTATUS ClasspAllocateReleaseQueueIrp | ( | IN PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension | ) |
◆ ClasspAllocateReleaseRequest()
| NTSTATUS ClasspAllocateReleaseRequest | ( | IN PDEVICE_OBJECT | Fdo | ) |
Definition at line 11489 of file class.c.
11492{
11494
11495 PAGED_CODE();
11496
11498
11502
11503 //
11504 // The class driver is responsible for allocating a properly sized irp,
11505 // or ClassReleaseQueue will attempt to do it on the first error.
11506 //
11507
11509
11510 //
11511 // Write length to SRB.
11512 //
11513
11515
11517} // end ClasspAllocateReleaseRequest()
struct _SCSI_REQUEST_BLOCK SCSI_REQUEST_BLOCK
BOOLEAN ReleaseQueueInProgress
Definition: classpnp.h:915
BOOLEAN ReleaseQueueNeeded
Definition: classpnp.h:914
KSPIN_LOCK ReleaseQueueSpinLock
Definition: classpnp.h:911
SCSI_REQUEST_BLOCK ReleaseQueueSrb
Definition: classpnp.h:913
BOOLEAN ReleaseQueueIrpFromPool
Definition: classpnp.h:916
◆ ClasspBinaryToAscii()
| _IRQL_requires_same_ PUCHAR ClasspBinaryToAscii | ( | _In_reads_(Length) PUCHAR | HexBuffer, |
| _In_ ULONG | Length, | ||
| _Inout_ PULONG | UpdateLength | ||
| ) |
Definition at line 7717 of file utils.c.
7744{
7745 static const UCHAR integerTable[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
7748 ULONG actualLength;
7750 UCHAR highWord;
7751 UCHAR lowWord;
7752
7753 TracePrint((TRACE_LEVEL_VERBOSE,
7754 TRACE_FLAG_IOCTL,
7755 "ClasspBinaryToAscii (HexBuff %p): Entering function.\n",
7756 HexBuffer));
7757
7759 *UpdateLength = 0;
7760 goto __ClasspBinaryToAscii_Exit;
7761 }
7762
7763 //
7764 // Each byte converts into 2 chars:
7765 // e.g. 0x05 => '0' '5'
7766 // 0x0C => '0' 'C'
7767 // 0x12 => '1' '2'
7768 // And we need a terminating NULL for the string.
7769 //
7770 actualLength = (Length * 2) + 1;
7771
7772 //
7773 // Allocate the buffer.
7774 //
7775 buffer = ExAllocatePoolWithTag(NonPagedPoolNx, actualLength, CLASSPNP_POOL_TAG_TOKEN_OPERATION);
7777
7778 TracePrint((TRACE_LEVEL_ERROR,
7779 TRACE_FLAG_IOCTL,
7780 "ClasspBinaryToAscii (HexBuff %p): Failed to allocate buffer for ASCII equivalent.\n",
7781 HexBuffer));
7782
7783 *UpdateLength = 0;
7784 goto __ClasspBinaryToAscii_Exit;
7785 }
7786
7788
7790
7791 //
7792 // Split out each nibble from the binary byte.
7793 //
7794 highWord = HexBuffer[i] >> 4;
7795 lowWord = HexBuffer[i] & 0x0F;
7796
7797 //
7798 // Using the lookup table, convert and stuff into
7799 // the ascii buffer.
7800 //
7802#ifdef _MSC_VER
7803#pragma warning(suppress: 6386) // PREFast bug means it doesn't see that Length < actualLength
7804#endif
7806 }
7807
7808 //
7809 // Update the caller's length field.
7810 //
7811 *UpdateLength = actualLength;
7812
7813__ClasspBinaryToAscii_Exit:
7814
7815 TracePrint((TRACE_LEVEL_VERBOSE,
7816 TRACE_FLAG_IOCTL,
7817 "ClasspBinaryToAscii (HexBuff %p): Exiting function with buffer %s.\n",
7818 HexBuffer,
7820
7822}
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
Referenced by ClasspContinueOffloadWrite(), and ClasspReceivePopulateTokenInformationTransferPacketDone().
◆ ClasspBlockLimitsDataSnapshot()
| NTSTATUS ClasspBlockLimitsDataSnapshot | ( | _In_ PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| _In_ BOOLEAN | ForceQuery, | ||
| _Out_ PCLASS_VPD_B0_DATA | BlockLimitsData, | ||
| _Out_ PULONG | GenerationCount | ||
| ) |
Definition at line 16504 of file class.c.
16539{
16541 KLOCK_QUEUE_HANDLE lockHandle;
16542
16544
16546 *BlockLimitsData = FdoExtension->FunctionSupportInfo->BlockLimitsData;
16547 *GenerationCount = FdoExtension->FunctionSupportInfo->GenerationCount;
16548 KeReleaseInStackQueuedSpinLock(&lockHandle);
16549
16551}
NTSTATUS ClasspRefreshFunctionSupportInfo(_Inout_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _In_ BOOLEAN ForceQuery)
Definition: class.c:16395
@ ForceQuery
Referenced by ClasspDeviceGetLBAStatus(), ClasspDeviceLBProvisioningProperty(), and ClasspDeviceTrimProcess().
◆ ClasspBuildDeviceMdl()
Definition at line 582 of file utils.c.
583{
585
588 _SEH2_TRY {
590#ifdef _MSC_VER
591 #pragma warning(suppress: 6320) // We want to handle any exception that MmProbeAndLockPages might throw
592#endif
595
596 TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_INIT, "ClasspBuildDeviceMdl: MmProbeAndLockPages failed with %xh.", status));
599 } _SEH2_END;
600 }
601 else {
602 TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_INIT, "ClasspBuildDeviceMdl: IoAllocateMdl failed"));
603 }
604
606}
_In_ PSCSI_REQUEST_BLOCK _In_opt_ PVOID _In_ ULONG _In_ BOOLEAN WriteToDevice
Definition: cdrom.h:992
VOID NTAPI MmProbeAndLockPages(IN PMDL Mdl, IN KPROCESSOR_MODE AccessMode, IN LOCK_OPERATION Operation)
Definition: mdlsup.c:928
Referenced by BuildDeviceInputMdl().
◆ ClasspBuildRequestEx()
| VOID ClasspBuildRequestEx | ( | _In_ PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| _In_ PIRP | Irp, | ||
| _In_ __drv_aliasesMem PSCSI_REQUEST_BLOCK | Srb | ||
| ) |
Definition at line 537 of file obsolete.c.
575{
578
580
581 PCDB cdb;
582 ULONG logicalBlockAddress;
583 USHORT transferBlocks;
586
587 // This function is obsolete, but still called by CDROM.SYS .
588 // TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL, "ClasspBuildRequestEx is OBSOLETE !"));
589
592 return;
593 }
594
595 //
596 // Calculate relative sector address.
597 //
598
599 logicalBlockAddress =
601 FdoExtension->SectorShift));
602
603 //
604 // Prepare the SRB.
605 // NOTE - for extended SRB, size used is based on allocation in ClasspAllocateSrb.
606 //
607
612 1,
613 SrbExDataTypeScsiCdb16);
616 return;
617 }
618
620 } else {
622
623 //
624 // Write length to SRB.
625 //
626
628
630 }
631
632
633 //
634 // Set up IRP Address.
635 //
636
638
639 //
640 // Set up data buffer
641 //
642
643 SrbSetDataBuffer(srbHeader,
645
646 //
647 // Save byte count of transfer in SRB Extension.
648 //
649
650 SrbSetDataTransferLength(srbHeader,
652
653 //
654 // Initialize the queue actions field.
655 //
656
658
659 //
660 // Queue sort key is Relative Block Address.
661 //
662
663 SrbSetQueueSortKey(srbHeader, logicalBlockAddress);
664
665 //
666 // Indicate auto request sense by specifying buffer and size.
667 //
668
671
672 //
673 // Set timeout value of one unit per 64k bytes of data.
674 //
675
676 SrbSetTimeOutValue(srbHeader,
677 ((SrbGetDataTransferLength(srbHeader) + 0xFFFF) >> 16) *
678 FdoExtension->TimeOutValue);
679
680 //
681 // Indicate that 10-byte CDB's will be used.
682 //
683
684 SrbSetCdbLength(srbHeader, 10);
685
686 //
687 // Fill in CDB fields.
688 //
689
690 cdb = SrbGetCdb(srbHeader);
692
694 FdoExtension->SectorShift);
695
696 //
697 // Move little endian values into CDB in big endian format.
698 //
699
704
707
708 //
709 // Set transfer direction flag and Cdb command.
710 //
711
713
715
718
719 } else {
720
722
725
726 }
727
728 //
729 // If this is not a write-through request, then allow caching.
730 //
731
733
735
736 } else {
737
738 //
739 // If write caching is enable then force media access in the
740 // cdb.
741 //
742
744 }
745
748 }
749
750 //
751 // OR in the default flags from the device object.
752 //
753
755
756 //
757 // Set up major SCSI function.
758 //
759
761
762 //
763 // Save SRB address in next stack for port driver.
764 //
765
767
768 //
769 // Save retry count in current IRP stack.
770 //
771
773
774 //
775 // Set up IoCompletion routine address.
776 //
777
779
780}
NTSTATUS InitializeStorageRequestBlock(_Inout_bytecount_(ByteSize) PSTORAGE_REQUEST_BLOCK Srb, _In_ USHORT AddressType, _In_ ULONG ByteSize, _In_ ULONG NumSrbExData,...)
Definition: srblib.c:206
FORCEINLINE UCHAR GET_FDO_EXTENSON_SENSE_DATA_LENGTH(_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
Definition: classpnp.h:1437
#define CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE
Definition: classpnp.h:695
struct _FOUR_BYTE * PFOUR_BYTE
NTSTATUS NTAPI ClassIoComplete(IN PDEVICE_OBJECT Fdo, IN PIRP Irp, IN PVOID Context)
Definition: class.c:3768
#define Int64ShrlMod32(a, b)
struct SRB_ALIGN _STORAGE_REQUEST_BLOCK_HEADER * PSTORAGE_REQUEST_BLOCK_HEADER
FORCEINLINE VOID SrbSetQueueSortKey(_In_ PVOID Srb, _In_ ULONG QueueSortKey)
Definition: srbhelper.h:847
FORCEINLINE VOID SrbSetDataTransferLength(_In_ PVOID Srb, _In_ ULONG DataTransferLength)
Definition: srbhelper.h:792
FORCEINLINE VOID SrbSetOriginalRequest(_In_ PVOID Srb, _In_opt_ PVOID OriginalRequest)
Definition: srbhelper.h:718
FORCEINLINE VOID SrbSetSenseInfoBufferLength(_In_ PVOID Srb, _In_ UCHAR SenseInfoBufferLength)
Definition: srbhelper.h:683
FORCEINLINE VOID SrbSetSenseInfoBuffer(_In_ PVOID Srb, _In_opt_ PVOID SenseInfoBuffer)
Definition: srbhelper.h:665
FORCEINLINE VOID SrbSetDataBuffer(_In_ PVOID Srb, _In_opt_ __drv_aliasesMem PVOID DataBuffer)
Definition: srbhelper.h:755
FORCEINLINE ULONG SrbGetDataTransferLength(_In_ PVOID Srb)
Definition: srbhelper.h:773
struct _IO_STACK_LOCATION::@5136::@5175 Others
struct _IO_STACK_LOCATION::@5136::@5158 Scsi
Definition: srb.h:248
struct _CDB::_CDB10 CDB10
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetNextIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2721
#define IRP_SYNCHRONOUS_PAGING_IO
#define MmGetMdlVirtualAddress(_Mdl)
Referenced by ClassBuildRequest().
◆ ClasspCalculateLogicalSectorSize()
| ULONG ClasspCalculateLogicalSectorSize | ( | _In_ PDEVICE_OBJECT | Fdo, |
| _In_ ULONG | BytesPerBlockInBigEndian | ||
| ) |
Definition at line 1483 of file utils.c.
1492{
1493 ULONG logicalSectorSize;
1494
1495 REVERSE_BYTES(&logicalSectorSize, &BytesPerBlockInBigEndian);
1496
1497 if (logicalSectorSize == 0) {
1498 logicalSectorSize = 512;
1499 } else {
1500 //
1501 // Clear all but the highest set bit.
1502 // That will give us a bytesPerSector value that is a power of 2.
1503 //
1504 if (logicalSectorSize & (logicalSectorSize-1)) {
1505 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_INIT, "FDO %ph has non-standard sector size 0x%x.", Fdo, logicalSectorSize));
1506 do {
1507 logicalSectorSize &= logicalSectorSize-1;
1508 }
1509 while (logicalSectorSize & (logicalSectorSize-1));
1510 }
1511 }
1512
1513 return logicalSectorSize;
1514}
Referenced by InterpretCapacityData(), and InterpretReadCapacity16Data().
◆ ClasspCleanupOffloadReadContext()
| VOID ClasspCleanupOffloadReadContext | ( | _In_ __drv_freesMem(mem) POFFLOAD_READ_CONTEXT | OffloadReadContext | ) |
Definition at line 14335 of file class.c.
14356{
14357 PMDL populateTokenMdl;
14358
14359 populateTokenMdl = OffloadReadContext->PopulateTokenMdl;
14360
14362
14363 if (populateTokenMdl) {
14364 ClasspFreeDeviceMdl(populateTokenMdl);
14365 }
14366 FREE_POOL(OffloadReadContext);
14367
14368 return;
14369}
Referenced by ClasspCompleteOffloadRead().
◆ ClasspCleanupOffloadWriteContext()
| VOID ClasspCleanupOffloadWriteContext | ( | _In_ __drv_freesMem(mem) POFFLOAD_WRITE_CONTEXT | OffloadWriteContext | ) |
Definition at line 15902 of file class.c.
15923{
15924 PMDL writeUsingTokenMdl = OffloadWriteContext->WriteUsingTokenMdl;
15925
15926 if (writeUsingTokenMdl) {
15927 ClasspFreeDeviceMdl(writeUsingTokenMdl);
15928 }
15929 FREE_POOL(OffloadWriteContext);
15930
15931 return;
15932}
Referenced by ClasspCompleteOffloadWrite().
◆ ClasspCleanupProtectedLocks()
| VOID ClasspCleanupProtectedLocks | ( | IN PFILE_OBJECT_EXTENSION | FsContext | ) |
Definition at line 296 of file create.c.
299{
300 PCOMMON_DEVICE_EXTENSION commonExtension =
301 FsContext->DeviceObject->DeviceExtension;
302
303 PFUNCTIONAL_DEVICE_EXTENSION fdoExtension =
304 commonExtension->PartitionZeroExtension;
305
306 ULONG newDeviceLockCount = 1;
307
308 PAGED_CODE();
309
310 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
311 "ClasspCleanupProtectedLocks called for %p\n",
312 FsContext->DeviceObject));
313 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
314 "ClasspCleanupProtectedLocks - FsContext %p is locked "
316
318
319 //
320 // Synchronize with ejection and ejection control requests.
321 //
322
323 KeEnterCriticalRegion();
325 UserRequest,
326 KernelMode,
327 FALSE,
328 NULL);
329
330 //
331 // For each secure lock on this handle decrement the secured lock count
332 // for the FDO. Keep track of the new value.
333 //
334
336
337 do {
338
340
341 newDeviceLockCount =
343
345
346 //
347 // If the new lock count has been dropped to zero then issue a lock
348 // command to the device.
349 //
350
351 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
352 "ClasspCleanupProtectedLocks: FDO secured lock count = %d "
353 "lock count = %d\n",
354 fdoExtension->ProtectedLockCount,
355 fdoExtension->LockCount));
356
358
359 SCSI_REQUEST_BLOCK srb = {0};
364 PSCSI_REQUEST_BLOCK srbPtr;
365
366 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
367 "ClasspCleanupProtectedLocks: FDO lock count dropped "
368 "to zero\n"));
369
371#ifdef _MSC_VER
372 #pragma prefast(suppress:26015, "InitializeStorageRequestBlock ensures buffer access is bounded")
373#endif
376 sizeof(srbExBuffer),
377 1,
378 SrbExDataTypeScsiCdb16);
380 srbEx->TimeOutValue = fdoExtension->TimeOutValue;
381 SrbSetCdbLength(srbEx, 6);
382 cdb = SrbGetCdb(srbEx);
383 srbPtr = (PSCSI_REQUEST_BLOCK)srbEx;
384 } else {
385 //
386 // Should not happen. Revert to legacy SRB.
387 //
390 srb.CdbLength = 6;
392 srbPtr = &srb;
393 }
394
395 } else {
396
398 srb.CdbLength = 6;
400 srbPtr = &srb;
401
402 }
403
405
406 //
407 // TRUE - prevent media removal.
408 // FALSE - allow media removal.
409 //
410
412
414 srbPtr,
415 NULL,
416 0,
417 FALSE);
418
419 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
420 "ClasspCleanupProtectedLocks: unlock request to drive "
422 }
423 }
424
426 IO_NO_INCREMENT,
427 FALSE);
428 KeLeaveCriticalRegion();
429 return;
430}
union _CDB * PCDB
PAGED_CODE()
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
struct _SCSI_REQUEST_BLOCK * PSCSI_REQUEST_BLOCK
#define KeWaitForSingleObject(pEvt, foo, a, b, c)
Definition: env_spec_w32.h:478
struct _FUNCTIONAL_DEVICE_EXTENSION * PartitionZeroExtension
Definition: classpnp.h:599
KEVENT EjectSynchronizationEvent
Definition: classpnp.h:897
struct _CDB::_MEDIA_REMOVAL MEDIA_REMOVAL
Referenced by ClasspCreateClose().
◆ ClasspCompleteIdleRequest()
| VOID ClasspCompleteIdleRequest | ( | PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension | ) |
Definition at line 713 of file clntirp.c.
716{
718
719 //
720 // Issue the next idle request if there are any left in the queue, there are
721 // no non-idle requests outstanding, there are less than max idle requests
722 // outstanding, and it has been long enough since the completion of the last
723 // non-idle request.
724 //
727 (fdoData->ActiveIoCount <= 0) &&
729 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_TIMER, "ClasspCompleteIdleRequest: Service next idle reqeusts\n"));
731 }
732
733 return;
734}
VOID ClasspServiceIdleRequest(PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, BOOLEAN PostToDpc)
Definition: clntirp.c:757
LOGICAL ClasspIdleDurationSufficient(IN PCLASS_PRIVATE_FDO_DATA FdoData, OUT LARGE_INTEGER **CurrentTimeIn)
Definition: clntirp.c:406
Definition: classp.h:658
Referenced by TransferPktComplete().
◆ ClasspCompleteOffloadRead()
| VOID ClasspCompleteOffloadRead | ( | _In_ POFFLOAD_READ_CONTEXT | OffloadReadContext, |
| _In_ NTSTATUS | CompletionStatus | ||
| ) |
Definition at line 14255 of file class.c.
14280{
14281 PDEVICE_MANAGE_DATA_SET_ATTRIBUTES dsmAttributes;
14282 ULONGLONG entireXferLen;
14283 PDEVICE_OBJECT fdo;
14284 PFUNCTIONAL_DEVICE_EXTENSION fdoExt;
14288 ULONGLONG totalSectorsProcessed;
14289
14290 status = CompletionStatus;
14291 dsmAttributes = OffloadReadContext->OffloadReadDsmIrp->AssociatedIrp.SystemBuffer;
14292 totalSectorsProcessed = OffloadReadContext->TotalSectorsProcessed;
14293 fdoExt = OffloadReadContext->Fdo->DeviceExtension;
14294 entireXferLen = OffloadReadContext->EntireXferLen;
14295 token = OffloadReadContext->Token;
14296 irp = OffloadReadContext->OffloadReadDsmIrp;
14297 fdo = OffloadReadContext->Fdo;
14298
14299 ((PSTORAGE_OFFLOAD_READ_OUTPUT)dsmAttributes)->OffloadReadFlags = 0;
14300 ((PSTORAGE_OFFLOAD_READ_OUTPUT)dsmAttributes)->Reserved = 0;
14301
14304
14305 TracePrint((totalBytesProcessed == entireXferLen ? TRACE_LEVEL_INFORMATION : TRACE_LEVEL_WARNING,
14306 TRACE_FLAG_IOCTL,
14307 "ClasspCompleteOffloadRead (%p): Successfully populated token with %I64u (out of %I64u) bytes (list Id %x).\n",
14308 fdo,
14309 totalBytesProcessed,
14310 entireXferLen,
14311 OffloadReadContext->ListIdentifier));
14312
14313 if (totalBytesProcessed < entireXferLen) {
14314 SET_FLAG(((PSTORAGE_OFFLOAD_READ_OUTPUT)dsmAttributes)->OffloadReadFlags, STORAGE_OFFLOAD_READ_RANGE_TRUNCATED);
14315 }
14316 ((PSTORAGE_OFFLOAD_READ_OUTPUT)dsmAttributes)->LengthProtected = totalBytesProcessed;
14317 ((PSTORAGE_OFFLOAD_READ_OUTPUT)dsmAttributes)->TokenLength = STORAGE_OFFLOAD_MAX_TOKEN_LENGTH;
14318 RtlCopyMemory(&((PSTORAGE_OFFLOAD_READ_OUTPUT)dsmAttributes)->Token, token, STORAGE_OFFLOAD_MAX_TOKEN_LENGTH);
14319 } else {
14320 ((PSTORAGE_OFFLOAD_READ_OUTPUT)dsmAttributes)->LengthProtected = 0;
14321 ((PSTORAGE_OFFLOAD_READ_OUTPUT)dsmAttributes)->TokenLength = 0;
14322 }
14323
14325
14327 ClasspCleanupOffloadReadContext(OffloadReadContext);
14328 OffloadReadContext = NULL;
14329
14330 return;
14331}
Definition: tokenizer.hpp:28
VOID ClasspCompleteOffloadRequest(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_ NTSTATUS CompletionStatus)
Definition: class.c:13632
VOID ClasspCleanupOffloadReadContext(_In_ __drv_freesMem(mem) POFFLOAD_READ_CONTEXT OffloadReadContext)
Definition: class.c:14335
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 token
Definition: glfuncs.h:210
struct _STORAGE_OFFLOAD_READ_OUTPUT * PSTORAGE_OFFLOAD_READ_OUTPUT
#define STORAGE_OFFLOAD_READ_RANGE_TRUNCATED
Definition: ntddstor.h:1026
struct _STORAGE_OFFLOAD_READ_OUTPUT STORAGE_OFFLOAD_READ_OUTPUT
Definition: ntddstor.h:771
Definition: env_spec_w32.h:413
Definition: ntddstor.h:1028
Referenced by ClasspPopulateTokenTransferPacketDone(), ClasspReceivePopulateTokenInformation(), and ClasspReceivePopulateTokenInformationTransferPacketDone().
◆ ClasspCompleteOffloadRequest()
| VOID ClasspCompleteOffloadRequest | ( | _In_ PDEVICE_OBJECT | DeviceObject, |
| _In_ PIRP | Irp, | ||
| _In_ NTSTATUS | CompletionStatus | ||
| ) |
Definition at line 13632 of file class.c.
13636{
13638
13639
13641
13644
13645 return;
13646}
Referenced by _IRQL_requires_max_(), ClasspCompleteOffloadRead(), and ClasspCompleteOffloadWrite().
◆ ClasspCompleteOffloadWrite()
| VOID ClasspCompleteOffloadWrite | ( | _In_ __drv_freesMem(Mem) POFFLOAD_WRITE_CONTEXT | OffloadWriteContext, |
| _In_ NTSTATUS | CompletionCausingStatus | ||
| ) |
Definition at line 15788 of file class.c.
15824{
15825 PDEVICE_OBJECT fdo;
15826 PFUNCTIONAL_DEVICE_EXTENSION fdoExt;
15827 PDEVICE_MANAGE_DATA_SET_ATTRIBUTES dsmAttributes;
15828 PULONGLONG totalSectorsProcessedSuccessfully;
15829 ULONGLONG entireXferLen;
15831 PBOOLEAN tokenInvalidated;
15832 ULONG listIdentifier;
15833 ULONGLONG totalSectorsProcessed;
15835 ULONGLONG totalBytesProcessed;
15836
15837 fdo = OffloadWriteContext->Fdo;
15838 fdoExt = fdo->DeviceExtension;
15839 dsmAttributes = OffloadWriteContext->DsmAttributes;
15840 totalSectorsProcessedSuccessfully = &OffloadWriteContext->TotalSectorsProcessedSuccessfully;
15841 entireXferLen = OffloadWriteContext->EntireXferLen;
15842 irp = OffloadWriteContext->OffloadWriteDsmIrp;
15843 tokenInvalidated = &OffloadWriteContext->TokenInvalidated;
15844 listIdentifier = OffloadWriteContext->ListIdentifier;
15845 totalSectorsProcessed = OffloadWriteContext->TotalSectorsProcessed;
15846 status = CompletionCausingStatus;
15847
15848 ((PSTORAGE_OFFLOAD_WRITE_OUTPUT)dsmAttributes)->OffloadWriteFlags = 0;
15849 ((PSTORAGE_OFFLOAD_WRITE_OUTPUT)dsmAttributes)->Reserved = 0;
15850
15851 totalBytesProcessed = (*totalSectorsProcessedSuccessfully) * fdoExt->DiskGeometry.BytesPerSector;
15852
15853 TracePrint((totalBytesProcessed == entireXferLen ? TRACE_LEVEL_INFORMATION : TRACE_LEVEL_WARNING,
15854 TRACE_FLAG_IOCTL,
15855 "ClasspCompleteOffloadWrite (%p): %ws wrote using token %I64u (out of %I64u) bytes (Irp %p).\n",
15856 fdo,
15858 totalBytesProcessed,
15859 entireXferLen,
15860 irp));
15861
15862 if (totalBytesProcessed > 0 && totalBytesProcessed < entireXferLen) {
15863 SET_FLAG(((PSTORAGE_OFFLOAD_WRITE_OUTPUT)dsmAttributes)->OffloadWriteFlags, STORAGE_OFFLOAD_WRITE_RANGE_TRUNCATED);
15864 }
15865 if (*tokenInvalidated) {
15866 SET_FLAG(((PSTORAGE_OFFLOAD_WRITE_OUTPUT)dsmAttributes)->OffloadWriteFlags, STORAGE_OFFLOAD_TOKEN_INVALID);
15867 }
15868 ((PSTORAGE_OFFLOAD_WRITE_OUTPUT)dsmAttributes)->LengthCopied = totalBytesProcessed;
15869
15870
15872
15873 TracePrint((TRACE_LEVEL_WARNING,
15874 TRACE_FLAG_IOCTL,
15875 "ClasspCompleteOffloadWrite (%p): TokenOperation for WriteUsingToken (list Id %u) completed with %x writing %I64u blocks (currentTotal %I64u blocks).\n",
15876 fdo,
15877 listIdentifier,
15878 status,
15879 totalSectorsProcessed,
15880 *totalSectorsProcessedSuccessfully));
15881
15882 //
15883 // Even if target returned an error, from the OS upper layers' perspective,
15884 // it is a success (with truncation) if any data at all was written.
15885 //
15886 if (*totalSectorsProcessedSuccessfully) {
15888 }
15889 }
15890
15892
15894 ClasspCleanupOffloadWriteContext(OffloadWriteContext);
15895 OffloadWriteContext = NULL;
15896
15897 return;
15898}
VOID ClasspCleanupOffloadWriteContext(_In_ __drv_freesMem(mem) POFFLOAD_WRITE_CONTEXT OffloadWriteContext)
Definition: class.c:15902
#define STORAGE_OFFLOAD_WRITE_RANGE_TRUNCATED
Definition: ntddstor.h:1051
struct _STORAGE_OFFLOAD_WRITE_OUTPUT * PSTORAGE_OFFLOAD_WRITE_OUTPUT
struct _STORAGE_OFFLOAD_WRITE_OUTPUT STORAGE_OFFLOAD_WRITE_OUTPUT
Definition: ntddstor.h:1054
Referenced by ClasspContinueOffloadWrite(), ClasspReceiveWriteUsingTokenInformation(), ClasspReceiveWriteUsingTokenInformationDone(), ClasspReceiveWriteUsingTokenInformationTransferPacketDone(), and ClasspWriteUsingTokenTransferPacketDone().
◆ ClasspContinueOffloadWrite()
| VOID ClasspContinueOffloadWrite | ( | _In_ __drv_aliasesMem POFFLOAD_WRITE_CONTEXT | OffloadWriteContext | ) |
Definition at line 15187 of file class.c.
15213{
15214 BOOLEAN allDataSetRangeFullyConverted;
15215 ULONG blockDescrIndex;
15216 PBLOCK_DEVICE_RANGE_DESCRIPTOR blockDescrPointer;
15219 ULONGLONG dataSetRangeByteOffset;
15220 ULONG dataSetRangeIndex;
15221 PDEVICE_DATA_SET_RANGE dataSetRanges;
15222 ULONG dataSetRangesCount;
15223 ULONGLONG entireXferLen;
15224 PDEVICE_OBJECT fdo;
15225 PFUNCTIONAL_DEVICE_EXTENSION fdoExt;
15227 ULONG lbaCount;
15228 ULONG listIdentifier;
15229 ULONGLONG logicalBlockOffset;
15230 ULONG maxBlockDescrCount;
15231 ULONGLONG maxLbaCount;
15232 PDEVICE_DSM_OFFLOAD_WRITE_PARAMETERS offloadWriteParameters;
15233 PTRANSFER_PACKET pkt;
15234 PIRP pseudoIrp;
15236 DEVICE_DATA_SET_RANGE tempDataSetRange;
15237 BOOLEAN tempDataSetRangeFullyConverted;
15238 PVOID tokenAscii;
15239 ULONG tokenSize;
15240 ULONGLONG totalSectorCount;
15241 ULONGLONG totalSectorsProcessedSuccessfully;
15242 ULONGLONG totalSectorsToProcess;
15243 ULONG transferSize;
15244 USHORT writeUsingTokenDataLength;
15245 USHORT writeUsingTokenDescriptorsLength;
15246 PMDL writeUsingTokenMdl;
15247
15248 tokenAscii = NULL;
15249 tokenSize = BLOCK_DEVICE_TOKEN_SIZE;
15250 tempDataSetRangeFullyConverted = FALSE;
15251 allDataSetRangeFullyConverted = FALSE;
15252 fdo = OffloadWriteContext->Fdo;
15253 fdoExt = fdo->DeviceExtension;
15254 irp = OffloadWriteContext->OffloadWriteDsmIrp;
15255 buffer = OffloadWriteContext + 1;
15256 bufferLength = OffloadWriteContext->BufferLength;
15257 dataSetRanges = OffloadWriteContext->DataSetRanges;
15258 offloadWriteParameters = OffloadWriteContext->OffloadWriteParameters;
15259 pseudoIrp = &OffloadWriteContext->PseudoIrp;
15260 writeUsingTokenMdl = OffloadWriteContext->WriteUsingTokenMdl;
15261 entireXferLen = OffloadWriteContext->EntireXferLen;
15262
15264
15266 if (!pkt){
15267
15268 TracePrint((TRACE_LEVEL_ERROR,
15269 TRACE_FLAG_IOCTL,
15270 "ClasspContinueOffloadWrite (%p): Failed to retrieve transfer packet for TokenOperation (WriteUsingToken) operation.\n",
15271 fdo));
15272
15274 goto __ClasspContinueOffloadWrite_ErrorExit;
15275 }
15276
15277 OffloadWriteContext->Pkt = pkt;
15278
15279 blockDescrPointer = (PBLOCK_DEVICE_RANGE_DESCRIPTOR)
15281
15282 blockDescrIndex = 0;
15283 lbaCount = 0;
15284
15285 totalSectorsToProcess = 0;
15286
15287 maxBlockDescrCount = OffloadWriteContext->MaxBlockDescrCount;
15288 maxLbaCount = OffloadWriteContext->MaxLbaCount;
15289
15290 //
15291 // The OffloadWriteContext->DataSetRangeIndex, DataSetRangeByteOffset, and
15292 // TotalSectorsProcessedSuccessfully don't move forward until RRTI has
15293 // reported the actual amount written.
15294 //
15295 // For that reason, this function only updates
15296 // OffloadWriteContext->TotalSectorsProcessed, which tracks the number of
15297 // sectors requested to be written by the current WRITE USING TOKEN command
15298 // (not all will necessarily be written).
15299 //
15300
15301 dataSetRangeIndex = OffloadWriteContext->DataSetRangeIndex;
15302 dataSetRangesCount = OffloadWriteContext->DataSetRangesCount;
15303 dataSetRangeByteOffset = OffloadWriteContext->DataSetRangeByteOffset;
15304 totalSectorsProcessedSuccessfully = OffloadWriteContext->TotalSectorsProcessedSuccessfully;
15305
15306 //
15307 // Send WriteUsingToken commands when the buffer is full or all input entries are converted.
15308 //
15309 while (!((blockDescrIndex == maxBlockDescrCount) || // buffer full or block descriptor count reached
15310 (lbaCount == maxLbaCount) || // block LBA count reached
15311 (allDataSetRangeFullyConverted))) { // all DataSetRanges have been converted
15312
15313 NT_ASSERT(dataSetRangeIndex < dataSetRangesCount);
15314 NT_ASSERT(dataSetRangeByteOffset < dataSetRanges[dataSetRangeIndex].LengthInBytes);
15315
15316 tempDataSetRange.StartingOffset = dataSetRanges[dataSetRangeIndex].StartingOffset + dataSetRangeByteOffset;
15317 tempDataSetRange.LengthInBytes = dataSetRanges[dataSetRangeIndex].LengthInBytes - dataSetRangeByteOffset;
15318
15319 totalSectorCount = 0;
15320
15321 ClasspConvertDataSetRangeToBlockDescr(fdo,
15322 blockDescrPointer,
15323 &blockDescrIndex,
15324 maxBlockDescrCount,
15325 &lbaCount,
15326 maxLbaCount,
15327 &tempDataSetRange,
15328 &totalSectorCount);
15329
15331
15332 allDataSetRangeFullyConverted = tempDataSetRangeFullyConverted && ((dataSetRangeIndex + 1) == dataSetRangesCount);
15333
15334 if (tempDataSetRangeFullyConverted) {
15335 dataSetRangeIndex += 1;
15336 dataSetRangeByteOffset = 0;
15337 NT_ASSERT(dataSetRangeIndex <= dataSetRangesCount);
15338 } else {
15340 NT_ASSERT(dataSetRangeByteOffset < dataSetRanges[dataSetRangeIndex].LengthInBytes);
15341 }
15342
15343 totalSectorsToProcess += totalSectorCount;
15344 }
15345
15346 //
15347 // Save the number of sectors being attempted in this WRITE USING TOKEN
15348 // command, so that a success return from the command will know how much
15349 // was written, without needing to issue a RECEIVE ROD TOKEN INFORMATION
15350 // command.
15351 //
15352 OffloadWriteContext->TotalSectorsToProcess = totalSectorsToProcess;
15353 OffloadWriteContext->TotalSectorsProcessed = 0;
15354
15355 //
15356 // Calculate transfer size, including the header
15357 //
15358 transferSize = (blockDescrIndex * sizeof(BLOCK_DEVICE_RANGE_DESCRIPTOR)) + FIELD_OFFSET(WRITE_USING_TOKEN_HEADER, BlockDeviceRangeDescriptor);
15359
15361
15362 writeUsingTokenDataLength = (USHORT)transferSize - RTL_SIZEOF_THROUGH_FIELD(WRITE_USING_TOKEN_HEADER, WriteUsingTokenDataLength);
15363 REVERSE_BYTES_SHORT(((PWRITE_USING_TOKEN_HEADER)buffer)->WriteUsingTokenDataLength, &writeUsingTokenDataLength);
15364
15366
15367 logicalBlockOffset = OffloadWriteContext->LogicalBlockOffset + totalSectorsProcessedSuccessfully;
15368 REVERSE_BYTES_QUAD(((PWRITE_USING_TOKEN_HEADER)buffer)->BlockOffsetIntoToken, &logicalBlockOffset);
15369
15371 &offloadWriteParameters->Token,
15372 BLOCK_DEVICE_TOKEN_SIZE);
15373
15374 writeUsingTokenDescriptorsLength = (USHORT)transferSize - FIELD_OFFSET(WRITE_USING_TOKEN_HEADER, BlockDeviceRangeDescriptor);
15375 REVERSE_BYTES_SHORT(((PWRITE_USING_TOKEN_HEADER)buffer)->BlockDeviceRangeDescriptorListLength, &writeUsingTokenDescriptorsLength);
15376
15378
15381 pseudoIrp->Tail.Overlay.DriverContext[0] = LongToPtr(1);
15382 pseudoIrp->MdlAddress = writeUsingTokenMdl;
15383
15384 InterlockedCompareExchange((volatile LONG *)&TokenOperationListIdentifier, -1, MaxTokenOperationListIdentifier);
15386
15387 ClasspSetupWriteUsingTokenTransferPacket(
15388 OffloadWriteContext,
15389 pkt,
15390 transferSize,
15392 pseudoIrp,
15393 listIdentifier);
15394
15396 tokenSize,
15397 &tokenSize);
15398
15399 TracePrint((TRACE_LEVEL_INFORMATION,
15400 TRACE_FLAG_IOCTL,
15401 "ClasspContinueOffloadWrite (%p): Offloading write for %I64u bytes (versus %I64u) [via %u descriptors]. \
15402 \n\t\t\tDataLength: %u, DescriptorsLength: %u. Pkt %p (list id %x) [Token: %s]\n",
15403 fdo,
15405 entireXferLen,
15406 blockDescrIndex,
15407 writeUsingTokenDataLength,
15408 writeUsingTokenDescriptorsLength,
15409 pkt,
15410 listIdentifier,
15412
15413 FREE_POOL(tokenAscii);
15414
15415 OffloadWriteContext->ListIdentifier = listIdentifier;
15416
15417 SubmitTransferPacket(pkt);
15418
15419 //
15420 // ClasspWriteUsingTokenTransferPacketDone() takes care of completing the
15421 // IRP, so this function is done.
15422 //
15423
15424 return;
15425
15426 //
15427 // Error cleaup label only - not used in success case:
15428 //
15429
15430__ClasspContinueOffloadWrite_ErrorExit:
15431
15433
15434 //
15435 // ClasspCompleteOffloadWrite also cleans up offloadWriteContext.
15436 //
15437
15439
15440 return;
15441}
#define MAX_TOKEN_OPERATION_PARAMETER_DATA_LENGTH
Definition: classp.h:207
_IRQL_requires_same_ PUCHAR ClasspBinaryToAscii(_In_reads_(Length) PUCHAR HexBuffer, _In_ ULONG Length, _Inout_ PULONG UpdateLength)
Definition: utils.c:7717
PTRANSFER_PACKET DequeueFreeTransferPacket(PDEVICE_OBJECT Fdo, BOOLEAN AllocIfNeeded)
Definition: xferpkt.c:656
VOID ClasspCompleteOffloadWrite(_In_ __drv_freesMem(Mem) POFFLOAD_WRITE_CONTEXT OffloadWriteContext, _In_ NTSTATUS CompletionCausingStatus)
Definition: class.c:15788
struct BLOCK_DEVICE_RANGE_DESCRIPTOR * PBLOCK_DEVICE_RANGE_DESCRIPTOR
struct WRITE_USING_TOKEN_HEADER * PWRITE_USING_TOKEN_HEADER
Definition: scsi.h:3632
Definition: scsi.h:3651
Definition: ntddstor.h:766
Definition: classp.h:497
Referenced by ClasspReceiveWriteUsingTokenInformationDone().
◆ ClasspConvertToScsiRequestBlock()
| VOID ClasspConvertToScsiRequestBlock | ( | _Out_ PSCSI_REQUEST_BLOCK | Srb, |
| _In_ PSTORAGE_REQUEST_BLOCK | SrbEx | ||
| ) |
Definition at line 6559 of file utils.c.
6563{
6564 PSTOR_ADDR_BTL8 storAddrBtl8;
6567 PSRBEX_DATA srbExData;
6568
6570 return;
6571 }
6572
6574
6587
6588 //
6589 // Handle address fields
6590 //
6593
6598 } else {
6599 // Catch unsupported address types
6601 }
6602 }
6603
6604 //
6605 // Handle SRB function specific fields
6606 //
6607 if (SrbEx->NumSrbExData > 0) {
6608
6610
6613 // Catch invalid offsets
6615 continue;
6616 }
6617
6619
6620 switch (SrbEx->SrbFunction) {
6621
6623
6624 switch (srbExData->Type) {
6625
6632 foundEntry = TRUE;
6633 break;
6634
6640
6641 // Copy only the first 16 bytes
6643 foundEntry = TRUE;
6644 break;
6645
6651
6652 // Copy only the first 16 bytes
6654 foundEntry = TRUE;
6655 break;
6656
6657 default:
6658 break;
6659
6660 }
6661 break;
6662
6664
6669 foundEntry = TRUE;
6670 }
6671 break;
6672
6674
6679 foundEntry = TRUE;
6680 }
6681 break;
6682
6684
6686 ((PSCSI_POWER_REQUEST_BLOCK)Srb)->DevicePowerState = ((PSRBEX_DATA_POWER)srbExData)->DevicePowerState;
6688 ((PSCSI_POWER_REQUEST_BLOCK)Srb)->SrbPowerFlags = ((PSRBEX_DATA_POWER)srbExData)->SrbPowerFlags;
6689 foundEntry = TRUE;
6690 }
6691 break;
6692
6693 default:
6694 break;
6695
6696 }
6697
6698 //
6699 // Quit on first match
6700 //
6701 if (foundEntry) {
6702 break;
6703 }
6704 }
6705 }
6706
6707 return;
6708}
struct _SCSI_WMI_REQUEST_BLOCK * PSCSI_WMI_REQUEST_BLOCK
struct STOR_ADDRESS_ALIGN _STOR_ADDR_BTL8 * PSTOR_ADDR_BTL8
struct _SCSI_PNP_REQUEST_BLOCK * PSCSI_PNP_REQUEST_BLOCK
struct SRB_ALIGN _SRBEX_DATA_SCSI_CDB_VAR * PSRBEX_DATA_SCSI_CDB_VAR
struct _SCSI_POWER_REQUEST_BLOCK * PSCSI_POWER_REQUEST_BLOCK
struct SRB_ALIGN _SRBEX_DATA * PSRBEX_DATA
struct SRB_ALIGN _SRBEX_DATA_SCSI_CDB16 * PSRBEX_DATA_SCSI_CDB16
struct SRB_ALIGN _SRBEX_DATA_SCSI_CDB32 * PSRBEX_DATA_SCSI_CDB32
struct SRB_ALIGN _SRBEX_DATA_POWER * PSRBEX_DATA_POWER
struct SRB_ALIGN _SRBEX_DATA_WMI * PSRBEX_DATA_WMI
struct SRB_ALIGN _SRBEX_DATA_PNP * PSRBEX_DATA_PNP
Referenced by ClassInterpretSenseInfo(), InterpretSenseInfoWithoutHistory(), and InterpretTransferPacketError().
◆ ClasspCreateClose()
| NTSTATUS ClasspCreateClose | ( | IN PDEVICE_OBJECT | DeviceObject, |
| IN PIRP | Irp | ||
| ) |
Definition at line 123 of file create.c.
148{
151
153
155
156 PAGED_CODE();
157
158
159 //
160 // ISSUE-2000/3/28-henrygab - if lower stack fails create/close, we end up
161 // in an inconsistent state. re-write to verify all args and allocate all
162 // required resources, then pass the irp down, then complete the
163 // transaction. this is because we also cannot forward the irp, then fail
164 // it after it has succeeded a lower-level driver.
165 //
166
168
169 PIO_SECURITY_CONTEXT securityContext =
171 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
172 "ClasspCREATEClose: create received for device %p\n",
173 DeviceObject));
174 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
175 "ClasspCREATEClose: desired access %lx\n",
176 securityContext->DesiredAccess));
177 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
178 "ClasspCREATEClose: file object %p\n",
179 irpStack->FileObject));
180
182
184
185 PFILE_OBJECT_EXTENSION fsContext;
186
187 //
188 // Allocate our own file object extension for this device object.
189 //
190
192 &commonExtension->FileObjectDictionary,
196 (PVOID *)&fsContext);
197
199
200 RtlZeroMemory(fsContext,
202
207 }
208 }
209
210 } else {
211
212 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
213 "ClasspCreateCLOSE: close received for device %p\n",
214 DeviceObject));
215 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
216 "ClasspCreateCLOSE: file object %p\n",
217 fileObject));
218
220
221 PFILE_OBJECT_EXTENSION fsContext =
222 ClassGetFsContext(commonExtension, irpStack->FileObject);
223
224 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
225 "ClasspCreateCLOSE: file extension %p\n",
226 fsContext));
227
229
230 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
231 "ClasspCreateCLOSE: extension is ours - "
232 "freeing\n"));
234
235 ClasspCleanupProtectedLocks(fsContext);
236
237 ClasspCleanupDisableMcn(fsContext);
238
240 fsContext);
241 }
242 }
243 }
244
245 //
246 // Notify the lower levels about the create or close operation - give them
247 // a chance to cleanup too.
248 //
249
250 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
251 "ClasspCreateClose: %s for devobj %p\n",
253 DeviceObject));
254
255
257
259
260 //
261 // Set up the event to wait on
262 //
263
265
269
271
274 Executive,
275 KernelMode,
276 FALSE,
277 NULL);
279 }
280
282 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_INIT,
283 "ClasspCreateClose: Lower driver failed, but we "
284 "succeeded. This is a problem, lock counts will be "
285 "out of sync between levels.\n"));
286 }
287
288 }
289
290
292}
VOID FreeDictionaryEntry(IN PDICTIONARY Dictionary, IN PVOID Entry)
Definition: dictlib.c:189
NTSTATUS AllocateDictionaryEntry(IN PDICTIONARY Dictionary, IN ULONGLONG Key, IN ULONG Size, IN ULONG Tag, OUT PVOID *Entry)
VOID ClasspCleanupDisableMcn(IN PFILE_OBJECT_EXTENSION FsContext)
Definition: create.c:434
VOID ClasspCleanupProtectedLocks(IN PFILE_OBJECT_EXTENSION FsContext)
Definition: create.c:296
DICTIONARY FileObjectDictionary
Definition: classpnp.h:631
Definition: io.h:101
Definition: iotypes.h:2880
struct _IO_STACK_LOCATION::@5136::@5137 Create
Definition: ketypes.h:879
Definition: filter.c:185
Referenced by ClassCreateClose().
◆ ClasspDeleteTimer()
| VOID ClasspDeleteTimer | ( | _In_ PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension | ) |
Definition at line 3798 of file autorun.c.
3817{
3819
3821 fdoData = FdoExtension->PrivateFdoData;
3823#if (NTDDI_VERSION >= NTDDI_WINBLUE)
3826 ExInitializeDeleteTimerParameters(¶meters);
3829 }
3830#endif
3833 }
3834 }
3835}
Definition: extypes.h:326
NTKERNELAPI BOOLEAN NTAPI ExDeleteTimer(_In_ PEX_TIMER Timer, _In_ BOOLEAN Cancel, _In_ BOOLEAN Wait, _In_opt_ PEXT_DELETE_PARAMETERS Parameters)
Referenced by ClassPnpStartDevice().
◆ ClasspDeviceGetBlockDeviceCharacteristicsVPDPage()
| NTSTATUS ClasspDeviceGetBlockDeviceCharacteristicsVPDPage | ( | _In_ PFUNCTIONAL_DEVICE_EXTENSION | fdoExtension, |
| _In_ PSCSI_REQUEST_BLOCK | Srb | ||
| ) |
Definition at line 2072 of file utils.c.
2095{
2097 PCDB cdb;
2101
2102
2103#if defined(_ARM_) || defined(_ARM64_)
2104 //
2105 // ARM has specific alignment requirements, although this will not have a functional impact on x86 or amd64
2106 // based platforms. We are taking the conservative approach here.
2107 //
2108 allocationBufferLength = ALIGN_UP_BY(allocationBufferLength,KeGetRecommendedSharedDataAlignment());
2109 dataBuffer = (PVPD_BLOCK_DEVICE_CHARACTERISTICS_PAGE)ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
2110 allocationBufferLength,
2111 '5CcS'
2112 );
2113#else
2114
2116 bufferLength,
2117 '5CcS'
2118 );
2119#endif
2123 }
2124
2126
2127 // prepare the Srb
2132
2134
2139 cdb->CDB6INQUIRY3.AllocationLength = bufferLength; //AllocationLength field in CDB6INQUIRY3 is only one byte.
2140
2142 Srb,
2143 dataBuffer,
2144 allocationBufferLength,
2145 FALSE);
2148 // the device should return at least 8 bytes of data for use.
2150 } else if ( (dataBuffer->PageLength != 0x3C) || (dataBuffer->PageCode != VPD_BLOCK_DEVICE_CHARACTERISTICS) ) {
2151 // 'PageLength' shall be 0x3C; and 'PageCode' shall match.
2153 } else {
2154 // cache data into fdoExtension
2155 fdoExtension->FunctionSupportInfo->DeviceCharacteristicsData.MediumRotationRate = (dataBuffer->MediumRotationRateMsb << 8) |
2156 dataBuffer->MediumRotationRateLsb;
2157 fdoExtension->FunctionSupportInfo->DeviceCharacteristicsData.MediumProductType = dataBuffer->MediumProductType;
2158 fdoExtension->FunctionSupportInfo->DeviceCharacteristicsData.NominalFormFactor = dataBuffer->NominalFormFactor;
2159 }
2160 } else {
2161 // the command failed, surface up the command error from 'status' variable. Nothing to do here.
2162 }
2163
2164Exit:
2167 }
2168
2170}
ULONG NTAPI KeGetRecommendedSharedDataAlignment(VOID)
Definition: cpu.c:535
struct _VPD_BLOCK_DEVICE_CHARACTERISTICS_PAGE VPD_BLOCK_DEVICE_CHARACTERISTICS_PAGE
struct _VPD_BLOCK_DEVICE_CHARACTERISTICS_PAGE * PVPD_BLOCK_DEVICE_CHARACTERISTICS_PAGE
FORCEINLINE VOID SrbAssignSrbFlags(_In_ PVOID Srb, _In_ ULONG Flags)
Definition: srbhelper.h:954
struct _CDB::_CDB6INQUIRY3 CDB6INQUIRY3
Referenced by ClasspDeviceMediaTypeProperty(), and ClasspDeviceSeekPenaltyProperty().
◆ ClasspDeviceGetBlockLimitsVPDPage()
| NTSTATUS ClasspDeviceGetBlockLimitsVPDPage | ( | _In_ PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| _Inout_bytecount_(SrbSize) PSCSI_REQUEST_BLOCK | Srb, | ||
| _In_ ULONG | SrbSize, | ||
| _Out_ PCLASS_VPD_B0_DATA | BlockLimitsData | ||
| ) |
Definition at line 2521 of file utils.c.
2527{
2532 PCDB cdb;
2534 ULONG dataTransferLength = 0;
2535
2536 //
2537 // Set default values for UNMAP parameters based upon UNMAP support or lack
2538 // thereof.
2539 //
2541 //
2542 // If UNMAP is supported, we default to the maximum LBA count and
2543 // block descriptor count. We also default the UNMAP granularity to
2544 // a single block and specify no granularity alignment.
2545 //
2546 BlockLimitsData->MaxUnmapLbaCount = (ULONG)-1;
2547 BlockLimitsData->MaxUnmapBlockDescrCount = (ULONG)-1;
2548 BlockLimitsData->OptimalUnmapGranularity = 1;
2549 BlockLimitsData->UnmapGranularityAlignment = 0;
2550 BlockLimitsData->UGAVALID = FALSE;
2551 } else {
2552 BlockLimitsData->MaxUnmapLbaCount = 0;
2553 BlockLimitsData->MaxUnmapBlockDescrCount = 0;
2554 BlockLimitsData->OptimalUnmapGranularity = 0;
2555 BlockLimitsData->UnmapGranularityAlignment = 0;
2556 BlockLimitsData->UGAVALID = FALSE;
2557 }
2558
2559 //
2560 // Try to get the Block Limits VPD page (0xB0), if it is supported.
2561 //
2563 {
2564#if defined(_ARM_) || defined(_ARM64_)
2565 //
2566 // ARM has specific alignment requirements, although this will not have a functional impact on x86 or amd64
2567 // based platforms. We are taking the conservative approach here.
2568 //
2569 allocationBufferLength = ALIGN_UP_BY(allocationBufferLength, KeGetRecommendedSharedDataAlignment());
2570 dataBuffer = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned, allocationBufferLength, '0CcS');
2571#else
2573#endif
2575 {
2576 // return without updating FdoExtension->FunctionSupportInfo->BlockLimitsData.CommandStatus
2577 // the field will remain value as "-1", so that the command will be attempted next time this function is called.
2580 }
2581
2583
2585
2587
2588#ifdef _MSC_VER
2589 #pragma prefast(suppress:26015, "InitializeStorageRequestBlock ensures buffer access is bounded")
2590#endif
2593 SrbSize,
2594 1,
2595 SrbExDataTypeScsiCdb16);
2596
2599 } else {
2600 //
2601 // Should not occur.
2602 //
2604 }
2605 } else {
2610 }
2611
2613 // prepare the Srb
2618
2620
2625 cdb->CDB6INQUIRY3.AllocationLength = bufferLength; //AllocationLength field in CDB6INQUIRY3 is only one byte.
2626
2628 Srb,
2629 dataBuffer,
2630 allocationBufferLength,
2631 FALSE);
2633 }
2634
2635 //
2636 // Handle the case where we get back STATUS_DATA_OVERRUN b/c the input
2637 // buffer was larger than necessary.
2638 //
2639
2641 {
2643 }
2644
2646 {
2647 USHORT pageLength;
2649
2650 //
2651 // Regardless of the device's support for unmap, cache away at least the basic block limits information
2652 //
2654
2655 // (6:7) OPTIMAL TRANSFER LENGTH GRANULARITY
2656 REVERSE_BYTES_SHORT(&BlockLimitsData->OptimalTransferLengthGranularity, &blockLimits->OptimalTransferLengthGranularity);
2657 // (8:11) MAXIMUM TRANSFER LENGTH
2659 // (12:15) OPTIMAL TRANSFER LENGTH
2661 }
2662
2663 if ((dataTransferLength < 0x24) ||
2664 (pageLength < (FIELD_OFFSET(VPD_BLOCK_LIMITS_PAGE,Reserved1) - FIELD_OFFSET(VPD_BLOCK_LIMITS_PAGE,Reserved0))) ||
2666 {
2667 // the device should return at least 36 bytes of data for use.
2668 // 'PageCode' shall match and we need all the relevant data after the header.
2670 }
2671 }
2672
2674 {
2675 // cache data into FdoExtension
2676 // (20:23) MAXIMUM UNMAP LBA COUNT
2678 // (24:27) MAXIMUM UNMAP BLOCK DESCRIPTOR COUNT
2679 REVERSE_BYTES(&BlockLimitsData->MaxUnmapBlockDescrCount, &blockLimits->MaximumUnmapBlockDescriptorCount);
2680 // (28:31) OPTIMAL UNMAP GRANULARITY
2681 REVERSE_BYTES(&BlockLimitsData->OptimalUnmapGranularity, &blockLimits->OptimalUnmapGranularity);
2682
2683 // (32:35) UNMAP GRANULARITY ALIGNMENT; (32) bit7: UGAVALID
2684 BlockLimitsData->UGAVALID = blockLimits->UGAValid;
2686 REVERSE_BYTES(&BlockLimitsData->UnmapGranularityAlignment, &blockLimits->UnmapGranularityAlignment);
2687 BlockLimitsData->UnmapGranularityAlignment &= 0x7FFFFFFF; // remove value of UGAVALID bit.
2688 } else {
2689 BlockLimitsData->UnmapGranularityAlignment = 0;
2690 }
2691
2692 TracePrint((TRACE_LEVEL_INFORMATION,
2693 TRACE_FLAG_PNP,
2694 "ClasspDeviceGetBlockLimitsVPDPage (%p): %s %s (rev %s) reported following parameters: \
2695 \n\t\t\tOptimalTransferLengthGranularity: %u \
2696 \n\t\t\tMaximumTransferLength: %u \
2697 \n\t\t\tOptimalTransferLength: %u \
2698 \n\t\t\tMaximumUnmapLBACount: %u \
2699 \n\t\t\tMaximumUnmapBlockDescriptorCount: %u \
2700 \n\t\t\tOptimalUnmapGranularity: %u \
2701 \n\t\t\tUGAValid: %u \
2702 \n\t\t\tUnmapGranularityAlignment: %u\n",
2703 FdoExtension->DeviceObject,
2704 (PCSZ)(((PUCHAR)FdoExtension->DeviceDescriptor) + FdoExtension->DeviceDescriptor->VendorIdOffset),
2705 (PCSZ)(((PUCHAR)FdoExtension->DeviceDescriptor) + FdoExtension->DeviceDescriptor->ProductIdOffset),
2706 (PCSZ)(((PUCHAR)FdoExtension->DeviceDescriptor) + FdoExtension->DeviceDescriptor->ProductRevisionOffset),
2707 BlockLimitsData->OptimalTransferLengthGranularity,
2708 BlockLimitsData->MaximumTransferLength,
2709 BlockLimitsData->OptimalTransferLength,
2710 BlockLimitsData->MaxUnmapLbaCount,
2711 BlockLimitsData->MaxUnmapBlockDescrCount,
2712 BlockLimitsData->OptimalUnmapGranularity,
2713 BlockLimitsData->UGAVALID,
2714 BlockLimitsData->UnmapGranularityAlignment));
2715
2716 }
2717 } else {
2719 }
2720
2721 BlockLimitsData->CommandStatus = status;
2722
2723Exit:
2725
2727}
struct _VPD_BLOCK_LIMITS_PAGE * PVPD_BLOCK_LIMITS_PAGE
Definition: scsi.h:2573
UCHAR OptimalUnmapGranularity[4]
Definition: scsi.h:2588
UCHAR OptimalTransferLengthGranularity[2]
Definition: scsi.h:2582
UCHAR MaximumUnmapBlockDescriptorCount[4]
Definition: scsi.h:2587
UCHAR UnmapGranularityAlignment[4]
Definition: scsi.h:2597
Referenced by ClasspGetLBProvisioningInfo(), and ClasspRefreshFunctionSupportInfo().
◆ ClasspDeviceGetLBAStatus()
| NTSTATUS ClasspDeviceGetLBAStatus | ( | _In_ PDEVICE_OBJECT | DeviceObject, |
| _Inout_ PIRP | Irp, | ||
| _Inout_ PSCSI_REQUEST_BLOCK | Srb | ||
| ) |
Definition at line 3861 of file utils.c.
3911{
3912 PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
3914 PDEVICE_MANAGE_DATA_SET_ATTRIBUTES dsmAttributes = (PDEVICE_MANAGE_DATA_SET_ATTRIBUTES)Irp->AssociatedIrp.SystemBuffer;
3916 PDEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT dsmOutput = (PDEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT)Irp->AssociatedIrp.SystemBuffer;
3917 ULONG dsmOutputLength;
3918 NTSTATUS finalStatus;
3919 NTSTATUS getLBAWorkerStatus;
3920 ULONG retryCount;
3921 ULONG retryCountMax;
3922 CLASS_VPD_B0_DATA blockLimitsData;
3923 ULONG generationCount1;
3924 ULONG generationCount2;
3925 BOOLEAN blockLimitsDataMayHaveChanged;
3927 LONGLONG startingOffset;
3928 ULONGLONG lengthInBytes;
3930 ULONG outputVersion;
3931
3932 //
3933 // Basic parameter validation.
3934 // Note that InputBufferLength and IsFdo have been validated beforing entering this routine.
3935 //
3937 dsmAttributes == NULL)
3938 {
3939 finalStatus = STATUS_INVALID_PARAMETER;
3941 }
3942
3944 //
3945 // The caller wants the mapping status of the entire disk.
3946 //
3947 ULONG unmapGranularityAlignment = 0;
3948 if (fdoExtension->FunctionSupportInfo->BlockLimitsData.UGAVALID) {
3949 unmapGranularityAlignment = fdoExtension->FunctionSupportInfo->BlockLimitsData.UnmapGranularityAlignment;
3950 }
3951 startingOffset = unmapGranularityAlignment;
3952 lengthInBytes = (ULONGLONG)fdoExtension->CommonExtension.PartitionLength.QuadPart - (ULONGLONG)startingOffset;
3953 } else {
3955 dsmAttributes->DataSetRangesLength == 0) {
3956 finalStatus = STATUS_INVALID_PARAMETER;
3958 }
3959
3960 //
3961 // We only service the first dataset range specified.
3962 //
3963 dataSetRanges = (PDEVICE_DATA_SET_RANGE)((PUCHAR)dsmAttributes + dsmAttributes->DataSetRangesOffset);
3964 startingOffset = dataSetRanges[0].StartingOffset;
3965 lengthInBytes = dataSetRanges[0].LengthInBytes;
3966 }
3967
3968
3969 //
3970 // See if the sender is requesting a specific version of the output data
3971 // structure. Othwerwise, default to V1.
3972 //
3973 outputVersion = DEVICE_DATA_SET_LB_PROVISIONING_STATE_VERSION_V1;
3974#if (NTDDI_VERSION >= NTDDI_WINBLUE)
3977 PDEVICE_DATA_SET_LBP_STATE_PARAMETERS parameters = Add2Ptr(dsmAttributes, dsmAttributes->ParameterBlockOffset);
3980
3981 outputVersion = parameters->OutputVersion;
3982
3984 (outputVersion != DEVICE_DATA_SET_LB_PROVISIONING_STATE_VERSION_V2)) {
3985 finalStatus = STATUS_INVALID_PARAMETER;
3987 }
3988 }
3989 }
3990#endif
3991
3992 //
3993 // Take a snapshot of the block limits data for the worker function to use.
3994 // We need to fail the request if we fail to get updated block limits data
3995 // since we need an accurate Optimal Unmap Granularity value to properly
3996 // convert the returned mapping descriptors into a bitmap.
3997 //
3998 finalStatus = ClasspBlockLimitsDataSnapshot(fdoExtension,
3999 TRUE,
4000 &blockLimitsData,
4001 &generationCount1);
4002
4004 information = 0;
4006 }
4007
4009 consolidateableBlocksOnly = TRUE;
4010 }
4011
4012 //
4013 // The retry logic is to handle the case when block limits data changes during rare occasions
4014 // (e.g. diff-VHD fork or merge).
4015 //
4016 retryCountMax = GET_LBA_STATUS_RETRY_COUNT_MAX;
4017 for (retryCount = 0; retryCount < retryCountMax; retryCount++) {
4018
4019 dsmOutputLength = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
4021 &blockLimitsData,
4022 startingOffset,
4023 lengthInBytes,
4024 dsmOutput,
4025 &dsmOutputLength,
4026 Srb,
4027 consolidateableBlocksOnly,
4028 outputVersion,
4029 &blockLimitsDataMayHaveChanged);
4030
4032 information = 0;
4033 finalStatus = getLBAWorkerStatus;
4034 break;
4035 }
4036
4037 //
4038 // Again, we need to fail the request if we fail to get updated block
4039 // limits data since we need an accurate Optimal Unmap Granularity value.
4040 //
4041 finalStatus = ClasspBlockLimitsDataSnapshot(fdoExtension,
4042 TRUE,
4043 &blockLimitsData,
4044 &generationCount2);
4046 information = 0;
4048 }
4049
4050 if (generationCount1 == generationCount2) {
4051 //
4052 // Block limits data stays the same during the call to ClasspDeviceGetLBAStatusWorker()
4053 // The result from ClasspDeviceGetLBAStatusWorker() is valid.
4054 //
4055 finalStatus = getLBAWorkerStatus;
4057 information = dsmOutputLength;
4058 }
4059 break;
4060 }
4061
4062 //
4063 // Try again with the latest block limits data
4064 //
4065 generationCount1 = generationCount2;
4066 information = 0;
4067 finalStatus = STATUS_DEVICE_DATA_ERROR;
4068 }
4069
4070Exit:
4072 Irp->IoStatus.Status = finalStatus;
4075 return finalStatus;
4076}
struct _FUNCTIONAL_DEVICE_EXTENSION * PFUNCTIONAL_DEVICE_EXTENSION
NTSTATUS ClasspBlockLimitsDataSnapshot(_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _In_ BOOLEAN ForceQuery, _Out_ PCLASS_VPD_B0_DATA BlockLimitsData, _Out_ PULONG GenerationCount)
Definition: class.c:16504
NTSTATUS ClasspDeviceGetLBAStatusWorker(_In_ PDEVICE_OBJECT DeviceObject, _In_ PCLASS_VPD_B0_DATA BlockLimitsData, _In_ ULONGLONG StartingOffset, _In_ ULONGLONG LengthInBytes, _Out_ PDEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT DsmOutput, _Inout_ PULONG DsmOutputLength, _Inout_ PSCSI_REQUEST_BLOCK Srb, _In_ BOOLEAN ConsolidateableBlocksOnly, _In_ ULONG OutputVersion, _Out_ PBOOLEAN BlockLimitsDataMayHaveChanged)
Definition: utils.c:4079
#define DEVICE_DATA_SET_LB_PROVISIONING_STATE_VERSION_V1
Definition: ntddstor.h:939
#define DEVICE_DSM_FLAG_ENTIRE_DATA_SET_RANGE
Definition: ntddstor.h:306
struct _DEVICE_DATA_SET_RANGE * PDEVICE_DATA_SET_RANGE
#define DEVICE_DSM_FLAG_ALLOCATION_CONSOLIDATEABLE_ONLY
Definition: ntddstor.h:963
struct _DEVICE_MANAGE_DATA_SET_ATTRIBUTES * PDEVICE_MANAGE_DATA_SET_ATTRIBUTES
#define DEVICE_DATA_SET_LB_PROVISIONING_STATE_VERSION_V2
Definition: ntddstor.h:953
Definition: classpnp.h:748
ULONG ParameterBlockLength
Definition: ntddstor.h:776
ULONG ParameterBlockOffset
Definition: ntddstor.h:775
ULONG DataSetRangesOffset
Definition: ntddstor.h:777
ULONG DataSetRangesLength
Definition: ntddstor.h:778
COMMON_DEVICE_EXTENSION CommonExtension
Definition: classpnp.h:873
Referenced by ClassDeviceControl().
◆ ClasspDeviceGetLBAStatusWorker()
| NTSTATUS ClasspDeviceGetLBAStatusWorker | ( | _In_ PDEVICE_OBJECT | DeviceObject, |
| _In_ PCLASS_VPD_B0_DATA | BlockLimitsData, | ||
| _In_ ULONGLONG | StartingOffset, | ||
| _In_ ULONGLONG | LengthInBytes, | ||
| _Out_ PDEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT | DsmOutput, | ||
| _Inout_ PULONG | DsmOutputLength, | ||
| _Inout_ PSCSI_REQUEST_BLOCK | Srb, | ||
| _In_ BOOLEAN | ConsolidateableBlocksOnly, | ||
| _In_ ULONG | OutputVersion, | ||
| _Out_ PBOOLEAN | BlockLimitsDataMayHaveChanged | ||
| ) |
Definition at line 4079 of file utils.c.
4147{
4149
4150 PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
4151
4152 PDEVICE_DATA_SET_LB_PROVISIONING_STATE lbpState;
4153 ULONG bitMapGranularityInBits = FIELD_SIZE(DEVICE_DATA_SET_LB_PROVISIONING_STATE,SlabAllocationBitMap[0]) * 8;
4154 ULONG requiredOutputLength;
4155 ULONG outputLength = *DsmOutputLength;
4156
4157 ULONG blocksPerSlab;
4158 ULONGLONG bytesPerSlab;
4159 ULONGLONG alignmentInBytes = 0;
4160 ULONG alignmentInBlocks = 0;
4161 ULONG maxBufferSize;
4162 ULONG maxSlabs;
4164 ULONGLONG startingLBA;
4165 ULONGLONG startingOffsetDelta;
4169
4170 ULONG lbaStatusSize;
4172
4173 //
4174 // This function can fail if the block limits data on the device changes.
4175 // This flag tells the caller if it should retry with a newer block limits data
4176 //
4177 *BlockLimitsDataMayHaveChanged = FALSE;
4178
4179 //
4180 // Make sure we're running at PASSIVE_LEVEL
4181 //
4183 {
4187 }
4188
4189 //
4190 // Don't send down a Get LBA Status command if UNMAP isn't supported.
4191 //
4192 if (!fdoExtension->FunctionSupportInfo->LBProvisioningData.LBPU)
4193 {
4196 }
4197
4198 //
4199 // Make sure we have a non-zero value for the number of bytes per block.
4200 // Otherwise we will end up dividing by zero later on.
4201 //
4203 {
4206 {
4209 }
4210 }
4211
4212 //
4213 // We only service the first dataset range specified.
4214 //
4216 alignmentInBlocks = BlockLimitsData->UnmapGranularityAlignment;
4217 alignmentInBytes = (ULONGLONG)alignmentInBlocks * (ULONGLONG)fdoExtension->DiskGeometry.BytesPerSector;
4218 }
4219
4220 //
4221 // Make sure the specified range is valid. The Unmap Granularity Alignment
4222 // defines a region at the beginning of the disk that cannot be
4223 // mapped/unmapped so the specified range should not include any part of that
4224 // region.
4225 //
4226 if (LengthInBytes == 0 ||
4227 StartingOffset < alignmentInBytes ||
4228 StartingOffset + LengthInBytes > (ULONGLONG)fdoExtension->CommonExtension.PartitionLength.QuadPart)
4229 {
4230 TracePrint((TRACE_LEVEL_ERROR,
4231 TRACE_FLAG_IOCTL,
4232 "ClasspDeviceGetLBAStatusWorker (%p): Invalid range, length is %I64u bytes, starting offset is %I64u bytes, Unmap alignment is %I64u bytes, and disk size is %I64u bytes\n",
4233 DeviceObject,
4234 LengthInBytes,
4235 StartingOffset,
4236 alignmentInBytes,
4238
4241 }
4242
4243 //
4244 // Calculate the number of bytes per slab so that we can convert (and
4245 // possibly align) the given offset (given in bytes) to slabs.
4246 //
4247 blocksPerSlab = BlockLimitsData->OptimalUnmapGranularity;
4248 bytesPerSlab = (ULONGLONG)blocksPerSlab * (ULONGLONG)fdoExtension->DiskGeometry.BytesPerSector;
4249
4250 //
4251 // If the starting offset is not slab-aligned, we need to adjust it to
4252 // be aligned with the next highest slab. We also need to save the delta
4253 // to return to the user later.
4254 //
4256 {
4257 startingLBA = (((StartingOffset - alignmentInBytes) / bytesPerSlab) + 1) * (ULONGLONG)blocksPerSlab + alignmentInBlocks;
4258 startingOffsetDelta = (startingLBA * fdoExtension->DiskGeometry.BytesPerSector) - StartingOffset;
4259 }
4260 else
4261 {
4262 startingLBA = ((StartingOffset - alignmentInBytes) / bytesPerSlab) * (ULONGLONG)blocksPerSlab + alignmentInBlocks;
4263 startingOffsetDelta = 0;
4264 }
4265
4266 //
4267 // Caclulate the number of slabs the caller requested.
4268 //
4269 if ((LengthInBytes % bytesPerSlab) == 0) {
4270 requestedSlabs = (LengthInBytes / bytesPerSlab);
4271 } else {
4272 //
4273 // Round up the number of requested slabs if the length indicates a
4274 // partial slab. This should cover the case where the user specifies
4275 // a dataset range for the whole disk, but the size of the disk is not
4276 // a slab-multiple. Rounding up allows us to return the status of the
4277 // partial slab
4278 //
4279 requestedSlabs = (LengthInBytes / bytesPerSlab) + 1;
4280 }
4281
4282 //
4283 // If the caller asked for no slabs then return STATUS_INVALID_PARAMETER.
4284 //
4285 if (requestedSlabs == 0)
4286 {
4287 TracePrint((TRACE_LEVEL_ERROR,
4288 TRACE_FLAG_IOCTL,
4289 "ClasspDeviceGetLBAStatusWorker (%p): Invalid number (%I64u) of slabs requested\n",
4290 DeviceObject,
4291 requestedSlabs));
4292
4295 }
4296
4297 //
4298 // Cap requested slabs at MAXULONG since SlabAllocationBitMapBitCount
4299 // is a 4-byte field. We may return less data than requested, but the
4300 // caller can simply re-query for the omitted portion(s).
4301 //
4303
4304 //
4305 // Calculate the required size of the output buffer based upon the desired
4306 // version of the output structure.
4307 // In the worst case, Get LBA Status returns a descriptor for each slab
4308 // requested, thus the required output buffer length is equal to:
4309 // 1. The size of DEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT; plus
4310 // 2. The size of DEVICE_DATA_SET_LB_PROVISIONING_STATE(_V2); plus
4311 // 3. The size of a ULONG array large enough to hold a bit for each slab requested.
4312 // (The first element is already allocated in DEVICE_DATA_SET_LB_PROVISIONING_STATE(_V2).)
4313 //
4314#if (NTDDI_VERSION >= NTDDI_WINBLUE)
4316
4319 + (((requestedSlabs - 1) / bitMapGranularityInBits))
4321
4322 } else
4323#else
4324 UNREFERENCED_PARAMETER(OutputVersion);
4325#endif
4326 {
4327
4330 + (((requestedSlabs - 1) / bitMapGranularityInBits))
4332 }
4333
4334 //
4335 // The output buffer is not big enough to hold the requested data.
4336 // Inform the caller of the correct buffer size.
4337 //
4338 if (outputLength < requiredOutputLength)
4339 {
4341
4342 TracePrint((TRACE_LEVEL_ERROR,
4343 TRACE_FLAG_IOCTL,
4344 "ClasspDeviceGetLBAStatusWorker (%p): Given output buffer is %u bytes, needs to be %u bytes\n",
4345 DeviceObject,
4346 outputLength,
4347 requiredOutputLength));
4348
4349 //
4350 // If the output buffer is big enough, write the required buffer
4351 // length to the first ULONG bytes of the output buffer.
4352 //
4354 {
4355 *((PULONG)DsmOutput) = requiredOutputLength;
4356 }
4357
4359 }
4360
4361 //
4362 // Calculate the maximum number of slabs that could be returned by a single
4363 // Get LBA Status command. The max buffer size could either be capped by
4364 // the Parameter Data Length field or the Max Transfer Length of the
4365 // adapter.
4366 // The number of slabs we actually ask for in a single command is the
4367 // smaller of the number of slabs requested by the user or the max number
4368 // of slabs we can theoretically ask for in a single command.
4369 //
4372 slabsPerCommand = min(requestedSlabs, maxSlabs);
4373
4374 //
4375 // Allocate the buffer that will contain the returned LBA Status Descriptors.
4376 // Assume that in the worst case every other slab has a different mapping
4377 // status. That means that there may be a descriptor for every slab requested.
4378 //
4379 lbaStatusSize = (ULONG)(sizeof(LBA_STATUS_LIST_HEADER) + (slabsPerCommand * sizeof(LBA_STATUS_DESCRIPTOR)));
4380#if defined(_ARM_) || defined(_ARM64_)
4381 //
4382 // ARM has specific alignment requirements, although this will not have a functional impact on x86 or amd64
4383 // based platforms. We are taking the conservative approach here.
4384 //
4386 lbaStatusListHeader = (PLBA_STATUS_LIST_HEADER)ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned, lbaStatusSize, CLASS_TAG_LB_PROVISIONING);
4387#else
4388 lbaStatusListHeader = (PLBA_STATUS_LIST_HEADER)ExAllocatePoolWithTag(NonPagedPoolNx, lbaStatusSize, CLASS_TAG_LB_PROVISIONING);
4389#endif
4390
4392 {
4393 TracePrint((TRACE_LEVEL_ERROR,
4394 TRACE_FLAG_IOCTL,
4395 "ClasspDeviceGetLBAStatusWorker (%p): Failed to allocate %u bytes for descriptors\n",
4396 DeviceObject,
4397 lbaStatusSize));
4398
4402 }
4403
4404 //
4405 // Set default values for the output buffer.
4406 // If we process at least one slab from the device we will update the
4407 // offset and lengths accordingly.
4408 //
4409 DsmOutput->Action = DeviceDsmAction_Allocation;
4411 DsmOutput->OutputBlockOffset = 0;
4412 DsmOutput->OutputBlockLength = 0;
4413 *DsmOutputLength = DsmOutput->Size;
4414
4415 //
4416 // The returned DEVICE_DATA_SET_LB_PROVISIONING_STATE is at the end of the
4417 // DSM output structure. Zero it out before we start to fill it in.
4418 //
4420 RtlZeroMemory(lbpState, requiredOutputLength - sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT));
4421
4422 do {
4423 //
4424 // Send down GetLBAStatus for the current range.
4425 //
4427 Srb,
4428 startingLBA,
4429 lbaStatusListHeader,
4430 lbaStatusSize,
4431 ConsolidateableBlocksOnly);
4432
4434 {
4435 ULONG descrIndex = 0;
4436 ULONG descrSize = 0;
4437 ULONG descrSizeOverhead;
4438 ULONG descrCount = 0;
4439 ULONGLONG expectedStartingLBA;
4442
4446
4447 //
4448 // If the returned Parameter Data Length field describes more
4449 // descriptors than we allocated space for then make sure we don't
4450 // try to process more descriptors than are actually present.
4451 //
4452 if (descrSize > (lbaStatusSize - RTL_SIZEOF_THROUGH_FIELD(LBA_STATUS_LIST_HEADER, ParameterLength))) {
4453 descrSize = (lbaStatusSize - RTL_SIZEOF_THROUGH_FIELD(LBA_STATUS_LIST_HEADER, ParameterLength));
4454 }
4455
4456 if (descrSize >= descrSizeOverhead) {
4457 descrSize -= descrSizeOverhead;
4459
4460 //
4461 // Make sure at least one descriptor was returned.
4462 //
4463 if (descrCount > 0) {
4464 //
4465 // We expect the first starting LBA returned by the device to be the
4466 // same starting LBA we specified in the command.
4467 //
4468 expectedStartingLBA = startingLBA;
4469
4470 //
4471 // Translate the returned LBA status descriptors into a bitmap where each bit represents
4472 // a slab. The slab size is represented by the Optimal Unmap Granularity.
4473 // 1 = The slab is mapped.
4474 // 0 = The slab is unmapped (deallocated or anchored).
4475 //
4476 for (descrIndex = 0; descrIndex < descrCount && totalProcessedSlabs < requestedSlabs && !doneProcessing; descrIndex++)
4477 {
4479 ULONGLONG returnedStartingLBA;
4481 ULONG lbaCount = 0;
4482
4485
4486 if (returnedStartingLBA != expectedStartingLBA)
4487 {
4488 //
4489 // We expect the descriptors will express a contiguous range of LBAs.
4490 // If the starting LBA is not contiguous with the LBA range from the
4491 // previous descriptor then we should not process any more descriptors,
4492 // including the current one.
4493 //
4494 TracePrint((TRACE_LEVEL_ERROR,
4495 TRACE_FLAG_IOCTL,
4496 "ClasspDeviceGetLBAStatusWorker (%p): Device returned starting LBA = %I64x when %I64x was expected.\n",
4497 DeviceObject,
4498 returnedStartingLBA,
4499 startingLBA));
4500
4501 doneProcessing = TRUE;
4502 processCurrentDescriptor = FALSE;
4503 *BlockLimitsDataMayHaveChanged = TRUE;
4504 }
4505 else if (lbaCount > 0 && lbaCount % blocksPerSlab != 0)
4506 {
4507 //
4508 // If the device returned an LBA count with a partial slab, round
4509 // the LBA count up to the nearest slab and set a flag to stop
4510 // processing further descriptors. This is mainly to handle the
4511 // case where disk size may not be slab-aligned and thus the last
4512 // "slab" is actually a partial slab.
4513 //
4514 TracePrint((TRACE_LEVEL_WARNING,
4515 TRACE_FLAG_IOCTL,
4516 "ClasspDeviceGetLBAStatusWorker (%p): Device returned an LBA count (%u) that is not a multiple of the slab size (%u)\n",
4517 DeviceObject,
4518 lbaCount,
4519 blocksPerSlab));
4520
4521 lbaCount = ((lbaCount / blocksPerSlab) + 1) * blocksPerSlab;
4522
4523 doneProcessing = TRUE;
4524 processCurrentDescriptor = TRUE;
4525 }
4526 else if (lbaCount == 0)
4527 {
4528 //
4529 // If the LBA count is 0, just skip this descriptor.
4530 //
4531 TracePrint((TRACE_LEVEL_WARNING,
4532 TRACE_FLAG_IOCTL,
4533 "ClasspDeviceGetLBAStatusWorker (%p): Device returned a zero LBA count\n",
4534 DeviceObject));
4535
4536 processCurrentDescriptor = FALSE;
4537 }
4538
4539 //
4540 // Generate bits for the slabs described in the current descriptor.
4541 // It's possible the device may have returned more slabs than requested
4542 // so we make sure to stop once we've processed all we need.
4543 //
4544 if (processCurrentDescriptor)
4545 {
4547
4548 for(; 0 < descrSlabs && totalProcessedSlabs < requestedSlabs; descrSlabs--, commandProcessedSlabs++, totalProcessedSlabs++)
4549 {
4550 ULONG bitMapIndex = totalProcessedSlabs / bitMapGranularityInBits;
4551 ULONG bitPos = totalProcessedSlabs % bitMapGranularityInBits;
4552
4553 #if (NTDDI_VERSION >= NTDDI_WINBLUE)
4555 ((PDEVICE_DATA_SET_LB_PROVISIONING_STATE_V2)lbpState)->SlabAllocationBitMap[bitMapIndex] |= (mapped << bitPos);
4556 } else
4557 #endif
4558 {
4559 lbpState->SlabAllocationBitMap[bitMapIndex] |= (mapped << bitPos);
4560 }
4561 }
4562 }
4563
4564 //
4565 // Calculate the next expected starting LBA.
4566 //
4567 expectedStartingLBA = returnedStartingLBA + lbaCount;
4568 }
4569
4570 if (commandProcessedSlabs > 0) {
4571
4572 //
4573 // Calculate the starting LBA we'll use for the next command.
4574 //
4576
4577 } else {
4578 //
4579 // This should never happen, but we should handle it gracefully anyway.
4580 //
4581 TracePrint((TRACE_LEVEL_ERROR,
4582 TRACE_FLAG_IOCTL,
4583 "ClasspDeviceGetLBAStatusWorker (%p): The slab allocation bitmap has zero length.\n",
4584 DeviceObject));
4585
4586 NT_ASSERT(commandProcessedSlabs != 0);
4587 doneProcessing = TRUE;
4589 }
4590 } else {
4591 TracePrint((TRACE_LEVEL_ERROR,
4592 TRACE_FLAG_IOCTL,
4593 "ClasspDeviceGetLBAStatusWorker (%p): Device returned no LBA Status Descriptors.\n",
4594 DeviceObject));
4595
4596 doneProcessing = TRUE;
4598 }
4599 } else {
4600 TracePrint((TRACE_LEVEL_ERROR,
4601 TRACE_FLAG_IOCTL,
4602 "ClasspDeviceGetLBAStatusWorker (%p): not enough bytes returned\n",
4603 DeviceObject));
4604
4605 doneProcessing = TRUE;
4607 }
4608 }
4609
4610 //
4611 // Loop until we encounter some error or we've processed all the requested slabs.
4612 //
4614 !doneProcessing &&
4615 (totalProcessedSlabs < requestedSlabs));
4616
4617 //
4618 // At least one slab was returned by the device and processed, which we
4619 // consider success. It's up to the caller to detect truncation.
4620 // Update the output buffer sizes, offsets, etc. accordingly.
4621 //
4622 if (totalProcessedSlabs > 0) {
4623
4624 #if (NTDDI_VERSION >= NTDDI_WINBLUE)
4626 PDEVICE_DATA_SET_LB_PROVISIONING_STATE_V2 lbpStateV2 = (PDEVICE_DATA_SET_LB_PROVISIONING_STATE_V2)lbpState;
4627
4628 lbpStateV2->SlabSizeInBytes = bytesPerSlab;
4629 lbpStateV2->SlabOffsetDeltaInBytes = startingOffsetDelta;
4630 lbpStateV2->SlabAllocationBitMapBitCount = totalProcessedSlabs;
4631 lbpStateV2->SlabAllocationBitMapLength = ((totalProcessedSlabs - 1) / (ULONGLONG)bitMapGranularityInBits) + 1;
4633
4634 //
4635 // Note that there is already one element of the bitmap array allocated
4636 // in the DEVICE_DATA_SET_LB_PROVISIONING_STATE_V2 structure itself, which
4637 // is why we subtract 1 from SlabAllocationBitMapLength.
4638 //
4640 + ((lbpStateV2->SlabAllocationBitMapLength - 1) * sizeof(lbpStateV2->SlabAllocationBitMap[0]));
4641
4642 } else
4643 #endif
4644 {
4645
4646 lbpState->SlabSizeInBytes = bytesPerSlab;
4647 lbpState->SlabOffsetDeltaInBytes = (ULONG)startingOffsetDelta;
4648 lbpState->SlabAllocationBitMapBitCount = totalProcessedSlabs;
4649 lbpState->SlabAllocationBitMapLength = ((totalProcessedSlabs - 1) / bitMapGranularityInBits) + 1;
4650 lbpState->Version = DEVICE_DATA_SET_LB_PROVISIONING_STATE_VERSION_V1;
4651
4652 //
4653 // Note that there is already one element of the bitmap array allocated
4654 // in the DEVICE_DATA_SET_LB_PROVISIONING_STATE structure itself, which
4655 // is why we subtract 1 from SlabAllocationBitMapLength.
4656 //
4658 + ((lbpState->SlabAllocationBitMapLength - 1) * sizeof(lbpState->SlabAllocationBitMap[0]));
4659 }
4660
4661 DsmOutput->OutputBlockLength = lbpState->Size; // Size is at the same offset in all versions of the structure.
4663 *DsmOutputLength = DsmOutput->Size + DsmOutput->OutputBlockLength;
4664
4666 }
4667
4668 TracePrint((TRACE_LEVEL_INFORMATION,
4669 TRACE_FLAG_IOCTL,
4670 "ClasspDeviceGetLBAStatusWorker (%p): Processed a total of %u slabs\n",
4671 DeviceObject,
4672 totalProcessedSlabs));
4673Exit:
4674
4675 FREE_POOL(lbaStatusListHeader);
4677}
_Must_inspect_result_ NTSTATUS NTAPI ClassReadDriveCapacity(_In_ PDEVICE_OBJECT Fdo)
Definition: class.c:2742
NTSTATUS GetLBAStatus(_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _In_ PSCSI_REQUEST_BLOCK Srb, _In_ ULONGLONG StartingLBA, _Inout_ PLBA_STATUS_LIST_HEADER LBAStatusHeader, _In_ ULONG LBAStatusSize, _In_ BOOLEAN ConsolidateableBlocksOnly)
Definition: utils.c:3772
struct _DEVICE_DATA_SET_LB_PROVISIONING_STATE DEVICE_DATA_SET_LB_PROVISIONING_STATE
struct _DEVICE_DATA_SET_LB_PROVISIONING_STATE_V2 * PDEVICE_DATA_SET_LB_PROVISIONING_STATE_V2
struct _DEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT DEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT
struct _DEVICE_DATA_SET_LB_PROVISIONING_STATE_V2 DEVICE_DATA_SET_LB_PROVISIONING_STATE_V2
struct _LBA_STATUS_LIST_HEADER LBA_STATUS_LIST_HEADER
struct _LBA_STATUS_DESCRIPTOR LBA_STATUS_DESCRIPTOR
struct _LBA_STATUS_LIST_HEADER * PLBA_STATUS_LIST_HEADER
ULONG SlabAllocationBitMap[ANYSIZE_ARRAY]
Definition: ntddstor.h:948
ULONG SlabAllocationBitMapBitCount
Definition: ntddstor.h:946
ULONG SlabAllocationBitMapLength
Definition: ntddstor.h:947
ULONGLONG SlabSizeInBytes
Definition: ntddstor.h:944
ULONGLONG SlabOffsetDeltaInBytes
Definition: ntddstor.h:945
Definition: scsi.h:2818
Definition: scsi.h:2826
#define FIELD_SIZE(type, field)
Referenced by ClasspDeviceGetLBAStatus().
◆ ClasspDeviceGetLBProvisioningVPDPage()
| NTSTATUS ClasspDeviceGetLBProvisioningVPDPage | ( | _In_ PDEVICE_OBJECT | DeviceObject, |
| _Inout_opt_ PSCSI_REQUEST_BLOCK | Srb | ||
| ) |
Definition at line 2350 of file utils.c.
2354{
2356 PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
2357 USHORT pageLength = 0;
2358
2361 ULONG allocationBufferLength = bufferLength; // Since the CDB size may differ from the actual buffer allocation
2362 PCDB cdb;
2363 ULONG dataTransferLength = 0;
2365
2366 //
2367 // if the informaiton has been attempted to retrieve, return the cached status.
2368 //
2369 if (fdoExtension->FunctionSupportInfo->LBProvisioningData.CommandStatus != -1) {
2370 // get cached NTSTATUS from previous call.
2371 return fdoExtension->FunctionSupportInfo->LBProvisioningData.CommandStatus;
2372 }
2373
2374 //
2375 // Initialize LBProvisioningData fields to 'unsupported' defaults.
2376 //
2377 fdoExtension->FunctionSupportInfo->LBProvisioningData.ProvisioningType = PROVISIONING_TYPE_UNKNOWN;
2378 fdoExtension->FunctionSupportInfo->LBProvisioningData.LBPRZ = FALSE;
2379 fdoExtension->FunctionSupportInfo->LBProvisioningData.LBPU = FALSE;
2380 fdoExtension->FunctionSupportInfo->LBProvisioningData.ANC_SUP = FALSE;
2381 fdoExtension->FunctionSupportInfo->LBProvisioningData.ThresholdExponent = 0;
2382
2383 //
2384 // Try to get the Thin Provisioning VPD page (0xB2), if it is supported.
2385 //
2388 {
2389#if defined(_ARM_) || defined(_ARM64_)
2390 //
2391 // ARM has specific alignment requirements, although this will not have a functional impact on x86 or amd64
2392 // based platforms. We are taking the conservative approach here.
2393 //
2394 //
2395 allocationBufferLength = ALIGN_UP_BY(allocationBufferLength,KeGetRecommendedSharedDataAlignment());
2397#else
2399#endif
2401 // return without updating FdoExtension->FunctionSupportInfo->LBProvisioningData.CommandStatus
2402 // the field will remain value as "-1", so that the command will be attempted next time this function is called.
2405 }
2406
2408
2410
2415 1,
2416 SrbExDataTypeScsiCdb16);
2419 } else {
2420 //
2421 // Should not occur.
2422 //
2424 }
2425 } else {
2430 }
2431
2433 // prepare the Srb
2438
2440
2442 cdb->CDB6INQUIRY3.OperationCode = SCSIOP_INQUIRY;
2443 cdb->CDB6INQUIRY3.EnableVitalProductData = 1; //EVPD bit
2444 cdb->CDB6INQUIRY3.PageCode = VPD_LOGICAL_BLOCK_PROVISIONING;
2445 cdb->CDB6INQUIRY3.AllocationLength = bufferLength; //AllocationLength field in CDB6INQUIRY3 is only one byte.
2446
2448 Srb,
2449 dataBuffer,
2450 allocationBufferLength,
2451 FALSE);
2452
2454 }
2455
2456 //
2457 // Handle the case where we get back STATUS_DATA_OVERRUN b/c the input
2458 // buffer was larger than necessary.
2459 //
2461 {
2463 }
2464
2466 REVERSE_BYTES_SHORT(&pageLength, &(lbProvisioning->PageLength));
2467 }
2468
2470 ((dataTransferLength < 0x08) ||
2471 (pageLength < (FIELD_OFFSET(VPD_LOGICAL_BLOCK_PROVISIONING_PAGE, Reserved2) - FIELD_OFFSET(VPD_LOGICAL_BLOCK_PROVISIONING_PAGE,ThresholdExponent))) ||
2472 (lbProvisioning->PageCode != VPD_LOGICAL_BLOCK_PROVISIONING)) ) {
2473 // the device should return at least 8 bytes of data for use.
2474 // 'PageCode' shall match and we need all the relevant data after the header.
2476 }
2477
2478 //
2479 // Fill in the FDO extension with either the data from the VPD page, or
2480 // use defaults if there was an error.
2481 //
2483 {
2484 fdoExtension->FunctionSupportInfo->LBProvisioningData.ProvisioningType = lbProvisioning->ProvisioningType;
2485 fdoExtension->FunctionSupportInfo->LBProvisioningData.LBPRZ = lbProvisioning->LBPRZ;
2486 fdoExtension->FunctionSupportInfo->LBProvisioningData.LBPU = lbProvisioning->LBPU;
2487 fdoExtension->FunctionSupportInfo->LBProvisioningData.ANC_SUP = lbProvisioning->ANC_SUP;
2488 fdoExtension->FunctionSupportInfo->LBProvisioningData.ThresholdExponent = lbProvisioning->ThresholdExponent;
2489
2490 TracePrint((TRACE_LEVEL_INFORMATION,
2491 TRACE_FLAG_PNP,
2492 "ClasspDeviceGetLBProvisioningVPDPage (%p): %s %s (rev %s) reported following parameters: \
2493 \n\t\t\tProvisioningType: %u \
2494 \n\t\t\tLBPRZ: %u \
2495 \n\t\t\tLBPU: %u \
2496 \n\t\t\tANC_SUP: %I64u \
2497 \n\t\t\tThresholdExponent: %u\n",
2498 DeviceObject,
2499 (PCSZ)(((PUCHAR)fdoExtension->DeviceDescriptor) + fdoExtension->DeviceDescriptor->VendorIdOffset),
2500 (PCSZ)(((PUCHAR)fdoExtension->DeviceDescriptor) + fdoExtension->DeviceDescriptor->ProductIdOffset),
2501 (PCSZ)(((PUCHAR)fdoExtension->DeviceDescriptor) + fdoExtension->DeviceDescriptor->ProductRevisionOffset),
2502 lbProvisioning->ProvisioningType,
2503 lbProvisioning->LBPRZ,
2504 lbProvisioning->LBPU,
2505 lbProvisioning->ANC_SUP,
2506 lbProvisioning->ThresholdExponent));
2507 }
2508 } else {
2510 }
2511
2512 fdoExtension->FunctionSupportInfo->LBProvisioningData.CommandStatus = status;
2513
2514Exit:
2516
2518}
struct _VPD_LOGICAL_BLOCK_PROVISIONING_PAGE * PVPD_LOGICAL_BLOCK_PROVISIONING_PAGE
PSTORAGE_DEVICE_DESCRIPTOR DeviceDescriptor
Definition: classpnp.h:876
ULONG ProductRevisionOffset
Definition: ntddstor.h:296
Definition: scsi.h:2638
Referenced by ClasspGetLBProvisioningInfo().
◆ ClasspDeviceLBProvisioningProperty()
| NTSTATUS ClasspDeviceLBProvisioningProperty | ( | _In_ PDEVICE_OBJECT | DeviceObject, |
| _Inout_ PIRP | Irp, | ||
| _Inout_ PSCSI_REQUEST_BLOCK | Srb | ||
| ) |
Definition at line 2894 of file utils.c.
2899{
2901 NTSTATUS blockLimitsStatus;
2902 PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
2907 CLASS_VPD_B0_DATA blockLimitsData;
2908 ULONG generationCount;
2909
2910 PDEVICE_LB_PROVISIONING_DESCRIPTOR lbpDescr;
2911
2913
2914 //
2915 // Check proper query type.
2916 //
2923 }
2924
2925 //
2926 // Request validation.
2927 // Note that InputBufferLength and IsFdo have been validated beforing entering this routine.
2928 //
2929
2934 }
2935
2937
2939
2941
2943
2945
2951 }
2952
2955 }
2956
2957 //
2958 // Set the structure version/size based upon the size of the given output
2959 // buffer. We may be working with an older component that was built with
2960 // the V1 structure definition.
2961 //
2966 } else {
2970 }
2971
2972 //
2973 // Take a snapshot of the block limits data since it can change.
2974 // If we failed to get the block limits data, we'll just set the Optimal
2975 // Unmap Granularity (and alignment) will default to 0. We don't want to
2976 // fail the request outright since there is some non-block limits data that
2977 // we can return.
2978 //
2979 blockLimitsStatus = ClasspBlockLimitsDataSnapshot(fdoExtension,
2980 TRUE,
2981 &blockLimitsData,
2982 &generationCount);
2983
2984 //
2985 // Fill in the output buffer. All data is copied from the FDO extension where we
2986 // cached Logical Block Provisioning info when the device was first initialized.
2987 //
2988
2989 lbpDescr->ThinProvisioningEnabled = ClasspIsThinProvisioned(fdoExtension->FunctionSupportInfo);
2990
2991 //
2992 // Make sure we have a non-zero value for the number of bytes per block.
2993 //
2995 {
2998 {
3000 information = 0;
3002 }
3003 }
3004
3005 lbpDescr->ThinProvisioningReadZeros = fdoExtension->FunctionSupportInfo->LBProvisioningData.LBPRZ;
3006 lbpDescr->AnchorSupported = fdoExtension->FunctionSupportInfo->LBProvisioningData.ANC_SUP;
3007
3010
3011 //
3012 // Granularity and Alignment are given to us in units of blocks,
3013 // but we convert and return them in bytes as it is more convenient
3014 // to the caller.
3015 //
3016 lbpDescr->OptimalUnmapGranularity = (ULONGLONG)blockLimitsData.OptimalUnmapGranularity * fdoExtension->DiskGeometry.BytesPerSector;
3017 lbpDescr->UnmapGranularityAlignment = (ULONGLONG)blockLimitsData.UnmapGranularityAlignment * fdoExtension->DiskGeometry.BytesPerSector;
3018
3019#if (NTDDI_VERSION >= NTDDI_WINBLUE)
3020 //
3021 // If the output buffer is large enough (i.e. not a V1 structure) copy
3022 // over the max UNMAP LBA count and max UNMAP block descriptor count.
3023 //
3027 }
3028#endif
3029 }
3030
3031Exit:
3032
3033 //
3034 // Set the size and status in IRP
3035 //
3038
3041
3043}
FORCEINLINE BOOLEAN ClasspIsThinProvisioned(_In_ PCLASS_FUNCTION_SUPPORT_INFO SupportInfo)
Definition: classp.h:1317
struct _DEVICE_LB_PROVISIONING_DESCRIPTOR * PDEVICE_LB_PROVISIONING_DESCRIPTOR
struct _DEVICE_LB_PROVISIONING_DESCRIPTOR DEVICE_LB_PROVISIONING_DESCRIPTOR
#define DEVICE_LB_PROVISIONING_DESCRIPTOR_V1_SIZE
Definition: ntddstor.h:661
ULONG UnmapGranularityAlignment
Definition: classpnp.h:753
Definition: ntddstor.h:644
UCHAR ThinProvisioningEnabled
Definition: ntddstor.h:647
ULONG MaxUnmapBlockDescriptorCount
Definition: ntddstor.h:657
UCHAR ThinProvisioningReadZeros
Definition: ntddstor.h:648
UCHAR UnmapGranularityAlignmentValid
Definition: ntddstor.h:650
ULONGLONG OptimalUnmapGranularity
Definition: ntddstor.h:653
ULONG MaxUnmapLbaCount
Definition: ntddstor.h:656
ULONGLONG UnmapGranularityAlignment
Definition: ntddstor.h:654
Referenced by ClassDeviceControl().
◆ ClasspDeviceMediaTypeProperty()
| NTSTATUS ClasspDeviceMediaTypeProperty | ( | _In_ PDEVICE_OBJECT | DeviceObject, |
| _Inout_ PIRP | Irp, | ||
| _Inout_ PSCSI_REQUEST_BLOCK | Srb | ||
| ) |
Definition at line 1917 of file utils.c.
1941{
1943 PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
1945 PSTORAGE_MEDIUM_PRODUCT_TYPE_DESCRIPTOR pDesc = (PSTORAGE_MEDIUM_PRODUCT_TYPE_DESCRIPTOR)Irp->AssociatedIrp.SystemBuffer;
1946 PIO_STACK_LOCATION irpStack;
1949
1951
1952 TracePrint((TRACE_LEVEL_VERBOSE,
1953 TRACE_FLAG_IOCTL,
1954 "ClasspDeviceMediaTypeProperty (%p): Entering function.\n",
1955 DeviceObject));
1956
1957 //
1958 // Check proper query type.
1959 //
1961
1962 //
1963 // In order to maintain consistency with the how the rest of the properties
1964 // are handled, always return success for PropertyExistsQuery.
1965 //
1967 goto __ClasspDeviceMediaTypeProperty_Exit;
1968
1970
1971 TracePrint((TRACE_LEVEL_ERROR,
1972 TRACE_FLAG_IOCTL,
1973 "ClasspDeviceMediaTypeProperty (%p): Unsupported query type %x for media type property.\n",
1974 DeviceObject,
1975 query->QueryType));
1976
1978 goto __ClasspDeviceMediaTypeProperty_Exit;
1979 }
1980
1981 //
1982 // Validate the request.
1983 // InputBufferLength and IsFdo have already been validated.
1984 //
1985
1987
1989
1990 TracePrint((TRACE_LEVEL_ERROR,
1991 TRACE_FLAG_IOCTL,
1992 "ClasspDeviceMediaTypeProperty (%p): Query property for media type at incorrect IRQL.\n",
1993 DeviceObject));
1994
1996 goto __ClasspDeviceMediaTypeProperty_Exit;
1997 }
1998
1999 length = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
2000
2002
2006 } else {
2007
2009 goto __ClasspDeviceMediaTypeProperty_Exit;
2010 }
2011
2013
2015 goto __ClasspDeviceMediaTypeProperty_Exit;
2016 }
2017
2018 //
2019 // Only query BlockDeviceCharacteristics VPD page if device support has been confirmed.
2020 //
2023 } else {
2024 //
2025 // Otherwise device was previously found lacking support for this VPD page. Fail the request.
2026 //
2028 goto __ClasspDeviceMediaTypeProperty_Exit;
2029 }
2030
2032
2033 status = fdoExtension->FunctionSupportInfo->DeviceCharacteristicsData.CommandStatus;
2034 information = 0;
2035
2036 TracePrint((TRACE_LEVEL_ERROR,
2037 TRACE_FLAG_IOCTL,
2038 "ClasspDeviceGetBlockDeviceCharacteristicsVPDPage (%p): VPD retrieval fails with %x.\n",
2039 DeviceObject,
2040 status));
2041
2042 goto __ClasspDeviceMediaTypeProperty_Exit;
2043 }
2044
2045 //
2046 // Fill in the output buffer. All data is copied from the FDO extension, cached
2047 // from device response to earlier VPD_BLOCK_DEVICE_CHARACTERISTICS query.
2048 //
2049 pDesc->MediumProductType = fdoExtension->FunctionSupportInfo->DeviceCharacteristicsData.MediumProductType;
2051
2052__ClasspDeviceMediaTypeProperty_Exit:
2053
2054 //
2055 // Set the size and status in IRP
2056 //
2059
2062
2063 TracePrint((TRACE_LEVEL_VERBOSE,
2064 TRACE_FLAG_IOCTL,
2065 "ClasspDeviceMediaTypeProperty (%p): Exiting function with status %x.\n",
2066 DeviceObject,
2067 status));
2068
2070}
NTSTATUS ClasspDeviceGetBlockDeviceCharacteristicsVPDPage(_In_ PFUNCTIONAL_DEVICE_EXTENSION fdoExtension, _In_ PSCSI_REQUEST_BLOCK Srb)
Definition: utils.c:2072
STORAGE_MEDIUM_PRODUCT_TYPE_DESCRIPTOR
Definition: ntddstor.h:615
* PSTORAGE_MEDIUM_PRODUCT_TYPE_DESCRIPTOR
Definition: ntddstor.h:615
Referenced by ClassDeviceControl().
◆ ClasspDeviceSeekPenaltyProperty()
| NTSTATUS ClasspDeviceSeekPenaltyProperty | ( | _In_ PDEVICE_OBJECT | DeviceObject, |
| _In_ PIRP | Irp, | ||
| _Inout_ PSCSI_REQUEST_BLOCK | Srb | ||
| ) |
Definition at line 2172 of file utils.c.
2181{
2183
2184 PCOMMON_DEVICE_EXTENSION commonExtension = (PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
2185 PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
2191 PDEVICE_SEEK_PENALTY_DESCRIPTOR seekPenalty;
2192
2195 (fdoExtension->FunctionSupportInfo->LowerLayerSupport.SeekPenaltyProperty == Supported) ) {
2196 // if it's not disk, forward the request to lower layer,
2197 // if the IOCTL is supported by lower stack, forward it down.
2199
2203 }
2204
2205 //
2206 // Check proper query type.
2207 //
2208
2215 }
2216
2217 //
2218 // Request validation.
2219 // Note that InputBufferLength and IsFdo have been validated beforing entering this routine.
2220 //
2221
2226 }
2227
2228 // do not touch this buffer because it can still be used as input buffer for lower layer in 'SupportUnknown' case.
2230
2231 length = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
2232
2234
2236
2242 }
2243
2246 }
2247
2248 //
2249 // note that 'Supported' case has been handled at the beginning of this function.
2250 //
2251 switch (fdoExtension->FunctionSupportInfo->LowerLayerSupport.SeekPenaltyProperty) {
2253 // send down request and wait for the request to complete.
2255
2257 // case 1: the request is not supported by lower layer, sends down command
2258 // some port drivers (or filter drivers) return STATUS_INVALID_DEVICE_REQUEST if a request is not supported.
2259
2260 // send INQUIRY command if the VPD page is supported.
2263 } else {
2264 // the INQUIRY - VPD page command to discover the info is not supported, fail the request.
2266 }
2267
2269 status = IncursSeekPenalty(fdoExtension->FunctionSupportInfo->DeviceCharacteristicsData.MediumRotationRate, &incursSeekPenalty);
2270 }
2271
2272 fdoExtension->FunctionSupportInfo->DeviceCharacteristicsData.CommandStatus = status;
2273
2274 // data is ready in fdoExtension
2275 // set the support status after the SCSI command is executed to avoid racing condition between multiple same type of requests.
2276 fdoExtension->FunctionSupportInfo->LowerLayerSupport.SeekPenaltyProperty = NotSupported;
2277
2278 // fill output buffer
2283 seekPenalty->IncursSeekPenalty = incursSeekPenalty;
2285
2286
2287 } else {
2288 information = 0;
2289 }
2290
2291 } else {
2292 // case 2: the request is supported and it completes successfully
2293 // case 3: the request is supported by lower stack but other failure status is returned.
2294 // from now on, the same request will be send down to lower stack directly.
2295 fdoExtension->FunctionSupportInfo->LowerLayerSupport.SeekPenaltyProperty = Supported;
2297
2298 }
2299
2300
2302
2303 break;
2304 }
2305
2307 status = fdoExtension->FunctionSupportInfo->DeviceCharacteristicsData.CommandStatus;
2308
2310 status = IncursSeekPenalty(fdoExtension->FunctionSupportInfo->DeviceCharacteristicsData.MediumRotationRate, &incursSeekPenalty);
2311 }
2312
2317 seekPenalty->IncursSeekPenalty = incursSeekPenalty;
2319
2320 } else {
2321 information = 0;
2322 }
2323
2325
2326 break;
2327 }
2328
2331 break;
2332 }
2333
2334 } // end of switch (fdoExtension->FunctionSupportInfo->LowerLayerSupport.SeekPenaltyProperty)
2335
2336Exit:
2337
2338 //
2339 // Set the size and status in IRP
2340 //
2343
2346
2348}
static NTSTATUS IncursSeekPenalty(_In_ USHORT MediumRotationRate, _In_ PBOOLEAN IncursSeekPenalty)
Definition: utils.c:1888
struct _DEVICE_SEEK_PENALTY_DESCRIPTOR DEVICE_SEEK_PENALTY_DESCRIPTOR
struct _DEVICE_SEEK_PENALTY_DESCRIPTOR * PDEVICE_SEEK_PENALTY_DESCRIPTOR
Definition: ntddstor.h:744
BOOLEAN IncursSeekPenalty
Definition: ntddstor.h:747
Referenced by ClassDeviceControl().
◆ ClasspDeviceTrimProcess()
| NTSTATUS ClasspDeviceTrimProcess | ( | _In_ PDEVICE_OBJECT | DeviceObject, |
| _In_ PIRP | Irp, | ||
| _In_ PGUID | ActivityId, | ||
| _Inout_ PSCSI_REQUEST_BLOCK | Srb | ||
| ) |
Definition at line 3476 of file utils.c.
3487{
3489
3490 PCOMMON_DEVICE_EXTENSION commonExtension = (PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
3491 PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
3492
3494
3495 PDEVICE_DATA_SET_RANGE dataSetRanges;
3496 ULONG dataSetRangesCount;
3497 DEVICE_DATA_SET_RANGE entireDataSetRange = {0};
3499 ULONGLONG granularityAlignmentInBytes;
3500 ULONG granularityInBlocks;
3501 ULONG srbFlags = 0;
3502
3503 CLASS_VPD_B0_DATA blockLimitsData;
3504 ULONG generationCount;
3505
3506
3509 (fdoExtension->FunctionSupportInfo->LowerLayerSupport.TrimProcess == Supported) ) {
3510 // if it's not disk, forward the request to lower layer,
3511 // if the IOCTL is supported by lower stack, forward it down.
3513
3514 TracePrint((TRACE_LEVEL_INFORMATION,
3515 TRACE_FLAG_GENERAL,
3516 "ClasspDeviceTrimProcess (%p): Lower layer supports Trim DSM IOCTL, forwarding IOCTL.\n",
3517 DeviceObject));
3518
3522 }
3523
3524 //
3525 // Request validation.
3526 // Note that InputBufferLength and IsFdo have been validated beforing entering this routine.
3527 //
3528
3533 }
3534
3535
3536 //
3537 // If the caller has not set the "entire dataset range" flag then at least
3538 // one dataset range should be specified. However, if the caller *has* set
3539 // the flag, then there should not be any dataset ranges specified.
3540 //
3542 (dsmAttributes->DataSetRangesOffset == 0 ||
3543 dsmAttributes->DataSetRangesLength == 0)) ||
3545 (dsmAttributes->DataSetRangesOffset != 0 ||
3546 dsmAttributes->DataSetRangesLength != 0))) {
3547
3550 }
3551
3552 //
3553 // note that 'Supported' case has been handled at the beginning of this function.
3554 //
3555 switch (fdoExtension->FunctionSupportInfo->LowerLayerSupport.TrimProcess) {
3557 // send down request and wait for the request to complete.
3559
3560 TracePrint((TRACE_LEVEL_INFORMATION,
3561 TRACE_FLAG_GENERAL,
3562 "ClasspDeviceTrimProcess (%p): Trim DSM IOCTL support unknown. Forwarded IOCTL and received NTSTATUS %!STATUS!.\n",
3563 DeviceObject,
3564 status));
3565
3567 // case 1: the request is not supported by lower layer, sends down command
3568 // some port drivers (or filter drivers) return STATUS_INVALID_DEVICE_REQUEST if a request is not supported.
3569 // In this case we'll just fall through to the NotSupported case so that we can handle it ourselves.
3570
3571 //
3572 // VPD pages 0xB2 and 0xB0 should have been cached in Start Device phase - ClassPnpStartDevice.
3573 // 0xB2 page: fdoExtension->FunctionSupportInfo->LBProvisioningData;
3574 // 0xB0 page: fdoExtension->FunctionSupportInfo->BlockLimitsData
3575 //
3577 NT_ASSERT(fdoExtension->FunctionSupportInfo->LBProvisioningData.CommandStatus != -1);
3578 }
3579
3581 NT_ASSERT(fdoExtension->FunctionSupportInfo->BlockLimitsData.CommandStatus != -1);
3582 }
3583
3584 } else {
3585
3586 // case 2: the request is supported and it completes successfully
3587 // case 3: the request is supported by lower stack but other failure status is returned.
3588 // from now on, the same request will be send down to lower stack directly.
3589 fdoExtension->FunctionSupportInfo->LowerLayerSupport.TrimProcess = Supported;
3591 }
3592 }
3593
3595
3596 // send UNMAP command if it is supported. don't need to check 'status' value.
3598 {
3599 //
3600 // Make sure that we know the bytes per sector (logical block) as it's
3601 // necessary for calculations involving granularity and alignment.
3602 //
3603 if (fdoExtension->DiskGeometry.BytesPerSector == 0) {
3608 }
3609 }
3610
3611 //
3612 // Take a snapshot of the block limits data since it can change.
3613 // It's acceptable if the block limits data is outdated since
3614 // there isn't a hard requirement on the unmap granularity.
3615 //
3616 ClasspBlockLimitsDataSnapshot(fdoExtension,
3617 FALSE,
3618 &blockLimitsData,
3619 &generationCount);
3620
3621 //
3622 // Check to see if the Optimal Unmap Granularity and Unmap Granularity
3623 // Alignment have been specified. If not, default the granularity to
3624 // one block and the alignment to zero.
3625 //
3627 {
3628 granularityInBlocks = blockLimitsData.OptimalUnmapGranularity;
3629 }
3630 else
3631 {
3632 granularityInBlocks = 1;
3633
3634 TracePrint((TRACE_LEVEL_INFORMATION,
3635 TRACE_FLAG_GENERAL,
3636 "ClasspDeviceTrimProcess (%p): Optimal Unmap Granularity not provided, defaulted to 1.\n",
3637 DeviceObject));
3638 }
3639
3641 {
3642 granularityAlignmentInBytes = (ULONGLONG)blockLimitsData.UnmapGranularityAlignment * fdoExtension->DiskGeometry.BytesPerSector;
3643 }
3644 else
3645 {
3646 granularityAlignmentInBytes = 0;
3647
3648 TracePrint((TRACE_LEVEL_INFORMATION,
3649 TRACE_FLAG_GENERAL,
3650 "ClasspDeviceTrimProcess (%p): Unmap Granularity Alignment not provided, defaulted to 0.\n",
3651 DeviceObject));
3652 }
3653
3655 {
3656 //
3657 // The caller wants to UNMAP the entire disk so we need to build a single
3658 // dataset range that represents the entire disk.
3659 //
3660 entireDataSetRange.StartingOffset = granularityAlignmentInBytes;
3661 entireDataSetRange.LengthInBytes = (ULONGLONG)fdoExtension->CommonExtension.PartitionLength.QuadPart - (ULONGLONG)entireDataSetRange.StartingOffset;
3662
3663 dataSetRanges = &entireDataSetRange;
3664 dataSetRangesCount = 1;
3665 }
3666 else
3667 {
3668
3669 dataSetRanges = (PDEVICE_DATA_SET_RANGE)((PUCHAR)dsmAttributes + dsmAttributes->DataSetRangesOffset);
3671
3672 //
3673 // Validate the data ranges. Make sure the range is block-aligned,
3674 // falls in a valid portion of the disk, and is non-zero.
3675 //
3677 {
3681 (dataSetRanges[i].LengthInBytes == 0) ||
3682 ((ULONGLONG)dataSetRanges[i].StartingOffset + dataSetRanges[i].LengthInBytes > (ULONGLONG)fdoExtension->CommonExtension.PartitionLength.QuadPart))
3683 {
3684 TracePrint((TRACE_LEVEL_ERROR,
3685 TRACE_FLAG_IOCTL,
3686 "ClasspDeviceTrimProcess (%p): Invalid dataset range. StartingOffset = %I64x, LengthInBytes = %I64x\n",
3687 DeviceObject,
3689 dataSetRanges[i].LengthInBytes));
3690
3693 }
3694 }
3695 }
3696
3697
3699 {
3700 {
3701 //
3702 // For security reasons, file-level TRIM must be forwarded on only
3703 // if reading the unmapped blocks' contents will return back zeros.
3704 // This is because if LBPRZ bit is not set, it indicates that a read
3705 // of unmapped blocks may return "any" data thus potentially leaking
3706 // in data (into the read buffer) from other blocks.
3707 //
3708 if (fdoExtension->FunctionSupportInfo->ValidInquiryPages.LBProvisioning &&
3709 !fdoExtension->FunctionSupportInfo->LBProvisioningData.LBPRZ) {
3710
3711 TracePrint((TRACE_LEVEL_ERROR,
3712 TRACE_FLAG_IOCTL,
3713 "ClasspDeviceTrimProcess (%p): Device does not support file level TRIM.\n",
3714 DeviceObject));
3715
3718 }
3719 }
3720 }
3721
3722 // process DSM IOCTL
3724 dataSetRanges,
3725 dataSetRangesCount,
3726 granularityInBlocks,
3727 srbFlags,
3728 Irp,
3729 ActivityId,
3730 Srb);
3731 } else {
3732 // DSM IOCTL should be completed as not supported
3733
3734 TracePrint((TRACE_LEVEL_ERROR,
3735 TRACE_FLAG_IOCTL,
3736 "ClasspDeviceTrimProcess (%p): Device does not support UNMAP.\n",
3737 DeviceObject));
3738
3740 }
3741
3742 // set the support status after the SCSI command is executed to avoid racing condition between multiple same type of requests.
3743 fdoExtension->FunctionSupportInfo->LowerLayerSupport.TrimProcess = NotSupported;
3744
3745 break;
3746 }
3747
3750 break;
3751 }
3752
3753 } // end of switch (fdoExtension->FunctionSupportInfo->LowerLayerSupport.TrimProcess)
3754
3755Exit:
3756
3757 //
3758 // Set the size and status in IRP
3759 //
3760 Irp->IoStatus.Information = 0;
3762
3763
3764
3767
3769}
FORCEINLINE BOOLEAN ClasspSupportsUnmap(_In_ PCLASS_FUNCTION_SUPPORT_INFO SupportInfo)
Definition: classp.h:1308
NTSTATUS DeviceProcessDsmTrimRequest(_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _In_ PDEVICE_DATA_SET_RANGE DataSetRanges, _In_ ULONG DataSetRangesCount, _In_ ULONG UnmapGranularity, _In_ ULONG SrbFlags, _In_ PIRP Irp, _In_ PGUID ActivityId, _Inout_ PSCSI_REQUEST_BLOCK Srb)
Definition: utils.c:3164
#define STATUS_TRIM_READ_ZERO_NOT_SUPPORTED
Definition: ntstatus.h:1152
#define DEVICE_DSM_FLAG_TRIM_NOT_FS_ALLOCATED
Definition: ntddstor.h:764
struct _DEVICE_DATA_SET_RANGE DEVICE_DATA_SET_RANGE
Referenced by ClassDeviceControl().
◆ ClasspDeviceTrimProperty()
| NTSTATUS ClasspDeviceTrimProperty | ( | _In_ PDEVICE_OBJECT | DeviceObject, |
| _In_ PIRP | Irp, | ||
| _Inout_ PSCSI_REQUEST_BLOCK | Srb | ||
| ) |
Definition at line 2730 of file utils.c.
2739{
2741
2742 PCOMMON_DEVICE_EXTENSION commonExtension = (PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
2743 PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
2748
2749 PDEVICE_TRIM_DESCRIPTOR trimDescr;
2750
2752
2755 (fdoExtension->FunctionSupportInfo->LowerLayerSupport.TrimProperty == Supported) ) {
2756 // if it's not disk, forward the request to lower layer,
2757 // if the IOCTL is supported by lower stack, forward it down.
2759
2763 }
2764
2765 //
2766 // Check proper query type.
2767 //
2768
2775 }
2776
2777 //
2778 // Request validation.
2779 // Note that InputBufferLength and IsFdo have been validated beforing entering this routine.
2780 //
2781
2786 }
2787
2788 // do not touch this buffer because it can still be used as input buffer for lower layer in 'SupportUnknown' case.
2790
2791 length = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
2792
2794
2796
2802 }
2803
2806 }
2807
2808 //
2809 // note that 'Supported' case has been handled at the beginning of this function.
2810 //
2811 switch (fdoExtension->FunctionSupportInfo->LowerLayerSupport.TrimProperty) {
2813 // send down request and wait for the request to complete.
2815
2820 // case 1: the request is not supported by lower layer, sends down command
2821 // some port drivers (or filter drivers) return STATUS_INVALID_DEVICE_REQUEST if a request is not supported.
2822 status = fdoExtension->FunctionSupportInfo->LBProvisioningData.CommandStatus;
2824
2825 // data is ready in fdoExtension
2826 // set the support status after the SCSI command is executed to avoid racing condition between multiple same type of requests.
2827 fdoExtension->FunctionSupportInfo->LowerLayerSupport.TrimProperty = NotSupported;
2828
2830 // fill output buffer
2835
2836 // set returned data length
2838 } else {
2839 // there was error retrieving TrimProperty. Surface the error up from 'status' variable.
2840 information = 0;
2841 }
2843 } else {
2844 // case 2: the request is supported and it completes successfully
2845 // case 3: the request is supported by lower stack but other failure status is returned.
2846 // from now on, the same request will be send down to lower stack directly.
2847 fdoExtension->FunctionSupportInfo->LowerLayerSupport.TrimProperty = Supported;
2850 }
2851 break;
2852 }
2853
2855 status = fdoExtension->FunctionSupportInfo->LBProvisioningData.CommandStatus;
2857
2863
2865 } else {
2866 information = 0;
2867 }
2869
2870 break;
2871 }
2872
2875 break;
2876 }
2877
2878 } // end of switch (fdoExtension->FunctionSupportInfo->LowerLayerSupport.TrimProperty)
2879
2880Exit:
2881
2882 //
2883 // Set the size and status in IRP
2884 //
2887
2890
2892}
struct _DEVICE_TRIM_DESCRIPTOR DEVICE_TRIM_DESCRIPTOR
struct _DEVICE_TRIM_DESCRIPTOR * PDEVICE_TRIM_DESCRIPTOR
Definition: ntddstor.h:756
Referenced by ClassDeviceControl().
◆ ClasspDisablePowerNotification()
| VOID ClasspDisablePowerNotification | ( | PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension | ) |
◆ ClasspDisableTimer()
| VOID ClasspDisableTimer | ( | _In_ PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension | ) |
Definition at line 3956 of file autorun.c.
3959{
3961
3963 fdoData = FdoExtension->PrivateFdoData;
3964 }
3965
3967
3968 //
3969 // we are only going to stop the actual timer in remove device routine
3970 // or when done transitioning to D3 (timer will be started again when
3971 // done transitioning to D0).
3972 //
3973 // it is the responsibility of the code within the timer routine to
3974 // check if the device is removed and not processing io for the final
3975 // call.
3976 // this keeps the code clean and prevents lots of bugs.
3977 //
3978#if (NTDDI_VERSION >= NTDDI_WINBLUE)
3981#else
3983#endif
3984 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, "ClasspDisableTimer: Periodic tick timer disabled "
3987
3988 } else {
3989
3990 TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN, "ClasspDisableTimer: Timer never initialized\n"));
3991
3992 }
3993
3994 return;
3995} // end ClasspDisableTimer()
NTKERNELAPI BOOLEAN NTAPI ExCancelTimer(_Inout_ PEX_TIMER Timer, _In_opt_ PEXT_CANCEL_PARAMETERS Parameters)
Referenced by ClassDispatchPnp(), and ClasspPowerHandler().
◆ ClasspDuidQueryProperty()
| NTSTATUS ClasspDuidQueryProperty | ( | PDEVICE_OBJECT | DeviceObject, |
| PIRP | Irp | ||
| ) |
Definition at line 997 of file utils.c.
1001{
1003 PSTORAGE_DESCRIPTOR_HEADER descHeader;
1005
1007
1009
1010 BOOLEAN includeOptionalIds;
1013 BOOLEAN useStatus = TRUE; // Use the status directly instead of relying on overflow and infoFound flags.
1014
1015 //
1016 // Must run at less then dispatch.
1017 //
1018
1020
1023 goto FnExit;
1024 }
1025
1026 //
1027 // Check proper query type.
1028 //
1029
1031 Irp->IoStatus.Information = 0;
1033 goto FnExit;
1034 }
1035
1038 goto FnExit;
1039 }
1040
1041 //
1042 // Check AdditionalParameters validity.
1043 //
1044
1046 includeOptionalIds = TRUE;
1048 includeOptionalIds = FALSE;
1049 } else {
1051 goto FnExit;
1052 }
1053
1054 //
1055 // Verify output parameters.
1056 //
1057
1059
1061 goto FnExit;
1062 }
1063
1064 //
1065 // From this point forward the status depends on the overflow
1066 // and infoFound flags.
1067 //
1068
1069 useStatus = FALSE;
1070
1071 descHeader = Irp->AssociatedIrp.SystemBuffer;
1072 RtlZeroMemory(descHeader, outLength);
1073
1076
1077 //
1078 // Try to build device unique id from StorageDeviceIdProperty.
1079 //
1080
1082 Irp);
1083
1086 }
1087
1089 infoFound = TRUE;
1090 }
1091
1092 //
1093 // Try to build device unique id from StorageDeviceProperty.
1094 //
1095
1097 Irp);
1098
1101 }
1102
1104 infoFound = TRUE;
1105 }
1106
1107 //
1108 // The following portion is optional and only included if the
1109 // caller requested software IDs.
1110 //
1111
1112 if (!includeOptionalIds) {
1113 goto FnExit;
1114 }
1115
1116 //
1117 // Try to build device unique id from drive layout signature (disk
1118 // devices only).
1119 //
1120
1122 Irp);
1123
1126 }
1127
1129 infoFound = TRUE;
1130 }
1131
1132FnExit:
1133
1134 if (!useStatus) {
1135
1136 //
1137 // Return overflow, success, or a generic error.
1138 //
1139
1140 if (overflow) {
1141
1142 //
1143 // If output buffer is STORAGE_DESCRIPTOR_HEADER, then return
1144 // success to the user. Otherwise, send an error so the user
1145 // knows a larger buffer is required.
1146 //
1147
1151 } else {
1153 }
1154
1155 } else if (infoFound) {
1157
1158 //
1159 // Exercise the compare routine. This should always succeed.
1160 //
1161
1163 Irp->AssociatedIrp.SystemBuffer));
1164
1165 } else {
1167 }
1168 }
1169
1171
1174
1176}
NTSTATUS ClasspDuidGetDeviceProperty(PDEVICE_OBJECT DeviceObject, PIRP Irp)
Definition: utils.c:782
NTSTATUS ClasspDuidGetDriveLayout(PDEVICE_OBJECT DeviceObject, PIRP Irp)
Definition: utils.c:875
NTSTATUS ClasspDuidGetDeviceIdProperty(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: utils.c:689
FORCEINLINE DUID_MATCH_STATUS CompareStorageDuids(_In_ PSTORAGE_DEVICE_UNIQUE_IDENTIFIER Duid1, _In_ PSTORAGE_DEVICE_UNIQUE_IDENTIFIER Duid2)
Definition: storduid.h:56
struct _STORAGE_DEVICE_UNIQUE_IDENTIFIER STORAGE_DEVICE_UNIQUE_IDENTIFIER
Referenced by ClassDeviceControl().
◆ ClasspEjectionControl()
| NTSTATUS ClasspEjectionControl | ( | IN PDEVICE_OBJECT | Fdo, |
| IN PIRP | Irp, | ||
| IN MEDIA_LOCK_TYPE | LockType, | ||
| IN BOOLEAN | Lock | ||
| ) |
Definition at line 474 of file create.c.
480{
482 PCOMMON_DEVICE_EXTENSION commonExtension =
484
489
490 PAGED_CODE();
491
492 /*
493 * Ensure that the user thread is not suspended while we are holding EjectSynchronizationEvent.
494 */
495 KeEnterCriticalRegion();
496
498 &(FdoExtension->EjectSynchronizationEvent),
499 UserRequest,
500 KernelMode,
501 FALSE,
502 NULL);
503
505
506 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
507 "ClasspEjectionControl: "
508 "Received request for %s lock type\n",
510 ));
511
512 _SEH2_TRY {
514
515 //
516 // Determine if this is a "secured" request.
517 //
518
520
523
524 //
525 // Make sure that the file object we are supplied has a
526 // proper FsContext before we try doing a secured lock.
527 //
528
530 fsContext = ClassGetFsContext(commonExtension, fileObject);
531 }
532
534
535 //
536 // This handle isn't setup correctly. We can't let the
537 // operation go.
538 //
539
541 _SEH2_LEAVE;
542 }
543 }
544
546
547 //
548 // This is a lock command. Reissue the command in case bus or
549 // device was reset and the lock was cleared.
550 // note: may need to decrement count if actual lock operation
551 // failed....
552 //
553
555
557 FdoExtension->LockCount++;
558 countChanged = TRUE;
559 break;
560 }
561
563 fsContext->LockCount++;
564 FdoExtension->ProtectedLockCount++;
565 countChanged = TRUE;
566 break;
567 }
568
570 FdoExtension->InternalLockCount++;
571 countChanged = TRUE;
572 break;
573 }
574 }
575
576 } else {
577
578 //
579 // This is an unlock command. If it's a secured one then make sure
580 // the caller has a lock outstanding or return an error.
581 // note: may need to re-increment the count if actual unlock
582 // operation fails....
583 //
584
586
589 FdoExtension->LockCount--;
590 countChanged = TRUE;
591 }
592 break;
593 }
594
598 _SEH2_LEAVE;
599 }
600 fsContext->LockCount--;
601 FdoExtension->ProtectedLockCount--;
602 countChanged = TRUE;
603 break;
604 }
605
608 FdoExtension->InternalLockCount--;
609 countChanged = TRUE;
610 break;
611 }
612 }
613
614 //
615 // We only send an unlock command to the drive if both the
616 // secured and unsecured lock counts have dropped to zero.
617 //
618
620 (FdoExtension->InternalLockCount != 0) ||
621 (FdoExtension->LockCount != 0)) {
622
624 _SEH2_LEAVE;
625 }
626 }
627
630
632
635 _SEH2_LEAVE;
636 }
637
639
640 //
641 // NOTE - this is based on size used in ClasspAllocateSrb
642 //
643
647 1,
648 SrbExDataTypeScsiCdb16);
651 _SEH2_LEAVE;
652 }
653
654 } else {
656 }
657
658 SrbSetCdbLength(srb, 6);
659 cdb = SrbGetCdb(srb);
661
663
664 //
665 // TRUE - prevent media removal.
666 // FALSE - allow media removal.
667 //
668
670
671 //
672 // Set timeout value.
673 //
674
676
677 //
678 // The actual lock operation on the device isn't so important
679 // as the internal lock counts. Ignore failures.
680 //
681
683 srb,
684 NULL,
685 0,
686 FALSE);
687 }
688
689 } _SEH2_FINALLY {
690
692 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
693 "ClasspEjectionControl: FAILED status %x -- "
695
696 if (countChanged) {
697
698 //
699 // have to revert to previous counts if the
700 // lock/unlock operation actually failed.
701 //
702
704
706
708 FdoExtension->LockCount--;
709 break;
710 }
711
713 fsContext->LockCount--;
714 FdoExtension->ProtectedLockCount--;
715 break;
716 }
717
719 FdoExtension->InternalLockCount--;
720 break;
721 }
722 }
723
724 } else {
725
727
729 FdoExtension->LockCount++;
730 break;
731 }
732
734 fsContext->LockCount++;
735 FdoExtension->ProtectedLockCount++;
736 break;
737 }
738
740 FdoExtension->InternalLockCount++;
741 break;
742 }
743 }
744 }
745
746 }
747
748 } else {
749
750 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
751 "ClasspEjectionControl: Succeeded\n"));
752
753 }
754
755 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
756 "ClasspEjectionControl: "
757 "Current Counts: Internal: %x Secure: %x Simple: %x\n",
758 FdoExtension->InternalLockCount,
759 FdoExtension->ProtectedLockCount,
760 FdoExtension->LockCount
761 ));
762
764 IO_NO_INCREMENT,
765 FALSE);
766 KeLeaveCriticalRegion();
767
768 if (srb) {
770 }
771
772 } _SEH2_END;
774}
VOID ClassFreeOrReuseSrb(IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN __drv_freesMem(mem) PSCSI_REQUEST_BLOCK Srb)
Definition: obsolete.c:882
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
Definition: wdfsync.h:127
Referenced by ClassDeviceControl(), and ClassDispatchPnp().
◆ ClasspEnableIdlePower()
| _IRQL_requires_same_ NTSTATUS ClasspEnableIdlePower | ( | _In_ PDEVICE_OBJECT | DeviceObject | ) |
Definition at line 2550 of file power.c.
2573{
2576 PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
2577 ULONG idleTimeoutOverrideInSeconds = 0;
2578
2579 //
2580 // This function should only be called once.
2581 //
2583
2584 ClassGetDeviceParameter(fdoExtension,
2585 CLASSP_REG_SUBKEY_NAME,
2587 &d3ColdDisabledByUser);
2588
2589 //
2590 // If the device is hot-pluggable or the user has explicitly
2591 // disabled D3Cold, do not enable D3Cold for this device.
2592 //
2593 if (d3ColdDisabledByUser || fdoExtension->PrivateFdoData->HotplugInfo.DeviceHotplug) {
2594 fdoExtension->FunctionSupportInfo->IdlePower.D3ColdSupported = 0;
2595 }
2596
2597 ClassGetDeviceParameter(fdoExtension,
2598 CLASSP_REG_SUBKEY_NAME,
2600 &idleTimeoutOverrideInSeconds);
2601
2602 //
2603 // Set the idle timeout. If the user has not specified an override value,
2604 // this will either be a default value or will have been updated by the
2605 // power setting notification callback.
2606 //
2607 if (idleTimeoutOverrideInSeconds != 0) {
2608 fdoExtension->FunctionSupportInfo->IdlePower.D3IdleTimeout = (idleTimeoutOverrideInSeconds * 1000);
2609 fdoExtension->FunctionSupportInfo->IdlePower.D3IdleTimeoutOverridden = TRUE;
2610 } else {
2611 fdoExtension->FunctionSupportInfo->IdlePower.D3IdleTimeout = DiskIdleTimeoutInMS;
2612 }
2613
2614 //
2615 // We don't allow disks to be wakeable.
2616 //
2617 fdoExtension->FunctionSupportInfo->IdlePower.DeviceWakeable = FALSE;
2618
2619 //
2620 // Send IOCTL_STORAGE_ENABLE_IDLE_POWER to the port driver to enable idle
2621 // power management by the port driver.
2622 //
2624
2627
2628 //
2629 // Put this FDO on the list of devices that are idle power managed.
2630 //
2631 fdoEntry = ExAllocatePoolWithTag(NonPagedPoolNx, sizeof(IDLE_POWER_FDO_LIST_ENTRY), CLASS_TAG_POWER);
2632 if (fdoEntry) {
2633
2634 fdoExtension->FunctionSupportInfo->IdlePower.IdlePowerEnabled = TRUE;
2635
2637
2641
2642 //
2643 // If not registered already, register for disk idle timeout power
2644 // setting notifications. The power manager will call our power
2645 // setting callback very soon to set the idle timeout to the actual
2646 // value.
2647 //
2650 &GUID_DISK_IDLE_TIMEOUT,
2651 &ClasspPowerSettingCallback,
2652 NULL,
2653 &(PowerSettingNotificationHandle));
2654 }
2655 } else {
2656 fdoExtension->FunctionSupportInfo->IdlePower.IdlePowerEnabled = FALSE;
2658 }
2659 }
2660
2662}
#define CLASSP_REG_IDLE_TIMEOUT_IN_SECONDS
Definition: classp.h:124
POWER_SETTING_CALLBACK ClasspPowerSettingCallback
Definition: classp.h:1619
_IRQL_requires_same_ NTSTATUS ClasspSendEnableIdlePowerIoctl(_In_ PDEVICE_OBJECT DeviceObject)
Definition: power.c:2333
VOID FASTCALL KeReleaseGuardedMutex(IN OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:53
VOID FASTCALL KeAcquireGuardedMutex(IN PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:42
NTKRNLVISTAAPI NTSTATUS NTAPI PoRegisterPowerSettingCallback(_In_opt_ PDEVICE_OBJECT DeviceObject, _In_ LPCGUID SettingGuid, _In_ PPOWER_SETTING_CALLBACK Callback, _In_opt_ PVOID Context, _Outptr_opt_ PVOID *Handle)
Definition: po.c:14
Definition: classp.h:1033
◆ ClasspEnableTimer()
| VOID ClasspEnableTimer | ( | _In_ PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension | ) |
Definition at line 3857 of file autorun.c.
3860{
3862
3864 fdoData = FdoExtension->PrivateFdoData;
3865 }
3866
3868 //
3869 // The timer should have already been initialized, but if that's not
3870 // the case it's not the end of the world. We can attempt to
3871 // initialize it now.
3872 //
3878 return;
3879 }
3880 }
3881
3882#if (NTDDI_VERSION >= NTDDI_WINBLUE)
3887
3889
3890 //
3891 // Set the no-wake tolerance to "unlimited" if the conditions below
3892 // are met. An "unlimited" no-wake tolerance means that the timer
3893 // will *never* wake the processor if the processor is in a
3894 // low-power state.
3895 // 1. The screen is off.
3896 // 2. The class driver is *not* a consumer of the tick timer (ClassTick is NULL).
3897 // 3. This is a disk device.
3898 // Otherwise the tolerance is set to the normal tolerable delay.
3899 //
3904 } else {
3906 }
3907
3909
3911 dueTime,
3912 period,
3913 ¶meters);
3914
3916 } else {
3918 }
3919#else
3920 //
3921 // Start the periodic tick timer using a coalescable timer with some delay
3922 //
3923 {
3926 KeSetCoalescableTimer(&fdoData->TickTimer,
3928 &fdoData->TickTimerDpc);
3930 }
3931#endif
3932
3933 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, "ClasspEnableTimer: Periodic tick timer enabled "
3935
3936 }
3937
3938} // end ClasspEnableTimer()
NTSTATUS ClasspInitializeTimer(_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
Definition: autorun.c:3737
LONGLONG CurrentNoWakeTolerance
Definition: classp.h:677
Definition: extypes.h:292
Definition: dhcpd.h:248
NTKERNELAPI BOOLEAN NTAPI ExSetTimer(_In_ PEX_TIMER Timer, _In_ LONGLONG DueTime, _In_ LONGLONG Period, _In_opt_ PEXT_SET_PARAMETERS Parameters)
FORCEINLINE VOID ExInitializeSetTimerParameters(_Out_ PEXT_SET_PARAMETERS Parameters)
Definition: exfuncs.h:995
Referenced by ClasspDeviceLockFailurePowerIrpCompletion(), and ClasspPowerUpCompletion().
◆ ClasspEnqueueIdleRequest()
| NTSTATUS ClasspEnqueueIdleRequest | ( | PDEVICE_OBJECT | DeviceObject, |
| PIRP | Irp | ||
| ) |
Definition at line 576 of file clntirp.c.
580{
582 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
583 KIRQL oldIrql;
585 LARGE_INTEGER currentTime;
586 LARGE_INTEGER* pCurrentTime;
587
588 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_TIMER, "ClasspEnqueueIdleRequest: Queue idle request %p\n", Irp));
589
591
592 //
593 // Reset issueRequest if the idle duration is not sufficient.
594 //
595 pCurrentTime = ¤tTime;
597 issueRequest = FALSE;
598 }
599
600 //
601 // If there are already max active idle requests in the port driver, then
602 // queue this idle request.
603 //
605 issueRequest = FALSE;
606 }
607
608
612 }
614
615
616 fdoData->IdleIoCount++;
618 ClasspStartIdleTimer(fdoData);
619 }
620
622 issueRequest = FALSE;
623 }
624
625
627
628 if (issueRequest) {
630 }
631
633}
VOID ClasspStartIdleTimer(IN PCLASS_PRIVATE_FDO_DATA FdoData)
Definition: clntirp.c:261
Referenced by ClassReadWrite().
◆ ClasspFailurePredictionPeriodMissed()
| BOOLEAN ClasspFailurePredictionPeriodMissed | ( | _In_ PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension | ) |
Definition at line 4391 of file autorun.c.
4412{
4413 LARGE_INTEGER currentTime;
4414 LARGE_INTEGER timeDifference;
4416
4420
4421 //
4422 // Find the difference between the last failure prediction
4423 // query and the current time and convert it to seconds.
4424 //
4425 KeQuerySystemTime(¤tTime);
4426 timeDifference.QuadPart = currentTime.QuadPart - FdoExtension->FailurePredictionInfo->LastFailurePredictionQueryTime.QuadPart;
4427 timeDifference.QuadPart /= (10LL * 1000LL * 1000LL);
4428
4430 missedPeriod = TRUE;
4431 }
4432
4433 return missedPeriod;
4434}
Referenced by _Function_class_(), ClasspDeviceLockFailurePowerIrpCompletion(), and ClasspPowerUpCompletion().
◆ ClasspFreeDeviceMdl()
Definition at line 615 of file utils.c.
616{
619}
Referenced by ClasspCleanupOffloadReadContext(), ClasspCleanupOffloadWriteContext(), and FreeDeviceInputMdl().
◆ ClasspFreeReleaseRequest()
| VOID ClasspFreeReleaseRequest | ( | IN PDEVICE_OBJECT | Fdo | ) |
Definition at line 11525 of file class.c.
11528{
11530
11531 PAGED_CODE();
11532
11533 //KIRQL oldIrql;
11534
11536
11537 //
11538 // free anything the driver allocated
11539 //
11540
11544 } else {
11546 }
11548 }
11549
11550 //
11551 // free anything that we allocated
11552 //
11553
11554 if ((fdoExtension->PrivateFdoData) &&
11555 (fdoExtension->PrivateFdoData->ReleaseQueueIrpAllocated)) {
11556
11558 fdoExtension->PrivateFdoData->ReleaseQueueIrpAllocated = FALSE;
11559 }
11560
11561 return;
11562} // end ClasspFreeReleaseRequest()
◆ ClasspGetBlockDeviceTokenLimitsInfo()
| _IRQL_requires_same_ NTSTATUS ClasspGetBlockDeviceTokenLimitsInfo | ( | _Inout_ PDEVICE_OBJECT | DeviceObject | ) |
Definition at line 13220 of file class.c.
13243{
13247 ULONG srbSize = 0;
13248 USHORT pageLength = 0;
13253 PCDB cdb;
13254 ULONG dataTransferLength = 0;
13257
13258 TracePrint((TRACE_LEVEL_VERBOSE,
13259 TRACE_FLAG_PNP,
13260 "ClasspGetBlockDeviceTokenLimitsInfo (%p): Entering function.\n",
13261 DeviceObject));
13262
13263 //
13264 // Allocate an SRB for querying the device for LBP-related info.
13265 //
13268 srbSize = CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE;
13269 } else {
13271 }
13272
13274
13275 if (!srb) {
13276
13277 TracePrint((TRACE_LEVEL_ERROR,
13278 TRACE_FLAG_PNP,
13279 "ClasspGetBlockDeviceTokenLimitsInfo (%p): Couldn't allocate SRB.\n",
13280 DeviceObject));
13281
13283 goto __ClasspGetBlockDeviceTokenLimitsInfo_Exit;
13284 }
13285
13286#if defined(_ARM_) || defined(_ARM64_)
13287 //
13288 // ARM has specific alignment requirements, although this will not have a functional impact on x86 or amd64
13289 // based platforms. We are taking the conservative approach here.
13290 //
13291 allocationBufferLength = ALIGN_UP_BY(allocationBufferLength, KeGetRecommendedSharedDataAlignment());
13292 dataBuffer = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned, allocationBufferLength, CLASSPNP_POOL_TAG_VPD);
13293#else
13295#endif
13296
13298
13299 TracePrint((TRACE_LEVEL_ERROR,
13300 TRACE_FLAG_PNP,
13301 "ClasspGetBlockDeviceTokenLimitsInfo (%p): Couldn't allocate dataBuffer.\n",
13302 DeviceObject));
13303
13305 goto __ClasspGetBlockDeviceTokenLimitsInfo_Exit;
13306 }
13307
13309
13311
13315 STORAGE_ADDRESS_TYPE_BTL8,
13317 1,
13318 SrbExDataTypeScsiCdb16);
13320
13322
13323 } else {
13324
13325 //
13326 // Should not occur. Revert to legacy SRB.
13327 //
13329
13330 TracePrint((TRACE_LEVEL_WARNING,
13331 TRACE_FLAG_PNP,
13332 "ClasspGetBlockDeviceTokenLimitsInfo (%p): Falling back to using SRB (instead of SRB_EX).\n",
13333 DeviceObject));
13334
13338 }
13339 } else {
13340
13344 }
13345
13350
13351 SrbSetCdbLength(srb, 6);
13352
13353 cdb = SrbGetCdb(srb);
13355 cdb->CDB6INQUIRY3.EnableVitalProductData = 1;
13358
13360 srb,
13361 dataBuffer,
13362 allocationBufferLength,
13363 FALSE);
13364
13365 //
13366 // Handle the case where we get back STATUS_DATA_OVERRUN because the input
13367 // buffer was larger than necessary.
13368 //
13369 dataTransferLength = SrbGetDataTransferLength(srb);
13370
13372
13374 }
13375
13377
13379
13380 } else {
13381 TracePrint((TRACE_LEVEL_ERROR,
13382 TRACE_FLAG_PNP,
13383 "ClasspGetBlockDeviceTokenLimitsInfo (%p): Inquiry for TPC VPD failed with %x.\n",
13384 DeviceObject,
13385 status));
13386 }
13387
13390
13391 USHORT descriptorType;
13392
13393 blockDeviceTokenLimits = (PWINDOWS_BLOCK_DEVICE_TOKEN_LIMITS_DESCRIPTOR)operatingParameters->ThirdPartyCopyDescriptors;
13396
13398 (VPD_PAGE_HEADER_SIZE + descriptorLength == sizeof(WINDOWS_BLOCK_DEVICE_TOKEN_LIMITS_DESCRIPTOR))) {
13399
13400 fdoExtension->FunctionSupportInfo->ValidInquiryPages.BlockDeviceRODLimits = TRUE;
13401
13402 REVERSE_BYTES_SHORT(&fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumRangeDescriptors, &blockDeviceTokenLimits->MaximumRangeDescriptors);
13403 REVERSE_BYTES(&fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumInactivityTimer, &blockDeviceTokenLimits->MaximumInactivityTimer);
13404 REVERSE_BYTES(&fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.DefaultInactivityTimer, &blockDeviceTokenLimits->DefaultInactivityTimer);
13405 REVERSE_BYTES_QUAD(&fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumTokenTransferSize, &blockDeviceTokenLimits->MaximumTokenTransferSize);
13406 REVERSE_BYTES_QUAD(&fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.OptimalTransferCount, &blockDeviceTokenLimits->OptimalTransferCount);
13407
13408 TracePrint((TRACE_LEVEL_INFORMATION,
13409 TRACE_FLAG_PNP,
13410 "ClasspGetBlockDeviceTokenLimitsInfo (%p): %s %s (rev %s) reported following parameters: \
13411 \n\t\t\tMaxRangeDescriptors: %u\n\t\t\tMaxIAT: %u\n\t\t\tDefaultIAT: %u \
13412 \n\t\t\tMaxTokenTransferSize: %I64u\n\t\t\tOptimalTransferCount: %I64u\n\t\t\tOptimalTransferLengthGranularity: %u \
13413 \n\t\t\tOptimalTransferLength: %u\n\t\t\tMaxTransferLength: %u\n",
13414 DeviceObject,
13415 (PCSZ)(((PUCHAR)fdoExtension->DeviceDescriptor) + fdoExtension->DeviceDescriptor->VendorIdOffset),
13416 (PCSZ)(((PUCHAR)fdoExtension->DeviceDescriptor) + fdoExtension->DeviceDescriptor->ProductIdOffset),
13417 (PCSZ)(((PUCHAR)fdoExtension->DeviceDescriptor) + fdoExtension->DeviceDescriptor->ProductRevisionOffset),
13418 fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumRangeDescriptors,
13419 fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumInactivityTimer,
13420 fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.DefaultInactivityTimer,
13421 fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumTokenTransferSize,
13422 fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.OptimalTransferCount,
13423 fdoExtension->FunctionSupportInfo->BlockLimitsData.OptimalTransferLengthGranularity,
13424 fdoExtension->FunctionSupportInfo->BlockLimitsData.OptimalTransferLength,
13425 fdoExtension->FunctionSupportInfo->BlockLimitsData.MaximumTransferLength));
13426 } else {
13427
13428 TracePrint((TRACE_LEVEL_WARNING,
13429 TRACE_FLAG_PNP,
13430 "ClasspGetBlockDeviceTokenLimitsInfo (%p): ThirdPartyCopy VPD data doesn't have Windows OffloadDataTransfer descriptor.\n",
13431 DeviceObject));
13432
13433 fdoExtension->FunctionSupportInfo->ValidInquiryPages.BlockDeviceRODLimits = FALSE;
13435 }
13436 } else {
13437
13438 TracePrint((TRACE_LEVEL_WARNING,
13439 TRACE_FLAG_PNP,
13440 "ClasspGetBlockDeviceTokenLimitsInfo (%p): TPC VPD data didn't return TPC descriptors of interest.\n",
13441 DeviceObject));
13442
13443 fdoExtension->FunctionSupportInfo->ValidInquiryPages.BlockDeviceRODLimits = FALSE;
13445 }
13446
13447__ClasspGetBlockDeviceTokenLimitsInfo_Exit:
13448
13450 FREE_POOL(srb);
13451 fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.CommandStatus = status;
13452
13453 TracePrint((TRACE_LEVEL_VERBOSE,
13454 TRACE_FLAG_PNP,
13455 "ClasspGetBlockDeviceTokenLimitsInfo (%p): Exiting function with status %x.\n",
13456 DeviceObject,
13457 status));
13458
13460}
#define STATUS_DEVICE_FEATURE_NOT_SUPPORTED
Definition: ntstatus.h:1137
struct _VPD_THIRD_PARTY_COPY_PAGE * PVPD_THIRD_PARTY_COPY_PAGE
#define BLOCK_DEVICE_TOKEN_LIMITS_DESCRIPTOR_TYPE_WINDOWS
Definition: scsi.h:2569
struct _WINDOWS_BLOCK_DEVICE_TOKEN_LIMITS_DESCRIPTOR * PWINDOWS_BLOCK_DEVICE_TOKEN_LIMITS_DESCRIPTOR
Definition: scsi.h:2548
UCHAR ThirdPartyCopyDescriptors[ANYSIZE_ARRAY]
Definition: scsi.h:2554
UCHAR DescriptorLength[2]
Definition: scsi.h:2560
UCHAR DescriptorType[2]
Definition: scsi.h:2559
UCHAR DefaultInactivityTimer[4]
Definition: scsi.h:2564
UCHAR OptimalTransferCount[8]
Definition: scsi.h:2566
UCHAR MaximumRangeDescriptors[2]
Definition: scsi.h:2562
UCHAR MaximumTokenTransferSize[8]
Definition: scsi.h:2565
UCHAR MaximumInactivityTimer[4]
Definition: scsi.h:2563
Referenced by _IRQL_requires_().
◆ ClasspGetCurrentTime()
| FORCEINLINE LARGE_INTEGER ClasspGetCurrentTime | ( | VOID | ) |
Definition at line 1280 of file classp.h.
1283{
1284 LARGE_INTEGER currentTime;
1285
1286#ifndef __REACTOS__
1288#else
1290#endif
1291
1292 return currentTime;
1293}
LARGE_INTEGER NTAPI KeQueryPerformanceCounter(IN PLARGE_INTEGER PerformanceFreq)
Definition: timer.c:138
Referenced by ClasspIdleDurationSufficient(), ClasspIdleTimerDpc(), ClasspStartIdleTimer(), ClassReadWrite(), and TransferPktComplete().
◆ ClasspGetInquiryVpdSupportInfo()
| VOID ClasspGetInquiryVpdSupportInfo | ( | _Inout_ PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension | ) |
Definition at line 12914 of file class.c.
12917{
12920 SCSI_REQUEST_BLOCK srb = {0};
12921 PCDB cdb;
12926 PSTORAGE_REQUEST_BLOCK_HEADER srbHeader;
12927
12928#if defined(_ARM_) || defined(_ARM64_)
12929 //
12930 // ARM has specific alignment requirements, although this will not have a functional impact on x86 or amd64
12931 // based platforms. We are taking the conservative approach here.
12932 //
12933 allocationBufferLength = ALIGN_UP_BY(allocationBufferLength,KeGetRecommendedSharedDataAlignment());
12934 supportedPages = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
12935 allocationBufferLength,
12936 '3CcS'
12937 );
12938
12939#else
12940 supportedPages = ExAllocatePoolWithTag(NonPagedPoolNx,
12941 bufferLength,
12942 '3CcS'
12943 );
12944#endif
12945
12947 // memory allocation failure.
12948 return;
12949 }
12950
12951 RtlZeroMemory(supportedPages, allocationBufferLength);
12952
12953 // prepare the Srb
12955
12956#ifdef _MSC_VER
12957 #pragma prefast(suppress:26015, "InitializeStorageRequestBlock ensures buffer access is bounded")
12958#endif
12960 STORAGE_ADDRESS_TYPE_BTL8,
12961 sizeof(srbExBuffer),
12962 1,
12963 SrbExDataTypeScsiCdb16);
12964
12966 //
12967 // Should not happen. Revert to legacy SRB.
12971 srbHeader = (PSTORAGE_REQUEST_BLOCK_HEADER)&srb;
12972 } else {
12974 srbHeader = (PSTORAGE_REQUEST_BLOCK_HEADER)srbExBuffer;
12975 }
12976
12977 } else {
12980 srbHeader = (PSTORAGE_REQUEST_BLOCK_HEADER)&srb;
12981 }
12982
12987 SrbSetCdbLength(srbHeader, 6);
12988
12989 cdb = SrbGetCdb(srbHeader);
12993 cdb->CDB6INQUIRY3.AllocationLength = bufferLength; //AllocationLength field in CDB6INQUIRY3 is only one byte.
12994
12996 (PSCSI_REQUEST_BLOCK)srbHeader,
12997 supportedPages,
12998 allocationBufferLength,
12999 FALSE);
13000
13001 //
13002 // Handle the case where we get back STATUS_DATA_OVERRUN b/c the input
13003 // buffer was larger than necessary.
13004 //
13006 {
13008 }
13009
13011 (supportedPages->PageLength > 0) &&
13012 (supportedPages->SupportedPageList[0] > 0) ) {
13013 // ataport treats all INQUIRY command as standard INQUIRY command, thus fills invalid info
13014 // If VPD INQUIRY is supported, the first page reported (additional length field for standard INQUIRY data) should be '00'
13016 }
13017
13020
13022 if ( (i > 0) && (supportedPages->SupportedPageList[i] <= supportedPages->SupportedPageList[i - 1]) ) {
13023 // shall be in ascending order beginning with page code 00h.
13028
13029
13030 break;
13031 }
13035 break;
13036
13039 break;
13040
13043 break;
13044
13047 break;
13048
13049 }
13050 }
13051 }
13052
13053 ExFreePool(supportedPages);
13054
13055 return;
13056}
Definition: scsi.h:2673
◆ ClasspGetLBProvisioningInfo()
| NTSTATUS ClasspGetLBProvisioningInfo | ( | _Inout_ PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension | ) |
Definition at line 13087 of file class.c.
13090{
13092 ULONG srbSize = 0;
13093
13094 //
13095 // Make sure we actually have data structures to work with.
13096 //
13100 }
13101
13102 //
13103 // Allocate an SRB for querying the device for LBP-related info if either
13104 // the Logical Block Provisioning (0xB2) or Block Limits (0xB0) VPD page
13105 // exists.
13106 //
13109
13112 srbSize = CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE;
13113 } else {
13115 }
13116
13118
13121 }
13122 }
13123
13124 //
13125 // Get the Logical Block Provisioning VPD page (0xB2). This function will
13126 // set some default values if the LBP VPD page is not supported.
13127 //
13129
13130
13131 //
13132 // Get the Block Limits VPD page (0xB0), which may override the default
13133 // UNMAP parameter values set above.
13134 //
13136 srb,
13137 srbSize,
13138 &FdoExtension->FunctionSupportInfo->BlockLimitsData);
13139
13140 FREE_POOL(srb);
13141
13143}
NTSTATUS ClasspDeviceGetLBProvisioningVPDPage(_In_ PDEVICE_OBJECT DeviceObject, _Inout_opt_ PSCSI_REQUEST_BLOCK Srb)
Definition: utils.c:2350
NTSTATUS ClasspDeviceGetBlockLimitsVPDPage(_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _Inout_bytecount_(SrbSize) PSCSI_REQUEST_BLOCK Srb, _In_ ULONG SrbSize, _Out_ PCLASS_VPD_B0_DATA BlockLimitsData)
Definition: utils.c:2521
◆ ClasspGetMaxUsableBufferLengthFromOffset()
| FORCEINLINE ULONG ClasspGetMaxUsableBufferLengthFromOffset | ( | _In_ PVOID | BaseAddress, |
| _In_ ULONG | OffsetInBytes, | ||
| _In_ ULONG | BaseStructureSizeInBytes | ||
| ) |
Definition at line 2585 of file classp.h.
2612{
2613
2615
2617 //
2618 // This means BaseAddress + OffsetInBytes > ULONG_PTR_MAX.
2619 //
2620 return 0;
2621 }
2622
2623 if (OffsetInBytes > BaseStructureSizeInBytes) {
2624 return 0;
2625 }
2626
2627 return BaseStructureSizeInBytes - OffsetInBytes;
2628}
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize _Pre_valid_ PVOID * BaseAddress
Definition: mmfuncs.h:408
◆ ClasspGetTokenOperationCommandBufferLength()
| _IRQL_requires_same_ NTSTATUS ClasspGetTokenOperationCommandBufferLength | ( | _In_ PDEVICE_OBJECT | Fdo, |
| _In_ ULONG | ServiceAction, | ||
| _Inout_ PULONG | CommandBufferLength, | ||
| _Out_opt_ PULONG | TokenOperationBufferLength, | ||
| _Out_opt_ PULONG | ReceiveTokenInformationBufferLength | ||
| ) |
Definition at line 7356 of file utils.c.
7385{
7387 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
7388 ULONG tokenOperationBufferLength;
7389 ULONG receiveTokenInformationBufferLength;
7391 PSTORAGE_ADAPTER_DESCRIPTOR adapterDesc = commonExtension->PartitionZeroExtension->AdapterDescriptor;
7392 ULONG hwMaxXferLen;
7394 ULONG tokenOperationHeaderSize;
7395 ULONG responseSize;
7396
7397 TracePrint((TRACE_LEVEL_VERBOSE,
7398 TRACE_FLAG_IOCTL,
7399 "ClasspGetTokenOperationCommandBufferLengths (%p): Entering function.\n",
7400 Fdo));
7401
7402 NT_ASSERT(fdoExt->FunctionSupportInfo->ValidInquiryPages.BlockDeviceRODLimits &&
7403 NT_SUCCESS(fdoExt->FunctionSupportInfo->BlockDeviceRODLimitsData.CommandStatus));
7404
7407 responseSize = FIELD_OFFSET(RECEIVE_TOKEN_INFORMATION_RESPONSE_HEADER, TokenDescriptor) + sizeof(BLOCK_DEVICE_TOKEN_DESCRIPTOR);
7408 } else {
7410 responseSize = 0;
7411 }
7412
7413 //
7414 // The TokenOperation command can specify a parameter length of max 2^16.
7415 // If the device has a max limit on the number of range descriptors that can be specified in
7416 // the TokenOperation command, we are limited to the lesser of these two values.
7417 //
7418 if (fdoExt->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumRangeDescriptors == 0) {
7419
7420 tokenOperationBufferLength = MAX_TOKEN_OPERATION_PARAMETER_DATA_LENGTH;
7421
7422 } else {
7423
7424 tokenOperationBufferLength = MIN(tokenOperationHeaderSize + fdoExt->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumRangeDescriptors * sizeof(BLOCK_DEVICE_RANGE_DESCRIPTOR),
7426 }
7427
7428
7429 //
7430 // The ReceiveTokenInformation command can specify a parameter length of max 2 ^ 32
7431 // Also, since the sense data can be of variable size, we'll use MAX_SENSE_BUFFER_SIZE.
7432 //
7433 receiveTokenInformationBufferLength = MIN(FIELD_OFFSET(RECEIVE_TOKEN_INFORMATION_HEADER, SenseData) + MAX_SENSE_BUFFER_SIZE + responseSize,
7435
7436 //
7437 // Since we're going to reuse the buffer for both the TokenOperation and the ReceiveTokenInformation
7438 // commands, the buffer length needs to handle both operations.
7439 //
7441
7442 //
7443 // The buffer length needs to be further limited to the adapter's capability though.
7444 //
7447
7448 *CommandBufferLength = bufferLength;
7449
7450 if (TokenOperationBufferLength) {
7451 *TokenOperationBufferLength = tokenOperationBufferLength;
7452 }
7453
7454 if (ReceiveTokenInformationBufferLength) {
7455 *ReceiveTokenInformationBufferLength = receiveTokenInformationBufferLength;
7456 }
7457
7458 TracePrint((TRACE_LEVEL_VERBOSE,
7459 TRACE_FLAG_IOCTL,
7460 "ClasspGetTokenOperationCommandBufferLengths (%p): Exiting function with bufferLength %u (tokenOpBufLen %u, recTokenInfoBufLen %u).\n",
7461 Fdo,
7462 bufferLength,
7463 tokenOperationBufferLength,
7464 receiveTokenInformationBufferLength));
7465
7467}
#define MAX_RECEIVE_TOKEN_INFORMATION_PARAMETER_DATA_LENGTH
Definition: classp.h:208
Definition: scsi.h:3692
Definition: scsi.h:3638
Definition: scsi.h:3665
Definition: ntddstor.h:303
◆ ClasspGetTokenOperationDescriptorLimits()
| _IRQL_requires_same_ NTSTATUS ClasspGetTokenOperationDescriptorLimits | ( | _In_ PDEVICE_OBJECT | Fdo, |
| _In_ ULONG | ServiceAction, | ||
| _In_ ULONG | MaxParameterBufferLength, | ||
| _Out_ PULONG | MaxBlockDescriptorsCount, | ||
| _Out_ PULONGLONG | MaxBlockDescriptorsLength | ||
| ) |
Definition at line 7472 of file utils.c.
7501{
7506
7507 TracePrint((TRACE_LEVEL_VERBOSE,
7508 TRACE_FLAG_IOCTL,
7509 "ClasspGetTokenOperationDescriptorLimits (%p): Entering function.\n",
7510 Fdo));
7511
7512 NT_ASSERT(fdoExt->FunctionSupportInfo->ValidInquiryPages.BlockDeviceRODLimits &&
7513 NT_SUCCESS(fdoExt->FunctionSupportInfo->BlockDeviceRODLimitsData.CommandStatus));
7514
7515 *MaxBlockDescriptorsCount = (MaxParameterBufferLength - tokenOperationHeaderSize) / sizeof(BLOCK_DEVICE_RANGE_DESCRIPTOR);
7516 *MaxBlockDescriptorsLength = (fdoExt->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumTokenTransferSize == 0) ?
7517 MAX_TOKEN_TRANSFER_SIZE : fdoExt->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumTokenTransferSize;
7518
7519 TracePrint((TRACE_LEVEL_VERBOSE,
7520 TRACE_FLAG_IOCTL,
7521 "ClasspGetTokenOperationDescriptorLimits (%p): Exiting function with MaxDescr %u, MaxXferBlocks %I64u.\n",
7522 Fdo,
7523 *MaxBlockDescriptorsCount,
7524 *MaxBlockDescriptorsLength));
7525
7527}
◆ ClasspInitializeGesn()
| NTSTATUS ClasspInitializeGesn | ( | IN PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| IN PMEDIA_CHANGE_DETECTION_INFO | Info | ||
| ) |
Definition at line 1990 of file autorun.c.
1994{
1997 PSTORAGE_DEVICE_DESCRIPTOR deviceDescriptor;
2001 BOOLEAN retryImmediately;
2003 ULONG atapiResets;
2004 ULONG srbFlags;
2005
2006 PAGED_CODE();
2008
2009 //
2010 // read if we already know the abilities of the device
2011 //
2012
2013 ClassGetDeviceParameter(FdoExtension,
2014 CLASSP_REG_SUBKEY_NAME,
2016 (PULONG)&detectionState);
2017
2019 goto ExitWithError;
2020 }
2021
2022 //
2023 // check if the device has a hack flag saying never to try this.
2024 //
2025
2027 FDO_HACK_GESN_IS_BAD)) {
2028
2029 ClassSetDeviceParameter(FdoExtension,
2030 CLASSP_REG_SUBKEY_NAME,
2032 ClassDetectionUnsupported);
2033 goto ExitWithError;
2034
2035 }
2036
2037
2038 //
2039 // else go through the process since we allocate buffers and
2040 // get all sorts of device settings.
2041 //
2042
2045 GESN_BUFFER_SIZE,
2046 '??cS');
2047 }
2050 goto ExitWithError;
2051 }
2054 }
2056 GESN_BUFFER_SIZE,
2060 goto ExitWithError;
2061 }
2062
2065 Info->Gesn.EventMask = 0;
2066
2067 //
2068 // all items are prepared to use GESN (except the event mask, so don't
2069 // optimize this part out!).
2070 //
2071 // now see if it really works. we have to loop through this because
2072 // many SAMSUNG (and one COMPAQ) drives timeout when requesting
2073 // NOT_READY events, even when the IMMEDIATE bit is set. :(
2074 //
2075 // using a drive list is cumbersome, so this might fix the problem.
2076 //
2077
2078 deviceDescriptor = FdoExtension->DeviceDescriptor;
2079 atapiResets = 0;
2080 retryImmediately = TRUE;
2082
2086 goto ExitWithError;
2087 }
2088
2090 srbFlags = Info->MediaChangeSrb.SrbEx.SrbFlags;
2091 } else {
2092 srbFlags = Info->MediaChangeSrb.Srb.SrbFlags;
2093 }
2095
2096 //
2097 // replace the completion routine with a different one this time...
2098 //
2099
2102 ClassSignalCompletion,
2103 &event,
2105
2107
2110 Executive,
2111 KernelMode,
2112 FALSE,
2113 NULL);
2115 }
2117
2119
2121 irp,
2122 &(Info->MediaChangeSrb.Srb),
2123 IRP_MJ_SCSI,
2124 0,
2125 0,
2126 &status,
2127 NULL);
2128 }
2129
2132 ) {
2133
2134 //
2135 // ATAPI unfortunately returns SRB_STATUS_BUS_RESET instead
2136 // of SRB_STATUS_TIMEOUT, so we cannot differentiate between
2137 // the two. if we get this status four time consecutively,
2138 // stop trying this command. it is too late to change ATAPI
2139 // at this point, so special-case this here. (07/10/2001)
2140 // NOTE: any value more than 4 may cause the device to be
2141 // marked missing.
2142 //
2143
2144 atapiResets++;
2145 if (atapiResets >= 4) {
2147 goto ExitWithError;
2148 }
2149 }
2150
2153 }
2154
2159 ) {
2160
2161 //
2162 // with these error codes, we don't ever want to try this command
2163 // again on this device, since it reacts poorly.
2164 //
2165
2166 ClassSetDeviceParameter(FdoExtension,
2167 CLASSP_REG_SUBKEY_NAME,
2169 ClassDetectionUnsupported);
2170 TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN,
2171 "Classpnp => GESN test failed %x for fdo %p\n",
2173 goto ExitWithError;
2174
2175
2176 }
2177
2179
2180 //
2181 // this may be other errors that should not disable GESN
2182 // for all future start_device calls.
2183 //
2184
2185 TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN,
2186 "Classpnp => GESN test failed %x for fdo %p\n",
2188 goto ExitWithError;
2189 }
2190
2192
2193 //
2194 // the first time, the request was just retrieving a mask of
2195 // available bits. use this to mask future requests.
2196 //
2197
2199
2200 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
2201 "Classpnp => Fdo %p supports event mask %x\n",
2203
2204
2206 NOTIFICATION_MEDIA_STATUS_CLASS_MASK)) {
2207 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
2208 "Classpnp => GESN supports MCN\n"));
2209 }
2211 NOTIFICATION_DEVICE_BUSY_CLASS_MASK)) {
2212 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
2213 "Classpnp => GESN supports DeviceBusy\n"));
2214 }
2217
2219 FDO_HACK_GESN_IGNORE_OPCHANGE)) {
2220 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
2221 "Classpnp => GESN supports OpChange, but "
2222 "must ignore these events for compatibility\n"));
2225 } else {
2226 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
2227 "Classpnp => GESN supports OpChange\n"));
2228 }
2229 }
2231
2232 //
2233 // realistically, we are only considering the following events:
2234 // EXTERNAL REQUEST - this is being tested for play/stop/etc.
2235 // MEDIA STATUS - autorun and ejection requests.
2236 // DEVICE BUSY - to allow us to predict when media will be ready.
2237 // therefore, we should not bother querying for the other,
2238 // unknown events. clear all but the above flags.
2239 //
2240
2241 Info->Gesn.EventMask &=
2246
2247
2248 //
2249 // HACKHACK - REF #0001
2250 // Some devices will *never* report an event if we've also requested
2251 // that it report lower-priority events. this is due to a
2252 // misunderstanding in the specification wherein a "No Change" is
2253 // interpreted to be a real event. what should occur is that the
2254 // device should ignore "No Change" events when multiple event types
2255 // are requested unless there are no other events waiting. this
2256 // greatly reduces the number of requests that the host must send
2257 // to determine if an event has occurred. Since we must work on all
2258 // drives, default to enabling the hack until we find evidence of
2259 // proper firmware.
2260 //
2262
2263 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
2264 "Classpnp => GESN supported, but not mask we care "
2265 "about (%x) for FDO %p\n",
2266 header->SupportedEventClasses,
2267 FdoExtension->DeviceObject));
2268 goto ExitWithError;
2269
2271
2272 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
2273 "Classpnp => GESN hack not required for FDO %p\n",
2274 FdoExtension->DeviceObject));
2275
2276 } else {
2277
2278 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
2279 "Classpnp => GESN hack enabled for FDO %p\n",
2280 FdoExtension->DeviceObject));
2281 Info->Gesn.HackEventMask = 1;
2282
2283 }
2284
2285 } else {
2286
2287 //
2288 // not the first time looping through, so interpret the results.
2289 //
2290
2293 &retryImmediately);
2294
2296
2297 //
2298 // This drive does not support GESN correctly
2299 //
2300
2301 ClassSetDeviceParameter(FdoExtension,
2302 CLASSP_REG_SUBKEY_NAME,
2304 ClassDetectionUnsupported);
2305 goto ExitWithError;
2306 }
2307 }
2308
2309 } // end loop of GESN requests....
2310
2311 //
2312 // we can only use this if it can be relied upon for media changes,
2313 // since we are (by definition) no longer going to be polling via
2314 // a TEST_UNIT_READY irp, and drives will not report UNIT ATTENTION
2315 // for this command (although a filter driver, such as one for burning
2316 // cd's, might still fake those errors).
2317 //
2318 // since we also rely upon NOT_READY events to change the cursor
2319 // into a "wait" cursor; GESN is still more reliable than other
2320 // methods, and includes eject button requests, so we'll use it
2321 // without DEVICE_BUSY in Windows Vista.
2322 //
2323
2325
2326 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
2327 "Classpnp => Enabling GESN support for fdo %p\n",
2328 FdoExtension->DeviceObject));
2330
2331 ClassSetDeviceParameter(FdoExtension,
2332 CLASSP_REG_SUBKEY_NAME,
2334 ClassDetectionSupported);
2335
2337
2338 }
2339
2340 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
2341 "Classpnp => GESN available but not enabled for fdo %p\n",
2342 FdoExtension->DeviceObject));
2343 goto ExitWithError;
2344
2345 // fall through...
2346
2347ExitWithError:
2348 TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN,
2349 "Classpnp => GESN support detection failed for fdo %p with status %08x\n",
2351
2352
2356 }
2358 Info->Gesn.Supported = 0;
2359 Info->Gesn.EventMask = 0;
2360 Info->Gesn.BufferSize = 0;
2362
2363}
#define CLASSP_REG_MMC_DETECTION_VALUE_NAME
Definition: cdromp.h:123
PIRP ClasspPrepareMcnIrp(IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN PMEDIA_CHANGE_DETECTION_INFO Info, IN BOOLEAN UseGesn)
Definition: autorun.c:1310
NTSTATUS ClasspInterpretGesnData(IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN PNOTIFICATION_EVENT_STATUS_HEADER Header, OUT PBOOLEAN ResendImmediately)
Definition: autorun.c:251
BOOLEAN InterpretSenseInfoWithoutHistory(_In_ PDEVICE_OBJECT Fdo, _In_opt_ PIRP OriginalRequest, _In_ PSCSI_REQUEST_BLOCK Srb, UCHAR MajorFunctionCode, ULONG IoDeviceCode, ULONG PreviousRetryCount, _Out_ NTSTATUS *Status, _Out_opt_ _Deref_out_range_(0, MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS) LONGLONG *RetryIn100nsUnits)
Definition: class.c:12844
#define NOTIFICATION_MEDIA_STATUS_CLASS_MASK
Definition: scsi.h:37
#define NOTIFICATION_EXTERNAL_REQUEST_CLASS_MASK
Definition: scsi.h:36
#define NOTIFICATION_OPERATIONAL_CHANGE_CLASS_MASK
Definition: scsi.h:34
struct _NOTIFICATION_EVENT_STATUS_HEADER * PNOTIFICATION_EVENT_STATUS_HEADER
Definition: scsi.h:2037
Definition: ntddstor.h:287
Definition: winhttp_private.h:134
_Must_inspect_result_ _In_ WDFCHILDLIST _In_ PWDF_CHILD_LIST_ITERATOR _Out_ WDFDEVICE _Inout_opt_ PWDF_CHILD_RETRIEVE_INFO Info
Definition: wdfchildlist.h:690
Referenced by ClasspInitializePolling().
◆ ClasspInitializeHotplugInfo()
| NTSTATUS ClasspInitializeHotplugInfo | ( | IN PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension | ) |
Definition at line 12507 of file class.c.
12510{
12512 DEVICE_REMOVAL_POLICY deviceRemovalPolicy = 0;
12514 ULONG resultLength = 0;
12515 ULONG writeCacheOverride;
12516
12517 PAGED_CODE();
12518
12519 //
12520 // start with some default settings
12521 //
12523
12524 //
12525 // set the size (aka version)
12526 //
12527
12529
12530 //
12531 // set if the device has removable media
12532 //
12533
12536 } else {
12538 }
12539
12540 //
12541 // this refers to devices which, for reasons not yet understood,
12542 // do not fail PREVENT_MEDIA_REMOVAL requests even though they
12543 // have no way to lock the media into the drive. this allows
12544 // the filesystems to turn off delayed-write caching for these
12545 // devices as well.
12546 //
12547
12549 FDO_HACK_CANNOT_LOCK_MEDIA)) {
12551 } else {
12553 }
12554
12555 //
12556 // Query the default removal policy from the kernel
12557 //
12558
12560 DevicePropertyRemovalPolicy,
12562 (PVOID)&deviceRemovalPolicy,
12563 &resultLength);
12566 }
12567
12570 }
12571
12572 //
12573 // Look into the registry to see if the user has chosen
12574 // to override the default setting for the removal policy.
12575 // User can override only if the default removal policy is
12576 // orderly or suprise removal.
12577
12579 (deviceRemovalPolicy == RemovalPolicyExpectSurpriseRemoval)) {
12580
12581 DEVICE_REMOVAL_POLICY userRemovalPolicy = 0;
12582
12583 ClassGetDeviceParameter(FdoExtension,
12584 CLASSP_REG_SUBKEY_NAME,
12586 (PULONG)&userRemovalPolicy);
12587
12588 //
12589 // Validate the override value and use it only if it is an
12590 // allowed value.
12591 //
12593 (userRemovalPolicy == RemovalPolicyExpectSurpriseRemoval)) {
12594 deviceRemovalPolicy = userRemovalPolicy;
12595 }
12596 }
12597
12598 //
12599 // use this info to set the DeviceHotplug setting
12600 // don't rely on DeviceCapabilities, since it can't properly
12601 // determine device relations, etc. let the kernel figure this
12602 // stuff out instead.
12603 //
12604
12607 } else {
12609 }
12610
12611 //
12612 // this refers to the *filesystem* caching, but has to be included
12613 // here since it's a per-device setting. this may change to be
12614 // stored by the system in the future.
12615 //
12616
12617 writeCacheOverride = FALSE;
12618 ClassGetDeviceParameter(FdoExtension,
12619 CLASSP_REG_SUBKEY_NAME,
12621 &writeCacheOverride);
12622
12623 if (writeCacheOverride) {
12625 } else {
12627 }
12628
12630}
#define CLASSP_REG_REMOVAL_POLICY_VALUE_NAME
Definition: cdromp.h:126
struct _STORAGE_HOTPLUG_INFO STORAGE_HOTPLUG_INFO
NTSTATUS NTAPI IoGetDeviceProperty(IN PDEVICE_OBJECT DeviceObject, IN DEVICE_REGISTRY_PROPERTY DeviceProperty, IN ULONG BufferLength, OUT PVOID PropertyBuffer, OUT PULONG ResultLength)
Definition: pnpmgr.c:1382
Definition: imports.h:244
BOOLEAN WriteCacheEnableOverride
Definition: imports.h:249
enum _DEVICE_REMOVAL_POLICY DEVICE_REMOVAL_POLICY
Referenced by ClassPnpStartDevice().
◆ ClasspInitializeIdleTimer()
| VOID ClasspInitializeIdleTimer | ( | PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension | ) |
Definition at line 175 of file clntirp.c.
178{
182 ULONG activeIdleIoMax = 1;
183
184 ClassGetDeviceParameter(FdoExtension,
187 &idlePrioritySupported);
188
189
191 //
192 // User has set the registry to disable idle priority for this disk.
193 // No need to initialize any further.
194 // Always ensure that none of the other fields used for idle priority
195 // io are ever used without checking if it is supported.
196 //
197 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_TIMER, "ClasspInitializeIdleTimer: Idle priority not supported for disk %p\n", FdoExtension));
199 fdoData->IdleIoCount = 0;
200 fdoData->ActiveIoCount = 0;
201 return;
202 }
203
204 ClassGetDeviceParameter(FdoExtension,
207 &idleInterval);
208
210 //
211 // If the interval is too low or too high, reset it to the default value.
212 //
213 idleInterval = CLASS_IDLE_INTERVAL;
214 }
215
224 fdoData->IdleIoCount = 0;
225 fdoData->ActiveIoCount = 0;
226 fdoData->ActiveIdleIoCount = 0;
227
228 ClassGetDeviceParameter(FdoExtension,
231 &activeIdleIoMax);
232
233 activeIdleIoMax = max(activeIdleIoMax, 1);
235
237
238 return;
239}
#define CLASSP_REG_IDLE_PRIORITY_SUPPORTED
Definition: classp.h:121
VOID NTAPI KeInitializeDpc(IN PKDPC Dpc, IN PKDEFERRED_ROUTINE DeferredRoutine, IN PVOID DeferredContext)
Definition: dpc.c:712
◆ ClasspInitializeRemoveTracking()
| VOID ClasspInitializeRemoveTracking | ( | _In_ PDEVICE_OBJECT | DeviceObject | ) |
Definition at line 500 of file lock.c.
503{
505
506 #if DBG
508
509 commonExtension->RemoveTrackingList = ExAllocatePoolWithTag(NonPagedPoolNx, sizeof(RTL_GENERIC_TABLE), CLASS_TAG_LOCK_TRACKING);
510
512 {
517 NULL);
518 }
519 #else
520
522
525 #endif
526}
RTL_GENERIC_FREE_ROUTINE RemoveTrackingFreeRoutine
Definition: classp.h:2404
RTL_GENERIC_ALLOCATE_ROUTINE RemoveTrackingAllocateRoutine
Definition: classp.h:2402
RTL_GENERIC_COMPARE_ROUTINE RemoveTrackingCompareRoutine
Definition: classp.h:2400
VOID NTAPI RtlInitializeGenericTable(IN PRTL_GENERIC_TABLE Table, IN PRTL_GENERIC_COMPARE_ROUTINE CompareRoutine, IN PRTL_GENERIC_ALLOCATE_ROUTINE AllocateRoutine, IN PRTL_GENERIC_FREE_ROUTINE FreeRoutine, IN PVOID TableContext)
Definition: generictable.c:100
KSPIN_LOCK RemoveTrackingSpinlock
Definition: classpnp.h:603
Definition: rtltypes.h:490
◆ ClasspInitializeTimer()
| NTSTATUS ClasspInitializeTimer | ( | _In_ PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension | ) |
Definition at line 3737 of file autorun.c.
3764{
3766
3768 fdoData = FdoExtension->PrivateFdoData;
3769 }
3770
3773 }
3774
3776#if (NTDDI_VERSION >= NTDDI_WINBLUE)
3778 //
3779 // The tick timer is a no-wake timer, which means it will not wake
3780 // the processor while the processor is in a low power state until
3781 // the timer's no-wake tolerance is reached.
3782 //
3786 }
3787#else
3790#endif
3792 }
3793
3795}
NTKERNELAPI PEX_TIMER NTAPI ExAllocateTimer(_In_opt_ PEXT_CALLBACK Callback, _In_opt_ PVOID CallbackContext, _In_ ULONG Attributes)
Referenced by ClasspEnableTimer(), and ClassPnpStartDevice().
◆ ClasspIsIdleRequest()
| FORCEINLINE BOOLEAN ClasspIsIdleRequest | ( | PIRP | Irp | ) |
Definition at line 1268 of file classp.h.
1271{
1272#ifdef _MSC_VER
1273#pragma warning(suppress:4305) // truncation is not an issue for this use case
1274#endif
1276}
Referenced by SubmitTransferPacket(), and TransferPktComplete().
◆ ClasspIsIdleRequestSupported()
| FORCEINLINE BOOLEAN ClasspIsIdleRequestSupported | ( | PCLASS_PRIVATE_FDO_DATA | FdoData, |
| PIRP | Irp | ||
| ) |
Definition at line 1236 of file classp.h.
1240{
1241#ifndef __REACTOS__
1244#else
1246#endif
1247}
NTKRNLVISTAAPI IO_PRIORITY_HINT NTAPI IoGetIoPriorityHint(_In_ PIRP Irp)
Definition: io.c:153
enum _IO_PRIORITY_HINT IO_PRIORITY_HINT
Referenced by ClassReadWrite().
◆ ClasspIsObsoletePortDriver()
| FORCEINLINE BOOLEAN ClasspIsObsoletePortDriver | ( | _In_ PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension | ) |
Definition at line 1335 of file classp.h.
1338{
1342 }
1343
1345}
Referenced by ClasspAccessAlignmentProperty(), and ClassReadCapacity16().
◆ ClasspIsOffloadDataTransferCommand()
| FORCEINLINE BOOLEAN ClasspIsOffloadDataTransferCommand | ( | _In_ PCDB | Cdb | ) |
Definition at line 2087 of file classp.h.
2090{
2091 BOOLEAN offloadCommand = (ClasspIsTokenOperation(Cdb) || ClasspIsReceiveTokenInformation(Cdb)) ? TRUE : FALSE;
2092
2093 return offloadCommand;
2094}
FORCEINLINE BOOLEAN ClasspIsReceiveTokenInformation(_In_ PCDB Cdb)
Definition: classp.h:2066
FORCEINLINE BOOLEAN ClasspIsTokenOperation(_In_ PCDB Cdb)
Definition: classp.h:2044
Referenced by ClassInterpretSenseInfo(), and InterpretTransferPacketError().
◆ ClasspIsPortable()
| NTSTATUS ClasspIsPortable | ( | _In_ PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| _Out_ PBOOLEAN | IsPortable | ||
| ) |
Definition at line 8837 of file class.c.
8841{
8847
8848 PAGED_CODE();
8849
8850 *IsPortable = FALSE;
8851
8852 //
8853 // Check to see if the underlying device
8854 // object is in local machine container
8855 //
8856
8858 &DEVPKEY_Device_InLocalMachineContainer,
8859 0,
8860 0,
8861 sizeof(isInternal),
8862 &isInternal,
8863 &size,
8864 &type);
8865
8868 }
8869
8872
8873 //
8874 // Volume is hot-pluggable if the disk pdo
8875 // container id differs from that of root device
8876 //
8877
8880 }
8881
8882 isPortable = TRUE;
8883
8884 //
8885 // Examine the bus type to ensure
8886 // that this really is a fixed disk
8887 //
8888
8892
8893 isPortable = FALSE;
8894 }
8895
8896 *IsPortable = isPortable;
8897
8898cleanup:
8899
8901}
Referenced by ClassPnpStartDevice().
◆ ClasspIsReceiveTokenInformation()
| FORCEINLINE BOOLEAN ClasspIsReceiveTokenInformation | ( | _In_ PCDB | Cdb | ) |
Definition at line 2066 of file classp.h.
2069{
2071
2075
2076 if (opCode == SCSIOP_RECEIVE_ROD_TOKEN_INFORMATION && serviceAction == SERVICE_ACTION_RECEIVE_TOKEN_INFORMATION) {
2077
2078 receiveTokenInformation = TRUE;
2079 }
2080 }
2081
2082 return receiveTokenInformation;
2083}
#define SCSIOP_RECEIVE_ROD_TOKEN_INFORMATION
Definition: scsi.h:343
#define SERVICE_ACTION_RECEIVE_TOKEN_INFORMATION
Definition: scsi.h:447
Referenced by ClassInterpretSenseInfo(), ClasspIsOffloadDataTransferCommand(), and ClasspTransferPacketGetNumberOfRetriesDone().
◆ ClasspIsThinProvisioned()
| FORCEINLINE BOOLEAN ClasspIsThinProvisioned | ( | _In_ PCLASS_FUNCTION_SUPPORT_INFO | SupportInfo | ) |
Definition at line 1317 of file classp.h.
1320{
1321 //
1322 // We only support thinly provisioned devices that also support UNMAP.
1323 //
1325 SupportInfo->LBProvisioningData.LBPU == TRUE)
1326 {
1328 }
1329
1331}
Referenced by ClasspDeviceLBProvisioningProperty().
◆ ClasspIsThinProvisioningError()
| BOOLEAN ClasspIsThinProvisioningError | ( | _In_ PSCSI_REQUEST_BLOCK | _Srb | ) |
Definition at line 9127 of file utils.c.
9146{
9149 if (senseBuffer) {
9151 UCHAR addlSenseCode = 0;
9152 UCHAR addlSenseCodeQual = 0;
9155 SCSI_SENSE_OPTIONS_NONE,
9156 &senseKey,
9157 &addlSenseCode,
9158 &addlSenseCodeQual);
9159
9162 && (addlSenseCode == SCSI_ADSENSE_LB_PROVISIONING)
9163 && (addlSenseCodeQual == SCSI_SENSEQ_SOFT_THRESHOLD_REACHED));
9164 }
9165 }
9167}
FORCEINLINE PVOID SrbGetSenseInfoBuffer(_In_ PVOID Srb)
Definition: srbhelper.h:627
FORCEINLINE UCHAR SrbGetSenseInfoBufferLength(_In_ PVOID Srb)
Definition: srbhelper.h:646
Referenced by RetryTransferPacket().
◆ ClasspIsTokenOperation()
| FORCEINLINE BOOLEAN ClasspIsTokenOperation | ( | _In_ PCDB | Cdb | ) |
Definition at line 2044 of file classp.h.
2047{
2049
2053
2056
2057 tokenOperation = TRUE;
2058 }
2059 }
2060
2061 return tokenOperation;
2062}
Referenced by ClasspIsOffloadDataTransferCommand(), and InterpretTransferPacketError().
◆ ClasspIsTokenOperationComplete()
| FORCEINLINE BOOLEAN ClasspIsTokenOperationComplete | ( | _In_ ULONG | CurrentStatus | ) |
Definition at line 2023 of file classp.h.
2026{
2028
2029 switch (CurrentStatus) {
2034
2035 operationCompleted = TRUE;
2036 }
2037 }
2038
2039 return operationCompleted;
2040}
@ OPERATION_COMPLETED_WITH_RESIDUAL_DATA
Definition: scsi.h:3700
Referenced by ClasspReceivePopulateTokenInformationTransferPacketDone(), and ClasspReceiveWriteUsingTokenInformationTransferPacketDone().
◆ ClasspLogSystemEventWithDeviceNumber()
| NTSTATUS ClasspLogSystemEventWithDeviceNumber | ( | _In_ PDEVICE_OBJECT | DeviceObject, |
| _In_ NTSTATUS | IoErrorCode | ||
| ) |
Definition at line 5354 of file utils.c.
5374{
5376 PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
5380 LONG stringSize = 0;
5381
5382 //
5383 // We need to allocate enough space for one insertion string: a ULONG
5384 // representing the disk number in decimal, which means a max of 10 digits,
5385 // plus one for the NULL character.
5386 // Make sure we do not exceed the max error log size or the max size of a
5387 // UCHAR since the size gets truncated to a UCHAR when we pass it to
5388 // IoAllocateErrorLogEntry().
5389 //
5393
5394 errorLogEntry = (PIO_ERROR_LOG_PACKET)IoAllocateErrorLogEntry(DeviceObject, (UCHAR)logEntrySize);
5395 if (errorLogEntry) {
5396
5397 RtlZeroMemory(errorLogEntry, logEntrySize);
5399 errorLogEntry->ErrorCode = IoErrorCode;
5400
5403
5404 //
5405 // Add the disk number to the insertion strings.
5406 //
5408
5410 errorLogEntry->NumberOfStrings++;
5411 }
5412
5413 //
5414 // Write the error log packet to the system error logging thread.
5415 // It will be freed automatically.
5416 //
5417 IoWriteErrorLogEntry(errorLogEntry);
5418
5420 }
5421
5423}
PVOID NTAPI IoAllocateErrorLogEntry(IN PVOID IoObject, IN UCHAR EntrySize)
Definition: error.c:528
NTSTRSAFEVAPI RtlStringCbPrintfW(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PWSTR pszDest, _In_ size_t cbDest, _In_ _Printf_format_string_ NTSTRSAFE_PCWSTR pszFormat,...)
Definition: ntstrsafe.h:1173
Definition: iotypes.h:2000
struct _IO_ERROR_LOG_PACKET * PIO_ERROR_LOG_PACKET
struct _IO_ERROR_LOG_PACKET IO_ERROR_LOG_PACKET
Referenced by ClassDispatchPnp(), and ClassIoComplete().
◆ ClasspLowerLayerNotSupport()
| FORCEINLINE BOOLEAN ClasspLowerLayerNotSupport | ( | _In_ NTSTATUS | Status | ) |
Definition at line 2638 of file classp.h.
2641{
2646}
Referenced by ClasspAccessAlignmentProperty(), ClasspDeviceSeekPenaltyProperty(), ClasspDeviceTrimProcess(), and ClasspGetHwFirmwareInfo().
◆ ClasspMarkIrpAsIdle()
| FORCEINLINE VOID ClasspMarkIrpAsIdle | ( | PIRP | Irp, |
| BOOLEAN | Idle | ||
| ) |
Definition at line 1251 of file classp.h.
1255{
1256#ifndef __REACTOS__
1257// truncation is not an issue for this use case
1258// nonstandard extension used is not an issue for this use case
1259#pragma warning(suppress:4305; suppress:4213)
1261#else
1263#endif
1264}
Referenced by ClassReadWrite().
◆ ClasspMcnControl()
| NTSTATUS ClasspMcnControl | ( | IN PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| IN PIRP | Irp, | ||
| IN PSCSI_REQUEST_BLOCK | Srb | ||
| ) |
Definition at line 3276 of file autorun.c.
3281{
3282 PCOMMON_DEVICE_EXTENSION commonExtension =
3284
3287
3290
3292
3293 PAGED_CODE();
3294
3295 //
3296 // Check to make sure we have a file object extension to keep track of this
3297 // request. If not we'll fail it before synchronizing.
3298 //
3299
3300 TRY {
3301
3303 fsContext = ClassGetFsContext(commonExtension, fileObject);
3305 fsContext = &FdoExtension->KernelModeMcnContext;
3306 }
3307
3309
3310 //
3311 // This handle isn't setup correctly. We can't let the
3312 // operation go.
3313 //
3314
3316 LEAVE;
3317 }
3318
3320
3321 //
3322 // This is a lock command. Reissue the command in case bus or
3323 // device was reset and the lock was cleared.
3324 //
3325
3326 ClassDisableMediaChangeDetection(FdoExtension);
3328
3329 } else {
3330
3333 LEAVE;
3334 }
3335
3337 ClassEnableMediaChangeDetection(FdoExtension);
3338 }
3339
3340 } FINALLY {
3341
3343
3345
3348 Irp,
3349 IO_NO_INCREMENT);
3350 }
3352} // end ClasspMcnControl(
Definition: ntddstor.h:342
Definition: tftpd.h:86
#define TRY(sps, bps)
Referenced by ClassDeviceControl().
◆ ClasspMediaChangeCompletion()
| NTSTATUS ClasspMediaChangeCompletion | ( | PDEVICE_OBJECT | DeviceObject, |
| PIRP | Irp, | ||
| PVOID | Context | ||
| ) |
◆ ClasspModeSelect()
| NTSTATUS ClasspModeSelect | ( | _In_ PDEVICE_OBJECT | Fdo, |
| _In_reads_bytes_(Length) PCHAR | ModeSelectBuffer, | ||
| _In_ ULONG | Length, | ||
| _In_ BOOLEAN | SavePages | ||
| ) |
Definition at line 6919 of file class.c.
6925{
6926
6927 PMDL senseBufferMdl;
6929
6931 if (senseBufferMdl) {
6932
6934 if (pkt){
6936 IRP pseudoIrp = {0};
6937
6938 /*
6939 * Store the number of packets servicing the irp (one)
6940 * inside the original IRP. It will be used to counted down
6941 * to zero when the packet completes.
6942 * Initialize the original IRP's status to success.
6943 * If the packet fails, we will set it to the error status.
6944 */
6945 pseudoIrp.Tail.Overlay.DriverContext[0] = LongToPtr(1);
6948 pseudoIrp.MdlAddress = senseBufferMdl;
6949
6950 /*
6951 * Set this up as a SYNCHRONOUS transfer, submit it,
6952 * and wait for the packet to complete. The result
6953 * status will be written to the original irp.
6954 */
6957 SetupModeSelectTransferPacket(pkt, &event, ModeSelectBuffer, (UCHAR)Length, SavePages, &pseudoIrp);
6958 SubmitTransferPacket(pkt);
6960
6962 /*
6963 * This request can sometimes fail legitimately
6964 * (e.g. when a SCSI device is attached but turned off)
6965 * so this is not necessarily a device/driver bug.
6966 */
6967 TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL, "ClassModeSelect on Fdo %ph failed with status %xh.", Fdo, pseudoIrp.IoStatus.Status));
6968 }
6969
6971 }
6972
6973 FreeDeviceInputMdl(senseBufferMdl);
6974 } else {
6976 }
6977
6979}
VOID SetupModeSelectTransferPacket(TRANSFER_PACKET *Pkt, PKEVENT SyncEventPtr, PVOID ModeSelectBuffer, UCHAR ModeSelectBufferLen, BOOLEAN SavePages, PIRP OriginalIrp)
Definition: xferpkt.c:1425
Referenced by ClassModeSelect(), and ClasspZeroQERR().
◆ ClasspModeSense()
| ULONG ClasspModeSense | ( | _In_ PDEVICE_OBJECT | Fdo, |
| _In_reads_bytes_(Length) PCHAR | ModeSenseBuffer, | ||
| _In_ ULONG | Length, | ||
| _In_ UCHAR | PageMode, | ||
| _In_ UCHAR | PageControl | ||
| ) |
Definition at line 6681 of file class.c.
6716{
6717 ULONG lengthTransferred = 0;
6718 PMDL senseBufferMdl;
6719
6720 PAGED_CODE();
6721
6723 if (senseBufferMdl){
6724
6726 if (pkt){
6728 IRP pseudoIrp = {0};
6729
6730 /*
6731 * Store the number of packets servicing the irp (one)
6732 * inside the original IRP. It will be used to counted down
6733 * to zero when the packet completes.
6734 * Initialize the original IRP's status to success.
6735 * If the packet fails, we will set it to the error status.
6736 */
6737 pseudoIrp.Tail.Overlay.DriverContext[0] = LongToPtr(1);
6740 pseudoIrp.MdlAddress = senseBufferMdl;
6741
6742 /*
6743 * Set this up as a SYNCHRONOUS transfer, submit it,
6744 * and wait for the packet to complete. The result
6745 * status will be written to the original irp.
6746 */
6749 SetupModeSenseTransferPacket(pkt, &event, ModeSenseBuffer, (UCHAR)Length, PageMode, 0, &pseudoIrp, PageControl);
6750 SubmitTransferPacket(pkt);
6752
6755 }
6756 else {
6757 /*
6758 * This request can sometimes fail legitimately
6759 * (e.g. when a SCSI device is attached but turned off)
6760 * so this is not necessarily a device/driver bug.
6761 */
6762 TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL, "ClasspModeSense on Fdo %ph failed with status %xh.", Fdo, pseudoIrp.IoStatus.Status));
6763 }
6764 }
6765
6766 FreeDeviceInputMdl(senseBufferMdl);
6767 }
6768
6769 return lengthTransferred;
6770}
VOID SetupModeSenseTransferPacket(TRANSFER_PACKET *Pkt, PKEVENT SyncEventPtr, PVOID ModeSenseBuffer, UCHAR ModeSenseBufferLen, UCHAR PageMode, UCHAR SubPage, PIRP OriginalIrp, UCHAR PageControl)
Definition: xferpkt.c:1365
Referenced by ClassModeSense(), ClassModeSenseEx(), and ClasspWriteCacheProperty().
◆ ClasspMyStringMatches()
| BOOLEAN ClasspMyStringMatches | ( | _In_opt_z_ PCHAR | StringToMatch, |
| _In_z_ PCHAR | TargetString | ||
| ) |
Definition at line 51 of file utils.c.
52{
54 PAGED_CODE();
56 // if no match requested, return TRUE
59 }
60 // cache the string length for efficiency
62 // ZERO-length strings may only match zero-length strings
65 }
66 // strncmp returns zero if the strings match
68}
◆ ClassPnpQueryFdoRelations()
| NTSTATUS ClassPnpQueryFdoRelations | ( | IN PDEVICE_OBJECT | Fdo, |
| IN PIRP | Irp | ||
| ) |
Definition at line 9843 of file class.c.
9847{
9849#ifdef _MSC_VER
9850#pragma warning(suppress:4054) // okay to type cast function pointer as data pointer for this use case
9851#endif
9852 PCLASS_DRIVER_EXTENSION driverExtension = IoGetDriverObjectExtension(Fdo->DriverObject, CLASS_DRIVER_EXTENSION_KEY);
9853
9854 PAGED_CODE();
9855
9857
9858 //
9859 // If there's already an enumeration in progress then don't start another
9860 // one.
9861 //
9862
9865 }
9866
9868 Fdo,
9869 BusRelations,
9872
9874} // end ClassPnpQueryFdoRelations()
NTSTATUS ClassRetrieveDeviceRelations(IN PDEVICE_OBJECT Fdo, IN DEVICE_RELATION_TYPE RelationType, OUT PDEVICE_RELATIONS *DeviceRelations)
Definition: class.c:10005
PCLASS_ENUM_DEVICE ClassEnumerateDevice
Definition: classpnp.h:541
Definition: iotypes.h:2163
ULONG EnumerationInterlock
Definition: classpnp.h:921
Referenced by ClassDispatchPnp().
◆ ClassPnpStartDevice()
| NTSTATUS ClassPnpStartDevice | ( | IN PDEVICE_OBJECT | DeviceObject | ) |
Definition at line 1819 of file class.c.
1820{
1821 PCLASS_DRIVER_EXTENSION driverExtension;
1822 PCLASS_INIT_DATA initData;
1823
1824 PCLASS_DEV_INFO devInfo;
1825
1829
1832
1835
1836
1837 PAGED_CODE();
1838
1839#ifdef _MSC_VER
1840#pragma warning(suppress:4054) // okay to type cast function pointer as data pointer for this use case
1841#endif
1842 driverExtension = IoGetDriverObjectExtension(DeviceObject->DriverObject, CLASS_DRIVER_EXTENSION_KEY);
1843
1844 initData = &(driverExtension->InitData);
1845 if(isFdo) {
1846 devInfo = &(initData->FdoData);
1847 } else {
1848 devInfo = &(initData->PdoData);
1849 }
1850
1853
1855
1856 //
1857 // perform FDO/PDO specific initialization
1858 //
1859
1860 if (isFdo){
1861 STORAGE_PROPERTY_ID propertyId;
1862
1863 //
1864 // allocate a private extension for class data
1865 //
1866
1868 fdoExtension->PrivateFdoData = ExAllocatePoolWithTag(NonPagedPoolNx,
1871 );
1872 }
1873
1875 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP, "ClassPnpStartDevice: Cannot allocate for private fdo data\n"));
1877 }
1878
1880
1881
1882#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
1883 //
1884 // Allocate a structure to hold more data than what we can put in FUNCTIONAL_DEVICE_EXTENSION.
1885 // This structure's memory is managed by classpnp, so it is more extensible.
1886 //
1888 fdoExtension->AdditionalFdoData = ExAllocatePoolWithTag(NonPagedPoolNx,
1889 sizeof(ADDITIONAL_FDO_DATA),
1891 );
1892 }
1893
1895 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP, "ClassPnpStartDevice: Cannot allocate memory for the additional data structure.\n"));
1897 }
1898
1900#endif
1901
1904 FREE_POOL(fdoExtension->PrivateFdoData);
1905#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
1906 FREE_POOL(fdoExtension->AdditionalFdoData);
1907#endif
1908 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP, "ClassPnpStartDevice: Failed to initialize tick timer\n"));
1910 }
1911
1912 //
1913 // allocate LowerLayerSupport for class data
1914 //
1915
1917 fdoExtension->FunctionSupportInfo = (PCLASS_FUNCTION_SUPPORT_INFO)ExAllocatePoolWithTag(NonPagedPoolNx,
1919 '3BcS'
1920 );
1921 }
1922
1924 ClasspDeleteTimer(fdoExtension);
1925 FREE_POOL(fdoExtension->PrivateFdoData);
1926#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
1927 FREE_POOL(fdoExtension->AdditionalFdoData);
1928#endif
1929 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP, "ClassPnpStartDevice: Cannot allocate for FunctionSupportInfo\n"));
1931 }
1932
1933 //
1934 // initialize the struct's various fields.
1935 //
1937 KeInitializeSpinLock(&fdoExtension->FunctionSupportInfo->SyncLock);
1938
1939 //
1940 // intialize the CommandStatus to -1 indicates that no effort made yet to retrieve the info.
1941 // Possible values of CommandStatus (data type: NTSTATUS):
1942 // -1: It's not attempted yet to retrieve the information.
1943 // success: Command sent and succeeded, information cached in FdoExtension.
1944 // failed/warning: Command is either not supported or failed by device or lower level driver.
1945 // The command should not be attempted again.
1946 //
1947 fdoExtension->FunctionSupportInfo->BlockLimitsData.CommandStatus = -1;
1948 fdoExtension->FunctionSupportInfo->DeviceCharacteristicsData.CommandStatus = -1;
1949 fdoExtension->FunctionSupportInfo->LBProvisioningData.CommandStatus = -1;
1950 fdoExtension->FunctionSupportInfo->ReadCapacity16Data.CommandStatus = -1;
1951 fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.CommandStatus = -1;
1952
1953
1954 KeInitializeTimer(&fdoExtension->PrivateFdoData->Retry.Timer);
1955 KeInitializeDpc(&fdoExtension->PrivateFdoData->Retry.Dpc,
1956 ClasspRetryRequestDpc,
1957 DeviceObject);
1958 KeInitializeSpinLock(&fdoExtension->PrivateFdoData->Retry.Lock);
1959 fdoExtension->PrivateFdoData->Retry.Granularity = KeQueryTimeIncrement();
1961 InitializeListHead(&fdoExtension->PrivateFdoData->DeferredClientIrpList);
1962
1963 KeInitializeSpinLock(&fdoExtension->PrivateFdoData->SpinLock);
1964
1965 //
1966 // keep a pointer to the senseinfo2 stuff locally also (used in every read/write).
1967 //
1968 fdoExtension->PrivateFdoData->InterpretSenseInfo = driverExtension->InterpretSenseInfo;
1969
1970 fdoExtension->PrivateFdoData->MaxNumberOfIoRetries = NUM_IO_RETRIES;
1971
1972 //
1973 // Initialize release queue extended SRB
1974 //
1978 0);
1981 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP,
1984 }
1985
1986
1987 /*
1988 * Anchor the FDO in our static list.
1989 * Pnp is synchronized, so we shouldn't need any synchronization here.
1990 */
1992
1993 //
1994 // NOTE: the old interface allowed the class driver to allocate
1995 // this. this was unsafe for low-memory conditions. allocate one
1996 // unconditionally now, and modify our internal functions to use
1997 // our own exclusively as it is the only safe way to do this.
1998 //
1999
2002 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP, "ClassPnpStartDevice: Cannot allocate the private release queue irp\n"));
2004 }
2005
2008 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP, "ClassPnpStartDevice: Cannot allocate the power process irp\n"));
2010 }
2011
2012 //
2013 // Call port driver to get miniport properties for disk devices
2014 // It's ok for this call to fail
2015 //
2016
2019
2020 propertyId = StorageMiniportProperty;
2021
2023 &propertyId,
2024 (PVOID *)&fdoExtension->MiniportDescriptor);
2025
2026 //
2027 // function ClassGetDescriptor returns succeed with buffer "fdoExtension->MiniportDescriptor" allocated.
2028 //
2030 (fdoExtension->MiniportDescriptor->Portdriver != StoragePortCodeSetStorport &&
2031 fdoExtension->MiniportDescriptor->Portdriver != StoragePortCodeSetUSBport) ) {
2032 //
2033 // field "IoTimeoutValue" supported for either Storport or USBStor
2034 //
2035 fdoExtension->MiniportDescriptor->IoTimeoutValue = 0;
2036 }
2037
2038
2039
2040 }
2041
2042 //
2043 // Call port driver to get adapter capabilities.
2044 //
2045
2046 propertyId = StorageAdapterProperty;
2047
2048 status = ClassGetDescriptor(
2049 commonExtension->LowerDeviceObject,
2050 &propertyId,
2053 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP, "ClassPnpStartDevice: ClassGetDescriptor [ADAPTER] failed %lx\n", status));
2055 }
2056
2057 //
2058 // Call port driver to get device descriptor.
2059 //
2060
2061 propertyId = StorageDeviceProperty;
2062
2063 status = ClassGetDescriptor(
2064 commonExtension->LowerDeviceObject,
2065 &propertyId,
2068
2069 ClasspScanForSpecialInRegistry(fdoExtension);
2071
2072 //
2073 // allow perf to be re-enabled after a given number of failed IOs
2074 // require this number to be at least CLASS_PERF_RESTORE_MINIMUM
2075 //
2076
2077 {
2079
2080 ClassGetDeviceParameter(fdoExtension,
2081 CLASSP_REG_SUBKEY_NAME,
2083 &t);
2085 fdoExtension->PrivateFdoData->Perf.ReEnableThreshhold = t;
2086 }
2087 }
2088
2089 //
2090 // compatibility comes first. writable cd media will not
2091 // get a SYNCH_CACHE on power down.
2092 //
2095 }
2096
2097
2098 //
2099 // Test if the device is portable and updated the characteristics if so
2100 //
2102 &isPortable);
2103
2106 }
2107
2108 //
2109 // initialize the hotplug information only after the ScanForSpecial
2110 // routines, as it relies upon the hack flags.
2111 //
2114 /*
2115 * Allocate/initialize TRANSFER_PACKETs and related resources.
2116 */
2118 }
2119 else {
2120 TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_PNP, "ClassPnpStartDevice: Could not initialize hotplug information %lx\n", status));
2121 }
2122 }
2123 else {
2124 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP, "ClassPnpStartDevice: ClassGetDescriptor [DEVICE] failed %lx\n", status));
2126 }
2127
2128
2130
2131 //
2132 // Retrieve info on whether async notification is supported by port drivers
2133 //
2134 propertyId = StorageDevicePowerProperty;
2135
2137 &propertyId,
2138 (PVOID *)&powerDescriptor);
2140 fdoExtension->FunctionSupportInfo->AsynchronousNotificationSupported = powerDescriptor->AsynchronousNotificationSupported;
2141 fdoExtension->FunctionSupportInfo->IdlePower.D3ColdSupported = powerDescriptor->D3ColdSupported;
2142 fdoExtension->FunctionSupportInfo->IdlePower.NoVerifyDuringIdlePower = powerDescriptor->NoVerifyDuringIdlePower;
2143 FREE_POOL(powerDescriptor);
2144 } else {
2145 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP, "ClassPnpStartDevice: ClassGetDescriptor [DevicePower] failed %lx\n", status));
2146
2147 //
2148 // Ignore error as device power property is optional
2149 //
2151 }
2152 }
2153 }
2154
2155 //
2156 // ISSUE - drivers need to disable write caching on the media
2157 // if hotplug and !useroverride. perhaps we should
2158 // allow registration of a callback to enable/disable
2159 // write cache instead.
2160 //
2161
2164 }
2165
2167 fdoExtension->PrivateFdoData->Perf.OriginalSrbFlags = fdoExtension->SrbFlags;
2168
2169 //
2170 // initialization for disk device
2171 //
2174
2175 ULONG accessAlignmentNotSupported = 0;
2178
2179 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,
2181 // Initialize idle timer for disk devices
2182 ClasspInitializeIdleTimer(fdoExtension);
2183
2185 // get INQUIRY VPD support information. It's safe to send command as everything is ready in ClassInitDevice().
2186 ClasspGetInquiryVpdSupportInfo(fdoExtension);
2187
2188 // Query and cache away Logical Block Provisioning info in the FDO extension.
2189 // The cached information will be used in responding to some IOCTLs
2190 ClasspGetLBProvisioningInfo(fdoExtension);
2191
2192 //
2193 // Query and cache away Block Device ROD Limits info in the FDO extension.
2194 //
2195 if (fdoExtension->FunctionSupportInfo->ValidInquiryPages.BlockDeviceRODLimits) {
2196 ClassDetermineTokenOperationCommandSupport(DeviceObject);
2197 }
2198
2199 //
2200 // See if the user has specified a particular QERR override
2201 // mode. "Override" meaning setting QERR = 0 via Mode Select.
2202 // 0 = Only when ODX or Thin Provisioning are supported (default)
2203 // 1 = Always
2204 // 2 = Never (or any value >= 2)
2205 //
2206 ClassGetDeviceParameter(fdoExtension,
2207 CLASSP_REG_SUBKEY_NAME,
2209 &qerrOverrideMode);
2210
2211 //
2212 // If this device is thinly provisioned or supports ODX, we
2213 // may need to force QERR to zero. The user may have also
2214 // specified that we should always or never do this.
2215 //
2217 (qerrOverrideMode == QERR_SET_ZERO_ODX_OR_TP_ONLY &&
2218 (ClasspIsThinProvisioned(fdoExtension->FunctionSupportInfo) ||
2220
2222 }
2223
2224 } else {
2225
2226 //
2227 // Since this device has been exposed by a legacy miniport (e.g. SCSIPort miniport)
2228 // set its LB Provisioning command status to an error status that will be surfaced
2229 // up to the caller of a TRIM/Unmap command.
2230 //
2231 fdoExtension->FunctionSupportInfo->LBProvisioningData.CommandStatus = STATUS_UNSUCCESSFUL;
2232 fdoExtension->FunctionSupportInfo->BlockLimitsData.CommandStatus = STATUS_UNSUCCESSFUL;
2233 fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.CommandStatus = STATUS_UNSUCCESSFUL;
2234 }
2235
2236 // Get registry setting of failing the IOCTL for AccessAlignment Property.
2237 ClassGetDeviceParameter(fdoExtension,
2238 CLASSP_REG_SUBKEY_NAME,
2240 &accessAlignmentNotSupported);
2241
2242 if (accessAlignmentNotSupported > 0) {
2243 fdoExtension->FunctionSupportInfo->RegAccessAlignmentQueryNotSupported = TRUE;
2244 }
2245
2246#if (NTDDI_VERSION >= NTDDI_WINBLUE)
2247
2248
2249 //
2250 // See if the user has specified legacy error handling.
2251 //
2252 ClassGetDeviceParameter(fdoExtension,
2253 CLASSP_REG_SUBKEY_NAME,
2255 &legacyErrorHandling);
2256
2257 if (legacyErrorHandling) {
2258 //
2259 // Legacy error handling means that the maximum number of
2260 // retries allowd for an IO request is 8 instead of 4.
2261 //
2262 fdoExtension->PrivateFdoData->MaxNumberOfIoRetries = LEGACY_NUM_IO_RETRIES;
2263 fdoExtension->PrivateFdoData->LegacyErrorHandling = TRUE;
2264 }
2265#else
2266 UNREFERENCED_PARAMETER(legacyErrorHandling);
2267#endif
2268
2269
2270 //
2271 // Get the copy offload max target duration value.
2272 // This function will set the default value if one hasn't been
2273 // specified in the registry.
2274 //
2275 ClasspGetCopyOffloadMaxDuration(DeviceObject,
2276 REG_DISK_CLASS_CONTROL,
2277 &(fdoExtension->PrivateFdoData->CopyOffloadMaxTargetDuration));
2278
2279 }
2280
2281 }
2282 }
2283
2285
2286 //
2287 // Just bail out - the remove that comes down will clean up the
2288 // initialized scraps.
2289 //
2290
2292 } else {
2294 }
2295
2296 //
2297 // If device requests autorun functionality or a once a second callback
2298 // then enable the once per second timer. Exception is if media change
2299 // detection is desired but device supports async notification.
2300 //
2301 // NOTE: This assumes that ClassInitializeMediaChangeDetection is always
2302 // called in the context of the ClassInitDevice callback. If called
2303 // after then this check will have already been made and the
2304 // once a second timer will not have been enabled.
2305 //
2306 if ((isFdo) &&
2309 (fdoExtension->FunctionSupportInfo != NULL) &&
2310 (fdoExtension->FunctionSupportInfo->AsynchronousNotificationSupported == FALSE)) ||
2313 {
2314 ClasspEnableTimer(fdoExtension);
2315
2316 //
2317 // In addition, we may change our polling behavior when the screen is
2318 // off so register for screen state notification if we haven't already
2319 // done so.
2320 //
2323 &GUID_CONSOLE_DISPLAY_STATE,
2324 &ClasspPowerSettingCallback,
2325 NULL,
2326 &ScreenStateNotificationHandle);
2327 }
2328 }
2329
2330 //
2331 // NOTE: the timer looks at commonExtension->CurrentState now
2332 // to prevent Media Change Notification code from running
2333 // until the device is started, but allows the device
2334 // specific tick handler to run. therefore it is imperative
2335 // that commonExtension->CurrentState not be updated until
2336 // the device specific startdevice handler has finished.
2337 //
2338
2340
2343
2345 isMountedDevice = FALSE;
2346 }
2347
2349
2350 isMountedDevice = FALSE;
2351 }
2352
2353 //
2354 // Register for mounted device interface if this is a
2355 // sfloppy device.
2356 //
2359
2360 isMountedDevice = TRUE;
2361 }
2362
2363 if(isMountedDevice) {
2365 }
2366
2369
2370 //
2371 // Tell Storport (Usbstor or SD) to enable idle power management for this
2372 // device, assuming the user hasn't turned it off in the registry.
2373 //
2375 fdoExtension->FunctionSupportInfo->IdlePower.IdlePowerEnabled == FALSE &&
2376 fdoExtension->MiniportDescriptor != NULL &&
2377 (fdoExtension->MiniportDescriptor->Portdriver == StoragePortCodeSetStorport ||
2378 fdoExtension->MiniportDescriptor->Portdriver == StoragePortCodeSetSDport ||
2379 fdoExtension->MiniportDescriptor->Portdriver == StoragePortCodeSetUSBport)) {
2380 ULONG disableIdlePower= 0;
2381 ClassGetDeviceParameter(fdoExtension,
2382 CLASSP_REG_SUBKEY_NAME,
2384 &disableIdlePower);
2385
2386 if (!disableIdlePower) {
2388 }
2389 }
2390 }
2391 }
2392 else {
2393 ClasspDisableTimer(fdoExtension);
2394 }
2395
2396
2398}
#define CLASSP_REG_PERF_RESTORE_VALUE_NAME
Definition: cdromp.h:125
#define CLASSP_REG_ACCESS_ALIGNMENT_NOT_SUPPORTED
Definition: classp.h:122
VOID ClasspInitializeIdleTimer(PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
Definition: clntirp.c:175
NTSTATUS InitializeTransferPackets(PDEVICE_OBJECT Fdo)
Definition: xferpkt.c:45
_IRQL_requires_same_ NTSTATUS ClasspEnableIdlePower(_In_ PDEVICE_OBJECT DeviceObject)
Definition: power.c:2550
#define CLASSP_REG_DISBALE_IDLE_POWER_NAME
Definition: classp.h:123
VOID ClasspEnableTimer(_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
Definition: autorun.c:3857
VOID ClasspDeleteTimer(_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
Definition: autorun.c:3798
VOID ClasspDisableTimer(_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
Definition: autorun.c:3956
struct _CLASS_FUNCTION_SUPPORT_INFO * PCLASS_FUNCTION_SUPPORT_INFO
VOID NTAPI ClasspScanForClassHacks(IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN ULONG_PTR Data)
Definition: class.c:12634
VOID ClasspGetInquiryVpdSupportInfo(_Inout_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
Definition: class.c:12914
VOID ClasspScanForSpecialInRegistry(IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
Definition: class.c:12651
NTSTATUS ClasspAllocateReleaseQueueIrp(PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
Definition: class.c:11621
NTSTATUS ClasspGetLBProvisioningInfo(_Inout_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
Definition: class.c:13087
NTSTATUS ClasspIsPortable(_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _Out_ PBOOLEAN IsPortable)
Definition: class.c:8837
VOID ClasspRegisterMountedDeviceInterface(IN PDEVICE_OBJECT DeviceObject)
Definition: class.c:10970
NTSTATUS ClasspAllocatePowerProcessIrp(PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
Definition: class.c:11683
NTSTATUS ClasspInitializeHotplugInfo(IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
Definition: class.c:12507
NTSTATUS NTAPI IoWMIRegistrationControl(IN PDEVICE_OBJECT DeviceObject, IN ULONG Action)
Definition: wmi.c:68
enum _STORAGE_PROPERTY_ID STORAGE_PROPERTY_ID
Definition: classpnp.h:517
PCLASS_INTERPRET_SENSE_INFO2 InterpretSenseInfo
Definition: classpnp.h:587
Definition: classpnp.h:813
Definition: classpnp.h:536
Definition: ntddstor.h:663
BOOLEAN NoVerifyDuringIdlePower
Definition: ntddstor.h:671
BOOLEAN AsynchronousNotificationSupported
Definition: ntddstor.h:667
struct _FAILURE_PREDICTION_INFO * FailurePredictionInfo
Definition: classpnp.h:919
PMEDIA_CHANGE_DETECTION_INFO MediaChangeDetectionInfo
Definition: classpnp.h:905
#define IRP_MN_START_DEVICE
#define WMIREG_ACTION_REGISTER
Referenced by ClassDispatchPnp().
◆ ClasspPagingNotificationCompletion()
| NTSTATUS ClasspPagingNotificationCompletion | ( | IN PDEVICE_OBJECT | DeviceObject, |
| IN PIRP | Irp, | ||
| IN PDEVICE_OBJECT | RealDeviceObject | ||
| ) |
◆ ClasspPerfIncrementErrorCount()
| VOID ClasspPerfIncrementErrorCount | ( | IN PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension | ) |
Definition at line 432 of file utils.c.
435{
437 KIRQL oldIrql;
438 ULONG errors;
439
441
444
446
448
449 //
450 // If the error count has exceeded the error limit, then disable
451 // any tagged queuing, multiple requests per lu queueing
452 // and sychronous data transfers.
453 //
454 // Clearing the no queue freeze flag prevents the port driver
455 // from sending multiple requests per logical unit.
456 //
457
460
462
464 "Too many errors; disabling tagged queuing and "
465 "synchronous data tranfers.\n"));
466
467 }
468
470
471 //
472 // If a second threshold is reached, disable disconnects.
473 //
474
477 "Too many errors; disabling disconnects.\n"));
478 }
479 }
480
482 return;
483}
struct _CLASS_PRIVATE_FDO_DATA::@1263 Perf
Referenced by ClassInterpretSenseInfo().
◆ ClasspPerfIncrementSuccessfulIo()
| VOID ClasspPerfIncrementSuccessfulIo | ( | IN PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension | ) |
Definition at line 486 of file utils.c.
489{
491 KIRQL oldIrql;
492 ULONG errors;
493 ULONG succeeded = 0;
494
495 //
496 // don't take a hit from the interlocked op unless we're in
497 // a degraded state and we've got a threshold to hit.
498 //
499
501 return;
502 }
503
505 return;
506 }
507
509 if (succeeded < fdoData->Perf.ReEnableThreshhold) {
510 return;
511 }
512
513 //
514 // if we hit the threshold, grab the spinlock and verify we've
515 // actually done so. this allows us to ignore the spinlock 99%
516 // of the time.
517 //
518
520
521 //
522 // re-read the value, so we don't run this multiple times
523 // for a single threshhold being hit. this keeps errorcount
524 // somewhat useful.
525 //
526
527 succeeded = fdoData->Perf.SuccessfulIO;
528
530 (fdoData->Perf.ReEnableThreshhold <= succeeded)
531 ) {
532
534
537
538 //
539 // note: do in reverse order of the sets "just in case"
540 //
541
545 "Error level 2 no longer required.\n"));
546 }
548 SRB_FLAGS_DISABLE_DISCONNECT)) {
551 }
552 }
553
557 "Error level 1 no longer required.\n"));
558 }
560 SRB_FLAGS_DISABLE_SYNCH_TRANSFER)) {
563 }
565 SRB_FLAGS_QUEUE_ACTION_ENABLE)) {
568 }
570 SRB_FLAGS_NO_QUEUE_FREEZE)) {
573 }
574 }
575 } // end of threshhold definitely being hit for first time
576
578 return;
579}
Referenced by ClassIoComplete(), and TransferPktComplete().
◆ ClasspPersistentReserve()
| NTSTATUS ClasspPersistentReserve | ( | _In_ PDEVICE_OBJECT | DeviceObject, |
| _In_ PIRP | Irp, | ||
| _Inout_ PSCSI_REQUEST_BLOCK | Srb | ||
| ) |
Definition at line 6211 of file utils.c.
6216{
6221
6223
6224 ULONG dataBufLen;
6226
6227 BOOLEAN writeToDevice;
6228
6229 //
6230 // Check common input buffer parameters.
6231 //
6232
6236
6239 Irp->IoStatus.Information = 0;
6240
6242
6245 goto ClasspPersistentReserve_Exit;
6246 }
6247
6248 //
6249 // Check buffer alignment. Only an issue if another kernel mode component
6250 // (not the I/O manager) allocates the buffer.
6251 //
6252
6254
6257 Irp->IoStatus.Information = 0;
6258
6260
6263 goto ClasspPersistentReserve_Exit;
6264 }
6265
6266 //
6267 // Check additional parameters.
6268 //
6269
6271
6274
6276
6277 //
6278 // Check output buffer for PR In.
6279 //
6280
6282 prCommand->PR_IN.AllocationLength) {
6283
6285 }
6286
6287 switch (prCommand->PR_IN.ServiceAction) {
6288
6290
6292
6294 }
6295
6296 break;
6297
6299
6301
6303 }
6304
6305 break;
6306
6307 default:
6308
6310 break;
6311 }
6312
6314
6316 Irp->IoStatus.Information = 0;
6317
6319
6322 goto ClasspPersistentReserve_Exit;
6323 }
6324
6325 //
6326 // Fill in the CDB.
6327 //
6328
6330 cdb->PERSISTENT_RESERVE_IN.ServiceAction = prCommand->PR_IN.ServiceAction;
6331
6333 &(prCommand->PR_IN.AllocationLength));
6334
6336 writeToDevice = FALSE;
6337
6338
6339 } else {
6340
6341 //
6342 // Verify ServiceAction, Scope, and Type
6343 //
6344
6345 switch (prCommand->PR_OUT.ServiceAction) {
6346
6350
6351 // Scope and type ignored.
6352
6353 break;
6354
6359
6361 !ValidPersistentReserveType(prCommand->PR_OUT.Type)) {
6362
6364
6365 }
6366
6367 break;
6368
6369 default:
6370
6372
6373 break;
6374 }
6375
6376 //
6377 // Check input buffer for PR Out.
6378 // Caller must include the PR parameter list.
6379 //
6380
6382
6386 prCommand->Size <
6388
6390
6391 }
6392 }
6393
6394
6396
6398 Irp->IoStatus.Information = 0;
6399
6401
6404 goto ClasspPersistentReserve_Exit;
6405 }
6406
6407 //
6408 // Fill in the CDB.
6409 //
6410
6412 cdb->PERSISTENT_RESERVE_OUT.ServiceAction = prCommand->PR_OUT.ServiceAction;
6413 cdb->PERSISTENT_RESERVE_OUT.Scope = prCommand->PR_OUT.Scope;
6414 cdb->PERSISTENT_RESERVE_OUT.Type = prCommand->PR_OUT.Type;
6415
6417
6418 //
6419 // Move the parameter list to the beginning of the data buffer (so it is aligned
6420 // correctly and that the MDL describes it correctly).
6421 //
6422
6423 RtlMoveMemory(prCommand,
6424 prCommand->PR_OUT.ParameterList,
6426
6428 writeToDevice = TRUE;
6429 }
6430
6431 //
6432 // Fill in the SRB
6433 //
6434
6435 //
6436 // Set timeout value.
6437 //
6438
6440
6441 //
6442 // Send as a tagged request.
6443 //
6444
6447
6449 Srb,
6450 Irp,
6451 prCommand,
6452 dataBufLen,
6453 writeToDevice);
6454
6455ClasspPersistentReserve_Exit:
6456
6458
6459}
static BOOLEAN ValidPersistentReserveScope(UCHAR Scope)
Definition: utils.c:6152
static BOOLEAN ValidPersistentReserveType(UCHAR Type)
Definition: utils.c:6171
#define IOCTL_STORAGE_PERSISTENT_RESERVE_IN
Definition: ntddstor.h:169
#define RESERVATION_ACTION_REGISTER_IGNORE_EXISTING
Definition: scsi.h:585
struct _PRO_PARAMETER_LIST PRO_PARAMETER_LIST
#define RESERVATION_ACTION_READ_RESERVATIONS
Definition: scsi.h:577
Definition: ntddstor.h:830
Definition: scsi.h:2682
Definition: scsi.h:2697
Definition: scsi.h:2703
struct _CDB::_PERSISTENT_RESERVE_OUT PERSISTENT_RESERVE_OUT
struct _CDB::_PERSISTENT_RESERVE_IN PERSISTENT_RESERVE_IN
Referenced by ClassDeviceControl().
◆ ClasspPopulateTokenTransferPacketDone()
Definition at line 14166 of file class.c.
14191{
14192 PDEVICE_OBJECT fdo;
14193 ULONG listIdentifier;
14194 POFFLOAD_READ_CONTEXT offloadReadContext;
14195 PTRANSFER_PACKET pkt;
14196 PIRP pseudoIrp;
14198
14199 offloadReadContext = Context;
14200 pseudoIrp = &offloadReadContext->PseudoIrp;
14201 pkt = offloadReadContext->Pkt;
14202 fdo = offloadReadContext->Fdo;
14203 listIdentifier = offloadReadContext->ListIdentifier;
14204
14206
14207
14210
14212 TracePrint((TRACE_LEVEL_ERROR,
14213 TRACE_FLAG_IOCTL,
14214 "ClasspPopulateTokenTransferPacketDone (%p): Generate token for list Id %x failed with %x (Pkt %p).\n",
14215 fdo,
14216 listIdentifier,
14217 status,
14218 pkt));
14219 goto __ClasspPopulateTokenTransferPacketDone_ErrorExit;
14220 }
14221
14222 //
14223 // If a token was successfully generated, it is now time to retrieve the token.
14224 // The called function is responsible for completing the offload read DSM IRP.
14225 //
14226 ClasspReceivePopulateTokenInformation(offloadReadContext);
14227
14228 //
14229 // ClasspReceivePopulateTokenInformation() takes care of completing the IRP,
14230 // so this function is done regardless of success or failure in
14231 // ClasspReceivePopulateTokenInformation().
14232 //
14233
14234 return;
14235
14236 //
14237 // Error cleanup label only - not used in success case:
14238 //
14239
14240__ClasspPopulateTokenTransferPacketDone_ErrorExit:
14241
14243
14244 //
14245 // ClasspCompleteOffloadRead also cleans up offloadReadContext.
14246 //
14247
14249
14250 return;
14251}
VOID ClasspCompleteOffloadRead(_In_ POFFLOAD_READ_CONTEXT OffloadReadContext, _In_ NTSTATUS CompletionStatus)
Definition: class.c:14255
_IRQL_requires_same_ VOID ClasspReceivePopulateTokenInformation(_In_ POFFLOAD_READ_CONTEXT OffloadReadContext)
Definition: class.c:14374
Definition: classp.h:1038
Referenced by _IRQL_requires_max_().
◆ ClasspPriorityHint()
| NTSTATUS ClasspPriorityHint | ( | PDEVICE_OBJECT | DeviceObject, |
| PIRP | Irp | ||
| ) |
Definition at line 6480 of file utils.c.
6484{
6487 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
6491
6492 Irp->IoStatus.Information = 0;
6493
6494 //
6495 // Check whether this device supports idle priority.
6496 //
6499 goto PriorityHintExit;
6500 }
6501
6504
6506 goto PriorityHintExit;
6507 }
6508
6510
6513 //
6514 // If I/O priority is not supported by lower drivers, just set the
6515 // priorities supported by class driver.
6516 //
6517 TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_IOCTL, "ClasspPriorityHint: I/O priority not supported by port driver.\n"));
6518 priSupport->SupportFlags = 0;
6520 }
6521
6522 TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_IOCTL, "ClasspPriorityHint: I/O priorities supported by port driver: %X\n", priSupport->SupportFlags));
6523
6525 (1 << IoPriorityLow) |
6526 (1 << IoPriorityNormal) ;
6527
6528 TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_IOCTL, "ClasspPriorityHint: I/O priorities supported: %X\n", priSupport->SupportFlags));
6530
6531PriorityHintExit:
6532
6537}
struct _STORAGE_PRIORITY_HINT_SUPPORT STORAGE_PRIORITY_HINT_SUPPORT
Definition: ntddstor.h:813
Referenced by ClassDeviceControl().
◆ ClasspQueueLogIOEventWithContextWorker()
| VOID ClasspQueueLogIOEventWithContextWorker | ( | _In_ PDEVICE_OBJECT | DeviceObject, |
| _In_ ULONG | SenseBufferSize, | ||
| _In_ PVOID | SenseData, | ||
| _In_ UCHAR | SrbStatus, | ||
| _In_ UCHAR | ScsiStatus, | ||
| _In_ ULONG | ErrorCode, | ||
| _In_ ULONG | CdbLength, | ||
| _In_opt_ PCDB | Cdb, | ||
| _In_opt_ PTRANSFER_PACKET | Pkt | ||
| ) |
Definition at line 6010 of file utils.c.
6041{
6042 PCOMMON_DEVICE_EXTENSION commonExtension = (PCOMMON_DEVICE_EXTENSION)(DeviceObject->DeviceExtension);
6043 PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
6047 ULONG senseBufferSize = 0;
6049
6051 return;
6052 }
6053
6055 return;
6056 }
6057
6059 if (!workItem) {
6060 goto __ClasspQueueLogIOEventWithContextWorker_ExitWithMessage;
6061 }
6062
6063 if (SenseBufferSize) {
6064 senseData = ExAllocatePoolWithTag(NonPagedPoolNx, SenseBufferSize, CLASSPNP_POOL_TAG_LOG_MESSAGE);
6065 if (senseData) {
6066 senseBufferSize = SenseBufferSize;
6067 }
6068 }
6069
6070 if (CdbLength == 16) {
6072 } else {
6077 }
6078
6079 //
6080 // Calculate the amount of buffer required for the insertion strings.
6081 //
6085
6087
6088 ioLogMessageContext = ExAllocatePoolWithTag(NonPagedPoolNx, sizeof(IO_RETRIED_LOG_MESSAGE_CONTEXT), CLASSPNP_POOL_TAG_LOG_MESSAGE);
6089 if (!ioLogMessageContext) {
6090 goto __ClasspQueueLogIOEventWithContextWorker_ExitWithMessage;
6091 }
6092
6094 ioLogMessageContext->DeviceNumber = fdoExtension->DeviceNumber;
6095
6096 ioLogMessageContextHeader = (POPCODE_SENSE_DATA_IO_LOG_MESSAGE_CONTEXT_HEADER)ioLogMessageContext;
6097
6098 break;
6099 }
6100
6101 default: goto __ClasspQueueLogIOEventWithContextWorker_Exit;
6102 }
6103
6104 TracePrint((TRACE_LEVEL_INFORMATION,
6105 TRACE_FLAG_GENERAL,
6106 "ClasspQueueLogIOEventWithContextWorker: DO (%p), Pkt (%p), Queueing IO retried event log message work item.\n",
6107 DeviceObject,
6108 Pkt));
6109
6110 ioLogMessageContextHeader->WorkItem = workItem;
6111 if (senseData) {
6112 RtlCopyMemory(senseData, SenseData, SenseBufferSize);
6113 }
6114 ioLogMessageContextHeader->SenseData = senseData;
6115 ioLogMessageContextHeader->SenseDataSize = senseBufferSize;
6116 ioLogMessageContextHeader->SrbStatus = SrbStatus;
6117 ioLogMessageContextHeader->ScsiStatus = ScsiStatus;
6119 ioLogMessageContextHeader->Reserved = 0;
6120 ioLogMessageContextHeader->ErrorCode = ErrorCode;
6121
6123
6124 //
6125 // Queue a work item to write the system event log.
6126 //
6127 IoQueueWorkItem(workItem, ClasspLogIOEventWithContext, DelayedWorkQueue, ioLogMessageContextHeader);
6128
6129 return;
6130
6131__ClasspQueueLogIOEventWithContextWorker_ExitWithMessage:
6132
6133 TracePrint((TRACE_LEVEL_ERROR,
6134 TRACE_FLAG_GENERAL,
6135 "ClasspQueueLogIOEventWithContextWorker: DO (%p), Failed to allocate memory for the log message.\n",
6136 DeviceObject));
6137
6138__ClasspQueueLogIOEventWithContextWorker_Exit:
6139 if (senseData) {
6140 ExFreePool(senseData);
6141 }
6142 if (workItem) {
6143 IoFreeWorkItem(workItem);
6144 }
6145 if (ioLogMessageContextHeader) {
6146 ExFreePool(ioLogMessageContextHeader);
6147 }
6148}
struct _OPCODE_SENSE_DATA_IO_LOG_MESSAGE_CONTEXT_HEADER * POPCODE_SENSE_DATA_IO_LOG_MESSAGE_CONTEXT_HEADER
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
Definition: classp.h:1178
Definition: io.h:310
#define lba
struct _CDB::_CDB6GENERIC CDB6GENERIC
struct _CDB::_CDB16 CDB16
Referenced by ClassInterpretSenseInfo().
◆ ClasspReceivePopulateTokenInformation()
| _IRQL_requires_same_ VOID ClasspReceivePopulateTokenInformation | ( | _In_ POFFLOAD_READ_CONTEXT | OffloadReadContext | ) |
Definition at line 14374 of file class.c.
14403{
14406 ULONG cdbLength;
14407 PDEVICE_OBJECT fdo;
14409 ULONG listIdentifier;
14410 PTRANSFER_PACKET pkt;
14411 PIRP pseudoIrp;
14412 ULONG receiveTokenInformationBufferLength;
14413 PSCSI_REQUEST_BLOCK srb;
14415 ULONG tempSizeUlong;
14416 PULONGLONG totalSectorsProcessed;
14417
14418 totalSectorsProcessed = &OffloadReadContext->TotalSectorsProcessed;
14419 buffer = OffloadReadContext + 1;
14420 bufferLength = OffloadReadContext->BufferLength;
14421 fdo = OffloadReadContext->Fdo;
14422 irp = OffloadReadContext->OffloadReadDsmIrp;
14423 receiveTokenInformationBufferLength = OffloadReadContext->ReceiveTokenInformationBufferLength;
14424 listIdentifier = OffloadReadContext->ListIdentifier;
14425
14426 TracePrint((TRACE_LEVEL_VERBOSE,
14427 TRACE_FLAG_IOCTL,
14428 "ClasspReceivePopulateTokenInformation (%p): Entering function. Irp %p\n",
14429 fdo,
14430 irp));
14431
14432 srb = &OffloadReadContext->Srb;
14433 *totalSectorsProcessed = 0;
14434
14436 if (!pkt){
14437
14438 TracePrint((TRACE_LEVEL_ERROR,
14439 TRACE_FLAG_IOCTL,
14440 "ClasspReceivePopulateTokenInformation (%p): Failed to retrieve transfer packet for ReceiveTokenInformation (PopulateToken) operation.\n",
14441 fdo));
14442
14444 goto __ClasspReceivePopulateTokenInformation_ErrorExit;
14445 }
14446
14447 OffloadReadContext->Pkt = pkt;
14448
14450
14451 tempSizeUlong = receiveTokenInformationBufferLength - 4;
14453
14454 pseudoIrp = &OffloadReadContext->PseudoIrp;
14456
14457
14460 pseudoIrp->Tail.Overlay.DriverContext[0] = LongToPtr(1);
14461 pseudoIrp->MdlAddress = OffloadReadContext->PopulateTokenMdl;
14462
14463 ClasspSetupReceivePopulateTokenInformationTransferPacket(
14464 OffloadReadContext,
14465 pkt,
14466 receiveTokenInformationBufferLength,
14468 pseudoIrp,
14469 listIdentifier);
14470
14471 //
14472 // Cache away the CDB as it may be required for forwarded sense data
14473 // after this command completes.
14474 //
14477 if (cdbLength <= 16) {
14479 }
14480
14481 SubmitTransferPacket(pkt);
14482
14483 return;
14484
14485 //
14486 // Error cleanup label only - not used in success case:
14487 //
14488
14489__ClasspReceivePopulateTokenInformation_ErrorExit:
14490
14492
14493 //
14494 // ClasspCompleteOffloadRead also cleans up offloadReadContext.
14495 //
14496
14498
14499 return;
14500}
Referenced by ClasspPopulateTokenTransferPacketDone().
◆ ClasspReceivePopulateTokenInformationTransferPacketDone()
Definition at line 14504 of file class.c.
14529{
14530 ULONG availableData;
14532 UCHAR completionStatus;
14533 ULONG estimatedRetryInterval;
14534 PDEVICE_OBJECT fdo;
14535 PFUNCTIONAL_DEVICE_EXTENSION fdoExt;
14537 ULONG listIdentifier;
14538 POFFLOAD_READ_CONTEXT offloadReadContext;
14539 BOOLEAN operationCompleted;
14540 UCHAR operationStatus;
14541 PIRP pseudoIrp;
14542 USHORT segmentsProcessed;
14543 PSENSE_DATA senseData;
14544 ULONG senseDataFieldLength;
14545 UCHAR senseDataLength;
14546 PSCSI_REQUEST_BLOCK srb;
14549 PVOID tokenAscii;
14550 PBLOCK_DEVICE_TOKEN_DESCRIPTOR tokenDescriptor;
14551 ULONG tokenDescriptorLength;
14552 PRECEIVE_TOKEN_INFORMATION_HEADER tokenInformationResults;
14553 PRECEIVE_TOKEN_INFORMATION_RESPONSE_HEADER tokenInformationResultsResponse;
14554 ULONG tokenLength;
14555 ULONG tokenSize;
14556 PULONGLONG totalSectorsProcessed;
14557 ULONGLONG totalSectorsToProcess;
14558 ULONGLONG transferBlockCount;
14559
14560 offloadReadContext = Context;
14561 fdo = offloadReadContext->Fdo;
14562 fdoExt = fdo->DeviceExtension;
14563 buffer = offloadReadContext + 1;
14564 listIdentifier = offloadReadContext->ListIdentifier;
14566 totalSectorsToProcess = offloadReadContext->TotalSectorsToProcess;
14567 totalSectorsProcessed = &offloadReadContext->TotalSectorsProcessed;
14568 srb = &offloadReadContext->Srb;
14569 tokenAscii = NULL;
14570 tokenSize = BLOCK_DEVICE_TOKEN_SIZE;
14572 senseData = (PSENSE_DATA)((PUCHAR)tokenInformationResults + FIELD_OFFSET(RECEIVE_TOKEN_INFORMATION_HEADER, SenseData));
14573 transferBlockCount = 0;
14574 tokenInformationResultsResponse = NULL;
14575 tokenDescriptor = NULL;
14576 operationCompleted = FALSE;
14577 tokenDescriptorLength = 0;
14578 tokenLength = 0;
14580 pseudoIrp = &offloadReadContext->PseudoIrp;
14581
14584
14585 //
14586 // The buffer we hand allows for the max sizes for all the fields whereas the returned
14587 // data may be lesser (e.g. sense data info will almost never be MAX_SENSE_BUFFER_SIZE, etc.
14588 // so handle underrun "error"
14589 //
14591
14593 }
14594
14596 TracePrint((TRACE_LEVEL_ERROR,
14597 TRACE_FLAG_IOCTL,
14598 "ClasspReceivePopulateTokenInformationTransferPacketDone (%p): Token retrieval failed for list Id %x with %x.\n",
14599 fdo,
14600 listIdentifier,
14601 status));
14602 goto __ClasspReceivePopulateTokenInformationTransferPacketDone_Exit;
14603 }
14604
14606
14607 NT_ASSERT(availableData <= FIELD_OFFSET(RECEIVE_TOKEN_INFORMATION_HEADER, SenseData) + MAX_SENSE_BUFFER_SIZE +
14608 FIELD_OFFSET(RECEIVE_TOKEN_INFORMATION_RESPONSE_HEADER, TokenDescriptor) + BLOCK_DEVICE_TOKEN_SIZE);
14609
14611
14612 operationStatus = tokenInformationResults->OperationStatus;
14613 operationCompleted = ClasspIsTokenOperationComplete(operationStatus);
14614 NT_ASSERT(operationCompleted);
14615
14617
14618 completionStatus = tokenInformationResults->CompletionStatus;
14619
14622
14624 NT_ASSERT(segmentsProcessed == 0);
14625
14626 if (operationCompleted) {
14627
14628 if (transferBlockCount > totalSectorsToProcess) {
14629
14630 //
14631 // Buggy or hostile target. Don't let it claim more was procesed
14632 // than was requested. Since this is likely a bug and it's unknown
14633 // how much was actually transferred, assume no data was
14634 // transferred.
14635 //
14636
14637 NT_ASSERT(transferBlockCount <= totalSectorsToProcess);
14638 transferBlockCount = 0;
14639 }
14640
14642 operationStatus != OPERATION_COMPLETED_WITH_RESIDUAL_DATA) {
14643
14644 //
14645 // Assert on buggy response from target, but in any case, make sure not
14646 // to claim that any data was written.
14647 //
14648
14649 NT_ASSERT(transferBlockCount == 0);
14650 transferBlockCount = 0;
14651 }
14652
14653 //
14654 // Since the TokenOperation was sent down synchronously, the operation is complete as soon as the command returns.
14655 //
14656
14657 senseDataFieldLength = tokenInformationResults->SenseDataFieldLength;
14658 senseDataLength = tokenInformationResults->SenseDataLength;
14659 NT_ASSERT(senseDataFieldLength >= senseDataLength);
14660
14661 tokenInformationResultsResponse = (PRECEIVE_TOKEN_INFORMATION_RESPONSE_HEADER)((PUCHAR)tokenInformationResults +
14663 tokenInformationResults->SenseDataFieldLength);
14664
14665 REVERSE_BYTES(&tokenDescriptorLength, &tokenInformationResultsResponse->TokenDescriptorsLength);
14666
14667 if (tokenDescriptorLength > 0) {
14668
14670
14672
14673 TracePrint((TRACE_LEVEL_ERROR,
14674 TRACE_FLAG_IOCTL,
14675 "ClasspReceivePopulateTokenInformationTransferPacketDone (%p): Bad firmware, token descriptor length %u.\n",
14676 fdo,
14677 tokenDescriptorLength));
14678
14679 NT_ASSERT((*totalSectorsProcessed) == 0);
14680 NT_ASSERT(tokenLength == 0);
14681
14682 } else {
14683
14684 USHORT restrictedId;
14685
14686 tokenDescriptor = (PBLOCK_DEVICE_TOKEN_DESCRIPTOR)tokenInformationResultsResponse->TokenDescriptor;
14687
14689 NT_ASSERT(restrictedId == 0);
14690
14691 tokenLength = BLOCK_DEVICE_TOKEN_SIZE;
14693
14694 *totalSectorsProcessed = transferBlockCount;
14695
14696 if (transferBlockCount < totalSectorsToProcess) {
14697
14699 operationStatus == OPERATION_COMPLETED_WITH_ERROR ||
14700 operationStatus == OPERATION_TERMINATED);
14701
14702 if (transferBlockCount == 0) {
14703 //
14704 // Treat the same as not getting a token.
14705 //
14706
14707 tokenLength = 0;
14708 }
14709
14710 } else {
14711
14713 NT_ASSERT(transferBlockCount == totalSectorsToProcess);
14714 }
14715
14716 //
14717 // Need to convert to ascii.
14718 //
14720 tokenSize,
14721 &tokenSize);
14722
14723 TracePrint((transferBlockCount == totalSectorsToProcess ? TRACE_LEVEL_INFORMATION : TRACE_LEVEL_WARNING,
14724 TRACE_FLAG_IOCTL,
14725 "ClasspReceivePopulateTokenInformationTransferPacketDone (%p): %wsToken %s generated successfully for list Id %x for data size %I64u bytes.\n",
14726 fdo,
14729 listIdentifier,
14731
14732 FREE_POOL(tokenAscii);
14733 }
14734 } else {
14735
14736 TracePrint((TRACE_LEVEL_ERROR,
14737 TRACE_FLAG_IOCTL,
14738 "ClasspReceivePopulateTokenInformationTransferPacketDone (%p): Target failed to generate a token for list Id %x for data size %I64u bytes (requested %I64u bytes).\n",
14739 fdo,
14740 listIdentifier,
14743
14744 *totalSectorsProcessed = 0;
14745
14747 }
14748
14749 //
14750 // Operation that completes with success can have sense data (for target to pass on some extra info)
14751 // but we don't care about such sense info.
14752 // Operation that complete but not with success, may not have sense data associated, but may
14753 // have valid CompletionStatus.
14754 //
14755 // The "status" may be overriden by ClassInterpretSenseInfo(). Final
14756 // status is determined a bit later - this is just the default status
14757 // when ClassInterpretSenseInfo() doesn't get to run here.
14758 //
14761 operationStatus == OPERATION_COMPLETED_WITH_RESIDUAL_DATA ||
14762 operationStatus == OPERATION_TERMINATED) {
14763
14765
14766 if (senseDataLength) {
14767
14768 ULONG retryInterval;
14769
14771
14773
14777
14778 ClassInterpretSenseInfo(fdo,
14779 srb,
14780 IRP_MJ_SCSI,
14781 0,
14782 0,
14783 &status,
14784 &retryInterval);
14785
14786 TracePrint((TRACE_LEVEL_WARNING,
14787 TRACE_FLAG_IOCTL,
14788 "ClasspReceivePopulateTokenInformationTransferPacketDone (%p): Reason for truncation/failure: %x - for list Id %x for data size %I64u bytes.\n",
14789 fdo,
14790 status,
14791 listIdentifier,
14793 } else {
14794
14795 TracePrint((TRACE_LEVEL_WARNING,
14796 TRACE_FLAG_IOCTL,
14797 "ClasspReceivePopulateTokenInformationTransferPacketDone (%p): No sense data available but reason for truncation/failure, possibly: %x - for list Id %x for data size %I64u bytes.\n",
14798 fdo,
14799 completionStatus,
14800 listIdentifier,
14802 }
14803 }
14804
14805 if (tokenLength > 0) {
14806
14808
14809 //
14810 // Even if target returned an error, from the OS upper layers' perspective,
14811 // it is a success (with truncation) if any data at all was read.
14812 //
14814
14815 } else {
14816
14818 //
14819 // Make sure status is a failing status, without throwing away an
14820 // already-failing status obtained from sense data.
14821 //
14823 }
14824 }
14825
14826 //
14827 // Done with the operation.
14828 //
14829
14831 goto __ClasspReceivePopulateTokenInformationTransferPacketDone_Exit;
14832
14833 } else {
14834
14836
14837 TracePrint((TRACE_LEVEL_ERROR,
14838 TRACE_FLAG_IOCTL,
14839 "ClasspReceivePopulateTokenInformationTransferPacketDone (%p): Token retrieval failed for list Id %x with %x.\n",
14840 fdo,
14841 listIdentifier,
14842 status));
14843
14844 NT_ASSERT(*totalSectorsProcessed == 0);
14845 goto __ClasspReceivePopulateTokenInformationTransferPacketDone_Exit;
14846 }
14847
14848__ClasspReceivePopulateTokenInformationTransferPacketDone_Exit:
14849
14851
14852 //
14853 // The "status" value can be success or failure at this point, as
14854 // appropriate.
14855 //
14856
14858 }
14859
14860 //
14861 // Due to tracing a potentially freed pointer value "Irp", this trace could
14862 // be delayed beyond another offload op picking up the same pointer value
14863 // for its Irp. This function exits after the operation is complete when
14864 // status != STATUS_PENDING.
14865 //
14866
14867 TracePrint((TRACE_LEVEL_VERBOSE,
14868 TRACE_FLAG_IOCTL,
14869 "ClasspReceivePopulateTokenInformationTransferPacketDone (%p): Exiting function (Irp %p) with internal status %x.\n",
14870 fdo,
14871 irp,
14872 status));
14873
14874 return;
14875}
struct _SENSE_DATA * PSENSE_DATA
FORCEINLINE BOOLEAN ClasspIsTokenOperationComplete(_In_ ULONG CurrentStatus)
Definition: classp.h:2023
BOOLEAN NTAPI ClassInterpretSenseInfo(_In_ PDEVICE_OBJECT Fdo, _In_ PSCSI_REQUEST_BLOCK _Srb, _In_ UCHAR MajorFunctionCode, _In_ ULONG IoDeviceCode, _In_ ULONG RetryCount, _Out_ NTSTATUS *Status, _Out_opt_ _Deref_out_range_(0, 100) ULONG *RetryInterval)
Definition: class.c:4452
struct BLOCK_DEVICE_TOKEN_DESCRIPTOR * PBLOCK_DEVICE_TOKEN_DESCRIPTOR
struct RECEIVE_TOKEN_INFORMATION_HEADER * PRECEIVE_TOKEN_INFORMATION_HEADER
struct RECEIVE_TOKEN_INFORMATION_RESPONSE_HEADER * PRECEIVE_TOKEN_INFORMATION_RESPONSE_HEADER
FORCEINLINE VOID SrbSetScsiStatus(_In_ PVOID Srb, _In_ UCHAR ScsiStatus)
Definition: srbhelper.h:1064
UCHAR SenseDataFieldLength
Definition: scsi.h:3674
UCHAR SegmentsProcessed[2]
Definition: scsi.h:3678
UCHAR ResponseToServiceAction
Definition: scsi.h:3667
UCHAR EstimatedStatusUpdateDelay[4]
Definition: scsi.h:3672
UCHAR TokenDescriptor[ANYSIZE_ARRAY]
Definition: scsi.h:3688
UCHAR TokenDescriptorsLength[4]
Definition: scsi.h:3686
ULONGLONG TotalSectorsToProcess
Definition: classp.h:1080
ULONGLONG TotalSectorsProcessed
Definition: classp.h:1086
Definition: cdrw_hw.h:1163
◆ ClasspReceiveWriteUsingTokenInformation()
| _IRQL_requires_same_ VOID ClasspReceiveWriteUsingTokenInformation | ( | _In_ POFFLOAD_WRITE_CONTEXT | OffloadWriteContext | ) |
Definition at line 15937 of file class.c.
15963{
15966 ULONG cdbLength;
15967 PDEVICE_OBJECT fdo;
15969 ULONG listIdentifier;
15970 PTRANSFER_PACKET pkt;
15971 PIRP pseudoIrp;
15972 ULONG receiveTokenInformationBufferLength;
15973 PSCSI_REQUEST_BLOCK srb;
15975 ULONG tempSizeUlong;
15976 PMDL writeUsingTokenMdl;
15977
15978 fdo = OffloadWriteContext->Fdo;
15979 irp = OffloadWriteContext->OffloadWriteDsmIrp;
15980 pseudoIrp = &OffloadWriteContext->PseudoIrp;
15981 buffer = OffloadWriteContext + 1;
15982 bufferLength = OffloadWriteContext->BufferLength;
15983 receiveTokenInformationBufferLength = OffloadWriteContext->ReceiveTokenInformationBufferLength;
15984 writeUsingTokenMdl = OffloadWriteContext->WriteUsingTokenMdl;
15985 listIdentifier = OffloadWriteContext->ListIdentifier;
15986 srb = &OffloadWriteContext->Srb;
15988
15989 TracePrint((TRACE_LEVEL_VERBOSE,
15990 TRACE_FLAG_IOCTL,
15991 "ClasspReceiveWriteUsingTokenInformation (%p): Entering function. Irp %p\n",
15992 fdo,
15993 irp));
15994
15995 //
15996 // The WRITE USING TOKEN wasn't immediately fully successful, so that means
15997 // the only way to find out how many sectors were processed by the WRITE
15998 // USING TOKEN is to get a successful RECEIVE ROD TOKEN INFORMATION that
15999 // indicates the operation is complete.
16000 //
16001
16002 NT_ASSERT(OffloadWriteContext->TotalSectorsProcessed == 0);
16003
16005
16006 if (!pkt) {
16007
16008 TracePrint((TRACE_LEVEL_ERROR,
16009 TRACE_FLAG_IOCTL,
16010 "ClasspReceiveWriteUsingTokenInformation (%p): Failed to retrieve transfer packet for ReceiveTokenInformation (WriteUsingToken) operation.\n",
16011 fdo));
16012
16014
16015 goto __ClasspReceiveWriteUsingTokenInformation_ErrorExit;
16016 }
16017
16019
16020 tempSizeUlong = receiveTokenInformationBufferLength - 4;
16022
16024
16027 pseudoIrp->Tail.Overlay.DriverContext[0] = LongToPtr(1);
16028 pseudoIrp->MdlAddress = writeUsingTokenMdl;
16029
16030 ClasspSetupReceiveWriteUsingTokenInformationTransferPacket(
16031 OffloadWriteContext,
16032 pkt,
16033 bufferLength,
16035 pseudoIrp,
16036 listIdentifier);
16037
16038 //
16039 // Cache away the CDB as it may be required for forwarded sense data
16040 // after this command completes.
16041 //
16044 if (cdbLength <= 16) {
16046 }
16047
16048 SubmitTransferPacket(pkt);
16049
16050 return;
16051
16052 //
16053 // Error label only - not used by success cases:
16054 //
16055
16056__ClasspReceiveWriteUsingTokenInformation_ErrorExit:
16057
16059
16060 //
16061 // ClasspCompleteOffloadWrite also cleans up OffloadWriteContext.
16062 //
16063
16065
16066 return;
16067}
Referenced by ClasspWriteUsingTokenTransferPacketDone().
◆ ClasspReceiveWriteUsingTokenInformationDone()
| VOID ClasspReceiveWriteUsingTokenInformationDone | ( | _In_ POFFLOAD_WRITE_CONTEXT | OffloadWriteContext, |
| _In_ NTSTATUS | CompletionCausingStatus | ||
| ) |
Definition at line 15695 of file class.c.
15727{
15728 PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = OffloadWriteContext->Fdo->DeviceExtension;
15729 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
15730
15731 //
15732 // Time taken in 100ns units.
15733 //
15734 ULONGLONG durationIn100ns = (KeQueryInterruptTime() - OffloadWriteContext->OperationStartTime);
15736
15737 NT_ASSERT(
15738 OffloadWriteContext->TotalSectorsProcessedSuccessfully <=
15739 OffloadWriteContext->TotalRequestSizeSectors);
15740
15741
15742 if (OffloadWriteContext->TotalSectorsProcessedSuccessfully == OffloadWriteContext->TotalRequestSizeSectors) {
15743
15744 ClasspCompleteOffloadWrite(OffloadWriteContext, CompletionCausingStatus);
15745
15746 goto __ClasspReceiveWriteUsingTokenInformationDone_Exit;
15747 }
15748
15749 //
15750 // Since we don't want a layered timeout mechanism (e.g. guest and parent OS in Hyper-V scenarios)
15751 // to cause a SCSI timeout for the higher layer token operations.
15752 //
15753 if (maxTargetDuration <= durationIn100ns) {
15754
15755 TracePrint((TRACE_LEVEL_WARNING,
15756 TRACE_FLAG_IOCTL,
15757 "ClasspReceiveWriteUsingTokenInformationDone (%p): Truncating write (list id %x) because of max-duration-rule.\n",
15758 OffloadWriteContext->Fdo,
15759 OffloadWriteContext->ListIdentifier));
15760
15761 //
15762 // We could technically pass in STATUS_IO_OPERATION_TIMEOUT, but ClasspCompleteOffloadWrite
15763 // won't end up doing anything (useful) with this status, since some bytes would already
15764 // have been transferred.
15765 //
15767
15768 goto __ClasspReceiveWriteUsingTokenInformationDone_Exit;
15769 }
15770
15771 NT_ASSERT(
15772 OffloadWriteContext->TotalSectorsProcessedSuccessfully <
15773 OffloadWriteContext->TotalRequestSizeSectors);
15774
15775 //
15776 // Keep going with the next sub-request.
15777 //
15778
15779 ClasspContinueOffloadWrite(OffloadWriteContext);
15780
15781__ClasspReceiveWriteUsingTokenInformationDone_Exit:
15782
15783 return;
15784}
VOID ClasspContinueOffloadWrite(_In_ __drv_aliasesMem POFFLOAD_WRITE_CONTEXT OffloadWriteContext)
Definition: class.c:15187
ULONG CopyOffloadMaxTargetDuration
Definition: classp.h:665
Referenced by ClasspReceiveWriteUsingTokenInformationTransferPacketDone(), and ClasspWriteUsingTokenTransferPacketDone().
◆ ClasspReceiveWriteUsingTokenInformationTransferPacketDone()
| VOID ClasspReceiveWriteUsingTokenInformationTransferPacketDone | ( | _In_ POFFLOAD_WRITE_CONTEXT | OffloadWriteContext | ) |
Definition at line 16071 of file class.c.
16100{
16101 ULONG availableData;
16103 UCHAR completionStatus;
16104 ULONG estimatedRetryInterval;
16105 PDEVICE_OBJECT fdo;
16106 PFUNCTIONAL_DEVICE_EXTENSION fdoExt;
16108 ULONG listIdentifier;
16109 BOOLEAN operationCompleted;
16110 UCHAR operationStatus;
16111 PIRP pseudoIrp;
16112 USHORT segmentsProcessed;
16113 PSENSE_DATA senseData;
16114 ULONG senseDataFieldLength;
16115 UCHAR senseDataLength;
16116 PSCSI_REQUEST_BLOCK srb;
16118 ULONG tokenDescriptorLength;
16119 PRECEIVE_TOKEN_INFORMATION_HEADER tokenInformationResults;
16120 PRECEIVE_TOKEN_INFORMATION_RESPONSE_HEADER tokenInformationResponsePadding;
16121 PBOOLEAN tokenInvalidated;
16122 PULONGLONG totalSectorsProcessed;
16123 ULONGLONG totalSectorsToProcess;
16124 ULONGLONG transferBlockCount;
16125
16126 fdo = OffloadWriteContext->Fdo;
16127 fdoExt = fdo->DeviceExtension;
16128 listIdentifier = OffloadWriteContext->ListIdentifier;
16129 totalSectorsProcessed = &OffloadWriteContext->TotalSectorsProcessed;
16130 totalSectorsToProcess = OffloadWriteContext->TotalSectorsToProcess;
16131 irp = OffloadWriteContext->OffloadWriteDsmIrp;
16132 pseudoIrp = &OffloadWriteContext->PseudoIrp;
16133 tokenInvalidated = &OffloadWriteContext->TokenInvalidated;
16134 srb = &OffloadWriteContext->Srb;
16135 operationCompleted = FALSE;
16136 buffer = OffloadWriteContext + 1;
16138 senseData = (PSENSE_DATA)((PUCHAR)tokenInformationResults + FIELD_OFFSET(RECEIVE_TOKEN_INFORMATION_HEADER, SenseData));
16139 transferBlockCount = 0;
16140 tokenInformationResponsePadding = NULL;
16141 tokenDescriptorLength = 0;
16142
16143 NT_ASSERT((*totalSectorsProcessed) == 0);
16144
16145 OffloadWriteContext->Pkt = NULL;
16146
16147
16150
16151 //
16152 // The buffer we hand allows for the max sizes for all the fields whereas the returned
16153 // data may be lesser (e.g. sense data info will almost never be MAX_SENSE_BUFFER_SIZE, etc.
16154 // so handle underrun "error"
16155 //
16157
16159 }
16160
16162 TracePrint((TRACE_LEVEL_ERROR,
16163 TRACE_FLAG_IOCTL,
16164 "ClasspReceiveWriteUsingTokenInformationTransferPacketDone (%p): Failed with %x to retrieve write results for list Id %x for data size %I64u bytes.\n",
16165 fdo,
16166 status,
16167 listIdentifier,
16169
16170 NT_ASSERT((*totalSectorsProcessed) == 0);
16171
16172 goto __ClasspReceiveWriteUsingTokenInformationTransferPacketDone_ErrorExit;
16173 }
16174
16176
16177 NT_ASSERT(availableData <= FIELD_OFFSET(RECEIVE_TOKEN_INFORMATION_HEADER, SenseData) + MAX_SENSE_BUFFER_SIZE);
16178
16179 NT_ASSERT(tokenInformationResults->ResponseToServiceAction == SERVICE_ACTION_WRITE_USING_TOKEN);
16180
16181 operationStatus = tokenInformationResults->OperationStatus;
16182 operationCompleted = ClasspIsTokenOperationComplete(operationStatus);
16183 NT_ASSERT(operationCompleted);
16184
16186
16187 completionStatus = tokenInformationResults->CompletionStatus;
16188
16189 senseDataFieldLength = tokenInformationResults->SenseDataFieldLength;
16190 senseDataLength = tokenInformationResults->SenseDataLength;
16191 NT_ASSERT(senseDataFieldLength >= senseDataLength);
16192
16193 tokenInformationResponsePadding = (PRECEIVE_TOKEN_INFORMATION_RESPONSE_HEADER)((PUCHAR)tokenInformationResults +
16195 tokenInformationResults->SenseDataFieldLength);
16196
16197 REVERSE_BYTES(&tokenDescriptorLength, &tokenInformationResponsePadding->TokenDescriptorsLength);
16198 NT_ASSERT(tokenDescriptorLength == 0);
16199
16202
16204 NT_ASSERT(segmentsProcessed == 0);
16205
16206 if (operationCompleted) {
16207
16208 if (transferBlockCount > totalSectorsToProcess) {
16209
16210 //
16211 // Buggy or hostile target. Don't let it claim more was procesed
16212 // than was requested. Since this is likely a bug and it's unknown
16213 // how much was actually transferred, assume no data was
16214 // transferred.
16215 //
16216
16217 NT_ASSERT(transferBlockCount <= totalSectorsToProcess);
16218 transferBlockCount = 0;
16219 }
16220
16222 operationStatus != OPERATION_COMPLETED_WITH_RESIDUAL_DATA) {
16223
16224 //
16225 // Assert on buggy response from target, but in any case, make sure not
16226 // to claim that any data was written.
16227 //
16228
16229 NT_ASSERT(transferBlockCount == 0);
16230 transferBlockCount = 0;
16231 }
16232
16233 //
16234 // Since the TokenOperation was sent down synchronously but failed, the operation is complete as soon as the
16235 // ReceiveTokenInformation command returns.
16236 //
16237
16238 NT_ASSERT((*totalSectorsProcessed) == 0);
16239 *totalSectorsProcessed = transferBlockCount;
16240 ClasspAdvanceOffloadWritePosition(OffloadWriteContext, transferBlockCount);
16241
16242 if (transferBlockCount < totalSectorsToProcess) {
16243
16245 operationStatus == OPERATION_COMPLETED_WITH_ERROR ||
16246 operationStatus == OPERATION_TERMINATED);
16247
16248 } else {
16249
16251 }
16252
16253 TracePrint((transferBlockCount == totalSectorsToProcess ? TRACE_LEVEL_INFORMATION : TRACE_LEVEL_WARNING,
16254 TRACE_FLAG_IOCTL,
16255 "ClasspReceiveWriteUsingTokenInformationTransferPacketDone (%p): %wsSuccessfully wrote (for list Id %x) for data size %I64u bytes\n",
16256 fdo,
16258 listIdentifier,
16260
16261 //
16262 // Operation that completes with success can have sense data (for target to pass on some extra info)
16263 // but we don't care about such sense info.
16264 // Operation that complete but not with success, may not have sense data associated, but may
16265 // have valid CompletionStatus.
16266 //
16267 // The "status" may be overriden by ClassInterpretSenseInfo(). Final
16268 // status is determined a bit later - this is just the default status
16269 // when ClassInterpretSenseInfo() doesn't get to run here.
16270 //
16273 operationStatus == OPERATION_COMPLETED_WITH_RESIDUAL_DATA ||
16274 operationStatus == OPERATION_TERMINATED) {
16275
16277
16278 if (senseDataLength) {
16279
16280 ULONG retryInterval;
16281
16283
16285
16289
16290 ClassInterpretSenseInfo(fdo,
16291 srb,
16292 IRP_MJ_SCSI,
16293 0,
16294 0,
16295 &status,
16296 &retryInterval);
16297
16298 TracePrint((TRACE_LEVEL_WARNING,
16299 TRACE_FLAG_IOCTL,
16300 "ClasspReceiveWriteUsingTokenInformationTransferPacketDone (%p): Reason for truncation/failure: %x - for list Id %x for data size %I64u bytes.\n",
16301 fdo,
16302 status,
16303 listIdentifier,
16305
16306 //
16307 // If the token isn't valid any longer, we should let the upper layers know so that
16308 // they don't waste time retrying the write with the same token.
16309 //
16311
16312 *tokenInvalidated = TRUE;
16313 }
16314 } else {
16315
16316 TracePrint((TRACE_LEVEL_WARNING,
16317 TRACE_FLAG_IOCTL,
16318 "ClasspReceiveWriteUsingTokenInformationTransferPacketDone (%p): No sense data available but reason for truncation/failure, possibly: %x - for list Id %x for data size %I64u bytes.\n",
16319 fdo,
16320 completionStatus,
16321 listIdentifier,
16323 }
16324 }
16325
16326 //
16327 // Initialize status. Upper layer needs to know if command failed because it
16328 // timed out without doing any writing. ClasspCompleteOffloadWrite() will
16329 // force status to success if any data was written, so it's this function's
16330 // job to set the status appropriately based on the outcome of this
16331 // WRITE USING TOKEN command, and then ClasspCompleteOffloadWrite()
16332 // can override with success if previos WRITE USING TOKEN commands
16333 // issued for the same upper request were able to write some data.
16334 //
16335 if (transferBlockCount != 0) {
16337 } else {
16338
16340 //
16341 // Make sure status is a failing status, without throwing away an
16342 // already-failing status obtained from sense data.
16343 //
16345 }
16346 }
16347
16349
16351 goto __ClasspReceiveWriteUsingTokenInformationTransferPacketDone_ErrorExit;
16352 }
16353
16356 goto __ClasspReceiveWriteUsingTokenInformationTransferPacketDone_Exit;
16357
16358 } else {
16359
16361
16362 goto __ClasspReceiveWriteUsingTokenInformationTransferPacketDone_ErrorExit;
16363 }
16364
16365 //
16366 // Error label only - not used in success case:
16367 //
16368
16369__ClasspReceiveWriteUsingTokenInformationTransferPacketDone_ErrorExit:
16370
16372
16374
16375__ClasspReceiveWriteUsingTokenInformationTransferPacketDone_Exit:
16376
16377 //
16378 // Due to tracing a potentially freed pointer value "Irp", this trace could
16379 // be delayed beyond another offload op picking up the same pointer value
16380 // for its Irp.
16381 //
16382
16383 TracePrint((TRACE_LEVEL_VERBOSE,
16384 TRACE_FLAG_IOCTL,
16385 "ClasspReceiveWriteUsingTokenInformationTransferPacketDone (%p): Exiting function (Irp %p) with status %x.\n",
16386 fdo,
16387 irp,
16388 status));
16389
16390 return;
16391}
VOID ClasspAdvanceOffloadWritePosition(_In_ POFFLOAD_WRITE_CONTEXT OffloadWriteContext, _In_ ULONGLONG SectorsToAdvance)
Definition: class.c:15445
VOID ClasspReceiveWriteUsingTokenInformationDone(_In_ POFFLOAD_WRITE_CONTEXT OffloadWriteContext, _In_ NTSTATUS CompletionCausingStatus)
Definition: class.c:15695
◆ ClasspRefreshFunctionSupportInfo()
| NTSTATUS ClasspRefreshFunctionSupportInfo | ( | _Inout_ PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| _In_ BOOLEAN | ForceQuery | ||
| ) |
Definition at line 16395 of file class.c.
16420{
16423 ULONG srbSize;
16424 CLASS_VPD_B0_DATA blockLimitsDataNew;
16425 PCLASS_VPD_B0_DATA blockLimitsDataOriginal;
16426 KLOCK_QUEUE_HANDLE lockHandle;
16427 ULONG generationCount;
16428 ULONG changeRequestCount;
16429
16430 //
16431 // ChangeRequestCount is incremented every time we get an unit attention with
16432 // SCSI_ADSENSE_OPERATING_CONDITIONS_CHANGED. GenerationCount will be set to
16433 // ChangeRequestCount after CLASS_FUNCTION_SUPPORT_INFO is refreshed with the latest
16434 // VPD data. i.e. if both values are the same, data in
16435 // CLASS_FUNCTION_SUPPORT_INFO is current
16436 //
16437
16438 generationCount = FdoExtension->FunctionSupportInfo->GenerationCount;
16439 changeRequestCount = FdoExtension->FunctionSupportInfo->ChangeRequestCount;
16442 }
16443
16444 //
16445 // Allocate an SRB for querying the device for LBP-related info if either
16446 // the Logical Block Provisioning (0xB2) or Block Limits (0xB0) VPD page
16447 // exists.
16448 //
16451 srbSize = CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE;
16452 } else {
16454 }
16455
16459 }
16460
16462 srb,
16463 srbSize,
16464 &blockLimitsDataNew);
16465
16467
16469
16470 //
16471 // If the generationCount didn't change since we looked at it last time, it means
16472 // no one has tried to update the CLASS_FUNCTION_SUPPORT_INFO data; otherwise, someone
16473 // else has beat us to it.
16474 //
16476
16477 blockLimitsDataOriginal = &FdoExtension->FunctionSupportInfo->BlockLimitsData;
16479 //
16480 // CommandStatus == -1 means this is the first time we have
16481 // gotten the block limits data.
16482 //
16483 *blockLimitsDataOriginal = blockLimitsDataNew;
16484 } else {
16485 //
16486 // We only expect the Optimal Unmap Granularity (and alignment)
16487 // to change, so those are the only parameters we update.
16488 //
16490 blockLimitsDataOriginal->UnmapGranularityAlignment = blockLimitsDataNew.UnmapGranularityAlignment;
16491 blockLimitsDataOriginal->OptimalUnmapGranularity = blockLimitsDataNew.OptimalUnmapGranularity;
16492 }
16493 FdoExtension->FunctionSupportInfo->GenerationCount = changeRequestCount;
16494 }
16495
16496 KeReleaseInStackQueuedSpinLock(&lockHandle);
16497 }
16498
16499 FREE_POOL(srb);
16501}
Referenced by ClasspBlockLimitsDataSnapshot().
◆ ClasspRegisterMountedDeviceInterface()
| VOID ClasspRegisterMountedDeviceInterface | ( | IN PDEVICE_OBJECT | DeviceObject | ) |
Definition at line 10970 of file class.c.
10973{
10974
10977 PDEVICE_OBJECT pdo;
10978 UNICODE_STRING interfaceName;
10979
10981
10982 PAGED_CODE();
10983
10984 if(isFdo) {
10985
10986 PFUNCTIONAL_DEVICE_EXTENSION functionalExtension;
10987
10988 functionalExtension =
10989 (PFUNCTIONAL_DEVICE_EXTENSION) commonExtension;
10990 pdo = functionalExtension->LowerPdo;
10991 } else {
10992 pdo = DeviceObject;
10993 }
10994
10995#ifdef _MSC_VER
10996#pragma prefast(suppress:6014, "The allocated memory that interfaceName points to will be freed in ClassRemoveDevice().")
10997#endif
10999 pdo,
11000 &MOUNTDEV_MOUNTED_DEVICE_GUID,
11001 NULL,
11002 &interfaceName
11003 );
11004
11006
11007 //
11008 // Copy the interface name before setting the interface state - the
11009 // name is needed by the components we notify.
11010 //
11011
11012 commonExtension->MountedDeviceInterfaceName = interfaceName;
11014
11016 RtlFreeUnicodeString(&interfaceName);
11017 }
11018 }
11019
11022 NULL);
11023 }
11024 return;
11025} // end ClasspRegisterMountedDeviceInterface()
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
NTSTATUS NTAPI IoRegisterDeviceInterface(IN PDEVICE_OBJECT PhysicalDeviceObject, IN CONST GUID *InterfaceClassGuid, IN PUNICODE_STRING ReferenceString OPTIONAL, OUT PUNICODE_STRING SymbolicLinkName)
Definition: deviface.c:1451
NTSTATUS NTAPI IoSetDeviceInterfaceState(IN PUNICODE_STRING SymbolicLinkName, IN BOOLEAN Enable)
Definition: deviface.c:1807
UNICODE_STRING MountedDeviceInterfaceName
Definition: classpnp.h:628
Definition: env_spec_w32.h:368
◆ ClasspReleaseQueue()
| VOID ClasspReleaseQueue | ( | IN PDEVICE_OBJECT | DeviceObject, |
| IN PIRP | ReleaseQueueIrp | ||
| ) |
Definition at line 11743 of file class.c.
11747{
11748 PIO_STACK_LOCATION irpStack;
11751 PDEVICE_OBJECT lowerDevice;
11752 PSTORAGE_REQUEST_BLOCK_HEADER srb;
11753 KIRQL currentIrql;
11754 ULONG function;
11755
11757
11758 //
11759 // we raise irql seperately so we're not swapped out or suspended
11760 // while holding the release queue irp in this routine. this lets
11761 // us release the spin lock before lowering irql.
11762 //
11763
11765
11767
11768 //
11769 // make sure that if they passed us an irp, it matches our allocated irp.
11770 //
11771
11773 (ReleaseQueueIrp == fdoExtension->PrivateFdoData->ReleaseQueueIrp));
11774
11775 //
11776 // ASSERT that we've already allocated this. (should not occur)
11777 // try to allocate it anyways, then finally bugcheck if
11778 // there's still no memory...
11779 //
11780
11781 NT_ASSERT(fdoExtension->PrivateFdoData->ReleaseQueueIrpAllocated);
11782 if (!fdoExtension->PrivateFdoData->ReleaseQueueIrpAllocated) {
11783 ClasspAllocateReleaseQueueIrp(fdoExtension);
11784 }
11785 if (!fdoExtension->PrivateFdoData->ReleaseQueueIrpAllocated) {
11787 }
11788
11790
11791 //
11792 // Someone is already using the irp - just set the flag to indicate that
11793 // we need to release the queue again.
11794 //
11795
11798 KeLowerIrql(currentIrql);
11799 return;
11800
11801 }
11802
11803 //
11804 // Mark that there is a release queue in progress and drop the spinlock.
11805 //
11806
11808 if (ReleaseQueueIrp) {
11809 irp = ReleaseQueueIrp;
11810 } else {
11812 }
11813
11816 } else {
11818 }
11819
11821
11823
11825
11827
11829
11830 //
11831 // Store the SRB address in next stack for port driver.
11832 //
11833
11835
11836 //
11837 // If this device is removable then flush the queue. This will also
11838 // release it.
11839 //
11840
11842 function = SRB_FUNCTION_FLUSH_QUEUE;
11843 }
11844 else {
11845 function = SRB_FUNCTION_RELEASE_QUEUE;
11846 }
11847
11849 ((PSTORAGE_REQUEST_BLOCK)srb)->SrbFunction = function;
11850 } else {
11851 srb->Function = (UCHAR)function;
11852 }
11853
11855
11857 ClassReleaseQueueCompletion,
11858 Fdo,
11859 TRUE,
11860 TRUE,
11861 TRUE);
11862
11864
11865 KeLowerIrql(currentIrql);
11866
11867 return;
11868
11869} // end ClassReleaseQueue()
DECLSPEC_NORETURN VOID NTAPI KeBugCheckEx(IN ULONG BugCheckCode, IN ULONG_PTR BugCheckParameter1, IN ULONG_PTR BugCheckParameter2, IN ULONG_PTR BugCheckParameter3, IN ULONG_PTR BugCheckParameter4)
Definition: debug.c:485
IO_COMPLETION_ROUTINE ClassReleaseQueueCompletion
Definition: classp.h:1586
Referenced by ClassReleaseQueue(), and ClassReleaseQueueCompletion().
◆ ClasspRetryDpcTimer()
| VOID ClasspRetryDpcTimer | ( | IN PCLASS_PRIVATE_FDO_DATA | FdoData | ) |
Definition at line 12457 of file class.c.
12460{
12461 LARGE_INTEGER fire;
12462
12465
12466 //
12467 // fire == (CurrentTick - now) * (100ns per tick)
12468 //
12469 // NOTE: Overflow is nearly impossible and is ignored here
12470 //
12471
12472 KeQueryTickCount(&fire);
12474 fire.QuadPart *= FdoData->Retry.Granularity;
12475
12476 //
12477 // fire is now multiples of 100ns until should fire the timer.
12478 // if timer should already have expired, or would fire too quickly,
12479 // fire it in some arbitrary number of ticks to prevent infinitely
12480 // recursing.
12481 //
12482
12485 }
12486
12487 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
12488 "ClassRetry: ======= %I64x ticks\n",
12489 fire.QuadPart));
12490
12491 //
12492 // must use negative to specify relative time to fire
12493 //
12494
12496
12497 //
12498 // set the timer, since this is the first addition
12499 //
12500
12501 KeSetTimerEx(&FdoData->Retry.Timer, fire, 0, &FdoData->Retry.Dpc);
12502
12503 return;
12504} // end ClasspRetryDpcTimer()
BOOLEAN NTAPI KeSetTimerEx(IN OUT PKTIMER Timer, IN LARGE_INTEGER DueTime, IN LONG Period, IN PKDPC Dpc OPTIONAL)
Definition: timerobj.c:295
Referenced by ClasspRetryRequestDpc(), and ClassRetryRequest().
◆ ClasspScanForClassHacks()
| VOID NTAPI ClasspScanForClassHacks | ( | IN PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| IN ULONG_PTR | Data | ||
| ) |
Definition at line 12634 of file class.c.
12638{
12639 PAGED_CODE();
12640
12641 //
12642 // remove invalid flags and save
12643 //
12644
12647 return;
12648}
Definition: sort_test.cpp:77
Referenced by ClassPnpStartDevice().
◆ ClasspScanForSpecialInRegistry()
| VOID ClasspScanForSpecialInRegistry | ( | IN PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension | ) |
Definition at line 12651 of file class.c.
12654{
12657 OBJECT_ATTRIBUTES objectAttributes = {0};
12658 UNICODE_STRING subkeyName;
12660
12661 //
12662 // seeded in the ENUM tree by ClassInstaller
12663 //
12664 ULONG deviceHacks;
12666
12667 PAGED_CODE();
12668
12669 deviceParameterHandle = NULL;
12670 classParameterHandle = NULL;
12671 deviceHacks = 0;
12672
12674 PLUGPLAY_REGKEY_DEVICE,
12675 KEY_WRITE,
12676 &deviceParameterHandle
12677 );
12678
12680 goto cleanupScanForSpecial;
12681 }
12682
12684 InitializeObjectAttributes(&objectAttributes,
12685 &subkeyName,
12687 deviceParameterHandle,
12688 NULL
12689 );
12690
12692 KEY_READ,
12693 &objectAttributes
12694 );
12695
12697 goto cleanupScanForSpecial;
12698 }
12699
12700 //
12701 // Setup the structure to read
12702 //
12703
12706 queryTable[0].EntryContext = &deviceHacks;
12708 queryTable[0].DefaultData = &deviceHacks;
12709 queryTable[0].DefaultLength = 0;
12710
12711 //
12712 // read values
12713 //
12714
12716 (PWSTR)classParameterHandle,
12717 &queryTable[0],
12718 NULL,
12719 NULL
12720 );
12722 goto cleanupScanForSpecial;
12723 }
12724
12725 //
12726 // remove unknown values and save...
12727 //
12728
12731
12732
12733cleanupScanForSpecial:
12734
12735 if (deviceParameterHandle) {
12736 ZwClose(deviceParameterHandle);
12737 }
12738
12739 if (classParameterHandle) {
12740 ZwClose(classParameterHandle);
12741 }
12742
12743 //
12744 // we should modify the system hive to include another key for us to grab
12745 // settings from. in this case: Classpnp\HackFlags
12746 //
12747 // the use of a DWORD value for the HackFlags allows 32 hacks w/o
12748 // significant use of the registry, and also reduces OEM exposure.
12749 //
12750 // definition of bit flags:
12751 // 0x00000001 -- Device succeeds PREVENT_MEDIUM_REMOVAL, but
12752 // cannot actually prevent removal.
12753 // 0x00000002 -- Device hard-hangs or times out for GESN requests.
12754 // 0xfffffffc -- Currently reserved, may be used later.
12755 //
12756
12757 return;
12758}
return ZwOpenKey(Handle, KEY_READ, &Attributes)
ZwClose(Handle)
NTSTATUS NTAPI IoOpenDeviceRegistryKey(IN PDEVICE_OBJECT DeviceObject, IN ULONG DevInstKeyType, IN ACCESS_MASK DesiredAccess, OUT PHANDLE DevInstRegKey)
Definition: pnpmgr.c:1619
Definition: umtypes.h:184
Definition: nt_native.h:108
NTSYSAPI NTSTATUS WINAPI RtlQueryRegistryValues(ULONG, PCWSTR, PRTL_QUERY_REGISTRY_TABLE, PVOID, PVOID)
#define RTL_QUERY_REGISTRY_TYPECHECK_SHIFT
Definition: winternl.h:3591
Referenced by ClassPnpStartDevice().
◆ ClasspSrbSetOriginalIrp()
| FORCEINLINE VOID ClasspSrbSetOriginalIrp | ( | _In_ PSTORAGE_REQUEST_BLOCK_HEADER | Srb, |
| _In_ PIRP | Irp | ||
| ) |
Definition at line 2530 of file classp.h.
2534{
2536 {
2538 }
2539 else
2540 {
2542 }
2543}
Referenced by SubmitTransferPacket().
◆ ClasspStorageEventNotification()
| _IRQL_requires_same_ NTSTATUS ClasspStorageEventNotification | ( | _In_ PDEVICE_OBJECT | DeviceObject, |
| _In_ PIRP | Irp | ||
| ) |
Definition at line 7826 of file utils.c.
7849{
7850 PFUNCTIONAL_DEVICE_EXTENSION fdoExtension;
7851 PIO_STACK_LOCATION irpStack;
7852 PSTORAGE_EVENT_NOTIFICATION storageEvents;
7854
7855 TracePrint((TRACE_LEVEL_VERBOSE,
7856 TRACE_FLAG_IOCTL,
7857 "ClasspStorageEventNotification (%p): Entering function Irp %p.\n",
7858 DeviceObject,
7859 Irp));
7860
7861 fdoExtension = DeviceObject->DeviceExtension;
7863 storageEvents = Irp->AssociatedIrp.SystemBuffer;
7865
7866 if (!storageEvents) {
7867
7868 TracePrint((TRACE_LEVEL_ERROR,
7869 TRACE_FLAG_IOCTL,
7870 "ClasspStorageEventNotification (%p): NULL storage events passed in.\n",
7871 DeviceObject));
7872
7874 goto __ClasspStorageEventNotification_Exit;
7875 }
7876
7877 if (irpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(STORAGE_EVENT_NOTIFICATION)) {
7878
7879 TracePrint((TRACE_LEVEL_ERROR,
7880 TRACE_FLAG_IOCTL,
7881 "ClasspStorageEventNotification (%p): Input buffer size (%u) too small.\n",
7882 DeviceObject,
7884
7886 goto __ClasspStorageEventNotification_Exit;
7887 }
7888
7891
7892 TracePrint((TRACE_LEVEL_ERROR,
7893 TRACE_FLAG_IOCTL,
7894 "ClasspStorageEventNotification (%p): Invalid version/size [version %u, size %u].\n",
7895 DeviceObject,
7896 storageEvents->Version,
7897 storageEvents->Size));
7898
7900 goto __ClasspStorageEventNotification_Exit;
7901 }
7902
7903 //
7904 // Handle a media status event.
7905 //
7907
7908 //
7909 // Only initiate operation if underlying port driver supports asynchronous notification
7910 // and this is the FDO.
7911 //
7913 (fdoExtension->FunctionSupportInfo->AsynchronousNotificationSupported)) {
7914 ClassCheckMediaState(fdoExtension);
7915 } else {
7917 }
7918
7919 }
7920
7921__ClasspStorageEventNotification_Exit:
7922 TracePrint((TRACE_LEVEL_VERBOSE,
7923 TRACE_FLAG_IOCTL,
7924 "ClasspStorageEventNotification (%p): Exiting function Irp %p with status %x.\n",
7925 DeviceObject,
7926 Irp,
7927 status));
7928
7929 Irp->IoStatus.Information = 0;
7933
7935}
VOID NTAPI ClassCheckMediaState(_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
Definition: autorun.c:1752
#define STORAGE_EVENT_NOTIFICATION_VERSION_V1
Definition: ntddstor.h:979
Definition: ntddstor.h:973
Referenced by ClassDeviceControl().
◆ ClasspSupportsUnmap()
| FORCEINLINE BOOLEAN ClasspSupportsUnmap | ( | _In_ PCLASS_FUNCTION_SUPPORT_INFO | SupportInfo | ) |
Definition at line 1308 of file classp.h.
1311{
1312 return SupportInfo->LBProvisioningData.LBPU;
1313}
Referenced by ClasspDeviceTrimProcess(), and ClasspDeviceTrimProperty().
◆ ClasspTimeDiffToMs()
| FORCEINLINE ULONGLONG ClasspTimeDiffToMs | ( | ULONGLONG | TimeDiff | ) |
Definition at line 1297 of file classp.h.
1300{
1301 TimeDiff /= (10 * 1000);
1302
1303 return TimeDiff;
1304}
Referenced by ClasspGetIdleTime(), and ClasspIdleTimerDpc().
◆ ClasspTransferPacketGetCdb()
| FORCEINLINE PCDB ClasspTransferPacketGetCdb | ( | _In_ PTRANSFER_PACKET | Pkt | ) |
◆ ClasspTransferPacketGetNumberOfRetriesDone()
| FORCEINLINE BOOLEAN ClasspTransferPacketGetNumberOfRetriesDone | ( | _In_ PTRANSFER_PACKET | Pkt, |
| _In_ PCDB | Cdb, | ||
| _Out_ PULONG | TimesAlreadyRetried | ||
| ) |
Definition at line 2459 of file classp.h.
2464{
2466 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
2467
2469 {
2471 }
2474 {
2476 }
2479 {
2481 }
2483 {
2485 }
2488 {
2490 }
2493 {
2495 }
2497 {
2499 }
2500
2501 else
2502 {
2503 *TimesAlreadyRetried = 0;
2505 }
2506
2507
2509}
#define NUM_RECEIVE_TOKEN_INFORMATION_RETRIES
Definition: classp.h:206
struct _CDB::_TOKEN_OPERATION TOKEN_OPERATION
struct _CDB::_MODE_SENSE MODE_SENSE
Referenced by InterpretTransferPacketError().
◆ ClasspTransferPacketGetSenseInfoBuffer()
| FORCEINLINE PVOID ClasspTransferPacketGetSenseInfoBuffer | ( | _In_ PTRANSFER_PACKET | Pkt | ) |
Definition at line 2513 of file classp.h.
Referenced by HistoryLogReturnedPacket(), and InterpretTransferPacketError().
◆ ClasspTransferPacketGetSenseInfoBufferLength()
| FORCEINLINE UCHAR ClasspTransferPacketGetSenseInfoBufferLength | ( | _In_ PTRANSFER_PACKET | Pkt | ) |
Definition at line 2521 of file classp.h.
Referenced by HistoryLogReturnedPacket(), and InterpretTransferPacketError().
◆ ClasspUninitializeRemoveTracking()
| VOID ClasspUninitializeRemoveTracking | ( | _In_ PDEVICE_OBJECT | DeviceObject | ) |
Definition at line 529 of file lock.c.
532{
533 #if DBG
536
538 commonExtension->RemoveTrackingUntrackedCount == 0 &&
540
542 {
543 KIRQL oldIrql;
545
546 FREE_POOL(removeTrackingList);
548
550 }
551
552 #else
553
555 #endif
556}
LONG RemoveTrackingUntrackedCount
Definition: classpnp.h:605
NTSYSAPI ULONG NTAPI RtlNumberGenericTableElements(_In_ PRTL_GENERIC_TABLE Table)
◆ ClasspUpdateTimerNoWakeTolerance()
| BOOLEAN ClasspUpdateTimerNoWakeTolerance | ( | _In_ PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension | ) |
Definition at line 3653 of file autorun.c.
3680{
3682
3684 fdoData = FdoExtension->PrivateFdoData;
3685 }
3686
3689 fdoData->TimerInitialized &&
3690 fdoData->TickTimerEnabled) {
3691
3693
3694 //
3695 // Set the no-wake tolerance to "unlimited" if the conditions below
3696 // are met. An "unlimited" no-wake tolerance means that the timer
3697 // will *never* wake the processor if the processor is in a
3698 // low-power state.
3699 // 1. The screen is off.
3700 // 2. The class driver is *not* a consumer of the tick timer (ClassTick is NULL).
3701 // 3. This is a disk device.
3702 // Otherwise the tolerance is set to the normal, default tolerable delay.
3703 //
3707 noWakeTolerance = EX_TIMER_UNLIMITED_TOLERANCE;
3708 }
3709
3710 //
3711 // The new tolerance is different from the current tolerance so we need
3712 // to set/reset the timer with the new tolerance value.
3713 //
3718
3720 parameters.NoWakeTolerance = noWakeTolerance;
3721 fdoData->CurrentNoWakeTolerance = noWakeTolerance;
3722
3724 dueTime,
3725 period,
3726 ¶meters);
3727
3729 }
3730 }
3731
3733}
Referenced by _Function_class_().
◆ ClasspWriteCacheProperty()
| NTSTATUS ClasspWriteCacheProperty | ( | _In_ PDEVICE_OBJECT | DeviceObject, |
| _In_ PIRP | Irp, | ||
| _Inout_ PSCSI_REQUEST_BLOCK | Srb | ||
| ) |
Definition at line 1199 of file utils.c.
1204{
1206 PSTORAGE_WRITE_CACHE_PROPERTY writeCache;
1213 PCDB cdb;
1214
1215 //
1216 // Must run at less then dispatch.
1217 //
1218
1220
1223 goto WriteCacheExit;
1224 }
1225
1226 //
1227 // Check proper query type.
1228 //
1229
1232 goto WriteCacheExit;
1233 }
1234
1237 goto WriteCacheExit;
1238 }
1239
1241
1244 goto WriteCacheExit;
1245 }
1246
1249
1250 //
1251 // Set version and required size.
1252 //
1253
1256
1260 goto WriteCacheExit;
1261 }
1262
1263 //
1264 // Set known values
1265 //
1266
1267 writeCache->NVCacheEnabled = FALSE;
1268 writeCache->UserDefinedPowerProtection = TEST_FLAG(fdoExtension->DeviceFlags, DEV_POWER_PROTECTED);
1269
1270 //
1271 // Check for flush cache support by sending a sync cache command
1272 // to the device.
1273 //
1274
1275 //
1276 // Set timeout value and mark the request as not being a tagged request.
1277 //
1282
1286
1288 Srb,
1289 NULL,
1290 0,
1291 TRUE);
1293 writeCache->FlushCacheSupported = TRUE;
1294 } else {
1295 //
1296 // Device does not support sync cache
1297 //
1298
1299 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "ClasspWriteCacheProperty: Synchronize cache failed with status 0x%X\n", status));
1300 writeCache->FlushCacheSupported = FALSE;
1301 //
1302 // Reset the status if there was any failure
1303 //
1305 }
1306
1307 modeData = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
1308 MODE_PAGE_DATA_SIZE,
1309 CLASS_TAG_MODE_DATA);
1310
1312 TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL, "ClasspWriteCacheProperty: Unable to allocate mode data buffer\n"));
1314 goto WriteCacheExit;
1315 }
1316
1318
1320 (PCHAR) modeData,
1321 MODE_PAGE_DATA_SIZE,
1322 MODE_PAGE_CACHING);
1323
1325
1326 //
1327 // Retry the request in case of a check condition.
1328 //
1329
1331 (PCHAR) modeData,
1332 MODE_PAGE_DATA_SIZE,
1333 MODE_PAGE_CACHING);
1334
1336 TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL, "ClasspWriteCacheProperty: Mode Sense failed\n"));
1338 goto WriteCacheExit;
1339 }
1340 }
1341
1342 //
1343 // If the length is greater than length indicated by the mode data reset
1344 // the data to the mode data.
1345 //
1346
1349 }
1350
1351 //
1352 // Look for caching page in the returned mode page data.
1353 //
1354
1356 length,
1357 MODE_PAGE_CACHING,
1358 TRUE);
1359
1360 //
1361 // Check if valid caching page exists.
1362 //
1363
1365
1366 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "ClasspWriteCacheProperty: Unable to find caching mode page.\n"));
1367 //
1368 // Set write cache value as unknown.
1369 //
1370 writeCache->WriteCacheEnabled = WriteCacheEnableUnknown;
1371 writeCache->WriteCacheType = WriteCacheTypeUnknown;
1372 } else {
1373 writeCache->WriteCacheEnabled = pageData->WriteCacheEnable ?
1375
1376 writeCache->WriteCacheType = pageData->WriteCacheEnable ?
1378 }
1379
1380 //
1381 // Check write through support. If the device previously failed a write request
1382 // with FUA bit is set, then CLASS_SPECIAL_FUA_NOT_SUPPORTED will be set,
1383 // which means write through is not support by the device.
1384 //
1385
1388 writeCache->WriteThroughSupported = WriteThroughSupported;
1389 } else {
1390 writeCache->WriteThroughSupported = WriteThroughNotSupported;
1391 }
1392
1393 //
1394 // Get the changeable caching mode page and check write cache is changeable.
1395 //
1396
1398
1400 (PCHAR) modeData,
1401 MODE_PAGE_DATA_SIZE,
1402 MODE_PAGE_CACHING,
1403 MODE_SENSE_CHANGEABLE_VALUES);
1404
1406
1407 //
1408 // Retry the request in case of a check condition.
1409 //
1410
1412 (PCHAR) modeData,
1413 MODE_PAGE_DATA_SIZE,
1414 MODE_PAGE_CACHING,
1415 MODE_SENSE_CHANGEABLE_VALUES);
1416
1418
1419 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "ClasspWriteCacheProperty: Mode Sense failed\n"));
1420
1421 //
1422 // If the device fails to return changeable pages, then
1423 // set the write cache changeable value to unknown.
1424 //
1425
1426 writeCache->WriteCacheChangeable = WriteCacheChangeUnknown;
1428 goto WriteCacheExit;
1429 }
1430 }
1431
1432 //
1433 // If the length is greater than length indicated by the mode data reset
1434 // the data to the mode data.
1435 //
1436
1439 }
1440
1441 //
1442 // Look for caching page in the returned mode page data.
1443 //
1444
1446 length,
1447 MODE_PAGE_CACHING,
1448 TRUE);
1449 //
1450 // Check if valid caching page exists.
1451 //
1452
1454 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "ClasspWriteCacheProperty: Unable to find caching mode page.\n"));
1455 //
1456 // Set write cache changeable value to unknown.
1457 //
1458 writeCache->WriteCacheChangeable = WriteCacheChangeUnknown;
1459 } else {
1460 writeCache->WriteCacheChangeable = pageData->WriteCacheEnable ?
1462 }
1463
1465
1466WriteCacheExit:
1467
1468 FREE_POOL(modeData);
1469
1470 //
1471 // Set the size and status in IRP
1472 //
1475
1478
1480}
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
ULONG ClasspModeSense(_In_ PDEVICE_OBJECT Fdo, _In_reads_bytes_(Length) PCHAR ModeSenseBuffer, _In_ ULONG Length, _In_ UCHAR PageMode, _In_ UCHAR PageControl)
Definition: class.c:6681
ULONG ScanForSpecialFlags
Definition: classpnp.h:925
Definition: cdrw_hw.h:2770
Definition: cdrw_hw.h:2504
UCHAR DeviceSpecificParameter
Definition: cdrw_hw.h:2507
Referenced by ClassDeviceControl().
◆ ClasspWriteUsingTokenTransferPacketDone()
Definition at line 15519 of file class.c.
15549{
15550 ULONGLONG entireXferLen;
15551 PDEVICE_OBJECT fdo;
15552 PFUNCTIONAL_DEVICE_EXTENSION fdoExt;
15553 ULONG listIdentifier;
15554 POFFLOAD_WRITE_CONTEXT offloadWriteContext;
15555 PTRANSFER_PACKET pkt;
15556 PIRP pseudoIrp;
15558 PBOOLEAN tokenInvalidated;
15559 ULONGLONG totalSectorsToProcess;
15560
15561 offloadWriteContext = Context;
15562 pseudoIrp = &offloadWriteContext->PseudoIrp;
15563 fdo = offloadWriteContext->Fdo;
15564 fdoExt = fdo->DeviceExtension;
15565 listIdentifier = offloadWriteContext->ListIdentifier;
15566 totalSectorsToProcess = offloadWriteContext->TotalSectorsToProcess;
15567 entireXferLen = offloadWriteContext->EntireXferLen;
15568 tokenInvalidated = &offloadWriteContext->TokenInvalidated;
15569 pkt = offloadWriteContext->Pkt;
15570
15572
15573
15576
15577 //
15578 // If the request failed with any of the following errors, then it is meaningless to send
15579 // down a ReceiveTokenInformation (regardless of whether the transfer was requested as sync
15580 // or async), since the target has no saved information about the command:
15581 // - STATUS_INVALID_TOKEN
15582 // - STATUS_INVALID_PARAMETER
15583 //
15586
15587 TracePrint((TRACE_LEVEL_ERROR,
15588 TRACE_FLAG_IOCTL,
15589 "ClasspWriteUsingTokenTransferPacketDone (%p): Write failed with %x (list id %x).\n",
15590 fdo,
15591 status,
15592 listIdentifier));
15593
15594 //
15595 // If the token isn't valid any longer, we should let the upper layers know so that
15596 // they don't waste time retrying the write with the same token.
15597 //
15599
15600 *tokenInvalidated = TRUE;
15601 }
15602
15604 goto __ClasspWriteUsingTokenTransferPacketDone_Exit;
15605
15608
15609 //
15610 // If the TokenOperation command was sent to the target requesting synchronous data
15611 // transfer, a success indicates that the command is complete.
15612 // This could either be because of a successful completion of the entire transfer
15613 // or because of a partial transfer due to target truncation. If it is the latter,
15614 // and the information field of the sense data has returned the TransferCount, we
15615 // can avoid sending down an RRTI.
15616 //
15618
15619 //
15620 // The entire transfer has completed successfully.
15621 //
15622 offloadWriteContext->TotalSectorsProcessed = totalSectorsToProcess;
15623 TracePrint((TRACE_LEVEL_INFORMATION,
15624 TRACE_FLAG_IOCTL,
15625 "ClasspWriteUsingTokenTransferPacketDone (%p): Successfully wrote using token %I64u (out of %I64u) bytes (list Id %x).\n",
15626 fdo,
15628 entireXferLen,
15629 listIdentifier));
15630 } else {
15631
15632 //
15633 // The target has returned how much data it transferred in the response to the
15634 // WUT command itself, allowing us to optimize by removing the necessaity for
15635 // sending down an RRTI to query the TransferCount.
15636 //
15638
15640 TracePrint((TRACE_LEVEL_INFORMATION,
15641 TRACE_FLAG_IOCTL,
15642 "ClasspWriteUsingTokenTransferPacketDone (%p): Target truncated write using token %I64u (out of %I64u) bytes (list Id %x).\n",
15643 fdo,
15645 entireXferLen,
15646 listIdentifier));
15647 }
15648
15649 ClasspAdvanceOffloadWritePosition(offloadWriteContext, totalSectorsToProcess);
15650
15652
15653 //
15654 // ClasspReceiveWriteUsingTokenInformationDone() takes care of
15655 // completing the operation (eventually), so pending from point of view
15656 // of this function.
15657 //
15658
15661
15662 goto __ClasspWriteUsingTokenTransferPacketDone_Exit;
15663
15664 } else {
15665
15666 //
15667 // Since the TokenOperation was failed (or the target truncated the transfer but
15668 // didn't indicate the amount), we need to send down ReceiveTokenInformation.
15669 //
15670 TracePrint((TRACE_LEVEL_ERROR,
15671 TRACE_FLAG_IOCTL,
15672 "ClasspWriteUsingTokenTransferPacketDone (%p): Write failed with status %x, %x (list id %x).\n",
15673 fdo,
15674 status,
15675 pkt->Srb->SrbStatus,
15676 listIdentifier));
15677
15678 ClasspReceiveWriteUsingTokenInformation(offloadWriteContext);
15679
15681 goto __ClasspWriteUsingTokenTransferPacketDone_Exit;
15682 }
15683
15684__ClasspWriteUsingTokenTransferPacketDone_Exit:
15685
15688 }
15689
15690 return;
15691}
_IRQL_requires_same_ VOID ClasspReceiveWriteUsingTokenInformation(_In_ POFFLOAD_WRITE_CONTEXT OffloadWriteContext)
Definition: class.c:15937
Definition: classp.h:1113
ULONGLONG TotalSectorsToProcess
Definition: classp.h:1149
ULONGLONG TotalSectorsProcessed
Definition: classp.h:1150
◆ ClasspZeroQERR()
| VOID ClasspZeroQERR | ( | _In_ PDEVICE_OBJECT | DeviceObject | ) |
Definition at line 7938 of file utils.c.
7957{
7961
7962 modeData = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
7963 MODE_PAGE_DATA_SIZE,
7964 CLASS_TAG_MODE_DATA);
7965
7967 TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_SCSI, "ClasspZeroQERR: Unable to allocate mode data buffer\n"));
7968 goto ClasspZeroQERR_Exit;
7969 }
7970
7972
7974 (PCHAR) modeData,
7975 MODE_PAGE_DATA_SIZE,
7976 MODE_PAGE_CONTROL);
7977
7979
7980 //
7981 // Retry the request in case of a check condition.
7982 //
7983
7985 (PCHAR) modeData,
7986 MODE_PAGE_DATA_SIZE,
7987 MODE_PAGE_CONTROL);
7988
7991 goto ClasspZeroQERR_Exit;
7992 }
7993 }
7994
7995 //
7996 // If the size is greater than size indicated by the mode data reset
7997 // the data to the mode data.
7998 //
7999
8002 }
8003
8004 //
8005 // Look for control page in the returned mode page data.
8006 //
8007
8009 size,
8010 MODE_PAGE_CONTROL,
8011 TRUE);
8012
8013 if (pageData) {
8014 TracePrint((TRACE_LEVEL_VERBOSE,
8015 TRACE_FLAG_SCSI,
8016 "ClasspZeroQERR (%p): Current settings: QERR = %u, TST = %u, TAS = %u.\n",
8017 DeviceObject,
8018 pageData->QERR,
8019 pageData->TST,
8020 pageData->TAS));
8021
8024 UCHAR pageSavable = 0;
8025
8026 //
8027 // Set QERR to 0 with a Mode Select command. Re-use the modeData
8028 // and pageData structures.
8029 //
8030 pageData->QERR = 0;
8031
8032 //
8033 // We use the original Page Savable (PS) value for the Save Pages
8034 // (SP) bit due to behavior described under the MODE SELECT(6)
8035 // section of SPC-4.
8036 //
8037 pageSavable = pageData->PageSavable;
8038
8040 (PCHAR)modeData,
8041 size,
8042 pageSavable);
8043
8045 TracePrint((TRACE_LEVEL_WARNING,
8046 TRACE_FLAG_SCSI,
8047 "ClasspZeroQERR (%p): Failed to set QERR = 0 with status %x\n",
8048 DeviceObject,
8049 status));
8050 }
8051 }
8052 }
8053
8054ClasspZeroQERR_Exit:
8055
8057 ExFreePool(modeData);
8058 }
8059}
NTSTATUS ClasspModeSelect(_In_ PDEVICE_OBJECT Fdo, _In_reads_bytes_(Length) PCHAR ModeSelectBuffer, _In_ ULONG Length, _In_ BOOLEAN SavePages)
Definition: class.c:6919
Definition: scsi.h:3431
◆ ClassQueryPnpCapabilities()
| NTSTATUS ClassQueryPnpCapabilities | ( | IN PDEVICE_OBJECT | PhysicalDeviceObject, |
| IN PDEVICE_CAPABILITIES | Capabilities | ||
| ) |
Definition at line 10192 of file class.c.
10196{
10197 PCLASS_DRIVER_EXTENSION driverExtension =
10198 ClassGetDriverExtension(DeviceObject->DriverObject);
10200
10201 PCLASS_QUERY_PNP_CAPABILITIES queryRoutine = NULL;
10202
10203 PAGED_CODE();
10204
10207
10210 } else {
10212 }
10213
10214 if(queryRoutine) {
10216 Capabilities);
10217 } else {
10219 }
10220} // end ClassQueryPnpCapabilities()
PCLASS_QUERY_PNP_CAPABILITIES ClassQueryPnpCapabilities
Definition: classpnp.h:532
Referenced by ClassDispatchPnp().
◆ ClassQueueCapacityChangedEventWorker()
| VOID ClassQueueCapacityChangedEventWorker | ( | _In_ PDEVICE_OBJECT | DeviceObject | ) |
Definition at line 5637 of file utils.c.
5650{
5651 PCOMMON_DEVICE_EXTENSION commonExtension = (PCOMMON_DEVICE_EXTENSION)(DeviceObject->DeviceExtension);
5653
5655 {
5657
5658 if (workItem)
5659 {
5660
5661 TracePrint((TRACE_LEVEL_INFORMATION,
5662 TRACE_FLAG_GENERAL,
5663 "ClassQueueCapacityChangedEventWorker: DO (%p), Queueing capacity changed event work item.\n",
5664 DeviceObject));
5665
5667
5668 //
5669 // Queue a work item to write the threshold notification to the
5670 // system event log.
5671 //
5673 }
5674 else
5675 {
5676 TracePrint((TRACE_LEVEL_ERROR,
5677 TRACE_FLAG_GENERAL,
5678 "ClassQueueCapacityChangedEventWorker: DO (%p), Failed to allocate memory for the work item.\n",
5679 DeviceObject));
5680 }
5681 }
5682}
Referenced by ClassInterpretSenseInfo().
◆ ClassQueueProvisioningTypeChangedEventWorker()
| VOID ClassQueueProvisioningTypeChangedEventWorker | ( | _In_ PDEVICE_OBJECT | DeviceObject | ) |
Definition at line 5726 of file utils.c.
5739{
5740 PCOMMON_DEVICE_EXTENSION commonExtension = (PCOMMON_DEVICE_EXTENSION)(DeviceObject->DeviceExtension);
5742
5744 {
5746
5747 if (workItem)
5748 {
5749
5750 TracePrint((TRACE_LEVEL_INFORMATION,
5751 TRACE_FLAG_GENERAL,
5752 "ClassQueueProvisioningTypeChangedEventWorker: DO (%p), Queueing LB provisioning type changed event work item.\n",
5753 DeviceObject));
5754
5756
5757 //
5758 // Queue a work item to write the threshold notification to the
5759 // system event log.
5760 //
5762 }
5763 else
5764 {
5765 TracePrint((TRACE_LEVEL_ERROR,
5766 TRACE_FLAG_GENERAL,
5767 "ClassQueueProvisioningTypeChangedEventWorker: DO (%p), Failed to allocate memory for the work item.\n",
5768 DeviceObject));
5769 }
5770 }
5771}
Referenced by ClassInterpretSenseInfo().
◆ ClassQueueResourceExhaustionEventWorker()
| VOID ClassQueueResourceExhaustionEventWorker | ( | _In_ PDEVICE_OBJECT | DeviceObject | ) |
Definition at line 5528 of file utils.c.
5543{
5544 PCOMMON_DEVICE_EXTENSION commonExtension = (PCOMMON_DEVICE_EXTENSION)(DeviceObject->DeviceExtension);
5546
5548 {
5550
5551 if (workItem)
5552 {
5553
5554 TracePrint((TRACE_LEVEL_INFORMATION,
5555 TRACE_FLAG_GENERAL,
5556 "ClassQueueResourceExhaustionEventWorker: DO (%p), Queueing permanent resource exhaustion event work item.\n",
5557 DeviceObject));
5558
5560
5561 //
5562 // Queue a work item to write the threshold notification to the
5563 // system event log.
5564 //
5566 }
5567 else
5568 {
5569 TracePrint((TRACE_LEVEL_ERROR,
5570 TRACE_FLAG_GENERAL,
5571 "ClassQueueResourceExhaustionEventWorker: DO (%p), Failed to allocate memory for the work item.\n",
5572 DeviceObject));
5573 }
5574 }
5575}
IO_WORKITEM_ROUTINE ClassLogResourceExhaustionEvent
Definition: classp.h:2306
Referenced by ClassInterpretSenseInfo().
◆ ClassQueueThresholdEventWorker()
| VOID ClassQueueThresholdEventWorker | ( | _In_ PDEVICE_OBJECT | DeviceObject | ) |
Definition at line 5471 of file utils.c.
5485{
5486 PCOMMON_DEVICE_EXTENSION commonExtension = (PCOMMON_DEVICE_EXTENSION)(DeviceObject->DeviceExtension);
5487 PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)(DeviceObject->DeviceExtension);
5489
5491 InterlockedCompareExchange((PLONG)&(fdoExtension->FunctionSupportInfo->LBProvisioningData.SoftThresholdEventPending), 1, 0) == 0)
5492 {
5494
5495 if (workItem)
5496 {
5497
5498 TracePrint((TRACE_LEVEL_INFORMATION,
5499 TRACE_FLAG_GENERAL,
5500 "ClassQueueThresholdEventWorker: DO (%p), Queueing soft threshold notification work item.\n",
5501 DeviceObject));
5502
5503
5505
5506 //
5507 // Queue a work item to write the threshold notification to the
5508 // system event log.
5509 //
5511 }
5512 else
5513 {
5514 //
5515 // Clear the soft threshold event pending flag since this is normally
5516 // done when the work item completes.
5517 //
5518 InterlockedExchange((PLONG)&(fdoExtension->FunctionSupportInfo->LBProvisioningData.SoftThresholdEventPending), 0);
5519
5520 TracePrint((TRACE_LEVEL_ERROR,
5521 TRACE_FLAG_GENERAL,
5522 "ClassQueueThresholdEventWorker: DO (%p), Failed to allocate memory for the work item.\n",
5523 DeviceObject));
5524 }
5525 }
5526}
Referenced by ClassInterpretSenseInfo().
◆ ClassReadCapacity16()
| NTSTATUS ClassReadCapacity16 | ( | _Inout_ PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| _Inout_ PSCSI_REQUEST_BLOCK | Srb | ||
| ) |
Definition at line 1568 of file utils.c.
1583{
1588 PCDB cdb;
1589 ULONG dataTransferLength = 0;
1590
1591 //
1592 // If the information retrieval has already been attempted, return the cached status.
1593 //
1595 // get cached NTSTATUS from previous call.
1597 }
1598
1602 }
1603
1604#if defined(_ARM_) || defined(_ARM64_)
1605 //
1606 // ARM has specific alignment requirements, although this will not have a functional impact on x86 or amd64
1607 // based platforms. We are taking the conservative approach here.
1608 //
1609 allocationBufferLength = ALIGN_UP_BY(allocationBufferLength,KeGetRecommendedSharedDataAlignment());
1610 dataBuffer = (PREAD_CAPACITY16_DATA)ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned, allocationBufferLength, '4CcS');
1611#else
1612 dataBuffer = (PREAD_CAPACITY16_DATA)ExAllocatePoolWithTag(NonPagedPoolNx, bufferLength, '4CcS');
1613#endif
1614
1616 // return without updating FdoExtension->FunctionSupportInfo->ReadCapacity16Data.CommandStatus
1617 // the field will remain value as "-1", so that the command will be attempted next time this function is called.
1619 }
1620
1622
1623 //
1624 // Initialize the SRB.
1625 //
1630 1,
1631 SrbExDataTypeScsiCdb16);
1634 } else {
1635 //
1636 // Should not occur.
1637 //
1639 }
1640 } else {
1644 }
1645
1646 //prepare the Srb
1648 {
1649
1654
1656
1661
1663 Srb,
1664 dataBuffer,
1665 allocationBufferLength,
1666 FALSE);
1667
1669 }
1670
1672 {
1673 // the device should return at least 16 bytes of data for this command.
1675 }
1676
1677 //
1678 // Handle the case where we get back STATUS_DATA_OVERRUN b/c the input
1679 // buffer was larger than necessary.
1680 //
1682 {
1684 }
1685
1687 {
1688 // cache data into FdoExtension
1690 }
1691
1692 // cache the status indicates that this funciton has been called.
1694
1696
1698}
NTSTATUS InterpretReadCapacity16Data(_Inout_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _In_ PREAD_CAPACITY16_DATA ReadCapacity16Data)
Definition: utils.c:1517
struct _READ_CAPACITY16_DATA READ_CAPACITY16_DATA
struct _READ_CAPACITY16_DATA * PREAD_CAPACITY16_DATA
Definition: scsi.h:1430
struct _CDB::_READ_CAPACITY16 READ_CAPACITY16
Referenced by ClasspAccessAlignmentProperty().
◆ ClassRemoveChild()
| PPHYSICAL_DEVICE_EXTENSION ClassRemoveChild | ( | IN PFUNCTIONAL_DEVICE_EXTENSION | Parent, |
| IN PPHYSICAL_DEVICE_EXTENSION | Child, | ||
| IN BOOLEAN | AcquireLock | ||
| ) |
Definition at line 12119 of file class.c.
12124{
12126 ClassAcquireChildLock(Parent);
12127 }
12128
12129 TRY {
12131
12132 //
12133 // If the list is empty then bail out now.
12134 //
12135
12138 LEAVE;
12139 }
12140
12141 //
12142 // If the caller specified a child then find the child object before
12143 // it. If none was specified then the FDO is the child object before
12144 // the one we want to remove.
12145 //
12146
12148
12149 //
12150 // Scan through the child list to find the entry which points to
12151 // this one.
12152 //
12153
12154 do {
12156
12158 break;
12159 }
12160
12161 previousChild = &previousChild->ChildList->CommonExtension;
12163
12166 LEAVE;
12167 }
12168 }
12169
12170 //
12171 // Save the next child away then unlink it from the list.
12172 //
12173
12177
12178 } FINALLY {
12181 }
12182 }
12184} // end ClassRemoveChild()
◆ ClassRetrieveDeviceRelations()
| NTSTATUS ClassRetrieveDeviceRelations | ( | IN PDEVICE_OBJECT | Fdo, |
| IN DEVICE_RELATION_TYPE | RelationType, | ||
| OUT PDEVICE_RELATIONS * | DeviceRelations | ||
| ) |
Definition at line 10005 of file class.c.
10010{
10012
10015
10016 PPHYSICAL_DEVICE_EXTENSION nextChild;
10017
10018 ULONG relationsSize;
10020 PDEVICE_RELATIONS oldRelations = *DeviceRelations;
10021
10023
10025
10026 PAGED_CODE();
10027
10028 ClassAcquireChildLock(fdoExtension);
10029
10031
10032 //
10033 // Count the number of PDO's attached to this disk
10034 //
10035
10037 PCOMMON_DEVICE_EXTENSION commonExtension;
10038
10039 commonExtension = &(nextChild->CommonExtension);
10040
10043
10044 nextChild = commonExtension->ChildList;
10045
10046 count++;
10047 };
10048
10049 //
10050 // If relations already exist in the QDR, adjust the current count
10051 // to include the previous list.
10052 //
10053
10054 if (oldRelations) {
10056 }
10057
10060
10062
10064
10065 TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_ENUM, "ClassRetrieveDeviceRelations: unable to allocate "
10066 "%d bytes for device relations\n", relationsSize));
10067
10068 ClassReleaseChildLock(fdoExtension);
10069
10071 }
10072
10073 RtlZeroMemory(deviceRelations, relationsSize);
10074
10075 if (oldRelations) {
10076
10077 //
10078 // Copy the old relations to the new list and free the old list.
10079 //
10080
10083 }
10084
10085 FREE_POOL(oldRelations);
10086 }
10087
10090
10092 PCOMMON_DEVICE_EXTENSION commonExtension;
10093
10094 commonExtension = &(nextChild->CommonExtension);
10095
10098
10101
10103 nextChild->DeviceObject,
10104 0,
10105 NULL,
10106 KernelMode);
10109 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_ENUM,
10110 "ClassRetrieveDeviceRelations: Error referencing child "
10112
10113 }
10115 nextChild = commonExtension->ChildList;
10116 }
10117
10119
10121 *DeviceRelations = deviceRelations;
10122
10123 ClassReleaseChildLock(fdoExtension);
10125} // end ClassRetrieveDeviceRelations()
NTSTATUS NTAPI ObReferenceObjectByPointer(IN PVOID Object, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode)
Definition: obref.c:380
struct _DEVICE_RELATIONS DEVICE_RELATIONS
Referenced by ClassPnpQueryFdoRelations().
◆ ClassRetryRequest()
| VOID ClassRetryRequest | ( | IN PDEVICE_OBJECT | SelfDeviceObject, |
| IN PIRP | Irp, | ||
| _In_ _In_range_(0, MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS) IN LONGLONG | TimeDelta100ns | ||
| ) |
Definition at line 12317 of file class.c.
12323{
12324 PFUNCTIONAL_DEVICE_EXTENSION fdoExtension;
12325 PCLASS_PRIVATE_FDO_DATA fdoData;
12326 PCLASS_RETRY_INFO retryInfo;
12327 LARGE_INTEGER delta;
12329
12330 //
12331 // this checks we aren't destroying irps
12332 //
12334
12335 fdoExtension = SelfDeviceObject->DeviceExtension;
12336
12338
12339 //
12340 // this debug print/assertion should ALWAYS be investigated.
12341 // ClassRetryRequest can currently only be used by FDO's
12342 //
12343
12344 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL, "ClassRetryRequestEx: LOST IRP %p\n", Irp));
12346 return;
12347
12348 }
12349
12350 fdoData = fdoExtension->PrivateFdoData;
12351
12352 if (TimeDelta100ns < 0) {
12354 TimeDelta100ns *= -1;
12355 }
12356
12357 /*
12358 * We are going to queue the irp and send it down in a timer DPC.
12359 * This means that we may be causing the irp to complete on a different thread than the issuing thread.
12360 * So mark the irp pending.
12361 */
12363
12364 //
12365 // prepare what we can out of the loop
12366 //
12367
12370
12374 }
12377 }
12378
12379 //
12380 // now determine if we should fire another DPC or not
12381 //
12382
12384
12385 //
12386 // always add request to the list
12387 //
12388
12390 fdoData->Retry.ListHead = retryInfo;
12391
12393
12395
12396 //
12397 // must be exactly one item on list
12398 //
12399
12402
12403 //
12404 // if currentDelta is zero, always fire a DPC
12405 //
12406
12410 ClasspRetryDpcTimer(fdoData);
12411
12413
12414 //
12415 // if delta is greater than the list's current delta,
12416 // increase the DPC handling time by difference
12417 // and update the delta to new larger value
12418 // allow the DPC to re-fire itself if needed
12419 //
12420
12422
12423 //
12424 // must be at least two items on list
12425 //
12426
12429
12432
12434
12435 } else {
12436
12437 //
12438 // just inserting it on the list was enough
12439 //
12440
12442
12443 }
12444
12445
12447
12448
12449} // end ClassRetryRequest()
struct _CLASS_RETRY_INFO * PCLASS_RETRY_INFO
VOID ClasspRetryDpcTimer(IN PCLASS_PRIVATE_FDO_DATA FdoData)
Definition: class.c:12457
HRESULT Next([in] ULONG celt, [out, size_is(celt), length_is(*pceltFetched)] STATPROPSETSTG *rgelt, [out] ULONG *pceltFetched)
struct _CLASS_PRIVATE_FDO_DATA::@1264 Retry
Definition: classp.h:407
Referenced by RetryPowerRequest(), and RetryRequest().
◆ ClassSendEjectionNotification()
| VOID ClassSendEjectionNotification | ( | IN PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension | ) |
Definition at line 155 of file autorun.c.
158{
159 //
160 // For post-NT5.1 work, need to move EjectSynchronizationEvent
161 // to be a MUTEX so we can attempt to grab it here and benefit
162 // from deadlock detection. This will allow checking if the media
163 // has been locked by programs before broadcasting these events.
164 // (what's the point of broadcasting if the media is not locked?)
165 //
166 // This would currently only be a slight optimization. For post-NT5.1,
167 // it would allow us to send a single PERSISTENT_PREVENT to MMC devices,
168 // thereby cleaning up a lot of the ejection code. Then, when the
169 // ejection request occured, we could see if any locks for the media
170 // existed. if locked, broadcast. if not, we send the eject irp.
171 //
172
173 //
174 // for now, just always broadcast. make this a public routine,
175 // so class drivers can add special hacks to broadcast this for their
176 // non-MMC-compliant devices also from sense codes.
177 //
178
179 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, "ClassSendEjectionNotification: media EJECT_REQUEST"));
180 ClassSendNotification(FdoExtension,
181 &GUID_IO_MEDIA_EJECT_REQUEST,
182 0,
183 NULL);
184 return;
185}
Referenced by ClassInterpretSenseInfo(), and ClasspInterpretGesnData().
◆ CleanupTransferPacketToWorkingSetSize()
| VOID CleanupTransferPacketToWorkingSetSize | ( | _In_ PDEVICE_OBJECT | Fdo, |
| _In_ BOOLEAN | LimitNumPktToDelete, | ||
| _In_ ULONG | Node | ||
| ) |
Definition at line 1615 of file xferpkt.c.
1634{
1636 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
1637 KIRQL oldIrql;
1638 SINGLE_LIST_ENTRY pktList;
1639 PSINGLE_LIST_ENTRY slistEntry;
1640 PTRANSFER_PACKET pktToDelete;
1641 ULONG requiredNumPktToDelete = fdoData->FreeTransferPacketsLists[Node].NumTotalTransferPackets -
1642 fdoData->LocalMaxWorkingSetTransferPackets;
1643
1644 if (LimitNumPktToDelete) {
1646 }
1647
1648 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_RW, "CleanupTransferPacketToWorkingSetSize (%p): Exiting stress, block freeing %d packets.", Fdo, requiredNumPktToDelete));
1649
1650 /*
1651 * Check the counter again with lock held. This eliminates a race condition
1652 * while still allowing us to not grab the spinlock in the common codepath.
1653 *
1654 * Note that the spinlock does not synchronize with threads dequeuing free
1655 * packets to send (DequeueFreeTransferPacket does that with a lightweight
1656 * interlocked exchange); the spinlock prevents multiple threads in this function
1657 * from deciding to free too many extra packets at once.
1658 */
1659 SimpleInitSlistHdr(&pktList);
1661 while ((fdoData->FreeTransferPacketsLists[Node].NumFreeTransferPackets >= fdoData->FreeTransferPacketsLists[Node].NumTotalTransferPackets) &&
1662 (fdoData->FreeTransferPacketsLists[Node].NumTotalTransferPackets > fdoData->LocalMaxWorkingSetTransferPackets) &&
1663 (requiredNumPktToDelete--)){
1664
1666 if (pktToDelete){
1667 SimplePushSlist(&pktList,
1669 InterlockedDecrement((volatile LONG *)&fdoData->FreeTransferPacketsLists[Node].NumTotalTransferPackets);
1670 } else {
1671 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_RW,
1672 "Extremely unlikely condition (non-fatal): %d packets dequeued at once for Fdo %p. NumTotalTransferPackets=%d (1). Node=%d",
1673 fdoData->LocalMaxWorkingSetTransferPackets,
1674 Fdo,
1676 Node));
1677 break;
1678 }
1679 }
1681
1682 slistEntry = SimplePopSlist(&pktList);
1683 while (slistEntry) {
1685 DestroyTransferPacket(pktToDelete);
1686 slistEntry = SimplePopSlist(&pktList);
1687 }
1688
1689 return;
1690}
FORCEINLINE VOID SimpleInitSlistHdr(SINGLE_LIST_ENTRY *SListHdr)
Definition: classp.h:1211
#define MAX_CLEANUP_TRANSFER_PACKETS_AT_ONCE
Definition: classp.h:639
FORCEINLINE SINGLE_LIST_ENTRY * SimplePopSlist(SINGLE_LIST_ENTRY *SListHdr)
Definition: classp.h:1220
FORCEINLINE VOID SimplePushSlist(SINGLE_LIST_ENTRY *SListHdr, SINGLE_LIST_ENTRY *SListEntry)
Definition: classp.h:1215
ULONG LocalMaxWorkingSetTransferPackets
Definition: classp.h:712
PPNL_SLIST_HEADER FreeTransferPacketsLists
Definition: classp.h:772
DECLSPEC_CACHEALIGN ULONG NumFreeTransferPackets
Definition: classp.h:645
Definition: ntbasedef.h:640
Definition: dlist.c:348
VOID DestroyTransferPacket(_In_ __drv_freesMem(mem) PTRANSFER_PACKET Pkt)
Definition: xferpkt.c:500
PTRANSFER_PACKET DequeueFreeTransferPacketEx(_In_ PDEVICE_OBJECT Fdo, _In_ BOOLEAN AllocIfNeeded, _In_ ULONG Node)
Definition: xferpkt.c:661
Referenced by CleanupTransferPacketToWorkingSetSizeWorker(), and EnqueueFreeTransferPacket().
◆ CreateStorageRequestBlock()
| NTSTATUS CreateStorageRequestBlock | ( | _Inout_ PSTORAGE_REQUEST_BLOCK * | Srb, |
| _In_ USHORT | AddressType, | ||
| _In_opt_ PSRB_ALLOCATE_ROUTINE | AllocateRoutine, | ||
| _Inout_opt_ ULONG * | ByteSize, | ||
| _In_ ULONG | NumSrbExData, | ||
| ... | |||
| ) |
Definition at line 249 of file srblib.c.
283{
284 ULONG sizeNeeded = 0;
288
289 // Ensure SrbExData offsets are pointer type aligned
291 if (NumSrbExData > 0) {
295 }
296 }
297
299 {
301 } else
302 {
304 }
305
307
309 {
311 {
314 break;
317 break;
320 break;
323 break;
326 break;
329 break;
332 break;
335 break;
336 default:
338 break;
339 }
340 }
342
344 {
346 {
349 {
351 }
352 }
353
355 {
356 *ByteSize = sizeNeeded;
357 }
358
360 {
362#ifdef _MSC_VER
363 #pragma prefast(suppress:26015, "pInitializeStorageRequestBlock will set the SrbLength field")
364#endif
367 }
368
369 }
370
372}
struct STOR_ADDRESS_ALIGN _STOR_ADDR_BTL8 STOR_ADDR_BTL8
struct SRB_ALIGN _SRBEX_DATA_SCSI_CDB_VAR SRBEX_DATA_SCSI_CDB_VAR
struct SRB_ALIGN _SRBEX_DATA_IO_INFO SRBEX_DATA_IO_INFO
struct SRB_ALIGN _SRBEX_DATA_SCSI_CDB16 SRBEX_DATA_SCSI_CDB16
struct SRB_ALIGN _SRBEX_DATA_PNP SRBEX_DATA_PNP
struct SRB_ALIGN _SRBEX_DATA_WMI SRBEX_DATA_WMI
struct SRB_ALIGN _SRBEX_DATA_POWER SRBEX_DATA_POWER
struct SRB_ALIGN _SRBEX_DATA_BIDIRECTIONAL SRBEX_DATA_BIDIRECTIONAL
struct SRB_ALIGN _SRBEX_DATA_SCSI_CDB32 SRBEX_DATA_SCSI_CDB32
enum _SRBEXDATATYPE SRBEXDATATYPE
NTSTATUS pInitializeStorageRequestBlock(_Inout_bytecount_(ByteSize) PSTORAGE_REQUEST_BLOCK Srb, _In_ USHORT AddressType, _In_ ULONG ByteSize, _In_ ULONG NumSrbExData, _In_ va_list ap)
Definition: srblib.c:52
_In_ PRTL_GENERIC_COMPARE_ROUTINE _In_ PRTL_GENERIC_ALLOCATE_ROUTINE AllocateRoutine
Definition: rtlfuncs.h:1106
Referenced by __drv_allocatesMem(), and InitializeTransferPackets().
◆ DefaultStorageRequestBlockAllocateRoutine()
Definition at line 28 of file srblib.c.
Referenced by __drv_allocatesMem(), and InitializeTransferPackets().
◆ DequeueDeferredClientIrp()
| PIRP DequeueDeferredClientIrp | ( | PDEVICE_OBJECT | Fdo | ) |
Definition at line 113 of file clntirp.c.
116{
118 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
120
121 //
122 // The DeferredClientIrpList is almost always empty.
123 // We don't want to grab the spinlock every time we check it (which is on every xfer completion)
124 // so check once first before we grab the spinlock.
125 //
128 }
129 else {
130 PLIST_ENTRY listEntry;
131 KIRQL oldIrql;
132
135 listEntry = NULL;
136 }
137 else {
139 }
141
144 }
145 else {
148
149
151 }
152 }
153
155}
LIST_ENTRY DeferredClientIrpList
Definition: classp.h:777
Definition: typedefs.h:120
#define IO_TYPE_IRP
Referenced by TransferPktComplete().
◆ DequeueFreeTransferPacket()
| PTRANSFER_PACKET DequeueFreeTransferPacket | ( | PDEVICE_OBJECT | Fdo, |
| BOOLEAN | AllocIfNeeded | ||
| ) |
Definition at line 656 of file xferpkt.c.
657{
659}
Referenced by ClasspContinueOffloadWrite(), ClasspModeSelect(), ClasspModeSense(), ClasspReceivePopulateTokenInformation(), ClasspReceiveWriteUsingTokenInformation(), ClassReadDriveCapacity(), and ServiceTransferRequest().
◆ DequeueFreeTransferPacketEx()
| PTRANSFER_PACKET DequeueFreeTransferPacketEx | ( | _In_ PDEVICE_OBJECT | Fdo, |
| _In_ BOOLEAN | AllocIfNeeded, | ||
| _In_ ULONG | Node | ||
| ) |
Definition at line 661 of file xferpkt.c.
665{
667 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
668 PTRANSFER_PACKET pkt;
669 PSLIST_ENTRY slistEntry;
670
672
673 if (slistEntry) {
674 slistEntry->Next = NULL;
676 InterlockedDecrement((volatile LONG *)&(fdoData->FreeTransferPacketsLists[Node].NumFreeTransferPackets));
677
678 // when dequeuing the packet, also reset the history data
679 HISTORYINITIALIZERETRYLOGS(pkt);
680
681 } else {
682 if (AllocIfNeeded) {
683 /*
684 * We are in stress and have run out of lookaside packets.
685 * In order to service the current transfer,
686 * allocate an extra packet.
687 * We will free it lazily when we are out of stress.
688 */
689 pkt = NewTransferPacket(Fdo);
690 if (pkt) {
691 InterlockedIncrement((volatile LONG *)&fdoData->FreeTransferPacketsLists[Node].NumTotalTransferPackets);
695 } else {
696 TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_RW, "DequeueFreeTransferPacket: packet allocation failed"));
697 }
698 } else {
699 pkt = NULL;
700 }
701 }
702
703 return pkt;
704}
Referenced by CleanupTransferPacketToWorkingSetSize(), DequeueFreeTransferPacket(), DestroyAllTransferPackets(), and EnqueueFreeTransferPacket().
◆ DestroyAllTransferPackets()
| VOID DestroyAllTransferPackets | ( | PDEVICE_OBJECT | Fdo | ) |
Definition at line 288 of file xferpkt.c.
289{
291 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
292 TRANSFER_PACKET *pkt;
294 ULONG arraySize;
295
296 PAGED_CODE();
297
298 //
299 // fdoData->FreeTransferPacketsLists could be NULL if
300 // there was an error during start device.
301 //
303
305
306 arraySize = KeQueryHighestNodeNumber() + 1;
309 while (pkt) {
310 DestroyTransferPacket(pkt);
311 InterlockedDecrement((volatile LONG *)&(fdoData->FreeTransferPacketsLists[index].NumTotalTransferPackets));
313 }
314
316 }
317 }
318
320}
PSTORAGE_REQUEST_BLOCK_HEADER SrbTemplate
Definition: classp.h:790
◆ DestroyTransferPacket()
| VOID DestroyTransferPacket | ( | _In_ __drv_freesMem(mem) PTRANSFER_PACKET | Pkt | ) |
Definition at line 500 of file xferpkt.c.
501{
503 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
504 KIRQL oldIrql;
505
507// NT_ASSERT(!Pkt->OriginalIrp);
508
510
511 /*
512 * Delete the packet from our all-packets queue.
513 */
518
520
526}
LIST_ENTRY AllTransferPacketsList
Definition: classp.h:771
Referenced by CleanupTransferPacketToWorkingSetSize(), DestroyAllTransferPackets(), and EnqueueFreeTransferPacket().
◆ EnqueueDeferredClientIrp()
| VOID EnqueueDeferredClientIrp | ( | PDEVICE_OBJECT | Fdo, |
| PIRP | Irp | ||
| ) |
Definition at line 78 of file clntirp.c.
82{
84 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
85 KIRQL oldIrql;
86
87
90
91
93}
Referenced by ServiceTransferRequest().
◆ EnqueueFreeTransferPacket()
| VOID EnqueueFreeTransferPacket | ( | PDEVICE_OBJECT | Fdo, |
| __drv_aliasesMem PTRANSFER_PACKET | Pkt | ||
| ) |
Definition at line 529 of file xferpkt.c.
530{
532 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
533 ULONG allocateNode;
534 KIRQL oldIrql;
535
537
539 InterlockedPushEntrySList(&(fdoData->FreeTransferPacketsLists[allocateNode].SListHeader), &Pkt->SlistEntry);
540 InterlockedIncrement((volatile LONG *)&(fdoData->FreeTransferPacketsLists[allocateNode].NumFreeTransferPackets));
541
542 /*
543 * If the total number of packets is larger than LocalMinWorkingSetTransferPackets,
544 * that means that we've been in stress. If all those packets are now
545 * free, then we are now out of stress and can free the extra packets.
546 * Attempt to free down to LocalMaxWorkingSetTransferPackets immediately, and
547 * down to LocalMinWorkingSetTransferPackets lazily (one at a time).
548 * However, since we're at DPC, do this is a work item. If the device is removed
549 * or we are unable to allocate the work item, do NOT free more than
550 * MAX_CLEANUP_TRANSFER_PACKETS_AT_ONCE. Subsequent IO completions will end up freeing
551 * up the rest, even if it is MAX_CLEANUP_TRANSFER_PACKETS_AT_ONCE at a time.
552 */
555
556 /*
557 * 1. Immediately snap down to our UPPER threshold.
558 */
560 fdoData->LocalMaxWorkingSetTransferPackets) {
561
562 ULONG isRemoved;
564
566
567 //
568 // Acquire a remove lock in order to make sure the device object and its
569 // private data structures will exist when the workitem fires.
570 // The remove lock will be released by the workitem (CleanupTransferPacketToWorkingSetSize).
571 //
573
574 if (workItem && !isRemoved) {
575
576 TracePrint((TRACE_LEVEL_INFORMATION,
577 TRACE_FLAG_GENERAL,
578 "EnqueueFreeTransferPacket: Device (%p), queuing work item to clean up free transfer packets.\n",
579 Fdo));
580
581 //
582 // Queue a work item to trim down the total number of transfer packets to with the
583 // working size.
584 //
585 IoQueueWorkItemEx(workItem, CleanupTransferPacketToWorkingSetSizeWorker, DelayedWorkQueue, (PVOID)(ULONG_PTR)allocateNode);
586
587 } else {
588
589 if (workItem) {
590 IoFreeWorkItem(workItem);
591 }
592
595 }
596
597 TracePrint((TRACE_LEVEL_ERROR,
598 TRACE_FLAG_GENERAL,
599 "EnqueueFreeTransferPacket: Device (%p), Failed to allocate memory for the work item.\n",
600 Fdo));
601
603 }
604 }
605
606 /*
607 * 2. Lazily work down to our LOWER threshold (by only freeing one packet at a time).
608 */
610 fdoData->LocalMinWorkingSetTransferPackets){
611 /*
612 * Check the counter again with lock held. This eliminates a race condition
613 * while still allowing us to not grab the spinlock in the common codepath.
614 *
615 * Note that the spinlock does not synchronize with threads dequeuing free
616 * packets to send (DequeueFreeTransferPacket does that with a lightweight
617 * interlocked exchange); the spinlock prevents multiple threads in this function
618 * from deciding to free too many extra packets at once.
619 */
621
622 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_RW, "Exiting stress, lazily freeing one of %d/%d packets from node %d.",
624 fdoData->LocalMinWorkingSetTransferPackets,
625 allocateNode));
626
631 fdoData->LocalMinWorkingSetTransferPackets)){
632
634 if (pktToDelete) {
635 InterlockedDecrement((volatile LONG *)&(fdoData->FreeTransferPacketsLists[allocateNode].NumTotalTransferPackets));
636 } else {
637 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_RW,
638 "Extremely unlikely condition (non-fatal): %d packets dequeued at once for Fdo %p. NumTotalTransferPackets=%d (2). Node=%d",
639 fdoData->LocalMinWorkingSetTransferPackets,
640 Fdo,
642 allocateNode));
643 }
644 }
646
647 if (pktToDelete) {
648 DestroyTransferPacket(pktToDelete);
649 }
650 }
651
652 }
653
654}
IO_WORKITEM_ROUTINE_EX CleanupTransferPacketToWorkingSetSizeWorker
Definition: classp.h:1745
NTKRNLVISTAAPI VOID NTAPI IoQueueWorkItemEx(_Inout_ PIO_WORKITEM IoWorkItem, _In_ PIO_WORKITEM_ROUTINE_EX WorkerRoutine, _In_ WORK_QUEUE_TYPE QueueType, _In_opt_ __drv_aliasesMem PVOID Context)
Definition: io.c:55
ULONG LocalMinWorkingSetTransferPackets
Definition: classp.h:711
#define InterlockedPushEntrySList(SListHead, SListEntry)
Definition: rtlfuncs.h:3413
VOID CleanupTransferPacketToWorkingSetSize(_In_ PDEVICE_OBJECT Fdo, _In_ BOOLEAN LimitNumPktToDelete, _In_ ULONG Node)
Definition: xferpkt.c:1615
Referenced by InitializeTransferPackets(), ServiceTransferRequest(), and TransferPktComplete().
◆ FREE_PORT_ALLOCATED_SENSE_BUFFER_EX()
| FORCEINLINE VOID FREE_PORT_ALLOCATED_SENSE_BUFFER_EX | ( | _In_ PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| _In_ PSTORAGE_REQUEST_BLOCK_HEADER | Srb | ||
| ) |
Definition at line 2560 of file classp.h.
2564{
2568
2573 return;
2574}
FORCEINLINE VOID SrbClearSrbFlags(_In_ PVOID Srb, _In_ ULONG Flags)
Definition: srbhelper.h:990
Referenced by _Success_(), ClasspMediaChangeDetectionCompletion(), ClassSendSrbSynchronous(), TransferPacketRetryTimerDpc(), and TransferPktComplete().
◆ FreeDeviceInputMdl()
Definition at line 622 of file utils.c.
623{
625 return;
626}
Referenced by ClasspModeSelect(), ClasspModeSense(), and ClassReadDriveCapacity().
◆ FreeDictionaryEntry()
| VOID FreeDictionaryEntry | ( | IN PDICTIONARY | Dictionary, |
| IN PVOID | Entry | ||
| ) |
Definition at line 189 of file dictlib.c.
193{
196 KIRQL oldIrql;
197 BOOLEAN found;
198
199 found = FALSE;
201
202 KeAcquireSpinLock(&(Dictionary->SpinLock), &oldIrql);
203
204 entry = &(Dictionary->List);
206
209 found = TRUE;
210 break;
211 } else {
212 entry = &(*entry)->Next;
213 }
214 }
215
216 KeReleaseSpinLock(&(Dictionary->SpinLock), oldIrql);
217
218 //
219 // calling this w/an invalid pointer invalidates the dictionary system,
220 // so NT_ASSERT() that we never try to Free something not in the list
221 //
222
223 NT_ASSERT(found);
224 if (found) {
226 }
227
228 return;
229
230}
Definition: dictlib.c:44
Referenced by ClasspCreateClose().
◆ GetDictionaryEntry()
| PVOID GetDictionaryEntry | ( | IN PDICTIONARY | Dictionary, |
| IN ULONGLONG | Key | ||
| ) |
Definition at line 157 of file dictlib.c.
161{
164 KIRQL oldIrql;
165
166
168
169 KeAcquireSpinLock(&(Dictionary->SpinLock), &oldIrql);
170
171 entry = Dictionary->List;
173
176 break;
177 } else {
179 }
180 }
181
182 KeReleaseSpinLock(&(Dictionary->SpinLock), oldIrql);
183
185}
Definition: find_test.cpp:52
Referenced by _IRQL_requires_max_().
◆ HistoryInitializeRetryLogs()
| VOID HistoryInitializeRetryLogs | ( | _Out_ PSRB_HISTORY | History, |
| ULONG | HistoryCount | ||
| ) |
Definition at line 36 of file history.c.
36 {
40 History->TotalHistoryCount = HistoryCount;
41 return;
42}
struct _SRB_HISTORY SRB_HISTORY
struct _SRB_HISTORY_ITEM SRB_HISTORY_ITEM
Definition: cdromp.h:96
Referenced by __drv_allocatesMem().
◆ HistoryLogReturnedPacket()
| VOID HistoryLogReturnedPacket | ( | TRANSFER_PACKET * | Pkt | ) |
Definition at line 83 of file history.c.
83 {
84
85 PSRB_HISTORY history;
87 UCHAR senseSize;
89 UCHAR senseInfoBufferLength;
90 SENSE_DATA convertedSenseBuffer = {0};
92
95 NT_ASSERT( history->UsedHistoryCount <= history->TotalHistoryCount );
96 item = &( history->History[ history->UsedHistoryCount-1 ] );
97
98 // Query the tick count and store in the history
100
101 // Copy the SRB Status...
103
104 //
105 // Process sense data
106 //
107
110
112
114 senseInfoBufferLength,
115 (PVOID)&convertedSenseBuffer,
116 sizeof(convertedSenseBuffer));
117
120 senseInfoBufferLength = sizeof(convertedSenseBuffer);
121 }
122 }
123
125
127
128 // Determine the amount of valid sense data
129
131 senseInfoBufferLength,
132 &senseSize)) {
133 senseSize = senseInfoBufferLength;
134 }
135
136 // Normalize the sense data copy in the history
139 senseInfoBuffer,
140 senseSize
141 );
142 }
143
144 return;
145}
FORCEINLINE PVOID ClasspTransferPacketGetSenseInfoBuffer(_In_ PTRANSFER_PACKET Pkt)
Definition: classp.h:2513
FORCEINLINE UCHAR ClasspTransferPacketGetSenseInfoBufferLength(_In_ PTRANSFER_PACKET Pkt)
Definition: classp.h:2521
#define IsDescriptorSenseDataFormat(SenseInfoBuffer)
Definition: scsi.h:3731
Definition: cdromp.h:105
Definition: interpreter.c:37
◆ HistoryLogSendPacket()
| VOID HistoryLogSendPacket | ( | TRANSFER_PACKET * | Pkt | ) |
Definition at line 45 of file history.c.
45 {
46
47 PSRB_HISTORY history;
49
52 // sending a packet implies a new history unit is to be used.
53 NT_ASSERT( history->UsedHistoryCount <= history->TotalHistoryCount );
54
55 // if already all used up, request class driver to remove at least one history unit
56 if (history->UsedHistoryCount == history->TotalHistoryCount )
57 {
59 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
63 NT_ASSERT( history->UsedHistoryCount < history->TotalHistoryCount );
64 }
65
66 // thus, since we are about to increment the count, it must now be less...
67 NT_ASSERT( history->UsedHistoryCount < history->TotalHistoryCount );
68
69 // increment the number of history units in use
70 history->UsedHistoryCount++;
71
72 // determine index to use
73 item = &( history->History[ history->UsedHistoryCount-1 ] );
74
75 // zero out the history item
77
78 // Query the tick count and store in the history
80 return;
81}
__callback PCLASS_COMPRESS_RETRY_HISTORY_DATA Compress
Definition: classpnp.h:565
PCLASS_INTERPRET_SENSE_INFO2 InterpretSenseInfo
Definition: classp.h:958
◆ InitializeDictionary()
| VOID InitializeDictionary | ( | IN PDICTIONARY | Dictionary | ) |
Definition at line 58 of file dictlib.c.
61{
63 Dictionary->Signature = DICTIONARY_SIGNATURE;
64 KeInitializeSpinLock(&Dictionary->SpinLock);
65 return;
66}
Definition: classpnp.h:293
◆ InitializeStorageRequestBlock()
| NTSTATUS InitializeStorageRequestBlock | ( | _Inout_bytecount_(ByteSize) PSTORAGE_REQUEST_BLOCK | Srb, |
| _In_ USHORT | AddressType, | ||
| _In_ ULONG | ByteSize, | ||
| _In_ ULONG | NumSrbExData, | ||
| ... | |||
| ) |
Definition at line 206 of file srblib.c.
237{
244}
Referenced by ClassDeviceControl(), ClassGetLBProvisioningLogPage(), ClasspBuildRequestEx(), ClasspCleanupProtectedLocks(), ClasspDeviceGetBlockLimitsVPDPage(), ClasspDeviceGetLBProvisioningVPDPage(), ClasspEjectionControl(), ClasspGetBlockDeviceTokenLimitsInfo(), ClasspGetInquiryVpdSupportInfo(), ClasspInterpretGesnData(), ClassPnpStartDevice(), ClasspPowerDownCompletion(), ClasspPowerHandler(), ClasspPowerUpCompletion(), ClasspPrepareMcnIrp(), ClassReadCapacity16(), ClassSendStartUnit(), and DeviceProcessDsmTrimRequest().
◆ InitializeTransferPackets()
| NTSTATUS InitializeTransferPackets | ( | PDEVICE_OBJECT | Fdo | ) |
Definition at line 45 of file xferpkt.c.
46{
49 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
52 STORAGE_PROPERTY_ID propertyId;
53 OSVERSIONINFOEXW osVersionInfo;
54 ULONG hwMaxPages;
55 ULONG arraySize;
57 ULONG maxOutstandingIOPerLUN;
58 ULONG minWorkingSetTransferPackets;
59 ULONG maxWorkingSetTransferPackets;
60
62
63 PAGED_CODE();
64
65 //
66 // Precompute the maximum transfer length
67 //
69
71
74
75 //
76 // Allocate per-node free packet lists
77 //
78 arraySize = KeQueryHighestNodeNumber() + 1;
79 fdoData->FreeTransferPacketsLists =
80 ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
83
87 }
88
93 }
94
96
97 //
98 // Set the packet threshold numbers based on the Windows Client or Server SKU.
99 //
100
103
105
106 //
107 // Retrieve info on IO capability supported by port drivers
108 //
109
110 propertyId = StorageDeviceIoCapabilityProperty;
112 &propertyId,
113 (PVOID *)&devIoCapabilityDesc);
114
116 maxOutstandingIOPerLUN = devIoCapabilityDesc->LunMaxIoCount;
117 FREE_POOL(devIoCapabilityDesc);
118
119#if DBG
120 fdoData->MaxOutstandingIOPerLUN = maxOutstandingIOPerLUN;
121#endif
122
123 } else {
124 maxOutstandingIOPerLUN = MAX_OUTSTANDING_IO_PER_LUN_DEFAULT;
125
126#if DBG
127 fdoData->MaxOutstandingIOPerLUN = 0;
128#endif
129
130 }
131
132 //
133 // StorageDeviceIoCapabilityProperty support is optional so
134 // ignore any failures.
135 //
136
138
139
142
143 // this is Client SKU
144
145 minWorkingSetTransferPackets = MIN_WORKINGSET_TRANSFER_PACKETS_Client;
146
147 // Note: the reason we use max here is to guarantee a reasonable large max number
148 // in the case where the port driver may return a very small supported outstanding
149 // IOs. For example, even EMMC drive only reports 1 outstanding IO supported, we
150 // may still want to set this value to be at least
151 // MAX_WORKINGSET_TRANSFER_PACKETS_Client.
153 2 * maxOutstandingIOPerLUN);
154
155 } else {
156
157 // this is Server SKU
158 // Note: the addition max here to make sure we set the min to be at least
159 // MIN_WORKINGSET_TRANSFER_PACKETS_Server_LowerBound no matter what maxOutstandingIOPerLUN
160 // reported. We shouldn't set this value to be smaller than client system.
161 // In other words, the minWorkingSetTransferPackets for server will always between
162 // MIN_WORKINGSET_TRANSFER_PACKETS_Server_LowerBound and MIN_WORKINGSET_TRANSFER_PACKETS_Server_UpperBound
163
164 minWorkingSetTransferPackets =
167 maxOutstandingIOPerLUN));
168
170 2 * maxOutstandingIOPerLUN);
171 }
172
173
174 fdoData->LocalMinWorkingSetTransferPackets = minWorkingSetTransferPackets;
175 fdoData->LocalMaxWorkingSetTransferPackets = maxWorkingSetTransferPackets;
176
177 //
178 // Allow class driver to override the settings
179 //
182
183 // override only if non-zero
184 if (workingSet->XferPacketsWorkingSetMinimum != 0)
185 {
186 fdoData->LocalMinWorkingSetTransferPackets = workingSet->XferPacketsWorkingSetMinimum;
187 // adjust maximum upwards if needed
189 {
191 }
192 }
193 // override only if non-zero
194 if (workingSet->XferPacketsWorkingSetMaximum != 0)
195 {
196 fdoData->LocalMaxWorkingSetTransferPackets = workingSet->XferPacketsWorkingSetMaximum;
197 // adjust minimum downwards if needed
199 {
201 }
202 }
203 // that's all the adjustments required/allowed
204 } // end working set size special code
205
207 while (fdoData->FreeTransferPacketsLists[index].NumFreeTransferPackets < MIN_INITIAL_TRANSFER_PACKETS){
209 if (pkt) {
210 InterlockedIncrement((volatile LONG *)&(fdoData->FreeTransferPacketsLists[index].NumTotalTransferPackets));
213 } else {
215 break;
216 }
217 }
218 fdoData->FreeTransferPacketsLists[index].DbgPeakNumTransferPackets = fdoData->FreeTransferPacketsLists[index].NumTotalTransferPackets;
219 }
220
221 //
222 // Pre-initialize our SCSI_REQUEST_BLOCK template with all
223 // the constant fields. This will save a little time for each xfer.
224 // NOTE: a CdbLength field of 10 may not always be appropriate
225 //
226
230
231 #if (NTDDI_VERSION >= NTDDI_WINBLUE)
233 (fdoExt->MiniportDescriptor->Size >= RTL_SIZEOF_THROUGH_FIELD(STORAGE_MINIPORT_DESCRIPTOR, ExtraIoInfoSupported)) &&
234 (fdoExt->MiniportDescriptor->ExtraIoInfoSupported == TRUE)) {
236 fdoExt->AdapterDescriptor->AddressType,
238 &ByteSize,
239 2,
242 );
243 } else {
245 fdoExt->AdapterDescriptor->AddressType,
247 &ByteSize,
248 1,
250 );
251 }
252 #else
254 fdoExt->AdapterDescriptor->AddressType,
256 &ByteSize,
257 1,
259 );
260 #endif
263 } else {
265 }
266 } else {
267 fdoData->SrbTemplate = ExAllocatePoolWithTag(NonPagedPoolNx, sizeof(SCSI_REQUEST_BLOCK), '-brs');
270 } else {
274 }
275 }
276 }
277
282 }
283
285}
NTSTATUS CreateStorageRequestBlock(_Inout_ PSTORAGE_REQUEST_BLOCK *Srb, _In_ USHORT AddressType, _In_opt_ PSRB_ALLOCATE_ROUTINE AllocateRoutine, _Inout_opt_ ULONG *ByteSize, _In_ ULONG NumSrbExData,...)
Definition: srblib.c:249
#define MAX_OUTSTANDING_IO_PER_LUN_DEFAULT
Definition: classp.h:638
#define MAX_WORKINGSET_TRANSFER_PACKETS_Client
Definition: classp.h:632
#define MIN_WORKINGSET_TRANSFER_PACKETS_Server_LowerBound
Definition: classp.h:634
#define MIN_WORKINGSET_TRANSFER_PACKETS_Server_UpperBound
Definition: classp.h:633
#define MAX_WORKINGSET_TRANSFER_PACKETS_Server
Definition: classp.h:635
PVOID DefaultStorageRequestBlockAllocateRoutine(_In_ CLONG ByteSize)
Definition: srblib.c:28
#define MIN_WORKINGSET_TRANSFER_PACKETS_Client
Definition: classp.h:631
NTSTATUS NTAPI RtlGetVersion(IN OUT PRTL_OSVERSIONINFOW lpVersionInformation)
Definition: version.c:182
* PSTORAGE_DEVICE_IO_CAPABILITY_DESCRIPTOR
Definition: ntddstor.h:695
Definition: classpnp.h:555
PCLASS_DRIVER_EXTENSION DriverExtension
Definition: classpnp.h:600
Definition: rtltypes.h:268
Definition: rtltypes.h:245
Definition: classp.h:643
ULONG MaximumPhysicalPages
Definition: ntddstor.h:307
Definition: ntddstor.h:628
FORCEINLINE VOID InitializeSListHead(_Out_ PSLIST_HEADER SListHead)
Definition: rtlfuncs.h:3375
#define VER_NT_SERVER
#define VER_NT_DOMAIN_CONTROLLER
struct _OSVERSIONINFOEXW OSVERSIONINFOEXW
VOID EnqueueFreeTransferPacket(PDEVICE_OBJECT Fdo, __drv_aliasesMem PTRANSFER_PACKET Pkt)
Definition: xferpkt.c:529
Referenced by ClassPnpStartDevice().
◆ InitLowMemRetry()
| VOID InitLowMemRetry | ( | PTRANSFER_PACKET | Pkt, |
| PVOID | BufPtr, | ||
| ULONG | Len, | ||
| LARGE_INTEGER | TargetLocation | ||
| ) |
Definition at line 670 of file retry.c.
671{
674
676 {
677 /*
678 * special case: StartIO-based writing must stay serialized for performance
679 * and proper operations (i.e. sequential writing mode). If need more than
680 * one transfer to perform this operation, and it's a StartIO-based driver
681 * (such as CDROM), then just use a single packet and use the retry logic
682 * that's already built-in to the packet engine. Note that low-mem retry
683 * cannot be used directly because some write methods do not work if the
684 * writes are only PAGE_SIZE (i.e. packet writing may corrupt data).
685 */
687 }
688 else
689 {
691 }
695}
PUCHAR LowMemRetry_remainingBufPtr
Definition: classp.h:545
LARGE_INTEGER LowMemRetry_nextChunkTargetLocation
Definition: classp.h:547
ULONG LowMemRetry_remainingBufLen
Definition: classp.h:546
Referenced by RetryTransferPacket(), and ServiceTransferRequest().
◆ InterpretCapacityData()
| VOID InterpretCapacityData | ( | PDEVICE_OBJECT | Fdo, |
| PREAD_CAPACITY_DATA_EX | ReadCapacityData | ||
| ) |
Definition at line 2640 of file class.c.
2641{
2643 ULONG cylinderSize;
2644 ULONG bytesPerSector;
2645 LARGE_INTEGER lastSector;
2646 LARGE_INTEGER largeInt;
2647
2649
2652
2653 /*
2654 * LogicalBlockAddress is the last sector of the logical drive, in big-endian.
2655 * It tells us the size of the drive (#sectors is lastSector+1).
2656 */
2657
2658 largeInt = ReadCapacityData->LogicalBlockAddress;
2659 REVERSE_BYTES_QUAD(&lastSector, &largeInt);
2660
2662 TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_INIT, "ClassReadDriveCapacity: reducing number of sectors by %d\n", fdoExt->DMSkew));
2664 }
2665
2666 /*
2667 * Check to see if we have a geometry we should be using already.
2668 * If not, we set part of the disk geometry to garbage values that will be filled in by the caller (e.g. disk.sys).
2669 *
2670 * So the first call to ClassReadDriveCapacity always sets a meaningless geometry.
2671 * TracksPerCylinder and SectorsPerTrack are kind of meaningless anyway wrt I/O,
2672 * because I/O is always targeted to a logical sector number.
2673 * All that really matters is BytesPerSector and the number of sectors.
2674 */
2676 if (cylinderSize == 0){
2680 }
2681
2682 /*
2683 * Calculate number of cylinders.
2684 * If there are zero cylinders, then the device lied AND it's
2685 * smaller than 0xff*0x3f (about 16k sectors, usually 8 meg)
2686 * this can fit into a single LONGLONG, so create another usable
2687 * geometry, even if it's unusual looking.
2688 * This allows small, non-standard devices, such as Sony's Memory Stick, to show up as having a partition.
2689 */
2695 }
2696
2697 /*
2698 * Calculate media capacity in bytes.
2699 * For this purpose we treat the entire LUN as is if it is one partition. Disk will deal with actual partitioning.
2700 */
2703
2704 /*
2705 * Is this removable or fixed media
2706 */
2709 }
2710 else {
2712 }
2713
2714}
ULONG ClasspCalculateLogicalSectorSize(_In_ PDEVICE_OBJECT Fdo, _In_ ULONG BytesPerBlockInBigEndian)
Definition: utils.c:1483
Referenced by ClassReadDriveCapacity().
◆ InterpretReadCapacity16Data()
| NTSTATUS InterpretReadCapacity16Data | ( | _Inout_ PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| _In_ PREAD_CAPACITY16_DATA | ReadCapacity16Data | ||
| ) |
Definition at line 1517 of file utils.c.
1521{
1523 USHORT lowestAlignedBlock;
1524 USHORT logicalBlocksPerPhysicalBlock;
1525 PCLASS_READ_CAPACITY16_DATA cachedData = &(FdoExtension->FunctionSupportInfo->ReadCapacity16Data);
1526
1527 // use Logical Sector Size from DiskGeometry to avoid duplicated calculation.
1528 FdoExtension->FunctionSupportInfo->ReadCapacity16Data.BytesPerLogicalSector = ClasspCalculateLogicalSectorSize(FdoExtension->DeviceObject, ReadCapacity16Data->BytesPerBlock);
1529
1530 // FdoExtension->DiskGeometry.BytesPerSector might be 0 for class drivers that don't get READ CAPACITY info yet.
1532 (FdoExtension->DiskGeometry.BytesPerSector == FdoExtension->FunctionSupportInfo->ReadCapacity16Data.BytesPerLogicalSector) );
1533
1534 logicalBlocksPerPhysicalBlock = 1 << ReadCapacity16Data->LogicalPerPhysicalExponent;
1535 lowestAlignedBlock = (ReadCapacity16Data->LowestAlignedBlock_MSB << 8) | ReadCapacity16Data->LowestAlignedBlock_LSB;
1536
1537 if (lowestAlignedBlock > logicalBlocksPerPhysicalBlock) {
1538 // we get garbage data
1540 } else {
1541 // value of lowestAlignedBlock (from T10 spec) needs to be converted.
1542 lowestAlignedBlock = (logicalBlocksPerPhysicalBlock - lowestAlignedBlock) % logicalBlocksPerPhysicalBlock;
1543 }
1544
1546 // fill output buffer
1547 cachedData->BytesPerPhysicalSector = cachedData->BytesPerLogicalSector * logicalBlocksPerPhysicalBlock;
1548 cachedData->BytesOffsetForSectorAlignment = cachedData->BytesPerLogicalSector * lowestAlignedBlock;
1549
1550 //
1551 // Fill in the Logical Block Provisioning info. Note that we do not
1552 // use these fields; we use the Provisioning Type and LBPRZ fields from
1553 // the Logical Block Provisioning VPD page (0xB2).
1554 //
1555 cachedData->LBProvisioningEnabled = ReadCapacity16Data->LBPME;
1556 cachedData->LBProvisioningReadZeros = ReadCapacity16Data->LBPRZ;
1557
1558 TracePrint((TRACE_LEVEL_INFORMATION,
1559 TRACE_FLAG_INIT,
1560 "InterpretReadCapacity16Data: Device\'s LBP enabled = %d\n",
1561 cachedData->LBProvisioningEnabled));
1562 }
1563
1565}
ULONG ClasspCalculateLogicalSectorSize(_In_ PDEVICE_OBJECT Fdo, _In_ ULONG BytesPerBlockInBigEndian)
Definition: utils.c:1483
Definition: classpnp.h:785
ULONG BytesOffsetForSectorAlignment
Definition: classpnp.h:789
ULONG BytesPerPhysicalSector
Definition: classpnp.h:788
BOOLEAN LBProvisioningReadZeros
Definition: classpnp.h:791
BOOLEAN LBProvisioningEnabled
Definition: classpnp.h:790
ULONG BytesPerLogicalSector
Definition: classpnp.h:787
Referenced by ClassReadCapacity16().
◆ InterpretSenseInfoWithoutHistory()
| BOOLEAN InterpretSenseInfoWithoutHistory | ( | _In_ PDEVICE_OBJECT | Fdo, |
| _In_opt_ PIRP | OriginalRequest, | ||
| _In_ PSCSI_REQUEST_BLOCK | Srb, | ||
| UCHAR | MajorFunctionCode, | ||
| ULONG | IoDeviceCode, | ||
| ULONG | PreviousRetryCount, | ||
| _Out_ NTSTATUS * | Status, | ||
| _Out_opt_ _Deref_out_range_(0, MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS) LONGLONG * | RetryIn100nsUnits | ||
| ) |
Definition at line 12844 of file class.c.
12855{
12857 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
12858 LONGLONG tmpRetry = 0;
12860
12862 {
12863 SCSI_REQUEST_BLOCK tempSrb = {0};
12865
12866 // SAL annotations and ClassInitializeEx() both validate this
12868
12869 //
12870 // If class driver does not support extended SRB and this is
12871 // an extended SRB, convert to legacy SRB and pass to class
12872 // driver.
12873 //
12876 CLASS_SRB_STORAGE_REQUEST_BLOCK) == 0)) {
12878 srbPtr = &tempSrb;
12879 }
12880
12882 OriginalRequest,
12883 srbPtr,
12884 MajorFunctionCode,
12885 IoDeviceCode,
12886 PreviousRetryCount,
12887 NULL,
12888 Status,
12889 &tmpRetry);
12890 }
12891 else
12892 {
12893 ULONG seconds = 0;
12894
12896 Srb,
12897 MajorFunctionCode,
12898 IoDeviceCode,
12899 PreviousRetryCount,
12900 Status,
12901 &seconds);
12902 tmpRetry = ((LONGLONG)seconds) * 1000 * 1000 * 10;
12903 }
12904
12905
12907 {
12908 *RetryIn100nsUnits = tmpRetry;
12909 }
12910 return retry;
12911}
_In_ PSCSI_REQUEST_BLOCK _In_opt_ PVOID _In_ ULONG _In_ BOOLEAN _In_opt_ WDFREQUEST OriginalRequest
Definition: cdrom.h:994
VOID ClasspConvertToScsiRequestBlock(_Out_ PSCSI_REQUEST_BLOCK Srb, _In_ PSTORAGE_REQUEST_BLOCK SrbEx)
Definition: utils.c:6559
_In_opt_ PIRP _In_ PSCSI_REQUEST_BLOCK _In_ UCHAR MajorFunctionCode
Definition: classpnp.h:484
_In_opt_ PIRP _In_ PSCSI_REQUEST_BLOCK _In_ UCHAR _In_ ULONG IoDeviceCode
Definition: classpnp.h:485
_In_opt_ PIRP _In_ PSCSI_REQUEST_BLOCK _In_ UCHAR _In_ ULONG _In_ ULONG PreviousRetryCount
Definition: classpnp.h:486
__callback PCLASS_INTERPRET_SENSE_INFO Interpret
Definition: classpnp.h:566
Referenced by ClassIoComplete(), ClassIoCompleteAssociated(), ClasspInitializeGesn(), ClasspMediaChangeDetectionCompletion(), ClasspPowerDownCompletion(), ClasspPowerUpCompletion(), and ClassSendSrbSynchronous().
◆ InterpretTransferPacketError()
| BOOLEAN InterpretTransferPacketError | ( | PTRANSFER_PACKET | Pkt | ) |
Definition at line 40 of file retry.c.
41{
43 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
44 ULONG timesAlreadyRetried;
47
48 /*
49 * Interpret the error using the returned sense info first.
50 */
51 Pkt->RetryIn100nsUnits = 0;
52
53
54 /*
55 * Pre-calculate the number of times the IO has already been
56 * retried, so that all InterpretSenseInfo routines get the right value.
57 */
59 {
60 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL, "Unhandled SRB Function %xh in error path for packet %p (did miniport change Srb.Cdb.OperationCode ?)", (ULONG)pCdb->CDB10.OperationCode, Pkt));
61 }
62
64
65 SCSI_REQUEST_BLOCK tempSrb = { 0 };
67
68 // SAL annotation and ClassInitializeEx() both validate this
70
71 //
72 // If class driver does not support extended SRB and this is
73 // an extended SRB, convert to legacy SRB and pass to class
74 // driver.
75 //
78 CLASS_SRB_STORAGE_REQUEST_BLOCK) == 0)) {
80 srbPtr = &tempSrb;
81 }
82
85 srbPtr,
86 IRP_MJ_SCSI,
87 0,
88 timesAlreadyRetried,
91 &Pkt->RetryIn100nsUnits);
92
93
94 } else {
95
96 //
97 // In this case, fdoData->InterpretSenseInfo == NULL so we must do our
98 // own error code and sense info processing.
99 //
100
106 UCHAR additionalSenseQual = 0;
107
109
111 senseInfoBufferLength,
113 &senseKey,
114 &additionalSenseCode,
115 &additionalSenseQual);
116
118
119 ULONG retryIntervalSeconds = 0;
120 /*
121 * This is an Ejection Control SRB. Interpret its sense info specially.
122 */
123 shouldRetry = ClassInterpretSenseInfo(
126 IRP_MJ_SCSI,
127 0,
128 timesAlreadyRetried,
130 &retryIntervalSeconds);
131
132 if (shouldRetry) {
133 /*
134 * If the device is not ready, wait at least 2 seconds before retrying.
135 */
137
139
142 setRetryIntervalSeconds = TRUE;
143 }
144 }
145
146 if (!setRetryIntervalSeconds && (SRB_STATUS(Pkt->Srb->SrbStatus) == SRB_STATUS_SELECTION_TIMEOUT)) {
147 setRetryIntervalSeconds = TRUE;
148 }
149
150 if (setRetryIntervalSeconds) {
151 retryIntervalSeconds = MAX(retryIntervalSeconds, 2);
152 }
153 }
154
155 if (shouldRetry)
156 {
157 Pkt->RetryIn100nsUnits = retryIntervalSeconds;
158 Pkt->RetryIn100nsUnits *= 1000 * 1000 * 10;
159 }
160
161 }
164
165 ULONG retryIntervalSeconds = 0;
166 /*
167 * This is an Mode Sense SRB. Interpret its sense info specially.
168 */
169 shouldRetry = ClassInterpretSenseInfo(
172 IRP_MJ_SCSI,
173 0,
174 timesAlreadyRetried,
176 &retryIntervalSeconds);
177 if (shouldRetry) {
178 /*
179 * If the device is not ready, wait at least 2 seconds before retrying.
180 */
182
186 setRetryIntervalSeconds = TRUE;
187 }
188 }
189
190 if (!setRetryIntervalSeconds && (SRB_STATUS(Pkt->Srb->SrbStatus) == SRB_STATUS_SELECTION_TIMEOUT)) {
191 setRetryIntervalSeconds = TRUE;
192 }
193
194 if (setRetryIntervalSeconds) {
195 retryIntervalSeconds = MAX(retryIntervalSeconds, 2);
196 }
197 }
198
199 /*
200 * Some special cases for mode sense.
201 */
203 shouldRetry = TRUE;
204 }
206 /*
207 * This is a HACK.
208 * Atapi returns SRB_STATUS_DATA_OVERRUN when it really means
209 * underrun (i.e. success, and the buffer is longer than needed).
210 * So treat this as a success.
211 * When the caller of this function sees that the status was changed to success,
212 * it will add the transferred length to the original irp.
213 */
215 shouldRetry = FALSE;
216 }
217
218 if (shouldRetry)
219 {
220 Pkt->RetryIn100nsUnits = retryIntervalSeconds;
221 Pkt->RetryIn100nsUnits *= 1000 * 1000 * 10;
222 }
223
224 }
227
228 ULONG retryIntervalSeconds = 0;
229
230 /*
231 * This is a Drive Capacity SRB. Interpret its sense info specially.
232 */
233 shouldRetry = ClassInterpretSenseInfo(
236 IRP_MJ_SCSI,
237 0,
238 timesAlreadyRetried,
240 &retryIntervalSeconds);
242 shouldRetry = TRUE;
243 }
244#if (NTDDI_VERSION >= NTDDI_WINBLUE)
246
248
249 if (shouldRetry) {
250 //
251 // For requests that have timed-out we may only perform a limited
252 // number of retries. This is typically less than the general
253 // number of retries allowed.
254 //
256 shouldRetry = FALSE;
257 } else {
259 //
260 // We expect to be able to retry if there are some general retries remaining.
261 //
262 }
263 }
264 }
265#endif
266
267 if (shouldRetry)
268 {
269 Pkt->RetryIn100nsUnits = retryIntervalSeconds;
270 Pkt->RetryIn100nsUnits *= 1000 * 1000 * 10;
271 }
272
273 }
275
276 ULONG retryIntervalSeconds = 0;
277 /*
278 * This is a Read/Write Data packet.
279 */
281
284 origCurrentSp->MajorFunction,
285 0,
286 timesAlreadyRetried,
288 &retryIntervalSeconds);
289
290 /*
291 * Deal with some special cases.
292 */
294 /*
295 * We are in extreme low-memory stress.
296 * We will retry in smaller chunks.
297 */
298 shouldRetry = TRUE;
299 }
302 /*
303 * We are still verifying a (possibly) reloaded disk/cdrom.
304 * So retry the request.
305 */
307 shouldRetry = TRUE;
308
309 }
310#if (NTDDI_VERSION >= NTDDI_WINBLUE)
312
314
315 if (shouldRetry) {
316 //
317 // For requests that have timed-out we may only perform a limited
318 // number of retries. This is typically less than the general
319 // number of retries allowed.
320 //
322 shouldRetry = FALSE;
323 } else {
325 //
326 // We expect to be able to retry if there are some general retries remaining.
327 //
328 }
329 }
330 }
331#endif
332
333 if (shouldRetry)
334 {
335 Pkt->RetryIn100nsUnits = retryIntervalSeconds;
336 Pkt->RetryIn100nsUnits *= 1000 * 1000 * 10;
337 }
338
340
341 ULONG retryIntervalSeconds = 0;
342
344
345 shouldRetry = ClassInterpretSenseInfo(
348 IRP_MJ_SCSI,
349 0,
350 timesAlreadyRetried,
352 &retryIntervalSeconds);
353
354 if (shouldRetry) {
355
356 Pkt->RetryIn100nsUnits = retryIntervalSeconds;
357 Pkt->RetryIn100nsUnits *= 1000 * 1000 * 10;
358
359 } else {
360
362
365
367
368 //
369 // If this is a data underrun condition (i.e. target truncated the offload data transfer),
370 // the SenseData's Information field may have the TransferCount.
371 //
373 (additionalSenseCode == SCSI_ADSENSE_COPY_TARGET_DEVICE_ERROR && additionalSenseQual == SCSI_SENSEQ_DATA_UNDERRUN)) {
374
375 //
376 // Sense data in Descriptor format
377 //
379
381 UCHAR startBufferLength = 0;
382
383
386 &startBuffer,
387 &startBufferLength)) {
388 UCHAR outType;
390 UCHAR outBufferLength = 0;
391
393
394 if (ScsiGetNextSenseDescriptorByType(startBuffer,
395 startBufferLength,
396 typeList,
397 ARRAYSIZE(typeList),
398 &outType,
399 &outBuffer,
400 &outBufferLength)) {
401
403
405 REVERSE_BYTES_QUAD(&information, &(((PSCSI_SENSE_DESCRIPTOR_INFORMATION)outBuffer)->Information));
406 isInformationValid = TRUE;
407 }
408
409 } else {
410
411 //
412 // ScsiGetNextDescriptorByType should only return a type that is specified by us.
413 //
415 }
416 }
417 }
418 } else {
419
420 //
421 // Sense data in Fixed format
422 //
424 isInformationValid = TRUE;
425 }
426
427 if (isInformationValid) {
429 }
430 }
431 }
432 }
433 }
434
435 }
436 else {
437 TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL, "Unhandled SRB Function %xh in error path for packet %p (did miniport change Srb.Cdb.OperationCode ?)", (ULONG)pCdb->CDB10.OperationCode, Pkt));
438 }
439 }
440
441 return shouldRetry;
442}
FORCEINLINE BOOLEAN ClasspIsOffloadDataTransferCommand(_In_ PCDB Cdb)
Definition: classp.h:2087
FORCEINLINE BOOLEAN ClasspTransferPacketGetNumberOfRetriesDone(_In_ PTRANSFER_PACKET Pkt, _In_ PCDB Cdb, _Out_ PULONG TimesAlreadyRetried)
Definition: classp.h:2459
FORCEINLINE PCDB ClasspTransferPacketGetCdb(_In_ PTRANSFER_PACKET Pkt)
Definition: classp.h:2445
#define SCSI_SENSE_DESCRIPTOR_TYPE_INFORMATION
Definition: scsi.h:630
#define SCSI_SENSE_OPTIONS_FIXED_FORMAT_IF_UNKNOWN_FORMAT_INDICATED
Definition: scsi.h:3885
#define SCSI_ADSENSE_COPY_TARGET_DEVICE_ERROR
Definition: scsi.h:657
Definition: scsi.h:2736
Referenced by TransferPktComplete().
◆ PORT_ALLOCATED_SENSE_EX()
| FORCEINLINE BOOLEAN PORT_ALLOCATED_SENSE_EX | ( | _In_ PFUNCTIONAL_DEVICE_EXTENSION | FdoExtension, |
| _In_ PSTORAGE_REQUEST_BLOCK_HEADER | Srb | ||
| ) |
Definition at line 2547 of file classp.h.
2551{
2555 );
2556}
Referenced by _Success_(), ClasspMediaChangeDetectionCompletion(), ClassSendSrbSynchronous(), TransferPacketRetryTimerDpc(), and TransferPktComplete().
◆ RetryRequest()
| VOID RetryRequest | ( | PDEVICE_OBJECT | DeviceObject, |
| PIRP | Irp, | ||
| PSCSI_REQUEST_BLOCK | Srb, | ||
| BOOLEAN | Associated, | ||
| LONGLONG | TimeDelta100ns | ||
| ) |
Definition at line 359 of file obsolete.c.
366{
369 ULONG transferByteCount;
370 ULONG dataTransferLength;
372
373 // This function is obsolete but is still used by some of our class drivers.
374 // TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL, "RetryRequest is OBSOLETE !"));
375
376 //
377 // Determine the transfer count of the request. If this is a read or a
378 // write then the transfer count is in the Irp stack. Otherwise assume
379 // the MDL contains the correct length. If there is no MDL then the
380 // transfer length must be zero.
381 //
382
383 dataTransferLength = SrbGetDataTransferLength(srbHeader);
386
389
391
392 //
393 // Note this assumes that only read and write requests are spilt and
394 // other request do not need to be. If the data buffer address in
395 // the MDL and the SRB don't match then transfer length is most
396 // likely incorrect.
397 //
398
401 transferByteCount = Irp->MdlAddress->ByteCount;
402
403 } else {
404
405 transferByteCount = 0;
406 }
407
408 //
409 // this is a safety net. this should not normally be hit, since we are
410 // not guaranteed to be an fdoExtension
411 //
412
414
415 //
416 // Reset byte count of transfer in SRB Extension.
417 //
418
419 SrbSetDataTransferLength(srbHeader, transferByteCount);
420
421 //
422 // Zero SRB statuses.
423 //
424
425 srbHeader->SrbStatus = 0;
426 SrbSetScsiStatus(srbHeader, 0);
427
428 //
429 // If this is the last retry, then disable all the special flags.
430 //
431
433 //
434 // Set the no disconnect flag, disable synchronous data transfers and
435 // disable tagged queuing. This fixes some errors.
436 // NOTE: Cannot clear these flags, just add to them
437 //
438
439 SrbSetSrbFlags(srbHeader,
442
444 }
445
446
447 //
448 // Set up major SCSI function.
449 //
450
452
453 //
454 // Save SRB address in next stack for port driver.
455 //
456
458
459 if (Associated){
461 }
462 else {
464 }
465
467 return;
468} // end RetryRequest()
VOID ClassRetryRequest(IN PDEVICE_OBJECT SelfDeviceObject, IN PIRP Irp, _In_ _In_range_(0, MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS) IN LONGLONG TimeDelta100ns)
Definition: class.c:12317
NTSTATUS NTAPI ClassIoCompleteAssociated(IN PDEVICE_OBJECT Fdo, IN PIRP Irp, IN PVOID Context)
Definition: obsolete.c:111
FORCEINLINE VOID SrbSetQueueTag(_In_ PVOID Srb, _In_ ULONG QueueTag)
Definition: srbhelper.h:861
Referenced by ClassIoComplete(), ClassIoCompleteAssociated(), and ClassReadDriveCapacity().
◆ RetryTransferPacket()
| BOOLEAN RetryTransferPacket | ( | PTRANSFER_PACKET | Pkt | ) |
Definition at line 453 of file retry.c.
454{
455 BOOLEAN packetDone;
457 PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)Pkt->Fdo->DeviceExtension;
458 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
460
461#if !defined(__REACTOS__) && NTDDI_VERSION >= NTDDI_WINBLUE
464
466 //We've already retried this the maximum times. Bail out.
468 }
470 }
471 else {
474 }
475#else
478#endif
479
480 TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL, "retrying failed transfer (pkt=%ph, op=%s)", Pkt, DBGGETSCSIOPSTR(Pkt->Srb)));
481
482 if (!fdoData->DisableThrottling) {
483
484 //
485 // If this is the last retry, then turn off disconnect, sync transfer,
486 // and tagged queuing. On all other retries, leave the original settings.
487 // Do not apply this for thin provisioning soft threshold errors, since
488 // they should succeed as soon as they're retried on the right IT nexus.
489 //
491 scaleDown = TRUE;
492 }
493
494#if (NTDDI_VERSION >= NTDDI_WINBLUE)
495 //
496 // If this request previously timed-out and there are no more retries left
497 // for timed-out requests, then we should also apply the scale down.
498 //
500 scaleDown = TRUE;
501 }
502#endif
503 }
504
505
506 if (scaleDown) {
507 /*
508 * Tone down performance on the retry.
509 * This increases the chance for success on the retry.
510 * We've seen instances of drives that fail consistently but then start working
511 * once this scale-down is applied.
512 */
517 }
518
520
521 UCHAR cdbOpcode = 0;
523
524 if (pCdb) {
525 cdbOpcode = pCdb->CDB10.OperationCode;
526 isReadWrite = IS_SCSIOP_READWRITE(cdbOpcode);
527 }
528
530 ( (cdbOpcode == SCSIOP_WRITE6 ) ||
531 (cdbOpcode == SCSIOP_WRITE ) ||
532 (cdbOpcode == SCSIOP_WRITE12) ||
533 (cdbOpcode == SCSIOP_WRITE16) )) {
534
535 /* don't retry writes in super-low-memory conditions if the
536 * driver must serialize against StartIO. This is because
537 * some write methods used in such drivers cannot accept
538 * random-sized writes. (i.e CD-RW in packet writing mode)
539 * Reads, however, are always safe to split up.
540 */
542 packetDone = TRUE;
543 }
545 /*
546 * This should never happen under normal circumstances.
547 * The memory manager guarantees that at least four pages will
548 * be available to allow forward progress in the port driver.
549 * So a one-page transfer should never fail with insufficient resources.
550 *
551 * However, it is possible to get in here with virtual storage
552 * or thin provisioned storage for example.
553 * A single sector write can trigger an allocation request and
554 * presently a forward progress guarantee is not provided.
555 * VHD also may have some limitations in forward progress guarantee.
556 * And USB too might also fall into this category.
557 */
559 packetDone = TRUE;
560 }
561 else {
562 /*
563 * We are in low-memory stress.
564 * Start the low-memory retry state machine, which tries to
565 * resend the packet in little one-page chunks.
566 */
573 packetDone = FALSE;
574 }
575 }
576 else {
577 /*
578 * Retry the packet by simply resending it after a delay.
579 * Put the packet back in the pending queue and
580 * schedule a timer to retry the transfer.
581 *
582 * Do not call SetupReadWriteTransferPacket again because:
583 * (1) The minidriver may have set some bits
584 * in the SRB that it needs again and
585 * (2) doing so would reset numRetries.
586 *
587 * BECAUSE we do not call SetupReadWriteTransferPacket again,
588 * we have to reset a couple fields in the SRB that
589 * some miniports overwrite when they fail an SRB.
590 */
591
594
596
597 packetDone = FALSE;
598 }
599
600 return packetDone;
601}
BOOLEAN ClasspIsThinProvisioningError(_In_ PSCSI_REQUEST_BLOCK _Srb)
Definition: utils.c:9127
VOID TransferPacketQueueRetryDpc(PTRANSFER_PACKET Pkt)
Definition: retry.c:604
VOID InitLowMemRetry(PTRANSFER_PACKET Pkt, PVOID BufPtr, ULONG Len, LARGE_INTEGER TargetLocation)
Definition: retry.c:670
UCHAR NumThinProvisioningRetries
Definition: classp.h:517
Referenced by TransferPktComplete().
◆ ServiceTransferRequest()
| NTSTATUS ServiceTransferRequest | ( | PDEVICE_OBJECT | Fdo, |
| PIRP | Irp, | ||
| BOOLEAN | PostToDpc | ||
| ) |
Definition at line 3341 of file class.c.
3371{
3374 PSTORAGE_ADAPTER_DESCRIPTOR adapterDesc = commonExtension->PartitionZeroExtension->AdapterDescriptor;
3375 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
3376 IO_PAGING_PRIORITY priority = (TEST_FLAG(Irp->Flags, IRP_PAGING_IO)) ? IoGetPagingIoPriority(Irp) : IoPagingPriorityInvalid;
3379 KIRQL oldIrql;
3382
3383 /*
3384 * Initialize IRP status for the master IRP to
3385 * - STATUS_FT_READ_FROM_COPY if it's a copy-specific read
3386 * - STATUS_SUCCESS otherwise.
3387 *
3388 * This is required. When Classpnp determines the status for the master IRP
3389 * when completing child IRPs, the call to IoSetMasterIrpStatus
3390 * will be functioning properly (See TransferPktComplete function)
3391 *
3392 * Note:
3393 * If the IRP is a copy-specific read, File System already initialized the IRP status
3394 * to be STATUS_FT_READ_FROM_COPY. However, this can be changed when the IRP arrives
3395 * at Classpnp. It's possible that other drivers in the stack may initialize the
3396 * IRP status field to other values before forwarding the IRP down the stack.
3397 * To be defensive, we initialize the IRP status to either STATUS_FT_READ_FROM_COPY
3398 * if it's a copy-specific read, or STATUS_SUCCESS otherwise.
3399 */
3404 } else {
3406 }
3407
3408 //
3409 // If this is a high priority request, hold off all other Io requests
3410 //
3411
3413 {
3415
3417 {
3418 //
3419 // Entering throttle mode
3420 //
3421
3423 }
3424
3425 fdoData->NumHighPriorityPagingIo++;
3427
3429 }
3430 else
3431 {
3433 {
3434 //
3435 // This request wasn't flagged as critical and atleast one critical request
3436 // is currently outstanding. Queue this request until all of those are done
3437 // but only if the interleave threshold has been reached
3438 //
3439
3441
3443 {
3445 {
3446 deferClientIrp = TRUE;
3447 }
3448 else
3449 {
3450 fdoData->MaxInterleavedNormalIo--;
3451 }
3452 }
3453
3455 }
3456 }
3457
3458 if (!deferClientIrp)
3459 {
3464 PTRANSFER_PACKET pkt;
3465 SINGLE_LIST_ENTRY pktList;
3466 PSINGLE_LIST_ENTRY slistEntry;
3467 ULONG hwMaxXferLen;
3468 ULONG numPackets;
3470
3471
3472 /*
3473 * We precomputed fdoData->HwMaxXferLen using (MaximumPhysicalPages-1).
3474 * If the buffer is page-aligned, that's one less page crossing so we can add the page back in.
3475 * Note: adapters that return MaximumPhysicalPages=0x10 depend on this to
3476 * transfer aligned 64K requests in one piece.
3477 * Also note: make sure adding PAGE_SIZE back in doesn't wrap to zero.
3478 */
3480 hwMaxXferLen = fdoData->HwMaxXferLen;
3481 }
3482 else {
3485 }
3486
3487 /*
3488 * Compute the number of hw xfers we'll have to do.
3489 * Calculate this without allowing for an overflow condition.
3490 */
3492 numPackets = entireXferLen/hwMaxXferLen;
3493 if (entireXferLen % hwMaxXferLen){
3494 numPackets++;
3495 }
3496
3497 /*
3498 * Use our 'simple' slist functions since we don't need interlocked.
3499 */
3500 SimpleInitSlistHdr(&pktList);
3501
3502 if (driverUsesStartIO) {
3503 /*
3504 * special case: StartIO-based writing must stay serialized, so just
3505 * re-use one packet.
3506 */
3508 if (pkt) {
3510 i = 1;
3511 } else {
3512 i = 0;
3513 }
3514 } else {
3515 /*
3516 * First get all the TRANSFER_PACKETs that we'll need at once.
3517 */
3520 if (pkt){
3522 }
3523 else {
3524 break;
3525 }
3526 }
3527 }
3528
3529
3531 (!driverUsesStartIO)) {
3532 NTSTATUS pktStat;
3533
3534 /*
3535 * The IoStatus.Information field will be incremented to the
3536 * transfer length as the pieces complete.
3537 */
3538 Irp->IoStatus.Information = 0;
3539
3540 /*
3541 * Store the number of transfer pieces inside the original IRP.
3542 * It will be used to count down the pieces as they complete.
3543 */
3545
3546 /*
3547 * For the common 1-packet case, we want to allow for an optimization by BlkCache
3548 * (and also potentially synchronous storage drivers) which may complete the
3549 * downward request synchronously.
3550 * In that synchronous completion case, we want to _not_ mark the original irp pending
3551 * and thereby save on the top-level APC.
3552 * It's critical to coordinate this with the completion routine so that we mark the original irp
3553 * pending if-and-only-if we return STATUS_PENDING for it.
3554 */
3555 if (numPackets > 1){
3558 }
3559 else {
3561 }
3562
3563 /*
3564 * Transmit the pieces of the transfer.
3565 */
3566 while (entireXferLen > 0){
3568
3569 /*
3570 * Set up a TRANSFER_PACKET for this piece and send it.
3571 */
3572 slistEntry = SimplePopSlist(&pktList);
3573 NT_ASSERT(slistEntry);
3575 SetupReadWriteTransferPacket( pkt,
3576 bufPtr,
3577 thisPieceLen,
3578 targetLocation,
3579 Irp);
3580
3581 //
3582 // If the IRP needs to be split, then we need to use a partial MDL.
3583 // This prevents problems if the same MDL is mapped multiple times.
3584 //
3585 if (numPackets > 1) {
3587 }
3588
3589 /*
3590 * When an IRP is completed, the completion routine checks to see if there
3591 * is a deferred IRP ready to sent down (assuming that there are no non-idle
3592 * requests waiting to be serviced). If such a deferred IRP is available, it
3593 * is sent down using this routine. However, if the lower driver completes
3594 * the request inline, there is a potential for multiple deferred IRPs being
3595 * sent down in the context of the same completion thread, thus exhausting
3596 * the call stack.
3597 * In order to prevent this from happening, we need to ensure that deferred
3598 * IRPs that are dequeued in the context of a request's completion routine
3599 * get posted to a DPC.
3600 */
3601 if (PostToDpc) {
3602
3603 pkt->RetryIn100nsUnits = 0;
3604 TransferPacketQueueRetryDpc(pkt);
3606
3607 } else {
3608
3609 pktStat = SubmitTransferPacket(pkt);
3610
3611 /*
3612 * If any of the packets completes with pending, we MUST return pending.
3613 * Also, if a packet completes with an error, return pending; this is because
3614 * in the completion routine we mark the original irp pending if the packet failed
3615 * (since we may retry, thereby switching threads).
3616 */
3619 }
3620 }
3621
3622 entireXferLen -= thisPieceLen;
3623 bufPtr += thisPieceLen;
3624 targetLocation.QuadPart += thisPieceLen;
3625 }
3627 }
3629 /*
3630 * We were unable to get all the TRANSFER_PACKETs we need,
3631 * but we did get at least one.
3632 * That means that we are in extreme low-memory stress.
3633 * We'll try doing this transfer using a single packet.
3634 * The port driver is certainly also in stress, so use one-page
3635 * transfers.
3636 */
3637
3638 /*
3639 * Free all but one of the TRANSFER_PACKETs.
3640 */
3642 slistEntry = SimplePopSlist(&pktList);
3643 NT_ASSERT(slistEntry);
3646 }
3647
3648 /*
3649 * Get the single TRANSFER_PACKET that we'll be using.
3650 */
3651 slistEntry = SimplePopSlist(&pktList);
3652 NT_ASSERT(slistEntry);
3655
3656 if (!driverUsesStartIO) {
3657 TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_RW, "Insufficient packets available in ServiceTransferRequest - entering lowMemRetry with pkt=%p.", pkt));
3658 }
3659
3660 /*
3661 * Set the number of transfer packets (one)
3662 * inside the original irp.
3663 */
3664 Irp->IoStatus.Information = 0;
3667
3668 /*
3669 * Set up the TRANSFER_PACKET for a lowMem transfer and launch.
3670 */
3671 SetupReadWriteTransferPacket( pkt,
3672 bufPtr,
3673 entireXferLen,
3674 targetLocation,
3675 Irp);
3676
3677 InitLowMemRetry(pkt, bufPtr, entireXferLen, targetLocation);
3678 StepLowMemRetry(pkt);
3680 }
3681 else {
3682 /*
3683 * We were unable to get ANY TRANSFER_PACKETs.
3684 * Defer this client irp until some TRANSFER_PACKETs free up.
3685 */
3686 TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_RW, "No packets available in ServiceTransferRequest - deferring transfer (Irp=%p)...", Irp));
3687
3689 {
3691
3693 {
3694 fdoData->MaxInterleavedNormalIo = 0;
3695 }
3696 else
3697 {
3699 }
3700
3701 fdoData->NumHighPriorityPagingIo--;
3702
3704 {
3705 LARGE_INTEGER period;
3706
3707 //
3708 // Exiting throttle mode
3709 //
3710
3712
3714 fdoData->LongestThrottlePeriod.QuadPart = max(fdoData->LongestThrottlePeriod.QuadPart, period.QuadPart);
3715 }
3716
3718 }
3719
3720 deferClientIrp = TRUE;
3721 }
3722 }
3723 _Analysis_assume_(deferClientIrp);
3724 if (deferClientIrp)
3725 {
3729 }
3730
3732
3734}
VOID EnqueueFreeTransferPacket(PDEVICE_OBJECT Fdo, __drv_aliasesMem PTRANSFER_PACKET Pkt)
Definition: xferpkt.c:529
FORCEINLINE BOOLEAN SimpleIsSlistEmpty(SINGLE_LIST_ENTRY *SListHdr)
Definition: classp.h:1229
VOID EnqueueDeferredClientIrp(PDEVICE_OBJECT Fdo, PIRP Irp)
Definition: clntirp.c:78
VOID TransferPacketQueueRetryDpc(PTRANSFER_PACKET Pkt)
Definition: retry.c:604
VOID InitLowMemRetry(PTRANSFER_PACKET Pkt, PVOID BufPtr, ULONG Len, LARGE_INTEGER TargetLocation)
Definition: retry.c:670
VOID SetupReadWriteTransferPacket(PTRANSFER_PACKET pkt, PVOID Buf, ULONG Len, LARGE_INTEGER DiskLocation, PIRP OriginalIrp)
Definition: xferpkt.c:718
IO_PAGING_PRIORITY FASTCALL IoGetPagingIoPriority(IN PIRP Irp)
Definition: irp.c:1780
LARGE_INTEGER LongestThrottlePeriod
Definition: classp.h:846
ULONG NumHighPriorityPagingIo
Definition: classp.h:826
enum _IO_PAGING_PRIORITY IO_PAGING_PRIORITY
Referenced by ClasspServiceIdleRequest(), ClassReadWrite(), ClassSplitRequest(), and TransferPktComplete().
◆ SetupDriveCapacityTransferPacket()
| VOID SetupDriveCapacityTransferPacket | ( | TRANSFER_PACKET * | Pkt, |
| PVOID | ReadCapacityBuffer, | ||
| ULONG | ReadCapacityBufferLen, | ||
| PKEVENT | SyncEventPtr, | ||
| PIRP | OriginalIrp, | ||
| BOOLEAN | Use16ByteCdb | ||
| ) |
Definition at line 1480 of file xferpkt.c.
1486{
1488 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
1489 PCDB pCdb;
1490 ULONG srbLength;
1492
1496 } else {
1497 srbLength = fdoData->SrbTemplate->Length;
1498 }
1500
1505
1506
1510
1511 SrbAssignSrbFlags(Pkt->Srb, fdoExt->SrbFlags | SRB_FLAGS_DATA_IN | SRB_FLAGS_DISABLE_SYNCH_TRANSFER | SRB_FLAGS_NO_QUEUE_FREEZE);
1512
1514 if (pCdb) {
1521 } else {
1524 }
1525 }
1526
1529
1532#if !defined(__REACTOS__) && NTDDI_VERSION >= NTDDI_WINBLUE
1534#endif
1535
1538}
Definition: scsi.h:2794
BOOLEAN CompleteOriginalIrpWhenLastPacketCompletes
Definition: classp.h:510
Referenced by ClassReadDriveCapacity().
◆ SetupEjectionTransferPacket()
| VOID SetupEjectionTransferPacket | ( | TRANSFER_PACKET * | Pkt, |
| BOOLEAN | PreventMediaRemoval, | ||
| PKEVENT | SyncEventPtr, | ||
| PIRP | OriginalIrp | ||
| ) |
Definition at line 1315 of file xferpkt.c.
1319{
1321 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
1322 PCDB pCdb;
1323 ULONG srbLength;
1324
1325 PAGED_CODE();
1326
1330 } else {
1331 srbLength = fdoData->SrbTemplate->Length;
1332 }
1334
1341
1342 SrbAssignSrbFlags(Pkt->Srb, fdoExt->SrbFlags | SRB_FLAGS_DISABLE_SYNCH_TRANSFER | SRB_FLAGS_NO_QUEUE_FREEZE);
1343
1345 if (pCdb) {
1347 pCdb->MEDIA_REMOVAL.Prevent = PreventMediaRemoval;
1348 }
1349
1352
1357}
◆ SetupModeSelectTransferPacket()
| VOID SetupModeSelectTransferPacket | ( | TRANSFER_PACKET * | Pkt, |
| PKEVENT | SyncEventPtr, | ||
| PVOID | ModeSelectBuffer, | ||
| UCHAR | ModeSelectBufferLen, | ||
| BOOLEAN | SavePages, | ||
| PIRP | OriginalIrp | ||
| ) |
Definition at line 1425 of file xferpkt.c.
1432{
1434 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
1435 PCDB pCdb;
1436 ULONG srbLength;
1437
1441 } else {
1442 srbLength = fdoData->SrbTemplate->Length;
1443 }
1445
1454
1455 SrbAssignSrbFlags(Pkt->Srb, fdoExt->SrbFlags | SRB_FLAGS_DATA_OUT | SRB_FLAGS_DISABLE_SYNCH_TRANSFER | SRB_FLAGS_NO_QUEUE_FREEZE);
1456
1458 if (pCdb) {
1460 pCdb->MODE_SELECT.SPBit = SavePages;
1461 pCdb->MODE_SELECT.PFBit = 1;
1463 }
1464
1467
1472}
struct _CDB::_MODE_SELECT MODE_SELECT
Referenced by ClasspModeSelect().
◆ SetupModeSenseTransferPacket()
| VOID SetupModeSenseTransferPacket | ( | TRANSFER_PACKET * | Pkt, |
| PKEVENT | SyncEventPtr, | ||
| PVOID | ModeSenseBuffer, | ||
| UCHAR | ModeSenseBufferLen, | ||
| UCHAR | PageMode, | ||
| UCHAR | SubPage, | ||
| PIRP | OriginalIrp, | ||
| UCHAR | PageControl | ||
| ) |
Definition at line 1365 of file xferpkt.c.
1374{
1376 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
1377 PCDB pCdb;
1378 ULONG srbLength;
1379
1380 PAGED_CODE();
1381
1385 } else {
1386 srbLength = fdoData->SrbTemplate->Length;
1387 }
1389
1398
1399
1400 SrbAssignSrbFlags(Pkt->Srb, fdoExt->SrbFlags | SRB_FLAGS_DATA_IN | SRB_FLAGS_DISABLE_SYNCH_TRANSFER | SRB_FLAGS_NO_QUEUE_FREEZE);
1401
1403 if (pCdb) {
1406 pCdb->MODE_SENSE.SubPageCode = SubPage;
1409 }
1410
1413
1418}
Referenced by ClasspModeSense().
◆ SetupReadWriteTransferPacket()
| VOID SetupReadWriteTransferPacket | ( | PTRANSFER_PACKET | pkt, |
| PVOID | Buf, | ||
| ULONG | Len, | ||
| LARGE_INTEGER | DiskLocation, | ||
| PIRP | OriginalIrp | ||
| ) |
Definition at line 718 of file xferpkt.c.
723{
726 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
729 LARGE_INTEGER logicalBlockAddr;
730 ULONG numTransferBlocks;
731 PCDB pCdb;
732 ULONG srbLength;
734
737
738 /*
739 * This field is useful when debugging, since low-memory conditions are
740 * handled differently for CDROM (which is the only driver using StartIO)
741 */
743
744 /*
745 * Slap the constant SRB fields in from our pre-initialized template.
746 * We'll then only have to fill in the unique fields for this transfer.
747 * Tell lower drivers to sort the SRBs by the logical block address
748 * so that disk seeks are minimized.
749 */
753 } else {
754 srbLength = fdoData->SrbTemplate->Length;
755 }
761 //
762 // If the requested LBA is more than max ULONG set the
763 // QueueSortKey to the maximum value, so that these
764 // requests can be added towards the end of the queue.
765 //
766
768 }
771
772
774
775 /*
776 * Arrange values in CDB in big-endian format.
777 */
779 if (pCdb) {
785 } else {
793 }
794 }
795
796 /*
797 * Set SRB and IRP flags
798 */
803 }
805
806 /*
807 * Allow caching only if this is not a write-through request.
808 * If write-through and caching is enabled on the device, force
809 * media access.
810 * Ignore SL_WRITE_THROUGH for reads; it's only set because the file handle was opened with WRITE_THROUGH.
811 */
814 } else {
816 }
817
818 /*
819 * Remember the buf and len in the SRB because miniports
820 * can overwrite SRB.DataTransferLength and we may need it again
821 * for the retry.
822 */
826
831#if !defined(__REACTOS__) && NTDDI_VERSION >= NTDDI_WINBLUE
834#endif
835
836
837 if (pCdb) {
839 } else {
841 }
842}
Referenced by ServiceTransferRequest(), and StepLowMemRetry().
◆ SimpleInitSlistHdr()
| FORCEINLINE VOID SimpleInitSlistHdr | ( | SINGLE_LIST_ENTRY * | SListHdr | ) |
Definition at line 1211 of file classp.h.
1212{
1214}
Referenced by CleanupTransferPacketToWorkingSetSize(), and ServiceTransferRequest().
◆ SimpleIsSlistEmpty()
| FORCEINLINE BOOLEAN SimpleIsSlistEmpty | ( | SINGLE_LIST_ENTRY * | SListHdr | ) |
Definition at line 1229 of file classp.h.
Referenced by ServiceTransferRequest().
◆ SimplePopSlist()
| FORCEINLINE SINGLE_LIST_ENTRY * SimplePopSlist | ( | SINGLE_LIST_ENTRY * | SListHdr | ) |
Definition at line 1220 of file classp.h.
1221{
1223 if (sListEntry){
1226 }
1227 return sListEntry;
1228}
Referenced by CleanupTransferPacketToWorkingSetSize(), and ServiceTransferRequest().
◆ SimplePushSlist()
| FORCEINLINE VOID SimplePushSlist | ( | SINGLE_LIST_ENTRY * | SListHdr, |
| SINGLE_LIST_ENTRY * | SListEntry | ||
| ) |
Definition at line 1215 of file classp.h.
Referenced by CleanupTransferPacketToWorkingSetSize(), and ServiceTransferRequest().
◆ StepLowMemRetry()
| BOOLEAN StepLowMemRetry | ( | PTRANSFER_PACKET | Pkt | ) |
Definition at line 706 of file retry.c.
707{
708 BOOLEAN packetDone;
709
711 packetDone = TRUE;
712 }
713 else {
714 ULONG thisChunkLen;
716 {
717 /*
718 * Need the fdoData for the HwMaxXferLen
719 */
721 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
722
723 /*
724 * Need the adapterDesc to limit transfers based on byte count
725 */
727 PSTORAGE_ADAPTER_DESCRIPTOR adapterDesc = commonExtension->PartitionZeroExtension->AdapterDescriptor;
728
729 ULONG hwMaxXferLen;
730
731 /*
732 * special case: StartIO-based writing must stay serialized for performance
733 * and proper operations (i.e. sequential writing mode). If need more than
734 * one transfer to perform this operation, and it's a StartIO-based driver
735 * (such as CDROM), then just use a single packet and use the retry logic
736 * that's already built-in to the packet engine. Note that low-mem retry
737 * cannot be used directly because some write methods do not work if the
738 * writes are only PAGE_SIZE (i.e. packet writing may corrupt data).
739 */
741
742 /*
743 * We precomputed fdoData->HwMaxXferLen using (MaximumPhysicalPages-1).
744 * If the buffer is page-aligned, that's one less page crossing so we can add the page back in.
745 * Note: adapters that return MaximumPhysicalPages=0x10 depend on this to
746 * transfer aligned 64K requests in one piece.
747 * Also note: make sure adding PAGE_SIZE back in doesn't wrap to zero.
748 */
749
750 if (((ULONG_PTR)(Pkt->LowMemRetry_remainingBufPtr) & (PAGE_SIZE-1)) || (fdoData->HwMaxXferLen > 0xffffffff-PAGE_SIZE)){
751 hwMaxXferLen = fdoData->HwMaxXferLen;
752 }
753 else {
756 }
758 }
759 else {
760 /*
761 * Make sure the little chunk we send is <= a page length
762 * AND that it does not cross any page boundaries.
763 */
764 ULONG bytesToNextPageBoundary;
765 bytesToNextPageBoundary = PAGE_SIZE-(ULONG)((ULONG_PTR)Pkt->LowMemRetry_remainingBufPtr%PAGE_SIZE);
768 }
769
770
771 /*
772 * Set up the transfer packet for the new little chunk.
773 * This will reset numRetries so that we retry each chunk as required.
774 */
777 thisChunkLen,
780
784
785 //
786 // When running in low-memory stress, always use a partial MDL.
787 // This allows lower drivers to potentially map a smaller buffer.
788 //
790
792
793 packetDone = FALSE;
794 }
795
796 return packetDone;
797}
Referenced by RetryTransferPacket(), ServiceTransferRequest(), and TransferPktComplete().
◆ SubmitTransferPacket()
| NTSTATUS SubmitTransferPacket | ( | PTRANSFER_PACKET | Pkt | ) |
Definition at line 850 of file xferpkt.c.
851{
855 PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
857 PIO_STACK_LOCATION nextSp;
858
860
861 /*
862 * Attach the SRB to the IRP.
863 * The reused IRP's stack location has to be rewritten for each retry
864 * call because IoCompleteRequest clears the stack locations.
865 */
867
868
872
876
878 /*
879 * Only dereference the "original IRP"'s stack location
880 * if its a real client irp (as opposed to a static irp
881 * we're using just for result status for one of the non-IO scsi commands).
882 *
883 * For read/write, propagate the storage-specific IRP stack location flags
884 * (e.g. SL_OVERRIDE_VERIFY_VOLUME, SL_WRITE_THROUGH).
885 */
888 }
889
890 //
891 // If the request is not split, we can use the original IRP MDL. If the
892 // request needs to be split, we need to use a partial MDL. The partial MDL
893 // is needed because more than one driver might be mapping the same MDL
894 // and this causes problems.
895 //
898 } else {
899 IoBuildPartialMdl(Pkt->OriginalIrp->MdlAddress, Pkt->PartialMdl, SrbGetDataBuffer(Pkt->Srb), SrbGetDataTransferLength(Pkt->Srb));
901 }
902
903
906
907 //
908 // Set the original irp here for SFIO.
909 //
911
912 //
913 // No need to lock for IdlePrioritySupported, since it will
914 // be modified only at initialization time.
915 //
918 if (idleRequest) {
920 } else {
922 }
923 }
924
927}
FORCEINLINE VOID ClasspSrbSetOriginalIrp(_In_ PSTORAGE_REQUEST_BLOCK_HEADER Srb, _In_ PIRP Irp)
Definition: classp.h:2530
VOID NTAPI IoBuildPartialMdl(IN PMDL SourceMdl, IN PMDL TargetMdl, IN PVOID VirtualAddress, IN ULONG Length)
Definition: iomdl.c:96
Referenced by ClasspContinueOffloadWrite(), ClasspModeSelect(), ClasspModeSense(), ClasspReceivePopulateTokenInformation(), ClasspReceiveWriteUsingTokenInformation(), ClassReadDriveCapacity(), ServiceTransferRequest(), and TransferPacketRetryTimerDpc().
◆ TestDictionarySignature()
| BOOLEAN TestDictionarySignature | ( | IN PDICTIONARY | Dictionary | ) |
◆ TransferPacketQueueRetryDpc()
| VOID TransferPacketQueueRetryDpc | ( | PTRANSFER_PACKET | Pkt | ) |
Definition at line 604 of file retry.c.
605{
607
610 }
611 else {
612 LARGE_INTEGER timerPeriod;
613
614 NT_ASSERT(Pkt->RetryIn100nsUnits < 100 * 1000 * 1000 * 10); // sanity check -- 100 seconds is normally too long
618 }
619}
BOOLEAN NTAPI KeInsertQueueDpc(IN PKDPC Dpc, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
Definition: dpc.c:725
BOOLEAN NTAPI KeSetTimer(IN OUT PKTIMER Timer, IN LARGE_INTEGER DueTime, IN PKDPC Dpc OPTIONAL)
Definition: timerobj.c:282
Referenced by RetryTransferPacket(), ServiceTransferRequest(), and StepLowMemRetry().
Variable Documentation
◆ AllFdosList
|
extern |
Definition at line 29 of file data.c.
Referenced by ClassPnpStartDevice().
◆ BlockDescr
Definition at line 1996 of file classp.h.
Referenced by ConvertDataSetRangeToUnmapBlockDescr().
◆ ClassAddDevice
◆ ClassBadItems
|
extern |
Definition at line 43 of file data.c.
Referenced by ClassPnpStartDevice().
◆ ClassGuidQueryRegInfoEx
◆ ClassGuidSenseInfo2
◆ ClassGuidSrbSupport
◆ ClassGuidWorkingSet
◆ ClassLogResourceExhaustionEvent
| IO_WORKITEM_ROUTINE ClassLogResourceExhaustionEvent |
Definition at line 2306 of file classp.h.
Referenced by ClassQueueResourceExhaustionEventWorker().
◆ ClassLogThresholdEvent
| IO_WORKITEM_ROUTINE ClassLogThresholdEvent |
Definition at line 2298 of file classp.h.
Referenced by ClassQueueThresholdEventWorker().
◆ ClassMaxInterleavePerCriticalIo
|
extern |
Definition at line 88 of file class.c.
Referenced by ServiceTransferRequest(), and TransferPktComplete().
◆ ClasspLogIOEventWithContext
◆ ClasspPowerSettingCallback
| POWER_SETTING_CALLBACK ClasspPowerSettingCallback |
Definition at line 1619 of file classp.h.
Referenced by _Function_class_(), ClasspEnableIdlePower(), and ClasspInitializePolling().
◆ ClasspRetryRequestDpc
| KDEFERRED_ROUTINE ClasspRetryRequestDpc |
Definition at line 1644 of file classp.h.
Referenced by ClassPnpStartDevice().
◆ ClasspScreenOff
|
extern |
Definition at line 124 of file autorun.c.
Referenced by _Function_class_(), ClasspCanSendPollingIrp(), ClasspEnableTimer(), ClasspPrepareMcnIrp(), and ClasspUpdateTimerNoWakeTolerance().
◆ ClasspSendSynchronousCompletion
| IO_COMPLETION_ROUTINE ClasspSendSynchronousCompletion |
Definition at line 1410 of file classp.h.
Referenced by ClassSendSrbSynchronous().
◆ ClasspStartIo
| DRIVER_STARTIO ClasspStartIo |
Definition at line 1454 of file classp.h.
Referenced by _IRQL_requires_max_(), and ClasspStartIo().
◆ ClasspUpdateDiskProperties
| IO_WORKITEM_ROUTINE ClasspUpdateDiskProperties |
Definition at line 1714 of file classp.h.
Referenced by ClasspInternalSetMediaChangeState(), and ClassReadDriveCapacity().
◆ ClassReleaseQueueCompletion
| IO_COMPLETION_ROUTINE ClassReleaseQueueCompletion |
Definition at line 1586 of file classp.h.
Referenced by ClasspReleaseQueue().
◆ ClassUnload
| DRIVER_UNLOAD ClassUnload |
Definition at line 1356 of file classp.h.
Referenced by _IRQL_requires_max_(), ClassReleaseClientReference(), and LibraryUnloadClasses().
◆ CleanupTransferPacketToWorkingSetSizeWorker
| IO_WORKITEM_ROUTINE_EX CleanupTransferPacketToWorkingSetSizeWorker |
Definition at line 1745 of file classp.h.
Referenced by EnqueueFreeTransferPacket().
◆ CurrentBlockDescrIndex
Definition at line 1997 of file classp.h.
Referenced by ConvertDataSetRangeToUnmapBlockDescr().
◆ CurrentLbaCount
Definition at line 1999 of file classp.h.
Referenced by ConvertDataSetRangeToUnmapBlockDescr().
◆ DataSetRange
| _In_ PVOID _Inout_ PULONG _In_ ULONG _Inout_ PULONG _In_ ULONGLONG _Inout_ PDEVICE_DATA_SET_RANGE DataSetRange |
Definition at line 2001 of file classp.h.
Referenced by ConvertDataSetRangeToUnmapBlockDescr().
◆ DiskIdleTimeoutInMS
|
extern |
Definition at line 132 of file class.c.
Referenced by _Function_class_(), and ClasspEnableIdlePower().
◆ DriverEntry
◆ IdlePowerFDOList
|
extern |
Definition at line 113 of file class.c.
Referenced by _Function_class_(), _IRQL_requires_max_(), and ClasspEnableIdlePower().
◆ IdlePowerFDOListMutex
|
extern |
Definition at line 114 of file class.c.
Referenced by _Function_class_(), _IRQL_requires_max_(), and ClasspEnableIdlePower().
◆ Irp
◆ Length
◆ ListIdentifier
Definition at line 1758 of file classp.h.
Referenced by _IRQL_requires_max_(), and CRYPT_AsnDecodeCTL().
◆ Magic10000
|
extern |
◆ MaxBlockDescrCount
◆ MaxDuration
◆ MaximumListIdentifier
◆ MaxLbaCount
Definition at line 2000 of file classp.h.
Referenced by ConvertDataSetRangeToUnmapBlockDescr().
◆ MaxTokenOperationListIdentifier
|
extern |
Definition at line 107 of file class.c.
Referenced by _IRQL_requires_(), and ClasspContinueOffloadWrite().
◆ OriginalIrp
Definition at line 1757 of file classp.h.
Referenced by __drv_allocatesMem(), _IRQL_requires_max_(), ClasspPowerDownCompletion(), ClasspPowerUpCompletion(), SendDeviceUsageNotification(), SendDeviceUsageNotificationWorker(), SetupDriveCapacityTransferPacket(), SetupEjectionTransferPacket(), SetupModeSelectTransferPacket(), SetupModeSenseTransferPacket(), and SetupReadWriteTransferPacket().
◆ Pkt
| _In_ PTRANSFER_PACKET Pkt |
Definition at line 1754 of file classp.h.
Referenced by _IRQL_requires_max_(), ClasspTransferPacketGetCdb(), ClasspTransferPacketGetNumberOfRetriesDone(), ClasspTransferPacketGetSenseInfoBuffer(), ClasspTransferPacketGetSenseInfoBufferLength(), DestroyTransferPacket(), EnqueueFreeTransferPacket(), HistoryLogReturnedPacket(), HistoryLogSendPacket(), InitLowMemRetry(), InterpretTransferPacketError(), RetryTransferPacket(), SetupDriveCapacityTransferPacket(), SetupEjectionTransferPacket(), SetupModeSelectTransferPacket(), SetupModeSenseTransferPacket(), SetupReadWriteTransferPacket(), StepLowMemRetry(), SubmitTransferPacket(), and TransferPacketQueueRetryDpc().
◆ PowerSettingNotificationHandle
|
extern |
Definition at line 119 of file class.c.
Referenced by ClasspEnableIdlePower(), and DllUnload().
◆ RegistryPath
◆ RemoveTrackingAllocateRoutine
| RTL_GENERIC_ALLOCATE_ROUTINE RemoveTrackingAllocateRoutine |
Definition at line 2402 of file classp.h.
Referenced by ClasspInitializeRemoveTracking().
◆ RemoveTrackingCompareRoutine
| RTL_GENERIC_COMPARE_ROUTINE RemoveTrackingCompareRoutine |
Definition at line 2400 of file classp.h.
Referenced by ClasspInitializeRemoveTracking().
◆ RemoveTrackingFreeRoutine
| RTL_GENERIC_FREE_ROUTINE RemoveTrackingFreeRoutine |
Definition at line 2404 of file classp.h.
Referenced by ClasspInitializeRemoveTracking().
◆ ScreenStateNotificationHandle
|
extern |
Definition at line 124 of file class.c.
Referenced by ClasspInitializePolling(), and DllUnload().
◆ Srb
Definition at line 1949 of file classp.h.
Referenced by ClasspSrbSetOriginalIrp(), FREE_PORT_ALLOCATED_SENSE_BUFFER_EX(), and PORT_ALLOCATED_SENSE_EX().
◆ TokenOperationListIdentifier
Definition at line 108 of file class.c.
Referenced by ClasspContinueOffloadWrite().
◆ TotalSectorsProcessed
◆ TransferPacketRetryTimerDpc
| KDEFERRED_ROUTINE TransferPacketRetryTimerDpc |
Definition at line 1727 of file classp.h.
Referenced by TransferPacketQueueRetryDpc().
◆ TransferPktComplete
| IO_COMPLETION_ROUTINE TransferPktComplete |
Definition at line 1724 of file classp.h.
Referenced by SubmitTransferPacket().
