include/ddk/wdm.h

   1 #ifndef _WDMDDK_
   2 #define _WDMDDK_
   3
   4 /* Helper macro to enable gcc's extension.  */
   5 #ifndef __GNU_EXTENSION
   6 #ifdef __GNUC__
   7 #define __GNU_EXTENSION __extension__
   8 #else
   9 #define __GNU_EXTENSION
  10 #endif
  11 #endif
  12
  13 //
  14 // Dependencies
  15 //
  16 #define NT_INCLUDED
  17 #include <excpt.h>
  18 #include <ntdef.h>
  19 #include <ntstatus.h>
  20
  21 #ifndef GUID_DEFINED
  22 #include <guiddef.h>
  23 #endif /* GUID_DEFINED */
  24
  25 #include "intrin.h"
  26
  27 #ifdef __cplusplus
  28 extern "C" {
  29 #endif
  30
  31 #define NTKERNELAPI DECLSPEC_IMPORT
  32
  33 #ifdef _WIN64
  34 #define PORT_MAXIMUM_MESSAGE_LENGTH 512
  35 #else
  36 #define PORT_MAXIMUM_MESSAGE_LENGTH 256
  37 #endif
  38
  39
  40 #if defined(_MSC_VER)
  41
  42 //
  43 // Indicate if #pragma alloc_text() is supported
  44 //
  45 #if defined(_M_IX86) || defined(_M_AMD64) || defined(_M_IA64)
  46 #define ALLOC_PRAGMA 1
  47 #endif
  48
  49 //
  50 // Indicate if #pragma data_seg() is supported
  51 //
  52 #if defined(_M_IX86) || defined(_M_AMD64)
  53 #define ALLOC_DATA_PRAGMA 1
  54 #endif
  55
  56 #endif
  57
  58
  59 /*
  60  * Alignment Macros
  61  */
  62 #define ALIGN_DOWN(s, t) \
  63     ((ULONG)(s) & ~(sizeof(t) - 1))
  64
  65 #define ALIGN_UP(s, t) \
  66     (ALIGN_DOWN(((ULONG)(s) + sizeof(t) - 1), t))
  67
  68 #define ALIGN_DOWN_POINTER(p, t) \
  69     ((PVOID)((ULONG_PTR)(p) & ~((ULONG_PTR)sizeof(t) - 1)))
  70
  71 #define ALIGN_UP_POINTER(p, t) \
  72     (ALIGN_DOWN_POINTER(((ULONG_PTR)(p) + sizeof(t) - 1), t))
  73
  74 /*
  75  * GUID Comparison
  76  */
  77
  78 #ifndef __IID_ALIGNED__
  79     #define __IID_ALIGNED__
  80     #ifdef __cplusplus
  81         inline int IsEqualGUIDAligned(REFGUID guid1, REFGUID guid2)
  82         {
  83             return ((*(PLONGLONG)(&guid1) == *(PLONGLONG)(&guid2)) && (*((PLONGLONG)(&guid1) + 1) == *((PLONGLONG)(&guid2) + 1)));
  84         }
  85     #else
  86         #define IsEqualGUIDAligned(guid1, guid2) \
  87             ((*(PLONGLONG)(guid1) == *(PLONGLONG)(guid2)) && (*((PLONGLONG)(guid1) + 1) == *((PLONGLONG)(guid2) + 1)))
  88     #endif
  89 #endif
  90
  91 /* Simple types */
  92 typedef UCHAR KPROCESSOR_MODE;
  93 typedef LONG KPRIORITY;
  94 typedef PVOID PSECURITY_DESCRIPTOR;
  95 typedef ULONG SECURITY_INFORMATION, *PSECURITY_INFORMATION;
  96
  97 /* Structures not exposed to drivers */
  98 typedef struct _OBJECT_TYPE *POBJECT_TYPE;
  99 typedef struct _HAL_DISPATCH_TABLE *PHAL_DISPATCH_TABLE;
 100 typedef struct _HAL_PRIVATE_DISPATCH_TABLE *PHAL_PRIVATE_DISPATCH_TABLE;
 101 typedef struct _DEVICE_HANDLER_OBJECT *PDEVICE_HANDLER_OBJECT;
 102 typedef struct _BUS_HANDLER *PBUS_HANDLER;
 103
 104 typedef struct _ADAPTER_OBJECT *PADAPTER_OBJECT;
 105 typedef struct _CALLBACK_OBJECT *PCALLBACK_OBJECT;
 106 typedef struct _ETHREAD *PETHREAD;
 107 typedef struct _EPROCESS *PEPROCESS;
 108 typedef struct _IO_TIMER *PIO_TIMER;
 109 typedef struct _KINTERRUPT *PKINTERRUPT;
 110 typedef struct _KPROCESS *PKPROCESS;
 111 typedef struct _KTHREAD *PKTHREAD, *PRKTHREAD;
 112
 113
 114 typedef struct _CONTEXT *PCONTEXT;
 115
 116 //
 117 // Resource list definitions
 118 //
 119 typedef int CM_RESOURCE_TYPE;
 120
 121 #define CmResourceTypeNull              0
 122 #define CmResourceTypePort              1
 123 #define CmResourceTypeInterrupt         2
 124 #define CmResourceTypeMemory            3
 125 #define CmResourceTypeDma               4
 126 #define CmResourceTypeDeviceSpecific    5
 127 #define CmResourceTypeBusNumber         6
 128 #define CmResourceTypeNonArbitrated       128
 129 #define CmResourceTypeConfigData          128
 130 #define CmResourceTypeDevicePrivate       129
 131 #define CmResourceTypePcCardConfig        130
 132 #define CmResourceTypeMfCardConfig        131
 133
 134 typedef enum _INTERFACE_TYPE {
 135   InterfaceTypeUndefined = -1,
 136   Internal,
 137   Isa,
 138   Eisa,
 139   MicroChannel,
 140   TurboChannel,
 141   PCIBus,
 142   VMEBus,
 143   NuBus,
 144   PCMCIABus,
 145   CBus,
 146   MPIBus,
 147   MPSABus,
 148   ProcessorInternal,
 149   InternalPowerBus,
 150   PNPISABus,
 151   PNPBus,
 152   MaximumInterfaceType
 153 } INTERFACE_TYPE, *PINTERFACE_TYPE;
 154
 155 /* IO_RESOURCE_DESCRIPTOR.Option */
 156
 157 #define IO_RESOURCE_PREFERRED             0x01
 158 #define IO_RESOURCE_DEFAULT               0x02
 159 #define IO_RESOURCE_ALTERNATIVE           0x08
 160
 161 typedef struct _IO_RESOURCE_DESCRIPTOR {
 162   UCHAR  Option;
 163   UCHAR  Type;
 164   UCHAR  ShareDisposition;
 165   UCHAR  Spare1;
 166   USHORT  Flags;
 167   USHORT  Spare2;
 168   union {
 169     struct {
 170       ULONG  Length;
 171       ULONG  Alignment;
 172       PHYSICAL_ADDRESS  MinimumAddress;
 173       PHYSICAL_ADDRESS  MaximumAddress;
 174     } Port;
 175     struct {
 176       ULONG  Length;
 177       ULONG  Alignment;
 178       PHYSICAL_ADDRESS  MinimumAddress;
 179       PHYSICAL_ADDRESS  MaximumAddress;
 180     } Memory;
 181     struct {
 182       ULONG  MinimumVector;
 183       ULONG  MaximumVector;
 184     } Interrupt;
 185     struct {
 186       ULONG  MinimumChannel;
 187       ULONG  MaximumChannel;
 188     } Dma;
 189     struct {
 190       ULONG  Length;
 191       ULONG  Alignment;
 192       PHYSICAL_ADDRESS  MinimumAddress;
 193       PHYSICAL_ADDRESS  MaximumAddress;
 194     } Generic;
 195     struct {
 196       ULONG  Data[3];
 197     } DevicePrivate;
 198     struct {
 199       ULONG  Length;
 200       ULONG  MinBusNumber;
 201       ULONG  MaxBusNumber;
 202       ULONG  Reserved;
 203     } BusNumber;
 204     struct {
 205       ULONG  Priority;
 206       ULONG  Reserved1;
 207       ULONG  Reserved2;
 208     } ConfigData;
 209   } u;
 210 } IO_RESOURCE_DESCRIPTOR, *PIO_RESOURCE_DESCRIPTOR;
 211
 212 typedef struct _IO_RESOURCE_LIST {
 213   USHORT  Version;
 214   USHORT  Revision;
 215   ULONG  Count;
 216   IO_RESOURCE_DESCRIPTOR  Descriptors[1];
 217 } IO_RESOURCE_LIST, *PIO_RESOURCE_LIST;
 218
 219 typedef struct _IO_RESOURCE_REQUIREMENTS_LIST {
 220   ULONG  ListSize;
 221   INTERFACE_TYPE  InterfaceType;
 222   ULONG  BusNumber;
 223   ULONG  SlotNumber;
 224   ULONG  Reserved[3];
 225   ULONG  AlternativeLists;
 226   IO_RESOURCE_LIST  List[1];
 227 } IO_RESOURCE_REQUIREMENTS_LIST, *PIO_RESOURCE_REQUIREMENTS_LIST;
 228
 229 //
 230 // Global debug flag
 231 //
 232 extern ULONG NtGlobalFlag;
 233
 234
 235 #include <pshpack4.h>
 236 typedef struct _CM_PARTIAL_RESOURCE_DESCRIPTOR {
 237   UCHAR Type;
 238   UCHAR ShareDisposition;
 239   USHORT Flags;
 240   union {
 241     struct {
 242       PHYSICAL_ADDRESS Start;
 243       ULONG Length;
 244     } Generic;
 245     struct {
 246       PHYSICAL_ADDRESS Start;
 247       ULONG Length;
 248     } Port;
 249     struct {
 250       ULONG Level;
 251       ULONG Vector;
 252       KAFFINITY Affinity;
 253     } Interrupt;
 254 #if (NTDDI_VERSION >= NTDDI_LONGHORN)
 255     struct {
 256       __GNU_EXTENSION union {
 257         struct {
 258           USHORT Reserved;
 259           USHORT MessageCount;
 260           ULONG Vector;
 261           KAFFINITY Affinity;
 262         } Raw;
 263         struct {
 264           ULONG Level;
 265           ULONG Vector;
 266           KAFFINITY Affinity;
 267         } Translated;
 268       };
 269     } MessageInterrupt;
 270 #endif
 271     struct {
 272       PHYSICAL_ADDRESS Start;
 273       ULONG Length;
 274     } Memory;
 275     struct {
 276       ULONG Channel;
 277       ULONG Port;
 278       ULONG Reserved1;
 279     } Dma;
 280     struct {
 281       ULONG Data[3];
 282     } DevicePrivate;
 283     struct {
 284       ULONG Start;
 285       ULONG Length;
 286       ULONG Reserved;
 287     } BusNumber;
 288     struct {
 289       ULONG DataSize;
 290       ULONG Reserved1;
 291       ULONG Reserved2;
 292     } DeviceSpecificData;
 293 #if (NTDDI_VERSION >= NTDDI_LONGHORN)
 294     struct {
 295       PHYSICAL_ADDRESS Start;
 296       ULONG Length40;
 297     } Memory40;
 298     struct {
 299       PHYSICAL_ADDRESS Start;
 300       ULONG Length48;
 301     } Memory48;
 302     struct {
 303       PHYSICAL_ADDRESS Start;
 304       ULONG Length64;
 305     } Memory64;
 306 #endif
 307   } u;
 308 } CM_PARTIAL_RESOURCE_DESCRIPTOR, *PCM_PARTIAL_RESOURCE_DESCRIPTOR;
 309 #include <poppack.h>
 310
 311 //
 312 // Section map options
 313 //
 314 typedef enum _SECTION_INHERIT {
 315     ViewShare = 1,
 316     ViewUnmap = 2
 317 } SECTION_INHERIT;
 318
 319 //
 320 // Section access rights
 321 //
 322 #define SECTION_QUERY                0x0001
 323 #define SECTION_MAP_WRITE            0x0002
 324 #define SECTION_MAP_READ             0x0004
 325 #define SECTION_MAP_EXECUTE          0x0008
 326 #define SECTION_EXTEND_SIZE          0x0010
 327 #define SECTION_MAP_EXECUTE_EXPLICIT 0x0020
 328
 329 #define SECTION_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED|SECTION_QUERY|\
 330                             SECTION_MAP_WRITE |      \
 331                             SECTION_MAP_READ |       \
 332                             SECTION_MAP_EXECUTE |    \
 333                             SECTION_EXTEND_SIZE)
 334
 335 #define SESSION_QUERY_ACCESS  0x0001
 336 #define SESSION_MODIFY_ACCESS 0x0002
 337
 338 #define SESSION_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED |  \
 339                             SESSION_QUERY_ACCESS |             \
 340                             SESSION_MODIFY_ACCESS)
 341
 342
 343
 344 #define SEGMENT_ALL_ACCESS SECTION_ALL_ACCESS
 345
 346 #define PAGE_NOACCESS          0x01
 347 #define PAGE_READONLY          0x02
 348 #define PAGE_READWRITE         0x04
 349 #define PAGE_WRITECOPY         0x08
 350 #define PAGE_EXECUTE           0x10
 351 #define PAGE_EXECUTE_READ      0x20
 352 #define PAGE_EXECUTE_READWRITE 0x40
 353 #define PAGE_EXECUTE_WRITECOPY 0x80
 354 #define PAGE_GUARD            0x100
 355 #define PAGE_NOCACHE          0x200
 356 #define PAGE_WRITECOMBINE     0x400
 357
 358 #define MEM_COMMIT           0x1000
 359 #define MEM_RESERVE          0x2000
 360 #define MEM_DECOMMIT         0x4000
 361 #define MEM_RELEASE          0x8000
 362 #define MEM_FREE            0x10000
 363 #define MEM_PRIVATE         0x20000
 364 #define MEM_MAPPED          0x40000
 365 #define MEM_RESET           0x80000
 366 #define MEM_TOP_DOWN       0x100000
 367 #define MEM_LARGE_PAGES  0x20000000
 368 #define MEM_4MB_PAGES    0x80000000
 369
 370 #define SEC_RESERVE       0x4000000
 371 #define SEC_LARGE_PAGES  0x80000000
 372
 373 #define PROCESS_DUP_HANDLE                 (0x0040)
 374
 375 #if (NTDDI_VERSION >= NTDDI_VISTA)
 376 #define PROCESS_ALL_ACCESS        (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | \
 377                                    0xFFFF)
 378 #else
 379 #define PROCESS_ALL_ACCESS        (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | \
 380                                    0xFFF)
 381 #endif
 382
 383
 384
 385 //
 386 // Processor features
 387 //
 388 #define PF_FLOATING_POINT_PRECISION_ERRATA  0
 389 #define PF_FLOATING_POINT_EMULATED          1
 390 #define PF_COMPARE_EXCHANGE_DOUBLE          2
 391 #define PF_MMX_INSTRUCTIONS_AVAILABLE       3
 392 #define PF_PPC_MOVEMEM_64BIT_OK             4
 393 #define PF_ALPHA_BYTE_INSTRUCTIONS          5
 394 #define PF_XMMI_INSTRUCTIONS_AVAILABLE      6
 395 #define PF_3DNOW_INSTRUCTIONS_AVAILABLE     7
 396 #define PF_RDTSC_INSTRUCTION_AVAILABLE      8
 397 #define PF_PAE_ENABLED                      9
 398 #define PF_XMMI64_INSTRUCTIONS_AVAILABLE   10
 399 #define PF_SSE_DAZ_MODE_AVAILABLE          11
 400 #define PF_NX_ENABLED                      12
 401 #define PF_SSE3_INSTRUCTIONS_AVAILABLE     13
 402 #define PF_COMPARE_EXCHANGE128             14
 403 #define PF_COMPARE64_EXCHANGE128           15
 404 #define PF_CHANNELS_ENABLED                16
 405
 406
 407
 408 //
 409 // Intrinsics (note: taken from our winnt.h)
 410 // FIXME: 64-bit
 411 //
 412 #if defined(__GNUC__)
 413
 414 static __inline__ BOOLEAN
 415 InterlockedBitTestAndSet(IN LONG volatile *Base,
 416                          IN LONG Bit)
 417 {
 418 #if defined(_M_IX86)
 419         LONG OldBit;
 420         __asm__ __volatile__("lock "
 421                              "btsl %2,%1\n\t"
 422                              "sbbl %0,%0\n\t"
 423                              :"=r" (OldBit),"+m" (*Base)
 424                              :"Ir" (Bit)
 425                              : "memory");
 426         return OldBit;
 427 #else
 428         return (_InterlockedOr(Base, 1 << Bit) >> Bit) & 1;
 429 #endif
 430 }
 431
 432 static __inline__ BOOLEAN
 433 InterlockedBitTestAndReset(IN LONG volatile *Base,
 434                            IN LONG Bit)
 435 {
 436 #if defined(_M_IX86)
 437         LONG OldBit;
 438         __asm__ __volatile__("lock "
 439                              "btrl %2,%1\n\t"
 440                              "sbbl %0,%0\n\t"
 441                              :"=r" (OldBit),"+m" (*Base)
 442                              :"Ir" (Bit)
 443                              : "memory");
 444         return OldBit;
 445 #else
 446         return (_InterlockedAnd(Base, ~(1 << Bit)) >> Bit) & 1;
 447 #endif
 448 }
 449
 450 #endif
 451
 452 #define BitScanForward _BitScanForward
 453 #define BitScanReverse _BitScanReverse
 454
 455 #define BitTest _bittest
 456 #define BitTestAndComplement _bittestandcomplement
 457 #define BitTestAndSet _bittestandset
 458 #define BitTestAndReset _bittestandreset
 459 #define InterlockedBitTestAndSet _interlockedbittestandset
 460 #define InterlockedBitTestAndReset _interlockedbittestandreset
 461
 462
 463 /** INTERLOCKED FUNCTIONS *****************************************************/
 464
 465 #if !defined(__INTERLOCKED_DECLARED)
 466 #define __INTERLOCKED_DECLARED
 467
 468 #if defined (_X86_)
 469 #if defined(NO_INTERLOCKED_INTRINSICS)
 470 NTKERNELAPI
 471 LONG
 472 FASTCALL
 473 InterlockedIncrement(
 474   IN OUT LONG volatile *Addend);
 475
 476 NTKERNELAPI
 477 LONG
 478 FASTCALL
 479 InterlockedDecrement(
 480   IN OUT LONG volatile *Addend);
 481
 482 NTKERNELAPI
 483 LONG
 484 FASTCALL
 485 InterlockedCompareExchange(
 486   IN OUT LONG volatile *Destination,
 487   IN LONG  Exchange,
 488   IN LONG  Comparand);
 489
 490 NTKERNELAPI
 491 LONG
 492 FASTCALL
 493 InterlockedExchange(
 494   IN OUT LONG volatile *Destination,
 495   IN LONG Value);
 496
 497 NTKERNELAPI
 498 LONG
 499 FASTCALL
 500 InterlockedExchangeAdd(
 501   IN OUT LONG volatile *Addend,
 502   IN LONG  Value);
 503
 504 #else // !defined(NO_INTERLOCKED_INTRINSICS)
 505
 506 #define InterlockedExchange _InterlockedExchange
 507 #define InterlockedIncrement _InterlockedIncrement
 508 #define InterlockedDecrement _InterlockedDecrement
 509 #define InterlockedExchangeAdd _InterlockedExchangeAdd
 510 #define InterlockedCompareExchange _InterlockedCompareExchange
 511 #define InterlockedOr _InterlockedOr
 512 #define InterlockedAnd _InterlockedAnd
 513 #define InterlockedXor _InterlockedXor
 514
 515 #endif // !defined(NO_INTERLOCKED_INTRINSICS)
 516
 517 #endif // defined (_X86_)
 518
 519 #if !defined (_WIN64)
 520 /*
 521  * PVOID
 522  * InterlockedExchangePointer(
 523  *   IN OUT PVOID volatile  *Target,
 524  *   IN PVOID  Value)
 525  */
 526 #define InterlockedExchangePointer(Target, Value) \
 527   ((PVOID) InterlockedExchange((PLONG) Target, (LONG) Value))
 528
 529 /*
 530  * PVOID
 531  * InterlockedCompareExchangePointer(
 532  *   IN OUT PVOID  *Destination,
 533  *   IN PVOID  Exchange,
 534  *   IN PVOID  Comparand)
 535  */
 536 #define InterlockedCompareExchangePointer(Destination, Exchange, Comparand) \
 537   ((PVOID) InterlockedCompareExchange((PLONG) Destination, (LONG) Exchange, (LONG) Comparand))
 538
 539 #define InterlockedExchangeAddSizeT(a, b) InterlockedExchangeAdd((LONG *)a, b)
 540 #define InterlockedIncrementSizeT(a) InterlockedIncrement((LONG *)a)
 541 #define InterlockedDecrementSizeT(a) InterlockedDecrement((LONG *)a)
 542
 543 #endif // !defined (_WIN64)
 544
 545 #if defined (_M_AMD64)
 546
 547 #define InterlockedExchangeAddSizeT(a, b) InterlockedExchangeAdd64((LONGLONG *)a, (LONGLONG)b)
 548 #define InterlockedIncrementSizeT(a) InterlockedIncrement64((LONGLONG *)a)
 549 #define InterlockedDecrementSizeT(a) InterlockedDecrement64((LONGLONG *)a)
 550 #define InterlockedAnd _InterlockedAnd
 551 #define InterlockedOr _InterlockedOr
 552 #define InterlockedXor _InterlockedXor
 553 #define InterlockedIncrement _InterlockedIncrement
 554 #define InterlockedDecrement _InterlockedDecrement
 555 #define InterlockedAdd _InterlockedAdd
 556 #define InterlockedExchange _InterlockedExchange
 557 #define InterlockedExchangeAdd _InterlockedExchangeAdd
 558 #define InterlockedCompareExchange _InterlockedCompareExchange
 559 #define InterlockedAnd64 _InterlockedAnd64
 560 #define InterlockedOr64 _InterlockedOr64
 561 #define InterlockedXor64 _InterlockedXor64
 562 #define InterlockedIncrement64 _InterlockedIncrement64
 563 #define InterlockedDecrement64 _InterlockedDecrement64
 564 #define InterlockedAdd64 _InterlockedAdd64
 565 #define InterlockedExchange64 _InterlockedExchange64
 566 #define InterlockedExchangeAdd64 _InterlockedExchangeAdd64
 567 #define InterlockedCompareExchange64 _InterlockedCompareExchange64
 568 #define InterlockedCompareExchangePointer _InterlockedCompareExchangePointer
 569 #define InterlockedExchangePointer _InterlockedExchangePointer
 570 #define InterlockedBitTestAndSet64 _interlockedbittestandset64
 571 #define InterlockedBitTestAndReset64 _interlockedbittestandreset64
 572
 573 #endif // _M_AMD64
 574
 575 #if defined(_M_AMD64) && !defined(RC_INVOKED) && !defined(MIDL_PASS)
 576 //#if !defined(_X86AMD64_) // FIXME: what's _X86AMD64_ used for?
 577 FORCEINLINE
 578 LONG64
 579 InterlockedAdd64(
 580     IN OUT LONG64 volatile *Addend,
 581     IN LONG64 Value)
 582 {
 583     return InterlockedExchangeAdd64(Addend, Value) + Value;
 584 }
 585 //#endif
 586 #endif
 587
 588 #endif /* !__INTERLOCKED_DECLARED */
 589
 590 #if defined(_M_IX86)
 591 #define YieldProcessor _mm_pause
 592 #elif defined (_M_AMD64)
 593 #define YieldProcessor _mm_pause
 594 #elif defined(_M_PPC)
 595 #define YieldProcessor() __asm__ __volatile__("nop");
 596 #elif defined(_M_MIPS)
 597 #define YieldProcessor() __asm__ __volatile__("nop");
 598 #elif defined(_M_ARM)
 599 #define YieldProcessor()
 600 #else
 601 #error Unknown architecture
 602 #endif
 603
 604
 605
 606 //
 607 // Slist Header
 608 //
 609 #ifndef _SLIST_HEADER_
 610 #define _SLIST_HEADER_
 611
 612 #if defined(_WIN64)
 613 typedef struct DECLSPEC_ALIGN(16) _SLIST_ENTRY *PSLIST_ENTRY;
 614 typedef struct DECLSPEC_ALIGN(16) _SLIST_ENTRY {
 615         PSLIST_ENTRY Next;
 616 } SLIST_ENTRY;
 617 typedef union DECLSPEC_ALIGN(16) _SLIST_HEADER {
 618     struct {
 619         ULONGLONG Alignment;
 620         ULONGLONG Region;
 621     } DUMMYSTRUCTNAME;
 622     struct {
 623         ULONGLONG Depth:16;
 624         ULONGLONG Sequence:9;
 625         ULONGLONG NextEntry:39;
 626         ULONGLONG HeaderType:1;
 627         ULONGLONG Init:1;
 628         ULONGLONG Reserved:59;
 629         ULONGLONG Region:3;
 630     } Header8;
 631     struct {
 632         ULONGLONG Depth:16;
 633         ULONGLONG Sequence:48;
 634         ULONGLONG HeaderType:1;
 635         ULONGLONG Init:1;
 636         ULONGLONG Reserved:2;
 637         ULONGLONG NextEntry:60;
 638     } Header16;
 639 } SLIST_HEADER, *PSLIST_HEADER;
 640 #else
 641 #define SLIST_ENTRY SINGLE_LIST_ENTRY
 642 #define _SLIST_ENTRY _SINGLE_LIST_ENTRY
 643 #define PSLIST_ENTRY PSINGLE_LIST_ENTRY
 644 typedef union _SLIST_HEADER {
 645     ULONGLONG Alignment;
 646     struct {
 647         SLIST_ENTRY Next;
 648         USHORT Depth;
 649         USHORT Sequence;
 650     } DUMMYSTRUCTNAME;
 651 } SLIST_HEADER, *PSLIST_HEADER;
 652 #endif
 653
 654 #endif /* _SLIST_HEADER_ */
 655
 656
 657
 658 //
 659 // Power States/Levels
 660 //
 661 typedef enum _SYSTEM_POWER_STATE {
 662     PowerSystemUnspecified,
 663     PowerSystemWorking,
 664     PowerSystemSleeping1,
 665     PowerSystemSleeping2,
 666     PowerSystemSleeping3,
 667     PowerSystemHibernate,
 668     PowerSystemShutdown,
 669     PowerSystemMaximum
 670 } SYSTEM_POWER_STATE, *PSYSTEM_POWER_STATE;
 671
 672 #define POWER_SYSTEM_MAXIMUM PowerSystemMaximum
 673
 674 typedef enum _POWER_INFORMATION_LEVEL {
 675     SystemPowerPolicyAc,
 676     SystemPowerPolicyDc,
 677     VerifySystemPolicyAc,
 678     VerifySystemPolicyDc,
 679     SystemPowerCapabilities,
 680     SystemBatteryState,
 681     SystemPowerStateHandler,
 682     ProcessorStateHandler,
 683     SystemPowerPolicyCurrent,
 684     AdministratorPowerPolicy,
 685     SystemReserveHiberFile,
 686     ProcessorInformation,
 687     SystemPowerInformation,
 688     ProcessorStateHandler2,
 689     LastWakeTime,
 690     LastSleepTime,
 691     SystemExecutionState,
 692     SystemPowerStateNotifyHandler,
 693     ProcessorPowerPolicyAc,
 694     ProcessorPowerPolicyDc,
 695     VerifyProcessorPowerPolicyAc,
 696     VerifyProcessorPowerPolicyDc,
 697     ProcessorPowerPolicyCurrent
 698 } POWER_INFORMATION_LEVEL;
 699
 700 typedef enum {
 701     PowerActionNone,
 702     PowerActionReserved,
 703     PowerActionSleep,
 704     PowerActionHibernate,
 705     PowerActionShutdown,
 706     PowerActionShutdownReset,
 707     PowerActionShutdownOff,
 708     PowerActionWarmEject
 709 } POWER_ACTION, *PPOWER_ACTION;
 710
 711 typedef enum _DEVICE_POWER_STATE {
 712     PowerDeviceUnspecified,
 713     PowerDeviceD0,
 714     PowerDeviceD1,
 715     PowerDeviceD2,
 716     PowerDeviceD3,
 717     PowerDeviceMaximum
 718 } DEVICE_POWER_STATE, *PDEVICE_POWER_STATE;
 719
 720 #define ES_SYSTEM_REQUIRED                0x00000001
 721 #define ES_DISPLAY_REQUIRED               0x00000002
 722 #define ES_USER_PRESENT                   0x00000004
 723 #define ES_CONTINUOUS                     0x80000000
 724
 725 typedef ULONG EXECUTION_STATE;
 726
 727 typedef enum {
 728     LT_DONT_CARE,
 729     LT_LOWEST_LATENCY
 730 } LATENCY_TIME;
 731
 732
 733
 734 //
 735 // Access/Security Stuff
 736 //
 737 typedef ULONG ACCESS_MASK, *PACCESS_MASK;
 738 typedef PVOID PACCESS_TOKEN;
 739
 740 #define DELETE                           0x00010000L
 741 #define READ_CONTROL                     0x00020000L
 742 #define WRITE_DAC                        0x00040000L
 743 #define WRITE_OWNER                      0x00080000L
 744 #define SYNCHRONIZE                      0x00100000L
 745 #define STANDARD_RIGHTS_REQUIRED         0x000F0000L
 746 #define STANDARD_RIGHTS_READ             READ_CONTROL
 747 #define STANDARD_RIGHTS_WRITE            READ_CONTROL
 748 #define STANDARD_RIGHTS_EXECUTE          READ_CONTROL
 749 #define STANDARD_RIGHTS_ALL              0x001F0000L
 750 #define SPECIFIC_RIGHTS_ALL              0x0000FFFFL
 751 #define ACCESS_SYSTEM_SECURITY           0x01000000L
 752 #define MAXIMUM_ALLOWED                  0x02000000L
 753 #define GENERIC_READ                     0x80000000L
 754 #define GENERIC_WRITE                    0x40000000L
 755 #define GENERIC_EXECUTE                  0x20000000L
 756 #define GENERIC_ALL                      0x10000000L
 757
 758 typedef struct _GENERIC_MAPPING {
 759     ACCESS_MASK GenericRead;
 760     ACCESS_MASK GenericWrite;
 761     ACCESS_MASK GenericExecute;
 762     ACCESS_MASK GenericAll;
 763 } GENERIC_MAPPING, *PGENERIC_MAPPING;
 764
 765 #define ACL_REVISION                      2
 766 #define ACL_REVISION_DS                   4
 767
 768 #define ACL_REVISION1                     1
 769 #define ACL_REVISION2                     2
 770 #define ACL_REVISION3                     3
 771 #define ACL_REVISION4                     4
 772 #define MIN_ACL_REVISION                  ACL_REVISION2
 773 #define MAX_ACL_REVISION                  ACL_REVISION4
 774
 775 typedef struct _ACL {
 776     UCHAR AclRevision;
 777     UCHAR Sbz1;
 778     USHORT AclSize;
 779     USHORT AceCount;
 780     USHORT Sbz2;
 781 } ACL, *PACL;
 782
 783
 784
 785 //
 786 // Current security descriptor revision value
 787 //
 788 #define SECURITY_DESCRIPTOR_REVISION     (1)
 789 #define SECURITY_DESCRIPTOR_REVISION1    (1)
 790
 791 //
 792 // Privilege attributes
 793 //
 794 #define SE_PRIVILEGE_ENABLED_BY_DEFAULT (0x00000001L)
 795 #define SE_PRIVILEGE_ENABLED            (0x00000002L)
 796 #define SE_PRIVILEGE_REMOVED            (0X00000004L)
 797 #define SE_PRIVILEGE_USED_FOR_ACCESS    (0x80000000L)
 798
 799 #define SE_PRIVILEGE_VALID_ATTRIBUTES   (SE_PRIVILEGE_ENABLED_BY_DEFAULT | \
 800                                          SE_PRIVILEGE_ENABLED            | \
 801                                          SE_PRIVILEGE_REMOVED            | \
 802                                          SE_PRIVILEGE_USED_FOR_ACCESS)
 803
 804 #include <pshpack4.h>
 805 typedef struct _LUID_AND_ATTRIBUTES {
 806     LUID Luid;
 807     ULONG Attributes;
 808 } LUID_AND_ATTRIBUTES, *PLUID_AND_ATTRIBUTES;
 809 #include <poppack.h>
 810 typedef LUID_AND_ATTRIBUTES LUID_AND_ATTRIBUTES_ARRAY[ANYSIZE_ARRAY];
 811 typedef LUID_AND_ATTRIBUTES_ARRAY *PLUID_AND_ATTRIBUTES_ARRAY;
 812
 813
 814
 815 //
 816 // Privilege sets
 817 //
 818 #define PRIVILEGE_SET_ALL_NECESSARY (1)
 819
 820 typedef struct _PRIVILEGE_SET {
 821     ULONG PrivilegeCount;
 822     ULONG Control;
 823     LUID_AND_ATTRIBUTES Privilege[ANYSIZE_ARRAY];
 824 } PRIVILEGE_SET,*PPRIVILEGE_SET;
 825
 826 typedef enum _SECURITY_IMPERSONATION_LEVEL {
 827     SecurityAnonymous,
 828     SecurityIdentification,
 829     SecurityImpersonation,
 830     SecurityDelegation
 831 } SECURITY_IMPERSONATION_LEVEL, * PSECURITY_IMPERSONATION_LEVEL;
 832
 833 #define SECURITY_MAX_IMPERSONATION_LEVEL SecurityDelegation
 834 #define SECURITY_MIN_IMPERSONATION_LEVEL SecurityAnonymous
 835 #define DEFAULT_IMPERSONATION_LEVEL SecurityImpersonation
 836 #define VALID_IMPERSONATION_LEVEL(Level) (((Level) >= SECURITY_MIN_IMPERSONATION_LEVEL) && ((Level) <= SECURITY_MAX_IMPERSONATION_LEVEL))
 837
 838 #define SECURITY_DYNAMIC_TRACKING (TRUE)
 839 #define SECURITY_STATIC_TRACKING (FALSE)
 840
 841 typedef BOOLEAN SECURITY_CONTEXT_TRACKING_MODE, *PSECURITY_CONTEXT_TRACKING_MODE;
 842
 843 typedef struct _SECURITY_QUALITY_OF_SERVICE {
 844     ULONG Length;
 845     SECURITY_IMPERSONATION_LEVEL ImpersonationLevel;
 846     SECURITY_CONTEXT_TRACKING_MODE ContextTrackingMode;
 847     BOOLEAN EffectiveOnly;
 848 } SECURITY_QUALITY_OF_SERVICE, *PSECURITY_QUALITY_OF_SERVICE;
 849
 850 typedef struct _SE_IMPERSONATION_STATE {
 851     PACCESS_TOKEN Token;
 852     BOOLEAN CopyOnOpen;
 853     BOOLEAN EffectiveOnly;
 854     SECURITY_IMPERSONATION_LEVEL Level;
 855 } SE_IMPERSONATION_STATE, *PSE_IMPERSONATION_STATE;
 856
 857 #define OWNER_SECURITY_INFORMATION       (0x00000001L)
 858 #define GROUP_SECURITY_INFORMATION       (0x00000002L)
 859 #define DACL_SECURITY_INFORMATION        (0x00000004L)
 860 #define SACL_SECURITY_INFORMATION        (0x00000008L)
 861 #define LABEL_SECURITY_INFORMATION       (0x00000010L)
 862
 863 #define PROTECTED_DACL_SECURITY_INFORMATION     (0x80000000L)
 864 #define PROTECTED_SACL_SECURITY_INFORMATION     (0x40000000L)
 865 #define UNPROTECTED_DACL_SECURITY_INFORMATION   (0x20000000L)
 866 #define UNPROTECTED_SACL_SECURITY_INFORMATION   (0x10000000L)
 867
 868
 869
 870 //
 871 // Registry Access Rights
 872 //
 873 #define KEY_QUERY_VALUE         (0x0001)
 874 #define KEY_SET_VALUE           (0x0002)
 875 #define KEY_CREATE_SUB_KEY      (0x0004)
 876 #define KEY_ENUMERATE_SUB_KEYS  (0x0008)
 877 #define KEY_NOTIFY              (0x0010)
 878 #define KEY_CREATE_LINK         (0x0020)
 879 #define KEY_WOW64_32KEY         (0x0200)
 880 #define KEY_WOW64_64KEY         (0x0100)
 881 #define KEY_WOW64_RES           (0x0300)
 882
 883 #define KEY_READ                ((STANDARD_RIGHTS_READ       |\
 884                                   KEY_QUERY_VALUE            |\
 885                                   KEY_ENUMERATE_SUB_KEYS     |\
 886                                   KEY_NOTIFY)                 \
 887                                   &                           \
 888                                  (~SYNCHRONIZE))
 889
 890 #define KEY_WRITE               ((STANDARD_RIGHTS_WRITE      |\
 891                                   KEY_SET_VALUE              |\
 892                                   KEY_CREATE_SUB_KEY)         \
 893                                   &                           \
 894                                  (~SYNCHRONIZE))
 895
 896 #define KEY_EXECUTE             ((KEY_READ)                   \
 897                                   &                           \
 898                                  (~SYNCHRONIZE))
 899
 900 #define KEY_ALL_ACCESS          ((STANDARD_RIGHTS_ALL        |\
 901                                   KEY_QUERY_VALUE            |\
 902                                   KEY_SET_VALUE              |\
 903                                   KEY_CREATE_SUB_KEY         |\
 904                                   KEY_ENUMERATE_SUB_KEYS     |\
 905                                   KEY_NOTIFY                 |\
 906                                   KEY_CREATE_LINK)            \
 907                                   &                           \
 908                                  (~SYNCHRONIZE))
 909
 910 //
 911 // Registry Open/Create Options
 912 //
 913 #define REG_OPTION_RESERVED         (0x00000000L)
 914 #define REG_OPTION_NON_VOLATILE     (0x00000000L)
 915 #define REG_OPTION_VOLATILE         (0x00000001L)
 916 #define REG_OPTION_CREATE_LINK      (0x00000002L)
 917 #define REG_OPTION_BACKUP_RESTORE   (0x00000004L)
 918 #define REG_OPTION_OPEN_LINK        (0x00000008L)
 919
 920 #define REG_LEGAL_OPTION            \
 921                 (REG_OPTION_RESERVED            |\
 922                  REG_OPTION_NON_VOLATILE        |\
 923                  REG_OPTION_VOLATILE            |\
 924                  REG_OPTION_CREATE_LINK         |\
 925                  REG_OPTION_BACKUP_RESTORE      |\
 926                  REG_OPTION_OPEN_LINK)
 927
 928 //
 929 // Key creation/open disposition
 930 //
 931 #define REG_CREATED_NEW_KEY         (0x00000001L)
 932 #define REG_OPENED_EXISTING_KEY     (0x00000002L)
 933
 934 //
 935 // Key restore & hive load flags
 936 //
 937 #define REG_WHOLE_HIVE_VOLATILE         (0x00000001L)
 938 #define REG_REFRESH_HIVE                (0x00000002L)
 939 #define REG_NO_LAZY_FLUSH               (0x00000004L)
 940 #define REG_FORCE_RESTORE               (0x00000008L)
 941 #define REG_APP_HIVE                    (0x00000010L)
 942 #define REG_PROCESS_PRIVATE             (0x00000020L)
 943 #define REG_START_JOURNAL               (0x00000040L)
 944 #define REG_HIVE_EXACT_FILE_GROWTH      (0x00000080L)
 945 #define REG_HIVE_NO_RM                  (0x00000100L)
 946 #define REG_HIVE_SINGLE_LOG             (0x00000200L)
 947
 948 //
 949 // Unload Flags
 950 //
 951 #define REG_FORCE_UNLOAD            1
 952
 953 //
 954 // Notify Filter Values
 955 //
 956 #define REG_NOTIFY_CHANGE_NAME          (0x00000001L)
 957 #define REG_NOTIFY_CHANGE_ATTRIBUTES    (0x00000002L)
 958 #define REG_NOTIFY_CHANGE_LAST_SET      (0x00000004L)
 959 #define REG_NOTIFY_CHANGE_SECURITY      (0x00000008L)
 960
 961 #define REG_LEGAL_CHANGE_FILTER                 \
 962                 (REG_NOTIFY_CHANGE_NAME          |\
 963                  REG_NOTIFY_CHANGE_ATTRIBUTES    |\
 964                  REG_NOTIFY_CHANGE_LAST_SET      |\
 965                  REG_NOTIFY_CHANGE_SECURITY)
 966
 967
 968
 969 //
 970 // Thread Access Rights
 971 //
 972 #define THREAD_TERMINATE                 (0x0001)
 973 #define THREAD_SUSPEND_RESUME            (0x0002)
 974 #define THREAD_ALERT                     (0x0004)
 975 #define THREAD_GET_CONTEXT               (0x0008)
 976 #define THREAD_SET_CONTEXT               (0x0010)
 977 #define THREAD_SET_INFORMATION           (0x0020)
 978 #define THREAD_SET_LIMITED_INFORMATION   (0x0400)
 979 #define THREAD_QUERY_LIMITED_INFORMATION (0x0800)
 980 #if (NTDDI_VERSION >= NTDDI_VISTA)
 981 #define THREAD_ALL_ACCESS         (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | \
 982                                    0xFFFF)
 983 #else
 984 #define THREAD_ALL_ACCESS         (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | \
 985                                    0x3FF)
 986 #endif
 987
 988 //
 989 // Service Start Types
 990 //
 991 #define SERVICE_BOOT_START             0x00000000
 992 #define SERVICE_SYSTEM_START           0x00000001
 993 #define SERVICE_AUTO_START             0x00000002
 994 #define SERVICE_DEMAND_START           0x00000003
 995 #define SERVICE_DISABLED               0x00000004
 996
 997 //
 998 // Exception Records
 999 //
1000 #define EXCEPTION_NONCONTINUABLE 1
1001 #define EXCEPTION_MAXIMUM_PARAMETERS 15
1002
1003 typedef struct _EXCEPTION_RECORD {
1004     NTSTATUS ExceptionCode;
1005     ULONG ExceptionFlags;
1006     struct _EXCEPTION_RECORD *ExceptionRecord;
1007     PVOID ExceptionAddress;
1008     ULONG NumberParameters;
1009     ULONG_PTR ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS];
1010 } EXCEPTION_RECORD, *PEXCEPTION_RECORD;
1011
1012 typedef struct _EXCEPTION_RECORD32 {
1013     NTSTATUS ExceptionCode;
1014     ULONG ExceptionFlags;
1015     ULONG ExceptionRecord;
1016     ULONG ExceptionAddress;
1017     ULONG NumberParameters;
1018     ULONG ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS];
1019 } EXCEPTION_RECORD32, *PEXCEPTION_RECORD32;
1020
1021 typedef struct _EXCEPTION_RECORD64 {
1022     NTSTATUS ExceptionCode;
1023     ULONG ExceptionFlags;
1024     ULONG64 ExceptionRecord;
1025     ULONG64 ExceptionAddress;
1026     ULONG NumberParameters;
1027     ULONG __unusedAlignment;
1028     ULONG64 ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS];
1029 } EXCEPTION_RECORD64, *PEXCEPTION_RECORD64;
1030
1031 typedef struct _EXCEPTION_POINTERS {
1032     PEXCEPTION_RECORD ExceptionRecord;
1033     PCONTEXT ContextRecord;
1034 } EXCEPTION_POINTERS, *PEXCEPTION_POINTERS;
1035
1036
1037
1038 //
1039 // Process Qoutas
1040 //
1041 typedef struct _QUOTA_LIMITS {
1042     SIZE_T PagedPoolLimit;
1043     SIZE_T NonPagedPoolLimit;
1044     SIZE_T MinimumWorkingSetSize;
1045     SIZE_T MaximumWorkingSetSize;
1046     SIZE_T PagefileLimit;
1047     LARGE_INTEGER TimeLimit;
1048 } QUOTA_LIMITS, *PQUOTA_LIMITS;
1049
1050 #define QUOTA_LIMITS_HARDWS_MIN_ENABLE  0x00000001
1051 #define QUOTA_LIMITS_HARDWS_MIN_DISABLE 0x00000002
1052 #define QUOTA_LIMITS_HARDWS_MAX_ENABLE  0x00000004
1053 #define QUOTA_LIMITS_HARDWS_MAX_DISABLE 0x00000008
1054 #define QUOTA_LIMITS_USE_DEFAULT_LIMITS 0x00000010
1055
1056
1057 /******************************************************************************
1058  *                             WINBASE Functions                              *
1059  ******************************************************************************/
1060 #if !defined(_WINBASE_)
1061
1062 #if defined(_WIN64)
1063
1064 #define InterlockedPopEntrySList(Head) \
1065     ExpInterlockedPopEntrySList(Head)
1066
1067 #define InterlockedPushEntrySList(Head, Entry) \
1068     ExpInterlockedPushEntrySList(Head, Entry)
1069
1070 #define InterlockedFlushSList(Head) \
1071     ExpInterlockedFlushSList(Head)
1072
1073 #define QueryDepthSList(Head) \
1074     ExQueryDepthSList(Head)
1075
1076 #else // !defined(_WIN64)
1077
1078 NTKERNELAPI
1079 PSLIST_ENTRY
1080 FASTCALL
1081 InterlockedPopEntrySList(
1082     IN PSLIST_HEADER ListHead);
1083
1084 NTKERNELAPI
1085 PSLIST_ENTRY
1086 FASTCALL
1087 InterlockedPushEntrySList(
1088     IN PSLIST_HEADER ListHead,
1089     IN PSLIST_ENTRY ListEntry);
1090
1091 #define InterlockedFlushSList(ListHead) \
1092     ExInterlockedFlushSList(ListHead)
1093
1094 #define QueryDepthSList(Head) \
1095     ExQueryDepthSList(Head)
1096
1097 #endif // !defined(_WIN64)
1098
1099 #endif // !defined(_WINBASE_)
1100
1101
1102 /******************************************************************************
1103  *                              Kernel Types                                  *
1104  ******************************************************************************/
1105
1106 typedef struct _DISPATCHER_HEADER
1107 {
1108     __GNU_EXTENSION union
1109     {
1110         __GNU_EXTENSION struct
1111         {
1112             UCHAR Type;
1113             __GNU_EXTENSION union
1114             {
1115                 UCHAR Absolute;
1116                 UCHAR NpxIrql;
1117             };
1118             __GNU_EXTENSION union
1119             {
1120                 UCHAR Size;
1121                 UCHAR Hand;
1122             };
1123             __GNU_EXTENSION union
1124             {
1125                 UCHAR Inserted;
1126                 BOOLEAN DebugActive;
1127             };
1128         };
1129         volatile LONG Lock;
1130     };
1131     LONG SignalState;
1132     LIST_ENTRY WaitListHead;
1133 } DISPATCHER_HEADER, *PDISPATCHER_HEADER;
1134
1135 typedef ULONG_PTR KSPIN_LOCK, *PKSPIN_LOCK;
1136
1137 typedef struct _KEVENT {
1138   DISPATCHER_HEADER  Header;
1139 } KEVENT, *PKEVENT, *RESTRICTED_POINTER PRKEVENT;
1140
1141 typedef struct _KSEMAPHORE {
1142     DISPATCHER_HEADER Header;
1143     LONG Limit;
1144 } KSEMAPHORE, *PKSEMAPHORE, *RESTRICTED_POINTER PRKSEMAPHORE;
1145
1146 /******************************************************************************
1147  *                                 RTL Types                                  *
1148  ******************************************************************************/
1149
1150 #define RTL_REGISTRY_ABSOLUTE             0
1151 #define RTL_REGISTRY_SERVICES             1
1152 #define RTL_REGISTRY_CONTROL              2
1153 #define RTL_REGISTRY_WINDOWS_NT           3
1154 #define RTL_REGISTRY_DEVICEMAP            4
1155 #define RTL_REGISTRY_USER                 5
1156 #define RTL_REGISTRY_MAXIMUM              6
1157 #define RTL_REGISTRY_HANDLE               0x40000000
1158 #define RTL_REGISTRY_OPTIONAL             0x80000000
1159
1160 /* RTL_QUERY_REGISTRY_TABLE.Flags */
1161 #define RTL_QUERY_REGISTRY_SUBKEY         0x00000001
1162 #define RTL_QUERY_REGISTRY_TOPKEY         0x00000002
1163 #define RTL_QUERY_REGISTRY_REQUIRED       0x00000004
1164 #define RTL_QUERY_REGISTRY_NOVALUE        0x00000008
1165 #define RTL_QUERY_REGISTRY_NOEXPAND       0x00000010
1166 #define RTL_QUERY_REGISTRY_DIRECT         0x00000020
1167 #define RTL_QUERY_REGISTRY_DELETE         0x00000040
1168
1169 typedef struct _RTL_BITMAP {
1170     ULONG SizeOfBitMap;
1171     PULONG Buffer;
1172 } RTL_BITMAP, *PRTL_BITMAP;
1173
1174 typedef struct _RTL_BITMAP_RUN {
1175     ULONG StartingIndex;
1176     ULONG NumberOfBits;
1177 } RTL_BITMAP_RUN, *PRTL_BITMAP_RUN;
1178
1179 typedef NTSTATUS
1180 (DDKAPI *PRTL_QUERY_REGISTRY_ROUTINE)(
1181     IN PWSTR ValueName,
1182     IN ULONG ValueType,
1183     IN PVOID ValueData,
1184     IN ULONG ValueLength,
1185     IN PVOID Context,
1186     IN PVOID EntryContext);
1187
1188 typedef struct _RTL_QUERY_REGISTRY_TABLE {
1189     PRTL_QUERY_REGISTRY_ROUTINE QueryRoutine;
1190     ULONG Flags;
1191     PCWSTR Name;
1192     PVOID EntryContext;
1193     ULONG DefaultType;
1194     PVOID DefaultData;
1195     ULONG DefaultLength;
1196 } RTL_QUERY_REGISTRY_TABLE, *PRTL_QUERY_REGISTRY_TABLE;
1197
1198 typedef struct _TIME_FIELDS {
1199     CSHORT Year;
1200     CSHORT Month;
1201     CSHORT Day;
1202     CSHORT Hour;
1203     CSHORT Minute;
1204     CSHORT Second;
1205     CSHORT Milliseconds;
1206     CSHORT Weekday;
1207 } TIME_FIELDS, *PTIME_FIELDS;
1208
1209
1210 /******************************************************************************
1211  *                               RTL Functions                                *
1212  ******************************************************************************/
1213
1214 NTSYSAPI
1215 VOID
1216 NTAPI
1217 RtlAssert(
1218     IN PVOID FailedAssertion,
1219     IN PVOID FileName,
1220     IN ULONG LineNumber,
1221     IN PCHAR Message);
1222
1223 /* VOID
1224  * RtlCopyMemory(
1225  *     IN VOID UNALIGNED *Destination,
1226  *     IN CONST VOID UNALIGNED *Source,
1227  *     IN SIZE_T Length)
1228  */
1229 #define RtlCopyMemory(Destination, Source, Length) \
1230     memcpy(Destination, Source, Length)
1231
1232 #define RtlCopyBytes RtlCopyMemory
1233
1234 #if defined(_M_AMD64)
1235 NTSYSAPI
1236 VOID
1237 NTAPI
1238 RtlCopyMemoryNonTemporal(
1239     VOID UNALIGNED *Destination,
1240     CONST VOID UNALIGNED *Source,
1241     SIZE_T Length);
1242 #else
1243 #define RtlCopyMemoryNonTemporal RtlCopyMemory
1244 #endif
1245
1246 /* BOOLEAN
1247  * RtlEqualLuid(
1248  *     IN PLUID Luid1,
1249  *     IN PLUID Luid2)
1250  */
1251 #define RtlEqualLuid(Luid1, Luid2) \
1252     (((Luid1)->LowPart == (Luid2)->LowPart) && ((Luid1)->HighPart == (Luid2)->HighPart))
1253
1254 /* ULONG
1255  * RtlEqualMemory(
1256  *     IN VOID UNALIGNED *Destination,
1257  *     IN CONST VOID UNALIGNED *Source,
1258  *     IN SIZE_T Length)
1259  */
1260 #define RtlEqualMemory(Destination, Source, Length) \
1261     (!memcmp(Destination, Source, Length))
1262
1263 /* VOID
1264  * RtlFillMemory(
1265  *     IN VOID UNALIGNED *Destination,
1266  *     IN SIZE_T Length,
1267  *     IN UCHAR Fill)
1268  */
1269 #define RtlFillMemory(Destination, Length, Fill) \
1270     memset(Destination, Fill, Length)
1271
1272 #define RtlFillBytes RtlFillMemory
1273
1274 NTSYSAPI
1275 VOID
1276 NTAPI
1277 RtlFreeUnicodeString(
1278     IN PUNICODE_STRING UnicodeString);
1279
1280 NTSYSAPI
1281 NTSTATUS
1282 NTAPI
1283 RtlGUIDFromString(
1284     IN PUNICODE_STRING GuidString,
1285     OUT GUID *Guid);
1286
1287 NTSYSAPI
1288 VOID
1289 NTAPI
1290 RtlInitUnicodeString(
1291     IN OUT PUNICODE_STRING DestinationString,
1292     IN PCWSTR SourceString);
1293
1294 /* VOID
1295  * RtlMoveMemory(
1296  *    IN VOID UNALIGNED *Destination,
1297  *    IN CONST VOID UNALIGNED *Source,
1298  *    IN SIZE_T Length)
1299  */
1300 #define RtlMoveMemory(Destination, Source, Length) \
1301     memmove(Destination, Source, Length)
1302
1303 NTSYSAPI
1304 NTSTATUS
1305 NTAPI
1306 RtlStringFromGUID(
1307     IN REFGUID Guid,
1308     OUT PUNICODE_STRING GuidString);
1309
1310 /* VOID
1311  * RtlZeroMemory(
1312  *     IN VOID UNALIGNED *Destination,
1313  *     IN SIZE_T Length)
1314  */
1315 #define RtlZeroMemory(Destination, Length) \
1316     memset(Destination, 0, Length)
1317
1318 #define RtlZeroBytes RtlZeroMemory
1319
1320
1321 #if (NTDDI_VERSION >= NTDDI_WIN2K)
1322 NTSYSAPI
1323 BOOLEAN
1324 NTAPI
1325 RtlAreBitsClear(
1326     IN PRTL_BITMAP BitMapHeader,
1327     IN ULONG StartingIndex,
1328     IN ULONG Length);
1329
1330 NTSYSAPI
1331 BOOLEAN
1332 NTAPI
1333 RtlAreBitsSet(
1334     IN PRTL_BITMAP BitMapHeader,
1335     IN ULONG StartingIndex,
1336     IN ULONG Length);
1337
1338 NTSYSAPI
1339 NTSTATUS
1340 NTAPI
1341 RtlAnsiStringToUnicodeString(
1342     IN OUT PUNICODE_STRING DestinationString,
1343     IN PANSI_STRING SourceString,
1344     IN BOOLEAN AllocateDestinationString);
1345
1346 NTSYSAPI
1347 ULONG
1348 NTAPI
1349 RtlxAnsiStringToUnicodeSize(
1350     IN PCANSI_STRING AnsiString);
1351
1352 #define RtlAnsiStringToUnicodeSize(String) (               \
1353   NLS_MB_CODE_PAGE_TAG ?                                   \
1354   RtlxAnsiStringToUnicodeSize(String) :                    \
1355   ((String)->Length + sizeof(ANSI_NULL)) * sizeof(WCHAR)   \
1356 )
1357
1358 NTSYSAPI
1359 NTSTATUS
1360 NTAPI
1361 RtlAppendUnicodeStringToString(
1362     IN OUT PUNICODE_STRING Destination,
1363     IN PCUNICODE_STRING Source);
1364
1365 NTSYSAPI
1366 NTSTATUS
1367 NTAPI
1368 RtlAppendUnicodeToString(
1369     IN OUT PUNICODE_STRING Destination,
1370     IN PCWSTR Source);
1371
1372 NTSYSAPI
1373 NTSTATUS
1374 NTAPI
1375 RtlCheckRegistryKey(
1376     IN ULONG RelativeTo,
1377     IN PWSTR Path);
1378
1379 NTSYSAPI
1380 VOID
1381 NTAPI
1382 RtlClearAllBits(
1383     IN PRTL_BITMAP BitMapHeader);
1384
1385 NTSYSAPI
1386 VOID
1387 NTAPI
1388 RtlClearBits(
1389     IN PRTL_BITMAP BitMapHeader,
1390     IN ULONG StartingIndex,
1391     IN ULONG NumberToClear);
1392
1393 NTSYSAPI
1394 SIZE_T
1395 NTAPI
1396 RtlCompareMemory(
1397     IN CONST VOID *Source1,
1398     IN CONST VOID *Source2,
1399     IN SIZE_T Length);
1400
1401 NTSYSAPI
1402 LONG
1403 NTAPI
1404 RtlCompareUnicodeString(
1405     IN PCUNICODE_STRING String1,
1406     IN PCUNICODE_STRING String2,
1407     IN BOOLEAN CaseInSensitive);
1408
1409 NTSYSAPI
1410 LONG
1411 NTAPI
1412 RtlCompareUnicodeStrings(
1413     IN PCWCH String1,
1414     IN SIZE_T String1Length,
1415     IN PCWCH String2,
1416     IN SIZE_T String2Length,
1417     IN BOOLEAN CaseInSensitive);
1418
1419 NTSYSAPI
1420 VOID
1421 NTAPI
1422 RtlCopyUnicodeString(
1423   IN OUT PUNICODE_STRING  DestinationString,
1424   IN PCUNICODE_STRING  SourceString);
1425
1426 NTSYSAPI
1427 NTSTATUS
1428 NTAPI
1429 RtlCreateRegistryKey(
1430     IN ULONG RelativeTo,
1431     IN PWSTR Path);
1432
1433 NTSYSAPI
1434 NTSTATUS
1435 NTAPI
1436 RtlCreateSecurityDescriptor(
1437     IN OUT PSECURITY_DESCRIPTOR SecurityDescriptor,
1438     IN ULONG Revision);
1439
1440 NTSYSAPI
1441 NTSTATUS
1442 NTAPI
1443 RtlDeleteRegistryValue(
1444     IN ULONG RelativeTo,
1445     IN PCWSTR Path,
1446     IN PCWSTR ValueName);
1447
1448 NTSYSAPI
1449 BOOLEAN
1450 NTAPI
1451 RtlEqualUnicodeString(
1452     IN CONST UNICODE_STRING *String1,
1453     IN CONST UNICODE_STRING *String2,
1454     IN BOOLEAN CaseInSensitive);
1455
1456 #if !defined(_AMD64_) && !defined(_IA64_)
1457 NTSYSAPI
1458 LARGE_INTEGER
1459 NTAPI
1460 RtlExtendedIntegerMultiply(
1461     IN LARGE_INTEGER Multiplicand,
1462     IN LONG Multiplier);
1463
1464 NTSYSAPI
1465 LARGE_INTEGER
1466 NTAPI
1467 RtlExtendedLargeIntegerDivide(
1468   IN LARGE_INTEGER Dividend,
1469   IN ULONG Divisor,
1470   IN OUT PULONG Remainder);
1471 #endif
1472
1473 #if defined(_X86_) || defined(_IA64_)
1474 NTSYSAPI
1475 LARGE_INTEGER
1476 NTAPI
1477 RtlExtendedMagicDivide(
1478     IN LARGE_INTEGER Dividend,
1479     IN LARGE_INTEGER MagicDivisor,
1480     IN CCHAR  ShiftCount);
1481 #endif
1482
1483 NTSYSAPI
1484 VOID
1485 NTAPI
1486 RtlFreeAnsiString(
1487     IN PANSI_STRING AnsiString);
1488
1489 NTSYSAPI
1490 ULONG
1491 NTAPI
1492 RtlFindClearBits(
1493     IN PRTL_BITMAP BitMapHeader,
1494     IN ULONG NumberToFind,
1495     IN ULONG HintIndex);
1496
1497 NTSYSAPI
1498 ULONG
1499 NTAPI
1500 RtlFindClearBitsAndSet(
1501     IN PRTL_BITMAP BitMapHeader,
1502     IN ULONG NumberToFind,
1503     IN ULONG HintIndex);
1504
1505 NTSYSAPI
1506 ULONG
1507 NTAPI
1508 RtlFindFirstRunClear(
1509     IN PRTL_BITMAP BitMapHeader,
1510     OUT PULONG StartingIndex);
1511
1512 NTSYSAPI
1513 ULONG
1514 NTAPI
1515 RtlFindClearRuns(
1516     IN PRTL_BITMAP BitMapHeader,
1517     OUT PRTL_BITMAP_RUN RunArray,
1518     IN ULONG SizeOfRunArray,
1519     IN BOOLEAN LocateLongestRuns);
1520
1521 NTSYSAPI
1522 ULONG
1523 NTAPI
1524 RtlFindLastBackwardRunClear(
1525     IN PRTL_BITMAP BitMapHeader,
1526     IN ULONG FromIndex,
1527     OUT PULONG StartingRunIndex);
1528
1529 NTSYSAPI
1530 CCHAR
1531 NTAPI
1532 RtlFindLeastSignificantBit(
1533     IN ULONGLONG Set);
1534
1535 NTSYSAPI
1536 ULONG
1537 NTAPI
1538 RtlFindLongestRunClear(
1539     IN PRTL_BITMAP BitMapHeader,
1540     OUT PULONG StartingIndex);
1541
1542 NTSYSAPI
1543 CCHAR
1544 NTAPI
1545 RtlFindMostSignificantBit(
1546     IN ULONGLONG Set);
1547
1548 NTSYSAPI
1549 ULONG
1550 NTAPI
1551 RtlFindNextForwardRunClear(
1552     IN PRTL_BITMAP BitMapHeader,
1553     IN ULONG FromIndex,
1554     OUT PULONG StartingRunIndex);
1555
1556 NTSYSAPI
1557 ULONG
1558 NTAPI
1559 RtlFindSetBits(
1560     IN PRTL_BITMAP BitMapHeader,
1561     IN ULONG NumberToFind,
1562     IN ULONG HintIndex);
1563
1564 NTSYSAPI
1565 ULONG
1566 NTAPI
1567 RtlFindSetBitsAndClear(
1568     IN PRTL_BITMAP BitMapHeader,
1569     IN ULONG NumberToFind,
1570     IN ULONG HintIndex);
1571
1572 NTSYSAPI
1573 NTSTATUS
1574 NTAPI
1575 RtlHashUnicodeString(
1576     IN CONST UNICODE_STRING *String,
1577     IN BOOLEAN CaseInSensitive,
1578     IN ULONG HashAlgorithm,
1579     OUT PULONG HashValue);
1580
1581 NTSYSAPI
1582 VOID
1583 NTAPI
1584 RtlInitAnsiString(
1585     IN OUT PANSI_STRING DestinationString,
1586     IN PCSZ SourceString);
1587
1588 NTSYSAPI
1589 VOID
1590 NTAPI
1591 RtlInitializeBitMap(
1592     IN PRTL_BITMAP BitMapHeader,
1593     IN PULONG BitMapBuffer,
1594     IN ULONG SizeOfBitMap);
1595
1596 NTSYSAPI
1597 VOID
1598 NTAPI
1599 RtlInitString(
1600     IN OUT PSTRING DestinationString,
1601     IN PCSZ SourceString);
1602
1603 NTSYSAPI
1604 NTSTATUS
1605 NTAPI
1606 RtlIntegerToUnicodeString(
1607     IN ULONG Value,
1608     IN ULONG Base OPTIONAL,
1609     IN OUT PUNICODE_STRING String);
1610
1611 NTSYSAPI
1612 NTSTATUS
1613 NTAPI
1614 RtlInt64ToUnicodeString(
1615     IN ULONGLONG Value,
1616     IN ULONG Base OPTIONAL,
1617     IN OUT PUNICODE_STRING String);
1618
1619 #ifdef _WIN64
1620 #define RtlIntPtrToUnicodeString(Value, Base, String) \
1621     RtlInt64ToUnicodeString(Value, Base, String)
1622 #else
1623 #define RtlIntPtrToUnicodeString(Value, Base, String) \
1624     RtlIntegerToUnicodeString(Value, Base, String)
1625 #endif
1626
1627 /* BOOLEAN
1628  * RtlIsZeroLuid(
1629  *     IN PLUID L1);
1630  */
1631 #define RtlIsZeroLuid(_L1) \
1632     ((BOOLEAN) ((!(_L1)->LowPart) && (!(_L1)->HighPart)))
1633
1634 NTSYSAPI
1635 ULONG
1636 NTAPI
1637 RtlLengthSecurityDescriptor(
1638     IN PSECURITY_DESCRIPTOR SecurityDescriptor);
1639
1640 NTSYSAPI
1641 ULONG
1642 NTAPI
1643 RtlNumberOfClearBits(
1644     IN PRTL_BITMAP BitMapHeader);
1645
1646 NTSYSAPI
1647 ULONG
1648 NTAPI
1649 RtlNumberOfSetBits(
1650     IN PRTL_BITMAP BitMapHeader);
1651
1652 NTSYSAPI
1653 NTSTATUS
1654 NTAPI
1655 RtlQueryRegistryValues(
1656     IN ULONG RelativeTo,
1657     IN PCWSTR Path,
1658     IN PRTL_QUERY_REGISTRY_TABLE QueryTable,
1659     IN PVOID Context,
1660     IN PVOID Environment OPTIONAL);
1661
1662 #define LONG_SIZE (sizeof(LONG))
1663 #define LONG_MASK (LONG_SIZE - 1)
1664
1665 /* VOID
1666  * RtlRetrieveUlong(
1667  *        PULONG DestinationAddress,
1668  *        PULONG SourceAddress);
1669  */
1670 #if defined(_AMD64_)
1671 #define RtlRetrieveUlong(DestAddress,SrcAddress) \
1672     *(ULONG UNALIGNED *)(DestAddress) = *(PULONG)(SrcAddress)
1673 #else
1674 #define RtlRetrieveUlong(DestAddress,SrcAddress) \
1675     if ((ULONG_PTR)(SrcAddress) & LONG_MASK) \
1676     { \
1677         ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
1678         ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
1679         ((PUCHAR)(DestAddress))[2]=((PUCHAR)(SrcAddress))[2]; \
1680         ((PUCHAR)(DestAddress))[3]=((PUCHAR)(SrcAddress))[3]; \
1681     } \
1682     else \
1683     { \
1684         *((PULONG)(DestAddress))=*((PULONG)(SrcAddress)); \
1685     }
1686 #endif
1687
1688 /* VOID
1689  * RtlRetrieveUshort(
1690  *        PUSHORT DestinationAddress,
1691  *        PUSHORT SourceAddress);
1692  */
1693 #if defined(_AMD64_)
1694 #define RtlRetrieveUshort(DestAddress,SrcAddress) \
1695     *(USHORT UNALIGNED *)(DestAddress) = *(USHORT)(SrcAddress)
1696 #else
1697 #define RtlRetrieveUshort(DestAddress,SrcAddress) \
1698     if ((ULONG_PTR)(SrcAddress) & LONG_MASK) \
1699     { \
1700         ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
1701         ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
1702     } \
1703     else \
1704     { \
1705         *((PUSHORT)(DestAddress))=*((PUSHORT)(SrcAddress)); \
1706     }
1707 #endif
1708
1709 NTSYSAPI
1710 VOID
1711 NTAPI
1712 RtlSetAllBits(
1713     IN PRTL_BITMAP BitMapHeader);
1714
1715 NTSYSAPI
1716 VOID
1717 NTAPI
1718 RtlSetBits(
1719     IN PRTL_BITMAP BitMapHeader,
1720     IN ULONG StartingIndex,
1721     IN ULONG NumberToSet);
1722
1723 NTSYSAPI
1724 NTSTATUS
1725 NTAPI
1726 RtlSetDaclSecurityDescriptor(
1727     IN OUT PSECURITY_DESCRIPTOR SecurityDescriptor,
1728     IN BOOLEAN DaclPresent,
1729     IN PACL Dacl OPTIONAL,
1730     IN BOOLEAN DaclDefaulted OPTIONAL);
1731
1732 /* VOID
1733  * RtlStoreUlong(
1734  *     IN PULONG Address,
1735  *     IN ULONG Value);
1736  */
1737 #if defined(_AMD64_)
1738 #define RtlStoreUlong(Address,Value) \
1739     *(ULONG UNALIGNED *)(Address) = (Value)
1740 #else
1741 #define RtlStoreUlong(Address,Value)                      \
1742     if ((ULONG_PTR)(Address) & LONG_MASK) { \
1743         ((PUCHAR) (Address))[LONG_LEAST_SIGNIFICANT_BIT]    = (UCHAR)(FIRSTBYTE(Value)); \
1744         ((PUCHAR) (Address))[LONG_3RD_MOST_SIGNIFICANT_BIT] = (UCHAR)(SECONDBYTE(Value)); \
1745         ((PUCHAR) (Address))[LONG_2ND_MOST_SIGNIFICANT_BIT] = (UCHAR)(THIRDBYTE(Value)); \
1746         ((PUCHAR) (Address))[LONG_MOST_SIGNIFICANT_BIT]     = (UCHAR)(FOURTHBYTE(Value)); \
1747     } \
1748     else { \
1749         *((PULONG)(Address)) = (ULONG) (Value); \
1750     }
1751 #endif
1752
1753 /* VOID
1754  * RtlStoreUlonglong(
1755  *     IN OUT PULONGLONG Address,
1756  *     ULONGLONG Value);
1757  */
1758 #if defined(_AMD64_)
1759 #define RtlStoreUlonglong(Address,Value) \
1760     *(ULONGLONG UNALIGNED *)(Address) = (Value)
1761 #else
1762 #define RtlStoreUlonglong(Address,Value) \
1763     if ((ULONG_PTR)(Address) & LONGLONG_MASK) { \
1764         RtlStoreUlong((ULONG_PTR)(Address), \
1765                       (ULONGLONG)(Value) & 0xFFFFFFFF); \
1766         RtlStoreUlong((ULONG_PTR)(Address)+sizeof(ULONG), \
1767                       (ULONGLONG)(Value) >> 32); \
1768     } else { \
1769         *((PULONGLONG)(Address)) = (ULONGLONG)(Value); \
1770     }
1771 #endif
1772
1773 /* VOID
1774  * RtlStoreUlongPtr(
1775  *     IN OUT PULONG_PTR Address,
1776  *     IN ULONG_PTR Value);
1777  */
1778 #ifdef _WIN64
1779 #define RtlStoreUlongPtr(Address,Value)                         \
1780     RtlStoreUlonglong(Address,Value)
1781 #else
1782 #define RtlStoreUlongPtr(Address,Value)                         \
1783     RtlStoreUlong(Address,Value)
1784 #endif
1785
1786 /* VOID
1787  * RtlStoreUshort(
1788  *     IN PUSHORT Address,
1789  *     IN USHORT Value);
1790  */
1791 #if defined(_AMD64_)
1792 #define RtlStoreUshort(Address,Value) \
1793     *(USHORT UNALIGNED *)(Address) = (Value)
1794 #else
1795 #define RtlStoreUshort(Address,Value) \
1796     if ((ULONG_PTR)(Address) & SHORT_MASK) { \
1797         ((PUCHAR) (Address))[SHORT_LEAST_SIGNIFICANT_BIT] = (UCHAR)(FIRSTBYTE(Value)); \
1798         ((PUCHAR) (Address))[SHORT_MOST_SIGNIFICANT_BIT ] = (UCHAR)(SECONDBYTE(Value)); \
1799     } \
1800     else { \
1801         *((PUSHORT) (Address)) = (USHORT)Value; \
1802     }
1803 #endif
1804
1805 NTSYSAPI
1806 BOOLEAN
1807 NTAPI
1808 RtlTimeFieldsToTime(
1809     IN PTIME_FIELDS TimeFields,
1810     IN PLARGE_INTEGER Time);
1811
1812 NTSYSAPI
1813 VOID
1814 NTAPI
1815 RtlTimeToTimeFields(
1816     IN PLARGE_INTEGER Time,
1817     IN PTIME_FIELDS TimeFields);
1818
1819 NTSYSAPI
1820 ULONG
1821 FASTCALL
1822 RtlUlongByteSwap(
1823     IN ULONG Source);
1824
1825 NTSYSAPI
1826 ULONGLONG
1827 FASTCALL
1828 RtlUlonglongByteSwap(
1829     IN ULONGLONG Source);
1830
1831 NTSYSAPI
1832 NTSTATUS
1833 NTAPI
1834 RtlUnicodeStringToAnsiString(
1835     IN OUT PANSI_STRING DestinationString,
1836     IN PCUNICODE_STRING SourceString,
1837     IN BOOLEAN AllocateDestinationString);
1838
1839 NTSYSAPI
1840 ULONG
1841 NTAPI
1842 RtlxUnicodeStringToAnsiSize(
1843     IN PCUNICODE_STRING UnicodeString);
1844
1845 #define RtlUnicodeStringToAnsiSize(String) (                  \
1846     NLS_MB_CODE_PAGE_TAG ?                                    \
1847     RtlxUnicodeStringToAnsiSize(String) :                     \
1848     ((String)->Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR) \
1849 )
1850
1851 NTSYSAPI
1852 NTSTATUS
1853 NTAPI
1854 RtlUnicodeStringToInteger(
1855     IN PCUNICODE_STRING String,
1856     IN ULONG Base OPTIONAL,
1857     OUT PULONG Value);
1858
1859 NTSYSAPI
1860 WCHAR
1861 NTAPI
1862 RtlUpcaseUnicodeChar(
1863     IN WCHAR SourceCharacter);
1864
1865 NTSYSAPI
1866 USHORT
1867 FASTCALL
1868 RtlUshortByteSwap(
1869     IN USHORT Source);
1870
1871 NTSYSAPI
1872 BOOLEAN
1873 NTAPI
1874 RtlValidRelativeSecurityDescriptor(
1875     IN PSECURITY_DESCRIPTOR SecurityDescriptorInput,
1876     IN ULONG SecurityDescriptorLength,
1877     IN SECURITY_INFORMATION RequiredInformation);
1878
1879 NTSYSAPI
1880 BOOLEAN
1881 NTAPI
1882 RtlValidSecurityDescriptor(
1883     IN PSECURITY_DESCRIPTOR SecurityDescriptor);
1884
1885 NTSYSAPI
1886 NTSTATUS
1887 NTAPI
1888 RtlWriteRegistryValue(
1889     IN ULONG RelativeTo,
1890     IN PCWSTR Path,
1891     IN PCWSTR ValueName,
1892     IN ULONG ValueType,
1893     IN PVOID ValueData,
1894     IN ULONG ValueLength);
1895
1896 #endif // (NTDDI_VERSION >= NTDDI_WIN2K)
1897
1898 #if (NTDDI_VERSION >= NTDDI_WIN2KSP3)
1899 NTSYSAPI
1900 VOID
1901 FASTCALL
1902 RtlPrefetchMemoryNonTemporal(
1903     IN PVOID Source,
1904     IN SIZE_T Length);
1905 #endif
1906
1907 #if (NTDDI_VERSION >= NTDDI_WINXP)
1908 NTSYSAPI
1909 VOID
1910 NTAPI
1911 RtlClearBit(
1912     PRTL_BITMAP BitMapHeader,
1913     ULONG BitNumber);
1914
1915 NTSYSAPI
1916 WCHAR
1917 NTAPI
1918 RtlDowncaseUnicodeChar(
1919     IN WCHAR SourceCharacter);
1920
1921 NTSYSAPI
1922 VOID
1923 NTAPI
1924 RtlSetBit(
1925     PRTL_BITMAP BitMapHeader,
1926     ULONG BitNumber);
1927
1928 NTSYSAPI
1929 BOOLEAN
1930 NTAPI
1931 RtlTestBit(
1932     IN PRTL_BITMAP BitMapHeader,
1933     IN ULONG BitNumber);
1934
1935 #endif // (NTDDI_VERSION >= NTDDI_WINXP)
1936
1937 #if (NTDDI_VERSION >= NTDDI_VISTA)
1938 NTSYSAPI
1939 ULONG
1940 NTAPI
1941 RtlNumberOfSetBitsUlongPtr(
1942     IN ULONG_PTR Target);
1943
1944 NTSYSAPI
1945 ULONGLONG
1946 NTAPI
1947 RtlIoDecodeMemIoResource (
1948     IN PIO_RESOURCE_DESCRIPTOR Descriptor,
1949     OUT PULONGLONG Alignment OPTIONAL,
1950     OUT PULONGLONG MinimumAddress OPTIONAL,
1951     OUT PULONGLONG MaximumAddress OPTIONAL);
1952
1953 NTSYSAPI
1954 NTSTATUS
1955 NTAPI
1956 RtlIoEncodeMemIoResource(
1957     IN PIO_RESOURCE_DESCRIPTOR Descriptor,
1958     IN UCHAR Type,
1959     IN ULONGLONG Length,
1960     IN ULONGLONG Alignment,
1961     IN ULONGLONG MinimumAddress,
1962     IN ULONGLONG MaximumAddress);
1963
1964 NTSYSAPI
1965 ULONGLONG
1966 NTAPI
1967 RtlCmDecodeMemIoResource(
1968     IN PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor,
1969     OUT PULONGLONG Start OPTIONAL);
1970
1971 NTSYSAPI
1972 NTSTATUS
1973 NTAPI
1974 RtlFindClosestEncodableLength(
1975     IN ULONGLONG SourceLength,
1976     OUT PULONGLONG TargetLength);
1977
1978 #endif
1979
1980 #if !defined(MIDL_PASS)
1981 /* inline funftions */
1982 //DECLSPEC_DEPRECATED_DDK_WINXP
1983 static __inline
1984 LARGE_INTEGER
1985 NTAPI_INLINE
1986 RtlConvertLongToLargeInteger(LONG SignedInteger)
1987 {
1988     LARGE_INTEGER ret;
1989     ret.QuadPart = SignedInteger;
1990     return ret;
1991 }
1992
1993 //DECLSPEC_DEPRECATED_DDK_WINXP
1994 static __inline
1995 LARGE_INTEGER
1996 NTAPI_INLINE
1997 RtlConvertUlongToLargeInteger(
1998   ULONG UnsignedInteger)
1999 {
2000     LARGE_INTEGER ret;
2001     ret.QuadPart = UnsignedInteger;
2002     return ret;
2003 }
2004
2005 //DECLSPEC_DEPRECATED_DDK
2006 static __inline
2007 ULONG
2008 NTAPI_INLINE
2009 RtlEnlargedUnsignedDivide(
2010     IN ULARGE_INTEGER Dividend,
2011     IN ULONG Divisor,
2012     IN OUT PULONG Remainder)
2013 {
2014     if (Remainder)
2015         *Remainder = (ULONG)(Dividend.QuadPart % Divisor);
2016     return (ULONG)(Dividend.QuadPart / Divisor);
2017 }
2018
2019 //DECLSPEC_DEPRECATED_DDK
2020 static __inline
2021 LARGE_INTEGER
2022 NTAPI_INLINE
2023 RtlEnlargedUnsignedMultiply(
2024     IN ULONG Multiplicand,
2025     IN ULONG Multiplier)
2026 {
2027     LARGE_INTEGER ret;
2028     ret.QuadPart = (ULONGLONG)Multiplicand * (ULONGLONG)Multiplier;
2029     return ret;
2030 }
2031
2032 //DECLSPEC_DEPRECATED_DDK
2033 static __inline
2034 LARGE_INTEGER
2035 NTAPI_INLINE
2036 RtlEnlargedIntegerMultiply(
2037     IN LONG Multiplicand,
2038     IN LONG Multiplier)
2039 {
2040     LARGE_INTEGER ret;
2041     ret.QuadPart = (LONGLONG)Multiplicand * (ULONGLONG)Multiplier;
2042     return ret;
2043 }
2044
2045 FORCEINLINE
2046 VOID
2047 RtlInitEmptyAnsiString(OUT PANSI_STRING AnsiString,
2048                        IN PCHAR Buffer,
2049                        IN USHORT BufferSize)
2050 {
2051     AnsiString->Length = 0;
2052     AnsiString->MaximumLength = BufferSize;
2053     AnsiString->Buffer = Buffer;
2054 }
2055
2056 FORCEINLINE
2057 VOID
2058 RtlInitEmptyUnicodeString(
2059     OUT PUNICODE_STRING UnicodeString,
2060     IN PWSTR Buffer,
2061     IN USHORT BufferSize)
2062 {
2063     UnicodeString->Length = 0;
2064     UnicodeString->MaximumLength = BufferSize;
2065     UnicodeString->Buffer = Buffer;
2066 }
2067
2068 #if defined(_AMD64_) || defined(_IA64_)
2069 static __inline
2070 LARGE_INTEGER
2071 NTAPI_INLINE
2072 RtlExtendedIntegerMultiply(
2073     LARGE_INTEGER Multiplicand,
2074     LONG Multiplier)
2075 {
2076     LARGE_INTEGER ret;
2077     ret.QuadPart = Multiplicand.QuadPart * Multiplier;
2078     return ret;
2079 }
2080
2081 static __inline
2082 LARGE_INTEGER
2083 NTAPI_INLINE
2084 RtlExtendedLargeIntegerDivide(
2085     LARGE_INTEGER Dividend,
2086     ULONG Divisor,
2087     PULONG Remainder)
2088 {
2089     LARGE_INTEGER ret;
2090     ret.QuadPart = (ULONG64)Dividend.QuadPart / Divisor;
2091     if (Remainder)
2092         *Remainder = (ULONG)(Dividend.QuadPart % Divisor);
2093     return ret;
2094 }
2095 #endif
2096
2097 #if defined(_AMD64_)
2098
2099 #define MultiplyHigh __mulh
2100 #define UnsignedMultiplyHigh __umulh
2101
2102 //DECLSPEC_DEPRECATED_DDK
2103 static __inline
2104 LARGE_INTEGER
2105 NTAPI_INLINE
2106 RtlExtendedMagicDivide(
2107     IN LARGE_INTEGER Dividend,
2108     IN LARGE_INTEGER MagicDivisor,
2109     IN CCHAR ShiftCount)
2110 {
2111     LARGE_INTEGER ret;
2112     ULONG64 ret64;
2113     BOOLEAN Pos;
2114     Pos = (Dividend.QuadPart >= 0);
2115     ret64 = UnsignedMultiplyHigh(Pos ? Dividend.QuadPart : -Dividend.QuadPart,
2116                                  MagicDivisor.QuadPart);
2117     ret64 >>= ShiftCount;
2118     ret.QuadPart = Pos ? ret64 : -ret64;
2119     return ret;
2120 }
2121 #endif
2122
2123 //DECLSPEC_DEPRECATED_DDK
2124 static __inline
2125 LARGE_INTEGER
2126 NTAPI_INLINE
2127 RtlLargeIntegerAdd(
2128     IN LARGE_INTEGER Addend1,
2129     IN LARGE_INTEGER Addend2)
2130 {
2131     LARGE_INTEGER ret;
2132     ret.QuadPart = Addend1.QuadPart + Addend2.QuadPart;
2133     return ret;
2134 }
2135
2136 /* VOID
2137  * RtlLargeIntegerAnd(
2138  *     IN OUT LARGE_INTEGER Result,
2139  *     IN LARGE_INTEGER Source,
2140  *     IN LARGE_INTEGER Mask);
2141  */
2142 #define RtlLargeIntegerAnd(Result, Source, Mask) \
2143     Result.QuadPart = Source.QuadPart & Mask.QuadPart
2144
2145 //DECLSPEC_DEPRECATED_DDK
2146 static __inline
2147 LARGE_INTEGER
2148 NTAPI_INLINE
2149 RtlLargeIntegerArithmeticShift(
2150     IN LARGE_INTEGER LargeInteger,
2151     IN CCHAR ShiftCount)
2152 {
2153     LARGE_INTEGER ret;
2154     ret.QuadPart = LargeInteger.QuadPart >> ShiftCount;
2155     return ret;
2156 }
2157
2158 /* BOOLEAN
2159  * RtlLargeIntegerEqualTo(
2160  *     IN LARGE_INTEGER  Operand1,
2161  *     IN LARGE_INTEGER  Operand2);
2162  */
2163 #define RtlLargeIntegerEqualTo(X,Y) \
2164     (!(((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)))
2165
2166 FORCEINLINE
2167 PVOID
2168 RtlSecureZeroMemory(
2169     OUT PVOID Pointer,
2170     IN SIZE_T Size)
2171 {
2172     volatile char* vptr = (volatile char*)Pointer;
2173 #if defined(_M_AMD64)
2174     __stosb((PUCHAR)vptr, 0, Size);
2175 #else
2176     char * endptr = (char *)vptr + Size;
2177     while (vptr < endptr)
2178     {
2179         *vptr = 0; vptr++;
2180     }
2181 #endif
2182      return Pointer;
2183 }
2184
2185 #if defined(_M_AMD64)
2186 FORCEINLINE
2187 ULONG
2188 RtlCheckBit(
2189     IN PRTL_BITMAP BitMapHeader,
2190     IN ULONG BitPosition)
2191 {
2192     return BitTest((LONG CONST*)BitMapHeader->Buffer, BitPosition);
2193 }
2194 #else
2195 #define RtlCheckBit(BMH,BP) (((((PLONG)(BMH)->Buffer)[(BP)/32]) >> ((BP)%32)) & 0x1)
2196 #endif // defined(_M_AMD64)
2197
2198 #endif // !defined(MIDL_PASS)
2199
2200 //
2201 // Byte Swap Functions
2202 //
2203 #if (defined(_M_IX86) && (_MSC_FULL_VER > 13009037 || defined(__GNUC__))) || \
2204     ((defined(_M_AMD64) || defined(_M_IA64)) \
2205         && (_MSC_FULL_VER > 13009175 || defined(__GNUC__)))
2206
2207 #define RtlUshortByteSwap(_x) _byteswap_ushort((USHORT)(_x))
2208 #define RtlUlongByteSwap(_x) _byteswap_ulong((_x))
2209 #define RtlUlonglongByteSwap(_x) _byteswap_uint64((_x))
2210
2211 #endif
2212
2213 /******************************************************************************
2214  *                         Memory manager Types                               *
2215  ******************************************************************************/
2216
2217 typedef struct _MDL {
2218     struct _MDL *Next;
2219     CSHORT Size;
2220     CSHORT MdlFlags;
2221     struct _EPROCESS *Process;
2222     PVOID MappedSystemVa;
2223     PVOID StartVa;
2224     ULONG ByteCount;
2225     ULONG ByteOffset;
2226 } MDL, *PMDL;
2227
2228
2229 /******************************************************************************
2230  *                       Memory manager Functions                             *
2231  ******************************************************************************/
2232
2233 /* PVOID MmGetSystemAddressForMdl(
2234  *     IN PMDL Mdl);
2235  */
2236 #define MmGetSystemAddressForMdl(Mdl) \
2237   (((Mdl)->MdlFlags & (MDL_MAPPED_TO_SYSTEM_VA | \
2238     MDL_SOURCE_IS_NONPAGED_POOL)) ? \
2239       ((Mdl)->MappedSystemVa) : \
2240       (MmMapLockedPages((Mdl), KernelMode)))
2241
2242 /* PVOID
2243  * MmGetSystemAddressForMdlSafe(
2244  *     IN PMDL Mdl,
2245  *     IN MM_PAGE_PRIORITY Priority)
2246  */
2247 #define MmGetSystemAddressForMdlSafe(_Mdl, _Priority) \
2248   (((_Mdl)->MdlFlags & (MDL_MAPPED_TO_SYSTEM_VA \
2249     | MDL_SOURCE_IS_NONPAGED_POOL)) ? \
2250     (_Mdl)->MappedSystemVa : \
2251     (PVOID) MmMapLockedPagesSpecifyCache((_Mdl), \
2252       KernelMode, MmCached, NULL, FALSE, (_Priority)))
2253
2254 #if (NTDDI_VERSION >= NTDDI_WIN2K)
2255 NTKERNELAPI
2256 PMDL
2257 NTAPI
2258 MmCreateMdl(
2259   IN PMDL  MemoryDescriptorList  OPTIONAL,
2260   IN PVOID  Base,
2261   IN SIZE_T  Length);
2262
2263 #endif
2264
2265
2266 /******************************************************************************
2267  *                         I/O Manager Functions                              *
2268  ******************************************************************************/
2269
2270 #if defined(USE_DMA_MACROS) && !defined(_NTHAL_) && \
2271    (defined(_NTDDK_) || defined(_NTDRIVER_)) || defined(_WDM_INCLUDED_)
2272
2273 #define DMA_MACROS_DEFINED
2274
2275 FORCEINLINE
2276 NTSTATUS
2277 IoAllocateAdapterChannel(
2278     IN PADAPTER_OBJECT AdapterObject,
2279     IN PDEVICE_OBJECT DeviceObject,
2280     IN ULONG NumberOfMapRegisters,
2281     IN PDRIVER_CONTROL ExecutionRoutine,
2282     IN PVOID Context)
2283 {
2284     PALLOCATE_ADAPTER_CHANNEL AllocateAdapterChannel;
2285     AllocateAdapterChannel =
2286         *(DmaAdapter)->DmaOperations->AllocateAdapterChannel;
2287     ASSERT(AllocateAdapterChannel);
2288     return AllocateAdapterChannel(DmaAdapter,
2289                                   DeviceObject,
2290                                   NumberOfMapRegisters,
2291                                   ExecutionRoutine,
2292                                   Context );
2293 }
2294
2295 FORCEINLINE
2296 BOOLEAN
2297 IoFlushAdapterBuffers(
2298     IN PADAPTER_OBJECT AdapterObject,
2299     IN PMDL Mdl,
2300     IN PVOID MapRegisterBase,
2301     IN PVOID CurrentVa,
2302     IN ULONG Length,
2303     IN BOOLEAN WriteToDevice)
2304 {
2305     PFLUSH_ADAPTER_BUFFERS FlushAdapterBuffers;
2306     FlushAdapterBuffers = *(DmaAdapter)->DmaOperations->FlushAdapterBuffers;
2307     ASSERT(FlushAdapterBuffers);
2308     return FlushAdapterBuffers(DmaAdapter,
2309                                Mdl,
2310                                MapRegisterBase,
2311                                CurrentVa,
2312                                Length,
2313                                WriteToDevice );
2314 }
2315
2316 FORCEINLINE
2317 VOID
2318 IoFreeAdapterChannel(
2319     IN PADAPTER_OBJECT AdapterObject)
2320 {
2321     PFREE_ADAPTER_CHANNEL FreeAdapterChannel;
2322     FreeAdapterChannel = *(DmaAdapter)->DmaOperations->FreeAdapterChannel;
2323     ASSERT(FreeAdapterChannel);
2324     FreeAdapterChannel(DmaAdapter);
2325 }
2326
2327 FORCEINLINE
2328 VOID
2329 IoFreeMapRegisters(
2330     IN PADAPTER_OBJECT AdapterObject,
2331     IN PVOID MapRegisterBase,
2332     IN ULONG NumberOfMapRegisters)
2333 {
2334     PFREE_MAP_REGISTERS FreeMapRegisters;
2335     FreeMapRegisters = *(DmaAdapter)->DmaOperations->FreeMapRegisters;
2336     ASSERT(FreeMapRegisters);
2337     FreeMapRegisters(DmaAdapter, MapRegisterBase, NumberOfMapRegisters);
2338 }
2339
2340 FORCEINLINE
2341 PHYSICAL_ADDRESS
2342 IoMapTransfer(
2343     IN PDMA_ADAPTER DmaAdapter,
2344     IN PMDL Mdl,
2345     IN PVOID MapRegisterBase,
2346     IN PVOID CurrentVa,
2347     IN OUT PULONG Length,
2348     IN BOOLEAN WriteToDevice)
2349 {
2350     PMAP_TRANSFER MapTransfer;
2351
2352     MapTransfer = *(DmaAdapter)->DmaOperations->MapTransfer;
2353     ASSERT(MapTransfer);
2354     return MapTransfer(DmaAdapter,
2355                        Mdl,
2356                        MapRegisterBase,
2357                        CurrentVa,
2358                        Length,
2359                        WriteToDevice);
2360 }
2361 #endif
2362
2363
2364 /******************************************************************************
2365  *                            Executive Types                                 *
2366  ******************************************************************************/
2367
2368 typedef enum _POOL_TYPE {
2369     NonPagedPool,
2370     PagedPool,
2371     NonPagedPoolMustSucceed,
2372     DontUseThisType,
2373     NonPagedPoolCacheAligned,
2374     PagedPoolCacheAligned,
2375     NonPagedPoolCacheAlignedMustS,
2376     MaxPoolType,
2377     NonPagedPoolSession = 32,
2378     PagedPoolSession,
2379     NonPagedPoolMustSucceedSession,
2380     DontUseThisTypeSession,
2381     NonPagedPoolCacheAlignedSession,
2382     PagedPoolCacheAlignedSession,
2383     NonPagedPoolCacheAlignedMustSSession
2384 } POOL_TYPE;
2385
2386 typedef enum _SUITE_TYPE {
2387     SmallBusiness,
2388     Enterprise,
2389     BackOffice,
2390     CommunicationServer,
2391     TerminalServer,
2392     SmallBusinessRestricted,
2393     EmbeddedNT,
2394     DataCenter,
2395     SingleUserTS,
2396     Personal,
2397     Blade,
2398     MaxSuiteType
2399 } SUITE_TYPE;
2400
2401 typedef enum _EX_POOL_PRIORITY {
2402     LowPoolPriority,
2403     LowPoolPrioritySpecialPoolOverrun = 8,
2404     LowPoolPrioritySpecialPoolUnderrun = 9,
2405     NormalPoolPriority = 16,
2406     NormalPoolPrioritySpecialPoolOverrun = 24,
2407     NormalPoolPrioritySpecialPoolUnderrun = 25,
2408     HighPoolPriority = 32,
2409     HighPoolPrioritySpecialPoolOverrun = 40,
2410     HighPoolPrioritySpecialPoolUnderrun = 41
2411 } EX_POOL_PRIORITY;
2412
2413 typedef struct _FAST_MUTEX
2414 {
2415     LONG Count;
2416     PKTHREAD Owner;
2417     ULONG Contention;
2418     KEVENT Gate;
2419     ULONG OldIrql;
2420 } FAST_MUTEX, *PFAST_MUTEX;
2421
2422 typedef ULONG_PTR ERESOURCE_THREAD, *PERESOURCE_THREAD;
2423
2424 typedef struct _OWNER_ENTRY {
2425     ERESOURCE_THREAD OwnerThread;
2426     _ANONYMOUS_UNION union {
2427         LONG OwnerCount;
2428         ULONG TableSize;
2429     } DUMMYUNIONNAME;
2430 } OWNER_ENTRY, *POWNER_ENTRY;
2431
2432 typedef struct _ERESOURCE
2433 {
2434     LIST_ENTRY SystemResourcesList;
2435     POWNER_ENTRY OwnerTable;
2436     SHORT ActiveCount;
2437     USHORT Flag;
2438     volatile PKSEMAPHORE SharedWaiters;
2439     volatile PKEVENT ExclusiveWaiters;
2440     OWNER_ENTRY OwnerEntry;
2441     ULONG ActiveEntries;
2442     ULONG ContentionCount;
2443     ULONG NumberOfSharedWaiters;
2444     ULONG NumberOfExclusiveWaiters;
2445     __GNU_EXTENSION union
2446     {
2447         PVOID Address;
2448         ULONG_PTR CreatorBackTraceIndex;
2449     };
2450     KSPIN_LOCK SpinLock;
2451 } ERESOURCE, *PERESOURCE;
2452
2453 #if !defined(_WIN64) && (defined(_NTDDK_) || defined(_NTIFS_) || defined(_NDIS_))
2454 #define LOOKASIDE_ALIGN
2455 #else
2456 #define LOOKASIDE_ALIGN /* FIXME: DECLSPEC_CACHEALIGN */
2457 #endif
2458
2459 typedef struct _LOOKASIDE_LIST_EX *PLOOKASIDE_LIST_EX;
2460
2461 typedef PVOID
2462 (DDKAPI *PALLOCATE_FUNCTION)(
2463     IN POOL_TYPE PoolType,
2464     IN SIZE_T NumberOfBytes,
2465     IN ULONG Tag);
2466
2467 typedef PVOID
2468 (DDKAPI *PALLOCATE_FUNCTION_EX)(
2469     IN POOL_TYPE PoolType,
2470     IN SIZE_T NumberOfBytes,
2471     IN ULONG Tag,
2472     IN OUT PLOOKASIDE_LIST_EX Lookaside);
2473
2474 typedef VOID
2475 (DDKAPI *PFREE_FUNCTION)(
2476     IN PVOID Buffer);
2477
2478 typedef VOID
2479 (DDKAPI *PFREE_FUNCTION_EX)(
2480     IN PVOID Buffer,
2481     IN OUT PLOOKASIDE_LIST_EX Lookaside);
2482
2483 typedef VOID
2484 (DDKAPI *PCALLBACK_FUNCTION)(
2485   IN PVOID  CallbackContext,
2486   IN PVOID  Argument1,
2487   IN PVOID  Argument2);
2488
2489 typedef struct LOOKASIDE_ALIGN _GENERAL_LOOKASIDE {
2490     union {
2491         SLIST_HEADER ListHead;
2492         SINGLE_LIST_ENTRY SingleListHead;
2493     } DUMMYUNIONNAME;
2494     USHORT Depth;
2495     USHORT MaximumDepth;
2496     ULONG TotalAllocates;
2497     union {
2498         ULONG AllocateMisses;
2499         ULONG AllocateHits;
2500     } DUMMYUNIONNAME2;
2501     ULONG TotalFrees;
2502     union {
2503         ULONG FreeMisses;
2504         ULONG FreeHits;
2505     } DUMMYUNIONNAME3;
2506     POOL_TYPE Type;
2507     ULONG Tag;
2508     ULONG Size;
2509     union {
2510         PALLOCATE_FUNCTION_EX AllocateEx;
2511         PALLOCATE_FUNCTION Allocate;
2512     } DUMMYUNIONNAME4;
2513     union {
2514         PFREE_FUNCTION_EX FreeEx;
2515         PFREE_FUNCTION Free;
2516     } DUMMYUNIONNAME5;
2517     LIST_ENTRY ListEntry;
2518     ULONG  LastTotalAllocates;
2519     union {
2520         ULONG  LastAllocateMisses;
2521         ULONG  LastAllocateHits;
2522     } DUMMYUNIONNAME6;
2523     ULONG Future[2];
2524 } GENERAL_LOOKASIDE, *PGENERAL_LOOKASIDE;
2525
2526 typedef struct _PAGED_LOOKASIDE_LIST {
2527     GENERAL_LOOKASIDE L;
2528 #if !defined(_AMD64_) && !defined(_IA64_)
2529     FAST_MUTEX Lock__ObsoleteButDoNotDelete;
2530 #endif
2531 } PAGED_LOOKASIDE_LIST, *PPAGED_LOOKASIDE_LIST;
2532
2533 typedef struct LOOKASIDE_ALIGN _NPAGED_LOOKASIDE_LIST {
2534     GENERAL_LOOKASIDE L;
2535 #if !defined(_AMD64_) && !defined(_IA64_)
2536     KSPIN_LOCK Lock__ObsoleteButDoNotDelete;
2537 #endif
2538 } NPAGED_LOOKASIDE_LIST, *PNPAGED_LOOKASIDE_LIST;
2539
2540 //typedef struct _LOOKASIDE_LIST_EX {
2541 //    GENERAL_LOOKASIDE_POOL L;
2542 //} LOOKASIDE_LIST_EX, *PLOOKASIDE_LIST_EX;
2543
2544 typedef struct _EX_RUNDOWN_REF {
2545     __GNU_EXTENSION union {
2546         volatile ULONG_PTR Count;
2547         volatile PVOID Ptr;
2548     };
2549 } EX_RUNDOWN_REF, *PEX_RUNDOWN_REF;
2550
2551 typedef struct _EX_RUNDOWN_REF_CACHE_AWARE  *PEX_RUNDOWN_REF_CACHE_AWARE;
2552
2553 typedef enum _WORK_QUEUE_TYPE {
2554   CriticalWorkQueue,
2555   DelayedWorkQueue,
2556   HyperCriticalWorkQueue,
2557   MaximumWorkQueue
2558 } WORK_QUEUE_TYPE;
2559
2560 typedef VOID
2561 (DDKAPI *PWORKER_THREAD_ROUTINE)(
2562   IN PVOID Parameter);
2563
2564 typedef struct _WORK_QUEUE_ITEM {
2565   LIST_ENTRY  List;
2566   PWORKER_THREAD_ROUTINE  WorkerRoutine;
2567   volatile PVOID  Parameter;
2568 } WORK_QUEUE_ITEM, *PWORK_QUEUE_ITEM;
2569
2570
2571 /******************************************************************************
2572  *                          Executive Functions                               *
2573  ******************************************************************************/
2574
2575 #if defined(_X86_)
2576 #if defined(_NTHAL_)
2577 #define ExAcquireFastMutex ExiAcquireFastMutex
2578 #define ExReleaseFastMutex ExiReleaseFastMutex
2579 #define ExTryToAcquireFastMutex ExiTryToAcquireFastMutex
2580 #endif
2581 #define ExInterlockedAddUlong ExfInterlockedAddUlong
2582 #define ExInterlockedInsertHeadList ExfInterlockedInsertHeadList
2583 #define ExInterlockedInsertTailList ExfInterlockedInsertTailList
2584 #define ExInterlockedRemoveHeadList ExfInterlockedRemoveHeadList
2585 #define ExInterlockedPopEntryList ExfInterlockedPopEntryList
2586 #define ExInterlockedPushEntryList ExfInterlockedPushEntryList
2587 #endif
2588
2589 #if defined(_WIN64)
2590
2591 #if defined(_NTDRIVER_) || defined(_NTDDK_) || defined(_NTIFS_) || \
2592     defined(_NTHAL_) || defined(_NTOSP_)
2593 NTKERNELAPI
2594 USHORT
2595 ExQueryDepthSList(IN PSLIST_HEADER ListHead);
2596 #else
2597 FORCEINLINE
2598 USHORT
2599 ExQueryDepthSList(IN PSLIST_HEADER ListHead)
2600 {
2601     return (USHORT)(ListHead->Alignment & 0xffff);
2602 }
2603 #endif
2604
2605 NTKERNELAPI
2606 PSLIST_ENTRY
2607 ExpInterlockedFlushSList(
2608     PSLIST_HEADER ListHead);
2609
2610 NTKERNELAPI
2611 PSLIST_ENTRY
2612 ExpInterlockedPopEntrySList(
2613     PSLIST_HEADER ListHead);
2614
2615 NTKERNELAPI
2616 PSLIST_ENTRY
2617 ExpInterlockedPushEntrySList(
2618     PSLIST_HEADER ListHead,
2619     PSLIST_ENTRY ListEntry);
2620
2621 #define ExInterlockedFlushSList(Head) \
2622     ExpInterlockedFlushSList(Head)
2623 #define ExInterlockedPopEntrySList(Head, Lock) \
2624     ExpInterlockedPopEntrySList(Head)
2625 #define ExInterlockedPushEntrySList(Head, Entry, Lock) \
2626     ExpInterlockedPushEntrySList(Head, Entry)
2627
2628 #else // !defined(_WIN64)
2629
2630 #define ExQueryDepthSList(listhead) (listhead)->Depth
2631
2632 NTKERNELAPI
2633 PSINGLE_LIST_ENTRY
2634 FASTCALL
2635 ExInterlockedFlushSList(
2636     IN PSLIST_HEADER ListHead);
2637
2638 #if defined(_WIN2K_COMPAT_SLIST_USAGE) && defined(_X86_)
2639 NTKERNELAPI
2640 PSINGLE_LIST_ENTRY
2641 FASTCALL
2642 ExInterlockedPopEntrySList(
2643     IN PSLIST_HEADER ListHead,
2644     IN PKSPIN_LOCK Lock);
2645
2646 NTKERNELAPI
2647 PSINGLE_LIST_ENTRY
2648 FASTCALL
2649 ExInterlockedPushEntrySList(
2650     IN PSLIST_HEADER ListHead,
2651     IN PSINGLE_LIST_ENTRY ListEntry,
2652     IN PKSPIN_LOCK Lock);
2653 #else
2654 #define ExInterlockedPopEntrySList(_ListHead, _Lock) \
2655     InterlockedPopEntrySList(_ListHead)
2656 #define ExInterlockedPushEntrySList(_ListHead, _ListEntry, _Lock) \
2657     InterlockedPushEntrySList(_ListHead, _ListEntry)
2658 #endif // _WIN2K_COMPAT_SLIST_USAGE
2659
2660 #endif // !defined(_WIN64)
2661
2662 /* ERESOURCE_THREAD
2663  * ExGetCurrentResourceThread(
2664  *     VOID);
2665  */
2666 #define ExGetCurrentResourceThread() ((ERESOURCE_THREAD)PsGetCurrentThread())
2667
2668 #define ExReleaseResource(R) (ExReleaseResourceLite(R))
2669
2670 /* VOID
2671  * ExInitializeWorkItem(
2672  *     IN PWORK_QUEUE_ITEM Item,
2673  *     IN PWORKER_THREAD_ROUTINE Routine,
2674  *     IN PVOID Context)
2675  */
2676 #define ExInitializeWorkItem(Item, Routine, Context) \
2677 { \
2678   (Item)->WorkerRoutine = Routine; \
2679   (Item)->Parameter = Context; \
2680   (Item)->List.Flink = NULL; \
2681 }
2682
2683 #if (NTDDI_VERSION >= NTDDI_WIN2K)
2684
2685 NTKERNELAPI
2686 VOID
2687 FASTCALL
2688 ExAcquireFastMutex(
2689     IN OUT PFAST_MUTEX FastMutex);
2690
2691 NTKERNELAPI
2692 VOID
2693 FASTCALL
2694 ExReleaseFastMutex(
2695     IN OUT PFAST_MUTEX FastMutex);
2696
2697 NTKERNELAPI
2698 BOOLEAN
2699 FASTCALL
2700 ExTryToAcquireFastMutex(
2701     IN OUT PFAST_MUTEX FastMutex);
2702
2703 NTKERNELAPI
2704 VOID
2705 FASTCALL
2706 ExAcquireFastMutexUnsafe(
2707     IN OUT PFAST_MUTEX FastMutex);
2708
2709 NTKERNELAPI
2710 VOID
2711 FASTCALL
2712 ExReleaseFastMutexUnsafe(
2713     IN OUT PFAST_MUTEX FastMutex);
2714
2715 NTKERNELAPI
2716 BOOLEAN
2717 NTAPI
2718 ExAcquireResourceExclusiveLite(
2719     IN PERESOURCE Resource,
2720     IN BOOLEAN Wait);
2721
2722 NTKERNELAPI
2723 BOOLEAN
2724 NTAPI
2725 ExAcquireResourceSharedLite(
2726     IN PERESOURCE Resource,
2727     IN BOOLEAN Wait);
2728
2729 NTKERNELAPI
2730 BOOLEAN
2731 NTAPI
2732 ExAcquireSharedStarveExclusive(
2733     IN PERESOURCE Resource,
2734     IN BOOLEAN Wait);
2735
2736 NTKERNELAPI
2737 BOOLEAN
2738 NTAPI
2739 ExAcquireSharedWaitForExclusive(
2740     IN PERESOURCE Resource,
2741     IN BOOLEAN Wait);
2742
2743 NTKERNELAPI
2744 PVOID
2745 NTAPI
2746 ExAllocatePool(
2747     IN POOL_TYPE PoolType,
2748     IN SIZE_T NumberOfBytes);
2749
2750 #ifdef POOL_TAGGING
2751 #define ExAllocatePool(p,n) ExAllocatePoolWithTag(p,n,' kdD')
2752 #endif /* POOL_TAGGING */
2753
2754 NTKERNELAPI
2755 PVOID
2756 NTAPI
2757 ExAllocatePoolWithQuota(
2758     IN POOL_TYPE PoolType,
2759     IN SIZE_T NumberOfBytes);
2760
2761 #ifdef POOL_TAGGING
2762 #define ExAllocatePoolWithQuota(p,n) ExAllocatePoolWithQuotaTag(p,n,' kdD')
2763 #endif /* POOL_TAGGING */
2764
2765 NTKERNELAPI
2766 PVOID
2767 NTAPI
2768 ExAllocatePoolWithQuotaTag(
2769   IN POOL_TYPE  PoolType,
2770   IN SIZE_T  NumberOfBytes,
2771   IN ULONG  Tag);
2772
2773 #ifndef POOL_TAGGING
2774 #define ExAllocatePoolWithQuotaTag(a,b,c) ExAllocatePoolWithQuota(a,b)
2775 #endif /* POOL_TAGGING */
2776
2777 NTKERNELAPI
2778 PVOID
2779 NTAPI
2780 ExAllocatePoolWithTag(
2781     IN POOL_TYPE PoolType,
2782     IN SIZE_T NumberOfBytes,
2783     IN ULONG Tag);
2784
2785 NTKERNELAPI
2786 PVOID
2787 NTAPI
2788 ExAllocatePoolWithTagPriority(
2789     IN POOL_TYPE PoolType,
2790     IN SIZE_T NumberOfBytes,
2791     IN ULONG Tag,
2792     IN EX_POOL_PRIORITY Priority);
2793
2794 NTKERNELAPI
2795 VOID
2796 NTAPI
2797 ExConvertExclusiveToSharedLite(
2798     IN PERESOURCE Resource);
2799
2800 NTKERNELAPI
2801 NTSTATUS
2802 NTAPI
2803 ExCreateCallback(
2804     OUT PCALLBACK_OBJECT *CallbackObject,
2805     IN POBJECT_ATTRIBUTES ObjectAttributes,
2806     IN BOOLEAN Create,
2807     IN BOOLEAN AllowMultipleCallbacks);
2808
2809 NTKERNELAPI
2810 VOID
2811 NTAPI
2812 ExDeleteNPagedLookasideList(
2813     IN PNPAGED_LOOKASIDE_LIST Lookaside);
2814
2815 NTKERNELAPI
2816 VOID
2817 NTAPI
2818 ExDeletePagedLookasideList(
2819     IN PPAGED_LOOKASIDE_LIST Lookaside);
2820
2821 NTKERNELAPI
2822 NTSTATUS
2823 NTAPI
2824 ExDeleteResourceLite(
2825     IN PERESOURCE Resource);
2826
2827 NTKERNELAPI
2828 VOID
2829 NTAPI
2830 ExFreePool(
2831     IN PVOID P);
2832
2833 #ifdef POOL_TAGGING
2834 #define ExFreePool(P) ExFreePoolWithTag(P, 0)
2835 #endif
2836
2837 NTKERNELAPI
2838 VOID
2839 NTAPI
2840 ExFreePoolWithTag(
2841     IN PVOID P,
2842     IN ULONG Tag);
2843
2844 NTKERNELAPI
2845 ULONG
2846 NTAPI
2847 ExGetExclusiveWaiterCount(
2848     IN PERESOURCE Resource);
2849
2850 NTKERNELAPI
2851 KPROCESSOR_MODE
2852 NTAPI
2853 ExGetPreviousMode(
2854     VOID);
2855
2856 NTKERNELAPI
2857 ULONG
2858 NTAPI
2859 ExGetSharedWaiterCount(
2860     IN PERESOURCE Resource);
2861
2862 NTKERNELAPI
2863 VOID
2864 NTAPI
2865 ExInitializeNPagedLookasideList(
2866     IN PNPAGED_LOOKASIDE_LIST Lookaside,
2867     IN PALLOCATE_FUNCTION Allocate OPTIONAL,
2868     IN PFREE_FUNCTION Free OPTIONAL,
2869     IN ULONG Flags,
2870     IN SIZE_T Size,
2871     IN ULONG Tag,
2872     IN USHORT Depth);
2873
2874 NTKERNELAPI
2875 VOID
2876 NTAPI
2877 ExInitializePagedLookasideList(
2878     IN PPAGED_LOOKASIDE_LIST Lookaside,
2879     IN PALLOCATE_FUNCTION Allocate OPTIONAL,
2880     IN PFREE_FUNCTION Free OPTIONAL,
2881     IN ULONG Flags,
2882     IN SIZE_T Size,
2883     IN ULONG Tag,
2884     IN USHORT Depth);
2885
2886 NTKERNELAPI
2887 NTSTATUS
2888 NTAPI
2889 ExInitializeResourceLite(
2890     IN PERESOURCE Resource);
2891
2892 NTKERNELAPI
2893 LARGE_INTEGER
2894 NTAPI
2895 ExInterlockedAddLargeInteger(
2896     IN PLARGE_INTEGER Addend,
2897     IN LARGE_INTEGER Increment,
2898     IN PKSPIN_LOCK Lock);
2899
2900 #if defined(_WIN64)
2901 #define ExInterlockedAddLargeStatistic(Addend, Increment) \
2902     (VOID)InterlockedAdd64(&(Addend)->QuadPart, Increment)
2903 #else
2904 #define ExInterlockedAddLargeStatistic(Addend, Increment) \
2905     _InterlockedAddLargeStatistic((PLONGLONG)&(Addend)->QuadPart, Increment)
2906 #endif
2907
2908 NTKERNELAPI
2909 ULONG
2910 FASTCALL
2911 ExInterlockedAddUlong(
2912     IN PULONG Addend,
2913     IN ULONG Increment,
2914     PKSPIN_LOCK Lock);
2915
2916 #if defined(_AMD64_) || defined(_IA64_)
2917 #define ExInterlockedCompareExchange64(Destination, Exchange, Comperand, Lock) \
2918     InterlockedCompareExchange64(Destination, *(Exchange), *(Comperand))
2919 #elif defined(_X86_)
2920 NTKERNELAPI
2921 LONGLONG
2922 FASTCALL
2923 ExfInterlockedCompareExchange64(
2924     IN OUT LONGLONG volatile *Destination,
2925     IN PLONGLONG Exchange,
2926     IN PLONGLONG Comperand);
2927 #define ExInterlockedCompareExchange64(Destination, Exchange, Comperand, Lock) \
2928     ExfInterlockedCompareExchange64(Destination, Exchange, Comperand)
2929 #else
2930 NTKERNELAPI
2931 LONGLONG
2932 FASTCALL
2933 ExInterlockedCompareExchange64(
2934     IN OUT LONGLONG volatile *Destination,
2935     IN PLONGLONG Exchange,
2936     IN PLONGLONG Comparand,
2937     IN PKSPIN_LOCK Lock);
2938 #endif
2939
2940 NTKERNELAPI
2941 PLIST_ENTRY
2942 FASTCALL
2943 ExInterlockedInsertHeadList(
2944     IN PLIST_ENTRY ListHead,
2945     IN PLIST_ENTRY ListEntry,
2946     IN PKSPIN_LOCK Lock);
2947
2948 NTKERNELAPI
2949 PLIST_ENTRY
2950 FASTCALL
2951 ExInterlockedInsertTailList(
2952     IN PLIST_ENTRY ListHead,
2953     IN PLIST_ENTRY ListEntry,
2954     IN PKSPIN_LOCK Lock);
2955
2956 NTKERNELAPI
2957 PSINGLE_LIST_ENTRY
2958 FASTCALL
2959 ExInterlockedPopEntryList(
2960     IN PSINGLE_LIST_ENTRY ListHead,
2961     IN PKSPIN_LOCK Lock);
2962
2963 NTKERNELAPI
2964 PSINGLE_LIST_ENTRY
2965 FASTCALL
2966 ExInterlockedPushEntryList(
2967     IN PSINGLE_LIST_ENTRY ListHead,
2968     IN PSINGLE_LIST_ENTRY ListEntry,
2969     IN PKSPIN_LOCK Lock);
2970
2971 NTKERNELAPI
2972 PLIST_ENTRY
2973 FASTCALL
2974 ExInterlockedRemoveHeadList(
2975     IN PLIST_ENTRY ListHead,
2976     IN PKSPIN_LOCK Lock);
2977
2978 NTKERNELAPI
2979 BOOLEAN
2980 NTAPI
2981 ExIsProcessorFeaturePresent(
2982     IN ULONG ProcessorFeature);
2983
2984 NTKERNELAPI
2985 BOOLEAN
2986 NTAPI
2987 ExIsResourceAcquiredExclusiveLite(
2988     IN PERESOURCE Resource);
2989
2990 NTKERNELAPI
2991 ULONG
2992 NTAPI
2993 ExIsResourceAcquiredSharedLite(
2994     IN PERESOURCE Resource);
2995
2996 #define ExIsResourceAcquiredLite ExIsResourceAcquiredSharedLite
2997
2998 NTKERNELAPI
2999 VOID
3000 NTAPI
3001 ExLocalTimeToSystemTime(
3002     IN PLARGE_INTEGER LocalTime,
3003     OUT PLARGE_INTEGER SystemTime);
3004
3005 NTKERNELAPI
3006 VOID
3007 NTAPI
3008 ExNotifyCallback(
3009     IN PCALLBACK_OBJECT CallbackObject,
3010     IN PVOID Argument1,
3011     IN PVOID Argument2);
3012
3013 NTKERNELAPI
3014 VOID
3015 NTAPI
3016 ExQueueWorkItem(
3017     IN PWORK_QUEUE_ITEM WorkItem,
3018     IN WORK_QUEUE_TYPE QueueType);
3019
3020 NTKERNELAPI
3021 DECLSPEC_NORETURN
3022 VOID
3023 NTAPI
3024 ExRaiseStatus(
3025     IN NTSTATUS Status);
3026
3027 NTKERNELAPI
3028 PVOID
3029 NTAPI
3030 ExRegisterCallback(
3031     IN PCALLBACK_OBJECT CallbackObject,
3032     IN PCALLBACK_FUNCTION CallbackFunction,
3033     IN PVOID CallbackContext);
3034
3035 NTKERNELAPI
3036 NTSTATUS
3037 NTAPI
3038 ExReinitializeResourceLite(
3039     IN PERESOURCE Resource);
3040
3041 NTKERNELAPI
3042 VOID
3043 NTAPI
3044 ExReleaseResourceForThreadLite(
3045     IN PERESOURCE Resource,
3046     IN ERESOURCE_THREAD ResourceThreadId);
3047
3048 NTKERNELAPI
3049 VOID
3050 FASTCALL
3051 ExReleaseResourceLite(
3052     IN PERESOURCE Resource);
3053
3054 NTKERNELAPI
3055 VOID
3056 NTAPI
3057 ExSetResourceOwnerPointer(
3058     IN PERESOURCE Resource,
3059     IN PVOID OwnerPointer);
3060
3061 NTKERNELAPI
3062 ULONG
3063 NTAPI
3064 ExSetTimerResolution(
3065     IN ULONG DesiredTime,
3066     IN BOOLEAN SetResolution);
3067
3068 NTKERNELAPI
3069 VOID
3070 NTAPI
3071 ExSystemTimeToLocalTime(
3072     IN PLARGE_INTEGER SystemTime,
3073     OUT PLARGE_INTEGER LocalTime);
3074
3075 NTKERNELAPI
3076 VOID
3077 NTAPI
3078 ExUnregisterCallback(
3079     IN PVOID CbRegistration);
3080
3081
3082 #endif // (NTDDI_VERSION >= NTDDI_WIN2K)
3083
3084 #if (NTDDI_VERSION >= NTDDI_WINXP)
3085 NTKERNELAPI
3086 BOOLEAN
3087 FASTCALL
3088 ExAcquireRundownProtection(
3089     IN OUT PEX_RUNDOWN_REF RunRef);
3090
3091 NTKERNELAPI
3092 VOID
3093 FASTCALL
3094 ExInitializeRundownProtection(
3095     OUT PEX_RUNDOWN_REF RunRef);
3096
3097 NTKERNELAPI
3098 VOID
3099 FASTCALL
3100 ExReInitializeRundownProtection(
3101     OUT PEX_RUNDOWN_REF RunRef);
3102
3103 NTKERNELAPI
3104 VOID
3105 FASTCALL
3106 ExReleaseRundownProtection(
3107     IN OUT PEX_RUNDOWN_REF RunRef);
3108
3109 NTKERNELAPI
3110 VOID
3111 FASTCALL
3112 ExRundownCompleted(
3113     OUT PEX_RUNDOWN_REF RunRef);
3114
3115 NTKERNELAPI
3116 BOOLEAN
3117 NTAPI
3118 ExVerifySuite(
3119     IN SUITE_TYPE SuiteType);
3120
3121 NTKERNELAPI
3122 VOID
3123 FASTCALL
3124 ExWaitForRundownProtectionRelease(
3125     IN OUT PEX_RUNDOWN_REF RunRef);
3126
3127 #endif // (NTDDI_VERSION >= NTDDI_WINXP)
3128
3129 #if (NTDDI_VERSION >= NTDDI_WINXPSP2)
3130 NTKERNELAPI
3131 BOOLEAN
3132 FASTCALL
3133 ExAcquireRundownProtectionEx(
3134     IN OUT PEX_RUNDOWN_REF RunRef,
3135     IN ULONG Count);
3136
3137 NTKERNELAPI
3138 VOID
3139 FASTCALL
3140 ExReleaseRundownProtectionEx(
3141     IN OUT PEX_RUNDOWN_REF RunRef,
3142     IN ULONG Count);
3143 #endif // (NTDDI_VERSION >= NTDDI_WINXPSP2)
3144
3145 #if (NTDDI_VERSION >= NTDDI_WS03)
3146
3147 #endif // (NTDDI_VERSION >= NTDDI_WS03)
3148
3149 #if (NTDDI_VERSION >= NTDDI_WS03SP1)
3150 NTKERNELAPI
3151 PEX_RUNDOWN_REF_CACHE_AWARE
3152 ExAllocateCacheAwareRundownProtection(
3153     IN POOL_TYPE PoolType,
3154     IN ULONG PoolTag);
3155
3156 NTKERNELAPI
3157 SIZE_T
3158 ExSizeOfRundownProtectionCacheAware(VOID);
3159
3160 #endif // (NTDDI_VERSION >= NTDDI_WS03SP1)
3161
3162 #if (NTDDI_VERSION >= NTDDI_VISTA)
3163 NTKERNELAPI
3164 NTSTATUS
3165 ExInitializeLookasideListEx(
3166     OUT PLOOKASIDE_LIST_EX Lookaside,
3167     IN PALLOCATE_FUNCTION_EX Allocate OPTIONAL,
3168     IN PFREE_FUNCTION_EX Free OPTIONAL,
3169     IN POOL_TYPE PoolType,
3170     IN ULONG Flags,
3171     IN SIZE_T Size,
3172     IN ULONG Tag,
3173     IN USHORT Depth);
3174 #endif
3175
3176
3177 #if !defined(MIDL_PASS)
3178
3179 static __inline PVOID
3180 ExAllocateFromNPagedLookasideList(
3181     IN PNPAGED_LOOKASIDE_LIST Lookaside)
3182 {
3183     PVOID Entry;
3184
3185     Lookaside->L.TotalAllocates++;
3186     Entry = InterlockedPopEntrySList(&Lookaside->L.ListHead);
3187     if (Entry == NULL) {
3188         Lookaside->L.AllocateMisses++;
3189         Entry = (Lookaside->L.Allocate)(Lookaside->L.Type,
3190                                         Lookaside->L.Size,
3191                                         Lookaside->L.Tag);
3192     }
3193     return Entry;
3194 }
3195
3196 static __inline PVOID
3197 ExAllocateFromPagedLookasideList(
3198     IN PPAGED_LOOKASIDE_LIST Lookaside)
3199 {
3200     PVOID Entry;
3201
3202     Lookaside->L.TotalAllocates++;
3203     Entry = InterlockedPopEntrySList(&Lookaside->L.ListHead);
3204     if (Entry == NULL) {
3205         Lookaside->L.AllocateMisses++;
3206         Entry = (Lookaside->L.Allocate)(Lookaside->L.Type,
3207                                         Lookaside->L.Size,
3208                                         Lookaside->L.Tag);
3209     }
3210     return Entry;
3211 }
3212
3213 static __inline VOID
3214 ExFreeToNPagedLookasideList(
3215     IN PNPAGED_LOOKASIDE_LIST Lookaside,
3216     IN PVOID  Entry)
3217 {
3218     Lookaside->L.TotalFrees++;
3219     if (ExQueryDepthSList(&Lookaside->L.ListHead) >= Lookaside->L.Depth) {
3220         Lookaside->L.FreeMisses++;
3221         (Lookaside->L.Free)(Entry);
3222     } else {
3223         InterlockedPushEntrySList(&Lookaside->L.ListHead, (PSLIST_ENTRY)Entry);
3224     }
3225 }
3226
3227 static __inline VOID
3228 ExFreeToPagedLookasideList(
3229     IN PPAGED_LOOKASIDE_LIST Lookaside,
3230     IN PVOID  Entry)
3231 {
3232     Lookaside->L.TotalFrees++;
3233     if (ExQueryDepthSList(&Lookaside->L.ListHead) >= Lookaside->L.Depth) {
3234         Lookaside->L.FreeMisses++;
3235         (Lookaside->L.Free)(Entry);
3236     } else {
3237         InterlockedPushEntrySList(&Lookaside->L.ListHead, (PSLIST_ENTRY)Entry);
3238     }
3239 }
3240
3241
3242 #endif // !defined(MIDL_PASS)
3243
3244
3245 #ifdef __cplusplus
3246 }
3247 #endif
3248
3249 #endif // _WDMDDK_