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