#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()
| __drv_allocatesMem | ( | Mem | ) |
Definition at line 1476 of file exfuncs.h.
1484{
1486
1487 Lookaside->L.TotalAllocates++;
1488#ifdef NONAMELESSUNION
1489#if defined(_WIN2K_COMPAT_SLIST_USAGE) && defined(_X86_)
1491 &Lookaside->Lock__ObsoleteButDoNotDelete);
1492#else
1494#endif
1496 Lookaside->L.u2.AllocateMisses++;
1498 Lookaside->L.Size,
1499 Lookaside->L.Tag);
1500 }
1501#else /* NONAMELESSUNION */
1502#if defined(_WIN2K_COMPAT_SLIST_USAGE) && defined(_X86_)
1504 &Lookaside->Lock__ObsoleteButDoNotDelete);
1505#else
1507#endif
1509 Lookaside->L.AllocateMisses++;
1511 Lookaside->L.Size,
1512 Lookaside->L.Tag);
1513 }
1514#endif /* NONAMELESSUNION */
1516}
Definition: nsiface.idl:2307
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _In_ _In_ _Strict_type_match_ POOL_TYPE _In_opt_ PWDF_OBJECT_ATTRIBUTES _In_opt_ ULONG _Out_ WDFLOOKASIDE * Lookaside
Definition: wdfmemory.h:414
#define ExInterlockedPopEntrySList(SListHead, Lock)
Definition: exfuncs.h:166
◆ _Dispatch_type_() [1/7]
| _Dispatch_type_ | ( | IRP_MJ_CREATE | ) |
◆ _Dispatch_type_() [2/7]
| _Dispatch_type_ | ( | IRP_MJ_DEVICE_CONTROL | ) |
Definition at line 1007 of file isapnp.c.
1018{
1020
1021 PAGED_CODE();
1022
1025
1027 {
1030 }
1031 else
1032 {
1034
1037 }
1038}
Definition: isapnp.h:149
Definition: isapnp.h:156
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
◆ _Dispatch_type_() [3/7]
| _Dispatch_type_ | ( | IRP_MJ_PNP | ) |
Definition at line 1581 of file isapnp.c.
1591{
1594
1595 PAGED_CODE();
1596
1599 else
1601}
NTSTATUS IsaFdoPnp(_In_ PISAPNP_FDO_EXTENSION FdoExt, _Inout_ PIRP Irp, _In_ PIO_STACK_LOCATION IrpSp)
Definition: fdo.c:123
NTSTATUS IsaPdoPnp(_In_ PISAPNP_PDO_EXTENSION PdoDeviceExtension, _Inout_ PIRP Irp, _In_ PIO_STACK_LOCATION IrpSp)
Definition: pdo.c:864
Definition: iotypes.h:3110
Definition: isapnp.h:177
◆ _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:1817
ULONG NTAPI ExIsResourceAcquiredSharedLite(IN PERESOURCE Resource)
Definition: resource.c:1658
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
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:3128
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 | ) |
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: usbstor.h:97
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 */
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:2935
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:1024
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,
5120 irpStack->Parameters.DeviceIoControl.OutputBufferLength,
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
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)) ||
8937 (firmwareActivate->Size > irpStack->Parameters.DeviceIoControl.InputBufferLength)) {
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:1093
FORCEINLINE VOID SrbSetTimeOutValue(_In_ PVOID Srb, _In_ ULONG TimeOutValue)
Definition: srbhelper.h:821
Definition: pci.h:44
PDEVICE_OBJECT LowerDeviceObject
Definition: classpnp.h:598
Definition: classpnp.h:867
Definition: ketypes.h:614
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)) ||
8580 (firmwareDownload->Size > irpStack->Parameters.DeviceIoControl.InputBufferLength) ||
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) ||
8700 (firmwareDownload->BufferSize > fdoExtension->AdapterDescriptor->MaximumTransferLength) ||
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:498
PIRP NTAPI IoAllocateIrp(IN CCHAR StackSize, IN BOOLEAN ChargeQuota)
Definition: irp.c:615
FORCEINLINE VOID SrbSetSrbFlags(_In_ PVOID Srb, _In_ ULONG Flags)
Definition: srbhelper.h:964
FORCEINLINE VOID SrbSetRequestAttribute(_In_ PVOID Srb, _In_ UCHAR RequestAttribute)
Definition: srbhelper.h:1131
PSTORAGE_ADAPTER_DESCRIPTOR AdapterDescriptor
Definition: classpnp.h:877
Definition: Bus_PDO_QueryResourceRequirements.c:93
FORCEINLINE VOID IoSetNextIrpStackLocation(_Inout_ PIRP Irp)
Definition: iofuncs.h:2680
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:142
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:1889
Definition: kbdclass.h:24
WDF_EXTERN_C_START typedef _Must_inspect_result_ _In_ WDFDRIVER _In_opt_ PWDF_OBJECT_ATTRIBUTES _In_ PDEVICE_OBJECT _In_opt_ PDEVICE_OBJECT _In_opt_ PDEVICE_OBJECT Pdo
Definition: wdfminiport.h:72
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()
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:551
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
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:931
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,
651 currentIrpStack->Parameters.Read.Length);
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
NTSTATUS NTAPI ClassIoComplete(IN PDEVICE_OBJECT Fdo, IN PIRP Irp, IN PVOID Context)
Definition: class.c:3768
struct _FOUR_BYTE * PFOUR_BYTE
#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:839
FORCEINLINE VOID SrbSetDataTransferLength(_In_ PVOID Srb, _In_ ULONG DataTransferLength)
Definition: srbhelper.h:784
FORCEINLINE VOID SrbSetOriginalRequest(_In_ PVOID Srb, _In_opt_ PVOID OriginalRequest)
Definition: srbhelper.h:710
FORCEINLINE VOID SrbSetSenseInfoBufferLength(_In_ PVOID Srb, _In_ UCHAR SenseInfoBufferLength)
Definition: srbhelper.h:675
FORCEINLINE VOID SrbSetSenseInfoBuffer(_In_ PVOID Srb, _In_opt_ PVOID SenseInfoBuffer)
Definition: srbhelper.h:657
FORCEINLINE VOID SrbSetDataBuffer(_In_ PVOID Srb, _In_opt_ __drv_aliasesMem PVOID DataBuffer)
Definition: srbhelper.h:747
FORCEINLINE ULONG SrbGetDataTransferLength(_In_ PVOID Srb)
Definition: srbhelper.h:765
Definition: srb.h:248
struct _CDB::_CDB10 CDB10
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetNextIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2695
#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