reactos/include/ddk/ketypes.h

   1 /* KERNEL TYPES **************************************************************/
   2
   3 #ifndef __INCLUDE_DDK_KETYPES_H
   4 #define __INCLUDE_DDK_KETYPES_H
   5
   6 /* include ntos/ketypes.h here? */
   7
   8 struct _KMUTANT;
   9
  10 typedef LONG KPRIORITY;
  11
  12 typedef LONG FLONG;
  13
  14 typedef VOID STDCALL_FUNC
  15 (*PKBUGCHECK_CALLBACK_ROUTINE)(PVOID Buffer, ULONG Length);
  16
  17 typedef BOOLEAN STDCALL_FUNC
  18 (*PKSYNCHRONIZE_ROUTINE)(PVOID SynchronizeContext);
  19
  20 struct _KAPC;
  21
  22 typedef VOID STDCALL_FUNC
  23 (*PKNORMAL_ROUTINE)(PVOID NormalContext,
  24                     PVOID SystemArgument1,
  25                     PVOID SystemArgument2);
  26
  27 typedef VOID STDCALL_FUNC
  28 (*PKKERNEL_ROUTINE)(struct _KAPC* Apc,
  29                     PKNORMAL_ROUTINE* NormalRoutine,
  30                     PVOID* NormalContext,
  31                     PVOID* SystemArgument1,
  32                     PVOID* SystemArgument2);
  33
  34 typedef VOID STDCALL_FUNC
  35 (*PKRUNDOWN_ROUTINE)(struct _KAPC* Apc);
  36
  37 struct _DISPATCHER_HEADER;
  38
  39
  40
  41 #include <pshpack1.h>
  42
  43 typedef struct _DISPATCHER_HEADER
  44 {
  45    UCHAR      Type;
  46    UCHAR      Absolute;
  47    UCHAR      Size;
  48    UCHAR      Inserted;
  49    LONG       SignalState;
  50    LIST_ENTRY WaitListHead;
  51 } DISPATCHER_HEADER, *PDISPATCHER_HEADER;
  52
  53 #include <poppack.h>
  54
  55 typedef struct _KQUEUE
  56 {
  57    DISPATCHER_HEADER Header;
  58    LIST_ENTRY        EntryListHead;
  59    ULONG             CurrentCount;
  60    ULONG             MaximumCount;
  61    LIST_ENTRY        ThreadListHead;
  62 } KQUEUE, *PKQUEUE;
  63
  64 struct _KDPC;
  65
  66 typedef struct _KTIMER
  67  {
  68     DISPATCHER_HEADER Header;
  69     ULARGE_INTEGER DueTime;
  70     LIST_ENTRY TimerListEntry;
  71     struct _KDPC* Dpc;
  72     LONG Period;
  73 } KTIMER, *PKTIMER;
  74
  75 typedef ULONG_PTR KSPIN_LOCK, *PKSPIN_LOCK;
  76
  77 typedef struct _KDEVICE_QUEUE
  78 {
  79   CSHORT Type;
  80   CSHORT Size;
  81   LIST_ENTRY DeviceListHead;
  82   KSPIN_LOCK Lock;
  83   BOOLEAN Busy;
  84 } KDEVICE_QUEUE, *PKDEVICE_QUEUE;
  85
  86
  87 #include <pshpack1.h>
  88
  89 typedef struct _KAPC
  90 {
  91    CSHORT Type;
  92    CSHORT Size;
  93    ULONG Spare0;
  94    struct _KTHREAD* Thread;
  95    LIST_ENTRY ApcListEntry;
  96    PKKERNEL_ROUTINE KernelRoutine;
  97    PKRUNDOWN_ROUTINE RundownRoutine;
  98    PKNORMAL_ROUTINE NormalRoutine;
  99    PVOID NormalContext;
 100    PVOID SystemArgument1;
 101    PVOID SystemArgument2;
 102    CCHAR ApcStateIndex;
 103    KPROCESSOR_MODE ApcMode;
 104    USHORT Inserted;
 105 } KAPC, *PKAPC;
 106
 107 #include <poppack.h>
 108
 109 typedef struct _KBUGCHECK_CALLBACK_RECORD
 110 {
 111    LIST_ENTRY Entry;
 112    PKBUGCHECK_CALLBACK_ROUTINE CallbackRoutine;
 113    PVOID Buffer;
 114    ULONG Length;
 115    PUCHAR Component;
 116    ULONG Checksum;
 117    UCHAR State;
 118 } KBUGCHECK_CALLBACK_RECORD, *PKBUGCHECK_CALLBACK_RECORD;
 119
 120 typedef struct _KMUTEX
 121 {
 122    DISPATCHER_HEADER Header;
 123    LIST_ENTRY MutantListEntry;
 124    struct _KTHREAD* OwnerThread;
 125    BOOLEAN Abandoned;
 126    UCHAR ApcDisable;
 127 } KMUTEX, *PKMUTEX, KMUTANT, *PKMUTANT;
 128
 129 #include <pshpack1.h>
 130
 131 typedef struct _KSEMAPHORE
 132 {
 133    DISPATCHER_HEADER Header;
 134    LONG Limit;
 135 } KSEMAPHORE, *PKSEMAPHORE;
 136
 137 #include <poppack.h>
 138
 139 typedef struct _KEVENT
 140 {
 141    DISPATCHER_HEADER Header;
 142 } KEVENT, *PKEVENT;
 143
 144 typedef struct _KEVENT_PAIR
 145 {
 146    CSHORT Type;
 147    CSHORT Size;
 148    KEVENT LowEvent;
 149    KEVENT HighEvent;
 150 } KEVENT_PAIR, *PKEVENT_PAIR;
 151
 152
 153 struct _KDPC;
 154
 155 typedef struct _KSPIN_LOCK_QUEUE {
 156     struct _KSPIN_LOCK_QUEUE * volatile Next;
 157     PKSPIN_LOCK volatile Lock;
 158 } KSPIN_LOCK_QUEUE, *PKSPIN_LOCK_QUEUE;
 159
 160 typedef struct _KLOCK_QUEUE_HANDLE {
 161     KSPIN_LOCK_QUEUE LockQueue;
 162     KIRQL OldIrql;
 163 } KLOCK_QUEUE_HANDLE, *PKLOCK_QUEUE_HANDLE;
 164
 165 typedef struct _KWAIT_BLOCK
 166 /*
 167  * PURPOSE: Object describing the wait a thread is currently performing
 168  */
 169 {
 170    LIST_ENTRY WaitListEntry;
 171    struct _KTHREAD* Thread;
 172    struct _DISPATCHER_HEADER *Object;
 173    struct _KWAIT_BLOCK* NextWaitBlock;
 174    USHORT WaitKey;
 175    USHORT WaitType;
 176 } KWAIT_BLOCK, *PKWAIT_BLOCK;
 177
 178 /*
 179  * PURPOSE: Defines a delayed procedure call routine
 180  * NOTE:
 181  *      Dpc = The associated DPC object
 182  *      DeferredContext = Driver defined context for the DPC
 183  *      SystemArgument[1-2] = Undocumented.
 184  *
 185  */
 186 typedef VOID STDCALL_FUNC
 187 (*PKDEFERRED_ROUTINE)(struct _KDPC* Dpc,
 188                       PVOID DeferredContext,
 189                       PVOID SystemArgument1,
 190                       PVOID SystemArgument2);
 191
 192 /*
 193  * PURPOSE: Defines a delayed procedure call object
 194  */
 195 #include <pshpack1.h>
 196
 197 typedef struct _KDPC
 198 {
 199    SHORT Type;
 200    UCHAR Number;
 201    UCHAR Importance;
 202    LIST_ENTRY DpcListEntry;
 203    PKDEFERRED_ROUTINE DeferredRoutine;
 204    PVOID DeferredContext;
 205    PVOID SystemArgument1;
 206    PVOID SystemArgument2;
 207    PULONG Lock;
 208 } KDPC, *PKDPC;
 209
 210 #include <poppack.h>
 211
 212
 213 typedef struct _KDEVICE_QUEUE_ENTRY
 214 {
 215    LIST_ENTRY DeviceListEntry;
 216    ULONG SortKey;
 217    BOOLEAN Inserted;
 218 } KDEVICE_QUEUE_ENTRY, *PKDEVICE_QUEUE_ENTRY;
 219
 220 typedef struct _WAIT_CONTEXT_BLOCK
 221 {
 222   KDEVICE_QUEUE_ENTRY WaitQueueEntry;
 223   /*
 224    * XXX THIS IS WRONG XXX
 225    *
 226    * Our headers have enough circular dependancies that
 227    * I can't figure out, given 5 minutes of testing, what
 228    * order to include them in to get PDRIVER_CONTROL to be
 229    * defined here.  The proper definition of the next item
 230    * is:
 231    *
 232    * PDRIVER_CONTROL DeviceRoutine;
 233    *
 234    * but instead we use PVOID until headers are fixed.
 235    */
 236   PVOID DeviceRoutine;
 237   PVOID DeviceContext;
 238   ULONG NumberOfMapRegisters;
 239   PVOID DeviceObject;
 240   PVOID CurrentIrp;
 241   PKDPC BufferChainingDpc;
 242 } WAIT_CONTEXT_BLOCK, *PWAIT_CONTEXT_BLOCK;
 243
 244 typedef enum _KBUGCHECK_CALLBACK_REASON {
 245     KbCallbackInvalid,
 246     KbCallbackReserved1,
 247     KbCallbackSecondaryDumpData,
 248     KbCallbackDumpIo,
 249 } KBUGCHECK_CALLBACK_REASON;
 250
 251 typedef
 252 VOID
 253 (*PKBUGCHECK_REASON_CALLBACK_ROUTINE) (
 254     IN KBUGCHECK_CALLBACK_REASON Reason,
 255     IN PVOID Record, // This should be struct _KBUGCHECK_REASON_CALLBACK_RECORD* but minggw doesn't want to allow that...
 256     IN OUT PVOID ReasonSpecificData,
 257     IN ULONG ReasonSpecificDataLength
 258     );
 259
 260 typedef struct _KBUGCHECK_REASON_CALLBACK_RECORD {
 261     LIST_ENTRY Entry;
 262     PKBUGCHECK_REASON_CALLBACK_ROUTINE CallbackRoutine;
 263     PUCHAR Component;
 264     ULONG_PTR Checksum;
 265     KBUGCHECK_CALLBACK_REASON Reason;
 266     UCHAR State;
 267 } KBUGCHECK_REASON_CALLBACK_RECORD, *PKBUGCHECK_REASON_CALLBACK_RECORD;
 268
 269 struct _KINTERRUPT;
 270
 271 typedef BOOLEAN STDCALL_FUNC
 272 (*PKSERVICE_ROUTINE)(struct _KINTERRUPT* Interrupt,
 273                      PVOID ServiceContext);
 274 typedef struct _EPROCESS EPROCESS, *PEPROCESS;
 275
 276 typedef HANDLE HSEMAPHORE;
 277
 278 typedef HANDLE HDRVOBJ;
 279
 280 typedef LONG FLOAT_LONG, *PFLOAT_LONG;
 281
 282 typedef LONG FLOATL;
 283
 284 typedef LONG FIX; /* fixed-point number */
 285
 286 typedef struct _M128 {
 287     ULONGLONG Low;
 288     LONGLONG High;
 289 } M128, *PM128;
 290
 291 typedef struct _KEXCEPTION_FRAME {
 292     ULONG64 P1Home;
 293     ULONG64 P2Home;
 294     ULONG64 P3Home;
 295     ULONG64 P4Home;
 296     ULONG64 P5;
 297     ULONG64 InitialStack;
 298     M128 Xmm6;
 299     M128 Xmm7;
 300     M128 Xmm8;
 301     M128 Xmm9;
 302     M128 Xmm10;
 303     M128 Xmm11;
 304     M128 Xmm12;
 305     M128 Xmm13;
 306     M128 Xmm14;
 307     M128 Xmm15;
 308     ULONG64 TrapFrame;
 309     ULONG64 CallbackStack;
 310     ULONG64 OutputBuffer;
 311     ULONG64 OutputLength;
 312     UCHAR ExceptionRecord[64];
 313     ULONG64 Fill1;
 314     ULONG64 Rbp;
 315     ULONG64 Rbx;
 316     ULONG64 Rdi;
 317     ULONG64 Rsi;
 318     ULONG64 R12;
 319     ULONG64 R13;
 320     ULONG64 R14;
 321     ULONG64 R15;
 322     ULONG64 Return;
 323 } KEXCEPTION_FRAME, *PKEXCEPTION_FRAME;
 324
 325 /* copied from W32API */
 326 typedef struct _KFLOATING_SAVE
 327 {
 328   ULONG  ControlWord;
 329   ULONG  StatusWord;
 330   ULONG  ErrorOffset;
 331   ULONG  ErrorSelector;
 332   ULONG  DataOffset;
 333   ULONG  DataSelector;
 334   ULONG  Cr0NpxState;
 335   ULONG  Spare1;
 336 } KFLOATING_SAVE, *PKFLOATING_SAVE;
 337
 338 #endif /* __INCLUDE_DDK_KETYPES_H */