reactos/include/xdk/exfuncs.h

   1 /******************************************************************************
   2  *                          Executive Functions                               *
   3  ******************************************************************************/
   4
   5 $if (_WDMDDK_)
   6 #define ExInterlockedIncrementLong(Addend,Lock) Exfi386InterlockedIncrementLong(Addend)
   7 #define ExInterlockedDecrementLong(Addend,Lock) Exfi386InterlockedDecrementLong(Addend)
   8 #define ExInterlockedExchangeUlong(Target, Value, Lock) Exfi386InterlockedExchangeUlong(Target, Value)
   9
  10 #define ExAcquireSpinLock(Lock, OldIrql) KeAcquireSpinLock((Lock), (OldIrql))
  11 #define ExReleaseSpinLock(Lock, OldIrql) KeReleaseSpinLock((Lock), (OldIrql))
  12 #define ExAcquireSpinLockAtDpcLevel(Lock) KeAcquireSpinLockAtDpcLevel(Lock)
  13 #define ExReleaseSpinLockFromDpcLevel(Lock) KeReleaseSpinLockFromDpcLevel(Lock)
  14
  15 #define ExInitializeSListHead InitializeSListHead
  16
  17 #if defined(_NTHAL_) && defined(_X86_)
  18
  19 NTKERNELAPI
  20 VOID
  21 FASTCALL
  22 ExiAcquireFastMutex(
  23   IN OUT PFAST_MUTEX FastMutex);
  24
  25 NTKERNELAPI
  26 VOID
  27 FASTCALL
  28 ExiReleaseFastMutex(
  29   IN OUT PFAST_MUTEX FastMutex);
  30
  31 NTKERNELAPI
  32 BOOLEAN
  33 FASTCALL
  34 ExiTryToAcquireFastMutex(
  35     IN OUT PFAST_MUTEX FastMutex);
  36
  37 #define ExAcquireFastMutex ExiAcquireFastMutex
  38 #define ExReleaseFastMutex ExiReleaseFastMutex
  39 #define ExTryToAcquireFastMutex ExiTryToAcquireFastMutex
  40
  41 #else
  42
  43 #if (NTDDI_VERSION >= NTDDI_WIN2K)
  44
  45 _IRQL_raises_(APC_LEVEL)
  46 _IRQL_saves_global_(OldIrql, FastMutex)
  47 NTKERNELAPI
  48 VOID
  49 FASTCALL
  50 ExAcquireFastMutex(
  51   _Inout_ _Requires_lock_not_held_(*_Curr_) _Acquires_lock_(*_Curr_)
  52     PFAST_MUTEX FastMutex);
  53
  54 _IRQL_requires_(APC_LEVEL)
  55 _IRQL_restores_global_(OldIrql, FastMutex)
  56 NTKERNELAPI
  57 VOID
  58 FASTCALL
  59 ExReleaseFastMutex(
  60   _Inout_ _Requires_lock_held_(*_Curr_) _Releases_lock_(*_Curr_)
  61     PFAST_MUTEX FastMutex);
  62
  63 _Must_inspect_result_
  64 _Success_(return!=FALSE)
  65 _IRQL_raises_(APC_LEVEL)
  66 _IRQL_saves_global_(OldIrql, FastMutex)
  67 NTKERNELAPI
  68 BOOLEAN
  69 FASTCALL
  70 ExTryToAcquireFastMutex(
  71   _Inout_ _Requires_lock_not_held_(*_Curr_) _Acquires_lock_(*_Curr_)
  72     PFAST_MUTEX FastMutex);
  73
  74 #endif /* (NTDDI_VERSION >= NTDDI_WIN2K) */
  75
  76 #endif /* defined(_NTHAL_) && defined(_X86_) */
  77
  78 #if defined(_X86_)
  79 #define ExInterlockedAddUlong ExfInterlockedAddUlong
  80 #define ExInterlockedInsertHeadList ExfInterlockedInsertHeadList
  81 #define ExInterlockedInsertTailList ExfInterlockedInsertTailList
  82 #define ExInterlockedRemoveHeadList ExfInterlockedRemoveHeadList
  83 #define ExInterlockedPopEntryList ExfInterlockedPopEntryList
  84 #define ExInterlockedPushEntryList ExfInterlockedPushEntryList
  85 #endif /* defined(_X86_) */
  86
  87 #if defined(_WIN64)
  88
  89 #if defined(_NTDRIVER_) || defined(_NTDDK_) || defined(_NTIFS_) || \
  90     defined(_NTHAL_) || defined(_NTOSP_)
  91 NTKERNELAPI
  92 USHORT
  93 ExQueryDepthSList(_In_ PSLIST_HEADER ListHead);
  94 #else
  95 FORCEINLINE
  96 USHORT
  97 ExQueryDepthSList(_In_ PSLIST_HEADER ListHead)
  98 {
  99   return (USHORT)(ListHead->Alignment & 0xffff);
 100 }
 101 #endif
 102
 103 NTKERNELAPI
 104 PSLIST_ENTRY
 105 ExpInterlockedFlushSList(
 106   PSLIST_HEADER ListHead);
 107
 108 NTKERNELAPI
 109 PSLIST_ENTRY
 110 ExpInterlockedPopEntrySList(
 111   _Inout_ PSLIST_HEADER ListHead);
 112
 113 NTKERNELAPI
 114 PSLIST_ENTRY
 115 ExpInterlockedPushEntrySList(
 116   _Inout_ PSLIST_HEADER ListHead,
 117   _Inout_ __drv_aliasesMem PSLIST_ENTRY ListEntry);
 118
 119 #define ExInterlockedFlushSList(Head) \
 120     ExpInterlockedFlushSList(Head)
 121 #define ExInterlockedPopEntrySList(Head, Lock) \
 122     ExpInterlockedPopEntrySList(Head)
 123 #define ExInterlockedPushEntrySList(Head, Entry, Lock) \
 124     ExpInterlockedPushEntrySList(Head, Entry)
 125
 126 #else /* !defined(_WIN64) */
 127
 128 #ifdef NONAMELESSUNION
 129 #define ExQueryDepthSList(listhead) (listhead)->s.Depth
 130 #else
 131 #define ExQueryDepthSList(listhead) (listhead)->Depth
 132 #endif
 133
 134 NTKERNELAPI
 135 PSINGLE_LIST_ENTRY
 136 FASTCALL
 137 ExInterlockedFlushSList(
 138   _Inout_ PSLIST_HEADER ListHead);
 139
 140 #endif /* !defined(_WIN64) */
 141
 142 #if defined(_WIN2K_COMPAT_SLIST_USAGE) && defined(_X86_)
 143
 144 NTKERNELAPI
 145 PSINGLE_LIST_ENTRY
 146 FASTCALL
 147 ExInterlockedPopEntrySList(
 148   _Inout_ PSLIST_HEADER ListHead,
 149   _Inout_ _Requires_lock_not_held_(*_Curr_) PKSPIN_LOCK Lock);
 150
 151 NTKERNELAPI
 152 PSINGLE_LIST_ENTRY
 153 FASTCALL
 154 ExInterlockedPushEntrySList(
 155   _Inout_ PSLIST_HEADER ListHead,
 156   _Inout_ __drv_aliasesMem PSINGLE_LIST_ENTRY ListEntry,
 157   _Inout_ _Requires_lock_not_held_(*_Curr_) PKSPIN_LOCK Lock);
 158
 159 _IRQL_requires_max_(APC_LEVEL)
 160 NTKERNELAPI
 161 PVOID
 162 NTAPI
 163 ExAllocateFromPagedLookasideList(
 164   _Inout_ PPAGED_LOOKASIDE_LIST Lookaside);
 165
 166 _IRQL_requires_max_(APC_LEVEL)
 167 NTKERNELAPI
 168 VOID
 169 NTAPI
 170 ExFreeToPagedLookasideList(
 171   _Inout_ PPAGED_LOOKASIDE_LIST Lookaside,
 172   _In_ PVOID Entry);
 173
 174 #else /* !_WIN2K_COMPAT_SLIST_USAGE */
 175
 176 #if !defined(_WIN64)
 177 #define ExInterlockedPopEntrySList(_ListHead, _Lock) \
 178     InterlockedPopEntrySList(_ListHead)
 179 #define ExInterlockedPushEntrySList(_ListHead, _ListEntry, _Lock) \
 180     InterlockedPushEntrySList(_ListHead, _ListEntry)
 181 #endif
 182
 183 _IRQL_requires_max_(APC_LEVEL)
 184 static __inline
 185 PVOID
 186 ExAllocateFromPagedLookasideList(
 187   _Inout_ PPAGED_LOOKASIDE_LIST Lookaside)
 188 {
 189   PVOID Entry;
 190
 191   Lookaside->L.TotalAllocates++;
 192 #ifdef NONAMELESSUNION
 193   Entry = InterlockedPopEntrySList(&Lookaside->L.u.ListHead);
 194   if (Entry == NULL) {
 195     Lookaside->L.u2.AllocateMisses++;
 196     Entry = (Lookaside->L.u4.Allocate)(Lookaside->L.Type,
 197                                        Lookaside->L.Size,
 198                                        Lookaside->L.Tag);
 199   }
 200 #else /* NONAMELESSUNION */
 201   Entry = InterlockedPopEntrySList(&Lookaside->L.ListHead);
 202   if (Entry == NULL) {
 203     Lookaside->L.AllocateMisses++;
 204     Entry = (Lookaside->L.Allocate)(Lookaside->L.Type,
 205                                     Lookaside->L.Size,
 206                                     Lookaside->L.Tag);
 207   }
 208 #endif /* NONAMELESSUNION */
 209   return Entry;
 210 }
 211
 212 _IRQL_requires_max_(APC_LEVEL)
 213 static __inline
 214 VOID
 215 ExFreeToPagedLookasideList(
 216   _Inout_ PPAGED_LOOKASIDE_LIST Lookaside,
 217   _In_ PVOID Entry)
 218 {
 219   Lookaside->L.TotalFrees++;
 220 #ifdef NONAMELESSUNION
 221   if (ExQueryDepthSList(&Lookaside->L.u.ListHead) >= Lookaside->L.Depth) {
 222     Lookaside->L.u3.FreeMisses++;
 223     (Lookaside->L.u5.Free)(Entry);
 224   } else {
 225     InterlockedPushEntrySList(&Lookaside->L.u.ListHead, (PSLIST_ENTRY)Entry);
 226   }
 227 #else /* NONAMELESSUNION */
 228   if (ExQueryDepthSList(&Lookaside->L.ListHead) >= Lookaside->L.Depth) {
 229     Lookaside->L.FreeMisses++;
 230     (Lookaside->L.Free)(Entry);
 231   } else {
 232     InterlockedPushEntrySList(&Lookaside->L.ListHead, (PSLIST_ENTRY)Entry);
 233   }
 234 #endif /* NONAMELESSUNION */
 235 }
 236
 237 #endif /* _WIN2K_COMPAT_SLIST_USAGE */
 238
 239
 240 /* ERESOURCE_THREAD
 241  * ExGetCurrentResourceThread(
 242  *     VOID);
 243  */
 244 #define ExGetCurrentResourceThread() ((ULONG_PTR)PsGetCurrentThread())
 245
 246 #define ExReleaseResource(R) (ExReleaseResourceLite(R))
 247
 248 /* VOID
 249  * ExInitializeWorkItem(
 250  *     IN PWORK_QUEUE_ITEM Item,
 251  *     IN PWORKER_THREAD_ROUTINE Routine,
 252  *     IN PVOID Context)
 253  */
 254 #define ExInitializeWorkItem(Item, Routine, Context) \
 255 { \
 256   (Item)->WorkerRoutine = Routine; \
 257   (Item)->Parameter = Context; \
 258   (Item)->List.Flink = NULL; \
 259 }
 260
 261 FORCEINLINE
 262 VOID
 263 ExInitializeFastMutex(
 264   _Out_ PFAST_MUTEX FastMutex)
 265 {
 266   FastMutex->Count = FM_LOCK_BIT;
 267   FastMutex->Owner = NULL;
 268   FastMutex->Contention = 0;
 269   KeInitializeEvent(&FastMutex->Event, SynchronizationEvent, FALSE);
 270   return;
 271 }
 272
 273 $endif (_WDMDDK_)
 274 $if (_NTDDK_)
 275 static __inline PVOID
 276 ExAllocateFromZone(
 277   IN PZONE_HEADER Zone)
 278 {
 279   if (Zone->FreeList.Next)
 280     Zone->FreeList.Next = Zone->FreeList.Next->Next;
 281   return (PVOID) Zone->FreeList.Next;
 282 }
 283
 284 static __inline PVOID
 285 ExFreeToZone(
 286   IN PZONE_HEADER Zone,
 287   IN PVOID Block)
 288 {
 289   ((PSINGLE_LIST_ENTRY) Block)->Next = Zone->FreeList.Next;
 290   Zone->FreeList.Next = ((PSINGLE_LIST_ENTRY) Block);
 291   return ((PSINGLE_LIST_ENTRY) Block)->Next;
 292 }
 293
 294 /*
 295  * PVOID
 296  * ExInterlockedAllocateFromZone(
 297  *   IN PZONE_HEADER  Zone,
 298  *   IN PKSPIN_LOCK  Lock)
 299  */
 300 #define ExInterlockedAllocateFromZone(Zone, Lock) \
 301     ((PVOID) ExInterlockedPopEntryList(&Zone->FreeList, Lock))
 302
 303 /* PVOID
 304  * ExInterlockedFreeToZone(
 305  *  IN PZONE_HEADER  Zone,
 306  *  IN PVOID  Block,
 307  *  IN PKSPIN_LOCK  Lock);
 308  */
 309 #define ExInterlockedFreeToZone(Zone, Block, Lock) \
 310     ExInterlockedPushEntryList(&(Zone)->FreeList, (PSINGLE_LIST_ENTRY)(Block), Lock)
 311
 312 /*
 313  * BOOLEAN
 314  * ExIsFullZone(
 315  *  IN PZONE_HEADER  Zone)
 316  */
 317 #define ExIsFullZone(Zone) \
 318   ((Zone)->FreeList.Next == (PSINGLE_LIST_ENTRY) NULL)
 319
 320 /* BOOLEAN
 321  * ExIsObjectInFirstZoneSegment(
 322  *     IN PZONE_HEADER Zone,
 323  *     IN PVOID Object);
 324  */
 325 #define ExIsObjectInFirstZoneSegment(Zone,Object) \
 326     ((BOOLEAN)( ((PUCHAR)(Object) >= (PUCHAR)(Zone)->SegmentList.Next) && \
 327                 ((PUCHAR)(Object) <  (PUCHAR)(Zone)->SegmentList.Next + \
 328                          (Zone)->TotalSegmentSize)) )
 329
 330 #define ExAcquireResourceExclusive ExAcquireResourceExclusiveLite
 331 #define ExAcquireResourceShared ExAcquireResourceSharedLite
 332 #define ExConvertExclusiveToShared ExConvertExclusiveToSharedLite
 333 #define ExDeleteResource ExDeleteResourceLite
 334 #define ExInitializeResource ExInitializeResourceLite
 335 #define ExIsResourceAcquiredExclusive ExIsResourceAcquiredExclusiveLite
 336 #define ExIsResourceAcquiredShared ExIsResourceAcquiredSharedLite
 337 #define ExIsResourceAcquired ExIsResourceAcquiredSharedLite
 338 #define ExReleaseResourceForThread ExReleaseResourceForThreadLite
 339
 340 #ifndef _M_IX86
 341 #define RESULT_ZERO     0
 342 #define RESULT_NEGATIVE 1
 343 #define RESULT_POSITIVE 2
 344 #endif
 345
 346 typedef enum _INTERLOCKED_RESULT {
 347   ResultNegative = RESULT_NEGATIVE,
 348   ResultZero = RESULT_ZERO,
 349   ResultPositive = RESULT_POSITIVE
 350 } INTERLOCKED_RESULT;
 351
 352 #ifdef _X86_
 353
 354 NTKERNELAPI
 355 INTERLOCKED_RESULT
 356 FASTCALL
 357 Exfi386InterlockedIncrementLong(
 358   _Inout_ _Interlocked_operand_ LONG volatile *Addend);
 359
 360 NTKERNELAPI
 361 INTERLOCKED_RESULT
 362 FASTCALL
 363 Exfi386InterlockedDecrementLong(
 364   _Inout_ _Interlocked_operand_ PLONG Addend);
 365
 366 NTKERNELAPI
 367 ULONG
 368 FASTCALL
 369 Exfi386InterlockedExchangeUlong(
 370   _Inout_ _Interlocked_operand_ PULONG Target,
 371   _In_ ULONG Value);
 372
 373 #endif
 374
 375 $endif (_NTDDK_)
 376 $if (_NTIFS_)
 377
 378 #define ExDisableResourceBoost ExDisableResourceBoostLite
 379
 380 VOID
 381 ExInitializePushLock(
 382   _Out_ PEX_PUSH_LOCK PushLock);
 383 $endif (_NTIFS_)
 384
 385 #if (NTDDI_VERSION >= NTDDI_WIN2K)
 386 $if (_WDMDDK_)
 387 _IRQL_requires_max_(APC_LEVEL)
 388 _Requires_lock_held_(_Global_critical_region_)
 389 NTKERNELAPI
 390 VOID
 391 FASTCALL
 392 ExAcquireFastMutexUnsafe(
 393   _Inout_ _Requires_lock_not_held_(*_Curr_) _Acquires_lock_(*_Curr_)
 394     PFAST_MUTEX FastMutex);
 395
 396 _IRQL_requires_max_(APC_LEVEL)
 397 _Requires_lock_held_(_Global_critical_region_)
 398 NTKERNELAPI
 399 VOID
 400 FASTCALL
 401 ExReleaseFastMutexUnsafe(
 402   _Inout_ _Requires_lock_held_(*_Curr_) _Releases_lock_(*_Curr_)
 403     PFAST_MUTEX FastMutex);
 404
 405 _Requires_lock_held_(_Global_critical_region_)
 406 _Requires_lock_not_held_(*Resource)
 407 _When_(Wait!=0, _Acquires_exclusive_lock_(*Resource))
 408 _IRQL_requires_max_(APC_LEVEL)
 409 _When_(Wait!=0, _Post_satisfies_(return == 1))
 410 _When_(Wait==0, _Post_satisfies_(return == 0 || return == 1) _Must_inspect_result_)
 411 NTKERNELAPI
 412 BOOLEAN
 413 NTAPI
 414 ExAcquireResourceExclusiveLite(
 415   _Inout_ PERESOURCE Resource,
 416   _In_ _Literal_ BOOLEAN Wait);
 417
 418 _IRQL_requires_max_(APC_LEVEL)
 419 _Requires_lock_held_(_Global_critical_region_)
 420 _When_(Wait!=0, _Post_satisfies_(return == 1))
 421 _When_(Wait==0, _Post_satisfies_(return == 0 || return == 1) _Must_inspect_result_)
 422 NTKERNELAPI
 423 BOOLEAN
 424 NTAPI
 425 ExAcquireResourceSharedLite(
 426   _Inout_ _Requires_lock_not_held_(*_Curr_)
 427   _When_(return!=0, _Acquires_shared_lock_(*_Curr_))
 428     PERESOURCE Resource,
 429   _In_ BOOLEAN Wait);
 430
 431 _IRQL_requires_max_(APC_LEVEL)
 432 _Requires_lock_held_(_Global_critical_region_)
 433 _When_(Wait!=0, _Post_satisfies_(return == 1))
 434 _When_(Wait==0, _Post_satisfies_(return == 0 || return == 1) _Must_inspect_result_)
 435 NTKERNELAPI
 436 BOOLEAN
 437 NTAPI
 438 ExAcquireSharedStarveExclusive(
 439   _Inout_ _Requires_lock_not_held_(*_Curr_)
 440   _When_(return!=0, _Acquires_shared_lock_(*_Curr_))
 441     PERESOURCE Resource,
 442   _In_ BOOLEAN Wait);
 443
 444 _IRQL_requires_max_(APC_LEVEL)
 445 _Requires_lock_held_(_Global_critical_region_)
 446 _When_(Wait!=0, _Post_satisfies_(return == 1))
 447 _When_(Wait==0, _Post_satisfies_(return == 0 || return == 1) _Must_inspect_result_)
 448 NTKERNELAPI
 449 BOOLEAN
 450 NTAPI
 451 ExAcquireSharedWaitForExclusive(
 452   _Inout_ _Requires_lock_not_held_(*_Curr_)
 453   _When_(return!=0, _Acquires_lock_(*_Curr_))
 454     PERESOURCE Resource,
 455   _In_ BOOLEAN Wait);
 456
 457 __drv_preferredFunction("ExAllocatePoolWithTag",
 458                         "No tag interferes with debugging.")
 459 __drv_allocatesMem(Mem)
 460 _When_((PoolType & PagedPool) != 0, _IRQL_requires_max_(APC_LEVEL))
 461 _When_((PoolType & PagedPool) == 0, _IRQL_requires_max_(DISPATCH_LEVEL))
 462 _When_((PoolType & NonPagedPoolMustSucceed) != 0,
 463   __drv_reportError("Must succeed pool allocations are forbidden. "
 464                     "Allocation failures cause a system crash"))
 465 _When_((PoolType & (NonPagedPoolMustSucceed |
 466                     POOL_RAISE_IF_ALLOCATION_FAILURE)) == 0,
 467   _Post_maybenull_ _Must_inspect_result_)
 468 _When_((PoolType & (NonPagedPoolMustSucceed |
 469                     POOL_RAISE_IF_ALLOCATION_FAILURE)) != 0,
 470   _Post_notnull_)
 471 _Post_writable_byte_size_(NumberOfBytes)
 472 NTKERNELAPI
 473 PVOID
 474 NTAPI
 475 ExAllocatePool(
 476   __drv_strictTypeMatch(__drv_typeExpr) _In_ POOL_TYPE PoolType,
 477   _In_ SIZE_T NumberOfBytes);
 478
 479 __drv_preferredFunction("ExAllocatePoolWithQuotaTag",
 480                         "No tag interferes with debugging.")
 481 __drv_allocatesMem(Mem)
 482 _When_((PoolType & PagedPool) != 0, _IRQL_requires_max_(APC_LEVEL))
 483 _When_((PoolType & PagedPool) == 0, _IRQL_requires_max_(DISPATCH_LEVEL))
 484 _When_((PoolType & NonPagedPoolMustSucceed) != 0,
 485   __drv_reportError("Must succeed pool allocations are forbidden. "
 486                     "Allocation failures cause a system crash"))
 487 _When_((PoolType & POOL_QUOTA_FAIL_INSTEAD_OF_RAISE) != 0,
 488   _Post_maybenull_ _Must_inspect_result_)
 489 _When_((PoolType & POOL_QUOTA_FAIL_INSTEAD_OF_RAISE) == 0, _Post_notnull_)
 490 _Post_writable_byte_size_(NumberOfBytes)
 491 NTKERNELAPI
 492 PVOID
 493 NTAPI
 494 ExAllocatePoolWithQuota(
 495   __drv_strictTypeMatch(__drv_typeExpr) _In_ POOL_TYPE PoolType,
 496   _In_ SIZE_T NumberOfBytes);
 497
 498 __drv_allocatesMem(Mem)
 499 _When_((PoolType & PagedPool) != 0, _IRQL_requires_max_(APC_LEVEL))
 500 _When_((PoolType & PagedPool) == 0, _IRQL_requires_max_(DISPATCH_LEVEL))
 501 _When_((PoolType & NonPagedPoolMustSucceed) != 0,
 502   __drv_reportError("Must succeed pool allocations are forbidden. "
 503                     "Allocation failures cause a system crash"))
 504 _When_((PoolType & POOL_QUOTA_FAIL_INSTEAD_OF_RAISE) != 0,
 505   _Post_maybenull_ _Must_inspect_result_)
 506 _When_((PoolType & POOL_QUOTA_FAIL_INSTEAD_OF_RAISE) == 0, _Post_notnull_)
 507 _Post_writable_byte_size_(NumberOfBytes)
 508 NTKERNELAPI
 509 PVOID
 510 NTAPI
 511 ExAllocatePoolWithQuotaTag(
 512   _In_ __drv_strictTypeMatch(__drv_typeExpr) POOL_TYPE PoolType,
 513   _In_ SIZE_T NumberOfBytes,
 514   _In_ ULONG Tag);
 515
 516 #ifndef POOL_TAGGING
 517 #define ExAllocatePoolWithQuotaTag(a,b,c) ExAllocatePoolWithQuota(a,b)
 518 #endif
 519
 520 __drv_allocatesMem(Mem)
 521 _When_((PoolType & PagedPool) != 0, _IRQL_requires_max_(APC_LEVEL))
 522 _When_((PoolType & PagedPool) == 0, _IRQL_requires_max_(DISPATCH_LEVEL))
 523 _When_((PoolType & NonPagedPoolMustSucceed) != 0,
 524   __drv_reportError("Must succeed pool allocations are forbidden. "
 525                     "Allocation failures cause a system crash"))
 526 _When_((PoolType & (NonPagedPoolMustSucceed | POOL_RAISE_IF_ALLOCATION_FAILURE)) == 0,
 527   _Post_maybenull_ _Must_inspect_result_)
 528 _When_((PoolType & (NonPagedPoolMustSucceed | POOL_RAISE_IF_ALLOCATION_FAILURE)) != 0,
 529   _Post_notnull_)
 530 _Post_writable_byte_size_(NumberOfBytes)
 531 NTKERNELAPI
 532 PVOID
 533 NTAPI
 534 ExAllocatePoolWithTag(
 535   _In_ __drv_strictTypeMatch(__drv_typeExpr) POOL_TYPE PoolType,
 536   _In_ SIZE_T NumberOfBytes,
 537   _In_ ULONG Tag);
 538
 539 #ifndef POOL_TAGGING
 540 #define ExAllocatePoolWithTag(a,b,c) ExAllocatePool(a,b)
 541 #endif
 542
 543 __drv_allocatesMem(Mem)
 544 _When_((PoolType & PagedPool) != 0, _IRQL_requires_max_(APC_LEVEL))
 545 _When_((PoolType & PagedPool) == 0, _IRQL_requires_max_(DISPATCH_LEVEL))
 546 _When_((PoolType & NonPagedPoolMustSucceed) != 0,
 547   __drv_reportError("Must succeed pool allocations are forbidden. "
 548                     "Allocation failures cause a system crash"))
 549 _When_((PoolType & (NonPagedPoolMustSucceed | POOL_RAISE_IF_ALLOCATION_FAILURE)) == 0,
 550   _Post_maybenull_ _Must_inspect_result_)
 551 _When_((PoolType & (NonPagedPoolMustSucceed | POOL_RAISE_IF_ALLOCATION_FAILURE)) != 0,
 552   _Post_notnull_)
 553 _Post_writable_byte_size_(NumberOfBytes)
 554 NTKERNELAPI
 555 PVOID
 556 NTAPI
 557 ExAllocatePoolWithTagPriority(
 558   _In_ __drv_strictTypeMatch(__drv_typeCond) POOL_TYPE PoolType,
 559   _In_ SIZE_T NumberOfBytes,
 560   _In_ ULONG Tag,
 561   _In_ __drv_strictTypeMatch(__drv_typeExpr) EX_POOL_PRIORITY Priority);
 562
 563 _IRQL_requires_max_(DISPATCH_LEVEL)
 564 NTKERNELAPI
 565 VOID
 566 NTAPI
 567 ExConvertExclusiveToSharedLite(
 568   _Inout_ _Requires_lock_held_(*_Curr_) PERESOURCE Resource);
 569
 570 _IRQL_requires_max_(APC_LEVEL)
 571 NTKERNELAPI
 572 NTSTATUS
 573 NTAPI
 574 ExCreateCallback(
 575   _Outptr_ PCALLBACK_OBJECT *CallbackObject,
 576   _In_ POBJECT_ATTRIBUTES ObjectAttributes,
 577   _In_ BOOLEAN Create,
 578   _In_ BOOLEAN AllowMultipleCallbacks);
 579
 580 NTKERNELAPI
 581 VOID
 582 NTAPI
 583 ExDeleteNPagedLookasideList(
 584   _Inout_ PNPAGED_LOOKASIDE_LIST Lookaside);
 585
 586 _IRQL_requires_max_(APC_LEVEL)
 587 NTKERNELAPI
 588 VOID
 589 NTAPI
 590 ExDeletePagedLookasideList(
 591   _Inout_ PPAGED_LOOKASIDE_LIST Lookaside);
 592
 593 _IRQL_requires_max_(DISPATCH_LEVEL)
 594 NTKERNELAPI
 595 NTSTATUS
 596 NTAPI
 597 ExDeleteResourceLite(
 598   _Inout_ PERESOURCE Resource);
 599
 600 _IRQL_requires_max_(DISPATCH_LEVEL)
 601 NTKERNELAPI
 602 VOID
 603 NTAPI
 604 ExFreePool(
 605   _In_ __drv_freesMem(Mem) PVOID P);
 606
 607 _IRQL_requires_max_(DISPATCH_LEVEL)
 608 NTKERNELAPI
 609 VOID
 610 NTAPI
 611 ExFreePoolWithTag(
 612   _In_ __drv_freesMem(Mem) PVOID P,
 613   _In_ ULONG Tag);
 614
 615 _IRQL_requires_max_(DISPATCH_LEVEL)
 616 NTKERNELAPI
 617 ULONG
 618 NTAPI
 619 ExGetExclusiveWaiterCount(
 620   _In_ PERESOURCE Resource);
 621
 622 _IRQL_requires_max_(DISPATCH_LEVEL)
 623 NTKERNELAPI
 624 KPROCESSOR_MODE
 625 NTAPI
 626 ExGetPreviousMode(VOID);
 627
 628 _IRQL_requires_max_(DISPATCH_LEVEL)
 629 NTKERNELAPI
 630 ULONG
 631 NTAPI
 632 ExGetSharedWaiterCount(
 633   _In_ PERESOURCE Resource);
 634
 635 _IRQL_requires_max_(DISPATCH_LEVEL)
 636 NTKERNELAPI
 637 VOID
 638 NTAPI
 639 ExInitializeNPagedLookasideList(
 640   _Out_ PNPAGED_LOOKASIDE_LIST Lookaside,
 641   _In_opt_ PALLOCATE_FUNCTION Allocate,
 642   _In_opt_ PFREE_FUNCTION Free,
 643   _In_ ULONG Flags,
 644   _In_ SIZE_T Size,
 645   _In_ ULONG Tag,
 646   _In_ USHORT Depth);
 647
 648 _IRQL_requires_max_(APC_LEVEL)
 649 NTKERNELAPI
 650 VOID
 651 NTAPI
 652 ExInitializePagedLookasideList(
 653   _Out_ PPAGED_LOOKASIDE_LIST Lookaside,
 654   _In_opt_ PALLOCATE_FUNCTION Allocate,
 655   _In_opt_ PFREE_FUNCTION Free,
 656   _In_ ULONG Flags,
 657   _In_ SIZE_T Size,
 658   _In_ ULONG Tag,
 659   _In_ USHORT Depth);
 660
 661 _IRQL_requires_max_(DISPATCH_LEVEL)
 662 NTKERNELAPI
 663 NTSTATUS
 664 NTAPI
 665 ExInitializeResourceLite(
 666   _Out_ PERESOURCE Resource);
 667
 668 NTKERNELAPI
 669 LARGE_INTEGER
 670 NTAPI
 671 ExInterlockedAddLargeInteger(
 672   _Inout_ PLARGE_INTEGER Addend,
 673   _In_ LARGE_INTEGER Increment,
 674   _Inout_ _Requires_lock_not_held_(*_Curr_) PKSPIN_LOCK Lock);
 675
 676 #if defined(_WIN64)
 677 #define ExInterlockedAddLargeStatistic(Addend, Increment) \
 678     (VOID)InterlockedAdd64(&(Addend)->QuadPart, Increment)
 679 #else
 680 #define ExInterlockedAddLargeStatistic(Addend, Increment) \
 681     _InterlockedAddLargeStatistic((PLONGLONG)&(Addend)->QuadPart, Increment)
 682 #endif
 683
 684 NTKERNELAPI
 685 ULONG
 686 FASTCALL
 687 ExInterlockedAddUlong(
 688   _Inout_ PULONG Addend,
 689   _In_ ULONG Increment,
 690   _Inout_ _Requires_lock_not_held_(*_Curr_) PKSPIN_LOCK Lock);
 691
 692 #if defined(_AMD64_) || defined(_IA64_)
 693
 694 #define ExInterlockedCompareExchange64(Destination, Exchange, Comperand, Lock) \
 695     InterlockedCompareExchange64(Destination, *(Exchange), *(Comperand))
 696
 697 #elif defined(_X86_)
 698
 699 NTKERNELAPI
 700 LONGLONG
 701 FASTCALL
 702 ExfInterlockedCompareExchange64(
 703   _Inout_ _Interlocked_operand_ LONGLONG volatile *Destination,
 704   _In_ PLONGLONG Exchange,
 705   _In_ PLONGLONG Comperand);
 706
 707 #define ExInterlockedCompareExchange64(Destination, Exchange, Comperand, Lock) \
 708     ExfInterlockedCompareExchange64(Destination, Exchange, Comperand)
 709
 710 #else
 711
 712 NTKERNELAPI
 713 LONGLONG
 714 FASTCALL
 715 ExInterlockedCompareExchange64(
 716   IN OUT LONGLONG volatile *Destination,
 717   IN PLONGLONG Exchange,
 718   IN PLONGLONG Comparand,
 719   IN PKSPIN_LOCK Lock);
 720
 721 #endif /* defined(_AMD64_) || defined(_IA64_) */
 722
 723 NTKERNELAPI
 724 PLIST_ENTRY
 725 FASTCALL
 726 ExInterlockedInsertHeadList(
 727   _Inout_ PLIST_ENTRY ListHead,
 728   _Inout_ __drv_aliasesMem PLIST_ENTRY ListEntry,
 729   _Inout_ _Requires_lock_not_held_(*_Curr_) PKSPIN_LOCK Lock);
 730
 731 NTKERNELAPI
 732 PLIST_ENTRY
 733 FASTCALL
 734 ExInterlockedInsertTailList(
 735   _Inout_ PLIST_ENTRY ListHead,
 736   _Inout_ __drv_aliasesMem PLIST_ENTRY ListEntry,
 737   _Inout_ _Requires_lock_not_held_(*_Curr_) PKSPIN_LOCK Lock);
 738
 739 NTKERNELAPI
 740 PSINGLE_LIST_ENTRY
 741 FASTCALL
 742 ExInterlockedPopEntryList(
 743   _Inout_ PSINGLE_LIST_ENTRY ListHead,
 744   _Inout_ _Requires_lock_not_held_(*_Curr_) PKSPIN_LOCK Lock);
 745
 746 NTKERNELAPI
 747 PSINGLE_LIST_ENTRY
 748 FASTCALL
 749 ExInterlockedPushEntryList(
 750   _Inout_ PSINGLE_LIST_ENTRY ListHead,
 751   _Inout_ __drv_aliasesMem PSINGLE_LIST_ENTRY ListEntry,
 752   _Inout_ _Requires_lock_not_held_(*_Curr_) PKSPIN_LOCK Lock);
 753
 754 NTKERNELAPI
 755 PLIST_ENTRY
 756 FASTCALL
 757 ExInterlockedRemoveHeadList(
 758   _Inout_ PLIST_ENTRY ListHead,
 759   _Inout_ _Requires_lock_not_held_(*_Curr_) PKSPIN_LOCK Lock);
 760
 761 _IRQL_requires_max_(PASSIVE_LEVEL)
 762 NTKERNELAPI
 763 BOOLEAN
 764 NTAPI
 765 ExIsProcessorFeaturePresent(
 766   _In_ ULONG ProcessorFeature);
 767
 768 _IRQL_requires_max_(DISPATCH_LEVEL)
 769 NTKERNELAPI
 770 BOOLEAN
 771 NTAPI
 772 ExIsResourceAcquiredExclusiveLite(
 773   _In_ PERESOURCE Resource);
 774
 775 _IRQL_requires_max_(DISPATCH_LEVEL)
 776 NTKERNELAPI
 777 ULONG
 778 NTAPI
 779 ExIsResourceAcquiredSharedLite(
 780   _In_ PERESOURCE Resource);
 781
 782 #define ExIsResourceAcquiredLite ExIsResourceAcquiredSharedLite
 783
 784 NTKERNELAPI
 785 VOID
 786 NTAPI
 787 ExLocalTimeToSystemTime(
 788   _In_ PLARGE_INTEGER LocalTime,
 789   _Out_ PLARGE_INTEGER SystemTime);
 790
 791 _IRQL_requires_max_(DISPATCH_LEVEL)
 792 NTKERNELAPI
 793 VOID
 794 NTAPI
 795 ExNotifyCallback(
 796   _In_ PCALLBACK_OBJECT CallbackObject,
 797   _In_opt_ PVOID Argument1,
 798   _In_opt_ PVOID Argument2);
 799
 800 _IRQL_requires_max_(DISPATCH_LEVEL)
 801 NTKERNELAPI
 802 VOID
 803 NTAPI
 804 ExQueueWorkItem(
 805   _Inout_ __drv_aliasesMem PWORK_QUEUE_ITEM WorkItem,
 806   __drv_strictTypeMatch(__drv_typeExpr) _In_ WORK_QUEUE_TYPE QueueType);
 807
 808 _IRQL_requires_max_(APC_LEVEL)
 809 NTKERNELAPI
 810 DECLSPEC_NORETURN
 811 VOID
 812 NTAPI
 813 ExRaiseStatus(
 814   _In_ NTSTATUS Status);
 815
 816 _IRQL_requires_max_(APC_LEVEL)
 817 NTKERNELAPI
 818 PVOID
 819 NTAPI
 820 ExRegisterCallback(
 821   _Inout_ PCALLBACK_OBJECT CallbackObject,
 822   _In_ PCALLBACK_FUNCTION CallbackFunction,
 823   _In_opt_ PVOID CallbackContext);
 824
 825 _IRQL_requires_max_(DISPATCH_LEVEL)
 826 NTKERNELAPI
 827 NTSTATUS
 828 NTAPI
 829 ExReinitializeResourceLite(
 830   _Inout_ PERESOURCE Resource);
 831
 832 _IRQL_requires_max_(DISPATCH_LEVEL)
 833 _Requires_lock_held_(_Global_critical_region_)
 834 NTKERNELAPI
 835 VOID
 836 NTAPI
 837 ExReleaseResourceForThreadLite(
 838   _Inout_ _Requires_lock_held_(*_Curr_) _Releases_lock_(*_Curr_)
 839     PERESOURCE Resource,
 840   _In_ ERESOURCE_THREAD ResourceThreadId);
 841
 842 _Requires_lock_held_(_Global_critical_region_)
 843 _Requires_lock_held_(*Resource)
 844 _Releases_lock_(*Resource)
 845 _IRQL_requires_max_(DISPATCH_LEVEL)
 846 NTKERNELAPI
 847 VOID
 848 FASTCALL
 849 ExReleaseResourceLite(
 850   _Inout_ PERESOURCE Resource);
 851
 852 _IRQL_requires_max_(DISPATCH_LEVEL)
 853 NTKERNELAPI
 854 VOID
 855 NTAPI
 856 ExSetResourceOwnerPointer(
 857   _Inout_ PERESOURCE Resource,
 858   _In_ PVOID OwnerPointer);
 859
 860 _IRQL_requires_max_(APC_LEVEL)
 861 NTKERNELAPI
 862 ULONG
 863 NTAPI
 864 ExSetTimerResolution(
 865   _In_ ULONG DesiredTime,
 866   _In_ BOOLEAN SetResolution);
 867
 868 NTKERNELAPI
 869 VOID
 870 NTAPI
 871 ExSystemTimeToLocalTime(
 872   _In_ PLARGE_INTEGER SystemTime,
 873   _Out_ PLARGE_INTEGER LocalTime);
 874
 875 _IRQL_requires_max_(APC_LEVEL)
 876 NTKERNELAPI
 877 VOID
 878 NTAPI
 879 ExUnregisterCallback(
 880   _Inout_ PVOID CbRegistration);
 881
 882 $endif (_WDMDDK_)
 883 $if (_NTDDK_)
 884 NTKERNELAPI
 885 NTSTATUS
 886 NTAPI
 887 ExExtendZone(
 888   _Inout_ PZONE_HEADER Zone,
 889   _Inout_ PVOID Segment,
 890   _In_ ULONG SegmentSize);
 891
 892 NTKERNELAPI
 893 NTSTATUS
 894 NTAPI
 895 ExInitializeZone(
 896   _Out_ PZONE_HEADER Zone,
 897   _In_ ULONG BlockSize,
 898   _Inout_ PVOID InitialSegment,
 899   _In_ ULONG InitialSegmentSize);
 900
 901 _IRQL_requires_max_(DISPATCH_LEVEL)
 902 NTKERNELAPI
 903 NTSTATUS
 904 NTAPI
 905 ExInterlockedExtendZone(
 906   _Inout_ PZONE_HEADER Zone,
 907   _Inout_ PVOID Segment,
 908   _In_ ULONG SegmentSize,
 909   _Inout_ _Requires_lock_not_held_(*_Curr_) PKSPIN_LOCK Lock);
 910
 911 _IRQL_requires_max_(PASSIVE_LEVEL)
 912 NTKERNELAPI
 913 NTSTATUS
 914 NTAPI
 915 ExUuidCreate(
 916   _Out_ UUID *Uuid);
 917
 918 _IRQL_requires_max_(PASSIVE_LEVEL)
 919 NTKERNELAPI
 920 DECLSPEC_NORETURN
 921 VOID
 922 NTAPI
 923 ExRaiseAccessViolation(VOID);
 924
 925 _IRQL_requires_max_(PASSIVE_LEVEL)
 926 NTKERNELAPI
 927 DECLSPEC_NORETURN
 928 VOID
 929 NTAPI
 930 ExRaiseDatatypeMisalignment(VOID);
 931
 932 $endif (_NTDDK_)
 933 $if (_NTIFS_)
 934
 935 _IRQL_requires_max_(DISPATCH_LEVEL)
 936 NTKERNELAPI
 937 SIZE_T
 938 NTAPI
 939 ExQueryPoolBlockSize(
 940   _In_ PVOID PoolBlock,
 941   _Out_ PBOOLEAN QuotaCharged);
 942
 943 _IRQL_requires_max_(DISPATCH_LEVEL)
 944 VOID
 945 ExAdjustLookasideDepth(VOID);
 946
 947 _IRQL_requires_max_(DISPATCH_LEVEL)
 948 NTKERNELAPI
 949 VOID
 950 NTAPI
 951 ExDisableResourceBoostLite(
 952   _In_ PERESOURCE Resource);
 953 $endif (_NTIFS_)
 954 #endif /* (NTDDI_VERSION >= NTDDI_WIN2K) */
 955
 956 $if (_WDMDDK_ || _NTIFS_)
 957 #if (NTDDI_VERSION >= NTDDI_WINXP)
 958 $endif (_WDMDDK_ || _NTIFS_)
 959 $if (_WDMDDK_)
 960
 961 _Must_inspect_result_
 962 _Post_satisfies_(return == 0 || return == 1)
 963 NTKERNELAPI
 964 BOOLEAN
 965 FASTCALL
 966 ExAcquireRundownProtection(
 967   _Inout_ PEX_RUNDOWN_REF RunRef);
 968
 969 NTKERNELAPI
 970 VOID
 971 FASTCALL
 972 ExInitializeRundownProtection(
 973   _Out_ PEX_RUNDOWN_REF RunRef);
 974
 975 NTKERNELAPI
 976 VOID
 977 FASTCALL
 978 ExReInitializeRundownProtection(
 979   _Inout_ PEX_RUNDOWN_REF RunRef);
 980
 981 NTKERNELAPI
 982 VOID
 983 FASTCALL
 984 ExReleaseRundownProtection(
 985   _Inout_ PEX_RUNDOWN_REF RunRef);
 986
 987 NTKERNELAPI
 988 VOID
 989 FASTCALL
 990 ExRundownCompleted(
 991   _Out_ PEX_RUNDOWN_REF RunRef);
 992
 993 NTKERNELAPI
 994 BOOLEAN
 995 NTAPI
 996 ExVerifySuite(
 997   __drv_strictTypeMatch(__drv_typeExpr) _In_ SUITE_TYPE SuiteType);
 998
 999 NTKERNELAPI
1000 VOID
1001 FASTCALL
1002 ExWaitForRundownProtectionRelease(
1003   _Inout_ PEX_RUNDOWN_REF RunRef);
1004 $endif (_WDMDDK_)
1005 $if (_NTIFS_)
1006
1007 PSLIST_ENTRY
1008 FASTCALL
1009 InterlockedPushListSList(
1010   _Inout_ PSLIST_HEADER ListHead,
1011   _Inout_ __drv_aliasesMem PSLIST_ENTRY List,
1012   _Inout_ PSLIST_ENTRY ListEnd,
1013   _In_ ULONG Count);
1014 $endif (_NTIFS_)
1015 $if (_WDMDDK_ || _NTIFS_)
1016 #endif /* (NTDDI_VERSION >= NTDDI_WINXP) */
1017 $endif (_WDMDDK_ || _NTIFS_)
1018
1019 $if (_WDMDDK_)
1020 #if (NTDDI_VERSION >= NTDDI_WINXPSP2)
1021
1022 _Must_inspect_result_
1023 _Post_satisfies_(return == 0 || return == 1)
1024 NTKERNELAPI
1025 BOOLEAN
1026 FASTCALL
1027 ExAcquireRundownProtectionEx(
1028   _Inout_ PEX_RUNDOWN_REF RunRef,
1029   _In_ ULONG Count);
1030
1031 NTKERNELAPI
1032 VOID
1033 FASTCALL
1034 ExReleaseRundownProtectionEx(
1035   _Inout_ PEX_RUNDOWN_REF RunRef,
1036   _In_ ULONG Count);
1037
1038 #endif /* (NTDDI_VERSION >= NTDDI_WINXPSP2) */
1039
1040 #if (NTDDI_VERSION >= NTDDI_WS03SP1)
1041
1042 _Must_inspect_result_
1043 _IRQL_requires_max_(APC_LEVEL)
1044 NTKERNELAPI
1045 PEX_RUNDOWN_REF_CACHE_AWARE
1046 NTAPI
1047 ExAllocateCacheAwareRundownProtection(
1048   __drv_strictTypeMatch(__drv_typeExpr) _In_ POOL_TYPE PoolType,
1049   _In_ ULONG PoolTag);
1050
1051 _IRQL_requires_max_(APC_LEVEL)
1052 NTKERNELAPI
1053 SIZE_T
1054 NTAPI
1055 ExSizeOfRundownProtectionCacheAware(VOID);
1056
1057 _IRQL_requires_max_(APC_LEVEL)
1058 _Acquires_lock_(_Global_critical_region_)
1059 NTKERNELAPI
1060 PVOID
1061 NTAPI
1062 ExEnterCriticalRegionAndAcquireResourceShared(
1063   _Inout_ _Requires_lock_not_held_(*_Curr_) _Acquires_shared_lock_(*_Curr_)
1064     PERESOURCE Resource);
1065
1066 _IRQL_requires_max_(APC_LEVEL)
1067 _Acquires_lock_(_Global_critical_region_)
1068 NTKERNELAPI
1069 PVOID
1070 NTAPI
1071 ExEnterCriticalRegionAndAcquireResourceExclusive(
1072   _Inout_ _Requires_lock_not_held_(*_Curr_) _Acquires_exclusive_lock_(*_Curr_)
1073     PERESOURCE Resource);
1074
1075 _IRQL_requires_max_(APC_LEVEL)
1076 _Acquires_lock_(_Global_critical_region_)
1077 NTKERNELAPI
1078 PVOID
1079 NTAPI
1080 ExEnterCriticalRegionAndAcquireSharedWaitForExclusive(
1081   _Inout_ _Requires_lock_not_held_(*_Curr_) _Acquires_lock_(*_Curr_)
1082     PERESOURCE Resource);
1083
1084 _IRQL_requires_max_(DISPATCH_LEVEL)
1085 _Releases_lock_(_Global_critical_region_)
1086 NTKERNELAPI
1087 VOID
1088 FASTCALL
1089 ExReleaseResourceAndLeaveCriticalRegion(
1090   _Inout_ _Requires_lock_held_(*_Curr_) _Releases_lock_(*_Curr_)
1091     PERESOURCE Resource);
1092
1093 _IRQL_requires_max_(APC_LEVEL)
1094 NTKERNELAPI
1095 VOID
1096 NTAPI
1097 ExInitializeRundownProtectionCacheAware(
1098   _Out_ PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware,
1099   _In_ SIZE_T RunRefSize);
1100
1101 _IRQL_requires_max_(APC_LEVEL)
1102 NTKERNELAPI
1103 VOID
1104 NTAPI
1105 ExFreeCacheAwareRundownProtection(
1106   _Inout_ PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware);
1107
1108 _Must_inspect_result_
1109 _Post_satisfies_(return == 0 || return == 1)
1110 NTKERNELAPI
1111 BOOLEAN
1112 FASTCALL
1113 ExAcquireRundownProtectionCacheAware(
1114   _Inout_ PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware);
1115
1116 NTKERNELAPI
1117 VOID
1118 FASTCALL
1119 ExReleaseRundownProtectionCacheAware(
1120   _Inout_ PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware);
1121
1122 _Must_inspect_result_
1123 _Post_satisfies_(return == 0 || return == 1)
1124 NTKERNELAPI
1125 BOOLEAN
1126 FASTCALL
1127 ExAcquireRundownProtectionCacheAwareEx(
1128   _Inout_ PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware,
1129   _In_ ULONG Count);
1130
1131 NTKERNELAPI
1132 VOID
1133 FASTCALL
1134 ExReleaseRundownProtectionCacheAwareEx(
1135   _Inout_ PEX_RUNDOWN_REF_CACHE_AWARE RunRef,
1136   _In_ ULONG Count);
1137
1138 NTKERNELAPI
1139 VOID
1140 FASTCALL
1141 ExWaitForRundownProtectionReleaseCacheAware(
1142   IN OUT PEX_RUNDOWN_REF_CACHE_AWARE RunRef);
1143
1144 NTKERNELAPI
1145 VOID
1146 FASTCALL
1147 ExReInitializeRundownProtectionCacheAware(
1148   _Inout_ PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware);
1149
1150 NTKERNELAPI
1151 VOID
1152 FASTCALL
1153 ExRundownCompletedCacheAware(
1154   _Inout_ PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware);
1155
1156 #endif /* (NTDDI_VERSION >= NTDDI_WS03SP1) */
1157
1158 #if (NTDDI_VERSION >= NTDDI_VISTA)
1159
1160 _IRQL_requires_max_(DISPATCH_LEVEL)
1161 NTKERNELAPI
1162 NTSTATUS
1163 NTAPI
1164 ExInitializeLookasideListEx(
1165   _Out_ PLOOKASIDE_LIST_EX Lookaside,
1166   _In_opt_ PALLOCATE_FUNCTION_EX Allocate,
1167   _In_opt_ PFREE_FUNCTION_EX Free,
1168   _In_ POOL_TYPE PoolType,
1169   _In_ ULONG Flags,
1170   _In_ SIZE_T Size,
1171   _In_ ULONG Tag,
1172   _In_ USHORT Depth);
1173
1174 _IRQL_requires_max_(DISPATCH_LEVEL)
1175 NTKERNELAPI
1176 VOID
1177 NTAPI
1178 ExDeleteLookasideListEx(
1179   _Inout_ PLOOKASIDE_LIST_EX Lookaside);
1180
1181 _IRQL_requires_max_(DISPATCH_LEVEL)
1182 NTKERNELAPI
1183 VOID
1184 NTAPI
1185 ExFlushLookasideListEx(
1186   _Inout_ PLOOKASIDE_LIST_EX Lookaside);
1187
1188 _Must_inspect_result_
1189 _IRQL_requires_max_(DISPATCH_LEVEL)
1190 FORCEINLINE
1191 PVOID
1192 ExAllocateFromLookasideListEx(
1193   _Inout_ PLOOKASIDE_LIST_EX Lookaside)
1194 {
1195   PVOID Entry;
1196
1197   Lookaside->L.TotalAllocates += 1;
1198 #ifdef NONAMELESSUNION
1199   Entry = InterlockedPopEntrySList(&Lookaside->L.u.ListHead);
1200   if (Entry == NULL) {
1201     Lookaside->L.u2.AllocateMisses += 1;
1202     Entry = (Lookaside->L.u4.AllocateEx)(Lookaside->L.Type,
1203                                          Lookaside->L.Size,
1204                                          Lookaside->L.Tag,
1205                                          Lookaside);
1206   }
1207 #else /* NONAMELESSUNION */
1208   Entry = InterlockedPopEntrySList(&Lookaside->L.ListHead);
1209   if (Entry == NULL) {
1210     Lookaside->L.AllocateMisses += 1;
1211     Entry = (Lookaside->L.AllocateEx)(Lookaside->L.Type,
1212                                       Lookaside->L.Size,
1213                                       Lookaside->L.Tag,
1214                                       Lookaside);
1215   }
1216 #endif /* NONAMELESSUNION */
1217   return Entry;
1218 }
1219
1220 _IRQL_requires_max_(DISPATCH_LEVEL)
1221 FORCEINLINE
1222 VOID
1223 ExFreeToLookasideListEx(
1224   _Inout_ PLOOKASIDE_LIST_EX Lookaside,
1225   _In_ PVOID Entry)
1226 {
1227   Lookaside->L.TotalFrees += 1;
1228   if (ExQueryDepthSList(&Lookaside->L.ListHead) >= Lookaside->L.Depth) {
1229     Lookaside->L.FreeMisses += 1;
1230     (Lookaside->L.FreeEx)(Entry, Lookaside);
1231   } else {
1232     InterlockedPushEntrySList(&Lookaside->L.ListHead, (PSLIST_ENTRY)Entry);
1233   }
1234   return;
1235 }
1236
1237 #endif /* (NTDDI_VERSION >= NTDDI_VISTA) */
1238
1239 #if (NTDDI_VERSION >= NTDDI_WIN7)
1240
1241 _IRQL_requires_max_(DISPATCH_LEVEL)
1242 NTKERNELAPI
1243 VOID
1244 NTAPI
1245 ExSetResourceOwnerPointerEx(
1246   _Inout_ PERESOURCE Resource,
1247   _In_ PVOID OwnerPointer,
1248   _In_ ULONG Flags);
1249
1250 #define FLAG_OWNER_POINTER_IS_THREAD 0x1
1251
1252 #endif /* (NTDDI_VERSION >= NTDDI_WIN7) */
1253
1254 _IRQL_requires_max_(DISPATCH_LEVEL)
1255 static __inline PVOID
1256 ExAllocateFromNPagedLookasideList(
1257   _Inout_ PNPAGED_LOOKASIDE_LIST Lookaside)
1258 {
1259   PVOID Entry;
1260
1261   Lookaside->L.TotalAllocates++;
1262 #ifdef NONAMELESSUNION
1263 #if defined(_WIN2K_COMPAT_SLIST_USAGE) && defined(_X86_)
1264   Entry = ExInterlockedPopEntrySList(&Lookaside->L.u.ListHead,
1265                                      &Lookaside->Lock__ObsoleteButDoNotDelete);
1266 #else
1267   Entry = InterlockedPopEntrySList(&Lookaside->L.u.ListHead);
1268 #endif
1269   if (Entry == NULL) {
1270     Lookaside->L.u2.AllocateMisses++;
1271     Entry = (Lookaside->L.u4.Allocate)(Lookaside->L.Type,
1272                                        Lookaside->L.Size,
1273                                        Lookaside->L.Tag);
1274   }
1275 #else /* NONAMELESSUNION */
1276 #if defined(_WIN2K_COMPAT_SLIST_USAGE) && defined(_X86_)
1277   Entry = ExInterlockedPopEntrySList(&Lookaside->L.ListHead,
1278                                      &Lookaside->Lock__ObsoleteButDoNotDelete);
1279 #else
1280   Entry = InterlockedPopEntrySList(&Lookaside->L.ListHead);
1281 #endif
1282   if (Entry == NULL) {
1283     Lookaside->L.AllocateMisses++;
1284     Entry = (Lookaside->L.Allocate)(Lookaside->L.Type,
1285                                     Lookaside->L.Size,
1286                                     Lookaside->L.Tag);
1287   }
1288 #endif /* NONAMELESSUNION */
1289   return Entry;
1290 }
1291
1292 _IRQL_requires_max_(DISPATCH_LEVEL)
1293 static __inline VOID
1294 ExFreeToNPagedLookasideList(
1295   _Inout_ PNPAGED_LOOKASIDE_LIST Lookaside,
1296   _In_ PVOID Entry)
1297 {
1298   Lookaside->L.TotalFrees++;
1299 #ifdef NONAMELESSUNION
1300   if (ExQueryDepthSList(&Lookaside->L.u.ListHead) >= Lookaside->L.Depth) {
1301     Lookaside->L.u3.FreeMisses++;
1302     (Lookaside->L.u5.Free)(Entry);
1303   } else {
1304 #if defined(_WIN2K_COMPAT_SLIST_USAGE) && defined(_X86_)
1305       ExInterlockedPushEntrySList(&Lookaside->L.u.ListHead,
1306                                   (PSLIST_ENTRY)Entry,
1307                                   &Lookaside->Lock__ObsoleteButDoNotDelete);
1308 #else
1309       InterlockedPushEntrySList(&Lookaside->L.u.ListHead, (PSLIST_ENTRY)Entry);
1310 #endif
1311    }
1312 #else /* NONAMELESSUNION */
1313   if (ExQueryDepthSList(&Lookaside->L.ListHead) >= Lookaside->L.Depth) {
1314     Lookaside->L.FreeMisses++;
1315     (Lookaside->L.Free)(Entry);
1316   } else {
1317 #if defined(_WIN2K_COMPAT_SLIST_USAGE) && defined(_X86_)
1318       ExInterlockedPushEntrySList(&Lookaside->L.ListHead,
1319                                   (PSLIST_ENTRY)Entry,
1320                                   &Lookaside->Lock__ObsoleteButDoNotDelete);
1321 #else
1322       InterlockedPushEntrySList(&Lookaside->L.ListHead, (PSLIST_ENTRY)Entry);
1323 #endif
1324    }
1325 #endif /* NONAMELESSUNION */
1326 }
1327
1328 $endif (_WDMDDK_)