reactos/include/ddk/classpnp.h

   1
   2 #pragma once
   3
   4 #define _CLASS_
   5
   6 #include <ntdddisk.h>
   7 #include <ntddcdrm.h>
   8 #include <ntddtape.h>
   9 #include <ntddscsi.h>
  10 #include <ntddstor.h>
  11
  12 #include <stdio.h>
  13
  14 #include <scsi.h>
  15
  16 #define max(a,b) (((a) > (b)) ? (a) : (b))
  17 #define min(a,b) (((a) < (b)) ? (a) : (b))
  18
  19 #define SRB_CLASS_FLAGS_LOW_PRIORITY      0x10000000
  20 #define SRB_CLASS_FLAGS_PERSISTANT        0x20000000
  21 #define SRB_CLASS_FLAGS_PAGING            0x40000000
  22 #define SRB_CLASS_FLAGS_FREE_MDL          0x80000000
  23
  24 #define ASSERT_FDO(x) \
  25   ASSERT(((PCOMMON_DEVICE_EXTENSION) (x)->DeviceExtension)->IsFdo)
  26
  27 #define ASSERT_PDO(x) \
  28   ASSERT(!(((PCOMMON_DEVICE_EXTENSION) (x)->DeviceExtension)->IsFdo))
  29
  30 #define IS_CLEANUP_REQUEST(majorFunction)   \
  31   ((majorFunction == IRP_MJ_CLOSE) ||       \
  32    (majorFunction == IRP_MJ_CLEANUP) ||     \
  33    (majorFunction == IRP_MJ_SHUTDOWN))
  34
  35 #define DO_MCD(fdoExtension)                                 \
  36   (((fdoExtension)->MediaChangeDetectionInfo != NULL) &&     \
  37    ((fdoExtension)->MediaChangeDetectionInfo->MediaChangeDetectionDisableCount == 0))
  38
  39 #define IS_SCSIOP_READ(opCode)     \
  40   ((opCode == SCSIOP_READ6)   ||   \
  41    (opCode == SCSIOP_READ)    ||   \
  42    (opCode == SCSIOP_READ12)  ||   \
  43    (opCode == SCSIOP_READ16))
  44
  45 #define IS_SCSIOP_WRITE(opCode)     \
  46   ((opCode == SCSIOP_WRITE6)   ||   \
  47    (opCode == SCSIOP_WRITE)    ||   \
  48    (opCode == SCSIOP_WRITE12)  ||   \
  49    (opCode == SCSIOP_WRITE16))
  50
  51 #define IS_SCSIOP_READWRITE(opCode) (IS_SCSIOP_READ(opCode) || IS_SCSIOP_WRITE(opCode))
  52
  53 #define ADJUST_FUA_FLAG(fdoExt) {                                                       \
  54     if (TEST_FLAG(fdoExt->DeviceFlags, DEV_WRITE_CACHE) &&                              \
  55         !TEST_FLAG(fdoExt->DeviceFlags, DEV_POWER_PROTECTED) &&                         \
  56         !TEST_FLAG(fdoExt->ScanForSpecialFlags, CLASS_SPECIAL_FUA_NOT_SUPPORTED) ) {    \
  57         fdoExt->CdbForceUnitAccess = TRUE;                                              \
  58     } else {                                                                            \
  59         fdoExt->CdbForceUnitAccess = FALSE;                                             \
  60     }                                                                                   \
  61 }
  62
  63 #define FREE_POOL(_PoolPtr)     \
  64     if (_PoolPtr != NULL) {     \
  65         ExFreePool(_PoolPtr);   \
  66         _PoolPtr = NULL;        \
  67     }
  68
  69 #ifdef POOL_TAGGING
  70 #undef ExAllocatePool
  71 #undef ExAllocatePoolWithQuota
  72 #define ExAllocatePool(a,b) ExAllocatePoolWithTag(a,b,'nUcS')
  73 //#define ExAllocatePool(a,b) #assert(0)
  74 #define ExAllocatePoolWithQuota(a,b) ExAllocatePoolWithQuotaTag(a,b,'nUcS')
  75 #endif
  76
  77 #define CLASS_TAG_AUTORUN_DISABLE           'ALcS'
  78 #define CLASS_TAG_FILE_OBJECT_EXTENSION     'FLcS'
  79 #define CLASS_TAG_MEDIA_CHANGE_DETECTION    'MLcS'
  80 #define CLASS_TAG_MOUNT                     'mLcS'
  81 #define CLASS_TAG_RELEASE_QUEUE             'qLcS'
  82 #define CLASS_TAG_POWER                     'WLcS'
  83 #define CLASS_TAG_WMI                       'wLcS'
  84 #define CLASS_TAG_FAILURE_PREDICT           'fLcS'
  85 #define CLASS_TAG_DEVICE_CONTROL            'OIcS'
  86 #define CLASS_TAG_MODE_DATA                 'oLcS'
  87 #define CLASS_TAG_MULTIPATH                 'mPcS'
  88
  89 #define MAXIMUM_RETRIES 4
  90
  91 #define CLASS_DRIVER_EXTENSION_KEY ((PVOID) ClassInitialize)
  92
  93 #define NO_REMOVE                         0
  94 #define REMOVE_PENDING                    1
  95 #define REMOVE_COMPLETE                   2
  96
  97 #define ClassAcquireRemoveLock(devobj, tag) \
  98   ClassAcquireRemoveLockEx(devobj, tag, __FILE__, __LINE__)
  99
 100 #ifdef TRY
 101 #undef TRY
 102 #endif
 103 #ifdef LEAVE
 104 #undef LEAVE
 105 #endif
 106
 107 #ifdef FINALLY
 108 #undef FINALLY
 109 #endif
 110
 111 #define TRY
 112 #define LEAVE             goto __tryLabel;
 113 #define FINALLY           __tryLabel:
 114
 115 #if defined DebugPrint
 116 #undef DebugPrint
 117 #endif
 118
 119 #if DBG
 120 #define DebugPrint(x) ClassDebugPrint x
 121 #else
 122 #define DebugPrint(x)
 123 #endif
 124
 125 #define DEBUG_BUFFER_LENGTH                        256
 126
 127 #define START_UNIT_TIMEOUT                         (60 * 4)
 128
 129 #define MEDIA_CHANGE_DEFAULT_TIME                  1
 130 #define MEDIA_CHANGE_TIMEOUT_TIME                  300
 131
 132 #ifdef ALLOCATE_SRB_FROM_POOL
 133
 134 #define ClasspAllocateSrb(ext)                      \
 135   ExAllocatePoolWithTag(NonPagedPool,               \
 136                         sizeof(SCSI_REQUEST_BLOCK), \
 137                         'sBRS')
 138
 139 #define ClasspFreeSrb(ext, srb) ExFreePool((srb));
 140
 141 #else /* ALLOCATE_SRB_FROM_POOL */
 142
 143 #define ClasspAllocateSrb(ext)                      \
 144   ExAllocateFromNPagedLookasideList(                \
 145       &((ext)->CommonExtension.SrbLookasideList))
 146
 147 #define ClasspFreeSrb(ext, srb)                   \
 148   ExFreeToNPagedLookasideList(                    \
 149       &((ext)->CommonExtension.SrbLookasideList), \
 150       (srb))
 151
 152 #endif /* ALLOCATE_SRB_FROM_POOL */
 153
 154 #define SET_FLAG(Flags, Bit)    ((Flags) |= (Bit))
 155 #define CLEAR_FLAG(Flags, Bit)  ((Flags) &= ~(Bit))
 156 #define TEST_FLAG(Flags, Bit)   (((Flags) & (Bit)) != 0)
 157
 158 #define CLASS_WORKING_SET_MAXIMUM                         2048
 159
 160 #define CLASS_INTERPRET_SENSE_INFO2_MAXIMUM_HISTORY_COUNT 30000
 161
 162 #define CLASS_SPECIAL_DISABLE_SPIN_DOWN                 0x00000001
 163 #define CLASS_SPECIAL_DISABLE_SPIN_UP                   0x00000002
 164 #define CLASS_SPECIAL_NO_QUEUE_LOCK                     0x00000008
 165 #define CLASS_SPECIAL_DISABLE_WRITE_CACHE               0x00000010
 166 #define CLASS_SPECIAL_CAUSE_NOT_REPORTABLE_HACK         0x00000020
 167 #if ((NTDDI_VERSION == NTDDI_WIN2KSP3) || (OSVER(NTDDI_VERSION) == NTDDI_WINXP))
 168 #define CLASS_SPECIAL_DISABLE_WRITE_CACHE_NOT_SUPPORTED 0x00000040
 169 #endif
 170 #define CLASS_SPECIAL_MODIFY_CACHE_UNSUCCESSFUL         0x00000040
 171 #define CLASS_SPECIAL_FUA_NOT_SUPPORTED                 0x00000080
 172 #define CLASS_SPECIAL_VALID_MASK                        0x000000FB
 173 #define CLASS_SPECIAL_RESERVED         (~CLASS_SPECIAL_VALID_MASK)
 174
 175 #define DEV_WRITE_CACHE                                 0x00000001
 176 #define DEV_USE_SCSI1                                   0x00000002
 177 #define DEV_SAFE_START_UNIT                             0x00000004
 178 #define DEV_NO_12BYTE_CDB                               0x00000008
 179 #define DEV_POWER_PROTECTED                             0x00000010
 180 #define DEV_USE_16BYTE_CDB                              0x00000020
 181
 182 #define GUID_CLASSPNP_QUERY_REGINFOEX {0x00e34b11, 0x2444, 0x4745, {0xa5, 0x3d, 0x62, 0x01, 0x00, 0xcd, 0x82, 0xf7}}
 183 #define GUID_CLASSPNP_SENSEINFO2      {0x509a8c5f, 0x71d7, 0x48f6, {0x82, 0x1e, 0x17, 0x3c, 0x49, 0xbf, 0x2f, 0x18}}
 184 #define GUID_CLASSPNP_WORKING_SET     {0x105701b0, 0x9e9b, 0x47cb, {0x97, 0x80, 0x81, 0x19, 0x8a, 0xf7, 0xb5, 0x24}}
 185
 186 #define DEFAULT_FAILURE_PREDICTION_PERIOD 60 * 60 * 1
 187
 188 #define MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS (0x3b9aca00)
 189
 190 static inline ULONG CountOfSetBitsUChar(UCHAR _X)
 191 { ULONG i = 0; while (_X) { _X &= _X - 1; i++; } return i; }
 192 static inline ULONG CountOfSetBitsULong(ULONG _X)
 193 { ULONG i = 0; while (_X) { _X &= _X - 1; i++; } return i; }
 194 static inline ULONG CountOfSetBitsULong32(ULONG32 _X)
 195 { ULONG i = 0; while (_X) { _X &= _X - 1; i++; } return i; }
 196 static inline ULONG CountOfSetBitsULong64(ULONG64 _X)
 197 { ULONG i = 0; while (_X) { _X &= _X - 1; i++; } return i; }
 198 static inline ULONG CountOfSetBitsUlongPtr(ULONG_PTR _X)
 199 { ULONG i = 0; while (_X) { _X &= _X - 1; i++; } return i; }
 200
 201 typedef enum _MEDIA_CHANGE_DETECTION_STATE {
 202   MediaUnknown,
 203   MediaPresent,
 204   MediaNotPresent,
 205   MediaUnavailable
 206 } MEDIA_CHANGE_DETECTION_STATE, *PMEDIA_CHANGE_DETECTION_STATE;
 207
 208 typedef enum _CLASS_DEBUG_LEVEL {
 209   ClassDebugError = 0,
 210   ClassDebugWarning = 1,
 211   ClassDebugTrace = 2,
 212   ClassDebugInfo = 3,
 213   ClassDebugMediaLocks = 8,
 214   ClassDebugMCN = 9,
 215   ClassDebugDelayedRetry = 10,
 216   ClassDebugSenseInfo = 11,
 217   ClassDebugRemoveLock = 12,
 218   ClassDebugExternal4 = 13,
 219   ClassDebugExternal3 = 14,
 220   ClassDebugExternal2 = 15,
 221   ClassDebugExternal1 = 16
 222 } CLASS_DEBUG_LEVEL, *PCLASS_DEBUG_LEVEL;
 223
 224 typedef enum {
 225   EventGeneration,
 226   DataBlockCollection
 227 } CLASSENABLEDISABLEFUNCTION;
 228
 229 typedef enum {
 230   FailurePredictionNone = 0,
 231   FailurePredictionIoctl,
 232   FailurePredictionSmart,
 233   FailurePredictionSense
 234 } FAILURE_PREDICTION_METHOD, *PFAILURE_PREDICTION_METHOD;
 235
 236 typedef enum {
 237   PowerDownDeviceInitial,
 238   PowerDownDeviceLocked,
 239   PowerDownDeviceStopped,
 240   PowerDownDeviceOff,
 241   PowerDownDeviceUnlocked
 242 } CLASS_POWER_DOWN_STATE;
 243
 244 typedef enum {
 245   PowerDownDeviceInitial2,
 246   PowerDownDeviceLocked2,
 247   PowerDownDeviceFlushed2,
 248   PowerDownDeviceStopped2,
 249   PowerDownDeviceOff2,
 250   PowerDownDeviceUnlocked2
 251 } CLASS_POWER_DOWN_STATE2;
 252
 253 typedef enum {
 254   PowerUpDeviceInitial,
 255   PowerUpDeviceLocked,
 256   PowerUpDeviceOn,
 257   PowerUpDeviceStarted,
 258   PowerUpDeviceUnlocked
 259 } CLASS_POWER_UP_STATE;
 260
 261 struct _CLASS_INIT_DATA;
 262 typedef struct _CLASS_INIT_DATA CLASS_INIT_DATA, *PCLASS_INIT_DATA;
 263
 264 struct _CLASS_PRIVATE_FDO_DATA;
 265 typedef struct _CLASS_PRIVATE_FDO_DATA CLASS_PRIVATE_FDO_DATA, *PCLASS_PRIVATE_FDO_DATA;
 266
 267 struct _CLASS_PRIVATE_PDO_DATA;
 268 typedef struct _CLASS_PRIVATE_PDO_DATA CLASS_PRIVATE_PDO_DATA, *PCLASS_PRIVATE_PDO_DATA;
 269
 270 struct _CLASS_PRIVATE_COMMON_DATA;
 271 typedef struct _CLASS_PRIVATE_COMMON_DATA CLASS_PRIVATE_COMMON_DATA, *PCLASS_PRIVATE_COMMON_DATA;
 272
 273 struct _MEDIA_CHANGE_DETECTION_INFO;
 274 typedef struct _MEDIA_CHANGE_DETECTION_INFO MEDIA_CHANGE_DETECTION_INFO, *PMEDIA_CHANGE_DETECTION_INFO;
 275
 276 typedef struct _DICTIONARY {
 277   ULONGLONG Signature;
 278   struct _DICTIONARY_HEADER* List;
 279   KSPIN_LOCK SpinLock;
 280 } DICTIONARY, *PDICTIONARY;
 281
 282 typedef struct _CLASSPNP_SCAN_FOR_SPECIAL_INFO {
 283   PCHAR VendorId;
 284   PCHAR ProductId;
 285   PCHAR ProductRevision;
 286   ULONG_PTR Data;
 287 } CLASSPNP_SCAN_FOR_SPECIAL_INFO, *PCLASSPNP_SCAN_FOR_SPECIAL_INFO;
 288
 289 _IRQL_requires_max_(DISPATCH_LEVEL)
 290 typedef VOID
 291 (NTAPI *PCLASS_ERROR)(
 292   _In_ PDEVICE_OBJECT DeviceObject,
 293   _In_ PSCSI_REQUEST_BLOCK Srb,
 294   _Out_ NTSTATUS *Status,
 295   _Inout_ BOOLEAN *Retry);
 296
 297 _IRQL_requires_max_(PASSIVE_LEVEL)
 298 typedef NTSTATUS
 299 (NTAPI *PCLASS_ADD_DEVICE)(
 300   _In_ PDRIVER_OBJECT DriverObject,
 301   _In_ PDEVICE_OBJECT Pdo);
 302
 303 typedef NTSTATUS
 304 (NTAPI *PCLASS_POWER_DEVICE)(
 305   _In_ PDEVICE_OBJECT DeviceObject,
 306   _In_ PIRP Irp);
 307
 308 _IRQL_requires_max_(PASSIVE_LEVEL)
 309 typedef NTSTATUS
 310 (NTAPI *PCLASS_START_DEVICE)(
 311   _In_ PDEVICE_OBJECT DeviceObject);
 312
 313 _IRQL_requires_max_(PASSIVE_LEVEL)
 314 typedef NTSTATUS
 315 (NTAPI *PCLASS_STOP_DEVICE)(
 316   _In_ PDEVICE_OBJECT DeviceObject,
 317   _In_ UCHAR Type);
 318
 319 _IRQL_requires_max_(PASSIVE_LEVEL)
 320 typedef NTSTATUS
 321 (NTAPI *PCLASS_INIT_DEVICE)(
 322   _In_ PDEVICE_OBJECT DeviceObject);
 323
 324 _IRQL_requires_max_(PASSIVE_LEVEL)
 325 typedef NTSTATUS
 326 (NTAPI *PCLASS_ENUM_DEVICE)(
 327   _In_ PDEVICE_OBJECT DeviceObject);
 328
 329 _IRQL_requires_max_(DISPATCH_LEVEL)
 330 typedef NTSTATUS
 331 (NTAPI *PCLASS_READ_WRITE)(
 332   _In_ PDEVICE_OBJECT DeviceObject,
 333   _In_ PIRP Irp);
 334
 335 _IRQL_requires_max_(DISPATCH_LEVEL)
 336 typedef NTSTATUS
 337 (NTAPI *PCLASS_DEVICE_CONTROL)(
 338   _In_ PDEVICE_OBJECT DeviceObject,
 339   _In_ PIRP Irp);
 340
 341 _IRQL_requires_max_(DISPATCH_LEVEL)
 342 typedef NTSTATUS
 343 (NTAPI *PCLASS_SHUTDOWN_FLUSH)(
 344   _In_ PDEVICE_OBJECT DeviceObject,
 345   _In_ PIRP Irp);
 346
 347 _IRQL_requires_max_(PASSIVE_LEVEL)
 348 typedef NTSTATUS
 349 (NTAPI *PCLASS_CREATE_CLOSE)(
 350   _In_ PDEVICE_OBJECT DeviceObject,
 351   _In_ PIRP Irp);
 352
 353 _IRQL_requires_max_(PASSIVE_LEVEL)
 354 typedef NTSTATUS
 355 (NTAPI *PCLASS_QUERY_ID)(
 356   _In_ PDEVICE_OBJECT DeviceObject,
 357   _In_ BUS_QUERY_ID_TYPE IdType,
 358   _In_ PUNICODE_STRING IdString);
 359
 360 _IRQL_requires_max_(PASSIVE_LEVEL)
 361 typedef NTSTATUS
 362 (NTAPI *PCLASS_REMOVE_DEVICE)(
 363   _In_ PDEVICE_OBJECT DeviceObject,
 364   _In_ UCHAR Type);
 365
 366 _IRQL_requires_max_(PASSIVE_LEVEL)
 367 typedef VOID
 368 (NTAPI *PCLASS_UNLOAD)(
 369   _In_ PDRIVER_OBJECT DriverObject);
 370
 371 _IRQL_requires_max_(PASSIVE_LEVEL)
 372 typedef NTSTATUS
 373 (NTAPI *PCLASS_QUERY_PNP_CAPABILITIES)(
 374   _In_ PDEVICE_OBJECT PhysicalDeviceObject,
 375   _In_ PDEVICE_CAPABILITIES Capabilities);
 376
 377 _IRQL_requires_(DISPATCH_LEVEL)
 378 typedef VOID
 379 (NTAPI *PCLASS_TICK)(
 380   _In_ PDEVICE_OBJECT DeviceObject);
 381
 382 _IRQL_requires_max_(PASSIVE_LEVEL)
 383 typedef NTSTATUS
 384 (NTAPI *PCLASS_QUERY_WMI_REGINFO_EX)(
 385   _In_ PDEVICE_OBJECT DeviceObject,
 386   _Out_ ULONG *RegFlags,
 387   _Out_ PUNICODE_STRING Name,
 388   _Out_ PUNICODE_STRING MofResourceName);
 389
 390 _IRQL_requires_max_(PASSIVE_LEVEL)
 391 typedef NTSTATUS
 392 (NTAPI *PCLASS_QUERY_WMI_REGINFO)(
 393   _In_ PDEVICE_OBJECT DeviceObject,
 394   _Out_ ULONG *RegFlags,
 395   _Out_ PUNICODE_STRING Name);
 396
 397 _IRQL_requires_max_(PASSIVE_LEVEL)
 398 typedef NTSTATUS
 399 (NTAPI *PCLASS_QUERY_WMI_DATABLOCK)(
 400   _In_ PDEVICE_OBJECT DeviceObject,
 401   _In_ PIRP Irp,
 402   _In_ ULONG GuidIndex,
 403   _In_ ULONG BufferAvail,
 404   _Out_writes_bytes_(BufferAvail) PUCHAR Buffer);
 405
 406 _IRQL_requires_max_(PASSIVE_LEVEL)
 407 typedef NTSTATUS
 408 (NTAPI *PCLASS_SET_WMI_DATABLOCK)(
 409   _In_ PDEVICE_OBJECT DeviceObject,
 410   _In_ PIRP Irp,
 411   _In_ ULONG GuidIndex,
 412   _In_ ULONG BufferSize,
 413   _In_reads_bytes_(BufferSize) PUCHAR Buffer);
 414
 415 _IRQL_requires_max_(PASSIVE_LEVEL)
 416 typedef NTSTATUS
 417 (NTAPI *PCLASS_SET_WMI_DATAITEM)(
 418   _In_ PDEVICE_OBJECT DeviceObject,
 419   _In_ PIRP Irp,
 420   _In_ ULONG GuidIndex,
 421   _In_ ULONG DataItemId,
 422   _In_ ULONG BufferSize,
 423   _In_reads_bytes_(BufferSize) PUCHAR Buffer);
 424
 425 _IRQL_requires_max_(PASSIVE_LEVEL)
 426 typedef NTSTATUS
 427 (NTAPI *PCLASS_EXECUTE_WMI_METHOD)(
 428   _In_ PDEVICE_OBJECT DeviceObject,
 429   _In_ PIRP Irp,
 430   _In_ ULONG GuidIndex,
 431   _In_ ULONG MethodId,
 432   _In_ ULONG InBufferSize,
 433   _In_ ULONG OutBufferSize,
 434   _In_reads_(_Inexpressible_(max(InBufferSize, OutBufferSize))) PUCHAR Buffer);
 435
 436 _IRQL_requires_max_(PASSIVE_LEVEL)
 437 typedef NTSTATUS
 438 (NTAPI *PCLASS_WMI_FUNCTION_CONTROL)(
 439   _In_ PDEVICE_OBJECT DeviceObject,
 440   _In_ PIRP Irp,
 441   _In_ ULONG GuidIndex,
 442   _In_ CLASSENABLEDISABLEFUNCTION Function,
 443   _In_ BOOLEAN Enable);
 444
 445 typedef struct _SRB_HISTORY_ITEM {
 446   LARGE_INTEGER TickCountSent;
 447   LARGE_INTEGER TickCountCompleted;
 448   ULONG MillisecondsDelayOnRetry;
 449   SENSE_DATA NormalizedSenseData;
 450   UCHAR SrbStatus;
 451   UCHAR ClassDriverUse;
 452 } SRB_HISTORY_ITEM, *PSRB_HISTORY_ITEM;
 453
 454 typedef struct _SRB_HISTORY {
 455   ULONG_PTR ClassDriverUse[4];
 456   _Field_range_(1,30000) ULONG TotalHistoryCount;
 457   _Field_range_(0,TotalHistoryCount) ULONG UsedHistoryCount;
 458   _Field_size_part_(TotalHistoryCount, UsedHistoryCount) SRB_HISTORY_ITEM History[1];
 459 } SRB_HISTORY, *PSRB_HISTORY;
 460
 461 _IRQL_requires_max_(DISPATCH_LEVEL)
 462 typedef BOOLEAN
 463 (NTAPI *PCLASS_INTERPRET_SENSE_INFO)(
 464   _In_ PDEVICE_OBJECT Fdo,
 465   _In_opt_ PIRP OriginalRequest,
 466   _In_ PSCSI_REQUEST_BLOCK Srb,
 467   _In_ UCHAR MajorFunctionCode,
 468   _In_ ULONG IoDeviceCode,
 469   _In_ ULONG PreviousRetryCount,
 470   _In_opt_ SRB_HISTORY *RequestHistory,
 471   _Out_ NTSTATUS *Status,
 472   _Out_ _Deref_out_range_(0,MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS)
 473     LONGLONG *RetryIn100nsUnits);
 474
 475 _IRQL_requires_max_(DISPATCH_LEVEL)
 476 _At_(RequestHistory->UsedHistoryCount, _Pre_equal_to_(RequestHistory->TotalHistoryCount)
 477    _Out_range_(0, RequestHistory->TotalHistoryCount - 1))
 478 typedef VOID
 479 (NTAPI *PCLASS_COMPRESS_RETRY_HISTORY_DATA)(
 480   _In_ PDEVICE_OBJECT DeviceObject,
 481   _Inout_ PSRB_HISTORY RequestHistory);
 482
 483 typedef struct {
 484   GUID Guid;
 485   ULONG InstanceCount;
 486   ULONG Flags;
 487 } GUIDREGINFO, *PGUIDREGINFO;
 488
 489 typedef struct _CLASS_WMI_INFO {
 490   ULONG GuidCount;
 491   PGUIDREGINFO GuidRegInfo;
 492   PCLASS_QUERY_WMI_REGINFO ClassQueryWmiRegInfo;
 493   PCLASS_QUERY_WMI_DATABLOCK ClassQueryWmiDataBlock;
 494   PCLASS_SET_WMI_DATABLOCK ClassSetWmiDataBlock;
 495   PCLASS_SET_WMI_DATAITEM ClassSetWmiDataItem;
 496   PCLASS_EXECUTE_WMI_METHOD ClassExecuteWmiMethod;
 497   PCLASS_WMI_FUNCTION_CONTROL ClassWmiFunctionControl;
 498 } CLASS_WMI_INFO, *PCLASS_WMI_INFO;
 499
 500 typedef struct _CLASS_DEV_INFO {
 501   ULONG DeviceExtensionSize;
 502   DEVICE_TYPE DeviceType;
 503   UCHAR StackSize;
 504   ULONG DeviceCharacteristics;
 505   PCLASS_ERROR ClassError;
 506   PCLASS_READ_WRITE ClassReadWriteVerification;
 507   PCLASS_DEVICE_CONTROL ClassDeviceControl;
 508   PCLASS_SHUTDOWN_FLUSH ClassShutdownFlush;
 509   PCLASS_CREATE_CLOSE ClassCreateClose;
 510   PCLASS_INIT_DEVICE ClassInitDevice;
 511   PCLASS_START_DEVICE ClassStartDevice;
 512   PCLASS_POWER_DEVICE ClassPowerDevice;
 513   PCLASS_STOP_DEVICE ClassStopDevice;
 514   PCLASS_REMOVE_DEVICE ClassRemoveDevice;
 515   PCLASS_QUERY_PNP_CAPABILITIES ClassQueryPnpCapabilities;
 516   CLASS_WMI_INFO ClassWmiInfo;
 517 } CLASS_DEV_INFO, *PCLASS_DEV_INFO;
 518
 519 struct _CLASS_INIT_DATA {
 520   ULONG InitializationDataSize;
 521   CLASS_DEV_INFO FdoData;
 522   CLASS_DEV_INFO PdoData;
 523   PCLASS_ADD_DEVICE ClassAddDevice;
 524   PCLASS_ENUM_DEVICE ClassEnumerateDevice;
 525   PCLASS_QUERY_ID ClassQueryId;
 526   PDRIVER_STARTIO ClassStartIo;
 527   PCLASS_UNLOAD ClassUnload;
 528   PCLASS_TICK ClassTick;
 529 };
 530
 531 typedef struct _FILE_OBJECT_EXTENSION {
 532   PFILE_OBJECT FileObject;
 533   PDEVICE_OBJECT DeviceObject;
 534   ULONG LockCount;
 535   ULONG McnDisableCount;
 536 } FILE_OBJECT_EXTENSION, *PFILE_OBJECT_EXTENSION;
 537
 538 typedef struct _CLASS_WORKING_SET {
 539   _Field_range_(sizeof(CLASS_WORKING_SET),sizeof(CLASS_WORKING_SET)) ULONG Size;
 540   _Field_range_(0,2048) ULONG XferPacketsWorkingSetMaximum;
 541   _Field_range_(0,2048) ULONG XferPacketsWorkingSetMinimum;
 542 } CLASS_WORKING_SET, *PCLASS_WORKING_SET;
 543
 544 typedef struct _CLASS_INTERPRET_SENSE_INFO2 {
 545   _Field_range_(sizeof(CLASS_INTERPRET_SENSE_INFO),sizeof(CLASS_INTERPRET_SENSE_INFO))
 546     ULONG Size;
 547   _Field_range_(1,30000) ULONG HistoryCount;
 548   __callback PCLASS_COMPRESS_RETRY_HISTORY_DATA Compress;
 549   __callback PCLASS_INTERPRET_SENSE_INFO Interpret;
 550 } CLASS_INTERPRET_SENSE_INFO2, *PCLASS_INTERPRET_SENSE_INFO2;
 551
 552 C_ASSERT((MAXULONG - sizeof(SRB_HISTORY)) / 30000 >= sizeof(SRB_HISTORY_ITEM));
 553
 554 typedef struct _CLASS_DRIVER_EXTENSION {
 555   UNICODE_STRING RegistryPath;
 556   CLASS_INIT_DATA InitData;
 557   ULONG DeviceCount;
 558 #if (NTDDI_VERSION >= NTDDI_WINXP)
 559   PCLASS_QUERY_WMI_REGINFO_EX ClassFdoQueryWmiRegInfoEx;
 560   PCLASS_QUERY_WMI_REGINFO_EX ClassPdoQueryWmiRegInfoEx;
 561 #endif
 562 #if (NTDDI_VERSION >= NTDDI_VISTA)
 563   REGHANDLE EtwHandle;
 564   PDRIVER_DISPATCH DeviceMajorFunctionTable[IRP_MJ_MAXIMUM_FUNCTION + 1];
 565   PDRIVER_DISPATCH MpDeviceMajorFunctionTable[IRP_MJ_MAXIMUM_FUNCTION + 1];
 566   PCLASS_INTERPRET_SENSE_INFO2 InterpretSenseInfo;
 567   PCLASS_WORKING_SET WorkingSet;
 568 #endif
 569 } CLASS_DRIVER_EXTENSION, *PCLASS_DRIVER_EXTENSION;
 570
 571 typedef struct _COMMON_DEVICE_EXTENSION {
 572   ULONG Version;
 573   PDEVICE_OBJECT DeviceObject;
 574   PDEVICE_OBJECT LowerDeviceObject;
 575   struct _FUNCTIONAL_DEVICE_EXTENSION *PartitionZeroExtension;
 576   PCLASS_DRIVER_EXTENSION DriverExtension;
 577   LONG RemoveLock;
 578   KEVENT RemoveEvent;
 579   KSPIN_LOCK RemoveTrackingSpinlock;
 580   PVOID RemoveTrackingList;
 581   LONG RemoveTrackingUntrackedCount;
 582   PVOID DriverData;
 583   _ANONYMOUS_STRUCT struct {
 584     BOOLEAN IsFdo:1;
 585     BOOLEAN IsInitialized:1;
 586     BOOLEAN IsSrbLookasideListInitialized:1;
 587   } DUMMYSTRUCTNAME;
 588   UCHAR PreviousState;
 589   UCHAR CurrentState;
 590   ULONG IsRemoved;
 591   UNICODE_STRING DeviceName;
 592   struct _PHYSICAL_DEVICE_EXTENSION *ChildList;
 593   ULONG PartitionNumber;
 594   LARGE_INTEGER PartitionLength;
 595   LARGE_INTEGER StartingOffset;
 596   PCLASS_DEV_INFO DevInfo;
 597   ULONG PagingPathCount;
 598   ULONG DumpPathCount;
 599   ULONG HibernationPathCount;
 600   KEVENT PathCountEvent;
 601 #ifndef ALLOCATE_SRB_FROM_POOL
 602   NPAGED_LOOKASIDE_LIST SrbLookasideList;
 603 #endif
 604   UNICODE_STRING MountedDeviceInterfaceName;
 605   ULONG GuidCount;
 606   PGUIDREGINFO GuidRegInfo;
 607   DICTIONARY FileObjectDictionary;
 608 #if (NTDDI_VERSION >= NTDDI_WINXP)
 609   PCLASS_PRIVATE_COMMON_DATA PrivateCommonData;
 610 #else
 611   ULONG_PTR Reserved1;
 612 #endif
 613 #if (NTDDI_VERSION >= NTDDI_VISTA)
 614   PDRIVER_DISPATCH *DispatchTable;
 615 #else
 616   ULONG_PTR Reserved2;
 617 #endif
 618   ULONG_PTR Reserved3;
 619   ULONG_PTR Reserved4;
 620 } COMMON_DEVICE_EXTENSION, *PCOMMON_DEVICE_EXTENSION;
 621
 622 typedef struct _PHYSICAL_DEVICE_EXTENSION {
 623   _ANONYMOUS_UNION union {
 624     _ANONYMOUS_STRUCT struct {
 625       ULONG Version;
 626       PDEVICE_OBJECT DeviceObject;
 627     } DUMMYSTRUCTNAME;
 628     COMMON_DEVICE_EXTENSION CommonExtension;
 629   } DUMMYUNIONNAME;
 630   BOOLEAN IsMissing;
 631   BOOLEAN IsEnumerated;
 632 #if (NTDDI_VERSION >= NTDDI_WINXP)
 633   PCLASS_PRIVATE_PDO_DATA PrivatePdoData;
 634 #else
 635   ULONG_PTR Reserved1;
 636 #endif
 637   ULONG_PTR Reserved2;
 638   ULONG_PTR Reserved3;
 639   ULONG_PTR Reserved4;
 640 } PHYSICAL_DEVICE_EXTENSION, *PPHYSICAL_DEVICE_EXTENSION;
 641
 642 typedef struct _CLASS_POWER_OPTIONS {
 643   ULONG PowerDown:1;
 644   ULONG LockQueue:1;
 645   ULONG HandleSpinDown:1;
 646   ULONG HandleSpinUp:1;
 647   ULONG Reserved:27;
 648 } CLASS_POWER_OPTIONS, *PCLASS_POWER_OPTIONS;
 649
 650 typedef struct _CLASS_POWER_CONTEXT {
 651   union {
 652     CLASS_POWER_DOWN_STATE PowerDown;
 653     CLASS_POWER_DOWN_STATE2 PowerDown2;
 654     CLASS_POWER_UP_STATE PowerUp;
 655   } PowerChangeState;
 656   CLASS_POWER_OPTIONS Options;
 657   BOOLEAN InUse;
 658   BOOLEAN QueueLocked;
 659   NTSTATUS FinalStatus;
 660   ULONG RetryCount;
 661   ULONG RetryInterval;
 662   PIO_COMPLETION_ROUTINE CompletionRoutine;
 663   PDEVICE_OBJECT DeviceObject;
 664   PIRP Irp;
 665   SCSI_REQUEST_BLOCK Srb;
 666 } CLASS_POWER_CONTEXT, *PCLASS_POWER_CONTEXT;
 667
 668 typedef struct _COMPLETION_CONTEXT {
 669   PDEVICE_OBJECT DeviceObject;
 670   SCSI_REQUEST_BLOCK Srb;
 671 } COMPLETION_CONTEXT, *PCOMPLETION_CONTEXT;
 672
 673 _IRQL_requires_max_(PASSIVE_LEVEL)
 674 _Must_inspect_result_
 675 SCSIPORTAPI
 676 ULONG
 677 NTAPI
 678 ClassInitialize(
 679   _In_ PVOID Argument1,
 680   _In_ PVOID Argument2,
 681   _In_ PCLASS_INIT_DATA InitializationData);
 682
 683 typedef struct _CLASS_QUERY_WMI_REGINFO_EX_LIST {
 684   ULONG Size;
 685   __callback PCLASS_QUERY_WMI_REGINFO_EX ClassFdoQueryWmiRegInfoEx;
 686   __callback PCLASS_QUERY_WMI_REGINFO_EX ClassPdoQueryWmiRegInfoEx;
 687 } CLASS_QUERY_WMI_REGINFO_EX_LIST, *PCLASS_QUERY_WMI_REGINFO_EX_LIST;
 688
 689 typedef struct _FUNCTIONAL_DEVICE_EXTENSION {
 690   _ANONYMOUS_UNION union {
 691     _ANONYMOUS_STRUCT struct {
 692       ULONG Version;
 693       PDEVICE_OBJECT DeviceObject;
 694     } DUMMYSTRUCTNAME;
 695     COMMON_DEVICE_EXTENSION CommonExtension;
 696   } DUMMYUNIONNAME;
 697   PDEVICE_OBJECT LowerPdo;
 698   PSTORAGE_DEVICE_DESCRIPTOR DeviceDescriptor;
 699   PSTORAGE_ADAPTER_DESCRIPTOR AdapterDescriptor;
 700   DEVICE_POWER_STATE DevicePowerState;
 701   ULONG DMByteSkew;
 702   ULONG DMSkew;
 703   BOOLEAN DMActive;
 704   DISK_GEOMETRY DiskGeometry;
 705   PSENSE_DATA SenseData;
 706   ULONG TimeOutValue;
 707   ULONG DeviceNumber;
 708   ULONG SrbFlags;
 709   ULONG ErrorCount;
 710   LONG LockCount;
 711   LONG ProtectedLockCount;
 712   LONG InternalLockCount;
 713   KEVENT EjectSynchronizationEvent;
 714   USHORT DeviceFlags;
 715   UCHAR SectorShift;
 716 #if (NTDDI_VERSION >= NTDDI_VISTA)
 717   UCHAR CdbForceUnitAccess;
 718 #else
 719   UCHAR ReservedByte;
 720 #endif
 721   PMEDIA_CHANGE_DETECTION_INFO MediaChangeDetectionInfo;
 722   PKEVENT Unused1;
 723   HANDLE Unused2;
 724   FILE_OBJECT_EXTENSION KernelModeMcnContext;
 725   ULONG MediaChangeCount;
 726   HANDLE DeviceDirectory;
 727   KSPIN_LOCK ReleaseQueueSpinLock;
 728   PIRP ReleaseQueueIrp;
 729   SCSI_REQUEST_BLOCK ReleaseQueueSrb;
 730   BOOLEAN ReleaseQueueNeeded;
 731   BOOLEAN ReleaseQueueInProgress;
 732   BOOLEAN ReleaseQueueIrpFromPool;
 733   BOOLEAN FailurePredicted;
 734   ULONG FailureReason;
 735   struct _FAILURE_PREDICTION_INFO* FailurePredictionInfo;
 736   BOOLEAN PowerDownInProgress;
 737   ULONG EnumerationInterlock;
 738   KEVENT ChildLock;
 739   PKTHREAD ChildLockOwner;
 740   ULONG ChildLockAcquisitionCount;
 741   ULONG ScanForSpecialFlags;
 742   KDPC PowerRetryDpc;
 743   KTIMER PowerRetryTimer;
 744   CLASS_POWER_CONTEXT PowerContext;
 745
 746 #if (NTDDI_VERSION <= NTDDI_WIN2K)
 747
 748 #if (SPVER(NTDDI_VERSION) < 2))
 749   ULONG_PTR Reserved1;
 750   ULONG_PTR Reserved2;
 751   ULONG_PTR Reserved3;
 752   ULONG_PTR Reserved4;
 753 #else
 754   ULONG CompletionSuccessCount;
 755   ULONG SavedSrbFlags;
 756   ULONG SavedErrorCount;
 757   ULONG_PTR Reserved1;
 758 #endif
 759
 760 #else /* (NTDDI_VERSION <= NTDDI_WIN2K) */
 761
 762   PCLASS_PRIVATE_FDO_DATA PrivateFdoData;
 763   ULONG_PTR Reserved2;
 764   ULONG_PTR Reserved3;
 765   ULONG_PTR Reserved4;
 766
 767 #endif /* (NTDDI_VERSION <= NTDDI_WIN2K) */
 768
 769 } FUNCTIONAL_DEVICE_EXTENSION, *PFUNCTIONAL_DEVICE_EXTENSION;
 770
 771 _IRQL_requires_max_(PASSIVE_LEVEL)
 772 _Must_inspect_result_
 773 SCSIPORTAPI
 774 ULONG
 775 NTAPI
 776 ClassInitializeEx(
 777   _In_ PDRIVER_OBJECT DriverObject,
 778   _In_ LPGUID Guid,
 779   _In_ PVOID Data);
 780
 781 _IRQL_requires_max_(PASSIVE_LEVEL)
 782 _Must_inspect_result_
 783 _Post_satisfies_(return <= 0)
 784 SCSIPORTAPI
 785 NTSTATUS
 786 NTAPI
 787 ClassCreateDeviceObject(
 788   _In_ PDRIVER_OBJECT DriverObject,
 789   _In_z_ PCCHAR ObjectNameBuffer,
 790   _In_ PDEVICE_OBJECT LowerDeviceObject,
 791   _In_ BOOLEAN IsFdo,
 792   _Outptr_result_nullonfailure_ _At_(*DeviceObject, __drv_allocatesMem(Mem) __drv_aliasesMem)
 793     PDEVICE_OBJECT *DeviceObject);
 794
 795 _Must_inspect_result_
 796 SCSIPORTAPI
 797 NTSTATUS
 798 NTAPI
 799 ClassReadDriveCapacity(
 800   _In_ PDEVICE_OBJECT DeviceObject);
 801
 802 SCSIPORTAPI
 803 VOID
 804 NTAPI
 805 ClassReleaseQueue(
 806   _In_ PDEVICE_OBJECT DeviceObject);
 807
 808 SCSIPORTAPI
 809 VOID
 810 NTAPI
 811 ClassSplitRequest(
 812   _In_ PDEVICE_OBJECT DeviceObject,
 813   _In_ PIRP Irp,
 814   _In_ ULONG MaximumBytes);
 815
 816 SCSIPORTAPI
 817 NTSTATUS
 818 NTAPI
 819 ClassDeviceControl(
 820   _In_ PDEVICE_OBJECT DeviceObject,
 821   _Inout_ PIRP Irp);
 822
 823 SCSIPORTAPI
 824 NTSTATUS
 825 NTAPI
 826 ClassIoComplete(
 827   PDEVICE_OBJECT DeviceObject,
 828   PIRP Irp,
 829   PVOID Context);
 830
 831 SCSIPORTAPI
 832 NTSTATUS
 833 NTAPI
 834 ClassIoCompleteAssociated(
 835   PDEVICE_OBJECT DeviceObject,
 836   PIRP Irp,
 837   PVOID Context);
 838
 839 SCSIPORTAPI
 840 BOOLEAN
 841 NTAPI
 842 ClassInterpretSenseInfo(
 843   _In_ PDEVICE_OBJECT DeviceObject,
 844   _In_ PSCSI_REQUEST_BLOCK Srb,
 845   _In_ UCHAR MajorFunctionCode,
 846   _In_ ULONG IoDeviceCode,
 847   _In_ ULONG RetryCount,
 848   _Out_ NTSTATUS *Status,
 849   _Out_opt_ _Deref_out_range_(0,100) ULONG *RetryInterval);
 850
 851 VOID
 852 NTAPI
 853 ClassSendDeviceIoControlSynchronous(
 854   _In_ ULONG IoControlCode,
 855   _In_ PDEVICE_OBJECT TargetDeviceObject,
 856   _Inout_updates_opt_(_Inexpressible_(max(InputBufferLength, OutputBufferLength)))
 857     PVOID Buffer,
 858   _In_ ULONG InputBufferLength,
 859   _In_ ULONG OutputBufferLength,
 860   _In_ BOOLEAN InternalDeviceIoControl,
 861   _Out_ PIO_STATUS_BLOCK IoStatus);
 862
 863 SCSIPORTAPI
 864 NTSTATUS
 865 NTAPI
 866 ClassSendIrpSynchronous(
 867   _In_ PDEVICE_OBJECT TargetDeviceObject,
 868   _In_ PIRP Irp);
 869
 870 SCSIPORTAPI
 871 NTSTATUS
 872 NTAPI
 873 ClassForwardIrpSynchronous(
 874   _In_ PCOMMON_DEVICE_EXTENSION CommonExtension,
 875   _In_ PIRP Irp);
 876
 877 SCSIPORTAPI
 878 NTSTATUS
 879 NTAPI
 880 ClassSendSrbSynchronous(
 881   _In_ PDEVICE_OBJECT DeviceObject,
 882   _Inout_ PSCSI_REQUEST_BLOCK Srb,
 883   _In_reads_bytes_opt_(BufferLength) PVOID BufferAddress,
 884   _In_ ULONG BufferLength,
 885   _In_ BOOLEAN WriteToDevice);
 886
 887 SCSIPORTAPI
 888 NTSTATUS
 889 NTAPI
 890 ClassSendSrbAsynchronous(
 891   _In_ PDEVICE_OBJECT DeviceObject,
 892   _Inout_ PSCSI_REQUEST_BLOCK Srb,
 893   _In_ PIRP Irp,
 894   _In_reads_bytes_opt_(BufferLength) __drv_aliasesMem PVOID BufferAddress,
 895   _In_ ULONG BufferLength,
 896   _In_ BOOLEAN WriteToDevice);
 897
 898 SCSIPORTAPI
 899 NTSTATUS
 900 NTAPI
 901 ClassBuildRequest(
 902   _In_ PDEVICE_OBJECT DeviceObject,
 903   _In_ PIRP Irp);
 904
 905 SCSIPORTAPI
 906 ULONG
 907 NTAPI
 908 ClassModeSense(
 909   _In_ PDEVICE_OBJECT DeviceObject,
 910   _In_reads_bytes_(Length) PCHAR ModeSenseBuffer,
 911   _In_ ULONG Length,
 912   _In_ UCHAR PageMode);
 913
 914 SCSIPORTAPI
 915 PVOID
 916 NTAPI
 917 ClassFindModePage(
 918   _In_reads_bytes_(Length) PCHAR ModeSenseBuffer,
 919   _In_ ULONG Length,
 920   _In_ UCHAR PageMode,
 921   _In_ BOOLEAN Use6Byte);
 922
 923 _IRQL_requires_max_(PASSIVE_LEVEL)
 924 SCSIPORTAPI
 925 NTSTATUS
 926 NTAPI
 927 ClassClaimDevice(
 928   _In_ PDEVICE_OBJECT LowerDeviceObject,
 929   _In_ BOOLEAN Release);
 930
 931 SCSIPORTAPI
 932 NTSTATUS
 933 NTAPI
 934 ClassInternalIoControl(
 935   PDEVICE_OBJECT DeviceObject,
 936   PIRP Irp);
 937
 938 _IRQL_requires_max_(PASSIVE_LEVEL)
 939 SCSIPORTAPI
 940 VOID
 941 NTAPI
 942 ClassInitializeSrbLookasideList(
 943   _Inout_ PCOMMON_DEVICE_EXTENSION CommonExtension,
 944   _In_ ULONG NumberElements);
 945
 946 _IRQL_requires_max_(PASSIVE_LEVEL)
 947 SCSIPORTAPI
 948 VOID
 949 NTAPI
 950 ClassDeleteSrbLookasideList(
 951   _Inout_ PCOMMON_DEVICE_EXTENSION CommonExtension);
 952
 953 _IRQL_requires_max_(PASSIVE_LEVEL)
 954 SCSIPORTAPI
 955 ULONG
 956 NTAPI
 957 ClassQueryTimeOutRegistryValue(
 958   _In_ PDEVICE_OBJECT DeviceObject);
 959
 960 _IRQL_requires_max_(PASSIVE_LEVEL)
 961 SCSIPORTAPI
 962 NTSTATUS
 963 NTAPI
 964 ClassGetDescriptor(
 965   _In_ PDEVICE_OBJECT DeviceObject,
 966   _In_ PSTORAGE_PROPERTY_ID PropertyId,
 967   _Outptr_ PSTORAGE_DESCRIPTOR_HEADER *Descriptor);
 968
 969 _IRQL_requires_max_(PASSIVE_LEVEL)
 970 SCSIPORTAPI
 971 VOID
 972 NTAPI
 973 ClassInvalidateBusRelations(
 974   _In_ PDEVICE_OBJECT Fdo);
 975
 976 _IRQL_requires_max_(PASSIVE_LEVEL)
 977 SCSIPORTAPI
 978 VOID
 979 NTAPI
 980 ClassMarkChildrenMissing(
 981   _In_ PFUNCTIONAL_DEVICE_EXTENSION Fdo);
 982
 983 _IRQL_requires_max_(PASSIVE_LEVEL)
 984 SCSIPORTAPI
 985 BOOLEAN
 986 NTAPI
 987 ClassMarkChildMissing(
 988   _In_ PPHYSICAL_DEVICE_EXTENSION PdoExtension,
 989   _In_ BOOLEAN AcquireChildLock);
 990
 991 SCSIPORTAPI
 992 VOID
 993 ClassDebugPrint(
 994   _In_ CLASS_DEBUG_LEVEL DebugPrintLevel,
 995   _In_z_ PCCHAR DebugMessage,
 996   ...);
 997
 998 __drv_aliasesMem
 999 _IRQL_requires_max_(DISPATCH_LEVEL)
1000 SCSIPORTAPI
1001 PCLASS_DRIVER_EXTENSION
1002 NTAPI
1003 ClassGetDriverExtension(
1004   _In_ PDRIVER_OBJECT DriverObject);
1005
1006 SCSIPORTAPI
1007 VOID
1008 NTAPI
1009 ClassCompleteRequest(
1010   _In_ PDEVICE_OBJECT DeviceObject,
1011   _In_ PIRP Irp,
1012   _In_ CCHAR PriorityBoost);
1013
1014 SCSIPORTAPI
1015 VOID
1016 NTAPI
1017 ClassReleaseRemoveLock(
1018   _In_ PDEVICE_OBJECT DeviceObject,
1019   PIRP Tag);
1020
1021 SCSIPORTAPI
1022 ULONG
1023 NTAPI
1024 ClassAcquireRemoveLockEx(
1025   _In_ PDEVICE_OBJECT DeviceObject,
1026   PVOID Tag,
1027   _In_ PCSTR File,
1028   _In_ ULONG Line);
1029
1030 _IRQL_requires_max_(PASSIVE_LEVEL)
1031 SCSIPORTAPI
1032 VOID
1033 NTAPI
1034 ClassUpdateInformationInRegistry(
1035   _In_ PDEVICE_OBJECT Fdo,
1036   _In_ PCHAR DeviceName,
1037   _In_ ULONG DeviceNumber,
1038   _In_reads_bytes_opt_(InquiryDataLength) PINQUIRYDATA InquiryData,
1039   _In_ ULONG InquiryDataLength);
1040
1041 SCSIPORTAPI
1042 NTSTATUS
1043 NTAPI
1044 ClassWmiCompleteRequest(
1045   _In_ PDEVICE_OBJECT DeviceObject,
1046   _Inout_ PIRP Irp,
1047   _In_ NTSTATUS Status,
1048   _In_ ULONG BufferUsed,
1049   _In_ CCHAR PriorityBoost);
1050
1051 _IRQL_requires_max_(DISPATCH_LEVEL)
1052 SCSIPORTAPI
1053 NTSTATUS
1054 NTAPI
1055 ClassWmiFireEvent(
1056   _In_ PDEVICE_OBJECT DeviceObject,
1057   _In_ LPGUID Guid,
1058   _In_ ULONG InstanceIndex,
1059   _In_ ULONG EventDataSize,
1060   _In_reads_bytes_(EventDataSize) PVOID EventData);
1061
1062 SCSIPORTAPI
1063 VOID
1064 NTAPI
1065 ClassResetMediaChangeTimer(
1066   _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension);
1067
1068 _IRQL_requires_max_(PASSIVE_LEVEL)
1069 SCSIPORTAPI
1070 VOID
1071 NTAPI
1072 ClassInitializeMediaChangeDetection(
1073   _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension,
1074   _In_ PUCHAR EventPrefix);
1075
1076 _IRQL_requires_max_(PASSIVE_LEVEL)
1077 SCSIPORTAPI
1078 NTSTATUS
1079 NTAPI
1080 ClassInitializeTestUnitPolling(
1081   _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension,
1082   _In_ BOOLEAN AllowDriveToSleep);
1083
1084 SCSIPORTAPI
1085 PVPB
1086 NTAPI
1087 ClassGetVpb(
1088   _In_ PDEVICE_OBJECT DeviceObject);
1089
1090 SCSIPORTAPI
1091 NTSTATUS
1092 NTAPI
1093 ClassSpinDownPowerHandler(
1094   _In_ PDEVICE_OBJECT DeviceObject,
1095   _In_ PIRP Irp);
1096
1097 NTSTATUS
1098 NTAPI
1099 ClassStopUnitPowerHandler(
1100   _In_ PDEVICE_OBJECT DeviceObject,
1101   _In_ PIRP Irp);
1102
1103 _IRQL_requires_max_(PASSIVE_LEVEL)
1104 NTSTATUS
1105 NTAPI
1106 ClassSetFailurePredictionPoll(
1107   _Inout_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension,
1108   _In_ FAILURE_PREDICTION_METHOD FailurePredictionMethod,
1109   _In_ ULONG PollingPeriod);
1110
1111 _IRQL_requires_max_(DISPATCH_LEVEL)
1112 VOID
1113 NTAPI
1114 ClassNotifyFailurePredicted(
1115   _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension,
1116   _In_reads_bytes_(BufferSize) PUCHAR Buffer,
1117   _In_ ULONG BufferSize,
1118   _In_ BOOLEAN LogError,
1119   _In_ ULONG UniqueErrorValue,
1120   _In_ UCHAR PathId,
1121   _In_ UCHAR TargetId,
1122   _In_ UCHAR Lun);
1123
1124 _IRQL_requires_max_(PASSIVE_LEVEL)
1125 SCSIPORTAPI
1126 VOID
1127 NTAPI
1128 ClassAcquireChildLock(
1129   _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension);
1130
1131 SCSIPORTAPI
1132 VOID
1133 NTAPI
1134 ClassReleaseChildLock(
1135   _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension);
1136
1137 NTSTATUS
1138 NTAPI
1139 ClassSignalCompletion(
1140   PDEVICE_OBJECT DeviceObject,
1141   PIRP Irp,
1142   PKEVENT Event);
1143
1144 VOID
1145 NTAPI
1146 ClassSendStartUnit(
1147   _In_ PDEVICE_OBJECT DeviceObject);
1148
1149 _IRQL_requires_max_(PASSIVE_LEVEL)
1150 SCSIPORTAPI
1151 NTSTATUS
1152 NTAPI
1153 ClassRemoveDevice(
1154   _In_ PDEVICE_OBJECT DeviceObject,
1155   _In_ UCHAR RemoveType);
1156
1157 SCSIPORTAPI
1158 NTSTATUS
1159 NTAPI
1160 ClassAsynchronousCompletion(
1161   PDEVICE_OBJECT DeviceObject,
1162   PIRP Irp,
1163   PVOID Event);
1164
1165 SCSIPORTAPI
1166 VOID
1167 NTAPI
1168 ClassCheckMediaState(
1169   _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension);
1170
1171 SCSIPORTAPI
1172 NTSTATUS
1173 NTAPI
1174 ClassCheckVerifyComplete(
1175   PDEVICE_OBJECT DeviceObject,
1176   PIRP Irp,
1177   PVOID Context);
1178
1179 _IRQL_requires_max_(PASSIVE_LEVEL)
1180 SCSIPORTAPI
1181 VOID
1182 NTAPI
1183 ClassSetMediaChangeState(
1184   _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension,
1185   _In_ MEDIA_CHANGE_DETECTION_STATE State,
1186   _In_ BOOLEAN Wait);
1187
1188 _IRQL_requires_max_(PASSIVE_LEVEL)
1189 SCSIPORTAPI
1190 VOID
1191 NTAPI
1192 ClassEnableMediaChangeDetection(
1193   _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension);
1194
1195 _IRQL_requires_max_(PASSIVE_LEVEL)
1196 SCSIPORTAPI
1197 VOID
1198 NTAPI
1199 ClassDisableMediaChangeDetection(
1200   _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension);
1201
1202 _IRQL_requires_max_(PASSIVE_LEVEL)
1203 SCSIPORTAPI
1204 VOID
1205 NTAPI
1206 ClassCleanupMediaChangeDetection(
1207   _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension);
1208
1209 _IRQL_requires_max_(PASSIVE_LEVEL)
1210 VOID
1211 NTAPI
1212 ClassGetDeviceParameter(
1213   _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension,
1214   _In_opt_ PWSTR SubkeyName,
1215   _In_ PWSTR ParameterName,
1216   _Inout_ PULONG ParameterValue);
1217
1218 _IRQL_requires_max_(PASSIVE_LEVEL)
1219 NTSTATUS
1220 NTAPI
1221 ClassSetDeviceParameter(
1222   _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension,
1223   _In_opt_ PWSTR SubkeyName,
1224   _In_ PWSTR ParameterName,
1225   _In_ ULONG ParameterValue);
1226
1227 #if (NTDDI_VERSION >= NTDDI_VISTA)
1228
1229 _IRQL_requires_max_(PASSIVE_LEVEL)
1230 PFILE_OBJECT_EXTENSION
1231 NTAPI
1232 ClassGetFsContext(
1233   _In_ PCOMMON_DEVICE_EXTENSION CommonExtension,
1234   _In_ PFILE_OBJECT FileObject);
1235
1236 _IRQL_requires_max_(DISPATCH_LEVEL)
1237 VOID
1238 NTAPI
1239 ClassSendNotification(
1240   _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension,
1241   _In_ const GUID *Guid,
1242   _In_ ULONG ExtraDataSize,
1243   _In_reads_bytes_opt_(ExtraDataSize) PVOID ExtraData);
1244
1245 #endif /* (NTDDI_VERSION >= NTDDI_VISTA) */
1246
1247 static __inline
1248 BOOLEAN
1249 PORT_ALLOCATED_SENSE(
1250   _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension,
1251   _In_ PSCSI_REQUEST_BLOCK Srb)
1252 {
1253   return ((BOOLEAN)((TEST_FLAG(Srb->SrbFlags, SRB_FLAGS_PORT_DRIVER_ALLOCSENSE) &&
1254           TEST_FLAG(Srb->SrbFlags, SRB_FLAGS_FREE_SENSE_BUFFER))                &&
1255           (Srb->SenseInfoBuffer != FdoExtension->SenseData)));
1256 }
1257
1258 static __inline
1259 VOID
1260 FREE_PORT_ALLOCATED_SENSE_BUFFER(
1261   _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension,
1262   _In_ PSCSI_REQUEST_BLOCK Srb)
1263 {
1264   ASSERT(TEST_FLAG(Srb->SrbFlags, SRB_FLAGS_PORT_DRIVER_ALLOCSENSE));
1265   ASSERT(TEST_FLAG(Srb->SrbFlags, SRB_FLAGS_FREE_SENSE_BUFFER));
1266   ASSERT(Srb->SenseInfoBuffer != FdoExtension->SenseData);
1267
1268   ExFreePool(Srb->SenseInfoBuffer);
1269   Srb->SenseInfoBuffer = FdoExtension->SenseData;
1270   Srb->SenseInfoBufferLength = SENSE_BUFFER_SIZE;
1271   CLEAR_FLAG(Srb->SrbFlags, SRB_FLAGS_FREE_SENSE_BUFFER);
1272   return;
1273 }
1274
1275 _IRQL_requires_max_(PASSIVE_LEVEL)
1276 typedef VOID
1277 (NTAPI *PCLASS_SCAN_FOR_SPECIAL_HANDLER)(
1278   _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension,
1279   _In_ ULONG_PTR Data);
1280
1281 _IRQL_requires_max_(PASSIVE_LEVEL)
1282 VOID
1283 NTAPI
1284 ClassScanForSpecial(
1285   _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension,
1286   _In_ CLASSPNP_SCAN_FOR_SPECIAL_INFO DeviceList[],
1287   _In_ PCLASS_SCAN_FOR_SPECIAL_HANDLER Function);