reactos/ntoskrnl/include/internal/ex.h

   1 #ifndef __NTOSKRNL_INCLUDE_INTERNAL_EXECUTIVE_H
   2 #define __NTOSKRNL_INCLUDE_INTERNAL_EXECUTIVE_H
   3
   4 /* GLOBAL VARIABLES *********************************************************/
   5
   6 extern TIME_ZONE_INFORMATION ExpTimeZoneInfo;
   7 extern LARGE_INTEGER ExpTimeZoneBias;
   8 extern ULONG ExpTimeZoneId;
   9 extern POBJECT_TYPE ExEventPairObjectType;
  10
  11 #define EX_OBJ_TO_HDR(eob) ((PROS_OBJECT_HEADER)((ULONG_PTR)(eob) &                \
  12   ~(EX_HANDLE_ENTRY_PROTECTFROMCLOSE | EX_HANDLE_ENTRY_INHERITABLE |           \
  13   EX_HANDLE_ENTRY_AUDITONCLOSE)))
  14 #define EX_HTE_TO_HDR(hte) ((PROS_OBJECT_HEADER)((ULONG_PTR)((hte)->Object) &   \
  15   ~(EX_HANDLE_ENTRY_PROTECTFROMCLOSE | EX_HANDLE_ENTRY_INHERITABLE |           \
  16   EX_HANDLE_ENTRY_AUDITONCLOSE)))
  17
  18 /* Note: we only use a spinlock on SMP. On UP, we cli/sti intead */
  19 #ifndef CONFIG_SMP
  20 #define ExAcquireResourceLock(l, i) { \
  21     (void)i; \
  22     Ke386DisableInterrupts(); \
  23 }
  24 #define ExReleaseResourceLock(l, i) Ke386EnableInterrupts();
  25 #else
  26 #define ExAcquireResourceLock(l, i) KeAcquireSpinLock(l, i);
  27 #define ExReleaseResourceLock(l, i) KeReleaseSpinLock(l, i);
  28 #endif
  29
  30 /* INITIALIZATION FUNCTIONS *************************************************/
  31
  32 VOID
  33 STDCALL
  34 ExpWin32kInit(VOID);
  35
  36 VOID
  37 STDCALL
  38 ExInit2(VOID);
  39
  40 VOID
  41 STDCALL
  42 ExpInitTimeZoneInfo(VOID);
  43
  44 VOID
  45 STDCALL
  46 ExpInitializeWorkerThreads(VOID);
  47
  48 VOID
  49 STDCALL
  50 ExpInitLookasideLists(VOID);
  51
  52 VOID
  53 STDCALL
  54 ExpInitializeCallbacks(VOID);
  55
  56 VOID
  57 STDCALL
  58 ExpInitUuids(VOID);
  59
  60 VOID
  61 STDCALL
  62 ExpInitializeExecutive(VOID);
  63
  64 VOID
  65 STDCALL
  66 ExpInitializeEventImplementation(VOID);
  67
  68 VOID
  69 STDCALL
  70 ExpInitializeEventImplementation(VOID);
  71
  72 VOID
  73 STDCALL
  74 ExpInitializeEventPairImplementation(VOID);
  75
  76 VOID
  77 STDCALL
  78 ExpInitializeSemaphoreImplementation(VOID);
  79
  80 VOID
  81 STDCALL
  82 ExpInitializeMutantImplementation(VOID);
  83
  84 VOID
  85 STDCALL
  86 ExpInitializeTimerImplementation(VOID);
  87
  88 VOID
  89 STDCALL
  90 ExpInitializeProfileImplementation(VOID);
  91
  92 VOID
  93 NTAPI
  94 ExpResourceInitialization(VOID);
  95
  96 /* Rundown Functions ********************************************************/
  97
  98 VOID
  99 FASTCALL
 100 ExfInitializeRundownProtection(
 101      OUT PEX_RUNDOWN_REF RunRef
 102 );
 103
 104 VOID
 105 FASTCALL
 106 ExfReInitializeRundownProtection(
 107      OUT PEX_RUNDOWN_REF RunRef
 108 );
 109
 110 BOOLEAN
 111 FASTCALL
 112 ExfAcquireRundownProtection(
 113      IN OUT PEX_RUNDOWN_REF RunRef
 114 );
 115
 116 BOOLEAN
 117 FASTCALL
 118 ExfAcquireRundownProtectionEx(
 119      IN OUT PEX_RUNDOWN_REF RunRef,
 120      IN ULONG Count
 121 );
 122
 123 VOID
 124 FASTCALL
 125 ExfReleaseRundownProtection(
 126      IN OUT PEX_RUNDOWN_REF RunRef
 127 );
 128
 129 VOID
 130 FASTCALL
 131 ExfReleaseRundownProtectionEx(
 132      IN OUT PEX_RUNDOWN_REF RunRef,
 133      IN ULONG Count
 134 );
 135
 136 VOID
 137 FASTCALL
 138 ExfRundownCompleted(
 139      OUT PEX_RUNDOWN_REF RunRef
 140 );
 141
 142 VOID
 143 FASTCALL
 144 ExfWaitForRundownProtectionRelease(
 145      IN OUT PEX_RUNDOWN_REF RunRef
 146 );
 147
 148 /* HANDLE TABLE FUNCTIONS ***************************************************/
 149
 150 #define EX_HANDLE_ENTRY_LOCKED (1 << ((sizeof(PVOID) * 8) - 1))
 151 #define EX_HANDLE_ENTRY_PROTECTFROMCLOSE (1 << 0)
 152 #define EX_HANDLE_ENTRY_INHERITABLE (1 << 1)
 153 #define EX_HANDLE_ENTRY_AUDITONCLOSE (1 << 2)
 154
 155 #define EX_HANDLE_TABLE_CLOSING 0x1
 156
 157 #define EX_HANDLE_ENTRY_FLAGSMASK (EX_HANDLE_ENTRY_LOCKED |                    \
 158                                    EX_HANDLE_ENTRY_PROTECTFROMCLOSE |          \
 159                                    EX_HANDLE_ENTRY_INHERITABLE |               \
 160                                    EX_HANDLE_ENTRY_AUDITONCLOSE)
 161
 162 typedef VOID (STDCALL PEX_SWEEP_HANDLE_CALLBACK)(
 163     PHANDLE_TABLE HandleTable,
 164     PVOID Object,
 165     ULONG GrantedAccess,
 166     PVOID Context
 167 );
 168
 169 typedef BOOLEAN (STDCALL PEX_DUPLICATE_HANDLE_CALLBACK)(
 170     PHANDLE_TABLE HandleTable,
 171     PHANDLE_TABLE_ENTRY HandleTableEntry,
 172     PVOID Context
 173 );
 174
 175 typedef BOOLEAN (STDCALL PEX_CHANGE_HANDLE_CALLBACK)(
 176     PHANDLE_TABLE HandleTable,
 177     PHANDLE_TABLE_ENTRY HandleTableEntry,
 178     PVOID Context
 179 );
 180
 181 VOID
 182 ExpInitializeHandleTables(VOID);
 183
 184 PHANDLE_TABLE
 185 ExCreateHandleTable(IN PEPROCESS QuotaProcess  OPTIONAL);
 186
 187 VOID
 188 ExDestroyHandleTable(
 189     IN PHANDLE_TABLE HandleTable
 190 );
 191
 192 VOID
 193 ExSweepHandleTable(
 194     IN PHANDLE_TABLE HandleTable,
 195     IN PEX_SWEEP_HANDLE_CALLBACK SweepHandleCallback  OPTIONAL,
 196     IN PVOID Context  OPTIONAL
 197 );
 198
 199 PHANDLE_TABLE
 200 ExDupHandleTable(
 201     IN PEPROCESS QuotaProcess  OPTIONAL,
 202     IN PEX_DUPLICATE_HANDLE_CALLBACK DuplicateHandleCallback  OPTIONAL,
 203     IN PVOID Context  OPTIONAL,
 204     IN PHANDLE_TABLE SourceHandleTable
 205 );
 206
 207 BOOLEAN
 208 ExLockHandleTableEntry(
 209     IN PHANDLE_TABLE HandleTable,
 210     IN PHANDLE_TABLE_ENTRY Entry
 211 );
 212
 213 VOID
 214 ExUnlockHandleTableEntry(
 215     IN PHANDLE_TABLE HandleTable,
 216     IN PHANDLE_TABLE_ENTRY Entry
 217 );
 218
 219 HANDLE
 220 ExCreateHandle(
 221     IN PHANDLE_TABLE HandleTable,
 222     IN PHANDLE_TABLE_ENTRY Entry
 223 );
 224
 225 BOOLEAN
 226 ExDestroyHandle(
 227     IN PHANDLE_TABLE HandleTable,
 228     IN HANDLE Handle
 229 );
 230
 231 VOID
 232 ExDestroyHandleByEntry(
 233     IN PHANDLE_TABLE HandleTable,
 234     IN PHANDLE_TABLE_ENTRY Entry,
 235     IN HANDLE Handle
 236 );
 237
 238 PHANDLE_TABLE_ENTRY
 239 ExMapHandleToPointer(
 240     IN PHANDLE_TABLE HandleTable,
 241     IN HANDLE Handle
 242 );
 243
 244 BOOLEAN
 245 ExChangeHandle(
 246     IN PHANDLE_TABLE HandleTable,
 247     IN HANDLE Handle,
 248     IN PEX_CHANGE_HANDLE_CALLBACK ChangeHandleCallback,
 249     IN PVOID Context
 250 );
 251
 252 /* PSEH EXCEPTION HANDLING **************************************************/
 253
 254 LONG
 255 STDCALL
 256 ExSystemExceptionFilter(VOID);
 257
 258 static __inline _SEH_FILTER(_SEH_ExSystemExceptionFilter)
 259 {
 260     return ExSystemExceptionFilter();
 261 }
 262
 263 /* RUNDOWN *******************************************************************/
 264
 265 #ifdef _WIN64
 266 #define ExpChangeRundown(x, y, z) InterlockedCompareExchange64((PLONGLONG)x, y, z)
 267 #define ExpSetRundown(x, y) InterlockedExchange64((PLONGLONG)x, y)
 268 #else
 269 #define ExpChangeRundown(x, y, z) InterlockedCompareExchange((PLONG)x, y, z)
 270 #define ExpSetRundown(x, y) InterlockedExchange((PLONG)x, y)
 271 #endif
 272
 273 /*++
 274  * @name ExfAcquireRundownProtection
 275  * INTERNAL MACRO
 276  *
 277  *     The ExfAcquireRundownProtection routine acquires rundown protection for
 278  *     the specified descriptor.
 279  *
 280  * @param RunRef
 281  *        Pointer to a rundown reference descriptor.
 282  *
 283  * @return TRUE if access to the protected structure was granted, FALSE otherwise.
 284  *
 285  * @remarks This is the internal macro for system use only.In case the rundown
 286  *          was active, then the slow-path will be called through the exported
 287  *          function.
 288  *
 289  *--*/
 290 BOOLEAN
 291 FORCEINLINE
 292 ExAcquireRundownProtection(IN PEX_RUNDOWN_REF RunRef)
 293 {
 294     ULONG_PTR Value, NewValue, OldValue;
 295
 296     /* Get the current value and mask the active bit */
 297     Value = RunRef->Count &~ EX_RUNDOWN_ACTIVE;
 298
 299     /* Add a reference */
 300     NewValue = Value + EX_RUNDOWN_COUNT_INC;
 301
 302     /* Change the value */
 303     OldValue = ExpChangeRundown(RunRef, NewValue, Value);
 304     if (OldValue != Value)
 305     {
 306         /* Rundown was active, use long path */
 307         return ExfAcquireRundownProtection(RunRef);
 308     }
 309
 310     /* Success */
 311     return TRUE;
 312 }
 313
 314 /*++
 315  * @name ExReleaseRundownProtection
 316  * INTERNAL MACRO
 317  *
 318  *     The ExReleaseRundownProtection routine releases rundown protection for
 319  *     the specified descriptor.
 320  *
 321  * @param RunRef
 322  *        Pointer to a rundown reference descriptor.
 323  *
 324  * @return TRUE if access to the protected structure was granted, FALSE otherwise.
 325  *
 326  * @remarks This is the internal macro for system use only.In case the rundown
 327  *          was active, then the slow-path will be called through the exported
 328  *          function.
 329  *
 330  *--*/
 331 VOID
 332 FORCEINLINE
 333 ExReleaseRundownProtection(IN PEX_RUNDOWN_REF RunRef)
 334 {
 335     ULONG_PTR Value, NewValue, OldValue;
 336
 337     /* Get the current value and mask the active bit */
 338     Value = RunRef->Count &~ EX_RUNDOWN_ACTIVE;
 339
 340     /* Remove a reference */
 341     NewValue = Value - EX_RUNDOWN_COUNT_INC;
 342
 343     /* Change the value */
 344     OldValue = ExpChangeRundown(RunRef, NewValue, Value);
 345
 346     /* Check if the rundown was active */
 347     if (OldValue != Value)
 348     {
 349         /* Rundown was active, use long path */
 350         ExfReleaseRundownProtection(RunRef);
 351     }
 352     else
 353     {
 354         /* Sanity check */
 355         ASSERT((Value >= EX_RUNDOWN_COUNT_INC) || (KeNumberProcessors > 1));
 356     }
 357 }
 358
 359 /*++
 360  * @name ExInitializeRundownProtection
 361  * INTERNAL MACRO
 362  *
 363  *     The ExInitializeRundownProtection routine initializes a rundown
 364  *     protection descriptor.
 365  *
 366  * @param RunRef
 367  *        Pointer to a rundown reference descriptor.
 368  *
 369  * @return None.
 370  *
 371  * @remarks This is the internal macro for system use only.
 372  *
 373  *--*/
 374 VOID
 375 FORCEINLINE
 376 ExInitializeRundownProtection(IN PEX_RUNDOWN_REF RunRef)
 377 {
 378     /* Set the count to zero */
 379     RunRef->Count = 0;
 380 }
 381
 382 /*++
 383  * @name ExWaitForRundownProtectionRelease
 384  * INTERNAL MACRO
 385  *
 386  *     The ExWaitForRundownProtectionRelease routine waits until the specified
 387  *     rundown descriptor has been released.
 388  *
 389  * @param RunRef
 390  *        Pointer to a rundown reference descriptor.
 391  *
 392  * @return None.
 393  *
 394  * @remarks This is the internal macro for system use only. If a wait is actually
 395  *          necessary, then the slow path is taken through the exported function.
 396  *
 397  *--*/
 398 VOID
 399 FORCEINLINE
 400 ExWaitForRundownProtectionRelease(IN PEX_RUNDOWN_REF RunRef)
 401 {
 402     ULONG_PTR Value;
 403
 404     /* Set the active bit */
 405     Value = ExpChangeRundown(RunRef, EX_RUNDOWN_ACTIVE, 0);
 406     if ((Value) || (Value != EX_RUNDOWN_ACTIVE))
 407     {
 408         /* If the the rundown wasn't already active, then take the long path */
 409         ExfWaitForRundownProtectionRelease(RunRef);
 410     }
 411 }
 412
 413 /*++
 414  * @name ExRundownCompleted
 415  * INTERNAL MACRO
 416  *
 417  *     The ExRundownCompleted routine completes the rundown of the specified
 418  *     descriptor by setting the active bit.
 419  *
 420  * @param RunRef
 421  *        Pointer to a rundown reference descriptor.
 422  *
 423  * @return None.
 424  *
 425  * @remarks This is the internal macro for system use only.
 426  *
 427  *--*/
 428 VOID
 429 FORCEINLINE
 430 ExRundownCompleted(IN PEX_RUNDOWN_REF RunRef)
 431 {
 432     /* Sanity check */
 433     ASSERT((RunRef->Count & EX_RUNDOWN_ACTIVE) != 0);
 434
 435     /* Mark the counter as active */
 436     ExpSetRundown(&RunRef->Count, EX_RUNDOWN_ACTIVE);
 437 }
 438
 439 /* PUSHLOCKS *****************************************************************/
 440
 441 /*++
 442  * @name ExAcquirePushLockExclusive
 443  * INTERNAL MACRO
 444  *
 445  *     The ExAcquirePushLockExclusive macro exclusively acquires a PushLock.
 446  *
 447  * @params PushLock
 448  *         Pointer to the pushlock which is to be acquired.
 449  *
 450  * @return None.
 451  *
 452  * @remarks The function attempts the quickest route to acquire the lock, which is
 453  *          to simply set the lock bit.
 454  *          However, if the pushlock is already shared, the slower path is taken.
 455  *
 456  *          Callers of ExAcquirePushLockShared must be running at IRQL <= APC_LEVEL.
 457  *          This macro should usually be paired up with KeAcquireCriticalRegion.
 458  *
 459  *--*/
 460 VOID
 461 FORCEINLINE
 462 ExAcquirePushLockExclusive(PEX_PUSH_LOCK PushLock)
 463 {
 464     /* Try acquiring the lock */
 465     if (InterlockedBitTestAndSet((PLONG)PushLock, EX_PUSH_LOCK_LOCK_V))
 466     {
 467         /* Someone changed it, use the slow path */
 468         ExfAcquirePushLockExclusive(PushLock);
 469     }
 470
 471     /* Sanity check */
 472     ASSERT(PushLock->Locked);
 473 }
 474
 475 /*++
 476  * @name ExAcquirePushLockShared
 477  * INTERNAL MACRO
 478  *
 479  *     The ExAcquirePushLockShared macro acquires a shared PushLock.
 480  *
 481  * @params PushLock
 482  *         Pointer to the pushlock which is to be acquired.
 483  *
 484  * @return None.
 485  *
 486  * @remarks The function attempts the quickest route to acquire the lock, which is
 487  *          to simply set the lock bit and set the share count to one.
 488  *          However, if the pushlock is already shared, the slower path is taken.
 489  *
 490  *          Callers of ExAcquirePushLockShared must be running at IRQL <= APC_LEVEL.
 491  *          This macro should usually be paired up with KeAcquireCriticalRegion.
 492  *
 493  *--*/
 494 VOID
 495 FORCEINLINE
 496 ExAcquirePushLockShared(PEX_PUSH_LOCK PushLock)
 497 {
 498     EX_PUSH_LOCK NewValue;
 499
 500     /* Try acquiring the lock */
 501     NewValue.Value = EX_PUSH_LOCK_LOCK | EX_PUSH_LOCK_SHARE_INC;
 502     if (!InterlockedCompareExchangePointer(PushLock, NewValue.Ptr, 0))
 503     {
 504         /* Someone changed it, use the slow path */
 505         ExfAcquirePushLockShared(PushLock);
 506     }
 507
 508     /* Sanity checks */
 509     ASSERT(PushLock->Locked);
 510     ASSERT(PushLock->Waiting || PushLock->Shared > 0);
 511 }
 512
 513 /*++
 514  * @name ExWaitOnPushLock
 515  * INTERNAL MACRO
 516  *
 517  *     The ExWaitOnPushLock macro acquires and instantly releases a pushlock.
 518  *
 519  * @params PushLock
 520  *         Pointer to a pushlock.
 521  *
 522  * @return None.
 523  *
 524  * @remarks The function attempts to get any exclusive waiters out of their slow
 525  *          path by forcing an instant acquire/release operation.
 526  *
 527  *          Callers of ExWaitOnPushLock must be running at IRQL <= APC_LEVEL.
 528  *
 529  *--*/
 530 VOID
 531 FORCEINLINE
 532 ExWaitOnPushLock(PEX_PUSH_LOCK PushLock)
 533 {
 534     /* Acquire the lock */
 535     ExfAcquirePushLockExclusive(PushLock);
 536     ASSERT(PushLock->Locked);
 537
 538     /* Release it */
 539     ExfReleasePushLockExclusive(PushLock);
 540 }
 541
 542 /*++
 543  * @name ExReleasePushLockShared
 544  * INTERNAL MACRO
 545  *
 546  *     The ExReleasePushLockShared macro releases a previously acquired PushLock.
 547  *
 548  * @params PushLock
 549  *         Pointer to a previously acquired pushlock.
 550  *
 551  * @return None.
 552  *
 553  * @remarks The function attempts the quickest route to release the lock, which is
 554  *          to simply decrease the share count and remove the lock bit.
 555  *          However, if the pushlock is being waited on then the long path is taken.
 556  *
 557  *          Callers of ExReleasePushLockShared must be running at IRQL <= APC_LEVEL.
 558  *          This macro should usually be paired up with KeLeaveCriticalRegion.
 559  *
 560  *--*/
 561 VOID
 562 FORCEINLINE
 563 ExReleasePushLockShared(PEX_PUSH_LOCK PushLock)
 564 {
 565     EX_PUSH_LOCK OldValue;
 566
 567     /* Sanity checks */
 568     ASSERT(PushLock->Locked);
 569     ASSERT(PushLock->Waiting || PushLock->Shared > 0);
 570
 571     /* Try to clear the pushlock */
 572     OldValue.Value = EX_PUSH_LOCK_LOCK | EX_PUSH_LOCK_SHARE_INC;
 573     if (InterlockedCompareExchangePointer(PushLock, 0, OldValue.Ptr) !=
 574         OldValue.Ptr)
 575     {
 576         /* There are still other people waiting on it */
 577         ExfReleasePushLockShared(PushLock);
 578     }
 579 }
 580
 581 /*++
 582  * @name ExReleasePushLockExclusive
 583  * INTERNAL MACRO
 584  *
 585  *     The ExReleasePushLockExclusive macro releases a previously
 586  *     exclusively acquired PushLock.
 587  *
 588  * @params PushLock
 589  *         Pointer to a previously acquired pushlock.
 590  *
 591  * @return None.
 592  *
 593  * @remarks The function attempts the quickest route to release the lock, which is
 594  *          to simply clear the locked bit.
 595  *          However, if the pushlock is being waited on, the slow path is taken
 596  *          in an attempt to wake up the lock.
 597  *
 598  *          Callers of ExReleasePushLockExclusive must be running at IRQL <= APC_LEVEL.
 599  *          This macro should usually be paired up with KeLeaveCriticalRegion.
 600  *
 601  *--*/
 602 VOID
 603 FORCEINLINE
 604 ExReleasePushLockExclusive(PEX_PUSH_LOCK PushLock)
 605 {
 606     EX_PUSH_LOCK OldValue;
 607
 608     /* Sanity checks */
 609     ASSERT(PushLock->Locked);
 610     ASSERT(PushLock->Waiting || PushLock->Shared == 0);
 611
 612     /* Unlock the pushlock */
 613     OldValue.Value = InterlockedExchangeAddSizeT((PLONG)PushLock, -1);
 614
 615     /* Sanity checks */
 616     ASSERT(OldValue.Locked);
 617     ASSERT(OldValue.Waiting || OldValue.Shared == 0);
 618
 619     /* Check if anyone is waiting on it and it's not already waking*/
 620     if ((OldValue.Waiting) && !(OldValue.Waking))
 621     {
 622         /* Wake it up */
 623         ExfTryToWakePushLock(PushLock);
 624     }
 625 }
 626
 627 /*++
 628  * @name ExReleasePushLock
 629  * INTERNAL MACRO
 630  *
 631  *     The ExReleasePushLock macro releases a previously acquired PushLock.
 632  *
 633  * @params PushLock
 634  *         Pointer to a previously acquired pushlock.
 635  *
 636  * @return None.
 637  *
 638  * @remarks The function attempts the quickest route to release the lock, which is
 639  *          to simply clear all the fields and decrease the share count if required.
 640  *          However, if the pushlock is being waited on then the long path is taken.
 641  *
 642  *          Callers of ExReleasePushLock must be running at IRQL <= APC_LEVEL.
 643  *          This macro should usually be paired up with KeLeaveCriticalRegion.
 644  *
 645  *--*/
 646 VOID
 647 FORCEINLINE
 648 ExReleasePushLock(PEX_PUSH_LOCK PushLock)
 649 {
 650     EX_PUSH_LOCK OldValue = *PushLock;
 651     EX_PUSH_LOCK NewValue;
 652
 653     /* Sanity checks */
 654     ASSERT(OldValue.Locked);
 655
 656     /* Check if the pushlock is shared */
 657     if (OldValue.Shared > 1)
 658     {
 659         /* Decrease the share count */
 660         NewValue.Value = OldValue.Value &~ EX_PUSH_LOCK_SHARE_INC;
 661     }
 662     else
 663     {
 664         /* Clear the pushlock entirely */
 665         NewValue.Value = 0;
 666     }
 667
 668     /* Check if nobody is waiting on us and try clearing the lock here */
 669     if ((OldValue.Waiting) ||
 670         (InterlockedCompareExchangePointer(PushLock, NewValue.Ptr, OldValue.Ptr) ==
 671          OldValue.Ptr))
 672     {
 673         /* We have waiters, use the long path */
 674         ExfReleasePushLock(PushLock);
 675     }
 676 }
 677
 678 /* OTHER FUNCTIONS **********************************************************/
 679
 680 LONGLONG
 681 FASTCALL
 682 ExfpInterlockedExchange64(
 683     LONGLONG volatile * Destination,
 684     PLONGLONG Exchange
 685 );
 686
 687 NTSTATUS
 688 ExpSetTimeZoneInformation(PTIME_ZONE_INFORMATION TimeZoneInformation);
 689
 690 NTSTATUS
 691 NTAPI
 692 ExpAllocateLocallyUniqueId(OUT LUID *LocallyUniqueId);
 693
 694 VOID
 695 STDCALL
 696 ExTimerRundown(VOID);
 697
 698 #define InterlockedDecrementUL(Addend) \
 699    (ULONG)InterlockedDecrement((PLONG)(Addend))
 700
 701 #define InterlockedIncrementUL(Addend) \
 702    (ULONG)InterlockedIncrement((PLONG)(Addend))
 703
 704 #define InterlockedExchangeUL(Target, Value) \
 705    (ULONG)InterlockedExchange((PLONG)(Target), (LONG)(Value))
 706
 707 #define InterlockedExchangeAddUL(Addend, Value) \
 708    (ULONG)InterlockedExchangeAdd((PLONG)(Addend), (LONG)(Value))
 709
 710 #define InterlockedCompareExchangeUL(Destination, Exchange, Comperand) \
 711    (ULONG)InterlockedCompareExchange((PLONG)(Destination), (LONG)(Exchange), (LONG)(Comperand))
 712
 713 #define ExfInterlockedCompareExchange64UL(Destination, Exchange, Comperand) \
 714    (ULONGLONG)ExfInterlockedCompareExchange64((PLONGLONG)(Destination), (PLONGLONG)(Exchange), (PLONGLONG)(Comperand))
 715
 716 #define ExfpInterlockedExchange64UL(Target, Value) \
 717    (ULONGLONG)ExfpInterlockedExchange64((PLONGLONG)(Target), (PLONGLONG)(Value))
 718
 719 #endif /* __NTOSKRNL_INCLUDE_INTERNAL_EXECUTIVE_H */