This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Classes | |
| union | _EXHANDLE |
| struct | _ETIMER |
| struct | SYSTEM_CALLBACKS |
| struct | _HARDERROR_USER_PARAMETERS |
| struct | _UUID_CACHED_VALUES_STRUCT |
Typedefs | |
| typedef enum _WINKD_WORKER_STATE | WINKD_WORKER_STATE |
| typedef union _EXHANDLE | EXHANDLE |
| typedef union _EXHANDLE * | PEXHANDLE |
| typedef struct _ETIMER | ETIMER |
| typedef struct _ETIMER * | PETIMER |
| typedef struct _HARDERROR_USER_PARAMETERS | HARDERROR_USER_PARAMETERS |
| typedef struct _HARDERROR_USER_PARAMETERS * | PHARDERROR_USER_PARAMETERS |
| typedef struct _UUID_CACHED_VALUES_STRUCT | UUID_CACHED_VALUES_STRUCT |
| typedef struct _UUID_CACHED_VALUES_STRUCT * | PUUID_CACHED_VALUES_STRUCT |
| typedef BOOLEAN(NTAPI * | PEX_SWEEP_HANDLE_CALLBACK) (PHANDLE_TABLE_ENTRY HandleTableEntry, HANDLE Handle, PVOID Context) |
| typedef BOOLEAN(NTAPI * | PEX_DUPLICATE_HANDLE_CALLBACK) (IN PEPROCESS Process, IN PHANDLE_TABLE HandleTable, IN PHANDLE_TABLE_ENTRY HandleTableEntry, IN PHANDLE_TABLE_ENTRY NewEntry) |
| typedef BOOLEAN(NTAPI * | PEX_CHANGE_HANDLE_CALLBACK) (PHANDLE_TABLE_ENTRY HandleTableEntry, ULONG_PTR Context) |
Enumerations | |
| enum | _WINKD_WORKER_STATE { WinKdWorkerReady = 0 , WinKdWorkerStart , WinKdWorkerInitialized } |
Macro Definition Documentation
◆ ExAcquireRundownProtection
| #define ExAcquireRundownProtection _ExAcquireRundownProtection |
◆ ExfInterlockedCompareExchange64UL
| #define ExfInterlockedCompareExchange64UL | ( | Destination, | |
| Exchange, | |||
| Comperand | |||
| ) | (ULONGLONG)ExfInterlockedCompareExchange64((PLONGLONG)(Destination), (PLONGLONG)(Exchange), (PLONGLONG)(Comperand)) |
◆ ExGetPreviousMode
| #define ExGetPreviousMode KeGetPreviousMode |
◆ EXHANDLE_TABLE_ENTRY_LOCK_BIT
◆ ExInitializePushLock
| #define ExInitializePushLock _ExInitializePushLock |
◆ ExInitializeRundownProtection
| #define ExInitializeRundownProtection _ExInitializeRundownProtection |
◆ ExpChangePushlock
◆ ExpChangeRundown
◆ ExpSetRundown
◆ ExReleaseRundownProtection
| #define ExReleaseRundownProtection _ExReleaseRundownProtection |
◆ ExRundownCompleted
| #define ExRundownCompleted _ExRundownCompleted |
◆ ExWaitForRundownProtectionRelease
| #define ExWaitForRundownProtectionRelease _ExWaitForRundownProtectionRelease |
◆ FREE_HANDLE_MASK
◆ HANDLE_HIGH_BITS
| #define HANDLE_HIGH_BITS (PAGE_SHIFT - 2) |
◆ HANDLE_INDEX_BITS
| #define HANDLE_INDEX_BITS (HANDLE_LOW_BITS + 2 * HANDLE_HIGH_BITS) |
◆ HANDLE_LOW_BITS
| #define HANDLE_LOW_BITS (PAGE_SHIFT - 3) |
◆ HANDLE_TAG_BITS
◆ HIGH_LEVEL_ENTRIES
| #define HIGH_LEVEL_ENTRIES (16777216 / (LOW_LEVEL_ENTRIES * MID_LEVEL_ENTRIES)) |
◆ InterlockedCompareExchangeSizeT
| #define InterlockedCompareExchangeSizeT | ( | Destination, | |
| Exchange, | |||
| Comperand | |||
| ) | (SIZE_T)InterlockedCompareExchangePointer((PVOID*)(Destination), (PVOID)(SIZE_T)(Exchange), (PVOID)(SIZE_T)(Comperand)) |
◆ InterlockedCompareExchangeUL
| #define InterlockedCompareExchangeUL | ( | Destination, | |
| Exchange, | |||
| Comperand | |||
| ) | (ULONG)InterlockedCompareExchange((PLONG)(Destination), (LONG)(Exchange), (LONG)(Comperand)) |
◆ InterlockedDecrementUL
◆ InterlockedExchangeAddUL
◆ InterlockedExchangeSizeT
◆ InterlockedExchangeUL
◆ InterlockedIncrementUL
◆ KERNEL_FLAG_BITS
| #define KERNEL_FLAG_BITS (sizeof(ULONG_PTR) * 8 - HANDLE_INDEX_BITS - HANDLE_TAG_BITS) |
◆ LOW_LEVEL_ENTRIES
| #define LOW_LEVEL_ENTRIES (PAGE_SIZE / sizeof(HANDLE_TABLE_ENTRY)) |
◆ MAX_FAST_REFS
◆ MAX_HIGH_INDEX
| #define MAX_HIGH_INDEX (MID_LEVEL_ENTRIES * MID_LEVEL_ENTRIES * LOW_LEVEL_ENTRIES) |
◆ MAX_LOW_INDEX
| #define MAX_LOW_INDEX LOW_LEVEL_ENTRIES |
◆ MAX_MID_INDEX
| #define MAX_MID_INDEX (MID_LEVEL_ENTRIES * LOW_LEVEL_ENTRIES) |
◆ MID_LEVEL_ENTRIES
| #define MID_LEVEL_ENTRIES (PAGE_SIZE / sizeof(PHANDLE_TABLE_ENTRY)) |
Typedef Documentation
◆ ETIMER
◆ EXHANDLE
◆ HARDERROR_USER_PARAMETERS
◆ PETIMER
◆ PEX_CHANGE_HANDLE_CALLBACK
| typedef BOOLEAN(NTAPI * PEX_CHANGE_HANDLE_CALLBACK) (PHANDLE_TABLE_ENTRY HandleTableEntry, ULONG_PTR Context) |
◆ PEX_DUPLICATE_HANDLE_CALLBACK
| typedef BOOLEAN(NTAPI * PEX_DUPLICATE_HANDLE_CALLBACK) (IN PEPROCESS Process, IN PHANDLE_TABLE HandleTable, IN PHANDLE_TABLE_ENTRY HandleTableEntry, IN PHANDLE_TABLE_ENTRY NewEntry) |
◆ PEX_SWEEP_HANDLE_CALLBACK
◆ PEXHANDLE
◆ PHARDERROR_USER_PARAMETERS
◆ PUUID_CACHED_VALUES_STRUCT
◆ UUID_CACHED_VALUES_STRUCT
◆ WINKD_WORKER_STATE
Enumeration Type Documentation
◆ _WINKD_WORKER_STATE
| Enumerator | |
|---|---|
| WinKdWorkerReady | |
| WinKdWorkerStart | |
| WinKdWorkerInitialized | |
Definition at line 60 of file ex.h.
61{
62 WinKdWorkerReady = 0,
63 WinKdWorkerStart,
65} WINKD_WORKER_STATE;
enum _WINKD_WORKER_STATE WINKD_WORKER_STATE
Function Documentation
◆ _ExAcquireFastMutex()
| FORCEINLINE VOID _ExAcquireFastMutex | ( | IN PFAST_MUTEX | FastMutex | ) |
Definition at line 1375 of file ex.h.
1376{
1379
1380 /* Raise IRQL to APC */
1382
1383 /* Decrease the count */
1385 {
1386 /* Someone is still holding it, use slow path */
1387 KiAcquireFastMutex(FastMutex);
1388 }
1389
1390 /* Set the owner and IRQL */
1391 FastMutex->Owner = KeGetCurrentThread();
1392 FastMutex->OldIrql = OldIrql;
1393}
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:778
Referenced by ExAcquireFastMutex().
◆ _ExAcquireFastMutexUnsafe()
| FORCEINLINE VOID _ExAcquireFastMutexUnsafe | ( | IN PFAST_MUTEX | FastMutex | ) |
Definition at line 1330 of file ex.h.
1331{
1333
1334 /* Sanity check */
1336 (Thread->CombinedApcDisable != 0) ||
1340
1341 /* Decrease the count */
1343 {
1344 /* Someone is still holding it, use slow path */
1345 KiAcquireFastMutex(FastMutex);
1346 }
1347
1348 /* Set the owner */
1349 FastMutex->Owner = Thread;
1350}
Definition: ketypes.h:1660
Definition: compat.h:836
Referenced by _ExEnterCriticalRegionAndAcquireFastMutexUnsafe(), and ExAcquireFastMutexUnsafe().
◆ _ExAcquireRundownProtection()
| FORCEINLINE BOOLEAN _ExAcquireRundownProtection | ( | IN PEX_RUNDOWN_REF | RunRef | ) |
Definition at line 820 of file ex.h.
821{
823
824 /* Get the current value and mask the active bit */
825 Value = RunRef->Count &~ EX_RUNDOWN_ACTIVE;
826
827 /* Add a reference */
829
830 /* Change the value */
833 {
834 /* Rundown was active, use long path */
836 }
837
838 /* Success */
840}
BOOLEAN FASTCALL ExfAcquireRundownProtection(IN OUT PEX_RUNDOWN_REF RunRef)
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:413
#define EX_RUNDOWN_COUNT_INC
Referenced by ExfAcquireRundownProtectionCacheAware().
◆ _ExEnterCriticalRegionAndAcquireFastMutexUnsafe()
| FORCEINLINE VOID _ExEnterCriticalRegionAndAcquireFastMutexUnsafe | ( | IN OUT PFAST_MUTEX | FastMutex | ) |
Definition at line 1446 of file ex.h.
1447{
1448 /* Enter the Critical Region */
1449 KeEnterCriticalRegion();
1450
1451 /* Acquire the mutex unsafely */
1452 _ExAcquireFastMutexUnsafe(FastMutex);
1453}
FORCEINLINE VOID _ExAcquireFastMutexUnsafe(IN PFAST_MUTEX FastMutex)
Definition: ex.h:1330
Referenced by ExEnterCriticalRegionAndAcquireFastMutexUnsafe().
◆ _ExInitializePushLock()
| FORCEINLINE VOID _ExInitializePushLock | ( | OUT PEX_PUSH_LOCK | PushLock | ) |
◆ _ExInitializeRundownProtection()
| FORCEINLINE VOID _ExInitializeRundownProtection | ( | IN PEX_RUNDOWN_REF | RunRef | ) |
Definition at line 904 of file ex.h.
905{
906 /* Set the count to zero */
907 RunRef->Count = 0;
908}
Referenced by ExAllocateCacheAwareRundownProtection(), and ExInitializeRundownProtectionCacheAware().
◆ _ExReleaseFastMutex()
| FORCEINLINE VOID _ExReleaseFastMutex | ( | IN OUT PFAST_MUTEX | FastMutex | ) |
Definition at line 1397 of file ex.h.
1398{
1401
1402 /* Erase the owner */
1403 FastMutex->Owner = NULL;
1405
1406 /* Increase the count */
1408 {
1409 /* Someone was waiting for it, signal the waiter */
1411 }
1412
1413 /* Lower IRQL back */
1415}
VOID NTAPI KeSetEventBoostPriority(IN PKEVENT Event, IN PKTHREAD *WaitingThread OPTIONAL)
Definition: eventobj.c:229
Referenced by ExReleaseFastMutex().
◆ _ExReleaseFastMutexUnsafe()
| FORCEINLINE VOID _ExReleaseFastMutexUnsafe | ( | IN OUT PFAST_MUTEX | FastMutex | ) |
Definition at line 1354 of file ex.h.
1355{
1357 (KeGetCurrentThread()->CombinedApcDisable != 0) ||
1361
1362 /* Erase the owner */
1363 FastMutex->Owner = NULL;
1364
1365 /* Increase the count */
1367 {
1368 /* Someone was waiting for it, signal the waiter */
1370 }
1371}
Referenced by _ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(), and ExReleaseFastMutexUnsafe().
◆ _ExReleaseFastMutexUnsafeAndLeaveCriticalRegion()
| FORCEINLINE VOID _ExReleaseFastMutexUnsafeAndLeaveCriticalRegion | ( | IN OUT PFAST_MUTEX | FastMutex | ) |
Definition at line 1457 of file ex.h.
1458{
1459 /* Release the mutex unsafely */
1460 _ExReleaseFastMutexUnsafe(FastMutex);
1461
1462 /* Leave the critical region */
1463 KeLeaveCriticalRegion();
1464}
FORCEINLINE VOID _ExReleaseFastMutexUnsafe(IN OUT PFAST_MUTEX FastMutex)
Definition: ex.h:1354
Referenced by ExReleaseFastMutexUnsafeAndLeaveCriticalRegion().
◆ _ExReleaseRundownProtection()
| FORCEINLINE VOID _ExReleaseRundownProtection | ( | IN PEX_RUNDOWN_REF | RunRef | ) |
Definition at line 861 of file ex.h.
862{
864
865 /* Get the current value and mask the active bit */
866 Value = RunRef->Count &~ EX_RUNDOWN_ACTIVE;
867
868 /* Remove a reference */
870
871 /* Change the value */
873
874 /* Check if the rundown was active */
876 {
877 /* Rundown was active, use long path */
878 ExfReleaseRundownProtection(RunRef);
879 }
880 else
881 {
882 /* Sanity check */
884 }
885}
VOID FASTCALL ExfReleaseRundownProtection(IN OUT PEX_RUNDOWN_REF RunRef)
Referenced by ExfReleaseRundownProtectionCacheAware().
◆ _ExRundownCompleted()
| FORCEINLINE VOID _ExRundownCompleted | ( | IN PEX_RUNDOWN_REF | RunRef | ) |
◆ _ExTryToAcquireFastMutex()
| FORCEINLINE BOOLEAN _ExTryToAcquireFastMutex | ( | IN OUT PFAST_MUTEX | FastMutex | ) |
Definition at line 1419 of file ex.h.
1420{
1423
1424 /* Raise to APC_LEVEL */
1426
1427 /* Check if we can quickly acquire it */
1429 {
1430 /* We have, set us as owners */
1431 FastMutex->Owner = KeGetCurrentThread();
1432 FastMutex->OldIrql = OldIrql;
1434 }
1435 else
1436 {
1437 /* Acquire attempt failed */
1439 YieldProcessor();
1441 }
1442}
Referenced by ExTryToAcquireFastMutex().
◆ _ExWaitForRundownProtectionRelease()
| FORCEINLINE VOID _ExWaitForRundownProtectionRelease | ( | IN PEX_RUNDOWN_REF | RunRef | ) |
Definition at line 928 of file ex.h.
929{
931
932 /* Set the active bit */
935 {
936 /* If the the rundown wasn't already active, then take the long path */
937 ExfWaitForRundownProtectionRelease(RunRef);
938 }
939}
VOID FASTCALL ExfWaitForRundownProtectionRelease(IN OUT PEX_RUNDOWN_REF RunRef)
◆ C_ASSERT()
| C_ASSERT | ( | RTL_FIELD_SIZE(UUID_CACHED_VALUES_STRUCT, GuidInit) | = =RTL_FIELD_SIZE(UUID, Data4) | ) |
◆ ExAcquireFastReference()
| FORCEINLINE EX_FAST_REF ExAcquireFastReference | ( | IN OUT PEX_FAST_REF | FastRef | ) |
Definition at line 617 of file ex.h.
618{
619 EX_FAST_REF OldValue, NewValue;
620
621 /* Start reference loop */
622 for (;;)
623 {
624 /* Get the current reference count */
625 OldValue = *FastRef;
627 {
628 /* Increase the reference count */
631 NewValue.Object,
632 OldValue.Object);
634 }
635
636 /* We are done */
637 break;
638 }
639
640 /* Return the old value */
641 return OldValue;
642}
Definition: extypes.h:419
Referenced by ExReferenceCallBackBlock(), ObFastReferenceObject(), and ObpReferenceSecurityDescriptor().
◆ ExAcquirePushLockExclusive()
| FORCEINLINE VOID ExAcquirePushLockExclusive | ( | PEX_PUSH_LOCK | PushLock | ) |
Definition at line 1036 of file ex.h.
1037{
1038 /* Try acquiring the lock */
1040 {
1041 /* Someone changed it, use the slow path */
1042 ExfAcquirePushLockExclusive(PushLock);
1043 }
1044
1045 /* Sanity check */
1046 ASSERT(PushLock->Locked);
1047}
VOID FASTCALL ExfAcquirePushLockExclusive(PEX_PUSH_LOCK PushLock)
Definition: pushlock.c:471
Referenced by CmLoadKey(), CmpAcquireKcbLockExclusiveByIndex(), CmpDestroyHive(), CmpInitializeHive(), CmpUnlinkHiveFromMaster(), ExCreateHandleTable(), ExDupHandleTable(), ExpAllocateHandleTableEntry(), ExRemoveHandleTable(), GDIOBJ_hInsertObject(), GDIOBJ_LockObject(), GdiPoolAllocate(), GdiPoolFree(), MiLockProcessWorkingSet(), MiLockProcessWorkingSetUnsafe(), MiLockWorkingSet(), NtUnloadKey2(), ObpAcquireDirectoryLockExclusive(), ObpSdAcquireLock(), PspCreateThread(), PspDeleteThread(), PspExitThread(), PspLockProcessSecurityExclusive(), PspLockThreadSecurityExclusive(), PsSetProcessWin32Process(), and TEXTOBJ_LockText().
◆ ExAcquirePushLockShared()
| FORCEINLINE VOID ExAcquirePushLockShared | ( | PEX_PUSH_LOCK | PushLock | ) |
Definition at line 1105 of file ex.h.
1106{
1107 EX_PUSH_LOCK NewValue;
1108
1109 /* Try acquiring the lock */
1112 {
1113 /* Someone changed it, use the slow path */
1114 ExfAcquirePushLockShared(PushLock);
1115 }
1116
1117 /* Sanity checks */
1119}
VOID FASTCALL ExfAcquirePushLockShared(PEX_PUSH_LOCK PushLock)
Definition: pushlock.c:645
Definition: extypes.h:454
Referenced by CmpDoFlushAll(), CmpDoFlushNextHive(), ExpAllocateHandleTableEntry(), MiLockProcessWorkingSetShared(), MiLockWorkingSetShared(), NtSetInformationProcess(), NtSetInformationThread(), ObpAcquireDirectoryLockShared(), ObpSdAcquireLockShared(), PsGetNextProcessThread(), PspLockProcessSecurityShared(), PspLockThreadSecurityShared(), and QSI_DEF().
◆ ExAcquireTimeRefreshLock()
Definition at line 145 of file time.c.
146{
147 /* Block APCs */
148 KeEnterCriticalRegion();
149
150 /* Attempt lock acquisition */
152 {
153 /* Lock was not acquired, enable APCs and fail */
154 KeLeaveCriticalRegion();
156 }
157
158 /* Lock has been acquired */
160}
#define ExAcquireResourceExclusiveLite(res, wait)
Definition: env_spec_w32.h:615
Referenced by ExSetTimerResolution(), and KdpTimeSlipWork().
◆ ExAllocateCallBack()
| PEX_CALLBACK_ROUTINE_BLOCK NTAPI ExAllocateCallBack | ( | IN PEX_CALLBACK_FUNCTION | Function, |
| IN PVOID | Context | ||
| ) |
Definition at line 54 of file callback.c.
56{
57 PEX_CALLBACK_ROUTINE_BLOCK CallbackBlock;
58
59 /* Allocate a callback */
63 if (CallbackBlock)
64 {
65 /* Initialize it */
69 }
70
71 /* Return it */
72 return CallbackBlock;
73}
_In_ CDROM_SCAN_FOR_SPECIAL_INFO _In_ PCDROM_SCAN_FOR_SPECIAL_HANDLER Function
Definition: cdrom.h:1156
Definition: compobj.c:4795
Definition: extypes.h:536
Referenced by PsSetCreateProcessNotifyRoutine(), PsSetCreateThreadNotifyRoutine(), PsSetLoadImageNotifyRoutine(), and TestPrivateFunctions().
◆ ExAllocateLocallyUniqueId()
Definition at line 335 of file uuid.c.
Referenced by NtAdjustGroupsToken(), NtAdjustPrivilegesToken(), NtAllocateLocallyUniqueId(), NtSetInformationToken(), SeCreateAccessStateEx(), SepCreateToken(), SepDuplicateToken(), and SepPerformTokenFiltering().
◆ ExBlockPushLock()
◆ ExChangeHandle()
| BOOLEAN NTAPI ExChangeHandle | ( | IN PHANDLE_TABLE | HandleTable, |
| IN HANDLE | Handle, | ||
| IN PEX_CHANGE_HANDLE_CALLBACK | ChangeRoutine, | ||
| IN ULONG_PTR | Context | ||
| ) |
Definition at line 1189 of file handle.c.
1193{
1194 EXHANDLE ExHandle;
1195 PHANDLE_TABLE_ENTRY HandleTableEntry;
1197 PAGED_CODE();
1198
1199 /* Set the handle value */
1201
1202 /* Find the entry for this handle */
1204
1205 /* Make sure that we found an entry, and that it's valid */
1206 if (!(HandleTableEntry) ||
1207 !(HandleTableEntry->Object) ||
1208 (HandleTableEntry->NextFreeTableEntry == -2))
1209 {
1210 /* It isn't, fail */
1212 }
1213
1214 /* Enter a critical region */
1215 KeEnterCriticalRegion();
1216
1217 /* Try locking the handle entry */
1219 {
1220 /* Call the change routine and unlock the entry */
1223 }
1224
1225 /* Leave the critical region and return the callback result */
1226 KeLeaveCriticalRegion();
1228}
PHANDLE_TABLE_ENTRY NTAPI ExpLookupHandleTableEntry(IN PHANDLE_TABLE HandleTable, IN EXHANDLE Handle)
Definition: handle.c:43
BOOLEAN NTAPI ExpLockHandleTableEntry(IN PHANDLE_TABLE HandleTable, IN PHANDLE_TABLE_ENTRY HandleTableEntry)
Definition: handle.c:884
VOID NTAPI ExUnlockHandleTableEntry(IN PHANDLE_TABLE HandleTable, IN PHANDLE_TABLE_ENTRY HandleTableEntry)
Definition: handle.c:923
Definition: extypes.h:596
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:409
Referenced by NtSetInformationObject(), and ObSetHandleAttributes().
◆ ExCompareExchangeCallBack()
| BOOLEAN NTAPI ExCompareExchangeCallBack | ( | IN OUT PEX_CALLBACK | CallBack, |
| IN PEX_CALLBACK_ROUTINE_BLOCK | NewBlock, | ||
| IN PEX_CALLBACK_ROUTINE_BLOCK | OldBlock | ||
| ) |
Definition at line 170 of file callback.c.
173{
174 EX_FAST_REF OldValue;
175 PEX_CALLBACK_ROUTINE_BLOCK CallbackBlock;
177
178 /* Check that we have a new block */
179 if (NewBlock)
180 {
181 /* Acquire rundown */
183 MAX_FAST_REFS + 1))
184 {
185 /* This should never happen */
188 }
189 }
190
191 /* Do the swap */
192 OldValue = ExCompareSwapFastReference(&CallBack->RoutineBlock,
193 NewBlock,
194 OldBlock);
195
196 /* Get the routine block */
197 CallbackBlock = ExGetObjectFastReference(OldValue);
199
200 /* Make sure the swap worked */
201 if (CallbackBlock == OldBlock)
202 {
203 /* Make sure we replaced a valid pointer */
204 if (CallbackBlock)
205 {
206 /* Acquire the flush lock and immediately release it */
207 KeEnterCriticalRegion();
209
210 /* Release rundown protection */
211 KeLeaveCriticalRegion();
213 Count + 1);
214 }
215
216 /* Compare worked */
218 }
219 else
220 {
221 /* It failed, check if we had a block */
222 if (NewBlock)
223 {
224 /* We did, remove the references that we had added */
225 ExfReleaseRundownProtectionEx(&NewBlock->RundownProtect,
226 MAX_FAST_REFS + 1);
227 }
228
229 /* Return failure */
231 }
232}
FORCEINLINE ULONG ExGetCountFastReference(IN EX_FAST_REF FastRef)
Definition: ex.h:588
FORCEINLINE EX_FAST_REF ExCompareSwapFastReference(IN PEX_FAST_REF FastRef, IN PVOID Object, IN PVOID OldObject)
Definition: ex.h:747
FORCEINLINE PVOID ExGetObjectFastReference(IN EX_FAST_REF FastRef)
Definition: ex.h:580
BOOLEAN FASTCALL ExfAcquireRundownProtectionEx(IN PEX_RUNDOWN_REF RunRef, IN ULONG Count)
Definition: rundown.c:78
VOID FASTCALL ExfReleaseRundownProtectionEx(IN PEX_RUNDOWN_REF RunRef, IN ULONG Count)
Definition: rundown.c:260
Referenced by PsRemoveCreateThreadNotifyRoutine(), PsRemoveLoadImageNotifyRoutine(), PsSetCreateProcessNotifyRoutine(), PsSetCreateThreadNotifyRoutine(), and PsSetLoadImageNotifyRoutine().
◆ ExCompareSwapFastReference()
| FORCEINLINE EX_FAST_REF ExCompareSwapFastReference | ( | IN PEX_FAST_REF | FastRef, |
| IN PVOID | Object, | ||
| IN PVOID | OldObject | ||
| ) |
Definition at line 747 of file ex.h.
750{
751 EX_FAST_REF OldValue, NewValue;
752
753 /* Sanity check and start swap loop */
755 for (;;)
756 {
757 /* Get the current value */
758 OldValue = *FastRef;
759
760 /* Make sure there's enough references to swap */
762
763 /* Check if we have an object to swap */
765 {
766 /* Set up the value with maximum fast references */
768 }
769 else
770 {
771 /* Write the object address itself (which is empty) */
773 }
774
775 /* Do the actual compare exchange */
777 NewValue.Object,
778 OldValue.Object);
780
781 /* All done */
782 break;
783 }
784
785 /* Return the old value */
786 return OldValue;
787}
Referenced by ExCompareExchangeCallBack(), and ObSetSecurityDescriptorInfo().
◆ ExConvertPushLockSharedToExclusive()
| FORCEINLINE BOOLEAN ExConvertPushLockSharedToExclusive | ( | IN PEX_PUSH_LOCK | PushLock | ) |
Definition at line 1139 of file ex.h.
1140{
1141 EX_PUSH_LOCK OldValue;
1142
1143 /* Set the expected old value */
1145
1146 /* Try converting the lock */
1148 OldValue.Ptr)
1149 {
1150 /* Conversion failed */
1152 }
1153
1154 /* Sanity check */
1155 ASSERT(PushLock->Locked);
1157}
Referenced by CmpTryToConvertKcbSharedToExclusive(), MiConvertSharedWorkingSetLockToExclusive(), and ObpLookupEntryDirectory().
◆ ExCreateHandle()
| HANDLE NTAPI ExCreateHandle | ( | IN PHANDLE_TABLE | HandleTable, |
| IN PHANDLE_TABLE_ENTRY | HandleTableEntry | ||
| ) |
Definition at line 827 of file handle.c.
829{
831 PHANDLE_TABLE_ENTRY NewEntry;
832 PAGED_CODE();
833
834 /* Start with a clean handle */
836
837 /* Allocate a new entry */
839 if (NewEntry)
840 {
841 /* Enter a critical region */
842 KeEnterCriticalRegion();
843
844 /* Write the entry */
845 *NewEntry = *HandleTableEntry;
846
847 /* Unlock it and leave the critical region */
849 KeLeaveCriticalRegion();
850 }
851
852 /* Return the handle value */
854}
PHANDLE_TABLE_ENTRY NTAPI ExpAllocateHandleTableEntry(IN PHANDLE_TABLE HandleTable, OUT PEXHANDLE NewHandle)
Definition: handle.c:683
Referenced by ObDuplicateObject(), ObpCreateHandle(), ObpCreateUnnamedHandle(), PspCreateProcess(), PspCreateThread(), and RtlpCreateAtomHandle().
◆ ExCreateHandleTable()
| PHANDLE_TABLE NTAPI ExCreateHandleTable | ( | IN PEPROCESS Process | OPTIONAL | ) |
Definition at line 801 of file handle.c.
802{
804 PAGED_CODE();
805
806 /* Allocate the handle table */
809
810 /* Acquire the handle table lock */
811 KeEnterCriticalRegion();
813
814 /* Insert it into the list */
816
817 /* Release the lock */
819 KeLeaveCriticalRegion();
820
821 /* Return the handle table */
823}
FORCEINLINE VOID ExAcquirePushLockExclusive(PEX_PUSH_LOCK PushLock)
Definition: ex.h:1036
FORCEINLINE VOID ExReleasePushLockExclusive(PEX_PUSH_LOCK PushLock)
Definition: ex.h:1252
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:223
PHANDLE_TABLE NTAPI ExpAllocateHandleTable(IN PEPROCESS Process OPTIONAL, IN BOOLEAN NewTable)
Definition: handle.c:331
Definition: extypes.h:617
Referenced by ObInitProcess(), ObInitSystem(), PspInitPhase0(), and RtlpCreateAtomHandleTable().
◆ ExDereferenceCallBackBlock()
| VOID NTAPI ExDereferenceCallBackBlock | ( | IN OUT PEX_CALLBACK | CallBack, |
| IN PEX_CALLBACK_ROUTINE_BLOCK | CallbackRoutineBlock | ||
| ) |
Definition at line 109 of file callback.c.
111{
112 /* Release a fast reference */
114 {
115 /* Take slow path */
116 ExReleaseRundownProtection(&CallbackBlock->RundownProtect);
117 }
118}
FORCEINLINE BOOLEAN ExReleaseFastReference(IN PEX_FAST_REF FastRef, IN PVOID Object)
Definition: ex.h:685
Referenced by ExDoCallBack(), PsRemoveCreateThreadNotifyRoutine(), PsRemoveLoadImageNotifyRoutine(), and PsSetCreateProcessNotifyRoutine().
◆ ExDestroyHandle()
| BOOLEAN NTAPI ExDestroyHandle | ( | IN PHANDLE_TABLE | HandleTable, |
| IN HANDLE | Handle, | ||
| IN PHANDLE_TABLE_ENTRY HandleTableEntry | OPTIONAL | ||
| ) |
Definition at line 984 of file handle.c.
987{
988 EXHANDLE ExHandle;
990 PAGED_CODE();
991
992 /* Setup the actual handle value */
994
995 /* Enter a critical region and check if we have to lookup the handle */
996 KeEnterCriticalRegion();
997 if (!HandleTableEntry)
998 {
999 /* Lookup the entry */
1001
1002 /* Make sure that we found an entry, and that it's valid */
1003 if (!(HandleTableEntry) ||
1004 !(HandleTableEntry->Object) ||
1005 (HandleTableEntry->NextFreeTableEntry == -2))
1006 {
1007 /* Invalid handle, fail */
1008 KeLeaveCriticalRegion();
1010 }
1011
1012 /* Lock the entry */
1014 {
1015 /* Couldn't lock, fail */
1016 KeLeaveCriticalRegion();
1018 }
1019 }
1020 else
1021 {
1022 /* Make sure the handle is locked */
1024 }
1025
1026 /* Clear the handle */
1028
1029 /* Sanity checks */
1032
1033 /* Unblock the pushlock */
1035
1036 /* Free the actual entry */
1038
1039 /* If we got here, return success */
1040 KeLeaveCriticalRegion();
1042}
Definition: nsiface.idl:2307
VOID NTAPI ExpFreeHandleTableEntry(IN PHANDLE_TABLE HandleTable, IN EXHANDLE Handle, IN PHANDLE_TABLE_ENTRY HandleTableEntry)
Definition: handle.c:279
VOID FASTCALL ExfUnblockPushLock(PEX_PUSH_LOCK PushLock, PVOID CurrentWaitBlock)
Definition: pushlock.c:1205
Referenced by ObpCloseHandleTableEntry(), PspDeleteProcess(), PspDeleteThread(), RtlpCloseHandleCallback(), RtlpCreateAtomHandle(), and RtlpFreeAtomHandle().
◆ ExDestroyHandleTable()
| VOID NTAPI ExDestroyHandleTable | ( | IN PHANDLE_TABLE | HandleTable, |
| IN PVOID DestroyHandleProcedure | OPTIONAL | ||
| ) |
Definition at line 963 of file handle.c.
965{
966 PAGED_CODE();
967
968 /* Remove the handle from the list */
970
971 /* Check if we have a destroy callback */
972 if (DestroyHandleProcedure)
973 {
974 /* FIXME: */
976 }
977
978 /* Free the handle table */
980}
VOID NTAPI ExRemoveHandleTable(IN PHANDLE_TABLE HandleTable)
Definition: handle.c:944
VOID NTAPI ExpFreeHandleTable(IN PHANDLE_TABLE HandleTable)
Definition: handle.c:202
Referenced by ObKillProcess(), and RtlpDestroyAtomHandleTable().
◆ ExDoCallBack()
| FORCEINLINE VOID ExDoCallBack | ( | IN OUT PEX_CALLBACK | Callback, |
| IN PVOID | Context, | ||
| IN PVOID | Argument1, | ||
| IN PVOID | Argument2 | ||
| ) |
Definition at line 553 of file ex.h.
557{
558 PEX_CALLBACK_ROUTINE_BLOCK CallbackBlock;
560
561 /* Reference the block */
563 if (CallbackBlock)
564 {
565 /* Get the function */
567
568 /* Do the callback */
570
571 /* Now dereference it */
573 }
574}
PEX_CALLBACK_FUNCTION NTAPI ExGetCallBackBlockRoutine(IN PEX_CALLBACK_ROUTINE_BLOCK CallbackRoutineBlock)
Definition: callback.c:93
PEX_CALLBACK_ROUTINE_BLOCK NTAPI ExReferenceCallBackBlock(IN OUT PEX_CALLBACK CallBack)
Definition: callback.c:122
VOID NTAPI ExDereferenceCallBackBlock(IN OUT PEX_CALLBACK CallBack, IN PEX_CALLBACK_ROUTINE_BLOCK CallbackRoutineBlock)
Definition: callback.c:109
Referenced by PspRunCreateProcessNotifyRoutines(), PspRunCreateThreadNotifyRoutines(), and PspRunLoadImageNotifyRoutines().
◆ ExDupHandleTable()
| PHANDLE_TABLE NTAPI ExDupHandleTable | ( | IN PEPROCESS | Process, |
| IN PHANDLE_TABLE | HandleTable, | ||
| IN PEX_DUPLICATE_HANDLE_CALLBACK | DupHandleProcedure, | ||
| IN ULONG_PTR | Mask | ||
| ) |
Definition at line 1072 of file handle.c.
1076{
1077 PHANDLE_TABLE NewTable;
1079 PHANDLE_TABLE_ENTRY HandleTableEntry, NewEntry;
1081 PAGED_CODE();
1082
1083 /* Allocate the duplicated copy */
1086
1087 /* Loop each entry */
1089 HandleTable->NextHandleNeedingPool)
1090 {
1091 /* Insert it into the duplicated copy */
1093 {
1094 /* Insert failed, free the new copy and return */
1095 ExpFreeHandleTable(NewTable);
1097 }
1098 }
1099
1100 /* Setup the initial handle table data */
1101 NewTable->HandleCount = 0;
1102 NewTable->ExtraInfoPages = 0;
1103 NewTable->FirstFree = 0;
1104
1105 /* Setup the first handle value */
1107
1108 /* Enter a critical region and lookup the new entry */
1109 KeEnterCriticalRegion();
1111 {
1112 /* Lookup the old entry */
1114
1115 /* Loop each entry */
1116 do
1117 {
1118 /* Check if it doesn't match the audit mask */
1120 {
1121 /* Free it since we won't use it */
1123 }
1124 else
1125 {
1126 /* Lock the entry */
1128 {
1129 /* Free it since we can't lock it, so we won't use it */
1131 }
1132 else
1133 {
1134 /* Copy the handle value */
1135 *NewEntry = *HandleTableEntry;
1136
1137 /* Call the duplicate callback */
1139 HandleTable,
1140 HandleTableEntry,
1141 NewEntry))
1142 {
1143 /* Clear failure flag */
1145
1146 /* Lock the entry, increase the handle count */
1148 NewTable->HandleCount++;
1149 }
1150 else
1151 {
1152 /* Duplication callback refused, fail */
1154 }
1155 }
1156 }
1157
1158 /* Check if we failed earlier and need to free */
1160 {
1161 /* Free this entry */
1163 NewEntry->NextFreeTableEntry = NewTable->FirstFree;
1165 }
1166
1167 /* Increase the handle value and move to the next entry */
1169 NewEntry++;
1170 HandleTableEntry++;
1172
1173 /* We're done, skip the last entry */
1175 }
1176
1177 /* Acquire the table lock and insert this new table into the list */
1181
1182 /* Leave the critical region we entered previously and return the table */
1183 KeLeaveCriticalRegion();
1184 return NewTable;
1185}
BOOLEAN NTAPI ExpAllocateHandleTableEntrySlow(IN PHANDLE_TABLE HandleTable, IN BOOLEAN DoInit)
Definition: handle.c:502
Referenced by ObInitProcess().
◆ ExfAcquireRundownProtection()
| BOOLEAN FASTCALL ExfAcquireRundownProtection | ( | IN OUT PEX_RUNDOWN_REF | RunRef | ) |
Referenced by _ExAcquireRundownProtection().
◆ ExfAcquireRundownProtectionEx()
◆ ExfInitializeRundownProtection()
| VOID FASTCALL ExfInitializeRundownProtection | ( | OUT PEX_RUNDOWN_REF | RunRef | ) |
◆ ExFreeCallBack()
| VOID NTAPI ExFreeCallBack | ( | IN PEX_CALLBACK_ROUTINE_BLOCK | CallbackRoutineBlock | ) |
Definition at line 77 of file callback.c.
78{
79 /* Just free it from memory */
81}
Referenced by PsRemoveCreateThreadNotifyRoutine(), PsRemoveLoadImageNotifyRoutine(), PsSetCreateProcessNotifyRoutine(), PsSetCreateThreadNotifyRoutine(), PsSetLoadImageNotifyRoutine(), and TestPrivateFunctions().
◆ ExfReInitializeRundownProtection()
| VOID FASTCALL ExfReInitializeRundownProtection | ( | OUT PEX_RUNDOWN_REF | RunRef | ) |
◆ ExfReleaseRundownProtection()
| VOID FASTCALL ExfReleaseRundownProtection | ( | IN OUT PEX_RUNDOWN_REF | RunRef | ) |
Referenced by _ExReleaseRundownProtection().
◆ ExfReleaseRundownProtectionEx()
◆ ExfRundownCompleted()
| VOID FASTCALL ExfRundownCompleted | ( | OUT PEX_RUNDOWN_REF | RunRef | ) |
◆ ExfUnblockPushLock()
◆ ExfWaitForRundownProtectionRelease()
| VOID FASTCALL ExfWaitForRundownProtectionRelease | ( | IN OUT PEX_RUNDOWN_REF | RunRef | ) |
Referenced by _ExWaitForRundownProtectionRelease().
◆ ExGetCallBackBlockContext()
| PVOID NTAPI ExGetCallBackBlockContext | ( | IN PEX_CALLBACK_ROUTINE_BLOCK | CallbackRoutineBlock | ) |
Definition at line 101 of file callback.c.
102{
103 /* Return the context */
104 return CallbackBlock->Context;
105}
◆ ExGetCallBackBlockRoutine()
| PEX_CALLBACK_FUNCTION NTAPI ExGetCallBackBlockRoutine | ( | IN PEX_CALLBACK_ROUTINE_BLOCK | CallbackRoutineBlock | ) |
Definition at line 93 of file callback.c.
94{
95 /* Return the function */
96 return CallbackBlock->Function;
97}
Referenced by ExDoCallBack(), PsRemoveCreateThreadNotifyRoutine(), PsRemoveLoadImageNotifyRoutine(), and PsSetCreateProcessNotifyRoutine().
◆ ExGetCountFastReference()
| FORCEINLINE ULONG ExGetCountFastReference | ( | IN EX_FAST_REF | FastRef | ) |
Definition at line 588 of file ex.h.
Referenced by ExCompareExchangeCallBack(), ExReferenceCallBackBlock(), ObDeassignSecurity(), ObFastReferenceObject(), ObFastReplaceObject(), ObpReferenceSecurityDescriptor(), and ObSetSecurityDescriptorInfo().
◆ ExGetObjectFastReference()
| FORCEINLINE PVOID ExGetObjectFastReference | ( | IN EX_FAST_REF | FastRef | ) |
Definition at line 580 of file ex.h.
Referenced by ExCompareExchangeCallBack(), ExReferenceCallBackBlock(), ObDeassignSecurity(), ObFastReferenceObject(), ObFastReferenceObjectLocked(), ObFastReplaceObject(), ObpReferenceSecurityDescriptor(), and ObSetSecurityDescriptorInfo().
◆ ExGetPoolTagInfo()
| NTSTATUS NTAPI ExGetPoolTagInfo | ( | IN PSYSTEM_POOLTAG_INFORMATION | SystemInformation, |
| IN ULONG | SystemInformationLength, | ||
| IN OUT PULONG ReturnLength | OPTIONAL | ||
| ) |
Definition at line 1356 of file expool.c.
1359{
1361 ULONG EntryCount;
1363 PSYSTEM_POOLTAG TagEntry;
1367
1368 //
1369 // Keep track of how much data the caller's buffer must hold
1370 //
1372
1373 //
1374 // Initialize the caller's buffer
1375 //
1376 TagEntry = &SystemInformation->TagInfo[0];
1377 SystemInformation->Count = 0;
1378
1379 //
1380 // Capture the number of entries, and the total size needed to make a copy
1381 // of the table
1382 //
1385
1386 //
1387 // Allocate the "Generic DPC" temporary buffer
1388 //
1391
1392 //
1393 // Do a "Generic DPC" to atomically retrieve the tag and allocation data
1394 //
1398 Context.PoolTrackTableSizeExpansion = 0;
1400
1401 //
1402 // Now parse the results
1403 //
1405 {
1406 //
1407 // If the entry is empty, skip it
1408 //
1410
1411 //
1412 // Otherwise, add one more entry to the caller's buffer, and ensure that
1413 // enough space has been allocated in it
1414 //
1415 SystemInformation->Count++;
1416 CurrentLength += sizeof(*TagEntry);
1417 if (SystemInformationLength < CurrentLength)
1418 {
1419 //
1420 // The caller's buffer is too small, so set a failure code. The
1421 // caller will know the count, as well as how much space is needed.
1422 //
1423 // We do NOT break out of the loop, because we want to keep incrementing
1424 // the Count as well as CurrentLength so that the caller can know the
1425 // final numbers
1426 //
1428 }
1429 else
1430 {
1431 //
1432 // Small sanity check that our accounting is working correctly
1433 //
1436
1437 //
1438 // Return the data into the caller's buffer
1439 //
1447 TagEntry++;
1448 }
1449 }
1450
1451 //
1452 // Free the "Generic DPC" temporary buffer, return the buffer length and status
1453 //
1457}
Definition: bufpool.h:45
VOID NTAPI KeGenericCallDpc(IN PKDEFERRED_ROUTINE Routine, IN PVOID Context)
Definition: dpc.c:1002
VOID NTAPI ExpGetPoolTagInfoTarget(IN PKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
Definition: expool.c:1321
struct _POOL_TRACKER_TABLE POOL_TRACKER_TABLE
Definition: expool.c:34
Definition: miarm.h:382
Definition: extypes.h:1150
Definition: extypes.h:1135
Referenced by QSI_DEF().
◆ ExGetRunRefForGivenProcessor()
| FORCEINLINE PEX_RUNDOWN_REF ExGetRunRefForGivenProcessor | ( | IN PEX_RUNDOWN_REF_CACHE_AWARE | RunRefCacheAware, |
| IN ULONG | ProcNumber | ||
| ) |
Definition at line 793 of file ex.h.
795{
797 RunRefCacheAware->RunRefSize *
798 (ProcNumber % RunRefCacheAware->Number));
799}
Definition: extypes.h:179
Referenced by ExAllocateCacheAwareRundownProtection(), ExfAcquireRundownProtectionCacheAware(), ExfAcquireRundownProtectionCacheAwareEx(), ExfReInitializeRundownProtectionCacheAware(), ExfReleaseRundownProtectionCacheAware(), ExfReleaseRundownProtectionCacheAwareEx(), ExfRundownCompletedCacheAware(), ExfWaitForRundownProtectionReleaseCacheAware(), and ExInitializeRundownProtectionCacheAware().
◆ ExInit2()
◆ ExInitializeCallBack()
| VOID NTAPI ExInitializeCallBack | ( | IN OUT PEX_CALLBACK | Callback | ) |
Definition at line 46 of file callback.c.
47{
48 /* Initialize the fast reference */
50}
FORCEINLINE VOID ExInitializeFastReference(OUT PEX_FAST_REF FastRef, IN OPTIONAL PVOID Object)
Definition: ex.h:596
Referenced by CmpInitCallback(), and PspInitPhase0().
◆ ExInitializeFastReference()
| FORCEINLINE VOID ExInitializeFastReference | ( | OUT PEX_FAST_REF | FastRef, |
| IN OPTIONAL PVOID | Object | ||
| ) |
Definition at line 596 of file ex.h.
598{
599 /* Sanity check */
601
602 /* Check if an object is being set */
604 {
605 /* Clear the field */
606 FastRef->Object = NULL;
607 }
608 else
609 {
610 /* Otherwise, we assume the object was referenced and is ready */
612 }
613}
Referenced by ExInitializeCallBack(), ObAssignObjectSecurityDescriptor(), and ObInitializeFastReference().
◆ ExInitializeSystemLookasideList()
| VOID NTAPI ExInitializeSystemLookasideList | ( | IN PGENERAL_LOOKASIDE | List, |
| IN POOL_TYPE | Type, | ||
| IN ULONG | Size, | ||
| IN ULONG | Tag, | ||
| IN USHORT | MaximumDepth, | ||
| IN PLIST_ENTRY | ListHead | ||
| ) |
Definition at line 31 of file lookas.c.
37{
38 /* Initialize the list */
43 List->MaximumDepth = MaximumDepth;
44 List->Depth = 2;
48 List->TotalAllocates = 0;
49 List->AllocateHits = 0;
50 List->TotalFrees = 0;
51 List->FreeHits = 0;
52 List->LastTotalAllocates = 0;
53 List->LastAllocateHits = 0;
54}
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
FORCEINLINE VOID InitializeSListHead(_Out_ PSLIST_HEADER SListHead)
Definition: rtlfuncs.h:3368
Referenced by ExpInitLookasideLists(), IopInitLookasideLists(), ObInit2(), and ObInitSystem().
◆ ExInitPoolLookasidePointers()
Definition at line 59 of file lookas.c.
60{
64
65 /* Loop for all pool lists */
67 {
68 /* Initialize the non-paged list */
71
72 /* Bind to PRCB */
75
76 /* Initialize the paged list */
79
80 /* Bind to PRCB */
83 }
84}
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GENERAL_LOOKASIDE ExpSmallNPagedPoolLookasideLists[NUMBER_POOL_LOOKASIDE_LISTS]
Definition: lookas.c:23
GENERAL_LOOKASIDE ExpSmallPagedPoolLookasideLists[NUMBER_POOL_LOOKASIDE_LISTS]
Definition: lookas.c:24
Definition: ketypes.h:629
GENERAL_LOOKASIDE_POOL PPPagedLookasideList[NUMBER_POOL_LOOKASIDE_LISTS]
Definition: ketypes.h:699
GENERAL_LOOKASIDE_POOL PPNPagedLookasideList[NUMBER_POOL_LOOKASIDE_LISTS]
Definition: ketypes.h:698
struct LOOKASIDE_ALIGN _GENERAL_LOOKASIDE * PGENERAL_LOOKASIDE
Referenced by ExpInitializeExecutive(), and KiSystemStartupBootStack().
◆ ExInsertFastReference()
| FORCEINLINE BOOLEAN ExInsertFastReference | ( | IN OUT PEX_FAST_REF | FastRef, |
| IN PVOID | Object | ||
| ) |
Definition at line 646 of file ex.h.
648{
649 EX_FAST_REF OldValue, NewValue;
650
651 /* Sanity checks */
653
654 /* Start update loop */
655 for (;;)
656 {
657 /* Get the current reference count */
658 OldValue = *FastRef;
659
660 /* Check if the current count is too high or if the pointer changed */
663 {
664 /* Fail */
666 }
667
668 /* Update the reference count */
671 NewValue.Object,
672 OldValue.Object);
674
675 /* We are done */
676 break;
677 }
678
679 /* Return success */
681}
Referenced by ExReferenceCallBackBlock(), ObFastReferenceObject(), and ObpReferenceSecurityDescriptor().
◆ ExLuidInitialization()
Definition at line 325 of file uuid.c.
Referenced by SepInitializationPhase0().
◆ ExMapHandleToPointer()
| PHANDLE_TABLE_ENTRY NTAPI ExMapHandleToPointer | ( | IN PHANDLE_TABLE | HandleTable, |
| IN HANDLE | Handle | ||
| ) |
Definition at line 1046 of file handle.c.
1048{
1049 EXHANDLE ExHandle;
1050 PHANDLE_TABLE_ENTRY HandleTableEntry;
1051 PAGED_CODE();
1052
1053 /* Set the handle value */
1055
1056 /* Fail if we got an invalid index */
1058
1059 /* Do the lookup */
1062
1063 /* Lock it */
1065
1066 /* Return the entry */
1067 return HandleTableEntry;
1068}
Referenced by NtWaitForMultipleObjects(), ObpCloseHandle(), ObpReferenceProcessObjectByHandle(), ObQueryObjectAuditingByHandle(), ObReferenceFileObjectForWrite(), ObReferenceObjectByHandle(), PsLookupProcessByProcessId(), PsLookupProcessThreadByCid(), PsLookupThreadByThreadId(), and RtlpGetAtomEntry().
◆ ExpDebuggerWorker()
Definition at line 52 of file dbgctrl.c.
53{
54 PEPROCESS ProcessToAttach, ProcessToKill;
55 ULONG_PTR PageInAddress;
58
60
61 /* Be sure we were started in an initialized state */
65 {
66 /* An error happened, so get a chance to restart proper */
68 return;
69 }
70
71 /* Get the processes to be attached or killed, and the address to page in */
72 ProcessToAttach = ExpDebuggerProcessAttach;
73 ProcessToKill = ExpDebuggerProcessKill;
74 PageInAddress = ExpDebuggerPageIn;
75
76 /* Reset the state machine to its ready state */
81
82 /* Default to the current process if we don't find the process to be attached or killed */
84
85 /* Check if we need to attach or kill some process */
87 {
88 /* Find the process in the list */
91 {
92 /* Is this the process we want to attach to? */
94 {
95 /* Yes, attach ourselves to it */
97 break;
98 }
99 /* Or is this the process we want to kill? */
101 {
102 /* Yes, kill and dereference it, then return */
105 return;
106 }
107
108 /* Get the next process */
110 }
111
112 /* We either have found a process, or we default to the current process */
113 }
114
115 /* If we have an address to page in... */
116 if (PageInAddress)
117 {
118 /* ... try to do it by attempting to read at this address */
119 _SEH2_TRY
120 {
121 ProbeForReadUchar(PageInAddress);
122 }
124 {
125 DPRINT1("Failed to page in address 0x%p, Status 0x%08lx\n", PageInAddress, _SEH2_GetExceptionCode());
126 }
127 _SEH2_END;
128 }
129
130 /* Break into the process (or the current one if Process == NULL) */
132
133 /* If we are attached to a process, not the current one... */
135 {
136 /* ... we can detach from the process */
138 /* Dereference the process which was referenced for us by PsGetNextProcess */
140 }
141}
VOID NTAPI KeStackAttachProcess(IN PKPROCESS Process, OUT PRKAPC_STATE ApcState)
Definition: procobj.c:704
VOID NTAPI KeUnstackDetachProcess(IN PRKAPC_STATE ApcState)
Definition: procobj.c:756
NTSTATUS NTAPI PsTerminateProcess(IN PEPROCESS Process, IN NTSTATUS ExitStatus)
Definition: kill.c:126
PEPROCESS NTAPI PsGetNextProcess(IN PEPROCESS OldProcess OPTIONAL)
Definition: process.c:128
Definition: pstypes.h:1262
__analysis_noreturn NTSYSAPI VOID NTAPI DbgBreakPointWithStatus(_In_ ULONG Status)
Referenced by ExpWorkerThreadBalanceManager().
◆ ExpInitializeCallbacks()
Definition at line 256 of file callback.c.
257{
261 UNICODE_STRING CallbackName;
263 OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
266
267 /* Setup lightweight callback lock */
269
270 /* Initialize the Callback Object type */
280 &ObjectTypeInitializer,
281 NULL,
282 &ExCallbackObjectType);
284
285 /* Initialize the Object */
287 &DirName,
289 NULL,
290 SePublicDefaultSd);
291
292 /* Create the Object Directory */
294 DIRECTORY_ALL_ACCESS,
295 &ObjectAttributes);
297
298 /* Close Handle... */
300
301 /* Initialize Event used when unregistering */
303
304 /* Default NT Kernel Callbacks. */
306 {
307 /* Create the name from the structure */
309
310 /* Initialize the Object Attributes Structure */
312 &CallbackName,
314 NULL,
315 NULL);
316
317 /* Create the Callback Object */
319 &ObjectAttributes,
320 TRUE,
321 TRUE);
323 }
324
325 /* Everything successful */
327}
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
NTSTATUS NTAPI ExCreateCallback(OUT PCALLBACK_OBJECT *CallbackObject, IN POBJECT_ATTRIBUTES ObjectAttributes, IN BOOLEAN Create, IN BOOLEAN AllowMultipleCallbacks)
Definition: callback.c:361
NTSTATUS NTAPI NtCreateDirectoryObject(OUT PHANDLE DirectoryHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes)
Definition: obdir.c:765
NTSTATUS NTAPI ObCreateObjectType(IN PUNICODE_STRING TypeName, IN POBJECT_TYPE_INITIALIZER ObjectTypeInitializer, IN PVOID Reserved, OUT POBJECT_TYPE *ObjectType)
Definition: oblife.c:1136
Definition: apinames.c:49
Definition: umtypes.h:182
Definition: obtypes.h:353
Definition: env_spec_w32.h:368
Referenced by ExpInitSystemPhase1().
◆ ExpInitializeEventImplementation()
Definition at line 39 of file event.c.
40{
41 OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
45
46 /* Create the Event Object Type */
58}
ULONG DefaultNonPagedPoolCharge
Definition: obtypes.h:365
Referenced by ExpInitSystemPhase1().
◆ ExpInitializeEventPairImplementation()
Definition at line 33 of file evtpair.c.
34{
35 OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
39
40 /* Create the Event Pair Object Type */
53}
struct _KEVENT_PAIR KEVENT_PAIR
Referenced by ExpInitSystemPhase1().
◆ ExpInitializeExecutive()
Definition at line 923 of file init.c.
925{
926 PNLS_DATA_BLOCK NlsData;
928 ANSI_STRING AnsiPath;
930 PCHAR CommandLine, PerfMem;
931 ULONG PerfMemUsed;
932 PLDR_DATA_TABLE_ENTRY NtosEntry;
933 PMESSAGE_RESOURCE_ENTRY MsgEntry;
934 ANSI_STRING CSDString;
935 size_t Remaining = 0;
937 CHAR VersionBuffer[65];
938
939 /* Validate Loader */
941 {
942 /* Invalid loader version */
943 KeBugCheckEx(MISMATCHED_HAL,
944 3,
945 LoaderBlock->Extension->Size,
946 LoaderBlock->Extension->MajorVersion,
947 LoaderBlock->Extension->MinorVersion);
948 }
949
950 /* Initialize PRCB pool lookaside pointers */
951 ExInitPoolLookasidePointers();
952
953 /* Check if this is an application CPU */
954 if (Cpu)
955 {
956 /* Then simply initialize it with HAL */
958 {
959 /* Initialization failed */
960 KeBugCheck(HAL_INITIALIZATION_FAILED);
961 }
962
963 /* We're done */
964 return;
965 }
966
967 /* Assume no text-mode or remote boot */
970
971 /* Check if we have a setup loader block */
972 if (LoaderBlock->SetupLdrBlock)
973 {
974 /* Check if this is text-mode setup */
977
978 /* Check if this is network boot */
980 {
981 /* Set variable */
983
984 /* Make sure we're actually booting off the network */
986 }
987 }
988
989 /* Set phase to 0 */
990 ExpInitializationPhase = 0;
991
992 /* Get boot command line */
993 CommandLine = LoaderBlock->LoadOptions;
994 if (CommandLine)
995 {
996 /* Upcase it for comparison and check if we're in performance mode */
997 _strupr(CommandLine);
999 if (PerfMem)
1000 {
1001 /* Check if the user gave a number of bytes to use */
1003 if (PerfMem)
1004 {
1005 /* Read the number of pages we'll use */
1007 if (PerfMemUsed)
1008 {
1009 /* FIXME: TODO */
1011 "/PERFMEM option ignored.\n");
1012 }
1013 }
1014 }
1015
1016 /* Check if we're burning memory */
1018 if (PerfMem)
1019 {
1020 /* Check if the user gave a number of bytes to use */
1022 if (PerfMem)
1023 {
1024 /* Read the number of pages we'll use */
1027 }
1028 }
1029 }
1030
1031 /* Setup NLS Base and offsets */
1032 NlsData = LoaderBlock->NlsData;
1034 ExpAnsiCodePageDataOffset = 0;
1039
1040 /* Initialize the NLS Tables */
1042 ExpAnsiCodePageDataOffset),
1044 ExpOemCodePageDataOffset),
1047 &ExpNlsTableInfo);
1049
1050 /* Now initialize the HAL */
1052 {
1053 /* HAL failed to initialize, bugcheck */
1054 KeBugCheck(HAL_INITIALIZATION_FAILED);
1055 }
1056
1057 /* Make sure interrupts are active now */
1058 _enable();
1059
1060 /* Clear the crypto exponent */
1061 SharedUserData->CryptoExponent = 0;
1062
1063 /* Set global flags for the checked build */
1064#if DBG
1067#endif
1068
1069 /* Setup NT System Root Path */
1071
1072 /* Convert to ANSI_STRING and null-terminate it */
1075
1076 /* Get the string from KUSER_SHARED_DATA's buffer */
1077 RtlInitEmptyUnicodeString(&NtSystemRoot,
1078 SharedUserData->NtSystemRoot,
1080
1081 /* Now fill it in */
1084
1085 /* Setup bugcheck messages */
1086 KiInitializeBugCheck();
1087
1088 /* Setup initial system settings */
1090
1091 /* Set the Service Pack Number and add it to the CSD Version number if needed */
1094 {
1096 }
1097
1098 /* Add loaded CmNtGlobalFlag value */
1100
1101 /* Initialize the executive at phase 0 */
1103
1104 /* Initialize the memory manager at phase 0 */
1106
1107 /* Load boot symbols */
1108 ExpLoadBootSymbols(LoaderBlock);
1109
1110 /* Check if we should break after symbol load */
1112
1113 /* Check if this loader is compatible with NT 5.2 */
1115 {
1116 /* Setup headless terminal settings */
1117 HeadlessInit(LoaderBlock);
1118 }
1119
1120 /* Set system ranges */
1121#ifdef _M_AMD64
1124#else
1127#endif
1128
1129 /* Make a copy of the NLS Tables */
1130 ExpInitNls(LoaderBlock);
1131
1132 /* Get the kernel's load entry */
1133 NtosEntry = CONTAINING_RECORD(LoaderBlock->LoadOrderListHead.Flink,
1134 LDR_DATA_TABLE_ENTRY,
1135 InLoadOrderLinks);
1136
1137 /* Check if this is a service pack */
1139 {
1140 /* Get the service pack string */
1142 11,
1143 0,
1144 WINDOWS_NT_CSD_STRING,
1145 &MsgEntry);
1147 {
1148 /* Setup the string */
1150
1151 /* Remove trailing newline */
1155 {
1156 /* Skip the trailing character */
1157 CSDString.Length--;
1158 }
1159
1160 /* Fill the buffer with version information */
1163 "%Z %u%c",
1164 &CSDString,
1165 (CmNtCSDVersion & 0xFF00) >> 8,
1166 (CmNtCSDVersion & 0xFF) ?
1168 ANSI_NULL);
1169 }
1170 else
1171 {
1172 /* Build default string */
1175 "CSD %04x",
1176 CmNtCSDVersion);
1177 }
1178
1179 /* Check for success */
1181 {
1182 /* Fail */
1184 }
1185 }
1186 else
1187 {
1188 /* Then this is a beta */
1191 VER_PRODUCTBETA_STR,
1192 NULL,
1193 &Remaining,
1194 0);
1196 {
1197 /* Fail */
1199 }
1200
1201 /* Update length */
1203 }
1204
1205 /* Check if we have an RC number */
1207 {
1208 /* Check if we have no version data yet */
1210 {
1211 /* Set defaults */
1213 RcEnd = Buffer;
1214 }
1215 else
1216 {
1217 /* Add comma and space */
1220 ", ",
1221 &RcEnd,
1222 &Remaining,
1223 0);
1225 {
1226 /* Fail */
1228 }
1229 }
1230
1231 /* Add the version format string */
1233 Remaining,
1234 "v.%u",
1235 (CmNtCSDVersion & 0xFFFF0000) >> 16);
1237 {
1238 /* Fail */
1240 }
1241 }
1242
1243 /* Now setup the final string */
1246 &CSDString,
1247 TRUE);
1249 {
1250 /* Fail */
1252 }
1253
1254 /* Add our version */
1256 sizeof(VersionBuffer),
1257 "%u.%u",
1258 VER_PRODUCTMAJORVERSION,
1259 VER_PRODUCTMINORVERSION);
1261 {
1262 /* Fail */
1264 }
1265
1266 /* Build the final version string */
1268
1269 /* Check if the user wants a kernel stack trace database */
1271 {
1272 /* FIXME: TODO */
1274 "FLG_KERNEL_STACK_TRACE_DB flag ignored.\n");
1275 }
1276
1277 /* Check if he wanted exception logging */
1279 {
1280 /* FIXME: TODO */
1282 "FLG_ENABLE_EXCEPTION_LOGGING flag ignored.\n");
1283 }
1284
1285 /* Initialize the Handle Table */
1286 ExpInitializeHandleTables();
1287
1288#if DBG
1289 /* On checked builds, allocate the system call count table */
1293 'llaC');
1294
1295 /* Use it for the shadow table too */
1297
1298 /* Make sure allocation succeeded */
1300 {
1301 /* Zero the call counts to 0 */
1304 }
1305#endif
1306
1307 /* Create the Basic Object Manager Types to allow new Object Types */
1309
1310 /* Load basic Security for other Managers */
1312
1313 /* Initialize the Process Manager */
1315
1316 /* Initialize the PnP Manager */
1318
1319 /* Initialize the User-Mode Debugging Subsystem */
1320 DbgkInitialize();
1321
1322 /* Calculate the tick count multiplier */
1325
1326 /* Set the OS Version */
1329
1330 /* Set the machine type */
1331 SharedUserData->ImageNumberLow = IMAGE_FILE_MACHINE_NATIVE;
1332 SharedUserData->ImageNumberHigh = IMAGE_FILE_MACHINE_NATIVE;
1333
1334 /* ReactOS magic */
1336}
CM_SYSTEM_CONTROL_VECTOR CmControlVector[]
VOID NTAPI CmGetSystemControlValues(IN PVOID SystemHiveData, IN PCM_SYSTEM_CONTROL_VECTOR ControlVector)
Definition: cmcontrl.c:104
BOOLEAN NTAPI HalInitSystem(IN ULONG BootPhase, IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: halinit.c:43
VOID NTAPI HeadlessInit(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: hdlsterm.c:189
_Check_return_ long __cdecl atol(_In_z_ const char *_Str)
NTSYSAPI VOID NTAPI RtlInitNlsTables(_In_ PUSHORT AnsiTableBase, _In_ PUSHORT OemTableBase, _In_ PUSHORT CaseTableBase, _Out_ PNLSTABLEINFO NlsTable)
NTSYSAPI VOID NTAPI RtlResetRtlTranslations(_In_ PNLSTABLEINFO NlsTable)
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz(_Out_ PUNICODE_STRING Destination, _In_ PCSZ Source)
NTSYSAPI NTSTATUS NTAPI RtlFindMessage(_In_ PVOID BaseAddress, _In_ ULONG Type, _In_ ULONG Language, _In_ ULONG MessageId, _Out_ PMESSAGE_RESOURCE_ENTRY *MessageResourceEntry)
NTSYSAPI VOID NTAPI RtlInitString(PSTRING DestinationString, PCSZ SourceString)
NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString, PANSI_STRING SourceString, BOOLEAN AllocateDestinationString)
NTSYSAPI VOID NTAPI RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)
#define ANSI_NULL
VOID NTAPI ExBurnMemory(IN PLOADER_PARAMETER_BLOCK LoaderBlock, IN ULONG_PTR PagesToDestroy, IN TYPE_OF_MEMORY MemoryType)
Definition: init.c:877
ULONG NTAPI ExComputeTickCountMultiplier(IN ULONG ClockIncrement)
Definition: init.c:606
BOOLEAN NTAPI ExpIsLoaderValid(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: init.c:770
BOOLEAN NTAPI MmArmInitSystem(IN ULONG Phase, IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: mminit.c:2046
VOID NTAPI ExpLoadBootSymbols(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: init.c:796
BOOLEAN NTAPI SeInitSystem(VOID)
Main security manager initialization function.
Definition: semgr.c:285
NTSTRSAFEVAPI RtlStringCbPrintfA(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PSTR pszDest, _In_ size_t cbDest, _In_ _Printf_format_string_ NTSTRSAFE_PCSTR pszFormat,...)
Definition: ntstrsafe.h:1148
NTSTRSAFEAPI RtlStringCbCatExA(_Inout_updates_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PSTR pszDest, _In_ size_t cbDest, _In_ NTSTRSAFE_PCSTR pszSrc, _Outptr_opt_result_bytebuffer_(*pcbRemaining) NTSTRSAFE_PSTR *ppszDestEnd, _Out_opt_ size_t *pcbRemaining, _In_ STRSAFE_DWORD dwFlags)
Definition: ntstrsafe.h:718
NTSTRSAFEAPI RtlStringCbCopyExA(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PSTR pszDest, _In_ size_t cbDest, _In_ NTSTRSAFE_PCSTR pszSrc, _Outptr_opt_result_bytebuffer_(*pcbRemaining) STRSAFE_LPSTR *ppszDestEnd, _Out_opt_ size_t *pcbRemaining, _In_ STRSAFE_DWORD dwFlags)
Definition: ntstrsafe.h:270
KSERVICE_TABLE_DESCRIPTOR KeServiceDescriptorTable[SSDT_MAX_ENTRIES]
Definition: procobj.c:23
KSERVICE_TABLE_DESCRIPTOR KeServiceDescriptorTableShadow[SSDT_MAX_ENTRIES]
Definition: procobj.c:24
BOOLEAN NTAPI PsInitSystem(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: psmgr.c:532
VOID NTAPI KeBugCheckEx(_In_ ULONG BugCheckCode, _In_ ULONG_PTR BugCheckParameter1, _In_ ULONG_PTR BugCheckParameter2, _In_ ULONG_PTR BugCheckParameter3, _In_ ULONG_PTR BugCheckParameter4)
Definition: rtlcompat.c:108
_Check_return_ _CRTIMP int __cdecl _memicmp(_In_reads_bytes_opt_(_Size) const void *_Buf1, _In_reads_bytes_opt_(_Size) const void *_Buf2, _In_ size_t _Size)
_CRTIMP char *__cdecl _strupr(_Inout_z_ char *_String)
#define KI_USER_SHARED_DATA
#define SharedUserData
Definition: env_spec_w32.h:375
Definition: btrfs_drv.h:1876
Definition: arc.h:392
Definition: rtltypes.h:1896
Definition: arc.h:322
Referenced by KiInitializeKernel().
◆ ExpInitializeHandleTables()
Definition at line 34 of file handle.c.
35{
36 /* Initialize the list of handle tables and the lock */
39}
Referenced by ExpInitializeExecutive().
◆ ExpInitializeKeyedEventImplementation()
Referenced by ExpInitSystemPhase1().
◆ ExpInitializeMutantImplementation()
Definition at line 52 of file mutant.c.
53{
54 OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
58
59 /* Create the Event Pair Object Type */
72}
struct _KMUTANT KMUTANT
Referenced by ExpInitSystemPhase1().
◆ ExpInitializeProfileImplementation()
Definition at line 62 of file profile.c.
63{
64 OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
68
69 /* Initialize the Mutex to lock the States */
71
72 /* Create the Event Pair Object Type */
85}
struct _KPROFILE KPROFILE
VOID NTAPI KeInitializeMutex(IN PKMUTEX Mutex, IN ULONG Level)
Definition: mutex.c:67
Referenced by ExpInitSystemPhase1().
◆ ExpInitializePushLocks()
Definition at line 45 of file pushlock.c.
46{
47#ifdef CONFIG_SMP
48 /* Initialize an internal 1024-iteration spin for MP CPUs */
50 ExPushLockSpinCount = 1024;
51#endif
52}
Referenced by ExpInitSystemPhase1().
◆ ExpInitializeSemaphoreImplementation()
Definition at line 43 of file sem.c.
44{
45 OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
49
50 /* Create the Event Pair Object Type */
62}
struct _KSEMAPHORE KSEMAPHORE
Referenced by ExpInitSystemPhase1().
◆ ExpInitializeTimerImplementation()
Definition at line 223 of file timer.c.
224{
225 OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
228
229 /* Create the Timer Object Type */
241
242 /* Initialize the Wait List and Lock */
246}
struct _ETIMER ETIMER
Referenced by ExpInitSystemPhase1().
◆ ExpInitializeWorkerThreads()
Definition at line 522 of file work.c.
523{
524 ULONG WorkQueueType;
525 ULONG CriticalThreads, DelayedThreads;
526 HANDLE ThreadHandle;
530
531 /* Setup the stack swap support */
535
536 /* Set the number of critical and delayed threads. We shouldn't hardcode */
537 DelayedThreads = EX_DELAYED_WORK_THREADS;
538 CriticalThreads = EX_CRITICAL_WORK_THREADS;
539
540 /* Protect against greedy registry modifications */
545
546 /* Calculate final count */
547 DelayedThreads += ExpAdditionalDelayedWorkerThreads;
548 CriticalThreads += ExpAdditionalCriticalWorkerThreads;
549
550 /* Initialize the Array */
552 {
553 /* Clear the structure and initialize the queue */
556 }
557
558 /* Dynamic threads are only used for the critical queue */
560
561 /* Initialize the balance set manager events */
564 NotificationEvent,
565 FALSE);
566
567 /* Create the built-in worker threads for the critical queue */
569 {
570 /* Create the thread */
572 ExCriticalWorkerThreads++;
573 }
574
575 /* Create the built-in worker threads for the delayed queue */
577 {
578 /* Create the thread */
580 ExDelayedWorkerThreads++;
581 }
582
583 /* Create the built-in worker thread for the hypercritical queue */
585
586 /* Create the balance set manager thread */
588 THREAD_ALL_ACCESS,
589 NULL,
590 0,
591 NULL,
593 NULL);
595 {
597 }
598
599 /* Get a pointer to it for the shutdown process */
600 ObReferenceObjectByHandle(ThreadHandle,
601 THREAD_ALL_ACCESS,
602 NULL,
603 KernelMode,
605 NULL);
607
608 /* Close the handle and return */
610}
VOID NTAPI KeInitializeQueue(IN PKQUEUE Queue, IN ULONG Count OPTIONAL)
Definition: queue.c:148
NTSTATUS NTAPI PsCreateSystemThread(OUT PHANDLE ThreadHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, IN HANDLE ProcessHandle, IN PCLIENT_ID ClientId, IN PKSTART_ROUTINE StartRoutine, IN PVOID StartContext)
Definition: thread.c:602
NTSTATUS NTAPI ObCloseHandle(IN HANDLE Handle, IN KPROCESSOR_MODE AccessMode)
Definition: obhandle.c:3379
NTSTATUS NTAPI ObReferenceObjectByHandle(IN HANDLE Handle, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, OUT PVOID *Object, OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL)
Definition: obref.c:494
Definition: pstypes.h:1103
Definition: extypes.h:406
VOID NTAPI ExpWorkerThreadBalanceManager(IN PVOID Context)
Definition: work.c:427
VOID NTAPI ExpCreateWorkerThread(WORK_QUEUE_TYPE WorkQueueType, IN BOOLEAN Dynamic)
Definition: work.c:250
FORCEINLINE VOID ExInitializeFastMutex(_Out_ PFAST_MUTEX FastMutex)
Definition: exfuncs.h:274
Referenced by ExpInitSystemPhase1().
◆ ExpInitLookasideLists()
Definition at line 89 of file lookas.c.
90{
92
93 /* Initialize locks and lists */
100
101 /* Initialize the system lookaside lists */
103 {
104 /* Initialize the non-paged list */
106 NonPagedPool,
107 (i + 1) * 8,
108 'looP',
109 256,
110 &ExPoolLookasideListHead);
111
112 /* Initialize the paged list */
114 PagedPool,
115 (i + 1) * 8,
116 'looP',
117 256,
118 &ExPoolLookasideListHead);
119 }
120}
VOID NTAPI ExInitializeSystemLookasideList(IN PGENERAL_LOOKASIDE List, IN POOL_TYPE Type, IN ULONG Size, IN ULONG Tag, IN USHORT MaximumDepth, IN PLIST_ENTRY ListHead)
Definition: lookas.c:31
◆ ExpLockHandleTableEntry()
| BOOLEAN NTAPI ExpLockHandleTableEntry | ( | IN PHANDLE_TABLE | HandleTable, |
| IN PHANDLE_TABLE_ENTRY | HandleTableEntry | ||
| ) |
Definition at line 884 of file handle.c.
886{
887 LONG_PTR NewValue, OldValue;
888
889 /* Sanity check */
892
893 /* Start lock loop */
894 for (;;)
895 {
896 /* Get the current value and check if it's locked */
899 {
900 /* It's not locked, remove the lock bit to lock it */
901 NewValue = OldValue & ~EXHANDLE_TABLE_ENTRY_LOCK_BIT;
903 (PVOID)NewValue,
905 {
906 /* We locked it, get out */
908 }
909 }
910 else
911 {
912 /* We couldn't lock it, bail out if it's been freed */
914 }
915
916 /* It's locked, wait for it to be unlocked */
918 }
919}
#define InterlockedCompareExchangePointer
Definition: interlocked.h:129
VOID NTAPI ExpBlockOnLockedHandleEntry(IN PHANDLE_TABLE HandleTable, IN PHANDLE_TABLE_ENTRY HandleTableEntry)
Definition: handle.c:858
Referenced by ExChangeHandle(), ExDestroyHandle(), ExDupHandleTable(), ExEnumHandleTable(), ExMapHandleToPointer(), ExSweepHandleTable(), and QSI_DEF().
◆ ExpLookupHandleTableEntry()
| PHANDLE_TABLE_ENTRY NTAPI ExpLookupHandleTableEntry | ( | IN PHANDLE_TABLE | HandleTable, |
| IN EXHANDLE | Handle | ||
| ) |
Definition at line 43 of file handle.c.
45{
46 ULONG TableLevel;
47 ULONG_PTR TableBase;
49 PVOID *PointerArray;
50
51 /* Clear the tag bits */
52 Handle.TagBits = 0;
53
54 /* Check if the handle is in the allocated range */
56 {
58 }
59
60 /* Get the table code */
61 TableBase = HandleTable->TableCode;
62
63 /* Extract the table level and actual table base */
64 TableLevel = (ULONG)(TableBase & 3);
65 TableBase &= ~3;
66
67 PointerArray = (PVOID*)TableBase;
68 HandleArray = (PHANDLE_TABLE_ENTRY)TableBase;
69
70 /* Check what level we're running at */
71 switch (TableLevel)
72 {
73 case 2:
74
75 /* Get the mid level pointer array */
76 PointerArray = PointerArray[Handle.HighIndex];
78
79 /* Fall through */
80 case 1:
81
82 /* Get the handle array */
83 HandleArray = PointerArray[Handle.MidIndex];
85
86 /* Fall through */
87 case 0:
88
89 /* Get the entry using the low index */
91
92 /* All done */
93 break;
94
95 default:
96
99 }
100
101 /* Return the handle entry */
103}
struct _HANDLE_TABLE_ENTRY * PHANDLE_TABLE_ENTRY
Referenced by ExChangeHandle(), ExDestroyHandle(), ExDupHandleTable(), ExEnumHandleTable(), ExMapHandleToPointer(), ExpAllocateHandleTableEntry(), ExpFreeHandleTableEntry(), ExSweepHandleTable(), and QSI_DEF().
◆ ExpResourceInitialization()
Definition at line 173 of file resource.c.
174{
175 /* Setup the timeout */
179}
#define Int32x32To64(a, b)
Referenced by ExpInitSystemPhase0().
◆ ExpSetTimeZoneInformation()
| NTSTATUS ExpSetTimeZoneInformation | ( | IN PRTL_TIME_ZONE_INFORMATION | TimeZoneInformation | ) |
◆ ExpUuidInitialization()
◆ ExpWin32kInit()
Definition at line 259 of file win32k.c.
260{
261 OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
265
266 /* Create the window station Object Type */
277 OBJ_PERMANENT |
278 OBJ_EXCLUSIVE;
281 &ObjectTypeInitializer,
282 NULL,
283 &ExWindowStationObjectType);
285
286 /* Create desktop object type */
295 &ObjectTypeInitializer,
296 NULL,
297 &ExDesktopObjectType);
299
301}
OB_OKAYTOCLOSE_METHOD OkayToCloseProcedure
Definition: obtypes.h:373
BOOLEAN NTAPI ExpWindowStationOkToClose(IN PEPROCESS Process OPTIONAL, IN PVOID Object, IN HANDLE Handle, IN KPROCESSOR_MODE AccessMode)
Definition: win32k.c:135
NTSTATUS NTAPI ExpWinStaObjectParse(IN PVOID ParseObject, IN PVOID ObjectType, IN OUT PACCESS_STATE AccessState, IN KPROCESSOR_MODE AccessMode, IN ULONG Attributes, IN OUT PUNICODE_STRING CompleteName, IN OUT PUNICODE_STRING RemainingName, IN OUT PVOID Context OPTIONAL, IN PSECURITY_QUALITY_OF_SERVICE SecurityQos OPTIONAL, OUT PVOID *Object)
Definition: win32k.c:171
BOOLEAN NTAPI ExpDesktopOkToClose(IN PEPROCESS Process OPTIONAL, IN PVOID Object, IN HANDLE Handle, IN KPROCESSOR_MODE AccessMode)
Definition: win32k.c:113
VOID NTAPI ExpDesktopClose(IN PEPROCESS Process OPTIONAL, IN PVOID Object, IN ACCESS_MASK GrantedAccess, IN ULONG ProcessHandleCount, IN ULONG SystemHandleCount)
Definition: win32k.c:237
NTSTATUS NTAPI ExpDesktopOpen(IN OB_OPEN_REASON Reason, IN PEPROCESS Process OPTIONAL, IN PVOID ObjectBody, IN ACCESS_MASK GrantedAccess, IN ULONG HandleCount)
Definition: win32k.c:216
Referenced by ExpInitSystemPhase1().
◆ ExReferenceCallBackBlock()
| PEX_CALLBACK_ROUTINE_BLOCK NTAPI ExReferenceCallBackBlock | ( | IN OUT PEX_CALLBACK | CallBack | ) |
Definition at line 122 of file callback.c.
123{
124 EX_FAST_REF OldValue;
126 PEX_CALLBACK_ROUTINE_BLOCK CallbackBlock;
127
128 /* Acquire a reference */
129 OldValue = ExAcquireFastReference(&CallBack->RoutineBlock);
131
132 /* Fail if there isn't any object */
134
135 /* Check if we don't have a reference */
137 {
138 /* FIXME: Race */
142 }
143
144 /* Get the callback block */
145 CallbackBlock = ExGetObjectFastReference(OldValue);
146
147 /* Check if this is the last reference */
149 {
150 /* Acquire rundown protection */
152 MAX_FAST_REFS))
153 {
154 /* Insert references */
156 {
157 /* Backdown the rundown acquire */
159 MAX_FAST_REFS);
160 }
161 }
162 }
163
164 /* Return the callback block */
165 return CallbackBlock;
166}
FORCEINLINE BOOLEAN ExInsertFastReference(IN OUT PEX_FAST_REF FastRef, IN PVOID Object)
Definition: ex.h:646
FORCEINLINE EX_FAST_REF ExAcquireFastReference(IN OUT PEX_FAST_REF FastRef)
Definition: ex.h:617
Referenced by ExDoCallBack(), PsRemoveCreateThreadNotifyRoutine(), PsRemoveLoadImageNotifyRoutine(), and PsSetCreateProcessNotifyRoutine().
◆ ExRefreshTimeZoneInformation()
| BOOLEAN NTAPI ExRefreshTimeZoneInformation | ( | IN PLARGE_INTEGER | SystemBootTime | ) |
Definition at line 320 of file time.c.
321{
322 LARGE_INTEGER CurrentTime, NewTimeZoneBias;
324
326
327 /* Set the global data for ExpTimeZoneBias and the Time Zone ID */
330 {
333 }
335
336 ExpTimeZoneBias = NewTimeZoneBias;
337
338 /* Change SharedUserData->TimeZoneBias for user-mode applications */
343
344 /* Convert boot time from local time to UTC */
346
347 /* Convert system time from local time to UTC */
348 KeQuerySystemTime(&CurrentTime);;
349
350 /* Change it for user-mode applications */
355
356 /* Return success */
358}
static BOOLEAN ExpGetTimeZoneId(_In_ PLARGE_INTEGER TimeNow, _Out_ PULONG TimeZoneId, _Out_ PLARGE_INTEGER NewTimeZoneBias)
Definition: time.c:39
Definition: typedefs.h:103
struct _LARGE_INTEGER::@2303 u
Referenced by Phase1InitializationDiscard().
◆ ExReleaseFastReference()
| FORCEINLINE BOOLEAN ExReleaseFastReference | ( | IN PEX_FAST_REF | FastRef, |
| IN PVOID | Object | ||
| ) |
Definition at line 685 of file ex.h.
687{
688 EX_FAST_REF OldValue, NewValue;
689
690 /* Sanity checks */
693
694 /* Start reference loop */
695 for (;;)
696 {
697 /* Get the current reference count */
698 OldValue = *FastRef;
699
700 /* Check if we're full if if the pointer changed */
702
703 /* Decrease the reference count */
706 NewValue.Object,
707 OldValue.Object);
709
710 /* We are done */
711 break;
712 }
713
714 /* Return success */
716}
Referenced by ExDereferenceCallBackBlock(), and ObFastDereferenceObject().
◆ ExReleasePushLock()
| FORCEINLINE VOID ExReleasePushLock | ( | PEX_PUSH_LOCK | PushLock | ) |
Definition at line 1296 of file ex.h.
1297{
1298 EX_PUSH_LOCK OldValue = *PushLock;
1299 EX_PUSH_LOCK NewValue;
1300
1301 /* Sanity checks */
1303
1304 /* Check if the pushlock is shared */
1306 {
1307 /* Decrease the share count */
1309 }
1310 else
1311 {
1312 /* Clear the pushlock entirely */
1313 NewValue.Value = 0;
1314 }
1315
1316 /* Check if nobody is waiting on us and try clearing the lock here */
1319 OldValue.Ptr))
1320 {
1321 /* We have waiters, use the long path */
1322 ExfReleasePushLock(PushLock);
1323 }
1324}
VOID FASTCALL ExfReleasePushLock(PEX_PUSH_LOCK PushLock)
Definition: pushlock.c:810
Referenced by CmLoadKey(), CmpDestroyHive(), CmpDoFlushAll(), CmpDoFlushNextHive(), CmpInitializeHive(), CmpReleaseKcbLockByIndex(), CmpUnlinkHiveFromMaster(), ObpReleaseDirectoryLock(), and ObpSdReleaseLockShared().
◆ ExReleasePushLockExclusive()
| FORCEINLINE VOID ExReleasePushLockExclusive | ( | PEX_PUSH_LOCK | PushLock | ) |
Definition at line 1252 of file ex.h.
1253{
1254 EX_PUSH_LOCK OldValue;
1255
1256 /* Sanity checks */
1258
1259 /* Unlock the pushlock */
1262
1263 /* Sanity checks */
1266
1267 /* Check if anyone is waiting on it and it's not already waking*/
1269 {
1270 /* Wake it up */
1271 ExfTryToWakePushLock(PushLock);
1272 }
1273}
VOID FASTCALL ExfTryToWakePushLock(PEX_PUSH_LOCK PushLock)
Definition: pushlock.c:1165
Referenced by CmUnloadKey(), ExCreateHandleTable(), ExDupHandleTable(), ExpAllocateHandleTableEntry(), ExRemoveHandleTable(), GDIOBJ_vDeleteObject(), GDIOBJ_vUnlockObject(), GdiPoolAllocate(), GdiPoolFree(), MiUnlockProcessWorkingSet(), MiUnlockProcessWorkingSetUnsafe(), MiUnlockWorkingSet(), NtUnloadKey2(), ObpSdReleaseLock(), PspCreateThread(), PspDeleteThread(), PspExitThread(), PspUnlockProcessSecurityExclusive(), PspUnlockThreadSecurityExclusive(), PsSetProcessWin32Process(), and TEXTOBJ_UnlockText().
◆ ExReleasePushLockShared()
| FORCEINLINE VOID ExReleasePushLockShared | ( | PEX_PUSH_LOCK | PushLock | ) |
Definition at line 1213 of file ex.h.
1214{
1215 EX_PUSH_LOCK OldValue;
1216
1217 /* Sanity checks */
1219
1220 /* Try to clear the pushlock */
1223 {
1224 /* There are still other people waiting on it */
1225 ExfReleasePushLockShared(PushLock);
1226 }
1227}
VOID FASTCALL ExfReleasePushLockShared(PEX_PUSH_LOCK PushLock)
Definition: pushlock.c:956
Referenced by ExpAllocateHandleTableEntry(), MiUnlockProcessWorkingSetShared(), MiUnlockWorkingSetShared(), NtSetInformationProcess(), NtSetInformationThread(), PsGetNextProcessThread(), PspUnlockProcessSecurityShared(), PspUnlockThreadSecurityShared(), and QSI_DEF().
◆ ExReleaseTimeRefreshLock()
Definition at line 177 of file time.c.
178{
179 /* Release the lock and re-enable APCs */
181 KeLeaveCriticalRegion();
182}
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1822
Referenced by ExSetTimerResolution(), and KdpTimeSlipWork().
◆ ExShutdownSystem()
Definition at line 21 of file shutdown.c.
22{
23 /* Dereference the hard-error port and process objects */
25 {
28 }
30 {
33 }
34}
Referenced by PopGracefulShutdown().
◆ ExSwapFastReference()
| FORCEINLINE EX_FAST_REF ExSwapFastReference | ( | IN PEX_FAST_REF | FastRef, |
| IN PVOID | Object | ||
| ) |
Definition at line 720 of file ex.h.
722{
723 EX_FAST_REF NewValue, OldValue;
724
725 /* Sanity check */
727
728 /* Check if an object is being set */
730 {
731 /* Clear the field */
733 }
734 else
735 {
736 /* Otherwise, we assume the object was referenced and is ready */
738 }
739
740 /* Update the object */
742 return OldValue;
743}
Referenced by ObFastReplaceObject().
◆ ExSwapinWorkerThreads()
Definition at line 637 of file work.c.
638{
642 KAPC Apc;
643 PAGED_CODE();
644
645 /* Initialize an event so we know when we're done */
647
648 /* Lock this routine */
650
651 /* New threads cannot swap anymore */
652 ExpWorkersCanSwap = AllowSwap;
653
654 /* Loop all threads in the system process */
657 {
658 /* Skip threads with explicit permission to do this */
660
661 /* Check if we reached ourselves */
663 {
664 /* Do it inline */
665 KeSetKernelStackSwapEnable(AllowSwap);
666 }
667 else
668 {
669 /* Queue an APC */
670 KeInitializeApc(&Apc,
672 InsertApcEnvironment,
674 NULL,
675 NULL,
676 KernelMode,
677 &AllowSwap);
679 {
680 /* Wait for the APC to run */
683 }
684 }
685
686 /* Next thread */
687Next:
689 }
690
691 /* Release the lock */
693}
#define KeWaitForSingleObject(pEvt, foo, a, b, c)
Definition: env_spec_w32.h:478
BOOLEAN NTAPI KeInsertQueueApc(IN PKAPC Apc, IN PVOID SystemArgument1, IN PVOID SystemArgument2, IN KPRIORITY PriorityBoost)
Definition: apc.c:735
VOID NTAPI KeInitializeApc(IN PKAPC Apc, IN PKTHREAD Thread, IN KAPC_ENVIRONMENT TargetEnvironment, IN PKKERNEL_ROUTINE KernelRoutine, IN PKRUNDOWN_ROUTINE RundownRoutine OPTIONAL, IN PKNORMAL_ROUTINE NormalRoutine, IN KPROCESSOR_MODE Mode, IN PVOID Context)
Definition: apc.c:651
PETHREAD NTAPI PsGetNextProcessThread(IN PEPROCESS Process, IN PETHREAD Thread OPTIONAL)
Definition: process.c:75
Definition: filtergraph.c:51
Definition: ketypes.h:547
Definition: ketypes.h:811
BOOLEAN NTAPI KeSetKernelStackSwapEnable(IN BOOLEAN Enable)
Definition: thrdobj.c:988
VOID NTAPI ExpSetSwappingKernelApc(IN PKAPC Apc, OUT PKNORMAL_ROUTINE *NormalRoutine, IN OUT PVOID *NormalContext, IN OUT PVOID *SystemArgument1, IN OUT PVOID *SystemArgument2)
Definition: work.c:614
Referenced by NtSetSystemPowerState().
◆ ExSweepHandleTable()
| VOID NTAPI ExSweepHandleTable | ( | IN PHANDLE_TABLE | HandleTable, |
| IN PEX_SWEEP_HANDLE_CALLBACK | EnumHandleProcedure, | ||
| IN PVOID | Context | ||
| ) |
Definition at line 1232 of file handle.c.
1235{
1237 PHANDLE_TABLE_ENTRY HandleTableEntry;
1238 PAGED_CODE();
1239
1240 /* Set the initial value and loop the entries */
1243 {
1244 /* Loop each handle */
1245 do
1246 {
1247 /* Lock the entry */
1249 {
1250 /* Notify the callback routine */
1251 EnumHandleProcedure(HandleTableEntry,
1252 Handle.GenericHandleOverlay,
1253 Context);
1254 }
1255
1256 /* Go to the next handle and entry */
1258 HandleTableEntry++;
1260
1261 /* Skip past the last entry */
1263 }
1264}
Referenced by ObClearProcessHandleTable(), ObKillProcess(), and RtlpDestroyAtomHandleTable().
◆ ExSystemExceptionFilter()
Definition at line 349 of file harderr.c.
350{
353}
Referenced by _IRQL_requires_max_(), NtAddAtom(), NtAllocateUuids(), NtCancelTimer(), NtCompareTokens(), NtCreateDebugObject(), NtCreateDirectoryObject(), NtCreateEvent(), NtCreateEventPair(), NtCreateIoCompletion(), NtCreateMutant(), NtCreateProfile(), NtCreateSemaphore(), NtCreateSymbolicLinkObject(), NtCreateTimer(), NtFindAtom(), NtOpenDirectoryObject(), NtOpenEvent(), NtOpenEventPair(), NtOpenIoCompletion(), NtOpenMutant(), NtOpenSemaphore(), NtOpenSymbolicLinkObject(), NtOpenTimer(), NtPulseEvent(), NtQueryDefaultLocale(), NtQueryDefaultUILanguage(), NtQueryDirectoryObject(), NtQueryEvent(), NtQueryInformationAtom(), NtQueryInstallUILanguage(), NtQueryIntervalProfile(), NtQueryIoCompletion(), NtQueryMutant(), NtQueryObject(), NtQueryPerformanceCounter(), NtQuerySecurityObject(), NtQuerySemaphore(), NtQuerySymbolicLinkObject(), NtQuerySystemEnvironmentValue(), NtQuerySystemInformation(), NtQueryTimer(), NtReleaseMutant(), NtReleaseSemaphore(), NtRemoveIoCompletion(), NtResetEvent(), NtSetEvent(), NtSetInformationDebugObject(), NtSetSystemTime(), NtSetThreadExecutionState(), NtSetTimer(), NtStartProfile(), NtWaitForDebugEvent(), ObpCaptureObjectCreateInformation(), ObpCaptureObjectName(), ObQueryTypeInfo(), and ProbeAndCaptureObjectAttributes().
◆ ExTimerRundown()
Definition at line 43 of file timer.c.
44{
47 PLIST_ENTRY CurrentEntry;
49 ULONG DerefsToDo;
50
51 /* Lock the Thread's Active Timer List and loop it */
55 {
56 /* Get the timer */
58
59 /* Reference it */
61 DerefsToDo = 1;
62
63 /* Unlock the list */
65
66 /* Lock the Timer */
68
69 /* Lock the list again */
71
72 /* Make sure that the timer is valid */
74 {
75 /* Remove it from the list */
78
79 /* Cancel the timer and remove its DPC and APC */
83
84 /* Add another dereference to do */
85 DerefsToDo++;
86 }
87
88 /* Unlock the list */
90
91 /* Unlock the Timer */
93
94 /* Dereference it */
96
97 /* Loop again */
100 }
101
102 /* Release lock and return */
104}
Definition: cppunit_timer.h:24
BOOLEAN NTAPI KeRemoveQueueApc(PKAPC Apc)
LONG FASTCALL ObDereferenceObjectEx(IN PVOID Object, IN LONG Count)
Definition: obref.c:88
Definition: typedefs.h:120
Referenced by PspExitThread().
◆ ExTryToAcquirePushLockExclusive()
| FORCEINLINE BOOLEAN ExTryToAcquirePushLockExclusive | ( | PEX_PUSH_LOCK | PushLock | ) |
◆ ExTryToAcquireResourceExclusiveLite()
| BOOLEAN NTAPI ExTryToAcquireResourceExclusiveLite | ( | IN PERESOURCE | Resource | ) |
Definition at line 2134 of file resource.c.
2135{
2139
2140 /* Sanity check */
2142
2143 /* Get the thread */
2145
2146 /* Sanity check and validation */
2149
2150 /* Acquire the lock */
2152
2153 /* Check if there is an owner */
2155 {
2156 /* No owner, give exclusive access */
2159 Resource->OwnerEntry.OwnerCount = 1;
2160 Resource->ActiveCount = 1;
2161 Resource->ActiveEntries = 1;
2162 Acquired = TRUE;
2163 }
2166 {
2167 /* Do a recursive acquire */
2168 Resource->OwnerEntry.OwnerCount++;
2169 Acquired = TRUE;
2170 }
2171
2172 /* Release the resource */
2174 return Acquired;
2175}
_Acquires_exclusive_lock_ Resource _Acquires_shared_lock_ Resource _Inout_ PERESOURCE Resource
Definition: cdprocs.h:843
FORCEINLINE VOID ExReleaseResourceLock(IN PERESOURCE Resource, IN PKLOCK_QUEUE_HANDLE LockHandle)
Definition: resource.c:37
FORCEINLINE VOID ExAcquireResourceLock(IN PERESOURCE Resource, IN PKLOCK_QUEUE_HANDLE LockHandle)
Definition: resource.c:25
Definition: ketypes.h:626
Referenced by ApphelpCacheTryAcquireLock().
◆ ExUnlockHandleTableEntry()
| VOID NTAPI ExUnlockHandleTableEntry | ( | IN PHANDLE_TABLE | HandleTable, |
| IN PHANDLE_TABLE_ENTRY | HandleTableEntry | ||
| ) |
Definition at line 923 of file handle.c.
925{
926 LONG_PTR OldValue;
927 PAGED_CODE();
928
929 /* Sanity check */
932
933 /* Set the lock bit and make sure it wasn't earlier */
937
938 /* Unblock any waiters */
940}
Referenced by ExChangeHandle(), ExCreateHandle(), ExEnumHandleTable(), NtWaitForMultipleObjects(), ObpCloseHandleTableEntry(), ObpDuplicateHandleCallback(), ObpReferenceProcessObjectByHandle(), ObQueryObjectAuditingByHandle(), ObReferenceFileObjectForWrite(), ObReferenceObjectByHandle(), PsLookupProcessByProcessId(), PsLookupProcessThreadByCid(), PsLookupThreadByThreadId(), QSI_DEF(), and RtlpGetAtomEntry().
◆ ExUpdateSystemTimeFromCmos()
Definition at line 311 of file time.c.
313{
314 /* FIXME: TODO */
315 return;
316}
Referenced by KdpTimeSlipWork().
◆ ExWaitForCallBacks()
| VOID NTAPI ExWaitForCallBacks | ( | IN PEX_CALLBACK_ROUTINE_BLOCK | CallbackRoutineBlock | ) |
Definition at line 85 of file callback.c.
86{
87 /* Wait on the rundown */
88 ExWaitForRundownProtectionRelease(&CallbackBlock->RundownProtect);
89}
Referenced by PsRemoveCreateThreadNotifyRoutine(), PsRemoveLoadImageNotifyRoutine(), and PsSetCreateProcessNotifyRoutine().
◆ ExWaitForUnblockPushLock()
Definition at line 395 of file pushlock.c.
397{
398 /* Call the timed function with no timeout */
400}
NTSTATUS FASTCALL ExTimedWaitForUnblockPushLock(IN PEX_PUSH_LOCK PushLock, IN PVOID WaitBlock, IN PLARGE_INTEGER Timeout)
Definition: pushlock.c:319
Referenced by ExfUnblockPushLock(), and ExpBlockOnLockedHandleEntry().
◆ ExWaitOnPushLock()
| FORCEINLINE VOID ExWaitOnPushLock | ( | PEX_PUSH_LOCK | PushLock | ) |
Definition at line 1178 of file ex.h.
1179{
1180 /* Check if we're locked */
1182 {
1183 /* Acquire the lock */
1184 ExfAcquirePushLockExclusive(PushLock);
1186
1187 /* Release it */
1188 ExfReleasePushLockExclusive(PushLock);
1189 }
1190}
VOID FASTCALL ExfReleasePushLockExclusive(PEX_PUSH_LOCK PushLock)
Definition: pushlock.c:1091
Referenced by ExCompareExchangeCallBack(), and ExpMoveFreeHandles().
◆ HeadlessInit()
| VOID NTAPI HeadlessInit | ( | IN PLOADER_PARAMETER_BLOCK | LoaderBlock | ) |
Definition at line 189 of file hdlsterm.c.
190{
191 PHEADLESS_LOADER_BLOCK HeadlessBlock;
192
193 /* Only initialize further if the loader found EMS enabled */
194 HeadlessBlock = LoaderBlock->Extension->HeadlessLoaderBlock;
195 if (!HeadlessBlock) return;
196
197 /* Ignore invalid EMS settings */
199
200 /* Allocate the global headless data */
203 'sldH');
205
206 /* Zero and copy loader data */
221
222 /* These two are opposites of each other */
224
225 /* Check for a PCI device, warn that this isn't supported */
227 {
229 }
230
231 /* Log entries are not yet supported */
233
234 /* Allocate temporary buffer */
237
238 /* Windows seems to apply some special hacks for 9600 bps */
240 {
242 }
243
244 /* Enable the terminal */
246}
Definition: arc.h:352
Referenced by ExpInitializeExecutive().
◆ Phase1Initialization()
Definition at line 2026 of file init.c.
2027{
2028 /* Do the .INIT part of Phase 1 which we can free later */
2030
2031 /* Jump into zero page thread */
2032 MmZeroPageThread();
2033}
VOID NTAPI Phase1InitializationDiscard(IN PVOID Context)
Definition: init.c:1345
Referenced by PspInitPhase0().
◆ XIPInit()
| VOID NTAPI XIPInit | ( | IN PLOADER_PARAMETER_BLOCK | LoaderBlock | ) |
Definition at line 55 of file xipdisp.c.
56{
57 PCHAR CommandLine, XipBoot, XipRom, XipMegs, XipVerbose, XipRam;
58 PMEMORY_ALLOCATION_DESCRIPTOR XipDescriptor;
59
60 /* Get the command line */
61 CommandLine = LoaderBlock->LoadOptions;
62 if (!CommandLine) return;
63
64 /* Get XIP settings */
70
71 /* Check if this is a verbose boot */