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