//
// Returns whether or not this is a small valued key
//
-BOOLEAN
FORCEINLINE
+BOOLEAN
CmpIsKeyValueSmall(OUT PULONG RealLength,
IN ULONG Length)
{
//
// Returns whether or not this is a big valued key
//
-BOOLEAN
FORCEINLINE
+BOOLEAN
CmpIsKeyValueBig(IN PHHIVE Hive,
IN ULONG Length)
{
/* CALLBACKS *****************************************************************/
-VOID
FORCEINLINE
+VOID
ExDoCallBack(IN OUT PEX_CALLBACK Callback,
IN PVOID Context,
IN PVOID Argument1,
#define ExpChangeRundown(x, y, z) InterlockedCompareExchange64((PLONGLONG)x, y, z)
#define ExpSetRundown(x, y) InterlockedExchange64((PLONGLONG)x, y)
#else
-#define ExpChangeRundown(x, y, z) InterlockedCompareExchange((PLONG)x, PtrToLong(y), PtrToLong(z))
+#define ExpChangeRundown(x, y, z) PtrToUlong(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
* function.
*
*--*/
-BOOLEAN
FORCEINLINE
+BOOLEAN
_ExAcquireRundownProtection(IN PEX_RUNDOWN_REF RunRef)
{
ULONG_PTR Value, NewValue;
* function.
*
*--*/
-VOID
FORCEINLINE
+VOID
_ExReleaseRundownProtection(IN PEX_RUNDOWN_REF RunRef)
{
ULONG_PTR Value, NewValue;
* @remarks This is the internal macro for system use only.
*
*--*/
-VOID
FORCEINLINE
+VOID
_ExInitializeRundownProtection(IN PEX_RUNDOWN_REF RunRef)
{
/* Set the count to zero */
* necessary, then the slow path is taken through the exported function.
*
*--*/
-VOID
FORCEINLINE
+VOID
_ExWaitForRundownProtectionRelease(IN PEX_RUNDOWN_REF RunRef)
{
ULONG_PTR Value;
* @remarks This is the internal macro for system use only.
*
*--*/
-VOID
FORCEINLINE
+VOID
_ExRundownCompleted(IN PEX_RUNDOWN_REF RunRef)
{
/* Sanity check */
* @remarks None.
*
*--*/
-VOID
FORCEINLINE
+VOID
ExInitializePushLock(IN PULONG_PTR PushLock)
{
/* Set the value to 0 */
* This macro should usually be paired up with KeAcquireCriticalRegion.
*
*--*/
-VOID
FORCEINLINE
+VOID
ExAcquirePushLockExclusive(PEX_PUSH_LOCK PushLock)
{
/* Try acquiring the lock */
* This macro should usually be paired up with KeAcquireCriticalRegion.
*
*--*/
-BOOLEAN
FORCEINLINE
+BOOLEAN
ExTryToAcquirePushLockExclusive(PEX_PUSH_LOCK PushLock)
{
/* Try acquiring the lock */
* This macro should usually be paired up with KeAcquireCriticalRegion.
*
*--*/
-VOID
FORCEINLINE
+VOID
ExAcquirePushLockShared(PEX_PUSH_LOCK PushLock)
{
EX_PUSH_LOCK NewValue;
* to simply set the lock bit and remove any other bits.
*
*--*/
-BOOLEAN
FORCEINLINE
+BOOLEAN
ExConvertPushLockSharedToExclusive(IN PEX_PUSH_LOCK PushLock)
{
EX_PUSH_LOCK OldValue;
* Callers of ExWaitOnPushLock must be running at IRQL <= APC_LEVEL.
*
*--*/
-VOID
FORCEINLINE
+VOID
ExWaitOnPushLock(PEX_PUSH_LOCK PushLock)
{
/* Check if we're locked */
* This macro should usually be paired up with KeLeaveCriticalRegion.
*
*--*/
-VOID
FORCEINLINE
+VOID
ExReleasePushLockShared(PEX_PUSH_LOCK PushLock)
{
EX_PUSH_LOCK OldValue;
* This macro should usually be paired up with KeLeaveCriticalRegion.
*
*--*/
-VOID
FORCEINLINE
+VOID
ExReleasePushLockExclusive(PEX_PUSH_LOCK PushLock)
{
EX_PUSH_LOCK OldValue;
* This macro should usually be paired up with KeLeaveCriticalRegion.
*
*--*/
-VOID
FORCEINLINE
+VOID
ExReleasePushLock(PEX_PUSH_LOCK PushLock)
{
EX_PUSH_LOCK OldValue = *PushLock;
#elif defined(_MSC_VER)
-VOID
FORCEINLINE
+VOID
Ke386Wrmsr(IN ULONG Register,
IN ULONG Var1,
IN ULONG Var2)
__asm wrmsr;
}
-ULONGLONG
FORCEINLINE
+ULONGLONG
Ke386Rdmsr(IN ULONG Register,
IN ULONG Var1,
IN ULONG Var2)
__asm rdmsr;
}
-VOID
FORCEINLINE
+VOID
Ki386Cpuid(IN ULONG Operation,
OUT PULONG Var1,
OUT PULONG Var2,
__asm mov [Var4], edx;
}
-VOID
FORCEINLINE
+VOID
Ke386FnInit(VOID)
{
__asm fninit;
}
-VOID
FORCEINLINE
+VOID
Ke386HaltProcessor(VOID)
{
__asm hlt;
}
-VOID
FORCEINLINE
+VOID
Ke386GetInterruptDescriptorTable(OUT KDESCRIPTOR Descriptor)
{
__asm sidt Descriptor;
}
-VOID
FORCEINLINE
+VOID
Ke386SetInterruptDescriptorTable(IN KDESCRIPTOR Descriptor)
{
__asm lidt Descriptor;
}
-VOID
FORCEINLINE
+VOID
Ke386GetGlobalDescriptorTable(OUT KDESCRIPTOR Descriptor)
{
__asm sgdt Descriptor;
}
-VOID
FORCEINLINE
+VOID
Ke386SetGlobalDescriptorTable(IN KDESCRIPTOR Descriptor)
{
__asm lgdt Descriptor;
}
-VOID
FORCEINLINE
+VOID
Ke386GetLocalDescriptorTable(OUT USHORT Descriptor)
{
__asm sldt Descriptor;
}
-VOID
FORCEINLINE
+VOID
Ke386SetLocalDescriptorTable(IN USHORT Descriptor)
{
__asm lldt Descriptor;
}
-VOID
FORCEINLINE
+VOID
Ke386SaveFlags(IN ULONG Flags)
{
__asm pushf;
__asm pop Flags;
}
-VOID
FORCEINLINE
+VOID
Ke386RestoreFlags(IN ULONG Flags)
{
__asm push Flags;
__asm popf;
}
-VOID
FORCEINLINE
+VOID
Ke386SetTr(IN USHORT Tr)
{
__asm ltr Tr;
}
-USHORT
FORCEINLINE
+USHORT
Ke386GetTr(IN USHORT Tr)
{
__asm str Tr;
//
// CR Macros
//
-VOID
FORCEINLINE
+VOID
Ke386SetCr2(IN ULONG Value)
{
__asm mov eax, Value;
//
// DR Macros
//
-ULONG
FORCEINLINE
+ULONG
Ke386GetDr0(VOID)
{
__asm mov eax, dr0;
}
-ULONG
FORCEINLINE
+ULONG
Ke386GetDr1(VOID)
{
__asm mov eax, dr1;
}
-ULONG
FORCEINLINE
+ULONG
Ke386GetDr2(VOID)
{
__asm mov eax, dr2;
}
-ULONG
FORCEINLINE
+ULONG
Ke386GetDr3(VOID)
{
__asm mov eax, dr3;
}
-ULONG
FORCEINLINE
+ULONG
Ke386GetDr6(VOID)
{
__asm mov eax, dr6;
}
-ULONG
FORCEINLINE
+ULONG
Ke386GetDr7(VOID)
{
__asm mov eax, dr7;
}
-VOID
FORCEINLINE
+VOID
Ke386SetDr0(IN ULONG Value)
{
__asm mov eax, Value;
__asm mov dr0, eax;
}
-VOID
FORCEINLINE
+VOID
Ke386SetDr1(IN ULONG Value)
{
__asm mov eax, Value;
__asm mov dr1, eax;
}
-VOID
FORCEINLINE
+VOID
Ke386SetDr2(IN ULONG Value)
{
__asm mov eax, Value;
__asm mov dr2, eax;
}
-VOID
FORCEINLINE
+VOID
Ke386SetDr3(IN ULONG Value)
{
__asm mov eax, Value;
__asm mov dr3, eax;
}
-VOID
FORCEINLINE
+VOID
Ke386SetDr6(IN ULONG Value)
{
__asm mov eax, Value;
__asm mov dr6, eax;
}
-VOID
FORCEINLINE
+VOID
Ke386SetDr7(IN ULONG Value)
{
__asm mov eax, Value;
//
// Segment Macros
//
-USHORT
FORCEINLINE
+USHORT
Ke386GetSs(VOID)
{
__asm mov ax, ss;
}
-USHORT
FORCEINLINE
+USHORT
Ke386GetFs(VOID)
{
__asm mov ax, fs;
}
-USHORT
FORCEINLINE
+USHORT
Ke386GetDs(VOID)
{
__asm mov ax, ds;
}
-USHORT
FORCEINLINE
+USHORT
Ke386GetEs(VOID)
{
__asm mov ax, es;
}
-VOID
FORCEINLINE
+VOID
Ke386SetSs(IN USHORT Value)
{
__asm mov ax, Value;
__asm mov ss, ax;
}
-VOID
FORCEINLINE
+VOID
Ke386SetFs(IN USHORT Value)
{
__asm mov ax, Value;
__asm mov fs, ax;
}
-VOID
FORCEINLINE
+VOID
Ke386SetDs(IN USHORT Value)
{
__asm mov ax, Value;
__asm mov ds, ax;
}
-VOID
FORCEINLINE
+VOID
Ke386SetEs(IN USHORT Value)
{
__asm mov ax, Value;
* PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
*/
+static
+__inline
VOID
-static __inline
IopLockFileObject(IN PFILE_OBJECT FileObject)
{
/* Lock the FO and check for contention */
InterlockedDecrement((PLONG)&FileObject->Waiters);
}
+static
+__inline
VOID
-static __inline
IopUnlockFileObject(IN PFILE_OBJECT FileObject)
{
/* Unlock the FO and wake any waiters up */
if (FileObject->Waiters) KeSetEvent(&FileObject->Lock, 0, FALSE);
}
-VOID
FORCEINLINE
+VOID
IopQueueIrpToThread(IN PIRP Irp)
{
KIRQL OldIrql;
KeLowerIrql(OldIrql);
}
-VOID
FORCEINLINE
+VOID
IopUnQueueIrpFromThread(IN PIRP Irp)
{
/* Remove it from the list and reset it */
InitializeListHead(&Irp->ThreadListEntry);
}
+static
+__inline
VOID
-static __inline
IopUpdateOperationCount(IN IOP_TRANSFER_TYPE Type)
{
PLARGE_INTEGER CountToChange;
}
}
+static
+__inline
BOOLEAN
-static __inline
IopValidateOpenPacket(IN POPEN_PACKET OpenPacket)
{
/* Validate the packet */
#endif /* _M_IX86 */
#ifndef _M_ARM
-PRKTHREAD
FORCEINLINE
+PRKTHREAD
KeGetCurrentThread(VOID)
{
#ifdef _M_IX86
#endif
}
-UCHAR
FORCEINLINE
+UCHAR
KeGetPreviousMode(VOID)
{
/* Return the current mode */
}
#endif
-VOID
FORCEINLINE
+VOID
KeFlushProcessTb(VOID)
{
/* Flush the TLB by resetting CR3 */
//
// This routine protects against multiple CPU acquires, it's meaningless on UP.
//
-VOID
FORCEINLINE
+VOID
KiAcquireDispatcherObject(IN DISPATCHER_HEADER* Object)
{
UNREFERENCED_PARAMETER(Object);
//
// This routine protects against multiple CPU acquires, it's meaningless on UP.
//
-VOID
FORCEINLINE
+VOID
KiReleaseDispatcherObject(IN DISPATCHER_HEADER* Object)
{
UNREFERENCED_PARAMETER(Object);
}
-KIRQL
FORCEINLINE
+KIRQL
KiAcquireDispatcherLock(VOID)
{
/* Raise to DPC level */
return KeRaiseIrqlToDpcLevel();
}
-VOID
FORCEINLINE
+VOID
KiReleaseDispatcherLock(IN KIRQL OldIrql)
{
/* Just exit the dispatcher */
KiExitDispatcher(OldIrql);
}
-VOID
FORCEINLINE
+VOID
KiAcquireDispatcherLockAtDpcLevel(VOID)
{
/* This is a no-op at DPC Level for UP systems */
return;
}
-VOID
FORCEINLINE
+VOID
KiReleaseDispatcherLockFromDpcLevel(VOID)
{
/* This is a no-op at DPC Level for UP systems */
InterlockedAnd((PLONG)SpinLock, 0);
}
-VOID
FORCEINLINE
+VOID
KiAcquireDispatcherObject(IN DISPATCHER_HEADER* Object)
{
LONG OldValue;
OldValue) != OldValue);
}
-VOID
FORCEINLINE
+VOID
KiReleaseDispatcherObject(IN DISPATCHER_HEADER* Object)
{
/* Make sure we're at a safe level to touch the lock */
InterlockedAnd(&Object->Lock, ~KOBJECT_LOCK_BIT);
}
-KIRQL
FORCEINLINE
+KIRQL
KiAcquireDispatcherLock(VOID)
{
/* Raise to synchronization level and acquire the dispatcher lock */
return KeAcquireQueuedSpinLockRaiseToSynch(LockQueueDispatcherLock);
}
-VOID
FORCEINLINE
+VOID
KiReleaseDispatcherLock(IN KIRQL OldIrql)
{
/* First release the lock */
KiExitDispatcher(OldIrql);
}
-VOID
FORCEINLINE
+VOID
KiAcquireDispatcherLockAtDpcLevel(VOID)
{
/* Acquire the dispatcher lock */
KeAcquireQueuedSpinLockAtDpcLevel(LockQueueDispatcherLock);
}
-VOID
FORCEINLINE
+VOID
KiReleaseDispatcherLockFromDpcLevel(VOID)
{
/* Release the dispatcher lock */
//
// Recalculates the due time
//
-PLARGE_INTEGER
FORCEINLINE
+PLARGE_INTEGER
KiRecalculateDueTime(IN PLARGE_INTEGER OriginalDueTime,
IN PLARGE_INTEGER DueTime,
IN OUT PLARGE_INTEGER NewDueTime)
// Called from KiCompleteTimer, KiInsertTreeTimer, KeSetSystemTime
// to remove timer entries
// See Windows HPI blog for more information.
-VOID
FORCEINLINE
+VOID
KiRemoveEntryTimer(IN PKTIMER Timer)
{
ULONG Hand;
// Called by Wait and Queue code to insert a timer for dispatching.
// Also called by KeSetTimerEx to insert a timer from the caller.
//
-VOID
FORCEINLINE
+VOID
KxInsertTimer(IN PKTIMER Timer,
IN ULONG Hand)
{
// Called by KeSetTimerEx and KiInsertTreeTimer to calculate Due Time
// See the Windows HPI Blog for more information
//
-BOOLEAN
FORCEINLINE
+BOOLEAN
KiComputeDueTime(IN PKTIMER Timer,
IN LARGE_INTEGER DueTime,
OUT PULONG Hand)
// Also called by timer code when canceling an inserted timer.
// Removes a timer from it's tree.
//
-VOID
FORCEINLINE
+VOID
KxRemoveTreeTimer(IN PKTIMER Timer)
{
ULONG Hand = Timer->Header.Hand;
KiReleaseTimerLock(LockQueue);
}
-VOID
FORCEINLINE
+VOID
KxSetTimerForThreadWait(IN PKTIMER Timer,
IN LARGE_INTEGER Interval,
OUT PULONG Hand)
KiSelectReadyThread(IN KPRIORITY Priority,
IN PKPRCB Prcb)
{
- ULONG PrioritySet, HighPriority;
+ ULONG PrioritySet;
+ LONG HighPriority;
PLIST_ENTRY ListEntry;
PKTHREAD Thread = NULL;
// This routine computes the new priority for a thread. It is only valid for
// threads with priorities in the dynamic priority range.
//
-SCHAR
FORCEINLINE
+SCHAR
KiComputeNewPriority(IN PKTHREAD Thread,
IN SCHAR Adjustment)
{
//\r
// Allocates a new message\r
//\r
-PLPCP_MESSAGE\r
FORCEINLINE\r
+PLPCP_MESSAGE\r
LpcpAllocateFromPortZone(VOID)\r
{\r
PLPCP_MESSAGE Message;\r
//\r
// Get the LPC Message associated to the Thread\r
//\r
-PLPCP_MESSAGE\r
FORCEINLINE\r
+PLPCP_MESSAGE\r
LpcpGetMessageFromThread(IN PETHREAD Thread)\r
{\r
/* Check if the port flag is set */\r
return (PVOID)((ULONG_PTR)Thread->LpcReplyMessage & ~LPCP_THREAD_FLAGS);\r
}\r
\r
-PLPCP_PORT_OBJECT\r
FORCEINLINE\r
+PLPCP_PORT_OBJECT\r
LpcpGetPortFromThread(IN PETHREAD Thread)\r
{\r
/* Check if the port flag is set */\r
return NULL;\r
}\r
\r
-VOID\r
FORCEINLINE\r
+VOID\r
LpcpSetPortToThread(IN PETHREAD Thread,\r
IN PLPCP_PORT_OBJECT Port)\r
{\r
#define InterlockedCompareExchangePte(PointerPte, Exchange, Comperand) \
- InterlockedCompareExchange((PLONG)(PointerPte), Exchange, Comperand)
+ (ULONG)InterlockedCompareExchange((PLONG)(PointerPte), Exchange, Comperand)
#define InterlockedExchangePte(PointerPte, Value) \
- InterlockedExchange((PLONG)(PointerPte), Value)
+ (ULONG)InterlockedExchange((PLONG)(PointerPte), Value)
typedef struct
{
NTAPI
MmGetLockCountPage(PFN_TYPE Page);
-static __inline
+static
+__inline
KIRQL
NTAPI
MmAcquirePageListLock()
#define OBP_NAME_LOOKASIDE_MAX_SIZE 248
-ULONG
FORCEINLINE
+ULONG
ObpSelectObjectLockSlot(IN POBJECT_HEADER ObjectHeader)
{
/* We have 4 locks total, this will return a 0-index slot */
return (((ULONG_PTR)ObjectHeader) >> 8) & 3;
}
-VOID
FORCEINLINE
+VOID
ObpAcquireObjectLock(IN POBJECT_HEADER ObjectHeader)
{
ULONG Slot;
ExAcquireResourceExclusiveLite(&ObjectType->ObjectLocks[Slot], TRUE);
}
-VOID
FORCEINLINE
+VOID
ObpAcquireObjectLockShared(IN POBJECT_HEADER ObjectHeader)
{
ULONG Slot;
ExAcquireResourceSharedLite(&ObjectType->ObjectLocks[Slot], TRUE);
}
-VOID
FORCEINLINE
+VOID
ObpReleaseObjectLock(IN POBJECT_HEADER ObjectHeader)
{
ULONG Slot;
ASSERT(KeGetCurrentIrql() <= APC_LEVEL);
}
-POBJECT_HEADER_NAME_INFO
FORCEINLINE
+POBJECT_HEADER_NAME_INFO
ObpReferenceNameInfo(IN POBJECT_HEADER ObjectHeader)
{
POBJECT_HEADER_NAME_INFO ObjectNameInfo;
return ObjectNameInfo;
}
-VOID
FORCEINLINE
+VOID
ObpDereferenceNameInfo(IN POBJECT_HEADER_NAME_INFO HeaderNameInfo)
{
POBJECT_DIRECTORY Directory;
}
}
-VOID
FORCEINLINE
+VOID
ObpAcquireDirectoryLockShared(IN POBJECT_DIRECTORY Directory,
IN POBP_LOOKUP_CONTEXT Context)
{
Context->LockStateSignature = OBP_LOCK_STATE_POST_ACQUISITION_SHARED;
}
-VOID
FORCEINLINE
+VOID
ObpAcquireDirectoryLockExclusive(IN POBJECT_DIRECTORY Directory,
IN POBP_LOOKUP_CONTEXT Context)
{
Context->DirectoryLocked = TRUE;
}
-VOID
FORCEINLINE
+VOID
ObpReleaseDirectoryLock(IN POBJECT_DIRECTORY Directory,
IN POBP_LOOKUP_CONTEXT Context)
{
KeLeaveCriticalRegion();
}
-VOID
FORCEINLINE
+VOID
ObpInitializeLookupContext(IN POBP_LOOKUP_CONTEXT Context)
{
/* Initialize a null context */
Context->LockStateSignature = OBP_LOCK_STATE_INITIALIZED;
}
-VOID
FORCEINLINE
+VOID
ObpReleaseLookupContextObject(IN POBP_LOOKUP_CONTEXT Context)
{
POBJECT_HEADER ObjectHeader;
}
}
-VOID
FORCEINLINE
+VOID
ObpReleaseLookupContext(IN POBP_LOOKUP_CONTEXT Context)
{
/* Check if we came back with the directory locked */
ObpReleaseLookupContextObject(Context);
}
-VOID
FORCEINLINE
+VOID
ObpEnterObjectTypeMutex(IN POBJECT_TYPE ObjectType)
{
/* Sanity check */
ExAcquireResourceExclusiveLite(&ObjectType->Mutex, TRUE);
}
-VOID
FORCEINLINE
+VOID
ObpLeaveObjectTypeMutex(IN POBJECT_TYPE ObjectType)
{
/* Enter a critical region and acquire the resource */
ASSERT(KeGetCurrentIrql() <= APC_LEVEL);
}
-VOID
FORCEINLINE
+VOID
ObpReleaseObjectCreateInformation(IN POBJECT_CREATE_INFORMATION ObjectCreateInfo)
{
/* Check if we have a security descriptor */
}
}
-PVOID
FORCEINLINE
+PVOID
ObpAllocateObjectCreateInfoBuffer(IN PP_NPAGED_LOOKASIDE_NUMBER Type)
{
PVOID Buffer;
return Buffer;
}
-VOID
FORCEINLINE
+VOID
ObpFreeCapturedAttributes(IN PVOID Buffer,
IN PP_NPAGED_LOOKASIDE_NUMBER Type)
{
}
}
-VOID
FORCEINLINE
+VOID
ObpFreeObjectCreateInformation(IN POBJECT_CREATE_INFORMATION ObjectCreateInfo)
{
/* First release the attributes, then free them from the lookaside list */
}
#if DBG
-VOID
FORCEINLINE
+VOID
ObpCalloutStart(IN PKIRQL CalloutIrql)
{
/* Save the callout IRQL */
*CalloutIrql = KeGetCurrentIrql();
}
-VOID
FORCEINLINE
+VOID
ObpCalloutEnd(IN KIRQL CalloutIrql,
IN PCHAR Procedure,
IN POBJECT_TYPE ObjectType,
}
}
#else
-VOID
FORCEINLINE
+VOID
ObpCalloutStart(IN PKIRQL CalloutIrql)
{
/* No-op */
UNREFERENCED_PARAMETER(CalloutIrql);
}
-VOID
FORCEINLINE
+VOID
ObpCalloutEnd(IN KIRQL CalloutIrql,
IN PCHAR Procedure,
IN POBJECT_TYPE ObjectType,
#define PspClearProcessFlag(Process, Flag) \
InterlockedAnd((PLONG)&Process->Flags, ~Flag)
-VOID
FORCEINLINE
+VOID
PspRunCreateThreadNotifyRoutines(IN PETHREAD CurrentThread,
IN BOOLEAN Create)
{
}
}
-VOID
FORCEINLINE
+VOID
PspRunCreateProcessNotifyRoutines(IN PEPROCESS CurrentProcess,
IN BOOLEAN Create)
{
}
}
-VOID
FORCEINLINE
+VOID
PspRunLoadImageNotifyRoutines(PUNICODE_STRING FullImageName,
HANDLE ProcessId,
PIMAGE_INFO ImageInfo)
}
}
-VOID
FORCEINLINE
+VOID
PspRunLegoRoutine(IN PKTHREAD Thread)
{
/* Call it */
if (PspLegoNotifyRoutine) PspLegoNotifyRoutine(Thread);
}
-VOID
FORCEINLINE
+VOID
PspLockProcessSecurityShared(IN PEPROCESS Process)
{
/* Enter a Critical Region */
ExAcquirePushLockShared(&Process->ProcessLock);
}
-VOID
FORCEINLINE
+VOID
PspUnlockProcessSecurityShared(IN PEPROCESS Process)
{
/* Unlock the Process */
KeLeaveCriticalRegion();
}
-VOID
FORCEINLINE
+VOID
PspLockProcessSecurityExclusive(IN PEPROCESS Process)
{
/* Enter a Critical Region */
ExAcquirePushLockExclusive(&Process->ProcessLock);
}
-VOID
FORCEINLINE
+VOID
PspUnlockProcessSecurityExclusive(IN PEPROCESS Process)
{
/* Unlock the Process */
KeLeaveCriticalRegion();
}
-VOID
FORCEINLINE
+VOID
PspLockThreadSecurityShared(IN PETHREAD Thread)
{
/* Enter a Critical Region */
ExAcquirePushLockShared(&Thread->ThreadLock);
}
-VOID
FORCEINLINE
+VOID
PspUnlockThreadSecurityShared(IN PETHREAD Thread)
{
/* Unlock the Thread */
KeLeaveCriticalRegion();
}
-VOID
FORCEINLINE
+VOID
PspLockThreadSecurityExclusive(IN PETHREAD Thread)
{
/* Enter a Critical Region */
ExAcquirePushLockExclusive(&Thread->ThreadLock);
}
-VOID
FORCEINLINE
+VOID
PspUnlockThreadSecurityExclusive(IN PETHREAD Thread)
{
/* Unlock the Process */
KeLeaveCriticalRegion();
}
-PEPROCESS
FORCEINLINE
+PEPROCESS
_PsGetCurrentProcess(VOID)
{
/* Get the current process */