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