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