reactos/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, WorkerRoutine, RoutineContext) \
 260         ASSERT_IRQL(DISPATCH_LEVEL); \
 261         (Item)->Routine = (WorkerRoutine); \
 262         (Item)->Context = (RoutineContext); \
 263         (Item)->Entry.Flink = NULL; \
 264         (Item)->Entry.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 ULONG
 445 STDCALL
 446 ExIsResourceAcquiredSharedLite (
 447         PERESOURCE      Resource
 448         );
 449
 450 VOID
 451 STDCALL
 452 ExLocalTimeToSystemTime (
 453         PLARGE_INTEGER  LocalTime,
 454         PLARGE_INTEGER  SystemTime
 455         );
 456
 457 VOID
 458 STDCALL
 459 ExNotifyCallback (
 460         IN      PCALLBACK_OBJECT        CallbackObject,
 461         IN      PVOID   Argument1,
 462         IN      PVOID   Argument2
 463         );
 464
 465 VOID
 466 STDCALL
 467 ExPostSystemEvent (
 468         ULONG   Unknown1,
 469         ULONG   Unknown2,
 470         ULONG   Unknown3
 471         );
 472
 473 /*
 474  * USHORT
 475  * ExQueryDepthSList (
 476  *      PSLIST_HEADER   SListHead
 477  *      );
 478  */
 479 #define ExQueryDepthSList(ListHead) \
 480         (USHORT)(ListHead)->s.Depth
 481
 482 VOID
 483 STDCALL
 484 ExQueueWorkItem (
 485         PWORK_QUEUE_ITEM        WorkItem,
 486         WORK_QUEUE_TYPE         QueueType
 487         );
 488 VOID
 489 STDCALL
 490 ExRaiseAccessViolation (
 491         VOID
 492         );
 493 VOID
 494 STDCALL
 495 ExRaiseDatatypeMisalignment (
 496         VOID
 497         );
 498 VOID
 499 STDCALL
 500 ExRaiseStatus (
 501         NTSTATUS        Status
 502         );
 503
 504 PVOID
 505 STDCALL
 506 ExRegisterCallback (
 507         IN      PCALLBACK_OBJECT        CallbackObject,
 508         IN      PCALLBACK_FUNCTION      CallbackFunction,
 509         IN      PVOID                   CallbackContext
 510         );
 511
 512 VOID
 513 STDCALL
 514 ExReinitializeResourceLite (
 515         PERESOURCE      Resource
 516         );
 517 /* ReactOS Specific: begin */
 518 VOID
 519 FASTCALL
 520 ExReleaseFastMutex (
 521         PFAST_MUTEX     Mutex
 522         );
 523 /* ReactOS Specific: end */
 524 VOID
 525 FASTCALL
 526 ExReleaseFastMutexUnsafe (
 527         PFAST_MUTEX     Mutex
 528         );
 529 /*
 530 VOID
 531 STDCALL
 532 ExReleaseResource (
 533         PERESOURCE      Resource
 534         );
 535 */
 536 #define ExReleaseResource(Resource) \
 537         (ExReleaseResourceLite (Resource))
 538
 539 VOID
 540 FASTCALL
 541 ExReleaseResourceLite (
 542         PERESOURCE      Resource
 543         );
 544 VOID
 545 STDCALL
 546 ExReleaseResourceForThread (
 547         PERESOURCE              Resource,
 548         ERESOURCE_THREAD        ResourceThreadId
 549         );
 550 VOID
 551 STDCALL
 552 ExReleaseResourceForThreadLite (
 553         PERESOURCE              Resource,
 554         ERESOURCE_THREAD        ResourceThreadId
 555         );
 556
 557 VOID
 558 STDCALL
 559 ExSetResourceOwnerPointer (
 560         IN      PERESOURCE      Resource,
 561         IN      PVOID           OwnerPointer
 562         );
 563
 564 VOID
 565 STDCALL
 566 ExSystemTimeToLocalTime (
 567         PLARGE_INTEGER  SystemTime,
 568         PLARGE_INTEGER  LocalTime
 569         );
 570
 571 BOOLEAN
 572 FASTCALL
 573 ExTryToAcquireFastMutex (
 574         PFAST_MUTEX     FastMutex
 575         );
 576
 577 BOOLEAN
 578 STDCALL
 579 ExTryToAcquireResourceExclusiveLite (
 580         PERESOURCE      Resource
 581         );
 582
 583 VOID
 584 STDCALL
 585 ExUnregisterCallback (
 586         IN      PVOID   CallbackRegistration
 587         );
 588
 589 PSLIST_ENTRY
 590 FASTCALL
 591 InterlockedPopEntrySList (
 592   IN PSLIST_HEADER ListHead
 593   );
 594
 595 PSLIST_ENTRY
 596 FASTCALL
 597 InterlockedPushEntrySList(
 598   IN PSLIST_HEADER ListHead,
 599   IN PSLIST_ENTRY ListEntry
 600   );
 601
 602 /*
 603  * PVOID
 604  * ExAllocateFromNPagedLookasideList (
 605  *      PNPAGED_LOOKASIDE_LIST  LookSide
 606  *      );
 607  *
 608  * FUNCTION:
 609  *      Removes (pops) the first entry from the specified nonpaged
 610  *      lookaside list.
 611  *
 612  * ARGUMENTS:
 613  *      Lookaside = Pointer to a nonpaged lookaside list
 614  *
 615  * RETURNS:
 616  *      Address of the allocated list entry
 617  */
 618 static
 619 inline
 620 PVOID
 621 ExAllocateFromNPagedLookasideList (
 622         IN      PNPAGED_LOOKASIDE_LIST  Lookaside
 623         )
 624 {
 625         PVOID Entry;
 626
 627         Lookaside->TotalAllocates++;
 628         Entry = ExInterlockedPopEntrySList (&Lookaside->ListHead,
 629                                             &Lookaside->Obsoleted);
 630         if (Entry == NULL)
 631         {
 632                 Lookaside->AllocateMisses++;
 633                 Entry = (Lookaside->Allocate)(Lookaside->Type,
 634                                               Lookaside->Size,
 635                                               Lookaside->Tag);
 636         }
 637
 638   return Entry;
 639 }
 640
 641 static inline PVOID
 642 ExAllocateFromPagedLookasideList(
 643   IN PPAGED_LOOKASIDE_LIST  Lookaside)
 644 {
 645   PVOID Entry;
 646
 647   Lookaside->TotalAllocates++;
 648   Entry = InterlockedPopEntrySList(&Lookaside->ListHead);
 649   if (Entry == NULL) {
 650     Lookaside->AllocateMisses++;
 651     Entry = (Lookaside->Allocate)(Lookaside->Type,
 652       Lookaside->Size, Lookaside->Tag);
 653   }
 654   return Entry;
 655 }
 656
 657 VOID
 658 STDCALL
 659 ExDeleteNPagedLookasideList (
 660         PNPAGED_LOOKASIDE_LIST  Lookaside
 661         );
 662
 663 VOID
 664 STDCALL
 665 ExDeletePagedLookasideList (
 666         PPAGED_LOOKASIDE_LIST   Lookaside
 667         );
 668
 669
 670 /*
 671  * VOID
 672  * ExFreeToNPagedLookasideList (
 673  *      PNPAGED_LOOKASIDE_LIST  Lookaside,
 674  *      PVOID                   Entry
 675  *      );
 676  *
 677  * FUNCTION:
 678  *      Inserts (pushes) the specified entry into the specified
 679  *      nonpaged lookaside list.
 680  *
 681  * ARGUMENTS:
 682  *      Lookaside = Pointer to the nonpaged lookaside list
 683  *      Entry = Pointer to the entry that is inserted in the lookaside list
 684  */
 685 static
 686 inline
 687 VOID
 688 ExFreeToNPagedLookasideList (
 689         IN      PNPAGED_LOOKASIDE_LIST  Lookaside,
 690         IN      PVOID                   Entry
 691         )
 692 {
 693         Lookaside->TotalFrees++;
 694         if (ExQueryDepthSList (&Lookaside->ListHead) >= Lookaside->Depth)
 695         {
 696                 Lookaside->FreeMisses++;
 697                 (Lookaside->Free)(Entry);
 698         }
 699         else
 700         {
 701                 ExInterlockedPushEntrySList (&Lookaside->ListHead,
 702                                              (PSINGLE_LIST_ENTRY)Entry,
 703                                              &Lookaside->Obsoleted);
 704         }
 705 }
 706
 707 static inline VOID
 708 ExFreeToPagedLookasideList(
 709   IN PPAGED_LOOKASIDE_LIST  Lookaside,
 710   IN PVOID  Entry)
 711 {
 712   Lookaside->TotalFrees++;
 713   if (ExQueryDepthSList(&Lookaside->ListHead) >= Lookaside->Depth) {
 714     Lookaside->FreeMisses++;
 715     (Lookaside->Free)(Entry);
 716   } else {
 717     InterlockedPushEntrySList(&Lookaside->ListHead, (PSLIST_ENTRY)Entry);
 718   }
 719 }
 720
 721 VOID
 722 STDCALL
 723 ExInitializeNPagedLookasideList (
 724         PNPAGED_LOOKASIDE_LIST  Lookaside,
 725         PALLOCATE_FUNCTION      Allocate,
 726         PFREE_FUNCTION          Free,
 727         ULONG                   Flags,
 728         ULONG                   Size,
 729         ULONG                   Tag,
 730         USHORT                  Depth
 731         );
 732
 733 VOID
 734 STDCALL
 735 ExInitializePagedLookasideList (
 736         PPAGED_LOOKASIDE_LIST   Lookaside,
 737         PALLOCATE_FUNCTION      Allocate,
 738         PFREE_FUNCTION          Free,
 739         ULONG                   Flags,
 740         ULONG                   Size,
 741         ULONG                   Tag,
 742         USHORT                  Depth
 743         );
 744
 745 ULONG FASTCALL
 746 ExfInterlockedAddUlong(IN PULONG Addend,
 747                        IN ULONG Increment,
 748                        IN PKSPIN_LOCK Lock);
 749
 750 PLIST_ENTRY FASTCALL
 751 ExfInterlockedInsertHeadList(IN PLIST_ENTRY ListHead,
 752                              IN PLIST_ENTRY ListEntry,
 753                              IN PKSPIN_LOCK Lock);
 754
 755 PLIST_ENTRY FASTCALL
 756 ExfInterlockedInsertTailList(IN PLIST_ENTRY ListHead,
 757                              IN PLIST_ENTRY ListEntry,
 758                              IN PKSPIN_LOCK Lock);
 759
 760 PSINGLE_LIST_ENTRY FASTCALL
 761 ExfInterlockedPopEntryList(IN PSINGLE_LIST_ENTRY ListHead,
 762                            IN PKSPIN_LOCK Lock);
 763
 764 PSINGLE_LIST_ENTRY FASTCALL
 765 ExfInterlockedPushEntryList(IN PSINGLE_LIST_ENTRY ListHead,
 766                             IN PSINGLE_LIST_ENTRY ListEntry,
 767                             IN PKSPIN_LOCK Lock);
 768
 769 PLIST_ENTRY FASTCALL
 770 ExfInterlockedRemoveHeadList(IN PLIST_ENTRY Head,
 771                              IN PKSPIN_LOCK Lock);
 772
 773 INTERLOCKED_RESULT FASTCALL
 774 Exfi386InterlockedIncrementLong(IN PLONG Addend);
 775
 776 INTERLOCKED_RESULT FASTCALL
 777 Exfi386InterlockedDecrementLong(IN PLONG Addend);
 778
 779 ULONG FASTCALL
 780 Exfi386InterlockedExchangeUlong(IN PULONG Target,
 781                                 IN ULONG Value);
 782
 783 INTERLOCKED_RESULT STDCALL
 784 Exi386InterlockedIncrementLong(IN PLONG Addend);
 785
 786 INTERLOCKED_RESULT STDCALL
 787 Exi386InterlockedDecrementLong(IN PLONG Addend);
 788
 789 ULONG STDCALL
 790 Exi386InterlockedExchangeUlong(IN PULONG Target,
 791                                IN ULONG Value);
 792
 793
 794 LONG
 795 FASTCALL
 796 InterlockedCompareExchange (
 797         PLONG   Destination,
 798         LONG    Exchange,
 799         LONG    Comperand
 800         );
 801
 802 #ifdef _GNU_H_WINDOWS_H
 803 #ifdef InterlockedDecrement
 804 #undef InterlockedDecrement
 805 #undef InterlockedExchange
 806 #undef InterlockedExchangeAdd
 807 #undef InterlockedIncrement
 808 #endif /* def InterlockedDecrement */
 809 #endif /* def _GNU_H_WINDOWS_H */
 810 LONG
 811 FASTCALL
 812 InterlockedDecrement (
 813         PLONG   Addend
 814         );
 815 LONG
 816 FASTCALL
 817 InterlockedExchange (
 818         PLONG   Target,
 819         LONG    Value
 820         );
 821 LONG
 822 FASTCALL
 823 InterlockedExchangeAdd (
 824         PLONG   Addend,
 825         LONG    Value
 826         );
 827 LONG
 828 FASTCALL
 829 InterlockedIncrement (
 830         PLONG   Addend
 831         );
 832
 833 #ifndef InterlockedExchangePointer
 834 #define InterlockedExchangePointer(__T__, __V__) \
 835  (PVOID)InterlockedExchange((PLONG)(__T__), (LONG)(__V__))
 836 #endif
 837
 838 /*---*/
 839
 840 typedef
 841 unsigned int
 842 (exception_hook) (
 843         CONTEXT         * c,
 844         unsigned int    exp
 845         );
 846 unsigned int
 847 ExHookException (
 848         exception_hook  fn,
 849         unsigned int    exp
 850         );
 851
 852 #endif /* ndef _NTOS_EXFUNCS_H */