/[pcsx2_0.9.7]/trunk/common/src/Utilities/Linux/LnxHostSys.cpp
ViewVC logotype

Diff of /trunk/common/src/Utilities/Linux/LnxHostSys.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

--- trunk/common/src/Utilities/Linux/LnxHostSys.cpp	2010/12/23 11:48:33	279
+++ trunk/common/src/Utilities/Linux/LnxHostSys.cpp	2010/12/23 12:02:12	280
@@ -15,50 +15,204 @@
 
 
 #include "../PrecompiledHeader.h"
+#include "PageFaultSource.h"
+
+#include <wx/thread.h>
 
 #include <sys/mman.h>
 #include <signal.h>
+#include <errno.h>
+
+extern void SignalExit(int sig);
 
-namespace HostSys
+static const uptr m_pagemask = getpagesize()-1;
+
+// Linux implementation of SIGSEGV handler.  Bind it using sigaction().
+static void SysPageFaultSignalFilter( int signal, siginfo_t *siginfo, void * )
 {
-	static const uptr m_pagemask = getpagesize()-1;
+	// [TODO] : Add a thread ID filter to the Linux Signal handler here.
+	// Rationale: On windows, the __try/__except model allows per-thread specific behavior
+	// for page fault handling.  On linux, there is a single signal handler for the whole
+	// process, but the handler is executed by the thread that caused the exception.
 
-	void *Mmap(uptr base, u32 size)
-	{
-		u8 *Mem;
-		Mem = (u8*)mmap((uptr*)base, size, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
-		if (Mem == MAP_FAILED) Console.Warning("Mmap Failed!");
 
-		return Mem;
-	}
+	// Stdio Usage note: SIGSEGV handling is a synchronous in-thread signal.  It is done
+	// from the context of the current thread and stackframe.  So long as the thread is not
+	// the main/ui thread, use of the px assertion system should be safe.  Use of stdio should
+	// be safe even on the main thread.
+	//  (in other words, stdio limitations only really apply to process-level asynchronous
+	//   signals)
+
+	// Note: Use of stdio functions isn't safe here.  Avoid console logs,
+	// assertions, file logs, or just about anything else useful.
+
+	Source_PageFault->Dispatch( PageFaultInfo( (uptr)siginfo->si_addr & ~m_pagemask ) );
 
-	void Munmap(uptr base, u32 size)
+	// resumes execution right where we left off (re-executes instruction that
+	// caused the SIGSEGV).
+	if (Source_PageFault->WasHandled()) return;
+
+	if (!wxThread::IsMain())
 	{
-		munmap((uptr*)base, size);
+		pxFailRel(pxsFmt("Unhandled page fault @ 0x%08x", siginfo->si_addr));
 	}
 
-	void MemProtect( void* baseaddr, size_t size, PageProtectionMode mode, bool allowExecution )
+	// Bad mojo!  Completely invalid address.
+	// Instigate a trap if we're in a debugger, and if not then do a SIGKILL.
+
+	wxTrap();
+	if (!IsDebugBuild) raise( SIGKILL );
+}
+
+void _platform_InstallSignalHandler()
+{
+	Console.WriteLn("Installing POSIX SIGSEGV handler...");
+	struct sigaction sa;
+
+	sigemptyset(&sa.sa_mask);
+	sa.sa_flags = SA_SIGINFO;
+	sa.sa_sigaction = SysPageFaultSignalFilter;
+	sigaction(SIGSEGV, &sa, NULL);
+}
+
+static __ri void PageSizeAssertionTest( size_t size )
+{
+	pxAssertMsg( (__pagesize == getpagesize()), pxsFmt(
+		"Internal system error: Operating system pagesize does not match compiled pagesize.\n\t"
+		L"\tOS Page Size: 0x%x (%d), Compiled Page Size: 0x%x (%u)",
+		getpagesize(), getpagesize(), __pagesize, __pagesize )
+	);
+
+	pxAssertDev( (size & (__pagesize-1)) == 0, pxsFmt(
+		L"Memory block size must be a multiple of the target platform's page size.\n"
+		L"\tPage Size: 0x%x (%u), Block Size: 0x%x (%u)",
+		__pagesize, __pagesize, size, size )
+	);
+}
+
+// returns FALSE if the mprotect call fails with an ENOMEM.
+// Raises assertions on other types of POSIX errors (since those typically reflect invalid object
+// or memory states).
+static bool _memprotect( void* baseaddr, size_t size, const PageProtectionMode& mode )
+{
+	PageSizeAssertionTest(size);
+
+	uint lnxmode = 0;
+
+	if (mode.CanWrite())	lnxmode |= PROT_WRITE;
+	if (mode.CanRead())		lnxmode |= PROT_READ;
+	if (mode.CanExecute())	lnxmode |= PROT_EXEC | PROT_READ;
+
+	const int result = mprotect( baseaddr, size, lnxmode );
+
+	if (result == 0) return true;
+
+	switch(errno)
 	{
-		pxAssertDev( (size & (__pagesize-1)) == 0, wxsFormat(
-			L"Memory block size must be a multiple of the target platform's page size.\n"
-			L"\tPage Size: 0x%04x (%d), Block Size: 0x%04x (%d)",
-			__pagesize, __pagesize, size, size )
-		);
+		case EINVAL:
+			pxFailDev(pxsFmt(L"mprotect returned EINVAL @ 0x%08X -> 0x%08X  (mode=%s)",
+				baseaddr, (uptr)baseaddr+size, mode.ToString().c_str())
+			);
+		break;
+
+		case EACCES:
+			pxFailDev(pxsFmt(L"mprotect returned EACCES @ 0x%08X -> 0x%08X  (mode=%s)",
+				baseaddr, (uptr)baseaddr+size, mode.ToString().c_str())
+			);
+		break;
+
+		case ENOMEM:
+			// caller handles assertion or exception, or whatever.
+		break;
+	}
+	return false;
+}
+
+void* HostSys::MmapReservePtr(void* base, size_t size)
+{
+	PageSizeAssertionTest(size);
+
+	// On linux a reserve-without-commit is performed by using mmap on a read-only
+	// or anonymous source, with PROT_NONE (no-access) permission.  Since the mapping
+	// is completely inaccessible, the OS will simply reserve it and will not put it
+	// against the commit table.
+	return mmap(base, size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+}
+
+bool HostSys::MmapCommitPtr(void* base, size_t size, const PageProtectionMode& mode)
+{
+	// In linux, reserved memory is automatically committed when its permissions are
+	// changed to something other than PROT_NONE.  If the user is committing memory
+	// as PROT_NONE, then just ignore this call (memory will be committed automatically
+	// later when the user changes permissions to something useful via calls to MemProtect).
+
+	if (mode.IsNone()) return false;
+
+	if (_memprotect( base, size, mode )) return true;
+
+	if (!pxDoOutOfMemory) return false;
+	pxDoOutOfMemory(size);
+	return _memprotect( base, size, mode );
+}
+
+void HostSys::MmapResetPtr(void* base, size_t size)
+{
+	// On linux the only way to reset the memory is to unmap and remap it as PROT_NONE.
+	// That forces linux to unload all committed pages and start from scratch.
+
+	// FIXME: Ideally this code would have some threading lock on it to prevent any other
+	// malloc/free code in the current process from interfering with the operation, but I
+	// can't think of any good way to do that.  (generally it shouldn't be a problem in
+	// PCSX2 anyway, since MmapReset is only called when the ps2vm is suspended; so that
+	// pretty well stops all PCSX2 threads anyway).
+
+	Munmap(base, size);
+	void* result = MmapReservePtr(base, size);
+
+	pxAssertRel ((uptr)result == (uptr)base, pxsFmt(
+		"Virtual memory decommit failed: memory at 0x%08X -> 0x%08X could not be remapped.  "
+		"This is likely caused by multi-thread memory contention.", base, (uptr)base+size
+	));
+}
+
+void* HostSys::MmapReserve(uptr base, size_t size)
+{
+	return MmapReservePtr((void*)base, size);
+}
+
+bool HostSys::MmapCommit(uptr base, size_t size, const PageProtectionMode& mode)
+{
+	return MmapCommitPtr( (void*)base, size, mode );
+}
+
+void HostSys::MmapReset(uptr base, size_t size)
+{
+	MmapResetPtr((void*)base, size);
+}
+
+void* HostSys::Mmap(uptr base, size_t size)
+{
+	PageSizeAssertionTest(size);
 
-		int lnxmode = 0;
+	// MAP_ANONYMOUS - means we have no associated file handle (or device).
 
-		// make sure size is aligned to the system page size:
-		// Check is redundant against the assertion above, but might as well...
-		size = (size + m_pagemask) & ~m_pagemask;
-
-		switch( mode )
-		{
-			case Protect_NoAccess: break;
-			case Protect_ReadOnly: lnxmode = PROT_READ; break;
-			case Protect_ReadWrite: lnxmode = PROT_READ | PROT_WRITE; break;
-		}
+	return mmap((void*)base, size, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+}
+
+void HostSys::Munmap(uptr base, size_t size)
+{
+	if (!base) return;
+	munmap((void*)base, size);
+}
 
-		if( allowExecution ) lnxmode |= PROT_EXEC;
-		mprotect( baseaddr, size, lnxmode );
+void HostSys::MemProtect( void* baseaddr, size_t size, const PageProtectionMode& mode )
+{
+	if (!_memprotect(baseaddr, size, mode))
+	{
+		throw Exception::OutOfMemory( L"MemProtect" )
+			.SetDiagMsg(pxsFmt( L"mprotect failed @ 0x%08X -> 0x%08X  (mode=%s)",
+				baseaddr, (uptr)baseaddr+size, mode.ToString().c_str()
+			)
+		);
 	}
 }

 

  ViewVC Help
Powered by ViewVC 1.1.22