include/ddk/exfuncs.h

   1 #ifndef _NTOS_EXFUNCS_H
   2 #define _NTOS_EXFUNCS_H
   3
   4 /* EXECUTIVE ROUTINES ******************************************************/
   5
   6 #define TAG(A, B, C, D) (ULONG)(((A)<<0) + ((B)<<8) + ((C)<<16) + ((D)<<24))
   7
   8 VOID
   9 FASTCALL
  10 ExAcquireFastMutex (
  11         PFAST_MUTEX     FastMutex
  12         );
  13 VOID
  14 FASTCALL
  15 ExAcquireFastMutexUnsafe (
  16         PFAST_MUTEX     FastMutex
  17         );
  18 BOOLEAN
  19 STDCALL
  20 ExAcquireResourceExclusive (
  21         PERESOURCE      Resource,
  22         BOOLEAN         Wait
  23         );
  24 BOOLEAN
  25 STDCALL
  26 ExAcquireResourceExclusiveLite (
  27         PERESOURCE      Resource,
  28         BOOLEAN         Wait
  29         );
  30 BOOLEAN
  31 STDCALL
  32 ExAcquireResourceSharedLite (
  33         PERESOURCE      Resource,
  34         BOOLEAN         Wait
  35         );
  36 BOOLEAN
  37 STDCALL
  38 ExAcquireSharedStarveExclusive (
  39         PERESOURCE      Resource,
  40         BOOLEAN         Wait
  41         );
  42 BOOLEAN
  43 STDCALL
  44 ExAcquireSharedWaitForExclusive (
  45         PERESOURCE      Resource,
  46         BOOLEAN         Wait
  47         );
  48
  49 PVOID
  50 STDCALL
  51 ExAllocateFromZone (
  52         PZONE_HEADER    Zone
  53         );
  54
  55 /*
  56  * PVOID
  57  * ExAllocateFromZone (
  58  *      PZONE_HEADER    Zone
  59  *      );
  60  *
  61  * FUNCTION:
  62  *      Allocate a block from a zone
  63  *
  64  * ARGUMENTS:
  65  *      Zone = Zone to allocate from
  66  *
  67  * RETURNS:
  68  *      The base address of the block allocated
  69  */
  70 #define ExAllocateFromZone(Zone) \
  71         (PVOID)((Zone)->FreeList.Next); \
  72         if ((Zone)->FreeList.Next) \
  73                 (Zone)->FreeList.Next = (Zone)->FreeList.Next->Next
  74
  75 /*
  76  * FUNCTION: Allocates memory from the nonpaged pool
  77  * ARGUMENTS:
  78  *      NumberOfBytes = minimum size of the block to be allocated
  79  *      PoolType = the type of memory to use for the block (ignored)
  80  * RETURNS:
  81  *      the address of the block if it succeeds
  82  */
  83 PVOID
  84 STDCALL
  85 ExAllocatePool (
  86         IN      POOL_TYPE       PoolType,
  87         IN      ULONG           NumberOfBytes
  88         );
  89
  90 PVOID
  91 STDCALL
  92 ExAllocatePoolWithQuota (
  93         IN      POOL_TYPE       PoolType,
  94         IN      ULONG           NumberOfBytes
  95         );
  96 PVOID
  97 STDCALL
  98 ExAllocatePoolWithQuotaTag (
  99         IN      POOL_TYPE       PoolType,
 100         IN      ULONG           NumberOfBytes,
 101         IN      ULONG           Tag
 102         );
 103 PVOID
 104 STDCALL
 105 ExAllocatePoolWithTag (
 106         IN      POOL_TYPE       PoolType,
 107         IN      ULONG           NumberOfBytes,
 108         IN      ULONG           Tag
 109         );
 110
 111 VOID
 112 STDCALL
 113 ExConvertExclusiveToSharedLite (
 114         PERESOURCE      Resource
 115         );
 116
 117 NTSTATUS
 118 STDCALL
 119 ExCreateCallback (
 120         OUT     PCALLBACK_OBJECT        * CallbackObject,
 121         IN      POBJECT_ATTRIBUTES      ObjectAttributes,
 122         IN      BOOLEAN                 Create,
 123         IN      BOOLEAN                 AllowMultipleCallbacks
 124         );
 125
 126 NTSTATUS
 127 STDCALL
 128 ExDeleteResource (
 129         PERESOURCE      Resource
 130         );
 131 NTSTATUS
 132 STDCALL
 133 ExDeleteResourceLite (
 134         PERESOURCE      Resource
 135         );
 136
 137 VOID
 138 STDCALL
 139 ExDisableResourceBoostLite (
 140         PERESOURCE      Resource
 141         );
 142
 143 NTSTATUS
 144 STDCALL
 145 ExExtendZone (
 146         PZONE_HEADER    Zone,
 147         PVOID           Segment,
 148         ULONG           SegmentSize
 149         );
 150
 151 /*
 152  * FUNCTION: Releases previously allocated memory
 153  * ARGUMENTS:
 154  *        block = block to free
 155  */
 156 VOID
 157 STDCALL
 158 ExFreePool (
 159         PVOID   block
 160         );
 161
 162 /*
 163  * PVOID
 164  * ExFreeToZone (
 165  *      PZONE_HEADER    Zone,
 166  *      PVOID           Block
 167  *      );
 168  *
 169  * FUNCTION:
 170  *      Frees a block from a zone
 171  *
 172  * ARGUMENTS:
 173  *      Zone = Zone the block was allocated from
 174  *      Block = Block to free
 175  */
 176 #define ExFreeToZone(Zone,Block) \
 177         (((PSINGLE_LIST_ENTRY)(Block))->Next = (Zone)->FreeList.Next, \
 178          (Zone)->FreeList.Next = ((PSINGLE_LIST_ENTRY)(Block)), \
 179          ((PSINGLE_LIST_ENTRY)(Block))->Next)
 180
 181 /*
 182  * ERESOURCE_THREAD
 183  * ExGetCurrentResourceThread (
 184  *      VOID
 185  *      );
 186  */
 187 #define ExGetCurrentResourceThread() \
 188         ((ERESOURCE_THREAD)KeGetCurrentThread())
 189
 190 ULONG
 191 STDCALL
 192 ExGetExclusiveWaiterCount (
 193         PERESOURCE      Resource
 194         );
 195
 196 ULONG
 197 STDCALL
 198 ExGetPreviousMode (
 199         VOID
 200         );
 201
 202 ULONG
 203 STDCALL
 204 ExGetSharedWaiterCount (
 205         PERESOURCE      Resource
 206         );
 207
 208 /*
 209  * VOID
 210  * ExInitializeFastMutex (
 211  *      PFAST_MUTEX     FastMutex
 212  *      );
 213  */
 214 #define ExInitializeFastMutex(_FastMutex) \
 215         ((PFAST_MUTEX)_FastMutex)->Count = 1; \
 216         ((PFAST_MUTEX)_FastMutex)->Owner = NULL; \
 217         ((PFAST_MUTEX)_FastMutex)->Contention = 0; \
 218         KeInitializeEvent(&((PFAST_MUTEX)_FastMutex)->Event, \
 219                           SynchronizationEvent, \
 220                           FALSE);
 221
 222 NTSTATUS
 223 STDCALL
 224 ExInitializeResource (
 225         PERESOURCE      Resource
 226         );
 227 NTSTATUS
 228 STDCALL
 229 ExInitializeResourceLite (
 230         PERESOURCE      Resource
 231         );
 232
 233 /*
 234  * VOID
 235  * ExInitializeSListHead (
 236  *      PSLIST_HEADER   SListHead
 237  *      );
 238  */
 239 #define ExInitializeSListHead(ListHead) \
 240         (ListHead)->Alignment = 0
 241
 242 /*
 243  * VOID
 244  * ExInitializeWorkItem (
 245  *      PWORK_QUEUE_ITEM        Item,
 246  *      PWORKER_THREAD_ROUTINE  Routine,
 247  *      PVOID                   Context
 248  *      );
 249  *
 250  * FUNCTION:
 251  *      Initializes a work item to be processed by one of the system
 252  *      worker threads
 253  *
 254  * ARGUMENTS:
 255  *      Item = Pointer to the item to be initialized
 256  *      Routine = Routine to be called by the worker thread
 257  *      Context = Parameter to be passed to the callback
 258  */
 259 #define ExInitializeWorkItem(Item, Routine, RoutineContext) \
 260         ASSERT_IRQL(DISPATCH_LEVEL); \
 261         (Item)->WorkerRoutine = (Routine); \
 262         (Item)->Parameter = (RoutineContext); \
 263         (Item)->List.Flink = NULL; \
 264         (Item)->List.Blink = NULL;
 265
 266 NTSTATUS
 267 STDCALL
 268 ExInitializeZone (
 269         PZONE_HEADER    Zone,
 270         ULONG           BlockSize,
 271         PVOID           InitialSegment,
 272         ULONG           InitialSegmentSize
 273         );
 274
 275 LARGE_INTEGER
 276 STDCALL
 277 ExInterlockedAddLargeInteger (
 278         PLARGE_INTEGER  Addend,
 279         LARGE_INTEGER   Increment,
 280         PKSPIN_LOCK     Lock
 281         );
 282
 283 VOID
 284 FASTCALL
 285 ExInterlockedAddLargeStatistic (
 286         IN      PLARGE_INTEGER  Addend,
 287         IN      ULONG           Increment
 288         );
 289
 290 ULONG
 291 FASTCALL
 292 ExInterlockedAddUlong (
 293         PULONG          Addend,
 294         ULONG           Increment,
 295         PKSPIN_LOCK     Lock
 296         );
 297
 298 /*
 299  * PVOID
 300  * STDCALL
 301  * ExInterlockedAllocateFromZone (
 302  *      PZONE_HEADER    Zone,
 303  *      PKSPIN_LOCK     Lock
 304  *      );
 305  */
 306 #define ExInterlockedAllocateFromZone(Zone,Lock) \
 307         (PVOID)ExInterlockedPopEntryList(&(Zone)->FreeList,Lock)
 308
 309 LONGLONG
 310 FASTCALL
 311 ExInterlockedCompareExchange64 (
 312         IN OUT  PLONGLONG       Destination,
 313         IN      PLONGLONG       Exchange,
 314         IN      PLONGLONG       Comparand,
 315         IN      PKSPIN_LOCK     Lock
 316         );
 317
 318 INTERLOCKED_RESULT
 319 STDCALL
 320 ExInterlockedDecrementLong (
 321         PLONG           Addend,
 322         PKSPIN_LOCK     Lock
 323         );
 324 ULONG
 325 STDCALL
 326 ExInterlockedExchangeUlong (
 327         PULONG          Target,
 328         ULONG           Value,
 329         PKSPIN_LOCK     Lock
 330         );
 331 NTSTATUS
 332 STDCALL
 333 ExInterlockedExtendZone (
 334         PZONE_HEADER    Zone,
 335         PVOID           Segment,
 336         ULONG           SegmentSize,
 337         PKSPIN_LOCK     Lock
 338         );
 339
 340 /*
 341  * PVOID
 342  * ExInterlockedFreeToZone (
 343  *      PZONE_HEADER    Zone,
 344  *      PVOID           Block,
 345  *      PKSPIN_LOCK     Lock
 346  *      );
 347  */
 348 #define ExInterlockedFreeToZone(Zone,Block,Lock) \
 349         ExInterlockedPushEntryList(&(Zone)->FreeList,((PSINGLE_LIST_ENTRY)(Block)),(Lock))
 350
 351 INTERLOCKED_RESULT
 352 STDCALL
 353 ExInterlockedIncrementLong (
 354         PLONG           Addend,
 355         PKSPIN_LOCK     Lock
 356         );
 357 PLIST_ENTRY
 358 FASTCALL
 359 ExInterlockedInsertHeadList (
 360         PLIST_ENTRY     ListHead,
 361         PLIST_ENTRY     ListEntry,
 362         PKSPIN_LOCK     Lock
 363         );
 364 PLIST_ENTRY
 365 FASTCALL
 366 ExInterlockedInsertTailList (
 367         PLIST_ENTRY     ListHead,
 368         PLIST_ENTRY     ListEntry,
 369         PKSPIN_LOCK     Lock
 370         );
 371 PSINGLE_LIST_ENTRY
 372 FASTCALL
 373 ExInterlockedPopEntryList (
 374         PSINGLE_LIST_ENTRY      ListHead,
 375         PKSPIN_LOCK             Lock
 376         );
 377 PSINGLE_LIST_ENTRY
 378 FASTCALL
 379 ExInterlockedPopEntrySList (
 380         PSLIST_HEADER   ListHead,
 381         PKSPIN_LOCK     Lock
 382         );
 383 PSINGLE_LIST_ENTRY
 384 FASTCALL
 385 ExInterlockedPushEntryList (
 386         PSINGLE_LIST_ENTRY      ListHead,
 387         PSINGLE_LIST_ENTRY      ListEntry,
 388         PKSPIN_LOCK             Lock
 389         );
 390 PSINGLE_LIST_ENTRY
 391 FASTCALL
 392 ExInterlockedPushEntrySList (
 393         PSLIST_HEADER           ListHead,
 394         PSINGLE_LIST_ENTRY      ListEntry,
 395         PKSPIN_LOCK             Lock
 396         );
 397
 398 VOID
 399 ExInterlockedRemoveEntryList (
 400         PLIST_ENTRY     ListHead,
 401         PLIST_ENTRY     Entry,
 402         PKSPIN_LOCK     Lock
 403         );
 404
 405 PLIST_ENTRY
 406 FASTCALL
 407 ExInterlockedRemoveHeadList (
 408         PLIST_ENTRY     Head,
 409         PKSPIN_LOCK     Lock
 410         );
 411
 412 /*
 413  * BOOLEAN
 414  * ExIsFullZone (
 415  *      PZONE_HEADER    Zone
 416  *      );
 417  */
 418 #define ExIsFullZone(Zone) \
 419         ((Zone)->FreeList.Next==(PSINGLE_LIST_ENTRY)NULL)
 420
 421 /*
 422  * BOOLEAN
 423  * ExIsObjectInFirstZoneSegment (
 424  *      PZONE_HEADER    Zone,
 425  *      PVOID           Object
 426  *      );
 427  */
 428 #define ExIsObjectInFirstZoneSegment(Zone,Object) \
 429         (((PUCHAR)(Object)>=(PUCHAR)(Zone)->SegmentList.Next) && \
 430          ((PUCHAR)(Object)<(PUCHAR)(Zone)->SegmentList.Next+(Zone)->TotalSegmentSize))
 431
 432 BOOLEAN
 433 STDCALL
 434 ExIsProcessorFeaturePresent (
 435         IN      ULONG   ProcessorFeature
 436         );
 437
 438 BOOLEAN
 439 STDCALL
 440 ExIsResourceAcquiredExclusiveLite (
 441         PERESOURCE      Resource
 442         );
 443
 444 /* was ULONG */
 445 USHORT
 446 STDCALL
 447 ExIsResourceAcquiredSharedLite (
 448         PERESOURCE      Resource
 449         );
 450
 451 VOID
 452 STDCALL
 453 ExLocalTimeToSystemTime (
 454         PLARGE_INTEGER  LocalTime,
 455         PLARGE_INTEGER  SystemTime
 456         );
 457
 458 VOID
 459 STDCALL
 460 ExNotifyCallback (
 461         IN      PCALLBACK_OBJECT        CallbackObject,
 462         IN      PVOID   Argument1,
 463         IN      PVOID   Argument2
 464         );
 465
 466 VOID
 467 STDCALL
 468 ExPostSystemEvent (
 469         ULONG   Unknown1,
 470         ULONG   Unknown2,
 471         ULONG   Unknown3
 472         );
 473
 474 /*
 475  * USHORT
 476  * ExQueryDepthSList (
 477  *      PSLIST_HEADER   SListHead
 478  *      );
 479  */
 480 #define ExQueryDepthSList(ListHead) \
 481         (USHORT)(ListHead)->Depth
 482
 483 VOID
 484 STDCALL
 485 ExQueueWorkItem (
 486         PWORK_QUEUE_ITEM        WorkItem,
 487         WORK_QUEUE_TYPE         QueueType
 488         );
 489 VOID
 490 STDCALL
 491 ExRaiseAccessViolation (
 492         VOID
 493         );
 494 VOID
 495 STDCALL
 496 ExRaiseDatatypeMisalignment (
 497         VOID
 498         );
 499 VOID
 500 STDCALL
 501 ExRaiseStatus (
 502         NTSTATUS        Status
 503         );
 504
 505 PVOID
 506 STDCALL
 507 ExRegisterCallback (
 508         IN      PCALLBACK_OBJECT        CallbackObject,
 509         IN      PCALLBACK_FUNCTION      CallbackFunction,
 510         IN      PVOID                   CallbackContext
 511         );
 512
 513 VOID
 514 STDCALL
 515 ExReinitializeResourceLite (
 516         PERESOURCE      Resource
 517         );
 518 /* ReactOS Specific: begin */
 519 VOID
 520 FASTCALL
 521 ExReleaseFastMutex (
 522         PFAST_MUTEX     Mutex
 523         );
 524 /* ReactOS Specific: end */
 525 VOID
 526 FASTCALL
 527 ExReleaseFastMutexUnsafe (
 528         PFAST_MUTEX     Mutex
 529         );
 530 /*
 531 VOID
 532 STDCALL
 533 ExReleaseResource (
 534         PERESOURCE      Resource
 535         );
 536 */
 537 #define ExReleaseResource(Resource) \
 538         (ExReleaseResourceLite (Resource))
 539
 540 VOID
 541 FASTCALL
 542 ExReleaseResourceLite (
 543         PERESOURCE      Resource
 544         );
 545 VOID
 546 STDCALL
 547 ExReleaseResourceForThread (
 548         PERESOURCE              Resource,
 549         ERESOURCE_THREAD        ResourceThreadId
 550         );
 551 VOID
 552 STDCALL
 553 ExReleaseResourceForThreadLite (
 554         PERESOURCE              Resource,
 555         ERESOURCE_THREAD        ResourceThreadId
 556         );
 557
 558 VOID
 559 STDCALL
 560 ExSetResourceOwnerPointer (
 561         IN      PERESOURCE      Resource,
 562         IN      PVOID           OwnerPointer
 563         );
 564
 565 VOID
 566 STDCALL
 567 ExSystemTimeToLocalTime (
 568         PLARGE_INTEGER  SystemTime,
 569         PLARGE_INTEGER  LocalTime
 570         );
 571
 572 BOOLEAN
 573 FASTCALL
 574 ExTryToAcquireFastMutex (
 575         PFAST_MUTEX     FastMutex
 576         );
 577
 578 BOOLEAN
 579 STDCALL
 580 ExTryToAcquireResourceExclusiveLite (
 581         PERESOURCE      Resource
 582         );
 583
 584 VOID
 585 STDCALL
 586 ExUnregisterCallback (
 587         IN      PVOID   CallbackRegistration
 588         );
 589
 590 PSLIST_ENTRY
 591 FASTCALL
 592 InterlockedPopEntrySList (
 593   IN PSLIST_HEADER ListHead
 594   );
 595
 596 PSLIST_ENTRY
 597 FASTCALL
 598 InterlockedPushEntrySList(
 599   IN PSLIST_HEADER ListHead,
 600   IN PSLIST_ENTRY ListEntry
 601   );
 602
 603 /*
 604  * PVOID
 605  * ExAllocateFromNPagedLookasideList (
 606  *      PNPAGED_LOOKASIDE_LIST  LookSide
 607  *      );
 608  *
 609  * FUNCTION:
 610  *      Removes (pops) the first entry from the specified nonpaged
 611  *      lookaside list.
 612  *
 613  * ARGUMENTS:
 614  *      Lookaside = Pointer to a nonpaged lookaside list
 615  *
 616  * RETURNS:
 617  *      Address of the allocated list entry
 618  */
 619 static
 620 inline
 621 PVOID
 622 ExAllocateFromNPagedLookasideList (
 623         IN      PNPAGED_LOOKASIDE_LIST  Lookaside
 624         )
 625 {
 626         PVOID Entry;
 627
 628         Lookaside->TotalAllocates++;
 629         Entry = ExInterlockedPopEntrySList (&Lookaside->ListHead,
 630                                             &Lookaside->Obsoleted);
 631         if (Entry == NULL)
 632         {
 633                 Lookaside->AllocateMisses++;
 634                 Entry = (Lookaside->Allocate)(Lookaside->Type,
 635                                               Lookaside->Size,
 636                                               Lookaside->Tag);
 637         }
 638
 639   return Entry;
 640 }
 641
 642 static inline PVOID
 643 ExAllocateFromPagedLookasideList(
 644   IN PPAGED_LOOKASIDE_LIST  Lookaside)
 645 {
 646   PVOID Entry;
 647
 648   Lookaside->TotalAllocates++;
 649   Entry = InterlockedPopEntrySList(&Lookaside->ListHead);
 650   if (Entry == NULL) {
 651     Lookaside->AllocateMisses++;
 652     Entry = (Lookaside->Allocate)(Lookaside->Type,
 653       Lookaside->Size, Lookaside->Tag);
 654   }
 655   return Entry;
 656 }
 657
 658 VOID
 659 STDCALL
 660 ExDeleteNPagedLookasideList (
 661         PNPAGED_LOOKASIDE_LIST  Lookaside
 662         );
 663
 664 VOID
 665 STDCALL
 666 ExDeletePagedLookasideList (
 667         PPAGED_LOOKASIDE_LIST   Lookaside
 668         );
 669
 670
 671 /*
 672  * VOID
 673  * ExFreeToNPagedLookasideList (
 674  *      PNPAGED_LOOKASIDE_LIST  Lookaside,
 675  *      PVOID                   Entry
 676  *      );
 677  *
 678  * FUNCTION:
 679  *      Inserts (pushes) the specified entry into the specified
 680  *      nonpaged lookaside list.
 681  *
 682  * ARGUMENTS:
 683  *      Lookaside = Pointer to the nonpaged lookaside list
 684  *      Entry = Pointer to the entry that is inserted in the lookaside list
 685  */
 686 static
 687 inline
 688 VOID
 689 ExFreeToNPagedLookasideList (
 690         IN      PNPAGED_LOOKASIDE_LIST  Lookaside,
 691         IN      PVOID                   Entry
 692         )
 693 {
 694         Lookaside->TotalFrees++;
 695         if (ExQueryDepthSList (&Lookaside->ListHead) >= Lookaside->Depth)
 696         {
 697                 Lookaside->FreeMisses++;
 698                 (Lookaside->Free)(Entry);
 699         }
 700         else
 701         {
 702                 ExInterlockedPushEntrySList (&Lookaside->ListHead,
 703                                              (PSINGLE_LIST_ENTRY)Entry,
 704                                              &Lookaside->Obsoleted);
 705         }
 706 }
 707
 708 static inline VOID
 709 ExFreeToPagedLookasideList(
 710   IN PPAGED_LOOKASIDE_LIST  Lookaside,
 711   IN PVOID  Entry)
 712 {
 713   Lookaside->TotalFrees++;
 714   if (ExQueryDepthSList(&Lookaside->ListHead) >= Lookaside->Depth) {
 715     Lookaside->FreeMisses++;
 716     (Lookaside->Free)(Entry);
 717   } else {
 718     InterlockedPushEntrySList(&Lookaside->ListHead, (PSLIST_ENTRY)Entry);
 719   }
 720 }
 721
 722 VOID
 723 STDCALL
 724 ExInitializeNPagedLookasideList (
 725         PNPAGED_LOOKASIDE_LIST  Lookaside,
 726         PALLOCATE_FUNCTION      Allocate,
 727         PFREE_FUNCTION          Free,
 728         ULONG                   Flags,
 729         ULONG                   Size,
 730         ULONG                   Tag,
 731         USHORT                  Depth
 732         );
 733
 734 VOID
 735 STDCALL
 736 ExInitializePagedLookasideList (
 737         PPAGED_LOOKASIDE_LIST   Lookaside,
 738         PALLOCATE_FUNCTION      Allocate,
 739         PFREE_FUNCTION          Free,
 740         ULONG                   Flags,
 741         ULONG                   Size,
 742         ULONG                   Tag,
 743         USHORT                  Depth
 744         );
 745
 746 ULONG FASTCALL
 747 ExfInterlockedAddUlong(IN PULONG Addend,
 748                        IN ULONG Increment,
 749                        IN PKSPIN_LOCK Lock);
 750
 751 PLIST_ENTRY FASTCALL
 752 ExfInterlockedInsertHeadList(IN PLIST_ENTRY ListHead,
 753                              IN PLIST_ENTRY ListEntry,
 754                              IN PKSPIN_LOCK Lock);
 755
 756 PLIST_ENTRY FASTCALL
 757 ExfInterlockedInsertTailList(IN PLIST_ENTRY ListHead,
 758                              IN PLIST_ENTRY ListEntry,
 759                              IN PKSPIN_LOCK Lock);
 760
 761 PSINGLE_LIST_ENTRY FASTCALL
 762 ExfInterlockedPopEntryList(IN PSINGLE_LIST_ENTRY ListHead,
 763                            IN PKSPIN_LOCK Lock);
 764
 765 PSINGLE_LIST_ENTRY FASTCALL
 766 ExfInterlockedPushEntryList(IN PSINGLE_LIST_ENTRY ListHead,
 767                             IN PSINGLE_LIST_ENTRY ListEntry,
 768                             IN PKSPIN_LOCK Lock);
 769
 770 PLIST_ENTRY FASTCALL
 771 ExfInterlockedRemoveHeadList(IN PLIST_ENTRY Head,
 772                              IN PKSPIN_LOCK Lock);
 773
 774 INTERLOCKED_RESULT FASTCALL
 775 Exfi386InterlockedIncrementLong(IN PLONG Addend);
 776
 777 INTERLOCKED_RESULT FASTCALL
 778 Exfi386InterlockedDecrementLong(IN PLONG Addend);
 779
 780 ULONG FASTCALL
 781 Exfi386InterlockedExchangeUlong(IN PULONG Target,
 782                                 IN ULONG Value);
 783
 784 INTERLOCKED_RESULT STDCALL
 785 Exi386InterlockedIncrementLong(IN PLONG Addend);
 786
 787 INTERLOCKED_RESULT STDCALL
 788 Exi386InterlockedDecrementLong(IN PLONG Addend);
 789
 790 ULONG STDCALL
 791 Exi386InterlockedExchangeUlong(IN PULONG Target,
 792                                IN ULONG Value);
 793
 794
 795 LONG
 796 FASTCALL
 797 InterlockedCompareExchange (
 798         PLONG   Destination,
 799         LONG    Exchange,
 800         LONG    Comperand
 801         );
 802
 803 #ifdef _GNU_H_WINDOWS_H
 804 #ifdef InterlockedDecrement
 805 #undef InterlockedDecrement
 806 #undef InterlockedExchange
 807 #undef InterlockedExchangeAdd
 808 #undef InterlockedIncrement
 809 #endif /* def InterlockedDecrement */
 810 #endif /* def _GNU_H_WINDOWS_H */
 811 LONG
 812 FASTCALL
 813 InterlockedDecrement (
 814         PLONG   Addend
 815         );
 816 LONG
 817 FASTCALL
 818 InterlockedExchange (
 819         PLONG   Target,
 820         LONG    Value
 821         );
 822 LONG
 823 FASTCALL
 824 InterlockedExchangeAdd (
 825         PLONG   Addend,
 826         LONG    Value
 827         );
 828 LONG
 829 FASTCALL
 830 InterlockedIncrement (
 831         PLONG   Addend
 832         );
 833
 834 #ifndef InterlockedExchangePointer
 835 #define InterlockedExchangePointer(__T__, __V__) \
 836  (PVOID)InterlockedExchange((PLONG)(__T__), (LONG)(__V__))
 837 #endif
 838
 839 /*---*/
 840
 841 typedef
 842 unsigned int
 843 (exception_hook) (
 844         CONTEXT         * c,
 845         unsigned int    exp
 846         );
 847 unsigned int
 848 ExHookException (
 849         exception_hook  fn,
 850         unsigned int    exp
 851         );
 852
 853 #endif /* ndef _NTOS_EXFUNCS_H */