drivers/storage/classpnp/classp.h

   1 /*++
   2
   3 Copyright (C) Microsoft Corporation, 1991 - 1999
   4
   5 Module Name:
   6
   7     classp.h
   8
   9 Abstract:
  10
  11     Private header file for classpnp.sys modules.  This contains private
  12     structure and function declarations as well as constant values which do
  13     not need to be exported.
  14
  15 Author:
  16
  17 Environment:
  18
  19     kernel mode only
  20
  21 Notes:
  22
  23
  24 Revision History:
  25
  26 --*/
  27
  28 #ifndef _CLASSPNP_PCH_
  29 #define _CLASSPNP_PCH_
  30
  31 #include <ntddk.h>
  32 #include <classpnp.h>
  33 #include <ioevent.h>
  34 #include <pseh/pseh2.h>
  35
  36 extern CLASSPNP_SCAN_FOR_SPECIAL_INFO ClassBadItems[];
  37
  38 extern GUID ClassGuidQueryRegInfoEx;
  39
  40
  41 #define CLASSP_REG_SUBKEY_NAME                  (L"Classpnp")
  42
  43 #define CLASSP_REG_HACK_VALUE_NAME              (L"HackMask")
  44 #define CLASSP_REG_MMC_DETECTION_VALUE_NAME     (L"MMCDetectionState")
  45 #define CLASSP_REG_WRITE_CACHE_VALUE_NAME       (L"WriteCacheEnableOverride")
  46 #define CLASSP_REG_PERF_RESTORE_VALUE_NAME      (L"RestorePerfAtCount")
  47 #define CLASSP_REG_REMOVAL_POLICY_VALUE_NAME    (L"UserRemovalPolicy")
  48
  49 #define CLASS_PERF_RESTORE_MINIMUM (0x10)
  50 #define CLASS_ERROR_LEVEL_1 (0x4)
  51 #define CLASS_ERROR_LEVEL_2 (0x8)
  52
  53 #define FDO_HACK_CANNOT_LOCK_MEDIA (0x00000001)
  54 #define FDO_HACK_GESN_IS_BAD       (0x00000002)
  55 #define FDO_HACK_NO_SYNC_CACHE     (0x00000004)
  56
  57 #define FDO_HACK_VALID_FLAGS       (0x00000007)
  58 #define FDO_HACK_INVALID_FLAGS     (~FDO_HACK_VALID_FLAGS)
  59
  60 /*
  61  *  Lots of retries of synchronized SCSI commands that devices may not
  62  *  even support really slows down the system (especially while booting).
  63  *  (Even GetDriveCapacity may be failed on purpose if an external disk is powered off).
  64  *  If a disk cannot return a small initialization buffer at startup
  65  *  in two attempts (with delay interval) then we cannot expect it to return
  66  *  data consistently with four retries.
  67  *  So don't set the retry counts as high here as for data SRBs.
  68  *
  69  *  If we find that these requests are failing consecutively,
  70  *  despite the retry interval, on otherwise reliable media,
  71  *  then we should either increase the retry interval for
  72  *  that failure or (by all means) increase these retry counts as appropriate.
  73  */
  74 #define NUM_LOCKMEDIAREMOVAL_RETRIES    1
  75 #define NUM_MODESENSE_RETRIES           1
  76 #define NUM_DRIVECAPACITY_RETRIES       1
  77
  78
  79 #define CLASS_FILE_OBJECT_EXTENSION_KEY     'eteP'
  80 #define CLASSP_VOLUME_VERIFY_CHECKED        0x34
  81
  82 #define CLASS_TAG_PRIVATE_DATA              'CPcS'
  83 #define CLASS_TAG_PRIVATE_DATA_FDO          'FPcS'
  84 #define CLASS_TAG_PRIVATE_DATA_PDO          'PPcS'
  85
  86 struct _MEDIA_CHANGE_DETECTION_INFO {
  87
  88     //
  89     // Mutex to synchronize enable/disable requests and media state changes
  90     //
  91
  92     KMUTEX MediaChangeMutex;
  93
  94     //
  95     // The current state of the media (present, not present, unknown)
  96     // protected by MediaChangeSynchronizationEvent
  97     //
  98
  99     MEDIA_CHANGE_DETECTION_STATE MediaChangeDetectionState;
 100
 101     //
 102     // This is a count of how many time MCD has been disabled.  if it is
 103     // set to zero, then we'll poll the device for MCN events with the
 104     // then-current method (ie. TEST UNIT READY or GESN).  this is
 105     // protected by MediaChangeMutex
 106     //
 107
 108     LONG MediaChangeDetectionDisableCount;
 109
 110
 111     //
 112     // The timer value to support media change events.  This is a countdown
 113     // value used to determine when to poll the device for a media change.
 114     // The max value for the timer is 255 seconds.  This is not protected
 115     // by an event -- simply InterlockedExchanged() as needed.
 116     //
 117
 118     LONG MediaChangeCountDown;
 119
 120     //
 121     // recent changes allowed instant retries of the MCN irp.  Since this
 122     // could cause an infinite loop, keep a count of how many times we've
 123     // retried immediately so that we can catch if the count exceeds an
 124     // arbitrary limit.
 125     //
 126
 127     LONG MediaChangeRetryCount;
 128
 129     //
 130     // use GESN if it's available
 131     //
 132
 133     struct {
 134         BOOLEAN Supported;
 135         BOOLEAN HackEventMask;
 136         UCHAR   EventMask;
 137         UCHAR   NoChangeEventMask;
 138         PUCHAR  Buffer;
 139         PMDL    Mdl;
 140         ULONG   BufferSize;
 141     } Gesn;
 142
 143     //
 144     // If this value is one, then the irp is currently in use.
 145     // If this value is zero, then the irp is available.
 146     // Use InterlockedCompareExchange() to set from "available" to "in use".
 147     // ASSERT that InterlockedCompareExchange() showed previous value of
 148     //    "in use" when changing back to "available" state.
 149     // This also implicitly protects the MediaChangeSrb and SenseBuffer
 150     //
 151
 152     LONG MediaChangeIrpInUse;
 153
 154     //
 155     // Pointer to the irp to be used for media change detection.
 156     // protected by Interlocked MediaChangeIrpInUse
 157     //
 158
 159     PIRP MediaChangeIrp;
 160
 161     //
 162     // The srb for the media change detection.
 163     // protected by Interlocked MediaChangeIrpInUse
 164     //
 165
 166     SCSI_REQUEST_BLOCK MediaChangeSrb;
 167     PUCHAR SenseBuffer;
 168     ULONG SrbFlags;
 169
 170     //
 171     // Second timer to keep track of how long the media change IRP has been
 172     // in use.  If this value exceeds the timeout (#defined) then we should
 173     // print out a message to the user and set the MediaChangeIrpLost flag
 174     // protected by using Interlocked() operations in ClasspSendMediaStateIrp,
 175     // the only routine which should modify this value.
 176     //
 177
 178     LONG MediaChangeIrpTimeInUse;
 179
 180     //
 181     // Set by CdRomTickHandler when we determine that the media change irp has
 182     // been lost
 183     //
 184
 185     BOOLEAN MediaChangeIrpLost;
 186
 187 };
 188
 189 typedef enum {
 190     SimpleMediaLock,
 191     SecureMediaLock,
 192     InternalMediaLock
 193 } MEDIA_LOCK_TYPE, *PMEDIA_LOCK_TYPE;
 194
 195 typedef struct _FAILURE_PREDICTION_INFO {
 196     FAILURE_PREDICTION_METHOD Method;
 197     ULONG CountDown;                // Countdown timer
 198     ULONG Period;                   // Countdown period
 199
 200     PIO_WORKITEM WorkQueueItem;
 201
 202     KEVENT Event;
 203 } FAILURE_PREDICTION_INFO, *PFAILURE_PREDICTION_INFO;
 204
 205
 206
 207 //
 208 // This struct must always fit within four PVOIDs of info,
 209 // as it uses the irp's "PVOID DriverContext[4]" to store
 210 // this info
 211 //
 212 typedef struct _CLASS_RETRY_INFO {
 213     struct _CLASS_RETRY_INFO *Next;
 214 } CLASS_RETRY_INFO, *PCLASS_RETRY_INFO;
 215
 216
 217
 218 typedef struct _CSCAN_LIST {
 219
 220     //
 221     // The current block which has an outstanding request.
 222     //
 223
 224     ULONGLONG BlockNumber;
 225
 226     //
 227     // The list of blocks past the CurrentBlock to which we're going to do
 228     // i/o.  This list is maintained in sorted order.
 229     //
 230
 231     LIST_ENTRY CurrentSweep;
 232
 233     //
 234     // The list of blocks behind the current block for which we'll have to
 235     // wait until the next scan across the disk.  This is kept as a stack,
 236     // the cost of sorting it is taken when it's moved over to be the
 237     // running list.
 238     //
 239
 240     LIST_ENTRY NextSweep;
 241
 242 } CSCAN_LIST, *PCSCAN_LIST;
 243
 244 //
 245 // add to the front of this structure to help prevent illegal
 246 // snooping by other utilities.
 247 //
 248
 249
 250
 251 typedef enum _CLASS_DETECTION_STATE {
 252     ClassDetectionUnknown = 0,
 253     ClassDetectionUnsupported = 1,
 254     ClassDetectionSupported = 2
 255 } CLASS_DETECTION_STATE, *PCLASS_DETECTION_STATE;
 256
 257
 258 typedef struct _CLASS_ERROR_LOG_DATA {
 259     LARGE_INTEGER TickCount;        // Offset 0x00
 260     ULONG PortNumber;               // Offset 0x08
 261
 262     UCHAR ErrorPaging    : 1;       // Offset 0x0c
 263     UCHAR ErrorRetried   : 1;
 264     UCHAR ErrorUnhandled : 1;
 265     UCHAR ErrorReserved  : 5;
 266
 267     UCHAR Reserved[3];
 268
 269     SCSI_REQUEST_BLOCK Srb;     // Offset 0x10
 270
 271     /*
 272      *  We define the SenseData as the default length.
 273      *  Since the sense data returned by the port driver may be longer,
 274      *  SenseData must be at the end of this structure.
 275      *  For our internal error log, we only log the default length.
 276      */
 277     SENSE_DATA SenseData;     // Offset 0x50 for x86 (or 0x68 for ia64) (ULONG32 Alignment required!)
 278 } CLASS_ERROR_LOG_DATA, *PCLASS_ERROR_LOG_DATA;
 279
 280 #define NUM_ERROR_LOG_ENTRIES   16
 281
 282
 283
 284 typedef struct _TRANSFER_PACKET {
 285
 286         LIST_ENTRY AllPktsListEntry;    // entry in fdoData's static AllTransferPacketsList
 287         SINGLE_LIST_ENTRY SlistEntry;   // for when in free list (use fast slist)
 288
 289         PIRP Irp;
 290         PDEVICE_OBJECT Fdo;
 291
 292         /*
 293          *  This is the client IRP that this TRANSFER_PACKET is currently
 294          *  servicing.
 295          */
 296         PIRP OriginalIrp;
 297         BOOLEAN CompleteOriginalIrpWhenLastPacketCompletes;
 298
 299         /*
 300          *  Stuff for retrying the transfer.
 301          */
 302         ULONG NumRetries;
 303         KTIMER RetryTimer;
 304         KDPC RetryTimerDPC;
 305         ULONG RetryIntervalSec;
 306
 307         /*
 308          *  Event for synchronizing the transfer (optional).
 309          *  (Note that we can't have the event in the packet itself because
 310          *  by the time a thread waits on an event the packet may have
 311          *  been completed and re-issued.
 312          */
 313         PKEVENT SyncEventPtr;
 314
 315         /*
 316          *  Stuff for retrying during extreme low-memory stress
 317          *  (when we retry 1 page at a time).
 318          */
 319         BOOLEAN InLowMemRetry;
 320         PUCHAR LowMemRetry_remainingBufPtr;
 321         ULONG LowMemRetry_remainingBufLen;
 322         LARGE_INTEGER LowMemRetry_nextChunkTargetLocation;
 323
 324         /*
 325          *  Fields used for cancelling the packet.
 326          */
 327         // BOOLEAN Cancelled;
 328         // KEVENT CancelledEvent;
 329
 330         /*
 331          *  We keep the buffer and length values here as well
 332          *  as in the SRB because some miniports return
 333          *  the transferred length in SRB.DataTransferLength,
 334          *  and if the SRB failed we need that value again for the retry.
 335          *  We don't trust the lower stack to preserve any of these values in the SRB.
 336          */
 337         PUCHAR BufPtrCopy;
 338         ULONG BufLenCopy;
 339         LARGE_INTEGER TargetLocationCopy;
 340
 341         /*
 342          *  This is a standard SCSI structure that receives a detailed
 343          *  report about a SCSI error on the hardware.
 344          */
 345         SENSE_DATA SrbErrorSenseData;
 346
 347         /*
 348          *  This is the SRB block for this TRANSFER_PACKET.
 349          *  For IOCTLs, the SRB block includes two DWORDs for
 350          *  device object and ioctl code; so these must
 351          *  immediately follow the SRB block.
 352          */
 353         SCSI_REQUEST_BLOCK Srb;
 354         // ULONG SrbIoctlDevObj;        // not handling ioctls yet
 355         // ULONG SrbIoctlCode;
 356
 357 } TRANSFER_PACKET, *PTRANSFER_PACKET;
 358
 359 /*
 360  *  MIN_INITIAL_TRANSFER_PACKETS is the minimum number of packets that
 361  *  we preallocate at startup for each device (we need at least one packet
 362  *  to guarantee forward progress during memory stress).
 363  *  MIN_WORKINGSET_TRANSFER_PACKETS is the number of TRANSFER_PACKETs
 364  *  we allow to build up and remain for each device;
 365  *  we _lazily_ work down to this number when they're not needed.
 366  *  MAX_WORKINGSET_TRANSFER_PACKETS is the number of TRANSFER_PACKETs
 367  *  that we _immediately_ reduce to when they are not needed.
 368  *
 369  *  The absolute maximum number of packets that we will allocate is
 370  *  whatever is required by the current activity, up to the memory limit;
 371  *  as soon as stress ends, we snap down to MAX_WORKINGSET_TRANSFER_PACKETS;
 372  *  we then lazily work down to MIN_WORKINGSET_TRANSFER_PACKETS.
 373  */
 374 #define MIN_INITIAL_TRANSFER_PACKETS                     1
 375 #define MIN_WORKINGSET_TRANSFER_PACKETS_Consumer      4
 376 #define MAX_WORKINGSET_TRANSFER_PACKETS_Consumer     64
 377 #define MIN_WORKINGSET_TRANSFER_PACKETS_Server        64
 378 #define MAX_WORKINGSET_TRANSFER_PACKETS_Server      1024
 379 #define MIN_WORKINGSET_TRANSFER_PACKETS_Enterprise    256
 380 #define MAX_WORKINGSET_TRANSFER_PACKETS_Enterprise   2048
 381
 382
 383 //
 384 // add to the front of this structure to help prevent illegal
 385 // snooping by other utilities.
 386 //
 387 struct _CLASS_PRIVATE_FDO_DATA {
 388
 389     //
 390     // this private structure allows us to
 391     // dynamically re-enable the perf benefits
 392     // lost due to transient error conditions.
 393     // in w2k, a reboot was required. :(
 394     //
 395     struct {
 396         ULONG      OriginalSrbFlags;
 397         ULONG      SuccessfulIO;
 398         ULONG      ReEnableThreshhold; // 0 means never
 399     } Perf;
 400
 401     ULONG_PTR HackFlags;
 402
 403     STORAGE_HOTPLUG_INFO HotplugInfo;
 404
 405     // Legacy.  Still used by obsolete legacy code.
 406     struct {
 407         LARGE_INTEGER     Delta;       // in ticks
 408         LARGE_INTEGER     Tick;        // when it should fire
 409         PCLASS_RETRY_INFO ListHead;    // singly-linked list
 410         ULONG             Granularity; // static
 411         KSPIN_LOCK        Lock;        // protective spin lock
 412         KDPC              Dpc;         // DPC routine object
 413         KTIMER            Timer;       // timer to fire DPC
 414     } Retry;
 415
 416     BOOLEAN TimerStarted;
 417     BOOLEAN LoggedTURFailureSinceLastIO;
 418
 419     //
 420     // privately allocated release queue irp
 421     // protected by fdoExtension->ReleaseQueueSpinLock
 422     //
 423     BOOLEAN ReleaseQueueIrpAllocated;
 424     PIRP ReleaseQueueIrp;
 425
 426     /*
 427      *  Queues for TRANSFER_PACKETs that contextualize the IRPs and SRBs
 428      *  that we send down to the port driver.
 429      *  (The free list is an slist so that we can use fast
 430      *   interlocked operations on it; but the relatively-static
 431      *   AllTransferPacketsList list has to be
 432      *   a doubly-linked list since we have to dequeue from the middle).
 433      */
 434     LIST_ENTRY AllTransferPacketsList;
 435     SLIST_HEADER FreeTransferPacketsList;
 436     ULONG NumFreeTransferPackets;
 437     ULONG NumTotalTransferPackets;
 438     ULONG DbgPeakNumTransferPackets;
 439
 440     /*
 441      *  Queue for deferred client irps
 442      */
 443     LIST_ENTRY DeferredClientIrpList;
 444
 445     /*
 446      *  Precomputed maximum transfer length for the hardware.
 447      */
 448     ULONG HwMaxXferLen;
 449
 450     /*
 451      *  SCSI_REQUEST_BLOCK template preconfigured with the constant values.
 452      *  This is slapped into the SRB in the TRANSFER_PACKET for each transfer.
 453      */
 454     SCSI_REQUEST_BLOCK SrbTemplate;
 455
 456     KSPIN_LOCK SpinLock;
 457
 458     /*
 459      *  Circular array of timestamped logs of errors that occurred on this device.
 460      */
 461     ULONG ErrorLogNextIndex;
 462     CLASS_ERROR_LOG_DATA ErrorLogs[NUM_ERROR_LOG_ENTRIES];
 463
 464 };
 465
 466
 467 #define MIN(a, b)   ((a) < (b) ? (a) : (b))
 468 #define MAX(a, b)   ((a) > (b) ? (a) : (b))
 469
 470
 471 #define NOT_READY_RETRY_INTERVAL    10
 472 #define MINIMUM_RETRY_UNITS ((LONGLONG)32)
 473
 474
 475 /*
 476  *  Simple singly-linked-list queuing macros, with no synchronization.
 477  */
 478 static inline VOID SimpleInitSlistHdr(SINGLE_LIST_ENTRY *SListHdr)
 479 {
 480     SListHdr->Next = NULL;
 481 }
 482 static inline VOID SimplePushSlist(SINGLE_LIST_ENTRY *SListHdr, SINGLE_LIST_ENTRY *SListEntry)
 483 {
 484     SListEntry->Next = SListHdr->Next;
 485     SListHdr->Next = SListEntry;
 486 }
 487 static inline SINGLE_LIST_ENTRY *SimplePopSlist(SINGLE_LIST_ENTRY *SListHdr)
 488 {
 489     SINGLE_LIST_ENTRY *sListEntry = SListHdr->Next;
 490     if (sListEntry){
 491         SListHdr->Next = sListEntry->Next;
 492         sListEntry->Next = NULL;
 493     }
 494     return sListEntry;
 495 }
 496 static inline BOOLEAN SimpleIsSlistEmpty(SINGLE_LIST_ENTRY *SListHdr)
 497 {
 498     return (SListHdr->Next == NULL);
 499 }
 500
 501 DRIVER_INITIALIZE DriverEntry;
 502
 503 DRIVER_UNLOAD ClassUnload;
 504
 505 DRIVER_DISPATCH ClassCreateClose;
 506
 507 NTSTATUS
 508 NTAPI
 509 ClasspCreateClose(
 510     IN PDEVICE_OBJECT DeviceObject,
 511     IN PIRP Irp
 512     );
 513
 514 VOID
 515 NTAPI
 516 ClasspCleanupProtectedLocks(
 517     IN PFILE_OBJECT_EXTENSION FsContext
 518     );
 519
 520 NTSTATUS
 521 NTAPI
 522 ClasspEjectionControl(
 523     IN PDEVICE_OBJECT Fdo,
 524     IN PIRP Irp,
 525     IN MEDIA_LOCK_TYPE LockType,
 526     IN BOOLEAN Lock
 527     );
 528
 529 DRIVER_DISPATCH ClassReadWrite;
 530
 531 DRIVER_DISPATCH ClassDeviceControlDispatch;
 532
 533 DRIVER_DISPATCH ClassDispatchPnp;
 534
 535 NTSTATUS
 536 NTAPI
 537 ClassPnpStartDevice(
 538     IN PDEVICE_OBJECT DeviceObject
 539     );
 540
 541 NTSTATUS
 542 NTAPI
 543 ClassShutdownFlush(
 544     IN PDEVICE_OBJECT DeviceObject,
 545     IN PIRP Irp
 546     );
 547
 548 DRIVER_DISPATCH ClassSystemControl;
 549
 550 //
 551 // Class internal routines
 552 //
 553
 554 DRIVER_ADD_DEVICE ClassAddDevice;
 555
 556 IO_COMPLETION_ROUTINE ClasspSendSynchronousCompletion;
 557
 558 VOID
 559 NTAPI
 560 RetryRequest(
 561     PDEVICE_OBJECT DeviceObject,
 562     PIRP Irp,
 563     PSCSI_REQUEST_BLOCK Srb,
 564     BOOLEAN Associated,
 565     ULONG RetryInterval
 566     );
 567
 568 NTSTATUS
 569 NTAPI
 570 ClassIoCompletion(
 571     IN PDEVICE_OBJECT DeviceObject,
 572     IN PIRP Irp,
 573     IN PVOID Context
 574     );
 575
 576 NTSTATUS
 577 NTAPI
 578 ClassPnpQueryFdoRelations(
 579     IN PDEVICE_OBJECT Fdo,
 580     IN PIRP Irp
 581     );
 582
 583 NTSTATUS
 584 NTAPI
 585 ClassRetrieveDeviceRelations(
 586     IN PDEVICE_OBJECT Fdo,
 587     IN DEVICE_RELATION_TYPE RelationType,
 588     OUT PDEVICE_RELATIONS *DeviceRelations
 589     );
 590
 591 NTSTATUS
 592 NTAPI
 593 ClassGetPdoId(
 594     IN PDEVICE_OBJECT Pdo,
 595     IN BUS_QUERY_ID_TYPE IdType,
 596     IN PUNICODE_STRING IdString
 597     );
 598
 599 NTSTATUS
 600 NTAPI
 601 ClassQueryPnpCapabilities(
 602     IN PDEVICE_OBJECT PhysicalDeviceObject,
 603     IN PDEVICE_CAPABILITIES Capabilities
 604     );
 605
 606 DRIVER_STARTIO ClasspStartIo;
 607
 608 NTSTATUS
 609 NTAPI
 610 ClasspPagingNotificationCompletion(
 611     IN PDEVICE_OBJECT DeviceObject,
 612     IN PIRP Irp,
 613     IN PDEVICE_OBJECT RealDeviceObject
 614     );
 615
 616 NTSTATUS
 617 NTAPI
 618 ClasspMediaChangeCompletion(
 619     PDEVICE_OBJECT DeviceObject,
 620     PIRP Irp,
 621     PVOID Context
 622     );
 623
 624 PFILE_OBJECT_EXTENSION
 625 NTAPI
 626 ClasspGetFsContext(
 627     IN PCOMMON_DEVICE_EXTENSION CommonExtension,
 628     IN PFILE_OBJECT FileObject
 629     );
 630
 631 NTSTATUS
 632 NTAPI
 633 ClasspMcnControl(
 634     IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension,
 635     IN PIRP Irp,
 636     IN PSCSI_REQUEST_BLOCK Srb
 637     );
 638
 639 VOID
 640 NTAPI
 641 ClasspRegisterMountedDeviceInterface(
 642     IN PDEVICE_OBJECT DeviceObject
 643     );
 644
 645 NTSTATUS
 646 NTAPI
 647 ClasspDisableTimer(
 648     PDEVICE_OBJECT DeviceObject
 649     );
 650
 651 NTSTATUS
 652 NTAPI
 653 ClasspEnableTimer(
 654     PDEVICE_OBJECT DeviceObject
 655     );
 656
 657 //
 658 // routines for dictionary list support
 659 //
 660
 661 VOID
 662 NTAPI
 663 InitializeDictionary(
 664     IN PDICTIONARY Dictionary
 665     );
 666
 667 BOOLEAN
 668 NTAPI
 669 TestDictionarySignature(
 670     IN PDICTIONARY Dictionary
 671     );
 672
 673 NTSTATUS
 674 NTAPI
 675 AllocateDictionaryEntry(
 676     IN PDICTIONARY Dictionary,
 677     IN ULONGLONG Key,
 678     IN ULONG Size,
 679     IN ULONG Tag,
 680     OUT PVOID *Entry
 681     );
 682
 683 PVOID
 684 NTAPI
 685 GetDictionaryEntry(
 686     IN PDICTIONARY Dictionary,
 687     IN ULONGLONG Key
 688     );
 689
 690 VOID
 691 NTAPI
 692 FreeDictionaryEntry(
 693     IN PDICTIONARY Dictionary,
 694     IN PVOID Entry
 695     );
 696
 697
 698 NTSTATUS
 699 NTAPI
 700 ClasspAllocateReleaseRequest(
 701     IN PDEVICE_OBJECT Fdo
 702     );
 703
 704 VOID
 705 NTAPI
 706 ClasspFreeReleaseRequest(
 707     IN PDEVICE_OBJECT Fdo
 708     );
 709
 710 IO_COMPLETION_ROUTINE ClassReleaseQueueCompletion;
 711
 712 VOID
 713 NTAPI
 714 ClasspReleaseQueue(
 715     IN PDEVICE_OBJECT DeviceObject,
 716     IN PIRP ReleaseQueueIrp
 717     );
 718
 719 VOID
 720 NTAPI
 721 ClasspDisablePowerNotification(
 722     PFUNCTIONAL_DEVICE_EXTENSION FdoExtension
 723 );
 724
 725 //
 726 // class power routines
 727 //
 728
 729 DRIVER_DISPATCH ClassDispatchPower;
 730
 731 NTSTATUS
 732 NTAPI
 733 ClassMinimalPowerHandler(
 734     IN PDEVICE_OBJECT DeviceObject,
 735     IN PIRP Irp
 736     );
 737
 738 //
 739 // Child list routines
 740 //
 741
 742 VOID
 743 NTAPI
 744 ClassAddChild(
 745     IN PFUNCTIONAL_DEVICE_EXTENSION Parent,
 746     IN PPHYSICAL_DEVICE_EXTENSION Child,
 747     IN BOOLEAN AcquireLock
 748     );
 749
 750 PPHYSICAL_DEVICE_EXTENSION
 751 NTAPI
 752 ClassRemoveChild(
 753     IN PFUNCTIONAL_DEVICE_EXTENSION Parent,
 754     IN PPHYSICAL_DEVICE_EXTENSION Child,
 755     IN BOOLEAN AcquireLock
 756     );
 757
 758 VOID
 759 NTAPI
 760 ClasspRetryDpcTimer(
 761     IN PCLASS_PRIVATE_FDO_DATA FdoData
 762     );
 763
 764 KDEFERRED_ROUTINE ClasspRetryRequestDpc;
 765
 766 VOID
 767 NTAPI
 768 ClassFreeOrReuseSrb(
 769     IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension,
 770     IN PSCSI_REQUEST_BLOCK Srb
 771     );
 772
 773 VOID
 774 NTAPI
 775 ClassRetryRequest(
 776     IN PDEVICE_OBJECT SelfDeviceObject,
 777     IN PIRP           Irp,
 778     IN LARGE_INTEGER  TimeDelta100ns // in 100ns units
 779     );
 780
 781 VOID
 782 NTAPI
 783 ClasspBuildRequestEx(
 784     IN PFUNCTIONAL_DEVICE_EXTENSION Fdo,
 785     IN PIRP Irp,
 786     IN PSCSI_REQUEST_BLOCK Srb
 787     );
 788
 789 NTSTATUS
 790 NTAPI
 791 ClasspAllocateReleaseQueueIrp(
 792     IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension
 793     );
 794
 795 NTSTATUS
 796 NTAPI
 797 ClasspInitializeGesn(
 798     IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension,
 799     IN PMEDIA_CHANGE_DETECTION_INFO Info
 800     );
 801
 802 VOID
 803 NTAPI
 804 ClasspSendNotification(
 805     IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension,
 806     IN const GUID * Guid,
 807     IN ULONG  ExtraDataSize,
 808     IN PVOID  ExtraData
 809     );
 810
 811 VOID
 812 NTAPI
 813 ClassSendEjectionNotification(
 814     IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension
 815     );
 816
 817 VOID
 818 NTAPI
 819 ClasspScanForSpecialInRegistry(
 820     IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension
 821     );
 822
 823 VOID
 824 NTAPI
 825 ClasspScanForClassHacks(
 826     IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension,
 827     IN ULONG_PTR Data
 828     );
 829
 830 NTSTATUS
 831 NTAPI
 832 ClasspInitializeHotplugInfo(
 833     IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension
 834     );
 835
 836 VOID
 837 NTAPI
 838 ClasspPerfIncrementErrorCount(
 839     IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension
 840     );
 841 VOID
 842 NTAPI
 843 ClasspPerfIncrementSuccessfulIo(
 844     IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension
 845     );
 846
 847 PTRANSFER_PACKET NTAPI NewTransferPacket(PDEVICE_OBJECT Fdo);
 848 VOID NTAPI DestroyTransferPacket(PTRANSFER_PACKET Pkt);
 849 VOID NTAPI EnqueueFreeTransferPacket(PDEVICE_OBJECT Fdo, PTRANSFER_PACKET Pkt);
 850 PTRANSFER_PACKET NTAPI DequeueFreeTransferPacket(PDEVICE_OBJECT Fdo, BOOLEAN AllocIfNeeded);
 851 VOID NTAPI SetupReadWriteTransferPacket(PTRANSFER_PACKET pkt, PVOID Buf, ULONG Len, LARGE_INTEGER DiskLocation, PIRP OriginalIrp);
 852 VOID NTAPI SubmitTransferPacket(PTRANSFER_PACKET Pkt);
 853 NTSTATUS NTAPI TransferPktComplete(IN PDEVICE_OBJECT NullFdo, IN PIRP Irp, IN PVOID Context);
 854 VOID NTAPI ServiceTransferRequest(PDEVICE_OBJECT Fdo, PIRP Irp);
 855 VOID NTAPI TransferPacketRetryTimerDpc(IN PKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2);
 856 BOOLEAN NTAPI InterpretTransferPacketError(PTRANSFER_PACKET Pkt);
 857 BOOLEAN NTAPI RetryTransferPacket(PTRANSFER_PACKET Pkt);
 858 VOID NTAPI EnqueueDeferredClientIrp(PCLASS_PRIVATE_FDO_DATA FdoData, PIRP Irp);
 859 PIRP NTAPI DequeueDeferredClientIrp(PCLASS_PRIVATE_FDO_DATA FdoData);
 860 VOID NTAPI InitLowMemRetry(PTRANSFER_PACKET Pkt, PVOID BufPtr, ULONG Len, LARGE_INTEGER TargetLocation);
 861 BOOLEAN NTAPI StepLowMemRetry(PTRANSFER_PACKET Pkt);
 862 VOID NTAPI SetupEjectionTransferPacket(TRANSFER_PACKET *Pkt, BOOLEAN PreventMediaRemoval, PKEVENT SyncEventPtr, PIRP OriginalIrp);
 863 VOID NTAPI SetupModeSenseTransferPacket(TRANSFER_PACKET *Pkt, PKEVENT SyncEventPtr, PVOID ModeSenseBuffer, UCHAR ModeSenseBufferLen, UCHAR PageMode, PIRP OriginalIrp);
 864 VOID NTAPI SetupDriveCapacityTransferPacket(TRANSFER_PACKET *Pkt, PVOID ReadCapacityBuffer, ULONG ReadCapacityBufferLen, PKEVENT SyncEventPtr, PIRP OriginalIrp);
 865 PMDL NTAPI BuildDeviceInputMdl(PVOID Buffer, ULONG BufferLen);
 866 VOID NTAPI FreeDeviceInputMdl(PMDL Mdl);
 867 NTSTATUS NTAPI InitializeTransferPackets(PDEVICE_OBJECT Fdo);
 868 VOID NTAPI DestroyAllTransferPackets(PDEVICE_OBJECT Fdo);
 869
 870 #include "debug.h"
 871
 872 #endif /* _CLASSPNP_PCH_ */