mirrors/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-04-19 19:15:26 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Some functions removed

Browse source
This commit is contained in:
Nekotekina 2014-09-04 21:32:20 +04:00
parent 05cebd1017
commit 9f2afffca1
33 changed files with 401 additions and 446 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Utilities/rTime.cpp
View file

@ -139,9 +139,9 @@ std::string rDateTime::Format(const std::string &format, const rTimeZone &tz) co
return fmt::ToUTF8(static_cast<wxDateTime*>(handle)->Format(fmt::FromUTF8(format),convertTZ(tz)));
}
void rDateTime::ParseDateTime(const std::string & format)
void rDateTime::ParseDateTime(const char* format)
{
static_cast<wxDateTime*>(handle)->ParseDateTime(fmt::FromUTF8(format));
static_cast<wxDateTime*>(handle)->ParseDateTime(format);
}
u32 rDateTime::GetAsDOS()

2
Utilities/rTime.h
View file

@ -79,7 +79,7 @@ struct rDateTime
void Close();
std::string Format(const std::string &format = rDefaultDateTimeFormat, const rTimeZone &tz = Local) const;
void ParseDateTime(const std::string & format);
void ParseDateTime(const char* format);
u32 GetAsDOS();
rDateTime &SetFromDOS(u32 fromdos);

20
rpcs3/Emu/Cell/PPUInterpreter.h
View file

@ -2945,7 +2945,8 @@ private:
const u64 addr = ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb];
const u8 eb = addr & 0xf;
Memory.ReadLeft(CPU.VPR[vd]._u8 + eb, addr, 16 - eb);
CPU.VPR[vd].Clear();
for (u32 i = 0; i < 16 - eb; ++i) CPU.VPR[vd]._u8[15 - i] = Memory.Read8(addr + i);
}
void LDBRX(u32 rd, u32 ra, u32 rb)
{
@ -2987,7 +2988,8 @@ private:
const u64 addr = ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb];
const u8 eb = addr & 0xf;
Memory.ReadRight(CPU.VPR[vd]._u8, addr & ~0xf, eb);
CPU.VPR[vd].Clear();
for (u32 i = 16 - eb; i < 16; ++i) CPU.VPR[vd]._u8[15 - i] = Memory.Read8(addr + i - 16);
}
void LSWI(u32 rd, u32 ra, u32 nb)
{
@ -3043,7 +3045,7 @@ private:
const u64 addr = ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb];
const u8 eb = addr & 0xf;
Memory.WriteLeft(addr, 16 - eb, CPU.VPR[vs]._u8 + eb);
for (u32 i = 0; i < 16 - eb; ++i) Memory.Write8(addr + i, CPU.VPR[vs]._u8[15 - i]);
}
void STSWX(u32 rs, u32 ra, u32 rb)
{
@ -3062,7 +3064,7 @@ private:
const u64 addr = ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb];
const u8 eb = addr & 0xf;
Memory.WriteRight(addr - eb, eb, CPU.VPR[vs]._u8);
for (u32 i = 16 - eb; i < 16; ++i) Memory.Write8(addr + i - 16, CPU.VPR[vs]._u8[15 - i]);
}
void STFSUX(u32 frs, u32 ra, u32 rb)
{
@ -3113,7 +3115,8 @@ private:
const u64 addr = ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb];
const u8 eb = addr & 0xf;
Memory.ReadLeft(CPU.VPR[vd]._u8 + eb, addr, 16 - eb);
CPU.VPR[vd].Clear();
for (u32 i = 0; i < 16 - eb; ++i) CPU.VPR[vd]._u8[15 - i] = Memory.Read8(addr + i);
}
void LHBRX(u32 rd, u32 ra, u32 rb)
{
@ -3158,7 +3161,8 @@ private:
const u64 addr = ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb];
const u8 eb = addr & 0xf;
Memory.ReadRight(CPU.VPR[vd]._u8, addr & ~0xf, eb);
CPU.VPR[vd].Clear();
for (u32 i = 16 - eb; i < 16; ++i) CPU.VPR[vd]._u8[15 - i] = Memory.Read8(addr + i - 16);
}
void DSS(u32 strm, u32 a)
{
@ -3193,7 +3197,7 @@ private:
const u64 addr = ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb];
const u8 eb = addr & 0xf;
Memory.WriteLeft(addr, 16 - eb, CPU.VPR[vs]._u8 + eb);
for (u32 i = 0; i < 16 - eb; ++i) Memory.Write8(addr + i, CPU.VPR[vs]._u8[15 - i]);
}
void STHBRX(u32 rs, u32 ra, u32 rb)
{
@ -3209,7 +3213,7 @@ private:
const u64 addr = ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb];
const u8 eb = addr & 0xf;
Memory.WriteRight(addr - eb, eb, CPU.VPR[vs]._u8);
for (u32 i = 16 - eb; i < 16; ++i) Memory.Write8(addr + i - 16, CPU.VPR[vs]._u8[15 - i]);
}
void EXTSB(u32 ra, u32 rs, bool rc)
{

2
rpcs3/Emu/Cell/PPUThread.h
View file

@ -516,7 +516,7 @@ union VPR_reg
_u64[1] |= (value & 0x1) << bit;
}
void Clear() { memset(this, 0, sizeof(*this)); }
void Clear() { _u64[1] = _u64[0] = 0; }
};
static const s32 MAX_INT_VALUE = 0x7fffffff;

35
rpcs3/Emu/Memory/Memory.h
View file

@ -313,41 +313,6 @@ public:
}
}
void ReadLeft(u8* dst, const u64 addr, const u32 size)
{
for (u32 i = 0; i < size; ++i) dst[size - 1 - i] = Read8(addr + i);
}
void WriteLeft(const u64 addr, const u32 size, const u8* src)
{
for (u32 i = 0; i < size; ++i) Write8(addr + i, src[size - 1 - i]);
}
void ReadRight(u8* dst, const u64 addr, const u32 size)
{
for (u32 i = 0; i < size; ++i) dst[i] = Read8(addr + (size - 1 - i));
}
void WriteRight(const u64 addr, const u32 size, const u8* src)
{
for (u32 i = 0; i < size; ++i) Write8(addr + (size - 1 - i), src[i]);
}
//template<typename T, typename Td> void WriteData(const T addr, const Td* data)
//{
// memcpy(GetMemFromAddr<T>(addr), data, sizeof(Td));
//}
//template<typename T, typename Td> void WriteData(const T addr, const Td data)
//{
// *(Td*)GetMemFromAddr<T>(addr) = data;
//}
template<typename T> std::string ReadString(const T addr)
{
return std::string((const char*)GetMemFromAddr<T>(addr));
}
template<typename T> void WriteString(const T addr, const std::string& str)
{
memcpy((char*)GetMemFromAddr<T>(addr), str.c_str(), str.size() + 1);

111
rpcs3/Emu/Memory/vm_ptr.h
View file

@ -58,30 +58,29 @@ namespace vm
return make(m_addr - count * sizeof(AT));
}
__forceinline _ptr_base<T, lvl - 1, AT>& operator *()
__forceinline _ptr_base<T, lvl - 1, AT>& operator *() const
{
return vm::get_ref<_ptr_base<T, lvl - 1, AT>>(m_addr);
}
__forceinline const _ptr_base<T, lvl - 1, AT>& operator *() const
{
return vm::get_ref<const _ptr_base<T, lvl - 1, AT>>(m_addr);
}
__forceinline _ptr_base<T, lvl - 1, AT>& operator [](int index)
__forceinline _ptr_base<T, lvl - 1, AT>& operator [](int index) const
{
return vm::get_ref<_ptr_base<T, lvl - 1, AT>>(m_addr + sizeof(AT) * index);
}
__forceinline const _ptr_base<T, lvl - 1, AT>& operator [](int index) const
{
return vm::get_ref<const _ptr_base<T, lvl - 1, AT>>(m_addr + sizeof(AT) * index);
}
operator bool() const
{
return m_addr != 0;
}
//typedef typename invert_be_t<AT>::type AT2;
template<typename AT2>
operator const _ptr_base<T, lvl, AT2>() const
{
std::remove_const<AT2>::type addr; addr = m_addr;
return (_ptr_base<T, lvl, AT2>&)addr;
}
AT addr() const
{
@ -92,6 +91,8 @@ namespace vm
{
return (_ptr_base&)addr;
}
_ptr_base& operator = (const _ptr_base& right) = default;
};
template<typename T, typename AT>
@ -100,16 +101,11 @@ namespace vm
AT m_addr;
public:
__forceinline T* const operator -> ()
__forceinline T* const operator -> () const
{
return vm::get_ptr<T>(m_addr);
}
__forceinline const T* const operator -> () const
{
return vm::get_ptr<const T>(m_addr);
}
_ptr_base operator++ (int)
{
AT result = m_addr;
@ -158,25 +154,15 @@ namespace vm
return make(m_addr - count * sizeof(T));
}
__forceinline T& operator *()
__forceinline T& operator *() const
{
return get_ref<T>(m_addr);
}
__forceinline const T& operator *() const
{
return get_ref<T>(m_addr);
}
__forceinline T& operator [](int index)
__forceinline T& operator [](int index) const
{
return get_ref<T>(m_addr + sizeof(T) * index);
}
__forceinline const T& operator [](int index) const
{
return get_ref<const T>(m_addr + sizeof(T) * index);
}
/*
operator _ref_base<T, AT>()
@ -200,6 +186,15 @@ namespace vm
return m_addr != 0;
}
//typedef typename invert_be_t<AT>::type AT2;
template<typename AT2>
operator const _ptr_base<T, 1, AT2>() const
{
std::remove_const<AT2>::type addr; addr = m_addr;
return (_ptr_base<T, 1, AT2>&)addr;
}
T* const get_ptr() const
{
return vm::get_ptr<T>(m_addr);
@ -209,6 +204,8 @@ namespace vm
{
return (_ptr_base&)addr;
}
_ptr_base& operator = (const _ptr_base& right) = default;
};
template<typename AT>
@ -232,10 +229,21 @@ namespace vm
return m_addr != 0;
}
//typedef typename invert_be_t<AT>::type AT2;
template<typename AT2>
operator const _ptr_base<void, 1, AT2>() const
{
std::remove_const<AT2>::type addr; addr = m_addr;
return (_ptr_base<void, 1, AT2>&)addr;
}
static _ptr_base make(AT addr)
{
return (_ptr_base&)addr;
}
_ptr_base& operator = (const _ptr_base& right) = default;
};
template<typename AT>
@ -259,10 +267,21 @@ namespace vm
return m_addr != 0;
}
//typedef typename invert_be_t<AT>::type AT2;
template<typename AT2>
operator const _ptr_base<const void, 1, AT2>() const
{
std::remove_const<AT2>::type addr; addr = m_addr;
return (_ptr_base<const void, 1, AT2>&)addr;
}
static _ptr_base make(AT addr)
{
return (_ptr_base&)addr;
}
_ptr_base& operator = (const _ptr_base& right) = default;
};
template<typename RT, typename AT>
@ -304,6 +323,15 @@ namespace vm
return m_addr != 0;
}
//typedef typename invert_be_t<AT>::type AT2;
template<typename AT2>
operator const _ptr_base<RT(*)(), 1, AT2>() const
{
std::remove_const<AT2>::type addr; addr = m_addr;
return (_ptr_base<RT(*)(), 1, AT2>&)addr;
}
static _ptr_base make(AT addr)
{
return (_ptr_base&)addr;
@ -314,6 +342,8 @@ namespace vm
const AT addr = m_addr;
return [addr]() -> RT { return make(addr)(); };
}
_ptr_base& operator = (const _ptr_base& right) = default;
};
template<typename AT, typename RT, typename ...T>
@ -371,16 +401,27 @@ namespace vm
return m_addr != 0;
}
//typedef typename invert_be_t<AT>::type AT2;
template<typename AT2>
operator const _ptr_base<RT(*)(T...), 1, AT2>() const
{
std::remove_const<AT2>::type addr; addr = m_addr;
return (_ptr_base<RT(*)(T...), 1, AT2>&)addr;
}
static _ptr_base make(AT addr)
{
return (_ptr_base&)addr;
}
operator std::function<RT(T...)>() const
operator const std::function<RT(T...)>() const
{
const AT addr = m_addr;
std::remove_const<AT>::type AT addr; addr = m_addr;
return [addr](T... args) -> RT { return make(addr)(args...); };
}
_ptr_base& operator = (const _ptr_base& right) = default;
};
//BE pointer to LE data
@ -392,6 +433,7 @@ namespace vm
}
using _ptr_base<T, lvl, typename to_be_t<AT>::type>::operator=;
//using _ptr_base<T, lvl, typename to_be_t<AT>::type>::operator const _ptr_base<T, lvl, AT>;
};
//BE pointer to BE data
@ -403,6 +445,7 @@ namespace vm
}
using _ptr_base<typename to_be_t<T>::type, lvl, typename to_be_t<AT>::type>::operator=;
//using _ptr_base<typename to_be_t<T>::type, lvl, typename to_be_t<AT>::type>::operator const _ptr_base<typename to_be_t<T>::type, lvl, AT>;
};
//LE pointer to BE data
@ -414,6 +457,7 @@ namespace vm
}
using _ptr_base<typename to_be_t<T>::type, lvl, AT>::operator=;
//using _ptr_base<typename to_be_t<T>::type, lvl, AT>::operator const _ptr_base<typename to_be_t<T>::type, lvl, typename to_be_t<AT>::type>;
};
//LE pointer to LE data
@ -425,6 +469,7 @@ namespace vm
}
using _ptr_base<T, lvl, AT>::operator=;
//using _ptr_base<T, lvl, AT>::operator const _ptr_base<T, lvl, typename to_be_t<AT>::type>;
};
namespace ps3
@ -438,6 +483,7 @@ namespace vm
}
using lptrb<T, lvl, AT>::operator=;
//using lptrb<T, lvl, AT>::operator const _ptr_base<typename to_be_t<T>::type, lvl, AT>;
};
//default pointer for HLE structures (BE ptrerence to BE data)
@ -449,6 +495,7 @@ namespace vm
}
using bptrb<T, lvl, AT>::operator=;
//using bptrb<T, lvl, AT>::operator const _ptr_base<typename to_be_t<T>::type, lvl, AT>;
};
}

4
rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp
View file

@ -23,7 +23,7 @@ int cellGifDecExtCreate(u32 mainHandle, u32 threadInParam, u32 threadOutParam, u
return CELL_OK;
}
int cellGifDecOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, const vm::ptr<CellGifDecSrc> src, vm::ptr<CellGifDecOpnInfo> openInfo)
int cellGifDecOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, vm::ptr<CellGifDecSrc> src, vm::ptr<CellGifDecOpnInfo> openInfo)
{
cellGifDec->Warning("cellGifDecOpen(mainHandle=0x%x, subHandle_addr=0x%x, src_addr=0x%x, openInfo_addr=0x%x)",
mainHandle, subHandle.addr(), src.addr(), openInfo.addr());
@ -41,7 +41,7 @@ int cellGifDecOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, const vm::ptr<C
case se32(CELL_GIFDEC_FILE):
// Get file descriptor
vm::var<be_t<u32>> fd;
int ret = cellFsOpen(src->fileName, 0, fd, vm::ptr<be_t<u32>>::make(0), 0);
int ret = cellFsOpen(vm::ptr<const char>::make(src->fileName.addr()), 0, fd, vm::ptr<be_t<u32>>::make(0), 0);
current_subHandle->fd = fd->ToLE();
if (ret != CELL_OK) return CELL_GIFDEC_ERROR_OPEN_FILE;

2
rpcs3/Emu/SysCalls/Modules/cellGifDec.h
View file

@ -53,7 +53,7 @@ struct CellGifDecInfo
struct CellGifDecSrc
{
be_t<u32> srcSelect;
be_t<u32> fileName;
vm::bptr<const char> fileName;
be_t<s64> fileOffset;
be_t<u64> fileSize;
be_t<u32> streamPtr;

2
rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp
View file

@ -47,7 +47,7 @@ int cellJpgDecOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, vm::ptr<CellJpg
case se32(CELL_JPGDEC_FILE):
// Get file descriptor
vm::var<be_t<u32>> fd;
int ret = cellFsOpen(src->fileName, 0, fd, vm::ptr<be_t<u32>>::make(0), 0);
int ret = cellFsOpen(vm::ptr<const char>::make(src->fileName.addr()), 0, fd, vm::ptr<be_t<u32>>::make(0), 0);
current_subHandle->fd = fd->ToLE();
if (ret != CELL_OK) return CELL_JPGDEC_ERROR_OPEN_FILE;

2
rpcs3/Emu/SysCalls/Modules/cellJpgDec.h
View file

@ -56,7 +56,7 @@ struct CellJpgDecInfo
struct CellJpgDecSrc
{
be_t<u32> srcSelect; // CellJpgDecStreamSrcSel
be_t<u32> fileName; // const char*
vm::bptr<const char> fileName;
be_t<u64> fileOffset; // int64_t
be_t<u32> fileSize;
be_t<u32> streamPtr;

2
rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
View file

@ -69,7 +69,7 @@ int cellPngDecOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, vm::ptr<CellPng
case se32(CELL_PNGDEC_FILE):
// Get file descriptor
vm::var<be_t<u32>> fd;
int ret = cellFsOpen(src->fileName_addr, 0, fd, vm::ptr<be_t<u32>>::make(0), 0);
int ret = cellFsOpen(vm::ptr<const char>::make(src->fileName.addr()), 0, fd, vm::ptr<be_t<u32>>::make(0), 0);
current_subHandle->fd = fd->ToLE();
if(ret != CELL_OK) return CELL_PNGDEC_ERROR_OPEN_FILE;

2
rpcs3/Emu/SysCalls/Modules/cellPngDec.h
View file

@ -78,7 +78,7 @@ struct CellPngDecInfo
struct CellPngDecSrc
{
be_t<u32> srcSelect; // CellPngDecStreamSrcSel
be_t<u32> fileName_addr; // const char*
vm::bptr<const char> fileName;
be_t<s64> fileOffset;
be_t<u32> fileSize;
be_t<u32> streamPtr;

14
rpcs3/Emu/SysCalls/Modules/cellRtc.cpp
View file

@ -135,28 +135,26 @@ int cellRtcFormatRfc3339LocalTime(u32 pszDateTime_addr, vm::ptr<CellRtcTick> pUt
return CELL_OK;
}
int cellRtcParseDateTime(vm::ptr<CellRtcTick> pUtc, u32 pszDateTime_addr)
int cellRtcParseDateTime(vm::ptr<CellRtcTick> pUtc, vm::ptr<const char> pszDateTime)
{
cellRtc->Log("cellRtcParseDateTime(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.addr(), pszDateTime_addr);
cellRtc->Log("cellRtcParseDateTime(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.addr(), pszDateTime.addr());
// Get date from formatted string.
rDateTime date;
const std::string& format = Memory.ReadString(pszDateTime_addr);
date.ParseDateTime(format);
date.ParseDateTime(pszDateTime.get_ptr());
pUtc->tick = date.GetTicks();
return CELL_OK;
}
int cellRtcParseRfc3339(vm::ptr<CellRtcTick> pUtc, u32 pszDateTime_addr)
int cellRtcParseRfc3339(vm::ptr<CellRtcTick> pUtc, vm::ptr<const char> pszDateTime)
{
cellRtc->Log("cellRtcParseRfc3339(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.addr(), pszDateTime_addr);
cellRtc->Log("cellRtcParseRfc3339(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.addr(), pszDateTime.addr());
// Get date from RFC3339 formatted string.
rDateTime date;
const std::string& format = Memory.ReadString(pszDateTime_addr);
date.ParseDateTime(format);
date.ParseDateTime(pszDateTime.get_ptr());
pUtc->tick = date.GetTicks();

156
rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp → rpcs3/Emu/SysCalls/Modules/cellSaveData.cpp
View file

@ -7,7 +7,7 @@
#include "Emu/FS/vfsFile.h"
#include "Emu/FS/vfsDir.h"
#include "Loader/PSF.h"
#include "cellSysutil_SaveData.h"
#include "cellSaveData.h"
extern Module *cellSysutil;
@ -88,10 +88,10 @@ void addSaveDataEntry(std::vector<SaveDataEntry>& saveEntries, const std::string
void addNewSaveDataEntry(std::vector<SaveDataEntry>& saveEntries, vm::ptr<CellSaveDataListNewData> newData)
{
SaveDataEntry saveEntry;
saveEntry.dirName = (char*)Memory.VirtualToRealAddr(newData->dirName_addr);
saveEntry.title = (char*)Memory.VirtualToRealAddr(newData->icon->title_addr);
saveEntry.subtitle = (char*)Memory.VirtualToRealAddr(newData->icon->title_addr);
saveEntry.iconBuf = Memory.VirtualToRealAddr(newData->icon->iconBuf_addr);
saveEntry.dirName = newData->dirName.get_ptr();
saveEntry.title = newData->icon->title.get_ptr();
saveEntry.subtitle = newData->icon->title.get_ptr();
saveEntry.iconBuf = newData->icon->iconBuf.get_ptr();
saveEntry.iconBufSize = newData->icon->iconBufSize;
saveEntry.isNew = true;
// TODO: Add information stored in newData->iconPosition. (It's not very relevant)
@ -131,7 +131,7 @@ void setSaveDataFixed(std::vector<SaveDataEntry>& saveEntries, vm::ptr<CellSaveD
std::vector<SaveDataEntry>::iterator entry = saveEntries.begin();
while (entry != saveEntries.end())
{
if (entry->dirName == (char*)Memory.VirtualToRealAddr(fixedSet->dirName_addr))
if (entry->dirName == fixedSet->dirName.get_ptr())
entry = saveEntries.erase(entry);
else
entry++;
@ -140,17 +140,17 @@ void setSaveDataFixed(std::vector<SaveDataEntry>& saveEntries, vm::ptr<CellSaveD
if (saveEntries.size() == 0)
{
SaveDataEntry entry;
entry.dirName = (char*)Memory.VirtualToRealAddr(fixedSet->dirName_addr);
entry.dirName = fixedSet->dirName.get_ptr();
entry.isNew = true;
saveEntries.push_back(entry);
}
if (fixedSet->newIcon)
{
saveEntries[0].iconBuf = Memory.VirtualToRealAddr(fixedSet->newIcon->iconBuf_addr);
saveEntries[0].iconBuf = fixedSet->newIcon->iconBuf.get_ptr();
saveEntries[0].iconBufSize = fixedSet->newIcon->iconBufSize;
saveEntries[0].title = (char*)Memory.VirtualToRealAddr(fixedSet->newIcon->title_addr);
saveEntries[0].subtitle = (char*)Memory.VirtualToRealAddr(fixedSet->newIcon->title_addr);
saveEntries[0].title = fixedSet->newIcon->title.get_ptr();
saveEntries[0].subtitle = fixedSet->newIcon->title.get_ptr();
}
}
@ -168,13 +168,13 @@ void getSaveDataStat(SaveDataEntry entry, vm::ptr<CellSaveDataStatGet> statGet)
statGet->dir.st_atime_ = 0; // TODO ?
statGet->dir.st_mtime_ = 0; // TODO ?
statGet->dir.st_ctime_ = 0; // TODO ?
memcpy(statGet->dir.dirName, entry.dirName.c_str(), CELL_SAVEDATA_DIRNAME_SIZE);
strcpy_trunc(statGet->dir.dirName, entry.dirName);
statGet->getParam.attribute = 0; // TODO ?
memcpy(statGet->getParam.title, entry.title.c_str(), CELL_SAVEDATA_SYSP_TITLE_SIZE);
memcpy(statGet->getParam.subTitle, entry.subtitle.c_str(), CELL_SAVEDATA_SYSP_SUBTITLE_SIZE);
memcpy(statGet->getParam.detail, entry.details.c_str(), CELL_SAVEDATA_SYSP_DETAIL_SIZE);
memcpy(statGet->getParam.listParam, entry.listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
strcpy_trunc(statGet->getParam.title, entry.title);
strcpy_trunc(statGet->getParam.subTitle, entry.subtitle);
strcpy_trunc(statGet->getParam.detail, entry.details);
strcpy_trunc(statGet->getParam.listParam, entry.listParam);
statGet->fileNum = 0;
statGet->fileList = vm::bptr<CellSaveDataFileStat>::make(0);
@ -203,7 +203,7 @@ void getSaveDataStat(SaveDataEntry entry, vm::ptr<CellSaveDataStatGet> statGet)
fileEntry.st_atime_ = 0; // TODO ?
fileEntry.st_mtime_ = 0; // TODO ?
fileEntry.st_ctime_ = 0; // TODO ?
memcpy(fileEntry.fileName, dirEntry->name.c_str(), CELL_SAVEDATA_FILENAME_SIZE);
strcpy_trunc(fileEntry.fileName, dirEntry->name);
fileEntries.push_back(fileEntry);
}
@ -236,12 +236,12 @@ s32 modifySaveDataFiles(vm::ptr<CellSaveDataFileCallback> funcFile, vm::ptr<Cell
std::string filepath = saveDataDir + '/';
vfsStream* file = NULL;
void* buf = Memory.VirtualToRealAddr(fileSet->fileBuf_addr);
void* buf = fileSet->fileBuf.get_ptr();
switch ((u32)fileSet->fileType)
{
case CELL_SAVEDATA_FILETYPE_SECUREFILE: filepath += (char*)Memory.VirtualToRealAddr(fileSet->fileName_addr); break;
case CELL_SAVEDATA_FILETYPE_NORMALFILE: filepath += (char*)Memory.VirtualToRealAddr(fileSet->fileName_addr); break;
case CELL_SAVEDATA_FILETYPE_SECUREFILE: filepath += fileSet->fileName.get_ptr(); break;
case CELL_SAVEDATA_FILETYPE_NORMALFILE: filepath += fileSet->fileName.get_ptr(); break;
case CELL_SAVEDATA_FILETYPE_CONTENT_ICON0: filepath += "ICON0.PNG"; break;
case CELL_SAVEDATA_FILETYPE_CONTENT_ICON1: filepath += "ICON1.PAM"; break;
case CELL_SAVEDATA_FILETYPE_CONTENT_PIC1: filepath += "PIC1.PNG"; break;
@ -289,10 +289,10 @@ s32 modifySaveDataFiles(vm::ptr<CellSaveDataFileCallback> funcFile, vm::ptr<Cell
// Functions
int cellSaveDataListSave2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm::ptr<CellSaveDataSetBuf> setBuf,
vm::ptr<CellSaveDataListCallback> funcList, vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
u32 container, u32 userdata_addr)
u32 container, vm::ptr<void> userdata)
{
cellSysutil->Warning("cellSaveDataListSave2(version=%d, setList_addr=0x%x, setBuf_addr=0x%x, funcList_addr=0x%x, funcStat_addr=0x%x, funcFile_addr=0x%x, container=0x%x, userdata_addr=0x%x)",
version, setList.addr(), setBuf.addr(), funcList.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
version, setList.addr(), setBuf.addr(), funcList.addr(), funcStat.addr(), funcFile.addr(), container, userdata.addr());
vm::var<CellSaveDataCBResult> result;
vm::var<CellSaveDataListGet> listGet;
@ -305,7 +305,7 @@ int cellSaveDataListSave2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm:
if(!dir.IsOpened())
return CELL_SAVEDATA_ERROR_INTERNAL;
std::string dirNamePrefix = Memory.ReadString(setList->dirNamePrefix_addr);
std::string dirNamePrefix = setList->dirNamePrefix.get_ptr();
std::vector<SaveDataEntry> saveEntries;
for(const DirEntryInfo* entry = dir.Read(); entry; entry = dir.Read())
@ -325,12 +325,13 @@ int cellSaveDataListSave2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm:
// Sort the entries and fill the listGet->dirList array
std::sort(saveEntries.begin(), saveEntries.end(), sortSaveDataEntry(setList->sortType, setList->sortOrder));
listGet->dirList = vm::bptr<CellSaveDataDirList>::make(setBuf->buf_addr);
listGet->dirList = vm::bptr<CellSaveDataDirList>::make(setBuf->buf.addr());
CellSaveDataDirList* dirList = (CellSaveDataDirList*)Memory.VirtualToRealAddr(listGet->dirList.addr());
for (u32 i=0; i<saveEntries.size(); i++) {
memcpy(dirList[i].dirName, saveEntries[i].dirName.c_str(), CELL_SAVEDATA_DIRNAME_SIZE);
memcpy(dirList[i].listParam, saveEntries[i].listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
strcpy_trunc(dirList[i].dirName, saveEntries[i].dirName);
strcpy_trunc(dirList[i].listParam, saveEntries[i].listParam);
*dirList[i].reserved = {};
}
funcList(result, listGet, listSet);
@ -352,7 +353,7 @@ int cellSaveDataListSave2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm:
// TODO: Display the dialog here
u32 selectedIndex = focusIndex; // TODO: Until the dialog is implemented, select always the focused entry
getSaveDataStat(saveEntries[selectedIndex], statGet);
result->userdata_addr = userdata_addr;
result->userdata = userdata;
funcStat(result, statGet, statSet);
Memory.Free(statGet->fileList.addr());
@ -373,10 +374,10 @@ int cellSaveDataListSave2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm:
int cellSaveDataListLoad2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm::ptr<CellSaveDataSetBuf> setBuf,
vm::ptr<CellSaveDataListCallback> funcList, vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
u32 container, u32 userdata_addr)
u32 container, vm::ptr<void> userdata)
{
cellSysutil->Warning("cellSaveDataListLoad2(version=%d, setList_addr=0x%x, setBuf_addr=0x%x, funcList_addr=0x%x, funcStat_addr=0x%x, funcFile_addr=0x%x, container=0x%x, userdata_addr=0x%x)",
version, setList.addr(), setBuf.addr(), funcList.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
version, setList.addr(), setBuf.addr(), funcList.addr(), funcStat.addr(), funcFile.addr(), container, userdata.addr());
vm::var<CellSaveDataCBResult> result;
vm::var<CellSaveDataListGet> listGet;
@ -390,7 +391,7 @@ int cellSaveDataListLoad2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm:
if(!dir.IsOpened())
return CELL_SAVEDATA_ERROR_INTERNAL;
std::string dirNamePrefix = Memory.ReadString(setList->dirNamePrefix_addr);
std::string dirNamePrefix = setList->dirNamePrefix.get_ptr();
std::vector<SaveDataEntry> saveEntries;
for(const DirEntryInfo* entry = dir.Read(); entry; entry = dir.Read())
@ -410,12 +411,13 @@ int cellSaveDataListLoad2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm:
// Sort the entries and fill the listGet->dirList array
std::sort(saveEntries.begin(), saveEntries.end(), sortSaveDataEntry(setList->sortType, setList->sortOrder));
listGet->dirList = vm::bptr<CellSaveDataDirList>::make(setBuf->buf_addr);
listGet->dirList = vm::bptr<CellSaveDataDirList>::make(setBuf->buf.addr());
CellSaveDataDirList* dirList = (CellSaveDataDirList*)Memory.VirtualToRealAddr(listGet->dirList.addr());
for (u32 i=0; i<saveEntries.size(); i++) {
memcpy(dirList[i].dirName, saveEntries[i].dirName.c_str(), CELL_SAVEDATA_DIRNAME_SIZE);
memcpy(dirList[i].listParam, saveEntries[i].listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
strcpy_trunc(dirList[i].dirName, saveEntries[i].dirName);
strcpy_trunc(dirList[i].listParam, saveEntries[i].listParam);
*dirList[i].reserved = {};
}
funcList(result, listGet, listSet);
@ -437,7 +439,7 @@ int cellSaveDataListLoad2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm:
// TODO: Display the dialog here
u32 selectedIndex = focusIndex; // TODO: Until the dialog is implemented, select always the focused entry
getSaveDataStat(saveEntries[selectedIndex], statGet);
result->userdata_addr = userdata_addr;
result->userdata = userdata;
funcStat(result, statGet, statSet);
Memory.Free(statGet->fileList.addr());
@ -458,10 +460,10 @@ int cellSaveDataListLoad2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm:
int cellSaveDataFixedSave2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm::ptr<CellSaveDataSetBuf> setBuf,
vm::ptr<CellSaveDataFixedCallback> funcFixed, vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
u32 container, u32 userdata_addr)
u32 container, vm::ptr<void> userdata)
{
cellSysutil->Warning("cellSaveDataFixedSave2(version=%d, setList_addr=0x%x, setBuf_addr=0x%x, funcFixed_addr=0x%x, funcStat_addr=0x%x, funcFile_addr=0x%x, container=0x%x, userdata_addr=0x%x)",
version, setList.addr(), setBuf.addr(), funcFixed.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
version, setList.addr(), setBuf.addr(), funcFixed.addr(), funcStat.addr(), funcFile.addr(), container, userdata.addr());
vm::var<CellSaveDataCBResult> result;
vm::var<CellSaveDataListGet> listGet;
@ -474,7 +476,7 @@ int cellSaveDataFixedSave2(u32 version, vm::ptr<CellSaveDataSetList> setList, v
if (!dir.IsOpened())
return CELL_SAVEDATA_ERROR_INTERNAL;
std::string dirNamePrefix = Memory.ReadString(setList->dirNamePrefix_addr);
std::string dirNamePrefix = setList->dirNamePrefix.get_ptr();
std::vector<SaveDataEntry> saveEntries;
for (const DirEntryInfo* entry = dir.Read(); entry; entry = dir.Read())
{
@ -493,11 +495,12 @@ int cellSaveDataFixedSave2(u32 version, vm::ptr<CellSaveDataSetList> setList, v
// Sort the entries and fill the listGet->dirList array
std::sort(saveEntries.begin(), saveEntries.end(), sortSaveDataEntry(setList->sortType, setList->sortOrder));
listGet->dirList = vm::bptr<CellSaveDataDirList>::make(setBuf->buf_addr);
listGet->dirList = vm::bptr<CellSaveDataDirList>::make(setBuf->buf.addr());
CellSaveDataDirList* dirList = (CellSaveDataDirList*)Memory.VirtualToRealAddr(listGet->dirList.addr());
for (u32 i = 0; i<saveEntries.size(); i++) {
memcpy(dirList[i].dirName, saveEntries[i].dirName.c_str(), CELL_SAVEDATA_DIRNAME_SIZE);
memcpy(dirList[i].listParam, saveEntries[i].listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
strcpy_trunc(dirList[i].dirName, saveEntries[i].dirName);
strcpy_trunc(dirList[i].listParam, saveEntries[i].listParam);
*dirList[i].reserved = {};
}
funcFixed(result, listGet, fixedSet);
if (result->result < 0) {
@ -507,7 +510,7 @@ int cellSaveDataFixedSave2(u32 version, vm::ptr<CellSaveDataSetList> setList, v
setSaveDataFixed(saveEntries, fixedSet);
getSaveDataStat(saveEntries[0], statGet); // There should be only one element in this list
// TODO: Display the Yes|No dialog here
result->userdata_addr = userdata_addr;
result->userdata = userdata;
funcStat(result, statGet, statSet);
Memory.Free(statGet->fileList.addr());
@ -527,10 +530,10 @@ int cellSaveDataFixedSave2(u32 version, vm::ptr<CellSaveDataSetList> setList, v
int cellSaveDataFixedLoad2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm::ptr<CellSaveDataSetBuf> setBuf,
vm::ptr<CellSaveDataFixedCallback> funcFixed, vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
u32 container, u32 userdata_addr)
u32 container, vm::ptr<void> userdata)
{
cellSysutil->Warning("cellSaveDataFixedLoad2(version=%d, setList_addr=0x%x, setBuf=0x%x, funcList=0x%x, funcStat=0x%x, funcFile=0x%x, container=0x%x, userdata_addr=0x%x)",
version, setList.addr(), setBuf.addr(), funcFixed.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
version, setList.addr(), setBuf.addr(), funcFixed.addr(), funcStat.addr(), funcFile.addr(), container, userdata.addr());
vm::var<CellSaveDataCBResult> result;
vm::var<CellSaveDataListGet> listGet;
@ -543,7 +546,7 @@ int cellSaveDataFixedLoad2(u32 version, vm::ptr<CellSaveDataSetList> setList, v
if (!dir.IsOpened())
return CELL_SAVEDATA_ERROR_INTERNAL;
std::string dirNamePrefix = Memory.ReadString(setList->dirNamePrefix_addr);
std::string dirNamePrefix = setList->dirNamePrefix.get_ptr();
std::vector<SaveDataEntry> saveEntries;
for (const DirEntryInfo* entry = dir.Read(); entry; entry = dir.Read())
{
@ -562,11 +565,12 @@ int cellSaveDataFixedLoad2(u32 version, vm::ptr<CellSaveDataSetList> setList, v
// Sort the entries and fill the listGet->dirList array
std::sort(saveEntries.begin(), saveEntries.end(), sortSaveDataEntry(setList->sortType, setList->sortOrder));
listGet->dirList = vm::bptr<CellSaveDataDirList>::make(setBuf->buf_addr);
listGet->dirList = vm::bptr<CellSaveDataDirList>::make(setBuf->buf.addr());
CellSaveDataDirList* dirList = (CellSaveDataDirList*)Memory.VirtualToRealAddr(listGet->dirList.addr());
for (u32 i = 0; i<saveEntries.size(); i++) {
memcpy(dirList[i].dirName, saveEntries[i].dirName.c_str(), CELL_SAVEDATA_DIRNAME_SIZE);
memcpy(dirList[i].listParam, saveEntries[i].listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
strcpy_trunc(dirList[i].dirName, saveEntries[i].dirName);
strcpy_trunc(dirList[i].listParam, saveEntries[i].listParam);
*dirList[i].reserved = {};
}
funcFixed(result, listGet, fixedSet);
if (result->result < 0) {
@ -576,7 +580,7 @@ int cellSaveDataFixedLoad2(u32 version, vm::ptr<CellSaveDataSetList> setList, v
setSaveDataFixed(saveEntries, fixedSet);
getSaveDataStat(saveEntries[0], statGet); // There should be only one element in this list
// TODO: Display the Yes|No dialog here
result->userdata_addr = userdata_addr;
result->userdata = userdata;
funcStat(result, statGet, statSet);
Memory.Free(statGet->fileList.addr());
@ -594,12 +598,12 @@ int cellSaveDataFixedLoad2(u32 version, vm::ptr<CellSaveDataSetList> setList, v
return ret;
}
int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<CellSaveDataSetBuf> setBuf,
int cellSaveDataAutoSave2(u32 version, vm::ptr<const char> dirName, u32 errDialog, vm::ptr<CellSaveDataSetBuf> setBuf,
vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
u32 container, u32 userdata_addr)
u32 container, vm::ptr<void> userdata)
{
cellSysutil->Warning("cellSaveDataAutoSave2(version=%d, dirName_addr=0x%x, errDialog=%d, setBuf=0x%x, funcList=0x%x, funcStat=0x%x, funcFile=0x%x, container=0x%x, userdata_addr=0x%x)",
version, dirName_addr, errDialog, setBuf.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
version, dirName.addr(), errDialog, setBuf.addr(), funcStat.addr(), funcFile.addr(), container, userdata.addr());
vm::var<CellSaveDataCBResult> result;
vm::var<CellSaveDataStatGet> statGet;
@ -610,26 +614,26 @@ int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<
if (!dir.IsOpened())
return CELL_SAVEDATA_ERROR_INTERNAL;
std::string dirName = Memory.ReadString(dirName_addr);
std::string dirN = dirName.get_ptr();
std::vector<SaveDataEntry> saveEntries;
for (const DirEntryInfo* entry = dir.Read(); entry; entry = dir.Read())
{
if (entry->flags & DirEntry_TypeDir && entry->name == dirName) {
addSaveDataEntry(saveEntries, saveBaseDir+dirName);
if (entry->flags & DirEntry_TypeDir && entry->name == dirN) {
addSaveDataEntry(saveEntries, saveBaseDir + dirN);
}
}
// The target entry does not exist
if (saveEntries.size() == 0) {
SaveDataEntry entry;
entry.dirName = dirName;
entry.dirName = dirN;
entry.sizeKB = 0;
entry.isNew = true;
saveEntries.push_back(entry);
}
getSaveDataStat(saveEntries[0], statGet); // There should be only one element in this list
result->userdata_addr = userdata_addr;
result->userdata = userdata;
funcStat(result, statGet, statSet);
Memory.Free(statGet->fileList.addr());
@ -647,12 +651,12 @@ int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<
return CELL_SAVEDATA_RET_OK;
}
int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<CellSaveDataSetBuf> setBuf,
int cellSaveDataAutoLoad2(u32 version, vm::ptr<const char> dirName, u32 errDialog, vm::ptr<CellSaveDataSetBuf> setBuf,
vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
u32 container, u32 userdata_addr)
u32 container, vm::ptr<void> userdata)
{
cellSysutil->Warning("cellSaveDataAutoLoad2(version=%d, dirName_addr=0x%x, errDialog=%d, setBuf=0x%x, funcList=0x%x, funcStat=0x%x, funcFile=0x%x, container=0x%x, userdata_addr=0x%x)",
version, dirName_addr, errDialog, setBuf.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
version, dirName.addr(), errDialog, setBuf.addr(), funcStat.addr(), funcFile.addr(), container, userdata.addr());
vm::var<CellSaveDataCBResult> result;
vm::var<CellSaveDataStatGet> statGet;
@ -663,23 +667,23 @@ int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<
if (!dir.IsOpened())
return CELL_SAVEDATA_ERROR_INTERNAL;
std::string dirName = Memory.ReadString(dirName_addr);
std::string dirN = dirName.get_ptr();
std::vector<SaveDataEntry> saveEntries;
for (const DirEntryInfo* entry = dir.Read(); entry; entry = dir.Read())
{
if (entry->flags & DirEntry_TypeDir && entry->name == dirName) {
addSaveDataEntry(saveEntries, saveBaseDir+dirName);
if (entry->flags & DirEntry_TypeDir && entry->name == dirN) {
addSaveDataEntry(saveEntries, saveBaseDir + dirN);
}
}
// The target entry does not exist
if (saveEntries.size() == 0) {
cellSysutil->Warning("cellSaveDataAutoLoad2: Couldn't find save entry (%s)", dirName.c_str());
cellSysutil->Warning("cellSaveDataAutoLoad2: Couldn't find save entry (%s)", dirN.c_str());
return CELL_OK; // TODO: Can anyone check the actual behaviour of a PS3 when saves are not found?
}
getSaveDataStat(saveEntries[0], statGet); // There should be only one element in this list
result->userdata_addr = userdata_addr;
result->userdata = userdata;
funcStat(result, statGet, statSet);
Memory.Free(statGet->fileList.addr());
@ -698,10 +702,10 @@ int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<
}
int cellSaveDataListAutoSave(u32 version, u32 errDialog, vm::ptr<CellSaveDataSetList> setList, vm::ptr<CellSaveDataSetBuf> setBuf, vm::ptr<CellSaveDataFixedCallback> funcFixed,
vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile, u32 container, u32 userdata_addr)
vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile, u32 container, vm::ptr<void> userdata)
{
cellSysutil->Warning("cellSaveDataListAutoSave(version=%d, errDialog=%d, setBuf=0x%x, funcFixed=0x%x, funcStat=0x%x, funcFile=0x%x, container=0x%x, userdata_addr=0x%x)",
version, errDialog, setList.addr(), setBuf.addr(), funcFixed.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
version, errDialog, setList.addr(), setBuf.addr(), funcFixed.addr(), funcStat.addr(), funcFile.addr(), container, userdata.addr());
vm::var<CellSaveDataCBResult> result;
vm::var<CellSaveDataListGet> listGet;
@ -715,7 +719,7 @@ int cellSaveDataListAutoSave(u32 version, u32 errDialog, vm::ptr<CellSaveDataSet
if (!dir.IsOpened())
return CELL_SAVEDATA_ERROR_INTERNAL;
std::string dirNamePrefix = Memory.ReadString(setList->dirNamePrefix_addr);
std::string dirNamePrefix = setList->dirNamePrefix.get_ptr();
std::vector<SaveDataEntry> saveEntries;
for (const DirEntryInfo* entry = dir.Read(); entry; entry = dir.Read())
@ -735,12 +739,13 @@ int cellSaveDataListAutoSave(u32 version, u32 errDialog, vm::ptr<CellSaveDataSet
// Sort the entries and fill the listGet->dirList array
std::sort(saveEntries.begin(), saveEntries.end(), sortSaveDataEntry(setList->sortType, setList->sortOrder));
listGet->dirList = vm::bptr<CellSaveDataDirList>::make(setBuf->buf_addr);
listGet->dirList = vm::bptr<CellSaveDataDirList>::make(setBuf->buf.addr());
CellSaveDataDirList* dirList = (CellSaveDataDirList*)Memory.VirtualToRealAddr(listGet->dirList.addr());
for (u32 i = 0; i<saveEntries.size(); i++) {
memcpy(dirList[i].dirName, saveEntries[i].dirName.c_str(), CELL_SAVEDATA_DIRNAME_SIZE);
memcpy(dirList[i].listParam, saveEntries[i].listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
strcpy_trunc(dirList[i].dirName, saveEntries[i].dirName.c_str());
strcpy_trunc(dirList[i].listParam, saveEntries[i].listParam.c_str());
*dirList[i].reserved = {};
}
throw fmt::Format("%s(): implementation broken", __FUNCTION__);
@ -783,10 +788,10 @@ int cellSaveDataListAutoSave(u32 version, u32 errDialog, vm::ptr<CellSaveDataSet
}
int cellSaveDataListAutoLoad(u32 version, u32 errDialog, vm::ptr<CellSaveDataSetList> setList, vm::ptr<CellSaveDataSetBuf> setBuf, vm::ptr<CellSaveDataFixedCallback> funcFixed,
vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile, u32 container, u32 userdata_addr)
vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile, u32 container, vm::ptr<void> userdata)
{
cellSysutil->Warning("cellSaveDataListAutoLoad(version=%d, errDialog=%d, setBuf=0x%x, funcFixed=0x%x, funcStat=0x%x, funcFile=0x%x, container=0x%x, userdata_addr=0x%x)",
version, errDialog, setList.addr(), setBuf.addr(), funcFixed.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
version, errDialog, setList.addr(), setBuf.addr(), funcFixed.addr(), funcStat.addr(), funcFile.addr(), container, userdata.addr());
vm::var<CellSaveDataCBResult> result;
vm::var<CellSaveDataListGet> listGet;
@ -800,7 +805,7 @@ int cellSaveDataListAutoLoad(u32 version, u32 errDialog, vm::ptr<CellSaveDataSet
if (!dir.IsOpened())
return CELL_SAVEDATA_ERROR_INTERNAL;
std::string dirNamePrefix = Memory.ReadString(setList->dirNamePrefix_addr);
std::string dirNamePrefix = setList->dirNamePrefix.get_ptr();
std::vector<SaveDataEntry> saveEntries;
for (const DirEntryInfo* entry = dir.Read(); entry; entry = dir.Read())
@ -820,12 +825,13 @@ int cellSaveDataListAutoLoad(u32 version, u32 errDialog, vm::ptr<CellSaveDataSet
// Sort the entries and fill the listGet->dirList array
std::sort(saveEntries.begin(), saveEntries.end(), sortSaveDataEntry(setList->sortType, setList->sortOrder));
listGet->dirList = vm::bptr<CellSaveDataDirList>::make(setBuf->buf_addr);
listGet->dirList = vm::bptr<CellSaveDataDirList>::make(setBuf->buf.addr());
CellSaveDataDirList* dirList = (CellSaveDataDirList*)Memory.VirtualToRealAddr(listGet->dirList.addr());
for (u32 i = 0; i<saveEntries.size(); i++) {
memcpy(dirList[i].dirName, saveEntries[i].dirName.c_str(), CELL_SAVEDATA_DIRNAME_SIZE);
memcpy(dirList[i].listParam, saveEntries[i].listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
strcpy_trunc(dirList[i].dirName, saveEntries[i].dirName);
strcpy_trunc(dirList[i].listParam, saveEntries[i].listParam);
*dirList[i].reserved = {};
}
throw fmt::Format("%s(): implementation broken", __FUNCTION__);

81
rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.h → rpcs3/Emu/SysCalls/Modules/cellSaveData.h
View file

@ -93,7 +93,8 @@ struct CellSaveDataSetList
{
be_t<u32> sortType;
be_t<u32> sortOrder;
be_t<u32> dirNamePrefix_addr; // char*
vm::bptr<char> dirNamePrefix;
vm::bptr<void> reserved;
};
struct CellSaveDataSetBuf
@ -102,27 +103,30 @@ struct CellSaveDataSetBuf
be_t<u32> fileListMax;
be_t<u32> reserved[6];
be_t<u32> bufSize;
be_t<u32> buf_addr; // void*
vm::bptr<void> buf;
};
struct CellSaveDataNewDataIcon
{
be_t<u32> title_addr; // char*
vm::bptr<char> title;
be_t<u32> iconBufSize;
be_t<u32> iconBuf_addr; // void*
vm::bptr<void> iconBuf;
vm::bptr<void> reserved;
};
struct CellSaveDataListNewData
{
be_t<u32> iconPosition;
be_t<u32> dirName_addr; // char*
vm::bptr<char> dirName;
vm::bptr<CellSaveDataNewDataIcon> icon;
vm::bptr<void> reserved;
};
struct CellSaveDataDirList
{
s8 dirName[CELL_SAVEDATA_DIRNAME_SIZE];
s8 listParam[CELL_SAVEDATA_SYSP_LPARAM_SIZE];
char dirName[CELL_SAVEDATA_DIRNAME_SIZE];
char listParam[CELL_SAVEDATA_SYSP_LPARAM_SIZE];
char reserved[8];
};
struct CellSaveDataListGet
@ -130,34 +134,35 @@ struct CellSaveDataListGet
be_t<u32> dirNum;
be_t<u32> dirListNum;
vm::bptr<CellSaveDataDirList> dirList;
char reserved[64];
};
struct CellSaveDataListSet
{
be_t<u32> focusPosition;
be_t<u32> focusDirName_addr; // char*
vm::bptr<char> focusDirName;
be_t<u32> fixedListNum;
vm::bptr<CellSaveDataDirList> fixedList;
vm::bptr<CellSaveDataListNewData> newData;
be_t<u32> reserved_addr; // void*
vm::bptr<void> reserved;
};
struct CellSaveDataFixedSet
{
be_t<u32> dirName_addr; // char*
vm::bptr<char> dirName;
vm::bptr<CellSaveDataNewDataIcon> newIcon;
be_t<u32> option;
};
struct CellSaveDataSystemFileParam
{
s8 title[CELL_SAVEDATA_SYSP_TITLE_SIZE];
s8 subTitle[CELL_SAVEDATA_SYSP_SUBTITLE_SIZE];
s8 detail[CELL_SAVEDATA_SYSP_DETAIL_SIZE];
char title[CELL_SAVEDATA_SYSP_TITLE_SIZE];
char subTitle[CELL_SAVEDATA_SYSP_SUBTITLE_SIZE];
char detail[CELL_SAVEDATA_SYSP_DETAIL_SIZE];
be_t<u32> attribute;
s8 reserved2[4];
s8 listParam[CELL_SAVEDATA_SYSP_LPARAM_SIZE];
s8 reserved[256];
char reserved2[4];
char listParam[CELL_SAVEDATA_SYSP_LPARAM_SIZE];
char reserved[256];
};
struct CellSaveDataDirStat
@ -165,7 +170,7 @@ struct CellSaveDataDirStat
be_t<s64> st_atime_;
be_t<s64> st_mtime_;
be_t<s64> st_ctime_;
s8 dirName[CELL_SAVEDATA_DIRNAME_SIZE];
char dirName[CELL_SAVEDATA_DIRNAME_SIZE];
};
struct CellSaveDataFileStat
@ -176,7 +181,7 @@ struct CellSaveDataFileStat
be_t<s64> st_atime_;
be_t<s64> st_mtime_;
be_t<s64> st_ctime_;
u8 fileName[CELL_SAVEDATA_FILENAME_SIZE];
char fileName[CELL_SAVEDATA_FILENAME_SIZE];
u8 reserved2[3];
};
@ -192,15 +197,17 @@ struct CellSaveDataStatGet
be_t<u32> fileNum;
be_t<u32> fileListNum;
vm::bptr<CellSaveDataFileStat> fileList;
char reserved[64];
};
struct CellSaveDataAutoIndicator
{
be_t<u32> dispPosition;
be_t<u32> dispMode;
be_t<u32> dispMsg_addr; // char*
vm::bptr<char> dispMsg;
be_t<u32> picBufSize;
be_t<u32> picBuf_addr; // void*
vm::bptr<void> picBuf;
vm::bptr<void> reserved;
};
struct CellSaveDataStatSet
@ -213,19 +220,20 @@ struct CellSaveDataStatSet
struct CellSaveDataFileGet
{
be_t<u32> excSize;
char reserved[64];
};
struct CellSaveDataFileSet
{
be_t<u32> fileOperation;
be_t<u32> reserved_addr; // void*
vm::bptr<void> reserved;
be_t<u32> fileType;
u8 secureFileId[CELL_SAVEDATA_SECUREFILEID_SIZE];
be_t<u32> fileName_addr; // char*
vm::bptr<char> fileName;
be_t<u32> fileOffset;
be_t<u32> fileSize;
be_t<u32> fileBufSize;
be_t<u32> fileBuf_addr; // void*
vm::bptr<void> fileBuf;
};
struct CellSaveDataCBResult
@ -233,16 +241,17 @@ struct CellSaveDataCBResult
be_t<s32> result;
be_t<u32> progressBarInc;
be_t<s32> errNeedSizeKB;
be_t<u32> invalidMsg_addr; // char*
be_t<u32> userdata_addr; // void*
vm::bptr<char> invalidMsg;
vm::bptr<void> userdata;
};
struct CellSaveDataDoneGet
{
be_t<s32> excResult;
s8 dirName[CELL_SAVEDATA_DIRNAME_SIZE];
char dirName[CELL_SAVEDATA_DIRNAME_SIZE];
be_t<s32> sizeKB;
be_t<s32> hddFreeSizeKB;
char reserved[64];
};
@ -275,30 +284,30 @@ struct SaveDataEntry
// Function declarations
int cellSaveDataListSave2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm::ptr<CellSaveDataSetBuf> setBuf,
vm::ptr<CellSaveDataListCallback> funcList, vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
u32 container, u32 userdata_addr);
u32 container, vm::ptr<void> userdata);
int cellSaveDataListLoad2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm::ptr<CellSaveDataSetBuf> setBuf,
vm::ptr<CellSaveDataListCallback> funcList, vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
u32 container, u32 userdata_addr);
u32 container, vm::ptr<void> userdata);
int cellSaveDataFixedSave2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm::ptr<CellSaveDataSetBuf> setBuf,
vm::ptr<CellSaveDataFixedCallback> funcFixed, vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
u32 container, u32 userdata_addr);
u32 container, vm::ptr<void> userdata);
int cellSaveDataFixedLoad2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm::ptr<CellSaveDataSetBuf> setBuf,
vm::ptr<CellSaveDataFixedCallback> funcFixed, vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
u32 container, u32 userdata_addr);
u32 container, vm::ptr<void> userdata);
int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<CellSaveDataSetBuf> setBuf,
int cellSaveDataAutoSave2(u32 version, vm::ptr<const char> dirName, u32 errDialog, vm::ptr<CellSaveDataSetBuf> setBuf,
vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
u32 container, u32 userdata_addr);
u32 container, vm::ptr<void> userdata);
int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<CellSaveDataSetBuf> setBuf,
int cellSaveDataAutoLoad2(u32 version, vm::ptr<const char> dirName, u32 errDialog, vm::ptr<CellSaveDataSetBuf> setBuf,
vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
u32 container, u32 userdata_addr);
u32 container, vm::ptr<void> userdata);
int cellSaveDataListAutoSave(u32 version, u32 errDialog, vm::ptr<CellSaveDataSetList> setList, vm::ptr<CellSaveDataSetBuf> setBuf, vm::ptr<CellSaveDataFixedCallback> funcFixed,
vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile, u32 container, u32 userdata_addr);
vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile, u32 container, vm::ptr<void> userdata);
int cellSaveDataListAutoLoad(u32 version, u32 errDialog, vm::ptr<CellSaveDataSetList> setList, vm::ptr<CellSaveDataSetBuf> setBuf, vm::ptr<CellSaveDataFixedCallback> funcFixed,
vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile, u32 container, u32 userdata_addr);
vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile, u32 container, vm::ptr<void> userdata);

28
rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp
View file

@ -15,7 +15,7 @@
#include "cellMsgDialog.h"
#include "cellGame.h"
#include "cellSysutil.h"
#include "cellSysutil_SaveData.h"
#include "cellSaveData.h"
typedef void (*CellHddGameStatCallback)(vm::ptr<CellHddGameCBResult> cbResult, vm::ptr<CellHddGameStatGet> get, vm::ptr<CellHddGameStatSet> set);
@ -652,13 +652,13 @@ int cellSysCacheMount(vm::ptr<CellSysCacheParam> param)
return CELL_SYSCACHE_RET_OK_RELAYED;
}
int cellHddGameCheck(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<CellHddGameStatCallback> funcStat, u32 container)
int cellHddGameCheck(u32 version, vm::ptr<const char> dirName, u32 errDialog, vm::ptr<CellHddGameStatCallback> funcStat, u32 container)
{
cellSysutil->Warning("cellHddGameCheck(version=%d, dirName_addr=0x%xx, errDialog=%d, funcStat_addr=0x%x, container=%d)",
version, dirName_addr, errDialog, funcStat.addr(), container);
cellSysutil->Warning("cellHddGameCheck(version=%d, dirName_addr=0x%x, errDialog=%d, funcStat_addr=0x%x, container=%d)",
version, dirName.addr(), errDialog, funcStat.addr(), container);
std::string dirName = Memory.ReadString(dirName_addr);
if (dirName.size() != 9)
std::string dir = dirName.get_ptr();
if (dir.size() != 9)
return CELL_HDDGAME_ERROR_PARAM;
vm::var<CellHddGameSystemFileParam> param;
@ -673,10 +673,10 @@ int cellHddGameCheck(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<CellH
get->st_ctime__ = 0; // TODO
get->st_mtime__ = 0; // TODO
get->sizeKB = CELL_HDDGAME_SIZEKB_NOTCALC;
memcpy(get->contentInfoPath, ("/dev_hdd0/game/"+dirName).c_str(), CELL_HDDGAME_PATH_MAX);
memcpy(get->hddGamePath, ("/dev_hdd0/game/"+dirName+"/USRDIR").c_str(), CELL_HDDGAME_PATH_MAX);
memcpy(get->contentInfoPath, ("/dev_hdd0/game/" + dir).c_str(), CELL_HDDGAME_PATH_MAX);
memcpy(get->hddGamePath, ("/dev_hdd0/game/" + dir + "/USRDIR").c_str(), CELL_HDDGAME_PATH_MAX);
if (!Emu.GetVFS().ExistsDir(("/dev_hdd0/game/"+dirName).c_str()))
if (!Emu.GetVFS().ExistsDir(("/dev_hdd0/game/" + dir).c_str()))
{
get->isNewData = CELL_HDDGAME_ISNEWDATA_NODIR;
}
@ -684,7 +684,7 @@ int cellHddGameCheck(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<CellH
{
// TODO: Is cellHddGameCheck really responsible for writing the information in get->getParam ? (If not, delete this else)
vfsFile f(("/dev_hdd0/game/"+dirName+"/PARAM.SFO").c_str());
vfsFile f(("/dev_hdd0/game/" + dir + "/PARAM.SFO").c_str());
PSFLoader psf(f);
if (!psf.Load(false)) {
return CELL_HDDGAME_ERROR_BROKEN;
@ -695,16 +695,16 @@ int cellHddGameCheck(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<CellH
get->getParam.resolution = psf.GetInteger("RESOLUTION");
get->getParam.soundFormat = psf.GetInteger("SOUND_FORMAT");
std::string title = psf.GetString("TITLE");
memcpy(get->getParam.title, title.c_str(), std::min<size_t>(CELL_HDDGAME_SYSP_TITLE_SIZE,title.length()+1));
strcpy_trunc(get->getParam.title, title);
std::string app_ver = psf.GetString("APP_VER");
memcpy(get->getParam.dataVersion, app_ver.c_str(), std::min<size_t>(CELL_HDDGAME_SYSP_VERSION_SIZE,app_ver.length()+1));
memcpy(get->getParam.titleId, dirName.c_str(), std::min<size_t>(CELL_HDDGAME_SYSP_TITLEID_SIZE,dirName.length()+1));
strcpy_trunc(get->getParam.dataVersion, app_ver);
strcpy_trunc(get->getParam.titleId, dir);
for (u32 i=0; i<CELL_HDDGAME_SYSP_LANGUAGE_NUM; i++) {
char key [16];
sprintf(key, "TITLE_%02d", i);
title = psf.GetString(key);
memcpy(get->getParam.titleLang[i], title.c_str(), std::min<size_t>(CELL_HDDGAME_SYSP_TITLE_SIZE, title.length() + 1));
strcpy_trunc(get->getParam.titleLang[i], title);
}
}

8
rpcs3/Emu/SysCalls/Modules/cellSysutil.h
View file

@ -171,11 +171,11 @@ enum
struct CellHddGameSystemFileParam
{
u8 title[CELL_HDDGAME_SYSP_TITLE_SIZE];
u8 titleLang[CELL_HDDGAME_SYSP_LANGUAGE_NUM][CELL_HDDGAME_SYSP_TITLE_SIZE];
u8 titleId[CELL_HDDGAME_SYSP_TITLEID_SIZE];
char title[CELL_HDDGAME_SYSP_TITLE_SIZE];
char titleLang[CELL_HDDGAME_SYSP_LANGUAGE_NUM][CELL_HDDGAME_SYSP_TITLE_SIZE];
char titleId[CELL_HDDGAME_SYSP_TITLEID_SIZE];
u8 reserved0[2];
u8 dataVersion[CELL_HDDGAME_SYSP_VERSION_SIZE];
char dataVersion[CELL_HDDGAME_SYSP_VERSION_SIZE];
u8 reserved1[2];
be_t<u32> attribute;
be_t<u32> parentalLevel;

105
rpcs3/Emu/SysCalls/Modules/sceNp.cpp
View file

@ -25,14 +25,11 @@ int sceNpTerm()
return CELL_OK;
}
int sceNpDrmIsAvailable(u32 k_licensee_addr, u32 drm_path_addr)
int npDrmIsAvailable(u32 k_licensee_addr, vm::ptr<const char> drm_path)
{
sceNp->Warning("sceNpDrmIsAvailable(k_licensee_addr=0x%x, drm_path_addr=0x%x)", k_licensee_addr, drm_path_addr);
std::string drm_path = Memory.ReadString(drm_path_addr);
if (!Emu.GetVFS().ExistsFile(drm_path))
if (!Emu.GetVFS().ExistsFile(drm_path.get_ptr()))
{
sceNp->Warning("sceNpDrmIsAvailable(): '%s' not found", drm_path.c_str());
sceNp->Warning("npDrmIsAvailable(): '%s' not found", drm_path.get_ptr());
return CELL_ENOENT;
}
@ -48,94 +45,24 @@ int sceNpDrmIsAvailable(u32 k_licensee_addr, u32 drm_path_addr)
}
}
sceNp->Warning("sceNpDrmIsAvailable: Found DRM license file at %s", drm_path.c_str());
sceNp->Warning("sceNpDrmIsAvailable: Using k_licensee 0x%s", k_licensee_str.c_str());
sceNp->Warning("npDrmIsAvailable: Found DRM license file at %s", drm_path.get_ptr());
sceNp->Warning("npDrmIsAvailable: Using k_licensee 0x%s", k_licensee_str.c_str());
// Set the necessary file paths.
std::string drm_file_name = fmt::AfterLast(drm_path,'/');
std::string drm_file_name = fmt::AfterLast(drm_path.get_ptr(), '/');
// TODO: Make more explicit what this actually does (currently it copies "XXXXXXXX" from drm_path (== "/dev_hdd0/game/XXXXXXXXX/*" assumed)
std::string titleID = drm_path.substr(15, 9);
std::string titleID(&drm_path[15], 9);
// TODO: These shouldn't use current dir
std::string enc_drm_path = drm_path;
std::string dec_drm_path = "/dev_hdd1/" + titleID + "/" + drm_file_name;
std::string rap_path = "/dev_usb000/";
// Search dev_usb000 for a compatible RAP file.
vfsDir *raps_dir = new vfsDir(rap_path);
if (!raps_dir->IsOpened())
sceNp->Warning("sceNpDrmIsAvailable: Can't find RAP file for DRM!");
else
{
const std::vector<DirEntryInfo> &entries = raps_dir->GetEntries();
for (auto &entry: entries)
{
if (entry.name.find(titleID) != std::string::npos )
{
rap_path += entry.name;
break;
}
}
}
// Create a new directory under dev_hdd1/titleID to hold the decrypted data.
// TODO: These shouldn't use current dir
std::string tmp_dir = "./dev_hdd1/" + titleID;
if (!rExists(tmp_dir))
rMkdir("./dev_hdd1/" + titleID);
// Decrypt this EDAT using the supplied k_licensee and matching RAP file.
std::string enc_drm_path_local, dec_drm_path_local, rap_path_local;
Emu.GetVFS().GetDevice(enc_drm_path, enc_drm_path_local);
Emu.GetVFS().GetDevice(dec_drm_path, dec_drm_path_local);
Emu.GetVFS().GetDevice(rap_path, rap_path_local);
DecryptEDAT(enc_drm_path_local, dec_drm_path_local, 8, rap_path_local, k_licensee, false);
return CELL_OK;
}
int sceNpDrmIsAvailable2(u32 k_licensee_addr, u32 drm_path_addr)
{
sceNp->Warning("sceNpDrmIsAvailable2(k_licensee_addr=0x%x, drm_path_addr=0x%x)", k_licensee_addr, drm_path_addr);
std::string drm_path = Memory.ReadString(drm_path_addr);
if (!Emu.GetVFS().ExistsFile(drm_path))
{
sceNp->Warning("sceNpDrmIsAvailable2(): '%s' not found", drm_path.c_str());
return CELL_ENOENT;
}
std::string k_licensee_str = "0";
u8 k_licensee[0x10];
if (k_licensee_addr)
{
for (int i = 0; i < 0x10; i++)
{
k_licensee[i] = Memory.Read8(k_licensee_addr + i);
k_licensee_str += fmt::Format("%02x", k_licensee[i]);
}
}
sceNp->Warning("sceNpDrmIsAvailable2: Found DRM license file at %s", drm_path.c_str());
sceNp->Warning("sceNpDrmIsAvailable2: Using k_licensee 0x%s", k_licensee_str.c_str());
// Set the necessary file paths.
std::string drm_file_name = fmt::AfterLast(drm_path, '/');
// TODO: Make more explicit what this actually does (currently it copies "XXXXXXXX" from drm_path (== "/dev_hdd0/game/XXXXXXXXX/*" assumed)
std::string titleID = drm_path.substr(15, 9);
// TODO: These shouldn't use current dir
std::string enc_drm_path = drm_path;
std::string enc_drm_path = drm_path.get_ptr();
std::string dec_drm_path = "/dev_hdd1/" + titleID + "/" + drm_file_name;
std::string rap_path = "/dev_usb000/";
// Search dev_usb000 for a compatible RAP file.
vfsDir *raps_dir = new vfsDir(rap_path);
if (!raps_dir->IsOpened())
sceNp->Warning("sceNpDrmIsAvailable2: Can't find RAP file for DRM!");
sceNp->Warning("npDrmIsAvailable: Can't find RAP file for DRM!");
else
{
const std::vector<DirEntryInfo> &entries = raps_dir->GetEntries();
@ -165,6 +92,20 @@ int sceNpDrmIsAvailable2(u32 k_licensee_addr, u32 drm_path_addr)
return CELL_OK;
}
int sceNpDrmIsAvailable(u32 k_licensee_addr, vm::ptr<const char> drm_path)
{
sceNp->Warning("sceNpDrmIsAvailable(k_licensee_addr=0x%x, drm_path_addr=0x%x('%s'))", k_licensee_addr, drm_path.addr(), drm_path.get_ptr());
return npDrmIsAvailable(k_licensee_addr, drm_path);
}
int sceNpDrmIsAvailable2(u32 k_licensee_addr, vm::ptr<const char> drm_path)
{
sceNp->Warning("sceNpDrmIsAvailable2(k_licensee_addr=0x%x, drm_path_addr=0x%x('%s'))", k_licensee_addr, drm_path.addr(), drm_path.get_ptr());
return npDrmIsAvailable(k_licensee_addr, drm_path);
}
int sceNpDrmVerifyUpgradeLicense(u32 content_id_addr)
{
UNIMPLEMENTED_FUNC(sceNp);

11
rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp
View file

@ -117,16 +117,15 @@ int sys_spu_image_close(vm::ptr<sys_spu_image> img)
return CELL_OK;
}
int sys_raw_spu_load(int id, u32 path_addr, vm::ptr<be_t<u32>> entry)
int sys_raw_spu_load(s32 id, vm::ptr<const char> path, vm::ptr<be_t<u32>> entry)
{
const std::string path = Memory.ReadString(path_addr);
sysPrxForUser->Warning("sys_raw_spu_load(id=0x%x, path=0x%x [%s], entry_addr=0x%x)",
id, path_addr, path.c_str(), entry.addr());
sysPrxForUser->Warning("sys_raw_spu_load(id=0x%x, path_addr=0x%x('%s'), entry_addr=0x%x)",
id, path.addr(), path.get_ptr(), entry.addr());
vfsFile f(path);
vfsFile f(path.get_ptr());
if(!f.IsOpened())
{
sysPrxForUser->Error("sys_raw_spu_load error: '%s' not found!", path.c_str());
sysPrxForUser->Error("sys_raw_spu_load error: '%s' not found!", path.get_ptr());
return CELL_ENOENT;
}

7
rpcs3/Emu/SysCalls/Modules/sys_fs.cpp
View file

@ -110,11 +110,10 @@ int sdata_unpack(const std::string& packed_file, const std::string& unpacked_fil
}
int cellFsSdataOpen(u32 path_addr, int flags, vm::ptr<be_t<u32>> fd, vm::ptr<be_t<u32>> arg, u64 size)
int cellFsSdataOpen(vm::ptr<const char> path, int flags, vm::ptr<be_t<u32>> fd, vm::ptr<be_t<u32>> arg, u64 size)
{
const std::string& path = Memory.ReadString(path_addr);
sys_fs->Warning("cellFsSdataOpen(path=\"%s\", flags=0x%x, fd_addr=0x%x, arg_addr=0x%x, size=0x%llx) -> cellFsOpen()",
path.c_str(), flags, fd.addr(), arg.addr(), size);
path.get_ptr(), flags, fd.addr(), arg.addr(), size);
/*if (flags != CELL_O_RDONLY)
return CELL_EINVAL;
@ -133,7 +132,7 @@ int cellFsSdataOpen(u32 path_addr, int flags, vm::ptr<be_t<u32>> fd, vm::ptr<be_
return CELL_OK;*/
return cellFsOpen(path_addr, flags, fd, arg, size);
return cellFsOpen(path, flags, fd, arg, size);
}
int cellFsSdataOpenByFd(int mself_fd, int flags, vm::ptr<be_t<u32>> sdata_fd, u64 offset, vm::ptr<be_t<u32>> arg, u64 size)

133
rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp
View file

@ -30,20 +30,18 @@ struct FsRingBufferConfig
} fs_config;
s32 cellFsOpen(u32 path_addr, s32 flags, vm::ptr<be_t<u32>> fd, vm::ptr<be_t<u32>> arg, u64 size)
s32 cellFsOpen(vm::ptr<const char> path, s32 flags, vm::ptr<be_t<u32>> fd, vm::ptr<be_t<u32>> arg, u64 size)
{
const std::string& path = Memory.ReadString(path_addr);
sys_fs->Log("cellFsOpen(path=\"%s\", flags=0x%x, fd_addr=0x%x, arg_addr=0x%x, size=0x%llx)",
path.c_str(), flags, fd.addr(), arg.addr(), size);
path.get_ptr(), flags, fd.addr(), arg.addr(), size);
const std::string& ppath = path;
//ConLog.Warning("path: %s [%s]", ppath.c_str(), path.c_str());
const std::string _path = path.get_ptr();
s32 _oflags = flags;
if(flags & CELL_O_CREAT)
{
_oflags &= ~CELL_O_CREAT;
Emu.GetVFS().CreateFile(ppath);
Emu.GetVFS().CreateFile(_path);
}
vfsOpenMode o_mode;
@ -81,7 +79,7 @@ s32 cellFsOpen(u32 path_addr, s32 flags, vm::ptr<be_t<u32>> fd, vm::ptr<be_t<u32
{
_oflags &= ~CELL_O_TRUNC;
//truncate file before opening it as read/write
auto filePtr = Emu.GetVFS().OpenFile(ppath, vfsWrite);
auto filePtr = Emu.GetVFS().OpenFile(_path, vfsWrite);
delete filePtr;
}
o_mode = vfsReadWrite;
@ -90,28 +88,28 @@ s32 cellFsOpen(u32 path_addr, s32 flags, vm::ptr<be_t<u32>> fd, vm::ptr<be_t<u32
if(_oflags != 0)
{
sys_fs->Error("\"%s\" has unknown flags! flags: 0x%08x", ppath.c_str(), flags);
sys_fs->Error("\"%s\" has unknown flags! flags: 0x%08x", path.get_ptr(), flags);
return CELL_EINVAL;
}
if (!Emu.GetVFS().ExistsFile(ppath))
if (!Emu.GetVFS().ExistsFile(_path))
{
sys_fs->Error("\"%s\" not found! flags: 0x%08x", ppath.c_str(), flags);
sys_fs->Error("\"%s\" not found! flags: 0x%08x", path.get_ptr(), flags);
return CELL_ENOENT;
}
vfsFileBase* stream = Emu.GetVFS().OpenFile(ppath, o_mode);
vfsFileBase* stream = Emu.GetVFS().OpenFile(_path, o_mode);
if(!stream || !stream->IsOpened())
{
delete stream;
sys_fs->Error("\"%s\" not found! flags: 0x%08x", ppath.c_str(), flags);
sys_fs->Error("\"%s\" not found! flags: 0x%08x", path.get_ptr(), flags);
return CELL_ENOENT;
}
u32 id = sys_fs->GetNewId(stream, TYPE_FS_FILE);
*fd = id;
sys_fs->Notice("\"%s\" opened: fd = %d", path.c_str(), id);
sys_fs->Notice("\"%s\" opened: fd = %d", path.get_ptr(), id);
return CELL_OK;
}
@ -162,12 +160,11 @@ s32 cellFsClose(u32 fd)
return CELL_OK;
}
s32 cellFsOpendir(u32 path_addr, vm::ptr<be_t<u32>> fd)
s32 cellFsOpendir(vm::ptr<const char> path, vm::ptr<be_t<u32>> fd)
{
const std::string& path = Memory.ReadString(path_addr);
sys_fs->Warning("cellFsOpendir(path=\"%s\", fd_addr=0x%x)", path.c_str(), fd.addr());
sys_fs->Warning("cellFsOpendir(path=\"%s\", fd_addr=0x%x)", path.get_ptr(), fd.addr());
vfsDirBase* dir = Emu.GetVFS().OpenDir(path);
vfsDirBase* dir = Emu.GetVFS().OpenDir(path.get_ptr());
if(!dir || !dir->IsOpened())
{
delete dir;
@ -212,10 +209,11 @@ s32 cellFsClosedir(u32 fd)
return CELL_OK;
}
s32 cellFsStat(const u32 path_addr, vm::ptr<CellFsStat> sb)
s32 cellFsStat(vm::ptr<const char> path, vm::ptr<CellFsStat> sb)
{
const std::string& path = Memory.ReadString(path_addr);
sys_fs->Warning("cellFsStat(path=\"%s\", sb_addr: 0x%x)", path.c_str(), sb.addr());
sys_fs->Warning("cellFsStat(path=\"%s\", sb_addr: 0x%x)", path.get_ptr(), sb.addr());
const std::string _path = path.get_ptr();
sb->st_mode =
CELL_FS_S_IRUSR | CELL_FS_S_IWUSR | CELL_FS_S_IXUSR |
@ -230,7 +228,7 @@ s32 cellFsStat(const u32 path_addr, vm::ptr<CellFsStat> sb)
sb->st_blksize = 4096;
{
vfsDir dir(path);
vfsDir dir(_path);
if(dir.IsOpened())
{
sb->st_mode |= CELL_FS_S_IFDIR;
@ -239,7 +237,7 @@ s32 cellFsStat(const u32 path_addr, vm::ptr<CellFsStat> sb)
}
{
vfsFile f(path);
vfsFile f(_path);
if(f.IsOpened())
{
sb->st_mode |= CELL_FS_S_IFREG;
@ -248,7 +246,7 @@ s32 cellFsStat(const u32 path_addr, vm::ptr<CellFsStat> sb)
}
}
sys_fs->Warning("cellFsStat: \"%s\" not found.", path.c_str());
sys_fs->Warning("cellFsStat: \"%s\" not found.", path.get_ptr());
return CELL_ENOENT;
}
@ -279,36 +277,32 @@ s32 cellFsFstat(u32 fd, vm::ptr<CellFsStat> sb)
return CELL_OK;
}
s32 cellFsMkdir(u32 path_addr, u32 mode)
s32 cellFsMkdir(vm::ptr<const char> path, u32 mode)
{
const std::string& ps3_path = Memory.ReadString(path_addr);
sys_fs->Log("cellFsMkdir(path=\"%s\", mode=0x%x)", ps3_path.c_str(), mode);
/*vfsDir dir;
if(dir.IsExists(ps3_path))
return CELL_EEXIST;
if(!dir.Create(ps3_path))
return CELL_EBUSY;*/
sys_fs->Log("cellFsMkdir(path=\"%s\", mode=0x%x)", path.get_ptr(), mode);
if(Emu.GetVFS().ExistsDir(ps3_path))
const std::string _path = path.get_ptr();
if(Emu.GetVFS().ExistsDir(_path))
return CELL_EEXIST;
if(!Emu.GetVFS().CreateDir(ps3_path))
if(!Emu.GetVFS().CreateDir(_path))
return CELL_EBUSY;
return CELL_OK;
}
s32 cellFsRename(u32 from_addr, u32 to_addr)
s32 cellFsRename(vm::ptr<const char> from, vm::ptr<const char> to)
{
const std::string& ps3_from = Memory.ReadString(from_addr);
const std::string& ps3_to = Memory.ReadString(to_addr);
sys_fs->Log("cellFsRename(from='%s' (from_addr=0x%x), to='%s' (to_addr=0x%x))", ps3_from.c_str(), from_addr, ps3_to.c_str(), to_addr);
sys_fs->Log("cellFsRename(from='%s' (from_addr=0x%x), to='%s' (to_addr=0x%x))", from.get_ptr(), from.addr(), to.get_ptr(), to.addr());
std::string _from = from.get_ptr();
std::string _to = to.get_ptr();
{
vfsDir dir;
if(dir.IsExists(ps3_from))
if(dir.IsExists(_from))
{
if(!dir.Rename(ps3_from, ps3_to))
if(!dir.Rename(_from, _to))
return CELL_EBUSY;
return CELL_OK;
@ -317,9 +311,10 @@ s32 cellFsRename(u32 from_addr, u32 to_addr)
{
vfsFile f;
if(f.Exists(ps3_from))
if(f.Exists(_from))
{
if(!f.Rename(ps3_from, ps3_to))
if(!f.Rename(_from, _to))
return CELL_EBUSY;
return CELL_OK;
@ -328,10 +323,9 @@ s32 cellFsRename(u32 from_addr, u32 to_addr)
return CELL_ENOENT;
}
s32 cellFsChmod(u32 path_addr, u32 mode)
s32 cellFsChmod(vm::ptr<const char> path, u32 mode)
{
const std::string& ps3_path = Memory.ReadString(path_addr);
sys_fs->Todo("cellFsChmod(path=\"%s\", mode=0x%x)", ps3_path.c_str(), mode);
sys_fs->Todo("cellFsChmod(path=\"%s\", mode=0x%x)", path.get_ptr(), mode);
// TODO:
@ -347,33 +341,35 @@ s32 cellFsFsync(u32 fd)
return CELL_OK;
}
s32 cellFsRmdir(u32 path_addr)
s32 cellFsRmdir(vm::ptr<const char> path)
{
const std::string& ps3_path = Memory.ReadString(path_addr);
sys_fs->Log("cellFsRmdir(path=\"%s\")", ps3_path.c_str());
sys_fs->Log("cellFsRmdir(path=\"%s\")", path.get_ptr());
std::string _path = path.get_ptr();
vfsDir d;
if(!d.IsExists(ps3_path))
if(!d.IsExists(_path))
return CELL_ENOENT;
if(!d.Remove(ps3_path))
if(!d.Remove(_path))
return CELL_EBUSY;
return CELL_OK;
}
s32 cellFsUnlink(u32 path_addr)
s32 cellFsUnlink(vm::ptr<const char> path)
{
const std::string& ps3_path = Memory.ReadString(path_addr);
sys_fs->Warning("cellFsUnlink(path=\"%s\")", ps3_path.c_str());
sys_fs->Warning("cellFsUnlink(path=\"%s\")", path.get_ptr());
if (Emu.GetVFS().ExistsDir(ps3_path))
std::string _path = path.get_ptr();
if (Emu.GetVFS().ExistsDir(_path))
return CELL_EISDIR;
if (!Emu.GetVFS().ExistsFile(ps3_path))
if (!Emu.GetVFS().ExistsFile(_path))
return CELL_ENOENT;
if (!Emu.GetVFS().RemoveFile(ps3_path))
if (!Emu.GetVFS().RemoveFile(_path))
return CELL_EACCES;
return CELL_OK;
@ -431,15 +427,14 @@ s32 cellFsFtruncate(u32 fd, u64 size)
return CELL_OK;
}
s32 cellFsTruncate(u32 path_addr, u64 size)
s32 cellFsTruncate(vm::ptr<const char> path, u64 size)
{
const std::string& path = Memory.ReadString(path_addr);
sys_fs->Log("cellFsTruncate(path=\"%s\", size=%lld)", path.c_str(), size);
sys_fs->Log("cellFsTruncate(path=\"%s\", size=%lld)", path.get_ptr(), size);
vfsFile f(path, vfsReadWrite);
vfsFile f(path.get_ptr(), vfsReadWrite);
if(!f.IsOpened())
{
sys_fs->Warning("cellFsTruncate: \"%s\" not found.", path.c_str());
sys_fs->Warning("cellFsTruncate: \"%s\" not found.", path.get_ptr());
return CELL_ENOENT;
}
u64 initialSize = f.GetSize();
@ -464,7 +459,7 @@ s32 cellFsTruncate(u32 path_addr, u64 size)
s32 cellFsFGetBlockSize(u32 fd, vm::ptr<be_t<u64>> sector_size, vm::ptr<be_t<u64>> block_size)
{
sys_fs->Log("cellFsFGetBlockSize(fd=%d, sector_size_addr: 0x%x, block_size_addr: 0x%x)",
sys_fs->Log("cellFsFGetBlockSize(fd=%d, sector_size_addr=0x%x, block_size_addr=0x%x)",
fd, sector_size.addr(), block_size.addr());
vfsStream* file;
@ -476,10 +471,10 @@ s32 cellFsFGetBlockSize(u32 fd, vm::ptr<be_t<u64>> sector_size, vm::ptr<be_t<u64
return CELL_OK;
}
s32 cellFsGetBlockSize(u32 path_addr, vm::ptr<be_t<u64>> sector_size, vm::ptr<be_t<u64>> block_size)
s32 cellFsGetBlockSize(vm::ptr<const char> path, vm::ptr<be_t<u64>> sector_size, vm::ptr<be_t<u64>> block_size)
{
sys_fs->Log("cellFsGetBlockSize(file: %s, sector_size_addr: 0x%x, block_size_addr: 0x%x)",
Memory.ReadString(path_addr).c_str(), sector_size.addr(), block_size.addr());
sys_fs->Log("cellFsGetBlockSize(file='%s', sector_size_addr=0x%x, block_size_addr=0x%x)",
path.get_ptr(), sector_size.addr(), block_size.addr());
*sector_size = 4096; // ?
*block_size = 4096; // ?
@ -487,14 +482,10 @@ s32 cellFsGetBlockSize(u32 path_addr, vm::ptr<be_t<u64>> sector_size, vm::ptr<be
return CELL_OK;
}
s32 cellFsGetFreeSize(u32 path_addr, vm::ptr<be_t<u32>> block_size, vm::ptr<be_t<u64>> block_count)
s32 cellFsGetFreeSize(vm::ptr<const char> path, vm::ptr<be_t<u32>> block_size, vm::ptr<be_t<u64>> block_count)
{
const std::string& ps3_path = Memory.ReadString(path_addr);
sys_fs->Warning("cellFsGetFreeSize(path=\"%s\", block_size_addr=0x%x, block_count_addr=0x%x)",
ps3_path.c_str(), block_size.addr(), block_count.addr());
if (ps3_path.empty())
return CELL_EINVAL;
path.get_ptr(), block_size.addr(), block_count.addr());
// TODO: Get real values. Currently, it always returns 40 GB of free space divided in 4 KB blocks
*block_size = 4096; // ?

22
rpcs3/Emu/SysCalls/lv2/lv2Fs.h
View file

@ -124,27 +124,27 @@ struct CellFsRingBuffer
};
// SysCalls
s32 cellFsOpen(u32 path_addr, s32 flags, vm::ptr<be_t<u32>> fd, vm::ptr<be_t<u32>> arg, u64 size);
s32 cellFsOpen(vm::ptr<const char> path, s32 flags, vm::ptr<be_t<u32>> fd, vm::ptr<be_t<u32>> arg, u64 size);
s32 cellFsRead(u32 fd, u32 buf_addr, u64 nbytes, vm::ptr<be_t<u64>> nread);
s32 cellFsWrite(u32 fd, u32 buf_addr, u64 nbytes, vm::ptr<be_t<u64>> nwrite);
s32 cellFsClose(u32 fd);
s32 cellFsOpendir(u32 path_addr, vm::ptr<be_t<u32>> fd);
s32 cellFsOpendir(vm::ptr<const char> path, vm::ptr<be_t<u32>> fd);
s32 cellFsReaddir(u32 fd, vm::ptr<CellFsDirent> dir, vm::ptr<be_t<u64>> nread);
s32 cellFsClosedir(u32 fd);
s32 cellFsStat(u32 path_addr, vm::ptr<CellFsStat> sb);
s32 cellFsStat(vm::ptr<const char> path, vm::ptr<CellFsStat> sb);
s32 cellFsFstat(u32 fd, vm::ptr<CellFsStat> sb);
s32 cellFsMkdir(u32 path_addr, u32 mode);
s32 cellFsRename(u32 from_addr, u32 to_addr);
s32 cellFsChmod(u32 path_addr, u32 mode);
s32 cellFsMkdir(vm::ptr<const char> path, u32 mode);
s32 cellFsRename(vm::ptr<const char> from, vm::ptr<const char> to);
s32 cellFsChmod(vm::ptr<const char> path, u32 mode);
s32 cellFsFsync(u32 fd);
s32 cellFsRmdir(u32 path_addr);
s32 cellFsUnlink(u32 path_addr);
s32 cellFsRmdir(vm::ptr<const char> path);
s32 cellFsUnlink(vm::ptr<const char> path);
s32 cellFsLseek(u32 fd, s64 offset, u32 whence, vm::ptr<be_t<u64>> pos);
s32 cellFsFtruncate(u32 fd, u64 size);
s32 cellFsTruncate(u32 path_addr, u64 size);
s32 cellFsTruncate(vm::ptr<const char> path, u64 size);
s32 cellFsFGetBlockSize(u32 fd, vm::ptr<be_t<u64>> sector_size, vm::ptr<be_t<u64>> block_size);
s32 cellFsGetBlockSize(u32 path_addr, vm::ptr<be_t<u64>> sector_size, vm::ptr<be_t<u64>> block_size);
s32 cellFsGetFreeSize(u32 path_addr, vm::ptr<be_t<u32>> block_size, vm::ptr<be_t<u64>> block_count);
s32 cellFsGetBlockSize(vm::ptr<const char> path, vm::ptr<be_t<u64>> sector_size, vm::ptr<be_t<u64>> block_size);
s32 cellFsGetFreeSize(vm::ptr<const char> path, vm::ptr<be_t<u32>> block_size, vm::ptr<be_t<u64>> block_count);
s32 cellFsGetDirectoryEntries(u32 fd, vm::ptr<CellFsDirectoryEntry> entries, u32 entries_size, vm::ptr<be_t<u32>> data_count);
s32 cellFsStReadInit(u32 fd, vm::ptr<CellFsRingBuffer> ringbuf);
s32 cellFsStReadFinish(u32 fd);

15
rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.cpp
View file

@ -150,13 +150,10 @@ s32 sys_ppu_thread_restart(u64 thread_id)
return CELL_OK;
}
s32 sys_ppu_thread_create(vm::ptr<be_t<u64>> thread_id, u32 entry, u64 arg, s32 prio, u32 stacksize, u64 flags, u32 threadname_addr)
s32 sys_ppu_thread_create(vm::ptr<be_t<u64>> thread_id, u32 entry, u64 arg, s32 prio, u32 stacksize, u64 flags, vm::ptr<const char> threadname)
{
std::string threadname = "";
if (threadname_addr) threadname = Memory.ReadString(threadname_addr);
sys_ppu_thread.Log("sys_ppu_thread_create(thread_id_addr=0x%x, entry=0x%x, arg=0x%llx, prio=%d, stacksize=0x%x, flags=0x%llx, threadname_addr=0x%x('%s'))",
thread_id.addr(), entry, arg, prio, stacksize, flags, threadname_addr, threadname.c_str());
thread_id.addr(), entry, arg, prio, stacksize, flags, threadname.addr(), threadname.get_ptr());
bool is_joinable = false;
bool is_interrupt = false;
@ -187,7 +184,7 @@ s32 sys_ppu_thread_create(vm::ptr<be_t<u64>> thread_id, u32 entry, u64 arg, s32
//new_thread.flags = flags;
new_thread.m_has_interrupt = false;
new_thread.m_is_interrupt = is_interrupt;
new_thread.SetName(threadname);
new_thread.SetName(threadname.get_ptr());
sys_ppu_thread.Notice("*** New PPU Thread [%s] (flags=0x%llx, entry=0x%x): id = %d", new_thread.GetName().c_str(), flags, entry, new_thread.GetId());
@ -219,15 +216,15 @@ s32 sys_ppu_thread_get_id(vm::ptr<be_t<u64>> thread_id)
return CELL_OK;
}
s32 sys_ppu_thread_rename(u64 thread_id, u32 name_addr)
s32 sys_ppu_thread_rename(u64 thread_id, vm::ptr<const char> name)
{
sys_ppu_thread.Log("sys_ppu_thread_rename(thread_id=%d, name_addr=0x%x)", thread_id, name_addr);
sys_ppu_thread.Log("sys_ppu_thread_rename(thread_id=%d, name_addr=0x%x('%s'))", thread_id, name.addr(), name.get_ptr());
CPUThread* thr = Emu.GetCPU().GetThread(thread_id);
if (!thr) {
return CELL_ESRCH;
}
thr->SetThreadName(Memory.ReadString(name_addr));
thr->SetThreadName(name.get_ptr());
return CELL_OK;
}

4
rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.h
View file

@ -24,7 +24,7 @@ s32 sys_ppu_thread_get_priority(u64 thread_id, u32 prio_addr);
s32 sys_ppu_thread_get_stack_information(u32 info_addr);
s32 sys_ppu_thread_stop(u64 thread_id);
s32 sys_ppu_thread_restart(u64 thread_id);
s32 sys_ppu_thread_create(vm::ptr<be_t<u64>> thread_id, u32 entry, u64 arg, s32 prio, u32 stacksize, u64 flags, u32 threadname_addr);
s32 sys_ppu_thread_create(vm::ptr<be_t<u64>> thread_id, u32 entry, u64 arg, s32 prio, u32 stacksize, u64 flags, vm::ptr<const char> threadname);
void sys_ppu_thread_once(vm::ptr<std::atomic<be_t<u32>>> once_ctrl, u32 entry);
s32 sys_ppu_thread_get_id(vm::ptr<be_t<u64>> thread_id);
s32 sys_ppu_thread_rename(u64 thread_id, u32 name_addr);
s32 sys_ppu_thread_rename(u64 thread_id, vm::ptr<const char> name);

28
rpcs3/Emu/SysCalls/lv2/sys_process.cpp
View file

@ -38,7 +38,7 @@ s32 sys_process_exit(s32 errorcode)
}
void sys_game_process_exitspawn(
u32 path_addr,
vm::ptr<const char> path,
u32 argv_addr,
u32 envp_addr,
u32 data_addr,
@ -47,7 +47,7 @@ void sys_game_process_exitspawn(
u64 flags )
{
sys_process.Todo("sys_game_process_exitspawn()");
sys_process.Warning("path: %s", Memory.ReadString(path_addr).c_str());
sys_process.Warning("path: %s", path.get_ptr());
sys_process.Warning("argv: 0x%x", argv_addr);
sys_process.Warning("envp: 0x%x", envp_addr);
sys_process.Warning("data: 0x%x", data_addr);
@ -55,20 +55,20 @@ void sys_game_process_exitspawn(
sys_process.Warning("prio: %d", prio);
sys_process.Warning("flags: %d", flags);
std::string path = Memory.ReadString(path_addr);
std::string _path = path.get_ptr();
std::vector<std::string> argv;
std::vector<std::string> env;
auto argvp = vm::ptr<u32>::make(argv_addr);
auto argvp = vm::ptr<vm::bptr<const char>>::make(argv_addr);
while (argvp && *argvp)
{
argv.push_back(Memory.ReadString(Memory.Read32(argvp.addr())));
argv.push_back(argvp[0].get_ptr());
argvp++;
}
auto envp = vm::ptr<u32>::make(envp_addr);
auto envp = vm::ptr<vm::bptr<const char>>::make(envp_addr);
while (envp && *envp)
{
env.push_back(Memory.ReadString(Memory.Read32(envp.addr())));
env.push_back(envp[0].get_ptr());
envp++;
}
@ -86,7 +86,7 @@ void sys_game_process_exitspawn(
}
void sys_game_process_exitspawn2(
u32 path_addr,
vm::ptr<const char> path,
u32 argv_addr,
u32 envp_addr,
u32 data_addr,
@ -95,7 +95,7 @@ void sys_game_process_exitspawn2(
u64 flags)
{
sys_process.Todo("sys_game_process_exitspawn2");
sys_process.Warning("path: %s", Memory.ReadString(path_addr).c_str());
sys_process.Warning("path: %s", path.get_ptr());
sys_process.Warning("argv: 0x%x", argv_addr);
sys_process.Warning("envp: 0x%x", envp_addr);
sys_process.Warning("data: 0x%x", data_addr);
@ -103,20 +103,20 @@ void sys_game_process_exitspawn2(
sys_process.Warning("prio: %d", prio);
sys_process.Warning("flags: %d", flags);
std::string path = Memory.ReadString(path_addr);
std::string _path = path.get_ptr();
std::vector<std::string> argv;
std::vector<std::string> env;
auto argvp = vm::ptr<u32>::make(argv_addr);
auto argvp = vm::ptr<vm::bptr<const char>>::make(argv_addr);
while (argvp && *argvp)
{
argv.push_back(Memory.ReadString(Memory.Read32(argvp.addr())));
argv.push_back(argvp[0].get_ptr());
argvp++;
}
auto envp = vm::ptr<u32>::make(envp_addr);
auto envp = vm::ptr<vm::bptr<const char>>::make(envp_addr);
while (envp && *envp)
{
env.push_back(Memory.ReadString(Memory.Read32(envp.addr())));
env.push_back(envp[0].get_ptr());
envp++;
}

4
rpcs3/Emu/SysCalls/lv2/sys_process.h
View file

@ -40,7 +40,7 @@ s32 sys_process_kill(u32 pid);
s32 sys_process_wait_for_child(u32 pid, vm::ptr<be_t<u32>> status, u64 unk);
s32 sys_process_wait_for_child2(u64 unk1, u64 unk2, u64 unk3, u64 unk4, u64 unk5, u64 unk6);
s32 sys_process_detach_child(u64 unk);
void sys_game_process_exitspawn(u32 path_addr, u32 argv_addr, u32 envp_addr,
void sys_game_process_exitspawn(vm::ptr<const char> path, u32 argv_addr, u32 envp_addr,
u32 data_addr, u32 data_size, u32 prio, u64 flags);
void sys_game_process_exitspawn2(u32 path_addr, u32 argv_addr, u32 envp_addr,
void sys_game_process_exitspawn2(vm::ptr<const char> path, u32 argv_addr, u32 envp_addr,
u32 data_addr, u32 data_size, u32 prio, u64 flags);

12
rpcs3/Emu/SysCalls/lv2/sys_prx.cpp
View file

@ -10,22 +10,22 @@
SysCallBase sys_prx("sys_prx");
s32 sys_prx_load_module(u32 path_addr, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt)
s32 sys_prx_load_module(vm::ptr<const char> path, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt)
{
std::string path = Memory.ReadString(path_addr);
sys_prx.Todo("sys_prx_load_module(path=\"%s\", flags=0x%llx, pOpt=0x%x)", path.c_str(), flags, pOpt.addr());
sys_prx.Todo("sys_prx_load_module(path=\"%s\", flags=0x%llx, pOpt=0x%x)", path.get_ptr(), flags, pOpt.addr());
std::string _path = path.get_ptr();
// Check if the file is SPRX
std::string local_path;
Emu.GetVFS().GetDevice(path, local_path);
Emu.GetVFS().GetDevice(_path, local_path);
if (IsSelf(local_path)) {
if (!DecryptSelf(local_path+".prx", local_path)) {
return CELL_PRX_ERROR_ILLEGAL_LIBRARY;
}
path += ".prx";
_path += ".prx";
}
vfsFile f(path);
vfsFile f(_path);
if (!f.IsOpened()) {
return CELL_PRX_ERROR_UNKNOWN_MODULE;
}

2
rpcs3/Emu/SysCalls/lv2/sys_prx.h
View file

@ -65,7 +65,7 @@ struct sys_prx_t
};
// SysCalls
s32 sys_prx_load_module(u32 path_addr, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt);
s32 sys_prx_load_module(vm::ptr<const char> path, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt);
s32 sys_prx_load_module_on_memcontainer();
s32 sys_prx_load_module_by_fd();
s32 sys_prx_load_module_on_memcontainer_by_fd();

9
rpcs3/Emu/SysCalls/lv2/sys_spu.cpp
View file

@ -23,15 +23,14 @@ u32 LoadSpuImage(vfsStream& stream, u32& spu_ep)
}
//156
s32 sys_spu_image_open(vm::ptr<sys_spu_image> img, u32 path_addr)
s32 sys_spu_image_open(vm::ptr<sys_spu_image> img, vm::ptr<const char> path)
{
const std::string path = Memory.ReadString(path_addr);
sys_spu.Warning("sys_spu_image_open(img_addr=0x%x, path_addr=0x%x [%s])", img.addr(), path_addr, path.c_str());
sys_spu.Warning("sys_spu_image_open(img_addr=0x%x, path_addr=0x%x [%s])", img.addr(), path.addr(), path.get_ptr());
vfsFile f(path);
vfsFile f(path.get_ptr());
if(!f.IsOpened())
{
sys_spu.Error("sys_spu_image_open error: '%s' not found!", path.c_str());
sys_spu.Error("sys_spu_image_open error: '%s' not found!", path.get_ptr());
return CELL_ENOENT;
}

2
rpcs3/Emu/SysCalls/lv2/sys_spu.h
View file

@ -109,7 +109,7 @@ struct SpuGroupInfo
// SysCalls
s32 sys_spu_initialize(u32 max_usable_spu, u32 max_raw_spu);
s32 sys_spu_image_open(vm::ptr<sys_spu_image> img, u32 path_addr);
s32 sys_spu_image_open(vm::ptr<sys_spu_image> img, vm::ptr<const char> path);
s32 sys_spu_thread_initialize(vm::ptr<be_t<u32>> thread, u32 group, u32 spu_num, vm::ptr<sys_spu_image> img, vm::ptr<sys_spu_thread_attribute> attr, vm::ptr<sys_spu_thread_argument> arg);
s32 sys_spu_thread_set_argument(u32 id, vm::ptr<sys_spu_thread_argument> arg);
s32 sys_spu_thread_group_destroy(u32 id);

2
rpcs3/Loader/ELF64.cpp
View file

@ -420,7 +420,7 @@ bool ELF64Loader::LoadPhdrData(u64 offset)
{
Elf64_StubHeader stub = *(Elf64_StubHeader*)Memory.GetMemFromAddr(offset + s);
const std::string& module_name = Memory.ReadString(stub.s_modulename);
const std::string module_name = vm::get_ptr<const char>(stub.s_modulename);
Module* module = Emu.GetModuleManager().GetModuleByName(module_name);
if (module) {
//module->SetLoaded();

4
rpcs3/emucore.vcxproj
View file

@ -177,7 +177,7 @@
<ClCompile Include="Emu\SysCalls\Modules\cellSysmodule.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellSysutil.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellSysutilAp.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellSysutil_SaveData.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellSaveData.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellUsbd.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellUsbpspcm.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellUserInfo.cpp" />
@ -385,7 +385,7 @@
<ClInclude Include="Emu\SysCalls\Modules\cellSync.h" />
<ClInclude Include="Emu\SysCalls\Modules\cellSync2.h" />
<ClInclude Include="Emu\SysCalls\Modules\cellSysutil.h" />
<ClInclude Include="Emu\SysCalls\Modules\cellSysutil_SaveData.h" />
<ClInclude Include="Emu\SysCalls\Modules\cellSaveData.h" />
<ClInclude Include="Emu\SysCalls\Modules\cellUserInfo.h" />
<ClInclude Include="Emu\SysCalls\Modules\cellVdec.h" />
<ClInclude Include="Emu\SysCalls\Modules\cellVpost.h" />

12
rpcs3/emucore.vcxproj.filters
View file

@ -188,9 +188,6 @@
<ClCompile Include="Emu\SysCalls\Modules\cellSysutilAp.cpp">
<Filter>Emu\SysCalls\Modules</Filter>
</ClCompile>
<ClCompile Include="Emu\SysCalls\Modules\cellSysutil_SaveData.cpp">
<Filter>Emu\SysCalls\Modules</Filter>
</ClCompile>
<ClCompile Include="Emu\SysCalls\Modules\cellUserInfo.cpp">
<Filter>Emu\SysCalls\Modules</Filter>
</ClCompile>
@ -623,6 +620,9 @@
<ClCompile Include="Emu\SysCalls\Modules\cellPad.cpp">
<Filter>Emu\SysCalls\Modules</Filter>
</ClCompile>
<ClCompile Include="Emu\SysCalls\Modules\cellSaveData.cpp">
<Filter>Emu\SysCalls\Modules</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="Crypto\aes.h">
@ -715,9 +715,6 @@
<ClInclude Include="Emu\SysCalls\Modules\cellSysutil.h">
<Filter>Emu\SysCalls\Modules</Filter>
</ClInclude>
<ClInclude Include="Emu\SysCalls\Modules\cellSysutil_SaveData.h">
<Filter>Emu\SysCalls\Modules</Filter>
</ClInclude>
<ClInclude Include="Emu\SysCalls\Modules\cellUserInfo.h">
<Filter>Emu\SysCalls\Modules</Filter>
</ClInclude>
@ -1204,5 +1201,8 @@
<ClInclude Include="Emu\SysCalls\Modules\cellMouse.h">
<Filter>Emu\SysCalls\Modules</Filter>
</ClInclude>
<ClInclude Include="Emu\SysCalls\Modules\cellSaveData.h">
<Filter>Emu\SysCalls\Modules</Filter>
</ClInclude>
</ItemGroup>
</Project>