/* FUNCTIONS ******************************************************************/
-TABLE_SEARCH_RESULT
FORCEINLINE
+TABLE_SEARCH_RESULT
RtlpFindAvlTableNodeOrParent(IN PRTL_AVL_TABLE Table,
IN PVOID Buffer,
OUT PRTL_BALANCED_LINKS *NodeOrParent)
}
}
-VOID
FORCEINLINE
+VOID
RtlPromoteAvlTreeNode(IN PRTL_BALANCED_LINKS Node)
{
PRTL_BALANCED_LINKS ParentNode, SuperParentNode;
RtlSetParent(Node, SuperParentNode);
}
-BOOLEAN
FORCEINLINE
+BOOLEAN
RtlpRebalanceAvlTreeNode(IN PRTL_BALANCED_LINKS Node)
{
PRTL_BALANCED_LINKS ChildNode, SubChildNode;
return TRUE;
}
-VOID
FORCEINLINE
+VOID
RtlpInsertAvlTreeNode(IN PRTL_AVL_TABLE Table,
IN PRTL_BALANCED_LINKS NewNode,
IN OUT PVOID NodeOrParent,
}
}
-VOID
FORCEINLINE
+VOID
RtlpDeleteAvlTreeNode(IN PRTL_AVL_TABLE Table,
IN PRTL_BALANCED_LINKS Node)
{
return NULL;
}
-VOID
FORCEINLINE
+VOID
FsRtlNotifyAcquireFastMutex(IN PREAL_NOTIFY_SYNC RealNotifySync)
{
ULONG_PTR CurrentThread = (ULONG_PTR)KeGetCurrentThread();
}
}
-VOID
FORCEINLINE
+VOID
FsRtlNotifyReleaseFastMutex(IN PREAL_NOTIFY_SYNC RealNotifySync)
{
RealNotifySync->OwnerCount--;
//
// Returns a thread's FPU save area
//
-PFX_SAVE_AREA
FORCEINLINE
+PFX_SAVE_AREA
KiGetThreadNpxArea(IN PKTHREAD Thread)
{
return (PFX_SAVE_AREA)((ULONG_PTR)Thread->InitialStack - sizeof(FX_SAVE_AREA));
//
// Exception with no arguments
//
-VOID
FORCEINLINE
DECLSPEC_NORETURN
+VOID
KiDispatchException0Args(IN NTSTATUS Code,
IN ULONG_PTR Address,
IN PKTRAP_FRAME TrapFrame)
//
// Exception with one argument
//
-VOID
FORCEINLINE
DECLSPEC_NORETURN
+VOID
KiDispatchException1Args(IN NTSTATUS Code,
IN ULONG_PTR Address,
IN ULONG P1,
//
// Exception with two arguments
//
-VOID
FORCEINLINE
DECLSPEC_NORETURN
+VOID
KiDispatchException2Args(IN NTSTATUS Code,
IN ULONG_PTR Address,
IN ULONG P1,
*
*/
#ifdef __GNUC__
-NTSTATUS
FORCEINLINE
+NTSTATUS
KiSystemCallTrampoline(IN PVOID Handler,
IN PVOID Arguments,
IN ULONG StackBytes)
return Result;
}
#elif defined(_MSC_VER)
-NTSTATUS
FORCEINLINE
+NTSTATUS
KiSystemCallTrampoline(IN PVOID Handler,
IN PVOID Arguments,
IN ULONG StackBytes)
//
// Checks for pending APCs
//
-VOID
FORCEINLINE
+VOID
KiCheckForApcDelivery(IN PKTRAP_FRAME TrapFrame)
{
PKTHREAD Thread;
// Converts a base thread to a GUI thread
//
#ifdef __GNUC__
-NTSTATUS
FORCEINLINE
+NTSTATUS
KiConvertToGuiThread(VOID)
{
NTSTATUS Result;
//
// Switches from boot loader to initial kernel stack
//
-VOID
FORCEINLINE
+VOID
KiSwitchToBootStack(IN ULONG_PTR InitialStack)
{
/* We have to switch to a new stack before continuing kernel initialization */
//
// Emits the iret instruction for C code
//
+FORCEINLINE
DECLSPEC_NORETURN
VOID
-FORCEINLINE
KiIret(VOID)
{
#if defined(__GNUC__)
// Normally this is done by the HAL, but on x86 as an optimization, the kernel
// initiates the end by calling back into the HAL and exiting the trap here.
//
-VOID
FORCEINLINE
+VOID
KiEndInterrupt(IN KIRQL Irql,
IN PKTRAP_FRAME TrapFrame)
{
//
// PERF Code
//
-VOID
FORCEINLINE
+VOID
Ki386PerfEnd(VOID)
{
extern ULONGLONG BootCyclesEnd, BootCycles;
//
// Helper Code
//
-BOOLEAN
FORCEINLINE
+BOOLEAN
KiUserTrap(IN PKTRAP_FRAME TrapFrame)
{
/* Anything else but Ring 0 is Ring 3 */
//
// Debug Macros
//
-VOID
FORCEINLINE
+VOID
KiDumpTrapFrame(IN PKTRAP_FRAME TrapFrame)
{
/* Dump the whole thing */
extern BOOLEAN StopChecking;
-VOID
FORCEINLINE
+VOID
KiExitTrapDebugChecks(IN PKTRAP_FRAME TrapFrame,
IN BOOLEAN SkipPreviousMode)
{
StopChecking = FALSE;
}
-VOID
FORCEINLINE
+VOID
KiExitSystemCallDebugChecks(IN ULONG SystemCall,
IN PKTRAP_FRAME TrapFrame)
{
//
// Save user mode debug registers and restore kernel values
//
-VOID
FORCEINLINE
+VOID
KiHandleDebugRegistersOnTrapEntry(
IN PKTRAP_FRAME TrapFrame)
{
__writedr(7, Prcb->ProcessorState.SpecialRegisters.KernelDr7);
}
-VOID
FORCEINLINE
+VOID
KiHandleDebugRegistersOnTrapExit(
PKTRAP_FRAME TrapFrame)
{
//
// Virtual 8086 Mode Optimized Trap Exit
//
-VOID
FORCEINLINE
DECLSPEC_NORETURN
+VOID
KiExitV86Trap(IN PKTRAP_FRAME TrapFrame)
{
PKTHREAD Thread;
//
// Virtual 8086 Mode Optimized Trap Entry
//
-VOID
FORCEINLINE
+VOID
KiEnterV86Trap(IN PKTRAP_FRAME TrapFrame)
{
/* Save exception list */
//
// Interrupt Trap Entry
//
-VOID
FORCEINLINE
+VOID
KiEnterInterruptTrap(IN PKTRAP_FRAME TrapFrame)
{
/* Save exception list and terminate it */
//
// Generic Trap Entry
//
-VOID
FORCEINLINE
+VOID
KiEnterTrap(IN PKTRAP_FRAME TrapFrame)
{
/* Save exception list */
return STATUS_WAIT_0;
}
-ULONG
FORCEINLINE
+ULONG
KiComputeTimerTableIndex(IN ULONGLONG DueTime)
{
return (DueTime / KeMaximumIncrement) & (TIMER_TABLE_SIZE - 1);
ULONG SidStart;
} KNOWN_COMPOUND_ACE, *PKNOWN_COMPOUND_ACE;
-PSID
FORCEINLINE
+PSID
SepGetGroupFromDescriptor(PVOID _Descriptor)
{
PISECURITY_DESCRIPTOR Descriptor = (PISECURITY_DESCRIPTOR)_Descriptor;
}
}
-PSID
FORCEINLINE
+PSID
SepGetOwnerFromDescriptor(PVOID _Descriptor)
{
PISECURITY_DESCRIPTOR Descriptor = (PISECURITY_DESCRIPTOR)_Descriptor;
}
}
-PACL
FORCEINLINE
+PACL
SepGetDaclFromDescriptor(PVOID _Descriptor)
{
PISECURITY_DESCRIPTOR Descriptor = (PISECURITY_DESCRIPTOR)_Descriptor;
}
}
-PACL
FORCEINLINE
+PACL
SepGetSaclFromDescriptor(PVOID _Descriptor)
{
PISECURITY_DESCRIPTOR Descriptor = (PISECURITY_DESCRIPTOR)_Descriptor;
/*
* @implemented
*/
-VOID
FORCEINLINE
+VOID
IopNotifyFileSystemChange(IN PDEVICE_OBJECT DeviceObject,
IN BOOLEAN DriverActive)
{
KeRegisterInterruptHandler(Interrupt->Vector, Handler);
}
-VOID
FORCEINLINE
DECLSPEC_NORETURN
+VOID
KiExitInterrupt(IN PKTRAP_FRAME TrapFrame,
IN KIRQL OldIrql,
IN BOOLEAN Spurious)
/* TRAP EXIT CODE *************************************************************/
-BOOLEAN
FORCEINLINE
+BOOLEAN
KiVdmTrap(IN PKTRAP_FRAME TrapFrame)
{
/* Either the V8086 flag is on, or this is user-mode with a VDM */
((KiUserTrap(TrapFrame)) && (PsGetCurrentProcess()->VdmObjects)));
}
-BOOLEAN
FORCEINLINE
+BOOLEAN
KiV86Trap(IN PKTRAP_FRAME TrapFrame)
{
/* Check if the V8086 flag is on */
return ((TrapFrame->EFlags & EFLAGS_V86_MASK) != 0);
}
-BOOLEAN
FORCEINLINE
+BOOLEAN
KiIsFrameEdited(IN PKTRAP_FRAME TrapFrame)
{
/* An edited frame changes esp. It is marked by clearing the bits
return ((TrapFrame->SegCs & FRAME_EDITED) == 0);
}
-VOID
FORCEINLINE
+VOID
KiCommonExit(IN PKTRAP_FRAME TrapFrame, BOOLEAN SkipPreviousMode)
{
/* Disable interrupts until we return */
return Result;
}
+FORCEINLINE
DECLSPEC_NORETURN
VOID
-FORCEINLINE
KiSystemCall(IN PKTRAP_FRAME TrapFrame,
IN PVOID Arguments)
{
/* FUNCTIONS ******************************************************************/
-VOID
FORCEINLINE
+VOID
KiWriteSystemTime(volatile KSYSTEM_TIME *SystemTime, ULARGE_INTEGER NewTime)
{
#ifdef _WIN64
#endif
}
-VOID
FORCEINLINE
+VOID
KiCheckForTimerExpiration(
PKPRCB Prcb,
PKTRAP_FRAME TrapFrame,
extern LARGE_INTEGER MmCriticalSectionTimeout;
extern LIST_ENTRY MmWorkingSetExpansionHead;
-BOOLEAN
FORCEINLINE
+BOOLEAN
MiIsMemoryTypeFree(TYPE_OF_MEMORY MemoryType)
{
return ((MemoryType == LoaderFree) ||
(MemoryType == LoaderOsloaderStack));
}
-BOOLEAN
FORCEINLINE
+BOOLEAN
MiIsMemoryTypeInvisible(TYPE_OF_MEMORY MemoryType)
{
return ((MemoryType == LoaderFirmwarePermanent) ||
}
#ifdef _M_AMD64
-BOOLEAN
FORCEINLINE
+BOOLEAN
MiIsUserPxe(PVOID Address)
{
return ((ULONG_PTR)Address >> 7) == 0x1FFFFEDF6FB7DA0ULL;
}
-BOOLEAN
FORCEINLINE
+BOOLEAN
MiIsUserPpe(PVOID Address)
{
return ((ULONG_PTR)Address >> 16) == 0xFFFFF6FB7DA0ULL;
}
-BOOLEAN
FORCEINLINE
+BOOLEAN
MiIsUserPde(PVOID Address)
{
return ((ULONG_PTR)Address >> 25) == 0x7FFFFB7DA0ULL;
}
-BOOLEAN
FORCEINLINE
+BOOLEAN
MiIsUserPte(PVOID Address)
{
return ((ULONG_PTR)Address >> 34) == 0x3FFFFDA0ULL;
}
#else
-BOOLEAN
FORCEINLINE
+BOOLEAN
MiIsUserPde(PVOID Address)
{
return ((Address >= (PVOID)MiAddressToPde(NULL)) &&
(Address <= (PVOID)MiHighestUserPde));
}
-BOOLEAN
FORCEINLINE
+BOOLEAN
MiIsUserPte(PVOID Address)
{
return (Address <= (PVOID)MiHighestUserPte);
//
// Figures out the hardware bits for a PTE
//
-ULONG_PTR
FORCEINLINE
+ULONG_PTR
MiDetermineUserGlobalPteMask(IN PVOID PointerPte)
{
MMPTE TempPte;
//
// Writes a valid PTE
//
-VOID
FORCEINLINE
+VOID
MI_WRITE_VALID_PTE(IN PMMPTE PointerPte,
IN MMPTE TempPte)
{
//
// Writes an invalid PTE
//
-VOID
FORCEINLINE
+VOID
MI_WRITE_INVALID_PTE(IN PMMPTE PointerPte,
IN MMPTE InvalidPte)
{
//
// Writes a valid PDE
//
-VOID
FORCEINLINE
+VOID
MI_WRITE_VALID_PDE(IN PMMPDE PointerPde,
IN MMPDE TempPde)
{
//
// Writes an invalid PDE
//
-VOID
FORCEINLINE
+VOID
MI_WRITE_INVALID_PDE(IN PMMPDE PointerPde,
IN MMPDE InvalidPde)
{
//
// New ARM3<->RosMM PAGE Architecture
//
-BOOLEAN
FORCEINLINE
+BOOLEAN
MiIsRosSectionObject(IN PVOID Section)
{
PROS_SECTION_OBJECT RosSection = Section;
// then we'd like to have our own code to grab a free page and zero it out, by
// using MiRemoveAnyPage. This macro implements this.
//
-PFN_NUMBER
FORCEINLINE
+PFN_NUMBER
MiRemoveZeroPageSafe(IN ULONG Color)
{
if (MmFreePagesByColor[ZeroedPageList][Color].Flink != LIST_HEAD) return MiRemoveZeroPage(Color);
#define PRTL_BALANCED_LINKS PMMADDRESS_NODE
#define MI_ASSERT(x) ASSERT(x)
-VOID
FORCEINLINE
+VOID
RtlpCopyAvlNodeData(IN PRTL_BALANCED_LINKS Node1,
IN PRTL_BALANCED_LINKS Node2)
{
Node1->RightChild = Node2->RightChild;
}
-RTL_GENERIC_COMPARE_RESULTS
FORCEINLINE
+RTL_GENERIC_COMPARE_RESULTS
RtlpAvlCompareRoutine(IN PRTL_AVL_TABLE Table,
IN PVOID Buffer,
IN PVOID UserData)
}
}
-VOID
FORCEINLINE
+VOID
RtlSetParent(IN PRTL_BALANCED_LINKS Node,
IN PRTL_BALANCED_LINKS Parent)
{
Node->u1.Parent = (PRTL_BALANCED_LINKS)((ULONG_PTR)Parent | (Node->u1.Balance & 0x3));
}
-VOID
FORCEINLINE
+VOID
RtlSetBalance(IN PRTL_BALANCED_LINKS Node,
IN SCHAR Balance)
{
Node->u1.Balance = Balance;
}
-SCHAR
FORCEINLINE
+SCHAR
RtlBalance(IN PRTL_BALANCED_LINKS Node)
{
return (SCHAR)Node->u1.Balance;
}
-PRTL_BALANCED_LINKS
FORCEINLINE
+PRTL_BALANCED_LINKS
RtlParentAvl(IN PRTL_BALANCED_LINKS Node)
{
return (PRTL_BALANCED_LINKS)((ULONG_PTR)Node->u1.Parent & ~3);
}
-BOOLEAN
FORCEINLINE
+BOOLEAN
RtlIsRootAvl(IN PRTL_BALANCED_LINKS Node)
{
return (RtlParentAvl(Node) == Node);
}
-PRTL_BALANCED_LINKS
FORCEINLINE
+PRTL_BALANCED_LINKS
RtlRightChildAvl(IN PRTL_BALANCED_LINKS Node)
{
return Node->RightChild;
}
-PRTL_BALANCED_LINKS
FORCEINLINE
+PRTL_BALANCED_LINKS
RtlLeftChildAvl(IN PRTL_BALANCED_LINKS Node)
{
return Node->LeftChild;
}
-BOOLEAN
FORCEINLINE
+BOOLEAN
RtlIsLeftChildAvl(IN PRTL_BALANCED_LINKS Node)
{
return (RtlLeftChildAvl(RtlParentAvl(Node)) == Node);
}
-BOOLEAN
FORCEINLINE
+BOOLEAN
RtlIsRightChildAvl(IN PRTL_BALANCED_LINKS Node)
{
return (RtlRightChildAvl(RtlParentAvl(Node)) == Node);
}
-VOID
FORCEINLINE
+VOID
RtlInsertAsLeftChildAvl(IN PRTL_BALANCED_LINKS Parent,
IN PRTL_BALANCED_LINKS Node)
{
RtlSetParent(Node, Parent);
}
-VOID
FORCEINLINE
+VOID
RtlInsertAsRightChildAvl(IN PRTL_BALANCED_LINKS Parent,
IN PRTL_BALANCED_LINKS Node)
{
}
#if (_MI_PAGING_LEVELS == 2)
-BOOLEAN
FORCEINLINE
+BOOLEAN
MiSynchronizeSystemPde(PMMPDE PointerPde)
{
MMPDE SystemPde;
return UnprotectedPages ? TRUE : FALSE;
}
-VOID
FORCEINLINE
+VOID
MiProtectedPoolUnProtectLinks(IN PLIST_ENTRY Links,
OUT PVOID* PoolFlink,
OUT PVOID* PoolBlink)
}
}
-VOID
FORCEINLINE
+VOID
MiProtectedPoolProtectLinks(IN PVOID PoolFlink,
IN PVOID PoolBlink)
{
// being released, which is then inserted in front of the recorded cluster.
//
-ULONG
FORCEINLINE
+ULONG
MI_GET_CLUSTER_SIZE(IN PMMPTE Pte)
{
//
}
/* Taken from ARM3/pagfault.c */
-BOOLEAN
FORCEINLINE
+BOOLEAN
MiSynchronizeSystemPde(PMMPDE PointerPde)
{
MMPDE SystemPde;