reactos/include/ddk/exfuncs.h

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