include/ddk/iotypes.h

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