kdmemsup.c File Reference

#include <ntoskrnl.h>

Include dependency graph for kdmemsup.c:

Go to the source code of this file.

Macros
#define	HIGH_PHYS_MASK   0x80000000
#define	PAGE_TABLE_MASK   0x3ff
#define	BIG_PAGE_SIZE   (1<<22)
#define	CR4_PAGE_SIZE_BIT   0x10
#define	PDE_PRESENT_BIT   0x01
#define	PDE_W_BIT   0x02
#define	PDE_PWT_BIT   0x08
#define	PDE_PCD_BIT   0x10
#define	PDE_ACCESSED_BIT   0x20
#define	PDE_DIRTY_BIT   0x40
#define	PDE_PS_BIT   0x80
#define	MI_KDBG_TMP_PAGE_1   (HYPER_SPACE + 0x400000 - PAGE_SIZE)
#define	MI_KDBG_TMP_PAGE_0   (MI_KDBG_TMP_PAGE_1 - PAGE_SIZE)

Functions
static ULONG_PTR	KdpPhysMap (ULONG_PTR PhysAddr, LONG Len)
static ULONGLONG	KdpPhysRead (ULONG_PTR PhysAddr, LONG Len)
static VOID	KdpPhysWrite (ULONG_PTR PhysAddr, LONG Len, ULONGLONG Value)
static BOOLEAN	KdpTranslateAddress (ULONG_PTR Addr, PULONG_PTR ResultAddr)
BOOLEAN NTAPI	KdpSafeReadMemory (ULONG_PTR Addr, LONG Len, PVOID Value)
BOOLEAN NTAPI	KdpSafeWriteMemory (ULONG_PTR Addr, LONG Len, ULONGLONG Value)
VOID NTAPI	KdpEnableSafeMem (VOID)

Variables
static BOOLEAN	KdpPhysAccess = FALSE

Macro Definition Documentation

BIG_PAGE_SIZE

#define BIG_PAGE_SIZE   (1<<22)

Definition at line 21 of file kdmemsup.c.

CR4_PAGE_SIZE_BIT

#define CR4_PAGE_SIZE_BIT   0x10

Definition at line 22 of file kdmemsup.c.

HIGH_PHYS_MASK

#define HIGH_PHYS_MASK   0x80000000

Definition at line 19 of file kdmemsup.c.

MI_KDBG_TMP_PAGE_0

#define MI_KDBG_TMP_PAGE_0   (MI_KDBG_TMP_PAGE_1 - PAGE_SIZE)

Definition at line 32 of file kdmemsup.c.

MI_KDBG_TMP_PAGE_1

#define MI_KDBG_TMP_PAGE_1   (HYPER_SPACE + 0x400000 - PAGE_SIZE)

Definition at line 31 of file kdmemsup.c.

PAGE_TABLE_MASK

#define PAGE_TABLE_MASK   0x3ff

Definition at line 20 of file kdmemsup.c.

PDE_ACCESSED_BIT

#define PDE_ACCESSED_BIT   0x20

Definition at line 27 of file kdmemsup.c.

PDE_DIRTY_BIT

#define PDE_DIRTY_BIT   0x40

Definition at line 28 of file kdmemsup.c.

PDE_PCD_BIT

#define PDE_PCD_BIT   0x10

Definition at line 26 of file kdmemsup.c.

PDE_PRESENT_BIT

#define PDE_PRESENT_BIT   0x01

Definition at line 23 of file kdmemsup.c.

PDE_PS_BIT

#define PDE_PS_BIT   0x80

Definition at line 29 of file kdmemsup.c.

PDE_PWT_BIT

#define PDE_PWT_BIT   0x08

Definition at line 25 of file kdmemsup.c.

PDE_W_BIT

#define PDE_W_BIT   0x02

Definition at line 24 of file kdmemsup.c.

Function Documentation

KdpEnableSafeMem()

VOID NTAPI KdpEnableSafeMem

(

VOID

)

Definition at line 217 of file kdmemsup.c.

{
    KdpPhysAccess = TRUE;
}

KdpPhysMap()

static ULONG_PTR KdpPhysMap ( ULONG_PTR  PhysAddr, LONG  Len  )

static

Definition at line 40 of file kdmemsup.c.

{
    MMPTE TempPte;
    PMMPTE PointerPte;
    ULONG_PTR VirtAddr;
 
    TempPte.u.Long = PDE_PRESENT_BIT | PDE_W_BIT | PDE_PWT_BIT |
                     PDE_PCD_BIT | PDE_ACCESSED_BIT | PDE_DIRTY_BIT;
 
    if ((PhysAddr & (PAGE_SIZE - 1)) + Len > PAGE_SIZE)
    {
        TempPte.u.Hard.PageFrameNumber = (PhysAddr >> PAGE_SHIFT) + 1;
        PointerPte = MiAddressToPte((PVOID)MI_KDBG_TMP_PAGE_1);
        *PointerPte = TempPte;
        VirtAddr = (ULONG_PTR)PointerPte << 10;
        KeInvalidateTlbEntry((PVOID)VirtAddr);
    }
 
    TempPte.u.Hard.PageFrameNumber = PhysAddr >> PAGE_SHIFT;
    PointerPte = MiAddressToPte((PVOID)MI_KDBG_TMP_PAGE_0);
    *PointerPte = TempPte;
    VirtAddr = (ULONG_PTR)PointerPte << 10;
    KeInvalidateTlbEntry((PVOID)VirtAddr);
 
    return VirtAddr + (PhysAddr & (PAGE_SIZE - 1));
}

Referenced by KdpPhysRead(), and KdpPhysWrite().

KdpPhysRead()

static ULONGLONG KdpPhysRead ( ULONG_PTR  PhysAddr, LONG  Len  )

static

Definition at line 69 of file kdmemsup.c.

{
    ULONG_PTR Addr;
    ULONGLONG Result = 0;
 
    Addr = KdpPhysMap(PhysAddr, Len);
 
    switch (Len)
    {
    case 8:
        Result = *((PULONGLONG)Addr);
        break;
    case 4:
        Result = *((PULONG)Addr);
        break;
    case 2:
        Result = *((PUSHORT)Addr);
        break;
    case 1:
        Result = *((PUCHAR)Addr);
        break;
    }
 
    return Result;
}

Referenced by KdpSafeReadMemory(), and KdpTranslateAddress().

KdpPhysWrite()

static VOID KdpPhysWrite ( ULONG_PTR  PhysAddr, LONG  Len, ULONGLONG  Value  )

static

Definition at line 97 of file kdmemsup.c.

{
    ULONG_PTR Addr;
 
    Addr = KdpPhysMap(PhysAddr, Len);
 
    switch (Len)
    {
    case 8:
        *((PULONGLONG)Addr) = Value;
        break;
    case 4:
        *((PULONG)Addr) = Value;
        break;
    case 2:
        *((PUSHORT)Addr) = Value;
        break;
    case 1:
        *((PUCHAR)Addr) = Value;
        break;
    }
}

Referenced by KdpSafeWriteMemory().

KdpSafeReadMemory()

BOOLEAN NTAPI KdpSafeReadMemory	(	ULONG_PTR	Addr,
		LONG	Len,
		PVOID	Value
	)

Definition at line 162 of file kdmemsup.c.

{
    ULONG_PTR ResultPhysAddr;
 
    if (!KdpPhysAccess)
    {
        memcpy(Value, (PVOID)Addr, Len);
        return TRUE;
    }
 
    memset(Value, 0, Len);
 
    if (!KdpTranslateAddress(Addr, &ResultPhysAddr))
        return FALSE;
 
    switch (Len)
    {
    case 8:
        *((PULONGLONG)Value) = KdpPhysRead(ResultPhysAddr, Len);
        break;
    case 4:
        *((PULONG)Value) = KdpPhysRead(ResultPhysAddr, Len);
        break;
    case 2:
        *((PUSHORT)Value) = KdpPhysRead(ResultPhysAddr, Len);
        break;
    case 1:
        *((PUCHAR)Value) = KdpPhysRead(ResultPhysAddr, Len);
        break;
    }
 
    return TRUE;
}

KdpSafeWriteMemory()

BOOLEAN NTAPI KdpSafeWriteMemory	(	ULONG_PTR	Addr,
		LONG	Len,
		ULONGLONG	Value
	)

Definition at line 198 of file kdmemsup.c.

{
    ULONG_PTR ResultPhysAddr;
 
    if (!KdpPhysAccess)
    {
        memcpy((PVOID)Addr, &Value, Len);
        return TRUE;
    }
 
    if (!KdpTranslateAddress(Addr, &ResultPhysAddr))
        return FALSE;
 
    KdpPhysWrite(ResultPhysAddr, Len, Value);
    return TRUE;
}

KdpTranslateAddress()

static BOOLEAN KdpTranslateAddress ( ULONG_PTR  Addr, PULONG_PTR  ResultAddr  )

static

Definition at line 122 of file kdmemsup.c.

{
    ULONG_PTR CR3Value = __readcr3();
    ULONG_PTR CR4Value = __readcr4();
    ULONG_PTR PageDirectory = (CR3Value & ~(PAGE_SIZE-1)) +
        ((Addr >> 22) * sizeof(ULONG));
    ULONG_PTR PageDirectoryEntry = KdpPhysRead(PageDirectory, sizeof(ULONG));
 
    /* Not present -> fail */
    if (!(PageDirectoryEntry & PDE_PRESENT_BIT))
    {
        return FALSE;
    }
 
    /* Big Page? */
    if ((PageDirectoryEntry & PDE_PS_BIT) && (CR4Value & CR4_PAGE_SIZE_BIT))
    {
        *ResultAddr = (PageDirectoryEntry & ~(BIG_PAGE_SIZE-1)) +
            (Addr & (BIG_PAGE_SIZE-1));
        return TRUE;
    }
    else
    {
        ULONG_PTR PageTableAddr =
            (PageDirectoryEntry & ~(PAGE_SIZE-1)) +
            ((Addr >> PAGE_SHIFT) & PAGE_TABLE_MASK) * sizeof(ULONG);
        ULONG_PTR PageTableEntry = KdpPhysRead(PageTableAddr, sizeof(ULONG));
        if (PageTableEntry & PDE_PRESENT_BIT)
        {
            *ResultAddr = (PageTableEntry & ~(PAGE_SIZE-1)) +
                (Addr & (PAGE_SIZE-1));
            return TRUE;
        }
    }
 
    return FALSE;
}

Referenced by KdpSafeReadMemory(), and KdpSafeWriteMemory().

Variable Documentation

KdpPhysAccess

BOOLEAN KdpPhysAccess = FALSE

static

Definition at line 36 of file kdmemsup.c.

Referenced by KdpEnableSafeMem(), KdpSafeReadMemory(), and KdpSafeWriteMemory().