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