mirror of https://github.com/PCSX2/pcsx2.git
276 lines
8.5 KiB
C++
276 lines
8.5 KiB
C++
/* PCSX2 - PS2 Emulator for PCs
|
|
* Copyright (C) 2002-2010 PCSX2 Dev Team
|
|
*
|
|
* PCSX2 is free software: you can redistribute it and/or modify it under the terms
|
|
* of the GNU Lesser General Public License as published by the Free Software Found-
|
|
* ation, either version 3 of the License, or (at your option) any later version.
|
|
*
|
|
* PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
|
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
* PURPOSE. See the GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with PCSX2.
|
|
* If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
// [TODO] Rename this file to VirtualMemory.h !!
|
|
|
|
#pragma once
|
|
|
|
// =====================================================================================================
|
|
// Cross-Platform Memory Protection (Used by VTLB, Recompilers and Texture caches)
|
|
// =====================================================================================================
|
|
// Win32 platforms use the SEH model: __try {} __except {}
|
|
// Linux platforms use the POSIX Signals model: sigaction()
|
|
// [TODO] OS-X (Darwin) platforms should use the Mach exception model (not implemented)
|
|
|
|
#include "EventSource.h"
|
|
#include "General.h"
|
|
#include "Assertions.h"
|
|
#include <atomic>
|
|
#include <memory>
|
|
#include <mutex>
|
|
#include <string>
|
|
|
|
struct PageFaultInfo
|
|
{
|
|
uptr addr;
|
|
|
|
PageFaultInfo(uptr address)
|
|
{
|
|
addr = address;
|
|
}
|
|
};
|
|
|
|
// --------------------------------------------------------------------------------------
|
|
// IEventListener_PageFault
|
|
// --------------------------------------------------------------------------------------
|
|
class IEventListener_PageFault : public IEventDispatcher<PageFaultInfo>
|
|
{
|
|
public:
|
|
typedef PageFaultInfo EvtParams;
|
|
|
|
public:
|
|
virtual ~IEventListener_PageFault() = default;
|
|
|
|
virtual void DispatchEvent(const PageFaultInfo& evtinfo, bool& handled)
|
|
{
|
|
OnPageFaultEvent(evtinfo, handled);
|
|
}
|
|
|
|
virtual void DispatchEvent(const PageFaultInfo& evtinfo)
|
|
{
|
|
pxFailRel("Don't call me, damnit. Use DispatchException instead.");
|
|
}
|
|
|
|
virtual void OnPageFaultEvent(const PageFaultInfo& evtinfo, bool& handled) {}
|
|
};
|
|
|
|
// --------------------------------------------------------------------------------------
|
|
// EventListener_PageFault / EventListenerHelper_PageFault
|
|
// --------------------------------------------------------------------------------------
|
|
class EventListener_PageFault : public IEventListener_PageFault
|
|
{
|
|
public:
|
|
EventListener_PageFault();
|
|
virtual ~EventListener_PageFault();
|
|
};
|
|
|
|
template <typename TypeToDispatchTo>
|
|
class EventListenerHelper_PageFault : public EventListener_PageFault
|
|
{
|
|
public:
|
|
TypeToDispatchTo* Owner;
|
|
|
|
public:
|
|
EventListenerHelper_PageFault(TypeToDispatchTo& dispatchTo)
|
|
{
|
|
Owner = &dispatchTo;
|
|
}
|
|
|
|
EventListenerHelper_PageFault(TypeToDispatchTo* dispatchTo)
|
|
{
|
|
Owner = dispatchTo;
|
|
}
|
|
|
|
virtual ~EventListenerHelper_PageFault() = default;
|
|
|
|
protected:
|
|
virtual void OnPageFaultEvent(const PageFaultInfo& info, bool& handled)
|
|
{
|
|
Owner->OnPageFaultEvent(info, handled);
|
|
}
|
|
};
|
|
|
|
// --------------------------------------------------------------------------------------
|
|
// SrcType_PageFault
|
|
// --------------------------------------------------------------------------------------
|
|
class SrcType_PageFault : public EventSource<IEventListener_PageFault>
|
|
{
|
|
protected:
|
|
typedef EventSource<IEventListener_PageFault> _parent;
|
|
|
|
protected:
|
|
bool m_handled;
|
|
|
|
public:
|
|
SrcType_PageFault()
|
|
: m_handled(false)
|
|
{
|
|
}
|
|
virtual ~SrcType_PageFault() = default;
|
|
|
|
bool WasHandled() const { return m_handled; }
|
|
virtual void Dispatch(const PageFaultInfo& params);
|
|
|
|
protected:
|
|
virtual void _DispatchRaw(ListenerIterator iter, const ListenerIterator& iend, const PageFaultInfo& evt);
|
|
};
|
|
|
|
|
|
// --------------------------------------------------------------------------------------
|
|
// VirtualMemoryManager: Manages the allocation of PCSX2 VM
|
|
// Ensures that all memory is close enough together for rip-relative addressing
|
|
// --------------------------------------------------------------------------------------
|
|
class VirtualMemoryManager
|
|
{
|
|
DeclareNoncopyableObject(VirtualMemoryManager);
|
|
|
|
std::string m_name;
|
|
|
|
void* m_file_handle;
|
|
u8* m_baseptr;
|
|
|
|
// An array to track page usage (to trigger asserts if things try to overlap)
|
|
std::atomic<bool>* m_pageuse;
|
|
|
|
// reserved memory (in pages)
|
|
u32 m_pages_reserved;
|
|
|
|
public:
|
|
// If upper_bounds is nonzero and the OS fails to allocate memory that is below it,
|
|
// calls to IsOk() will return false and Alloc() will always return null pointers
|
|
// strict indicates that the allocation should quietly fail if the memory can't be mapped at `base`
|
|
VirtualMemoryManager(std::string name, const char* file_mapping_name, uptr base, size_t size, uptr upper_bounds = 0, bool strict = false);
|
|
~VirtualMemoryManager();
|
|
|
|
bool IsSharedMemory() const { return (m_file_handle != nullptr); }
|
|
void* GetFileHandle() const { return m_file_handle; }
|
|
u8* GetBase() const { return m_baseptr; }
|
|
u8* GetEnd() const { return (m_baseptr + m_pages_reserved * __pagesize); }
|
|
|
|
// Request the use of the memory at offsetLocation bytes from the start of the reserved memory area
|
|
// offsetLocation must be page-aligned
|
|
u8* Alloc(uptr offsetLocation, size_t size) const;
|
|
|
|
u8* AllocAtAddress(void* address, size_t size) const
|
|
{
|
|
return Alloc(size, static_cast<const u8*>(address) - m_baseptr);
|
|
}
|
|
|
|
void Free(void* address, size_t size) const;
|
|
|
|
// Was this VirtualMemoryManager successfully able to get its memory mapping?
|
|
// (If not, calls to Alloc will return null pointers)
|
|
bool IsOk() const { return m_baseptr != 0; }
|
|
};
|
|
|
|
typedef std::shared_ptr<const VirtualMemoryManager> VirtualMemoryManagerPtr;
|
|
|
|
// --------------------------------------------------------------------------------------
|
|
// VirtualMemoryBumpAllocator: Allocates memory for things that don't have explicitly-reserved spots
|
|
// --------------------------------------------------------------------------------------
|
|
class VirtualMemoryBumpAllocator
|
|
{
|
|
const VirtualMemoryManagerPtr m_allocator;
|
|
std::atomic<u8*> m_baseptr{0};
|
|
const u8* m_endptr = 0;
|
|
|
|
public:
|
|
VirtualMemoryBumpAllocator(VirtualMemoryManagerPtr allocator, size_t size, uptr offsetLocation);
|
|
u8* Alloc(size_t size);
|
|
const VirtualMemoryManagerPtr& GetAllocator() { return m_allocator; }
|
|
};
|
|
|
|
// --------------------------------------------------------------------------------------
|
|
// VirtualMemoryReserve
|
|
// --------------------------------------------------------------------------------------
|
|
class VirtualMemoryReserve
|
|
{
|
|
DeclareNoncopyableObject(VirtualMemoryReserve);
|
|
|
|
protected:
|
|
std::string m_name;
|
|
|
|
// Where the memory came from (so we can return it)
|
|
VirtualMemoryManagerPtr m_allocator;
|
|
|
|
u8* m_baseptr = nullptr;
|
|
size_t m_size = 0;
|
|
|
|
public:
|
|
VirtualMemoryReserve(std::string name);
|
|
virtual ~VirtualMemoryReserve();
|
|
|
|
// Initialize with the given piece of memory
|
|
// Note: The memory is already allocated, the allocator is for future use to free the region
|
|
// It may be null in which case there is no way to free the memory in a way it will be usable again
|
|
void Assign(VirtualMemoryManagerPtr allocator, u8* baseptr, size_t size);
|
|
|
|
u8* BumpAllocate(VirtualMemoryBumpAllocator& allocator, size_t size);
|
|
|
|
void Release();
|
|
|
|
bool IsOk() const { return m_baseptr != NULL; }
|
|
const std::string& GetName() const { return m_name; }
|
|
|
|
u8* GetPtr() { return m_baseptr; }
|
|
const u8* GetPtr() const { return m_baseptr; }
|
|
u8* GetPtrEnd() { return m_baseptr + m_size; }
|
|
const u8* GetPtrEnd() const { return m_baseptr + m_size; }
|
|
|
|
size_t GetSize() const { return m_size; }
|
|
|
|
operator void*() { return m_baseptr; }
|
|
operator const void*() const { return m_baseptr; }
|
|
|
|
operator u8*() { return (u8*)m_baseptr; }
|
|
operator const u8*() const { return (u8*)m_baseptr; }
|
|
|
|
u8& operator[](uint idx)
|
|
{
|
|
pxAssert(idx < m_size);
|
|
return *((u8*)m_baseptr + idx);
|
|
}
|
|
|
|
const u8& operator[](uint idx) const
|
|
{
|
|
pxAssert(idx < m_size);
|
|
return *((u8*)m_baseptr + idx);
|
|
}
|
|
};
|
|
|
|
#ifdef __POSIX__
|
|
|
|
#define PCSX2_PAGEFAULT_PROTECT
|
|
#define PCSX2_PAGEFAULT_EXCEPT
|
|
|
|
#elif defined(_WIN32)
|
|
|
|
struct _EXCEPTION_POINTERS;
|
|
extern long __stdcall SysPageFaultExceptionFilter(struct _EXCEPTION_POINTERS* eps);
|
|
|
|
#define PCSX2_PAGEFAULT_PROTECT __try
|
|
#define PCSX2_PAGEFAULT_EXCEPT \
|
|
__except (SysPageFaultExceptionFilter(GetExceptionInformation())) {}
|
|
|
|
#else
|
|
#error PCSX2 - Unsupported operating system platform.
|
|
#endif
|
|
|
|
extern void pxInstallSignalHandler();
|
|
extern void _platform_InstallSignalHandler();
|
|
|
|
extern SrcType_PageFault* Source_PageFault;
|
|
extern std::mutex PageFault_Mutex;
|