ShuriZma
/
Cxbx-Reloaded
mirror of https://github.com/Cxbx-Reloaded/Cxbx-Reloaded.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

MmDbg kernel thunk stubs

This commit is contained in:
ergo720 2018-03-02 21:44:47 +01:00
parent 8766aa57bf
commit dbc6b77434
5 changed files with 144 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
import/OpenXDK/include/xboxkrnl/mm.h
View File

@ -100,11 +100,17 @@ XBSYSAPI EXPORTNUM(173) PHYSICAL_ADDRESS NTAPI MmGetPhysicalAddress
IN PVOID BaseAddress
);
// ******************************************************************
// * MmIsAddressValid
// ******************************************************************
XBSYSAPI EXPORTNUM(174) BOOLEAN NTAPI MmIsAddressValid
(
IN PVOID VirtualAddress
);
// ******************************************************************
// * MmLockUnlockBufferPages
// ******************************************************************
XBSYSAPI EXPORTNUM(175) VOID NTAPI MmLockUnlockBufferPages
(
IN PHYSICAL_ADDRESS BaseAddress,
@ -112,6 +118,9 @@ XBSYSAPI EXPORTNUM(175) VOID NTAPI MmLockUnlockBufferPages
IN ULONG Protect
);
// ******************************************************************
// * MmLockUnlockPhysicalPage
// ******************************************************************
XBSYSAPI EXPORTNUM(176) VOID NTAPI MmLockUnlockPhysicalPage
(
IN ULONG_PTR PhysicalAddress,
@ -138,6 +147,9 @@ XBSYSAPI EXPORTNUM(178) VOID NTAPI MmPersistContiguousMemory
IN BOOLEAN Persist
);
// ******************************************************************
// * MmQueryAddressProtect
// ******************************************************************
XBSYSAPI EXPORTNUM(179) ULONG NTAPI MmQueryAddressProtect
(
IN PVOID VirtualAddress
@ -178,6 +190,47 @@ XBSYSAPI EXPORTNUM(183) NTSTATUS NTAPI MmUnmapIoSpace
IN ULONG NumberOfBytes
);
// ******************************************************************
// * MmDbgAllocateMemory
// ******************************************************************
XBSYSAPI EXPORTNUM(374) PVOID NTAPI MmDbgAllocateMemory
(
IN ULONG NumberOfBytes,
IN ULONG Protect
);
// ******************************************************************
// * MmDbgFreeMemory
// ******************************************************************
XBSYSAPI EXPORTNUM(375) ULONG NTAPI MmDbgFreeMemory
(
IN PVOID BaseAddress,
IN ULONG NumberOfBytes
);
// ******************************************************************
// * MmDbgQueryAvailablePages
// ******************************************************************
XBSYSAPI EXPORTNUM(376) ULONG NTAPI MmDbgQueryAvailablePages();
// ******************************************************************
// * MmDbgReleaseAddress
// ******************************************************************
XBSYSAPI EXPORTNUM(377) VOID NTAPI MmDbgReleaseAddress
(
IN PVOID VirtualAddress,
IN PULONG Opaque
);
// ******************************************************************
// * MmDbgWriteCheck
// ******************************************************************
XBSYSAPI EXPORTNUM(378) PVOID NTAPI MmDbgWriteCheck
(
IN PVOID VirtualAddress,
IN PULONG Opaque
);
#endif

83
src/CxbxKrnl/EmuKrnlMm.cpp
View File

@ -543,3 +543,86 @@ XBSYSAPI EXPORTNUM(183) xboxkrnl::NTSTATUS NTAPI xboxkrnl::MmUnmapIoSpace
RETURN(STATUS_SUCCESS);
}
// ******************************************************************
// * 0x0176 - MmDbgAllocateMemory
// ******************************************************************
XBSYSAPI EXPORTNUM(374) xboxkrnl::PVOID NTAPI xboxkrnl::MmDbgAllocateMemory
(
IN ULONG NumberOfBytes,
IN ULONG Protect
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(NumberOfBytes)
LOG_FUNC_ARG(Protect)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
RETURN(NULL);
}
// ******************************************************************
// * 0x0177 - MmDbgFreeMemory
// ******************************************************************
XBSYSAPI EXPORTNUM(375) xboxkrnl::ULONG NTAPI xboxkrnl::MmDbgFreeMemory
(
IN PVOID BaseAddress,
IN ULONG NumberOfBytes
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(BaseAddress)
LOG_FUNC_ARG(NumberOfBytes)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
RETURN(NULL);
}
// ******************************************************************
// * 0x0178 - MmDbgQueryAvailablePages
// ******************************************************************
XBSYSAPI EXPORTNUM(376) xboxkrnl::ULONG NTAPI xboxkrnl::MmDbgQueryAvailablePages()
{
LOG_UNIMPLEMENTED();
RETURN(NULL);
}
// ******************************************************************
// * 0x0179 - MmDbgReleaseAddress
// ******************************************************************
XBSYSAPI EXPORTNUM(377) xboxkrnl::VOID NTAPI xboxkrnl::MmDbgReleaseAddress
(
IN PVOID VirtualAddress,
IN PULONG Opaque
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(VirtualAddress)
LOG_FUNC_ARG(Opaque)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
}
// ******************************************************************
// * 0x017A - MmDbgWriteCheck
// ******************************************************************
XBSYSAPI EXPORTNUM(378) xboxkrnl::PVOID NTAPI xboxkrnl::MmDbgWriteCheck
(
IN PVOID VirtualAddress,
IN PULONG Opaque
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(VirtualAddress)
LOG_FUNC_ARG(Opaque)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
RETURN(NULL);
}

10
src/CxbxKrnl/KernelThunk.cpp
View File

@ -440,11 +440,11 @@ uint32 CxbxKrnl_KernelThunkTable[379] =
(uint32)FUNC(&xboxkrnl::XProfpGetData), // 0x0173 (371) PROFILING
(uint32)FUNC(&xboxkrnl::IrtClientInitFast), // 0x0174 (372) PROFILING
(uint32)FUNC(&xboxkrnl::IrtSweep), // 0x0175 (373) PROFILING
(uint32)PANIC(0x0176), // 0x0177 (374) DEVKIT MmDbgAllocateMemory
(uint32)PANIC(0x0177), // 0x0178 (375) DEVKIT MmDbgFreeMemory - Returns number of pages released.
(uint32)PANIC(0x0178), // 0x0179 (376) DEVKIT MmDbgQueryAvailablePages
(uint32)PANIC(0x0179), // 0x017A (377) DEVKIT MmDbgReleaseAddress
(uint32)PANIC(0x017A), // 0x017A (378) DEVKIT MmDbgWriteCheck
(uint32)FUNC(&xboxkrnl::MmDbgAllocateMemory), // 0x0176 (374) DEVKIT ONLY!
(uint32)FUNC(&xboxkrnl::MmDbgFreeMemory), // 0x0177 (375) DEVKIT ONLY!
(uint32)FUNC(&xboxkrnl::MmDbgQueryAvailablePages), // 0x0178 (376) DEVKIT ONLY!
(uint32)FUNC(&xboxkrnl::MmDbgReleaseAddress), // 0x0179 (377) DEVKIT ONLY!
(uint32)FUNC(&xboxkrnl::MmDbgWriteCheck), // 0x017A (378) DEVKIT ONLY!
};
/* prevent name collisions */

99
src/CxbxKrnl/VMManager.cpp
View File

@ -53,8 +53,7 @@ bool VirtualMemoryArea::CanBeMergedWith(const VirtualMemoryArea& next) const
{
assert(base + size == next.base);
if (permissions != next.permissions || type != next.type ||
type == VMAType::Lock || next.type == VMAType::Lock) { return false; }
if (permissions != next.permissions || type != next.type) { return false; }
if (type == VMAType::Allocated && next.type == VMAType::Allocated) { return false; }
return true;
@ -1298,57 +1297,8 @@ VMAIter VMManager::ReprotectVMA(VMAIter vma_handle, DWORD new_perms)
return MergeAdjacentVMA(vma_handle);
}
void VMManager::UpdatePageTableForVMA(const VirtualMemoryArea& vma)
VMAIter VMManager::DestructVMA(VAddr addr, MemoryRegionType Type)
{
switch (vma.type)
{
case VMAType::Free:
case VMAType::MemTiled:
case VMAType::IO_DeviceNV2A:
case VMAType::MemNV2A_PRAMIN:
case VMAType::IO_DeviceAPU:
case VMAType::IO_DeviceAC97:
case VMAType::IO_DeviceUSB0:
case VMAType::IO_DeviceUSB1:
case VMAType::IO_DeviceNVNet:
case VMAType::DeviceBIOS:
case VMAType::DeviceMCPX:
{
UnmapRegion(vma.base, vma.size);
}
break;
case VMAType::Allocated:
case VMAType::Stack:
{
MapMemoryRegion(vma.base, vma.size, vma.backing_block);
}
break;
default:
CxbxKrnlCleanup("VMAType::Lock or Unknown type in UpdatePageTableForVMA");
}
}
VMAIter VMManager::DestructVMA(VMAIter vma_handle, VAddr addr, size_t size)
{
if (vma_handle->second.type == VMAType::Free) { return std::next(vma_handle); }
if (vma_handle->second.type != VMAType::Stack)
{
vma_handle->second.permissions & (PAGE_EXECUTE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY) ?
m_ImageMemoryInUse -= size : m_NonImageMemoryInUse -= size;
}
else { m_StackMemoryInUse -= size; }
if (vma_handle->second.type == VMAType::Allocated || vma_handle->second.type == VMAType::Stack)
{
if (vma_handle->second.bFragmented) { DeAllocateFragmented(vma_handle->second.backing_block); }
else { DeAllocatePhysicalMemory(vma_handle->second.backing_block); }
}
VMAIter vma = CarveVMARange(addr, size);
VAddr target_end = addr + size;
@ -1362,48 +1312,3 @@ VMAIter VMManager::DestructVMA(VMAIter vma_handle, VAddr addr, size_t size)
return vma;
}
void VMManager::ResizeVMA(VMAIter vma_handle, size_t offset, bool bStart)
{
if (!offset) { return; } // nothing to do
VirtualMemoryArea& old_vma = vma_handle->second;
VirtualMemoryArea new_vma = old_vma;
if (bStart)
{
if (offset > old_vma.size) { return; } // sanity check
VAddr new_base = old_vma.base + offset;
new_vma.base = new_base;
new_vma.size = old_vma.size - offset;
if (old_vma.type == VMAType::Allocated || old_vma.type == VMAType::Stack) {
ShrinkPhysicalAllocation(vma_handle->second.backing_block, offset, vma_handle->second.bFragmented, bStart);
}
m_Vma_map.erase(old_vma.base);
if(new_vma.size) { m_Vma_map.emplace(new_base, new_vma); }
}
else
{
if (offset > old_vma.size) { return; } // sanity check
VAddr new_base = old_vma.base;
new_vma.base = new_base;
new_vma.size = old_vma.size - offset;
if (old_vma.type == VMAType::Allocated || old_vma.type == VMAType::Stack) {
ShrinkPhysicalAllocation(vma_handle->second.backing_block, offset, vma_handle->second.bFragmented, bStart);
}
m_Vma_map.erase(old_vma.base);
if (new_vma.size) { m_Vma_map.emplace(new_base, new_vma); }
}
if (new_vma.type != VMAType::Free)
{
if (new_vma.type != VMAType::Stack)
{
new_vma.permissions & (PAGE_EXECUTE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY) ?
m_ImageMemoryInUse -= offset : m_NonImageMemoryInUse -= offset;
}
else { m_StackMemoryInUse -= offset; }
}
}

4
src/CxbxKrnl/VMManager.h
View File

@ -221,9 +221,7 @@ class VMManager : public PhysicalMemory
// releases the critical section
void Unlock();
// destructs a vma if not free already
VMAIter DestructVMA(VMAIter vma_handle, VAddr addr, size_t size);
// changes the size/base of a vma
void ResizeVMA(VMAIter vma_handle, size_t offset, bool bStart);
VMAIter DestructVMA(VAddr addr, MemoryRegionType Type);
};