mirror
/
pcsx2
mirror of https://github.com/PCSX2/pcsx2
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge e6c6cd82bf into 5bdee3a611

This commit is contained in:
Ty 2025-12-16 22:25:57 -05:00 committed by GitHub
parent 5bdee3a611 e6c6cd82bf
commit 9d4038c908
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
9 changed files with 249 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
common/Darwin/DarwinMisc.cpp
View File

@ -410,6 +410,29 @@ void* HostSys::CreateSharedMemory(const char* name, size_t size)
return reinterpret_cast<void*>(static_cast<uintptr_t>(port));
}
void* HostSys::CreateMappingFromFile(FILE* file)
{
return reinterpret_cast<void*>(static_cast<uintptr_t>(fileno(file)));
}
void* HostSys::MapMapping(void* handle, size_t size, const PageProtectionMode& mode)
{
const u32 mmap_prot = (mode.CanWrite() ? (PROT_READ | PROT_WRITE) : (PROT_READ)) | (mode.CanExecute() ? PROT_EXEC : 0);
return mmap(nullptr, size, mmap_prot, MAP_PRIVATE, static_cast<int>(reinterpret_cast<intptr_t>(handle)), 0);
}
void HostSys::DestroyMapping(void* handle)
{
// The handle mmap requires is the same as the file descriptor.
return;
}
void HostSys::FlushMapping(void* handle, [[maybe_unused]] void* baseAddr, size_t size)
{
msync(handle, size, MS_SYNC);
}
void HostSys::DestroySharedMemory(void* ptr)
{
mach_port_deallocate(mach_task_self(), static_cast<mach_port_t>(reinterpret_cast<uintptr_t>(ptr)));

17
common/FileSystem.cpp
View File

@ -1141,6 +1141,23 @@ s64 FileSystem::FSize64(std::FILE* fp)
return -1;
}
bool FileSystem::FFlush(std::FILE *fp)
{
#ifdef _WIN32
HANDLE hFile = (HANDLE)_get_osfhandle(_fileno(fp));
if(hFile != INVALID_HANDLE_VALUE)
{
if(FlushFileBuffers(hFile))
{
return true;
}
}
return false;
#else
return !std::fflush(fp);
#endif
}
s64 FileSystem::GetPathFileSize(const char* Path)
{
FILESYSTEM_STAT_DATA sd;

2
common/FileSystem.h
View File

@ -120,6 +120,8 @@ namespace FileSystem
s64 FTell64(std::FILE* fp);
s64 FSize64(std::FILE* fp);
bool FFlush(std::FILE* fp);
int OpenFDFile(const char* filename, int flags, int mode, Error* error = nullptr);
/// Sharing modes for OpenSharedCFile().

6
common/HostSys.h
View File

@ -102,6 +102,12 @@ namespace HostSys
extern std::string GetFileMappingName(const char* prefix);
extern void* CreateSharedMemory(const char* name, size_t size);
extern void* CreateMappingFromFile(FILE* file);
extern void* MapMapping(void* handle, size_t size, const PageProtectionMode& mode);
extern void DestroyMapping(void* handle);
extern void FlushMapping(void* handle, void* baseAddr, size_t size);
extern void DestroySharedMemory(void* ptr);
extern void* MapSharedMemory(void* handle, size_t offset, void* baseaddr, size_t size, const PageProtectionMode& mode);
extern void UnmapSharedMemory(void* baseaddr, size_t size);

21
common/Linux/LnxHostSys.cpp
View File

@ -115,6 +115,27 @@ void* HostSys::CreateSharedMemory(const char* name, size_t size)
return reinterpret_cast<void*>(static_cast<intptr_t>(fd));
}
void* HostSys::CreateMappingFromFile(FILE* file)
{
return reinterpret_cast<void*>(static_cast<intptr_t>(fileno(file)));
}
void* HostSys::MapMapping(void* handle, size_t size, const PageProtectionMode& mode)
{
return HostSys::MapSharedMemory(handle, 0, nullptr, size, mode);
}
void HostSys::DestroyMapping(void* handle)
{
// The handle mmap requires is the same as the file descriptor.
return;
}
void HostSys::FlushMapping(void* handle, [[maybe_unused]] void* baseAddr, size_t size)
{
msync(handle, size, MS_SYNC);
}
void HostSys::DestroySharedMemory(void* ptr)
{
close(static_cast<int>(reinterpret_cast<intptr_t>(ptr)));

22
common/Windows/WinHostSys.cpp
View File

@ -12,6 +12,7 @@
#include "fmt/format.h"
#include <io.h>
#include <mutex>
static DWORD ConvertToWinApi(const PageProtectionMode& mode)
@ -71,6 +72,27 @@ void* HostSys::CreateSharedMemory(const char* name, size_t size)
static_cast<DWORD>(size >> 32), static_cast<DWORD>(size), StringUtil::UTF8StringToWideString(name).c_str()));
}
void* HostSys::CreateMappingFromFile(FILE* fd)
{
return static_cast<void*>(CreateFileMappingW(reinterpret_cast<HANDLE>(_get_osfhandle(_fileno(fd))), NULL, PAGE_READWRITE,
0, 0, nullptr));
}
void* HostSys::MapMapping(void* handle, size_t size, const PageProtectionMode& mode)
{
return MapViewOfFile(static_cast<HANDLE>(handle), FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
}
void HostSys::DestroyMapping(void* handle)
{
CloseHandle(static_cast<HANDLE>(handle));
}
void HostSys::FlushMapping([[maybe_unused]] void* handle, void* baseAddr, size_t size)
{
FlushViewOfFile(baseAddr, size);
}
void HostSys::DestroySharedMemory(void* ptr)
{
CloseHandle(static_cast<HANDLE>(ptr));

2
pcsx2/Config.h
View File

@ -1133,8 +1133,6 @@ struct Pcsx2Config
bool GenerateFunctionHashes = true;
void LoadSave(SettingsWrapper& wrap);
friend auto operator<=>(const DebugAnalysisOptions& lhs, const DebugAnalysisOptions& rhs) = default;
};
// ------------------------------------------------------------------------

212
pcsx2/SIO/Memcard/MemoryCardFile.cpp
View File

@ -11,11 +11,14 @@
#include "common/Console.h"
#include "common/Error.h"
#include "common/FileSystem.h"
#include "common/HostSys.h"
#include "common/Path.h"
#include "common/StringUtil.h"
#include "common/Threading.h"
#include <array>
#include <chrono>
#include <thread>
#include "Config.h"
#include "Host.h"
@ -159,6 +162,14 @@ class FileMemoryCard
{
protected:
std::FILE* m_file[8] = {};
u8* m_mappings[8] = {};
void* m_mapping_handles[8] = {};
std::thread flushThread;
std::atomic<bool> stopFlushThread{false};
std::mutex flushMutex;
std::condition_variable flushCV;
s64 m_fileSize[8] = {};
std::string m_filenames[8] = {};
std::vector<u8> m_currentdata;
@ -166,6 +177,8 @@ protected:
bool m_ispsx[8] = {};
u32 m_chkaddr = 0;
std::chrono::time_point<std::chrono::system_clock> m_lastSaveTime = std::chrono::system_clock::now();
public:
FileMemoryCard();
~FileMemoryCard();
@ -187,6 +200,9 @@ public:
protected:
bool Seek(std::FILE* f, u32 adr);
bool Create(const char* mcdFile, uint sizeInMB);
void FlushAllCards();
void FlushThreadFunc();
};
uint FileMcd_GetMtapPort(uint slot)
@ -255,9 +271,20 @@ FileMemoryCard::FileMemoryCard()
{
m_fileSize[slot] = -1;
}
flushThread = std::thread(&FileMemoryCard::FlushThreadFunc, this);
}
FileMemoryCard::~FileMemoryCard() = default;
FileMemoryCard::~FileMemoryCard()
{
stopFlushThread = true;
flushCV.notify_all();
if(flushThread.joinable())
{
Console.WriteLn("MemoryCards: Waiting on memory card flushing thread.");
flushThread.join();
}
}
void FileMemoryCard::Open()
{
@ -313,46 +340,74 @@ void FileMemoryCard::Open()
}
if (!m_file[slot])
goto memoryCardOpenFailed;
m_fileSize[slot] = FileSystem::FSize64(m_file[slot]);
m_mapping_handles[slot] = HostSys::CreateMappingFromFile(m_file[slot]);
if (!m_mapping_handles[slot])
{
Host::ReportErrorAsync(TRANSLATE_SV("MemoryCard", "Memory Card Read Failed"),
fmt::format(TRANSLATE_FS("MemoryCard", "Unable to access memory card:\n\n{}\n\n"
"Another instance of PCSX2 may be using this memory card "
"or the memory card is stored in a write-protected folder.\n"
"Close any other instances of PCSX2, or restart your computer.\n"),
fname));
Console.Warning("MemoryCardFile: CreateMappingFromFile failed!");
goto memoryCardOpenFailed;
}
else // Load checksum
m_mappings[slot] = static_cast<u8*>(HostSys::MapMapping(m_mapping_handles[slot], m_fileSize[slot], PageAccess_ReadWrite()));
if (!m_mappings[slot] || reinterpret_cast<intptr_t>(m_mappings[slot]) < 0)
{
m_fileSize[slot] = FileSystem::FSize64(m_file[slot]);
Console.WriteLnFmt(Color_Green, "McdSlot {} [File]: {} [{} MB, {}]", slot, Path::GetFileName(fname),
(m_fileSize[slot] + (MCD_SIZE + 1)) / MC2_MBSIZE,
FileMcd_IsMemoryCardFormatted(m_file[slot]) ? "Formatted" : "UNFORMATTED");
m_filenames[slot] = std::move(fname);
m_ispsx[slot] = m_fileSize[slot] == 0x20000;
m_chkaddr = 0x210;
if (!m_ispsx[slot] && FileSystem::FSeek64(m_file[slot], m_chkaddr, SEEK_SET) == 0)
{
const size_t read_result = std::fread(&m_chksum[slot], sizeof(m_chksum[slot]), 1, m_file[slot]);
if (read_result == 0)
Host::ReportErrorAsync("Memory Card Read Failed", "Error reading memory card.");
}
Console.Warning("MemoryCardFile: MapSharedMemory failed! %d. %s", errno, strerror(errno));
goto memoryCardOpenFailed;
}
Console.WriteLnFmt(Color_Green, "McdSlot {} [File]: {} [{} MB, {}]", slot, Path::GetFileName(fname),
(m_fileSize[slot] + (MCD_SIZE + 1)) / MC2_MBSIZE,
FileMcd_IsMemoryCardFormatted(m_file[slot]) ? "Formatted" : "UNFORMATTED");
m_filenames[slot] = std::move(fname);
m_ispsx[slot] = m_fileSize[slot] == 0x20000;
m_chkaddr = 0x210;
if (!m_ispsx[slot])
{
std::memcpy(&m_chksum[slot], m_mappings[slot] + m_chkaddr, sizeof(m_chksum[slot]));
}
continue;
memoryCardOpenFailed:
Host::ReportErrorAsync(TRANSLATE_SV("MemoryCard", "Memory Card Read Failed"),
fmt::format(TRANSLATE_FS("MemoryCard", "Unable to access memory card:\n\n{}\n\n"
"Another instance of PCSX2 may be using this memory card "
"or the memory card is stored in a write-protected folder.\n"
"Close any other instances of PCSX2, or restart your computer.\n"),
fname));
if(m_mapping_handles[slot])
{
HostSys::DestroyMapping(m_mapping_handles[slot]);
}
if(m_file[slot])
{
std::fclose(m_file[slot]);
m_file[slot] = nullptr;
}
m_filenames[slot] = {};
m_fileSize[slot] = -1;
}
}
void FileMemoryCard::Close()
{
std::unique_lock<std::mutex> lock(flushMutex);
for (int slot = 0; slot < 8; ++slot)
{
if (!m_file[slot])
continue;
// Store checksum
if (!m_ispsx[slot] && FileSystem::FSeek64(m_file[slot], m_chkaddr, SEEK_SET) == 0)
std::fwrite(&m_chksum[slot], sizeof(m_chksum[slot]), 1, m_file[slot]);
if (!m_ispsx[slot])
std::memcpy(m_mappings[slot] + m_chkaddr, &m_chksum[slot], sizeof(m_chksum[slot]));
std::fclose(m_file[slot]);
m_file[slot] = nullptr;
@ -364,6 +419,13 @@ void FileMemoryCard::Close()
FileSystem::DeleteFilePath(name_in.c_str());
}
if (m_mappings[slot])
{
HostSys::UnmapSharedMemory(m_mappings[slot], m_fileSize[slot]);
HostSys::DestroyMapping(m_mapping_handles[slot]);
m_mappings[slot] = nullptr;
}
m_filenames[slot] = {};
m_fileSize[slot] = -1;
}
@ -432,13 +494,21 @@ s32 FileMemoryCard::Read(uint slot, u8* dest, u32 adr, int size)
memset(dest, 0, size);
return 1;
}
if (!Seek(mcfp, adr))
return 0;
return std::fread(dest, size, 1, mcfp) == 1;
if (adr + size > static_cast<u32>(m_fileSize[slot]))
{
Console.Warning("(FileMcd) Warning: read past end of file. (%d) [%08X]", slot, adr);
}
std::memcpy(dest, m_mappings[slot] + adr, size);
return 1;
}
s32 FileMemoryCard::Save(uint slot, const u8* src, u32 adr, int size)
{
if (adr + size > static_cast<u32>(m_fileSize[slot]))
return 0;
std::FILE* mcfp = m_file[slot];
if (!mcfp)
@ -456,14 +526,10 @@ s32 FileMemoryCard::Save(uint slot, const u8* src, u32 adr, int size)
}
else
{
if (!Seek(mcfp, adr))
return 0;
if (static_cast<int>(m_currentdata.size()) < size)
m_currentdata.resize(size);
const size_t read_result = std::fread(m_currentdata.data(), size, 1, mcfp);
if (read_result == 0)
Host::ReportErrorAsync("Memory Card Read Failed", "Error reading memory card.");
std::memcpy(m_currentdata.data(), m_mappings[slot] + adr, size);
for (int i = 0; i < size; i++)
{
@ -485,26 +551,20 @@ s32 FileMemoryCard::Save(uint slot, const u8* src, u32 adr, int size)
}
}
if (!Seek(mcfp, adr))
return 0;
std::memcpy(m_mappings[slot] + adr, src, size);
if (std::fwrite(m_currentdata.data(), size, 1, mcfp) == 1)
std::chrono::duration<float> elapsed = std::chrono::system_clock::now() - m_lastSaveTime;
if (elapsed > std::chrono::seconds(5))
{
static auto last = std::chrono::time_point<std::chrono::system_clock>();
std::chrono::duration<float> elapsed = std::chrono::system_clock::now() - last;
if (elapsed > std::chrono::seconds(5))
{
Host::AddIconOSDMessage(fmt::format("MemoryCardSave{}", slot), ICON_PF_MEMORY_CARD,
fmt::format(TRANSLATE_FS("MemoryCard", "Memory Card '{}' was saved to storage."),
Path::GetFileName(m_filenames[slot])),
Host::OSD_INFO_DURATION);
last = std::chrono::system_clock::now();
}
return 1;
Host::AddIconOSDMessage(fmt::format("MemoryCardSave{}", slot), ICON_PF_MEMORY_CARD,
fmt::format(TRANSLATE_FS("MemoryCard", "Memory Card '{}' was saved to storage."),
Path::GetFileName(m_filenames[slot])),
Host::OSD_INFO_DURATION);
m_lastSaveTime = std::chrono::system_clock::now();
}
return 0;
flushCV.notify_all();
return 1;
}
s32 FileMemoryCard::EraseBlock(uint slot, u32 adr)
@ -519,9 +579,9 @@ s32 FileMemoryCard::EraseBlock(uint slot, u32 adr)
if (!Seek(mcfp, adr))
return 0;
u8 buf[MC2_ERASE_SIZE];
std::memset(buf, 0xff, sizeof(buf));
return std::fwrite(buf, sizeof(buf), 1, mcfp) == 1;
std::memset(m_mappings[slot] + adr, 0xff, MC2_ERASE_SIZE);
return 1;
}
u64 FileMemoryCard::GetCRC(uint slot)
@ -534,9 +594,6 @@ u64 FileMemoryCard::GetCRC(uint slot)
if (m_ispsx[slot])
{
if (!Seek(mcfp, 0))
return 0;
const s64 mcfpsize = m_fileSize[slot];
if (mcfpsize < 0)
return 0;
@ -548,8 +605,7 @@ u64 FileMemoryCard::GetCRC(uint slot)
const uint filesize = static_cast<uint>(mcfpsize) / sizeof(buffer);
for (uint i = filesize; i; --i)
{
if (std::fread(buffer, sizeof(buffer), 1, mcfp) != 1)
return 0;
std::memcpy(buffer, m_mappings[slot], sizeof(buffer));
for (uint t = 0; t < std::size(buffer); ++t)
retval ^= buffer[t];
@ -563,6 +619,45 @@ u64 FileMemoryCard::GetCRC(uint slot)
return retval;
}
void FileMemoryCard::FlushAllCards()
{
// The lock in FlushThreadFunc should keep us safe from the main thread touching the handles here
for(size_t i = 0; i < 8; i++)
{
if(m_fileSize[i] > 0)
{
HostSys::FlushMapping(m_mapping_handles[i], m_mappings[i], m_fileSize[i]);
FileSystem::FFlush(m_file[i]);
}
}
}
void FileMemoryCard::FlushThreadFunc() {
Threading::SetNameOfCurrentThread("MemoryCard I/O Flush Thread");
while (!stopFlushThread) {
std::unique_lock<std::mutex> lock(flushMutex);
flushCV.wait(lock, [this] {
return stopFlushThread || MemcardBusy::IsBusy();
});
Console.Warning("!! Memory card is busy, waiting to commit to disk!");
while (!stopFlushThread) {
if (!MemcardBusy::IsBusy()) {
FlushAllCards();
Console.Warning("!! Memory card committed to disk!");
break;
}
lock.unlock();
Threading::Sleep(50);
lock.lock();
}
}
// In the event that the user closes PCSX2 while the memory card is busy (against our recommendations!!)
// we can at least ensure that the memory card is flushed to disk.
FlushAllCards();
}
// --------------------------------------------------------------------------------------
// MemoryCard Component API Bindings
// --------------------------------------------------------------------------------------
@ -609,7 +704,6 @@ void FileMcd_EmuOpen()
return;
FileMcd_Open = true;
Mcd::impl.Open();
Mcd::implFolder.SetFiltering(EmuConfig.McdFolderAutoManage);
Mcd::implFolder.Open();

10
pcsx2/SIO/Memcard/MemoryCardProtocol.cpp
View File

@ -207,6 +207,7 @@ void MemoryCardProtocol::GetTerminator()
void MemoryCardProtocol::WriteData()
{
MemcardBusy::SetBusy();
MC_LOG.WriteLn("%s", __FUNCTION__);
PS1_FAIL();
g_Sio2FifoOut.push_back(0x00);
@ -230,8 +231,6 @@ void MemoryCardProtocol::WriteData()
g_Sio2FifoOut.push_back(mcd->term);
ReadWriteIncrement(writeLength);
MemcardBusy::SetBusy();
}
void MemoryCardProtocol::ReadData()
@ -332,6 +331,8 @@ u8 MemoryCardProtocol::PS1State(u8 data)
u8 MemoryCardProtocol::PS1Write(u8 data)
{
MemcardBusy::SetBusy();
MC_LOG.WriteLn("%s", __FUNCTION__);
bool sendAck = true;
u8 ret = 0;
@ -396,7 +397,6 @@ u8 MemoryCardProtocol::PS1Write(u8 data)
g_Sio0.SetAcknowledge(sendAck);
ps1McState.currentByte++;
MemcardBusy::SetBusy();
return ret;
}
@ -416,12 +416,12 @@ void MemoryCardProtocol::ReadWriteEnd()
void MemoryCardProtocol::EraseBlock()
{
MemcardBusy::SetBusy();
MC_LOG.WriteLn("%s", __FUNCTION__);
PS1_FAIL();
mcd->EraseBlock();
The2bTerminator(4);
MemcardBusy::SetBusy();
}
void MemoryCardProtocol::UnknownBoot()