pcsx2/pcsx2/SaveState.cpp

/*  PCSX2 - PS2 Emulator for PCs
 *  Copyright (C) 2002-2009  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/>.
 */


#include "PrecompiledHeader.h"

#include "IopCommon.h"
#include "SaveState.h"

//#include "CDVD/IsoFSdrv.h"
#include "ps2/BiosTools.h"

#include "VUmicro.h"
#include "VU.h"
#include "iCore.h"
#include "sVU_zerorec.h"

#include "GS.h"
#include "COP0.h"
#include "Cache.h"
#include "AppConfig.h"

using namespace R5900;

static void PreLoadPrep()
{
	SysClearExecutionCache();
}

static void PostLoadPrep()
{
	memzero(pCache);
//	WriteCP0Status(cpuRegs.CP0.n.Status.val);
	for(int i=0; i<48; i++) MapTLB(i);
}

wxString SaveStateBase::GetFilename( int slot )
{
	return (g_Conf->Folders.Savestates +
		wxsFormat( L"%8.8X.%3.3d", ElfCRC, slot )).GetFullPath();
}

SaveStateBase::SaveStateBase( SafeArray<u8>& memblock ) :
	m_memory( memblock )	
,	m_version( g_SaveVersion )
,	m_idx( 0 )
,	m_sectid( FreezeId_Unknown )
,	m_pid( PluginId_GS )
,	m_DidBios( false )
{
}

void SaveStateBase::PrepBlock( int size )
{
	const int end = m_idx+size;
	if( IsSaving() )
		m_memory.MakeRoomFor( end );
	else
	{
		if( m_memory.GetSizeInBytes() < end )
			throw Exception::BadSavedState();
	}
}

void SaveStateBase::FreezeTag( const char* src )
{
	const int allowedlen = sizeof( m_tagspace )-1;
	pxAssertDev( strlen(src) < allowedlen, wxsFormat( L"Tag name exceeds the allowed length of %d chars.", allowedlen) );

	memzero( m_tagspace );
	strcpy( m_tagspace, src );
	Freeze( m_tagspace );

	if( strcmp( m_tagspace, src ) != 0 )
	{
		pxFail( "Savestate data corruption detected while reading tag" );
		throw Exception::BadSavedState(
			// Untranslated diagnostic msg (use default msg for translation)
			L"Savestate data corruption detected while reading tag: " + fromUTF8(src)
		);
	}
}

void SaveStateBase::FreezeBios()
{
	// Check the BIOS, and issue a warning if the bios for this state
	// doesn't match the bios currently being used (chances are it'll still
	// work fine, but some games are very picky).
	
	char descin[128], desccmp[128];
	wxString descout;
	IsBIOS( g_Conf->FullpathToBios(), descout );
	memzero( descin );
	memzero( desccmp );

	memcpy_fast( descin, descout.ToUTF8().data(), descout.Length() );
	memcpy_fast( desccmp, descout.ToUTF8().data(), descout.Length() );

	// ... and only freeze bios info once per state, since the user msg could
	// become really annoying on a corrupted state or something.  (have to always
	// load though, so that we advance past the duplicated info, if present)

	if( IsLoading() || !m_DidBios )
		Freeze( descin );

	if( !m_DidBios )
	{
		if( memcmp( descin, desccmp, 128 ) != 0 )
		{
			Console.Error(
				"\n\tWarning: BIOS Version Mismatch, savestate may be unstable!\n"
				"\t\tCurrent Version:   %s\n"
				"\t\tSavestate Version: %s\n",
				descout.ToUTF8().data(), descin
			);
		}
	}
	m_DidBios = true;
}

static const int MainMemorySizeInBytes = 
	Ps2MemSize::Base + Ps2MemSize::Scratch + Ps2MemSize::Hardware +
	Ps2MemSize::IopRam + Ps2MemSize::IopHardware + 0x0100;

void SaveStateBase::FreezeMainMemory()
{
	if( IsLoading() )
		PreLoadPrep();

	// First Block - Memory Dumps
	// ---------------------------
	FreezeMem(PS2MEM_BASE,		Ps2MemSize::Base);		// 32 MB main memory   
	FreezeMem(PS2MEM_SCRATCH,	Ps2MemSize::Scratch);	// scratch pad 
	FreezeMem(PS2MEM_HW,		Ps2MemSize::Hardware);	// hardware memory

	FreezeMem(psxM, Ps2MemSize::IopRam);		// 2 MB main memory
	FreezeMem(psxH, Ps2MemSize::IopHardware);	// hardware memory
	FreezeMem(psxS, 0x000100);					// iop's sif memory	
}

void SaveStateBase::FreezeRegisters()
{
	if( IsLoading() )
		PreLoadPrep();

	// Second Block - Various CPU Registers and States
	// -----------------------------------------------
	FreezeTag( "cpuRegs" );
	Freeze(cpuRegs);		// cpu regs + COP0
	Freeze(psxRegs);		// iop regs
	Freeze(fpuRegs);
	Freeze(tlb);			// tlbs

	// Third Block - Cycle Timers and Events
	// -------------------------------------
	FreezeTag( "Cycles" );
	Freeze(EEsCycle);
	Freeze(EEoCycle);
	Freeze(g_nextBranchCycle);
	Freeze(g_psxNextBranchCycle);
	Freeze(s_iLastCOP0Cycle);
	Freeze(s_iLastPERFCycle);

	// Fourth Block - EE-related systems
	// ---------------------------------
	FreezeTag( "EE-Subsystems" );
	rcntFreeze();
	gsFreeze();
	vuMicroFreeze();
	vif0Freeze();
	vif1Freeze();
	sifFreeze();
	ipuFreeze();
	gifFreeze();
	sprFreeze();

	// Fifth Block - iop-related systems
	// ---------------------------------
	FreezeTag( "IOP-Subsystems" );
	psxRcntFreeze();
	sioFreeze();
	sio2Freeze();
	cdrFreeze();
	cdvdFreeze();

	if( IsLoading() )
		PostLoadPrep();
}

void SaveStateBase::WritebackSectionLength( int seekpos, int sectlen, const wxChar* sectname )
{
	int realsectsize = m_idx - seekpos;
	if( IsSaving() )
	{
		// write back the section length...
		*((u32*)m_memory.GetPtr(seekpos-4)) = realsectsize;
	}
	else	// IsLoading!!
	{
		if( sectlen != realsectsize )		// if they don't match then we have a problem, jim.
		{
			throw Exception::BadSavedState( wxEmptyString,
				wxsFormat( L"Invalid size encountered on section '%s'.", sectname ),
				_("The savestate data is invalid or corrupted.")
			);
		}
	}
}

bool SaveStateBase::FreezeSection( int seek_section )
{
	const bool isSeeking = (seek_section != FreezeId_NotSeeking );
	if( IsSaving() ) pxAssertDev( !isSeeking, "Cannot seek on a saving-mode savestate stream." );

	Freeze( m_sectid );
	if( seek_section == m_sectid ) return false;

	switch( m_sectid )
	{
		case FreezeId_End:
		return false;

		case FreezeId_Bios:
		{
			int sectlen = 128;
			FreezeTag( "BiosVersion" );
			Freeze( sectlen );

			if( sectlen != 128 )
			{
				throw Exception::BadSavedState( wxEmptyString,
					L"Invalid size encountered on BiosVersion section.",
					_("The savestate data is invalid or corrupted.")
				);
			}

			if( isSeeking )
				m_idx += sectlen;
			else
				FreezeBios();
			m_sectid++;
		}
		break;

		case FreezeId_Memory:
		{
			FreezeTag( "MainMemory" );

			int seekpos = m_idx+4;
			int sectlen = MainMemorySizeInBytes;
			Freeze( sectlen );
			if( sectlen != MainMemorySizeInBytes )
			{
				throw Exception::BadSavedState( wxEmptyString,
					L"Invalid size encountered on MainMemory section.",
					_("The savestate data is invalid or corrupted.")
				);
			}

			if( isSeeking )
				m_idx += sectlen;
			else
				FreezeMainMemory();

			int realsectsize = m_idx - seekpos;
			pxAssert( sectlen == realsectsize );
			m_sectid++;
		}
		break;
		
		case FreezeId_Registers:
		{
			FreezeTag( "HardwareRegisters" );
			int seekpos = m_idx+4;
			int sectlen = 0xdead;	// gets written back over with "real" data in IsSaving() mode

			Freeze( sectlen );
			FreezeRegisters();

			WritebackSectionLength( seekpos, sectlen, L"HardwareRegisters" );
			m_sectid++;
		}
		break;
		
		case FreezeId_Plugin:
		{
			FreezeTag( "Plugin" );
			int seekpos = m_idx+4;
			int sectlen = 0xdead;	// gets written back over with "real" data in IsSaving() mode

			Freeze( sectlen );
			Freeze( m_pid );

			if( isSeeking )
				m_idx += sectlen;
			else
				g_plugins->Freeze( (PluginsEnum_t)m_pid, *this );

			WritebackSectionLength( seekpos, sectlen, L"HardwareRegisters" );

			// following increments only affect Saving mode, which needs to be sure to save all
			// plugins (order doesn't matter but sequential is easy enough. (ignored by Loading mode)
			m_pid++;
			if( m_pid >= PluginId_Count )
				m_sectid = FreezeId_End;
		}
		break;

		case FreezeId_Unknown:
		default:
			pxAssert( IsSaving() );

			// Skip unknown sections with a warning log.
			// Maybe it'll work!  (haha?)

			int size;
			Freeze( m_tagspace );
			Freeze( size );
			m_tagspace[sizeof(m_tagspace)-1] = 0;

			Console.Warning(
				"Warning: Unknown tag encountered while loading savestate; going to ignore it!\n"
				"\tTagname: %s, Size: %d", m_tagspace, size
			);
			m_idx += size;
		break;
	}

	wxSafeYield( NULL );

	return true;
}

void SaveStateBase::FreezeAll()
{
	if( IsSaving() )
	{
		// Loading mode streams will assign these, but saving mode reads them so better
		// do some setup first.

		m_sectid	= (int)FreezeId_End+1;
		m_pid		= PluginId_GS;
	}

	while( FreezeSection() );
}

//////////////////////////////////////////////////////////////////////////////////
// uncompressed to/from memory state saves implementation

memSavingState::memSavingState( SafeArray<u8>& save_to ) :
	SaveStateBase( save_to )
{
}

// Saving of state data
void memSavingState::FreezeMem( void* data, int size )
{
	m_memory.MakeRoomFor( m_idx+size );
	memcpy_fast( m_memory.GetPtr(m_idx), data, size );
	m_idx += size;
}

void memSavingState::FreezeAll()
{
	// 90% of all savestates fit in under 45 megs (and require more than 43 megs, so might as well...)
	m_memory.ChunkSize = ReallocThreshold;
	m_memory.MakeRoomFor( MemoryBaseAllocSize );

	_parent::FreezeAll();
}

memLoadingState::memLoadingState( const SafeArray<u8>& load_from ) : 
	SaveStateBase( const_cast<SafeArray<u8>&>(load_from) )
{
}

memLoadingState::~memLoadingState() { }

// Loading of state data 
void memLoadingState::FreezeMem( void* data, int size )
{
	const u8* const src = m_memory.GetPtr(m_idx);
	m_idx += size;
	memcpy_fast( data, src, size );
}

bool memLoadingState::SeekToSection( PluginsEnum_t pid )
{
	m_idx = 0;		// start from the beginning

	do
	{
		while( FreezeSection( FreezeId_Plugin ) );
		if( m_sectid == FreezeId_End ) return false;

		FreezeTag( "Plugin" );
		int seekpos = m_idx + 4;
		int sectlen = 0xdead;

		Freeze( sectlen );
		Freeze( m_pid );

	} while( m_pid != pid );
	return true;
}