extern LARGE_INTEGER ExpTimeZoneBias;
extern ULONG ExpTimeZoneId;
extern ULONG ExpTickCountMultiplier;
+extern ULONG ExpLastTimeZoneBias;
extern POBJECT_TYPE ExEventPairObjectType;
+extern POBJECT_TYPE _ExEventObjectType, _ExSemaphoreObjectType;
extern ULONG NtBuildNumber;
extern ULONG NtMajorVersion;
extern ULONG NtMinorVersion;
extern FAST_MUTEX ExpEnvironmentLock;
extern ERESOURCE ExpFirmwareTableResource;
extern LIST_ENTRY ExpFirmwareTableProviderListHead;
+extern BOOLEAN ExpIsWinPEMode;
+extern LIST_ENTRY ExpSystemResourcesList;
+ULONG ExpAnsiCodePageDataOffset, ExpOemCodePageDataOffset;
+ULONG ExpUnicodeCaseTableDataOffset;
+PVOID ExpNlsSectionPointer;
+extern CHAR NtBuildLab[];
+extern ULONG CmNtCSDVersion;
+extern ULONG NtGlobalFlag;
+extern ULONG ExpInitializationPhase;
+
+typedef struct _EXHANDLE
+{
+ union
+ {
+ struct
+ {
+ ULONG TagBits:2;
+ ULONG Index:30;
+ };
+ HANDLE GenericHandleOverlay;
+ ULONG_PTR Value;
+ };
+} EXHANDLE, *PEXHANDLE;
+
+typedef struct _ETIMER
+{
+ KTIMER KeTimer;
+ KAPC TimerApc;
+ KDPC TimerDpc;
+ LIST_ENTRY ActiveTimerListEntry;
+ KSPIN_LOCK Lock;
+ LONG Period;
+ BOOLEAN ApcAssociated;
+ BOOLEAN WakeTimer;
+ LIST_ENTRY WakeTimerListEntry;
+} ETIMER, *PETIMER;
+
+typedef struct
+{
+ PCALLBACK_OBJECT *CallbackObject;
+ PWSTR Name;
+} SYSTEM_CALLBACKS;
#define MAX_FAST_REFS 7
-#define EX_OBJ_TO_HDR(eob) ((POBJECT_HEADER)((ULONG_PTR)(eob) & \
- ~(EX_HANDLE_ENTRY_PROTECTFROMCLOSE | EX_HANDLE_ENTRY_INHERITABLE | \
- EX_HANDLE_ENTRY_AUDITONCLOSE)))
-#define EX_HTE_TO_HDR(hte) ((POBJECT_HEADER)((ULONG_PTR)((hte)->Object) & \
- ~(EX_HANDLE_ENTRY_PROTECTFROMCLOSE | EX_HANDLE_ENTRY_INHERITABLE | \
- EX_HANDLE_ENTRY_AUDITONCLOSE)))
-
/* Note: we only use a spinlock on SMP. On UP, we cli/sti intead */
#ifndef CONFIG_SMP
#define ExAcquireResourceLock(l, i) { \
(void)i; \
- Ke386DisableInterrupts(); \
+ _disable(); \
}
-#define ExReleaseResourceLock(l, i) Ke386EnableInterrupts();
+#define ExReleaseResourceLock(l, i) _enable();
#else
#define ExAcquireResourceLock(l, i) KeAcquireSpinLock(l, i);
#define ExReleaseResourceLock(l, i) KeReleaseSpinLock(l, i);
#define ExInitializeRundownProtection _ExInitializeRundownProtection
#define ExWaitForRundownProtectionRelease _ExWaitForRundownProtectionRelease
#define ExRundownCompleted _ExRundownCompleted
+#define ExGetPreviousMode KeGetPreviousMode
+
+
+//
+// Various bits tagged on the handle or handle table
+//
+#define EXHANDLE_TABLE_ENTRY_LOCK_BIT 1
+#define FREE_HANDLE_MASK -1
+
+//
+// Number of entries in each table level
+//
+#define LOW_LEVEL_ENTRIES (PAGE_SIZE / sizeof(HANDLE_TABLE_ENTRY))
+#define MID_LEVEL_ENTRIES (PAGE_SIZE / sizeof(PHANDLE_TABLE_ENTRY))
+#define HIGH_LEVEL_ENTRIES (65535 / (LOW_LEVEL_ENTRIES * MID_LEVEL_ENTRIES))
+
+//
+// Maximum index in each table level before we need another table
+//
+#define MAX_LOW_INDEX LOW_LEVEL_ENTRIES
+#define MAX_MID_INDEX (MID_LEVEL_ENTRIES * LOW_LEVEL_ENTRIES)
+#define MAX_HIGH_INDEX (MID_LEVEL_ENTRIES * MID_LEVEL_ENTRIES * LOW_LEVEL_ENTRIES)
+
+//
+// Detect GCC 4.1.2+
+//
+#if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40102
+
+//
+// Broken GCC with Alignment Bug. We'll do alignment ourselves at higher cost.
+//
+#define DEFINE_WAIT_BLOCK(x) \
+ struct _AlignHack \
+ { \
+ UCHAR Hack[15]; \
+ EX_PUSH_LOCK_WAIT_BLOCK UnalignedBlock; \
+ } WaitBlockBuffer; \
+ PEX_PUSH_LOCK_WAIT_BLOCK x = (PEX_PUSH_LOCK_WAIT_BLOCK) \
+ ((ULONG_PTR)&WaitBlockBuffer.UnalignedBlock &~ 0xF);
+
+#else
+
+//
+// This is only for compatibility; the compiler will optimize the extra
+// local variable (the actual pointer) away, so we don't take any perf hit
+// by doing this.
+//
+#define DEFINE_WAIT_BLOCK(x) \
+ EX_PUSH_LOCK_WAIT_BLOCK WaitBlockBuffer; \
+ PEX_PUSH_LOCK_WAIT_BLOCK x = &WaitBlockBuffer;
+
+#endif
/* INITIALIZATION FUNCTIONS *************************************************/
VOID
NTAPI
-ExPhase2Init(
+Phase1Initialization(
IN PVOID Context
);
VOID
NTAPI
-ExpInitTimeZoneInfo(VOID);
+ExpInitializePushLocks(VOID);
+
+BOOLEAN
+NTAPI
+ExRefreshTimeZoneInformation(
+ IN PLARGE_INTEGER SystemBootTime
+);
VOID
NTAPI
IN PLIST_ENTRY ListHead
);
-VOID
+BOOLEAN
NTAPI
ExpInitializeCallbacks(VOID);
NTAPI
ExInitPoolLookasidePointers(VOID);
+/* Callback Functions ********************************************************/
+
+VOID
+NTAPI
+ExInitializeCallBack(
+ IN OUT PEX_CALLBACK Callback
+);
+
+PEX_CALLBACK_ROUTINE_BLOCK
+NTAPI
+ExAllocateCallBack(
+ IN PEX_CALLBACK_FUNCTION Function,
+ IN PVOID Context
+);
+
+VOID
+NTAPI
+ExFreeCallBack(
+ IN PEX_CALLBACK_ROUTINE_BLOCK CallbackRoutineBlock
+);
+
+BOOLEAN
+NTAPI
+ExCompareExchangeCallBack (
+ IN OUT PEX_CALLBACK CallBack,
+ IN PEX_CALLBACK_ROUTINE_BLOCK NewBlock,
+ IN PEX_CALLBACK_ROUTINE_BLOCK OldBlock
+);
+
+PEX_CALLBACK_ROUTINE_BLOCK
+NTAPI
+ExReferenceCallBackBlock(
+ IN OUT PEX_CALLBACK CallBack
+);
+
+VOID
+NTAPI
+ExDereferenceCallBackBlock(
+ IN OUT PEX_CALLBACK CallBack,
+ IN PEX_CALLBACK_ROUTINE_BLOCK CallbackRoutineBlock
+);
+
+PEX_CALLBACK_FUNCTION
+NTAPI
+ExGetCallBackBlockRoutine(
+ IN PEX_CALLBACK_ROUTINE_BLOCK CallbackRoutineBlock
+);
+
+PVOID
+NTAPI
+ExGetCallBackBlockContext(
+ IN PEX_CALLBACK_ROUTINE_BLOCK CallbackRoutineBlock
+);
+
+VOID
+NTAPI
+ExWaitForCallBacks(
+ IN PEX_CALLBACK_ROUTINE_BLOCK CallbackRoutineBlock
+);
+
/* Rundown Functions ********************************************************/
VOID
/* HANDLE TABLE FUNCTIONS ***************************************************/
-#define EX_HANDLE_ENTRY_LOCKED (1 << ((sizeof(PVOID) * 8) - 1))
-#define EX_HANDLE_ENTRY_PROTECTFROMCLOSE (1 << 0)
-#define EX_HANDLE_ENTRY_INHERITABLE (1 << 1)
-#define EX_HANDLE_ENTRY_AUDITONCLOSE (1 << 2)
-
-#define EX_HANDLE_TABLE_CLOSING 0x1
-
-#define EX_HANDLE_ENTRY_FLAGSMASK (EX_HANDLE_ENTRY_LOCKED | \
- EX_HANDLE_ENTRY_PROTECTFROMCLOSE | \
- EX_HANDLE_ENTRY_INHERITABLE | \
- EX_HANDLE_ENTRY_AUDITONCLOSE)
-
-typedef VOID (NTAPI PEX_SWEEP_HANDLE_CALLBACK)(
+typedef BOOLEAN
+(NTAPI *PEX_SWEEP_HANDLE_CALLBACK)(
PHANDLE_TABLE_ENTRY HandleTableEntry,
- HANDLE Handle,
+ HANDLE Handle,
PVOID Context
);
-typedef BOOLEAN (NTAPI PEX_DUPLICATE_HANDLE_CALLBACK)(
- PHANDLE_TABLE HandleTable,
- PHANDLE_TABLE_ENTRY HandleTableEntry,
- PVOID Context
-);
-
-typedef BOOLEAN (NTAPI PEX_CHANGE_HANDLE_CALLBACK)(
- PHANDLE_TABLE HandleTable,
- PHANDLE_TABLE_ENTRY HandleTableEntry,
- 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
);
-VOID
-ExpInitializeHandleTables(VOID);
-
-PHANDLE_TABLE
-ExCreateHandleTable(IN PEPROCESS QuotaProcess OPTIONAL);
-
-VOID
-ExDestroyHandleTable(
- IN PHANDLE_TABLE HandleTable
+typedef BOOLEAN
+(NTAPI *PEX_CHANGE_HANDLE_CALLBACK)(
+ PHANDLE_TABLE_ENTRY HandleTableEntry,
+ ULONG_PTR Context
);
VOID
-ExSweepHandleTable(
- IN PHANDLE_TABLE HandleTable,
- IN PEX_SWEEP_HANDLE_CALLBACK SweepHandleCallback OPTIONAL,
- IN PVOID Context OPTIONAL
+NTAPI
+ExpInitializeHandleTables(
+ VOID
);
PHANDLE_TABLE
-ExDupHandleTable(
- IN PEPROCESS QuotaProcess OPTIONAL,
- IN PEX_DUPLICATE_HANDLE_CALLBACK DuplicateHandleCallback OPTIONAL,
- IN PVOID Context OPTIONAL,
- IN PHANDLE_TABLE SourceHandleTable
-);
-
-BOOLEAN
-ExLockHandleTableEntry(
- IN PHANDLE_TABLE HandleTable,
- IN PHANDLE_TABLE_ENTRY Entry
+NTAPI
+ExCreateHandleTable(
+ IN PEPROCESS Process OPTIONAL
);
VOID
+NTAPI
ExUnlockHandleTableEntry(
IN PHANDLE_TABLE HandleTable,
- IN PHANDLE_TABLE_ENTRY Entry
+ IN PHANDLE_TABLE_ENTRY HandleTableEntry
);
HANDLE
+NTAPI
ExCreateHandle(
IN PHANDLE_TABLE HandleTable,
- IN PHANDLE_TABLE_ENTRY Entry
+ IN PHANDLE_TABLE_ENTRY HandleTableEntry
);
-BOOLEAN
-ExDestroyHandle(
+VOID
+NTAPI
+ExDestroyHandleTable(
IN PHANDLE_TABLE HandleTable,
- IN HANDLE Handle
+ IN PVOID DestroyHandleProcedure OPTIONAL
);
-VOID
-ExDestroyHandleByEntry(
+BOOLEAN
+NTAPI
+ExDestroyHandle(
IN PHANDLE_TABLE HandleTable,
- IN PHANDLE_TABLE_ENTRY Entry,
- IN HANDLE Handle
+ IN HANDLE Handle,
+ IN PHANDLE_TABLE_ENTRY HandleTableEntry OPTIONAL
);
PHANDLE_TABLE_ENTRY
+NTAPI
ExMapHandleToPointer(
IN PHANDLE_TABLE HandleTable,
IN HANDLE Handle
);
+PHANDLE_TABLE
+NTAPI
+ExDupHandleTable(
+ IN PEPROCESS Process,
+ IN PHANDLE_TABLE HandleTable,
+ IN PEX_DUPLICATE_HANDLE_CALLBACK DupHandleProcedure,
+ IN ULONG_PTR Mask
+);
+
BOOLEAN
+NTAPI
ExChangeHandle(
IN PHANDLE_TABLE HandleTable,
IN HANDLE Handle,
- IN PEX_CHANGE_HANDLE_CALLBACK ChangeHandleCallback,
+ IN PEX_CHANGE_HANDLE_CALLBACK ChangeRoutine,
+ IN ULONG_PTR Context
+);
+
+VOID
+NTAPI
+ExSweepHandleTable(
+ IN PHANDLE_TABLE HandleTable,
+ IN PEX_SWEEP_HANDLE_CALLBACK EnumHandleProcedure,
IN PVOID Context
);
return ExSystemExceptionFilter();
}
+/* CALLBACKS *****************************************************************/
+
+VOID
+FORCEINLINE
+ExDoCallBack(IN OUT PEX_CALLBACK Callback,
+ IN PVOID Context,
+ IN PVOID Argument1,
+ IN PVOID Argument2)
+{
+ PEX_CALLBACK_ROUTINE_BLOCK CallbackRoutineBlock;
+ PEX_CALLBACK_FUNCTION Function;
+
+ /* Reference the block */
+ CallbackRoutineBlock = ExReferenceCallBackBlock(Callback);
+ if (CallbackRoutineBlock)
+ {
+ /* Get the function */
+ Function = ExGetCallBackBlockRoutine(CallbackRoutineBlock);
+
+ /* Do the callback */
+ Function(Context, Argument1, Argument2);
+
+ /* Now dereference it */
+ ExDereferenceCallBackBlock(Callback, CallbackRoutineBlock);
+ }
+}
+
/* RUNDOWN *******************************************************************/
#ifdef _WIN64
#define ExpSetRundown(x, y) InterlockedExchange64((PLONGLONG)x, y)
#else
#define ExpChangeRundown(x, y, z) InterlockedCompareExchange((PLONG)x, PtrToLong(y), PtrToLong(z))
+#define ExpChangePushlock(x, y, z) LongToPtr(InterlockedCompareExchange((PLONG)x, PtrToLong(y), PtrToLong(z)))
#define ExpSetRundown(x, y) InterlockedExchange((PLONG)x, y)
#endif
FORCEINLINE
_ExAcquireRundownProtection(IN PEX_RUNDOWN_REF RunRef)
{
- ULONG_PTR Value, NewValue, OldValue;
+ ULONG_PTR Value, NewValue;
/* Get the current value and mask the active bit */
Value = RunRef->Count &~ EX_RUNDOWN_ACTIVE;
NewValue = Value + EX_RUNDOWN_COUNT_INC;
/* Change the value */
- OldValue = ExpChangeRundown(RunRef, NewValue, Value);
- if (OldValue != Value)
+ NewValue = ExpChangeRundown(RunRef, NewValue, Value);
+ if (NewValue != Value)
{
/* Rundown was active, use long path */
return ExfAcquireRundownProtection(RunRef);
FORCEINLINE
_ExReleaseRundownProtection(IN PEX_RUNDOWN_REF RunRef)
{
- ULONG_PTR Value, NewValue, OldValue;
+ ULONG_PTR Value, NewValue;
/* Get the current value and mask the active bit */
Value = RunRef->Count &~ EX_RUNDOWN_ACTIVE;
NewValue = Value - EX_RUNDOWN_COUNT_INC;
/* Change the value */
- OldValue = ExpChangeRundown(RunRef, NewValue, Value);
+ NewValue = ExpChangeRundown(RunRef, NewValue, Value);
/* Check if the rundown was active */
- if (OldValue != Value)
+ if (NewValue != Value)
{
/* Rundown was active, use long path */
ExfReleaseRundownProtection(RunRef);
/* Set the active bit */
Value = ExpChangeRundown(RunRef, EX_RUNDOWN_ACTIVE, 0);
- if ((Value) || (Value != EX_RUNDOWN_ACTIVE))
+ if ((Value) && (Value != EX_RUNDOWN_ACTIVE))
{
/* If the the rundown wasn't already active, then take the long path */
ExfWaitForRundownProtectionRelease(RunRef);
/* PUSHLOCKS *****************************************************************/
+/* FIXME: VERIFY THESE! */
+
+VOID
+FASTCALL
+ExBlockPushLock(
+ IN PEX_PUSH_LOCK PushLock,
+ IN PVOID WaitBlock
+);
+
+VOID
+FASTCALL
+ExfUnblockPushLock(
+ IN PEX_PUSH_LOCK PushLock,
+ IN PVOID CurrentWaitBlock
+);
+
+VOID
+FASTCALL
+ExWaitForUnblockPushLock(
+ IN PEX_PUSH_LOCK PushLock,
+ IN PVOID WaitBlock
+);
+
+/*++
+ * @name ExInitializePushLock
+ * INTERNAL MACRO
+ *
+ * The ExInitializePushLock macro initializes a PushLock.
+ *
+ * @params PushLock
+ * Pointer to the pushlock which is to be initialized.
+ *
+ * @return None.
+ *
+ * @remarks None.
+ *
+ *--*/
+VOID
+FORCEINLINE
+ExInitializePushLock(IN PULONG_PTR PushLock)
+{
+ /* Set the value to 0 */
+ *PushLock = 0;
+}
+
/*++
* @name ExAcquirePushLockExclusive
* INTERNAL MACRO
/* Try acquiring the lock */
NewValue.Value = EX_PUSH_LOCK_LOCK | EX_PUSH_LOCK_SHARE_INC;
- if (InterlockedCompareExchangePointer(PushLock, NewValue.Ptr, 0))
+ if (ExpChangePushlock(PushLock, NewValue.Ptr, 0))
{
/* Someone changed it, use the slow path */
DbgPrint("%s - Contention!\n", __FUNCTION__);
ASSERT(PushLock->Waiting || PushLock->Shared > 0);
}
+/*++
+ * @name ExConvertPushLockSharedToExclusive
+ * INTERNAL MACRO
+ *
+ * The ExConvertPushLockSharedToExclusive macro converts an exclusive
+ * pushlock to a shared pushlock.
+ *
+ * @params PushLock
+ * Pointer to the pushlock which is to be converted.
+ *
+ * @return FALSE if conversion failed, TRUE otherwise.
+ *
+ * @remarks The function attempts the quickest route to convert the lock, which is
+ * to simply set the lock bit and remove any other bits.
+ *
+ *--*/
+BOOLEAN
+FORCEINLINE
+ExConvertPushLockSharedToExclusive(IN PEX_PUSH_LOCK PushLock)
+{
+ EX_PUSH_LOCK OldValue;
+
+ /* Set the expected old value */
+ OldValue.Value = EX_PUSH_LOCK_LOCK | EX_PUSH_LOCK_SHARE_INC;
+
+ /* Try converting the lock */
+ if (ExpChangePushlock(PushLock, EX_PUSH_LOCK_LOCK, OldValue.Value) !=
+ OldValue.Ptr)
+ {
+ /* Conversion failed */
+ return FALSE;
+ }
+
+ /* Sanity check */
+ ASSERT(PushLock->Locked);
+ return TRUE;
+}
+
/*++
* @name ExWaitOnPushLock
* INTERNAL MACRO
VOID
FORCEINLINE
ExWaitOnPushLock(PEX_PUSH_LOCK PushLock)
-{
- /* Acquire the lock */
- ExfAcquirePushLockExclusive(PushLock);
- ASSERT(PushLock->Locked);
+{
+ /* Check if we're locked */
+ if (PushLock->Locked)
+ {
+ /* Acquire the lock */
+ ExfAcquirePushLockExclusive(PushLock);
+ ASSERT(PushLock->Locked);
- /* Release it */
- ExfReleasePushLockExclusive(PushLock);
+ /* Release it */
+ ExfReleasePushLockExclusive(PushLock);
+ }
}
/*++
/* Try to clear the pushlock */
OldValue.Value = EX_PUSH_LOCK_LOCK | EX_PUSH_LOCK_SHARE_INC;
- if (InterlockedCompareExchangePointer(PushLock, 0, OldValue.Ptr) !=
- OldValue.Ptr)
+ if (ExpChangePushlock(PushLock, 0, OldValue.Ptr) != OldValue.Ptr)
{
/* There are still other people waiting on it */
DbgPrint("%s - Contention!\n", __FUNCTION__);
ASSERT(PushLock->Waiting || PushLock->Shared == 0);
/* Unlock the pushlock */
- OldValue.Value = InterlockedExchangeAddSizeT((PLONG)PushLock, -1);
+ OldValue.Value = InterlockedExchangeAddSizeT((PLONG)PushLock,
+ -(LONG)EX_PUSH_LOCK_LOCK);
/* Sanity checks */
ASSERT(OldValue.Locked);
/* Check if nobody is waiting on us and try clearing the lock here */
if ((OldValue.Waiting) ||
- (InterlockedCompareExchangePointer(PushLock, NewValue.Ptr, OldValue.Ptr) ==
+ (ExpChangePushlock(PushLock, NewValue.Ptr, OldValue.Ptr) !=
OldValue.Ptr))
{
/* We have waiters, use the long path */
NTSTATUS
ExpSetTimeZoneInformation(PTIME_ZONE_INFORMATION TimeZoneInformation);
+BOOLEAN
+NTAPI
+ExAcquireTimeRefreshLock(BOOLEAN Wait);
+
+VOID
+NTAPI
+ExReleaseTimeRefreshLock(VOID);
+
+VOID
+NTAPI
+ExUpdateSystemTimeFromCmos(IN BOOLEAN UpdateInterruptTime,
+ IN ULONG MaxSepInSeconds);
+
NTSTATUS
NTAPI
ExpAllocateLocallyUniqueId(OUT LUID *LocallyUniqueId);
projects / reactos.git / blobdiff