reactos/include/ddk/iotypes.h

   1 /* $Id: iotypes.h,v 1.32 2002/01/21 22:28:45 hbirr Exp $
   2  *
   3  */
   4
   5 #ifndef __INCLUDE_DDK_IOTYPES_H
   6 #define __INCLUDE_DDK_IOTYPES_H
   7
   8 #include <ntos/disk.h>
   9 #include <ntos/file.h>
  10
  11 #ifdef __NTOSKRNL__
  12 extern POBJECT_TYPE EXPORTED IoAdapterObjectType;
  13 extern POBJECT_TYPE EXPORTED IoDeviceHandlerObjectType;
  14 extern POBJECT_TYPE EXPORTED IoDeviceObjectType;
  15 extern POBJECT_TYPE EXPORTED IoDriverObjectType;
  16 extern POBJECT_TYPE EXPORTED IoFileObjectType;
  17 #else
  18 extern POBJECT_TYPE IMPORTED IoAdapterObjectType;
  19 extern POBJECT_TYPE IMPORTED IoDeviceHandlerObjectType;
  20 extern POBJECT_TYPE IMPORTED IoDeviceObjectType;
  21 extern POBJECT_TYPE IMPORTED IoDriverObjectType;
  22 extern POBJECT_TYPE IMPORTED IoFileObjectType;
  23 #endif
  24
  25 /*
  26  * These are referenced before they can be fully defined
  27  */
  28 struct _DRIVER_OBJECT;
  29 struct _FILE_OBJECT;
  30 struct _DEVICE_OBJECT;
  31 struct _IRP;
  32 struct _IO_STATUS_BLOCK;
  33
  34 /* SIMPLE TYPES *************************************************************/
  35
  36 enum
  37 {
  38    DeallocateObject,
  39    KeepObject,
  40 };
  41
  42
  43 typedef enum _CREATE_FILE_TYPE
  44 {
  45    CreateFileTypeNone,
  46    CreateFileTypeNamedPipe,
  47    CreateFileTypeMailslot
  48 } CREATE_FILE_TYPE;
  49
  50
  51 typedef struct _SHARE_ACCESS
  52 {
  53    ULONG OpenCount;
  54    ULONG Readers;
  55    ULONG Writers;
  56    ULONG Deleters;
  57    ULONG SharedRead;
  58    ULONG SharedWrite;
  59    ULONG SharedDelete;
  60 } SHARE_ACCESS, *PSHARE_ACCESS;
  61
  62 /* FUNCTION TYPES ************************************************************/
  63
  64 typedef VOID STDCALL
  65 (*PDRIVER_REINITIALIZE)(struct _DRIVER_OBJECT* DriverObject,
  66                         PVOID Context,
  67                         ULONG Count);
  68
  69 typedef NTSTATUS STDCALL
  70 (*PIO_QUERY_DEVICE_ROUTINE)(PVOID Context,
  71                             PUNICODE_STRING Pathname,
  72                             INTERFACE_TYPE BusType,
  73                             ULONG BusNumber,
  74                             PKEY_VALUE_FULL_INFORMATION* BI,
  75                             CONFIGURATION_TYPE ControllerType,
  76                             ULONG ControllerNumber,
  77                             PKEY_VALUE_FULL_INFORMATION* CI,
  78                             CONFIGURATION_TYPE PeripheralType,
  79                             ULONG PeripheralNumber,
  80                             PKEY_VALUE_FULL_INFORMATION* PI);
  81
  82 typedef NTSTATUS STDCALL
  83 (*PIO_COMPLETION_ROUTINE)(struct _DEVICE_OBJECT* DeviceObject,
  84                           struct _IRP* Irp,
  85                           PVOID Context);
  86
  87 typedef VOID STDCALL
  88 (*PIO_APC_ROUTINE)(PVOID ApcContext,
  89                    struct _IO_STATUS_BLOCK* IoStatusBlock,
  90                    ULONG Reserved);
  91
  92
  93 /* STRUCTURE TYPES ***********************************************************/
  94
  95 typedef struct _ADAPTER_OBJECT ADAPTER_OBJECT, *PADAPTER_OBJECT;
  96
  97 /*
  98  * PURPOSE: Special timer associated with each device
  99  * NOTES: This is a guess
 100  */
 101 typedef struct _IO_TIMER
 102 {
 103    KTIMER timer;
 104    KDPC dpc;
 105 } IO_TIMER, *PIO_TIMER;
 106
 107 typedef struct _IO_SECURITY_CONTEXT
 108 {
 109    PSECURITY_QUALITY_OF_SERVICE SecurityQos;
 110    PACCESS_STATE AccessState;
 111    ACCESS_MASK DesiredAccess;
 112    ULONG FullCreateOptions;
 113 } IO_SECURITY_CONTEXT, *PIO_SECURITY_CONTEXT;
 114
 115
 116 typedef struct _IO_RESOURCE_DESCRIPTOR
 117 {
 118    UCHAR Option;
 119    UCHAR Type;
 120    UCHAR ShareDisposition;
 121
 122    /*
 123     * Reserved for system use
 124     */
 125    UCHAR Spare1;
 126
 127    USHORT Flags;
 128
 129    /*
 130     * Reserved for system use
 131     */
 132    UCHAR Spare2;
 133
 134    union
 135      {
 136         struct
 137           {
 138              ULONG Length;
 139              ULONG Alignment;
 140              PHYSICAL_ADDRESS MinimumAddress;
 141              PHYSICAL_ADDRESS MaximumAddress;
 142           } Port;
 143         struct
 144           {
 145              ULONG Length;
 146              ULONG Alignment;
 147              PHYSICAL_ADDRESS MinimumAddress;
 148              PHYSICAL_ADDRESS MaximumAddress;
 149           } Memory;
 150         struct
 151           {
 152              ULONG MinimumVector;
 153              ULONG MaximumVector;
 154           } Interrupt;
 155         struct
 156           {
 157              ULONG MinimumChannel;
 158              ULONG MaximumChannel;
 159           } Dma;
 160      } u;
 161 } IO_RESOURCE_DESCRIPTOR, *PIO_RESOURCE_DESCRIPTOR;
 162
 163 // IO_RESOURCE_DESCRIPTOR Options
 164 #define IO_RESOURCE_REQUIRED    0x00
 165 #define IO_RESOURCE_PREFERRED   0x01
 166 #define IO_RESOURCE_DEFAULT     0x02
 167 #define IO_RESOURCE_ALTERNATIVE 0x08
 168
 169 typedef struct _IO_RESOURCE_LIST
 170 {
 171    USHORT Version;
 172    USHORT Revision;
 173    ULONG Count;
 174    IO_RESOURCE_DESCRIPTOR Descriptors[1];
 175 } IO_RESOURCE_LIST, *PIO_RESOURCE_LIST;
 176
 177 typedef struct _IO_RESOURCE_REQUIREMENTS_LIST
 178 {
 179    /*
 180     * List size in bytes
 181     */
 182    ULONG ListSize;
 183
 184    /*
 185     * System defined enum for the bus
 186     */
 187    INTERFACE_TYPE InterfaceType;
 188
 189    ULONG BusNumber;
 190    ULONG SlotNumber;
 191    ULONG Reserved[3];
 192    ULONG AlternativeLists;
 193    IO_RESOURCE_LIST List[1];
 194 } IO_RESOURCE_REQUIREMENTS_LIST, *PIO_RESOURCE_REQUIREMENTS_LIST;
 195
 196 typedef struct
 197 {
 198    UCHAR Type;
 199    UCHAR ShareDisposition;
 200    USHORT Flags;
 201    union
 202      {
 203         struct
 204           {
 205              PHYSICAL_ADDRESS Start;
 206              ULONG Length;
 207           } Port;
 208         struct
 209           {
 210              ULONG Level;
 211              ULONG Vector;
 212              ULONG Affinity;
 213           } Interrupt;
 214         struct
 215           {
 216              PHYSICAL_ADDRESS Start;
 217              ULONG Length;
 218           } Memory;
 219         struct
 220           {
 221              ULONG Channel;
 222              ULONG Port;
 223              ULONG Reserved1;
 224           } Dma;
 225         struct
 226           {
 227              ULONG DataSize;
 228              ULONG Reserved1;
 229              ULONG Reserved2;
 230           } DeviceSpecificData;
 231      } u;
 232 } CM_PARTIAL_RESOURCE_DESCRIPTOR, *PCM_PARTIAL_RESOURCE_DESCRIPTOR;
 233
 234 typedef struct
 235 {
 236    USHORT Version;
 237    USHORT Revision;
 238    ULONG Count;
 239    CM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptors[1];
 240 } CM_PARTIAL_RESOURCE_LIST;
 241
 242 typedef struct
 243 {
 244    INTERFACE_TYPE InterfaceType;
 245    ULONG BusNumber;
 246    CM_PARTIAL_RESOURCE_LIST PartialResourceList;
 247 } CM_FULL_RESOURCE_DESCRIPTOR;
 248
 249 typedef struct
 250 {
 251    ULONG Count;
 252    CM_FULL_RESOURCE_DESCRIPTOR List[1];
 253 } CM_RESOURCE_LIST, *PCM_RESOURCE_LIST;
 254
 255
 256 /*
 257  * PURPOSE: IRP stack location
 258  */
 259 typedef struct __attribute__((packed)) _IO_STACK_LOCATION
 260 {
 261    UCHAR MajorFunction;
 262    UCHAR MinorFunction;
 263    UCHAR Flags;
 264    UCHAR Control;
 265
 266    union
 267      {
 268         struct
 269           {
 270              PIO_SECURITY_CONTEXT SecurityContext;
 271              ULONG Options;
 272              USHORT FileAttributes;
 273              USHORT ShareAccess;
 274              ULONG EaLength;
 275           } Create;
 276         struct
 277           {
 278              ULONG Length;
 279              ULONG Key;
 280              LARGE_INTEGER ByteOffset;
 281           } Read;
 282         struct
 283           {
 284              ULONG Length;
 285              ULONG Key;
 286              LARGE_INTEGER ByteOffset;
 287           } Write;
 288         struct
 289           {
 290              ULONG OutputBufferLength;
 291              ULONG InputBufferLength;
 292              ULONG IoControlCode;
 293              PVOID Type3InputBuffer;
 294           } DeviceIoControl;
 295         struct
 296           {
 297              ULONG OutputBufferLength;
 298              ULONG InputBufferLength;
 299              ULONG IoControlCode;
 300              PVOID Type3InputBuffer;
 301           } FileSystemControl;
 302         struct
 303           {
 304              struct _VPB* Vpb;
 305              struct _DEVICE_OBJECT* DeviceObject;
 306           } Mount;
 307         struct
 308           {
 309              ULONG Length;
 310              FILE_INFORMATION_CLASS FileInformationClass;
 311           } QueryFile;
 312         struct
 313           {
 314              ULONG Length;
 315              FS_INFORMATION_CLASS FsInformationClass;
 316           } QueryVolume;
 317         struct
 318           {
 319              ULONG Length;
 320              FS_INFORMATION_CLASS FsInformationClass;
 321           } SetVolume;
 322         struct
 323           {
 324              ULONG Length;
 325              FILE_INFORMATION_CLASS FileInformationClass;
 326              struct _FILE_OBJECT* FileObject;
 327              union
 328                {
 329                   struct
 330                     {
 331                        BOOLEAN ReplaceIfExists;
 332                        BOOLEAN AdvanceOnly;
 333                     } d;
 334                   ULONG ClusterCount;
 335                   HANDLE DeleteHandle;
 336                } u;
 337           } SetFile;
 338         struct
 339           {
 340              ULONG Length;
 341              PUNICODE_STRING FileName;
 342              FILE_INFORMATION_CLASS FileInformationClass;
 343              ULONG FileIndex;
 344           } QueryDirectory;
 345
 346     // Parameters for IRP_MN_QUERY_DEVICE_RELATIONS
 347     struct {
 348       DEVICE_RELATION_TYPE Type;
 349     } QueryDeviceRelations;
 350
 351     // Parameters for IRP_MN_QUERY_INTERFACE
 352     struct {
 353       CONST GUID *InterfaceType;
 354       USHORT Size;
 355       USHORT Version;
 356       PINTERFACE Interface;
 357       PVOID InterfaceSpecificData;
 358     } QueryInterface;
 359
 360     // Parameters for IRP_MN_QUERY_CAPABILITIES
 361     struct {
 362       PDEVICE_CAPABILITIES Capabilities;
 363     } DeviceCapabilities;
 364
 365     // Parameters for IRP_MN_QUERY_ID
 366     struct {
 367       BUS_QUERY_ID_TYPE IdType;
 368     } QueryId;
 369
 370     // Parameters for IRP_MN_QUERY_DEVICE_TEXT
 371     struct {
 372       DEVICE_TEXT_TYPE DeviceTextType;
 373       LCID LocaleId;
 374     } QueryDeviceText;
 375
 376     // Parameters for IRP_MN_DEVICE_USAGE_NOTIFICATION
 377     struct {
 378       BOOLEAN InPath;
 379       BOOLEAN Reserved[3];
 380       DEVICE_USAGE_NOTIFICATION_TYPE Type;
 381     } UsageNotification;
 382
 383     // Parameters for IRP_MN_WAIT_WAKE
 384     struct {
 385       SYSTEM_POWER_STATE PowerState;
 386     } WaitWake;
 387
 388     // Parameter for IRP_MN_POWER_SEQUENCE
 389     struct {
 390       PPOWER_SEQUENCE PowerSequence;
 391     } PowerSequence;
 392
 393     // Parameters for IRP_MN_SET_POWER and IRP_MN_QUERY_POWER
 394     struct {
 395       ULONG SystemContext;
 396       POWER_STATE_TYPE Type;
 397       POWER_STATE State;
 398       POWER_ACTION ShutdownType;
 399     } Power;
 400
 401     // Parameters for IRP_MN_START_DEVICE
 402     struct {
 403       PCM_RESOURCE_LIST AllocatedResources;
 404       PCM_RESOURCE_LIST AllocatedResourcesTranslated;
 405     } StartDevice;
 406
 407   }  Parameters;
 408
 409    struct _DEVICE_OBJECT* DeviceObject;
 410    struct _FILE_OBJECT* FileObject;
 411
 412    PIO_COMPLETION_ROUTINE CompletionRoutine;
 413    PVOID CompletionContext;
 414
 415 } __attribute__((packed)) IO_STACK_LOCATION, *PIO_STACK_LOCATION;
 416
 417 typedef struct _IO_STATUS_BLOCK
 418 {
 419    NTSTATUS Status;
 420    ULONG Information;
 421 } IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
 422
 423
 424 typedef struct _IO_PIPE_CREATE_BUFFER
 425 {
 426    BOOLEAN WriteModeMessage;
 427    BOOLEAN ReadModeMessage;
 428    BOOLEAN NonBlocking;
 429    ULONG MaxInstances;
 430    ULONG InBufferSize;
 431    ULONG OutBufferSize;
 432    LARGE_INTEGER TimeOut;
 433 } IO_PIPE_CREATE_BUFFER, *PIO_PIPE_CREATE_BUFFER;
 434
 435
 436 typedef struct _IO_MAILSLOT_CREATE_BUFFER
 437 {
 438    ULONG Param; /* ?? */
 439    ULONG MaxMessageSize;
 440    LARGE_INTEGER TimeOut;
 441 } IO_MAILSLOT_CREATE_BUFFER, *PIO_MAILSLOT_CREATE_BUFFER;
 442
 443
 444 /*
 445  * Driver entry point declaration
 446  */
 447 typedef NTSTATUS STDCALL
 448 (*PDRIVER_INITIALIZE)(struct _DRIVER_OBJECT* DriverObject,
 449                       PUNICODE_STRING RegistryPath);
 450
 451 /*
 452  * Driver cancel declaration
 453  */
 454 typedef NTSTATUS STDCALL
 455 (*PDRIVER_CANCEL)(struct _DEVICE_OBJECT* DeviceObject,
 456                   struct _IRP* RegistryPath);
 457
 458
 459 typedef struct _SECTION_OBJECT_POINTERS
 460 {
 461    PVOID DataSectionObject;
 462    PVOID SharedCacheMap;
 463    PVOID ImageSectionObject;
 464 } SECTION_OBJECT_POINTERS, *PSECTION_OBJECT_POINTERS;
 465
 466 typedef struct _IO_COMPLETION_CONTEXT
 467 {
 468    PVOID Port;
 469    ULONG Key;
 470 } IO_COMPLETION_CONTEXT, *PIO_COMPLETION_CONTEXT;
 471
 472 #define FO_FILE_OPEN                    0x00000001
 473 #define FO_SYNCHRONOUS_IO               0x00000002
 474 #define FO_ALERTABLE_IO                 0x00000004
 475 #define FO_NO_INTERMEDIATE_BUFFERING    0x00000008
 476 #define FO_WRITE_THROUGH                0x00000010
 477 #define FO_SEQUENTIAL_ONLY              0x00000020
 478 #define FO_CACHE_SUPPORTED              0x00000040
 479 #define FO_NAMED_PIPE                   0x00000080
 480 #define FO_STREAM_FILE                  0x00000100
 481 #define FO_MAILSLOT                     0x00000200
 482 #define FO_GENERATE_AUDIT_ON_CLOSE      0x00000400
 483 #define FO_DIRECT_DEVICE_OPEN           0x00000800
 484 #define FO_FILE_MODIFIED                0x00001000
 485 #define FO_FILE_SIZE_CHANGED            0x00002000
 486 #define FO_CLEANUP_COMPLETE             0x00004000
 487 #define FO_TEMPORARY_FILE               0x00008000
 488 #define FO_DELETE_ON_CLOSE              0x00010000
 489 #define FO_OPENED_CASE_SENSITIVE        0x00020000
 490 #define FO_HANDLE_CREATED               0x00040000
 491 #define FO_FILE_FAST_IO_READ            0x00080000
 492
 493 /*
 494  * ReactOS specific flags
 495  */
 496 #define FO_DIRECT_CACHE_READ            0x72000001
 497 #define FO_DIRECT_CACHE_WRITE           0x72000002
 498 #define FO_DIRECT_CACHE_PAGING_READ     0x72000004
 499 #define FO_DIRECT_CACHE_PAGING_WRITE    0x72000008
 500 #define FO_FCB_IS_VALID                 0x72000010
 501
 502 typedef struct _FILE_OBJECT
 503 {
 504    CSHORT Type;
 505    CSHORT Size;
 506    struct _DEVICE_OBJECT* DeviceObject;
 507    struct _VPB* Vpb;
 508    PVOID FsContext;
 509    PVOID FsContext2;
 510    PSECTION_OBJECT_POINTERS SectionObjectPointers;
 511    PVOID PrivateCacheMap;
 512    NTSTATUS FinalStatus;
 513    struct _FILE_OBJECT* RelatedFileObject;
 514    BOOLEAN LockOperation;
 515    BOOLEAN DeletePending;
 516    BOOLEAN ReadAccess;
 517    BOOLEAN WriteAccess;
 518    BOOLEAN DeleteAccess;
 519    BOOLEAN SharedRead;
 520    BOOLEAN SharedWrite;
 521    BOOLEAN SharedDelete;
 522    ULONG Flags;
 523    UNICODE_STRING FileName;
 524    LARGE_INTEGER CurrentByteOffset;
 525    ULONG Waiters;
 526    ULONG Busy;
 527    PVOID LastLock;
 528    KEVENT Lock;
 529    KEVENT Event;
 530    PIO_COMPLETION_CONTEXT CompletionContext;
 531 } FILE_OBJECT, *PFILE_OBJECT;
 532
 533
 534 typedef struct _IRP
 535 {
 536    CSHORT Type;
 537    USHORT Size;
 538    PMDL MdlAddress;
 539    ULONG Flags;
 540    union
 541      {
 542         struct _IRP* MasterIrp;
 543         LONG IrpCount;
 544         PVOID SystemBuffer;
 545      } AssociatedIrp;
 546    LIST_ENTRY ThreadListEntry;
 547    IO_STATUS_BLOCK IoStatus;
 548    KPROCESSOR_MODE RequestorMode;
 549    BOOLEAN PendingReturned;
 550    CHAR StackCount;
 551    CHAR CurrentLocation;
 552    BOOLEAN Cancel;
 553    KIRQL CancelIrql;
 554    CCHAR ApcEnvironment;// CCHAR or PVOID?
 555    UCHAR AllocationFlags;//UCHAR or ULONG?
 556    PIO_STATUS_BLOCK UserIosb;
 557    PKEVENT UserEvent;
 558    union
 559      {
 560         struct
 561           {
 562              PIO_APC_ROUTINE UserApcRoutine;
 563              PVOID UserApcContext;
 564           } AsynchronousParameters;
 565         LARGE_INTEGER AllocationSize;
 566      } Overlay;
 567    PDRIVER_CANCEL CancelRoutine;
 568    PVOID UserBuffer;
 569    union
 570      {
 571         struct
 572           {
 573              union {
 574                KDEVICE_QUEUE_ENTRY DeviceQueueEntry;
 575                PVOID DriverContext[4];
 576              };
 577              struct _ETHREAD* Thread;
 578              PCHAR AuxiliaryBuffer;
 579              LIST_ENTRY ListEntry;
 580              struct _IO_STACK_LOCATION* CurrentStackLocation;
 581              PFILE_OBJECT OriginalFileObject;
 582           } Overlay;
 583         KAPC Apc;
 584         ULONG CompletionKey;
 585      } Tail;
 586    IO_STACK_LOCATION Stack[1];
 587 } IRP, *PIRP;
 588
 589 #define VPB_MOUNTED                     0x00000001
 590 #define VPB_LOCKED                      0x00000002
 591 #define VPB_PERSISTENT                  0x00000004
 592 #define VPB_REMOVE_PENDING              0x00000008
 593
 594 typedef struct _VPB
 595 {
 596    CSHORT Type;
 597    CSHORT Size;
 598    USHORT Flags;
 599    USHORT VolumeLabelLength;
 600    struct _DEVICE_OBJECT* DeviceObject;
 601    struct _DEVICE_OBJECT* RealDevice;
 602    ULONG SerialNumber;
 603    ULONG ReferenceCount;
 604    WCHAR VolumeLabel[MAXIMUM_VOLUME_LABEL_LENGTH];
 605 } VPB, *PVPB;
 606
 607
 608 typedef struct _DEVICE_OBJECT
 609 {
 610    CSHORT Type;
 611    CSHORT Size;
 612    LONG ReferenceCount;
 613    struct _DRIVER_OBJECT* DriverObject;
 614    struct _DEVICE_OBJECT* NextDevice;
 615    struct _DEVICE_OBJECT* AttachedDevice;
 616    struct _IRP* CurrentIrp;
 617    PIO_TIMER Timer;
 618    ULONG Flags;
 619    ULONG Characteristics;
 620    PVPB Vpb;
 621    PVOID DeviceExtension;
 622    DEVICE_TYPE DeviceType;
 623    CCHAR StackSize;
 624    union
 625      {
 626         LIST_ENTRY ListHead;
 627         WAIT_CONTEXT_BLOCK Wcb;
 628      } Queue;
 629    ULONG AlignmentRequirement;
 630    KDEVICE_QUEUE DeviceQueue;
 631    KDPC Dpc;
 632    ULONG ActiveThreadCount;
 633    PSECURITY_DESCRIPTOR SecurityDescriptor;
 634    KEVENT DeviceLock;
 635    USHORT SectorSize;
 636    USHORT Spare1;
 637    struct _DEVOBJ_EXTENSION* DeviceObjectExtension;
 638    PVOID Reserved;
 639 } DEVICE_OBJECT, *PDEVICE_OBJECT;
 640
 641 /*
 642  * Dispatch routine type declaration
 643  */
 644 typedef NTSTATUS STDCALL
 645 (*PDRIVER_DISPATCH)(struct _DEVICE_OBJECT*,
 646                     IRP*);
 647
 648
 649 /*
 650  * Fast i/o routine type declaration
 651  */
 652 //typedef NTSTATUS (*PFAST_IO_DISPATCH)(struct _DEVICE_OBJECT*, IRP*);
 653 //FIXME : this type is ok for read and write, but not for all routines
 654 typedef BOOLEAN STDCALL
 655 (*PFAST_IO_ROUTINE)(IN struct _FILE_OBJECT *FileObject,
 656                     IN PLARGE_INTEGER FileOffset,
 657                     IN ULONG Length,
 658                     IN BOOLEAN Wait,
 659                     IN ULONG LockKey,
 660                     OUT PVOID Buffer,
 661                     OUT PIO_STATUS_BLOCK IoStatus,
 662                     IN struct _DEVICE_OBJECT *DeviceObject);
 663
 664 typedef struct _FAST_IO_DISPATCH {
 665    ULONG SizeOfFastIoDispatch;
 666    PFAST_IO_ROUTINE FastIoCheckIfPossible;
 667    PFAST_IO_ROUTINE FastIoRead;
 668    PFAST_IO_ROUTINE FastIoWrite;
 669    PFAST_IO_ROUTINE FastIoQueryBasicInfo;
 670    PFAST_IO_ROUTINE FastIoQueryStandardInfo;
 671    PFAST_IO_ROUTINE FastIoLock;
 672    PFAST_IO_ROUTINE FastIoUnlockSingle;
 673    PFAST_IO_ROUTINE FastIoUnlockAll;
 674    PFAST_IO_ROUTINE FastIoUnlockAllByKey;
 675    PFAST_IO_ROUTINE FastIoDeviceControl;
 676    PFAST_IO_ROUTINE AcquireFileForNtCreateSection;
 677    PFAST_IO_ROUTINE ReleaseFileForNtCreateSection;
 678    PFAST_IO_ROUTINE FastIoDetachDevice;
 679    PFAST_IO_ROUTINE FastIoQueryNetworkOpenInfo;
 680    PFAST_IO_ROUTINE AcquireForModWrite;
 681    PFAST_IO_ROUTINE MdlRead;
 682    PFAST_IO_ROUTINE MdlReadComplete;
 683    PFAST_IO_ROUTINE PrepareMdlWrite;
 684    PFAST_IO_ROUTINE MdlWriteComplete;
 685    PFAST_IO_ROUTINE FastIoReadCompressed;
 686    PFAST_IO_ROUTINE FastIoWriteCompressed;
 687    PFAST_IO_ROUTINE MdlReadCompleteCompressed;
 688    PFAST_IO_ROUTINE MdlWriteCompleteCompressed;
 689    PFAST_IO_ROUTINE FastIoQueryOpen;
 690    PFAST_IO_ROUTINE ReleaseForModWrite;
 691    PFAST_IO_ROUTINE AcquireForCcFlush;
 692    PFAST_IO_ROUTINE ReleaseForCcFlush;
 693 } FAST_IO_DISPATCH, *PFAST_IO_DISPATCH;
 694
 695 /*
 696  * Dispatch routine type declaration
 697  */
 698 typedef VOID STDCALL
 699 (*PDRIVER_STARTIO)(IN PDEVICE_OBJECT DeviceObject,
 700                    IN PIRP Irp);
 701
 702 /*
 703  * Dispatch routine type declaration
 704  */
 705 typedef NTSTATUS STDCALL
 706 (*PDRIVER_UNLOAD)(struct _DRIVER_OBJECT*);
 707
 708 typedef NTSTATUS STDCALL
 709 (*PDRIVER_ADD_DEVICE)(IN struct _DRIVER_OBJECT *DriverObject,
 710                       IN struct _DEVICE_OBJECT *PhysicalDeviceObject);
 711
 712
 713 typedef struct _DRIVER_EXTENSION
 714 {
 715    struct _DRIVER_OBJECT* DriverObject;
 716    PDRIVER_ADD_DEVICE AddDevice;
 717    ULONG Count;
 718    UNICODE_STRING ServiceKeyName;
 719 } DRIVER_EXTENSION, *PDRIVER_EXTENSION;
 720
 721 #if 0
 722 typedef
 723 struct _FAST_IO_DISPATCH_TABLE
 724 {
 725         ULONG                   Count;
 726         PFAST_IO_DISPATCH       Dispatch;
 727
 728 } FAST_IO_DISPATCH_TABLE, * PFAST_IO_DISPATCH_TABLE;
 729 #endif
 730
 731 typedef struct _DRIVER_OBJECT
 732 {
 733    CSHORT Type;
 734    CSHORT Size;
 735    PDEVICE_OBJECT DeviceObject;
 736    ULONG Flags;
 737    PVOID DriverStart;
 738    ULONG DriverSize;
 739    PVOID DriverSection;
 740    PDRIVER_EXTENSION DriverExtension;
 741    UNICODE_STRING DriverName;
 742    PUNICODE_STRING HardwareDatabase;
 743 #if 0
 744    PFAST_IO_DISPATCH_TABLE FastIoDispatch;
 745 #else
 746    PFAST_IO_DISPATCH FastIoDispatch;
 747 #endif
 748    PDRIVER_INITIALIZE DriverInit;
 749    PDRIVER_STARTIO DriverStartIo;
 750    PDRIVER_UNLOAD DriverUnload;
 751    PDRIVER_DISPATCH MajorFunction[IRP_MJ_MAXIMUM_FUNCTION + 1];
 752 } DRIVER_OBJECT, *PDRIVER_OBJECT;
 753
 754
 755 typedef struct _CONFIGURATION_INFORMATION
 756 {
 757    ULONG DiskCount;
 758    ULONG FloppyCount;
 759    ULONG CDRomCount;
 760    ULONG TapeCount;
 761    ULONG ScsiPortCount;
 762    ULONG SerialCount;
 763    ULONG ParallelCount;
 764    BOOLEAN AtDiskPrimaryAddressClaimed;
 765    BOOLEAN AtDiskSecondaryAddressClaimed;
 766 } CONFIGURATION_INFORMATION, *PCONFIGURATION_INFORMATION;
 767
 768 typedef VOID STDCALL
 769 (*PIO_DPC_ROUTINE)(PKDPC Dpc,
 770                    PDEVICE_OBJECT DeviceObject,
 771                    PIRP Irp,
 772                    PVOID Context);
 773
 774 typedef VOID STDCALL
 775 (*PIO_TIMER_ROUTINE)(PDEVICE_OBJECT DeviceObject,
 776                      PVOID Context);
 777
 778 #if WINDOWS_STRUCTS_DOESNT_ALREADY_DEFINE_THIS
 779 typedef struct _PARTITION_INFORMATION
 780 {
 781    LARGE_INTEGER StartingOffset;
 782    LARGE_INTEGER PartitionLength;
 783    ULONG HiddenSectors;
 784    ULONG PartitionNumber;
 785    UCHAR PartitionType;
 786    BOOLEAN BootIndicator;
 787    BOOLEAN RecognizedPartition;
 788    BOOLEAN RewritePartition;
 789 } PARTITION_INFORMATION, *PPARTITION_INFORMATION;
 790 #endif
 791
 792 typedef struct _DRIVER_LAYOUT_INFORMATION
 793 {
 794    ULONG PartitionCount;
 795    ULONG Signature;
 796    PARTITION_INFORMATION PartitionEntry[1];
 797 } DRIVER_LAYOUT_INFORMATION, *PDRIVER_LAYOUT_INFORMATION;
 798
 799
 800 typedef IO_ALLOCATION_ACTION STDCALL
 801 (*PDRIVER_CONTROL)(PDEVICE_OBJECT DeviceObject,
 802                    PIRP Irp,
 803                    PVOID MapRegisterBase,
 804                    PVOID Context);
 805 #if (_WIN32_WINNT >= 0x0400)
 806 typedef VOID STDCALL
 807 (*PFSDNOTIFICATIONPROC)(IN PDEVICE_OBJECT PtrTargetFileSystemDeviceObject,
 808                         IN BOOLEAN DriverActive);
 809 #endif // (_WIN32_WINNT >= 0x0400)
 810
 811 #endif /* __INCLUDE_DDK_IOTYPES_H */