archive/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-07-09 00:11:24 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge remote-tracking branch 'upstream/master'

Browse source
This commit is contained in:
S Gopal Rajagopal 2014-12-01 18:47:25 +05:30
commit 54d6aee028
31 changed files with 723 additions and 251 deletions
Download patch file Download diff file Expand all files Collapse all files

64
Utilities/StrFmt.cpp
View file

@ -57,7 +57,7 @@ int fmt::CmpNoCase(const std::string& a, const std::string& b)
return std::equal(a.begin(),
a.end(),
b.begin(),
[](const char& a, const char& b){return tolower(a) == tolower(b); })
[](const char& a, const char& b){return ::tolower(a) == ::tolower(b); })
? 0 : -1;
}
}
@ -102,4 +102,66 @@ std::vector<std::string> fmt::rSplit(const std::string& source, const std::strin
}
} while (true);
return ret;
}
std::vector<std::string> fmt::split(const std::string& source, std::initializer_list<std::string> separators, bool is_skip_empty)
{
std::vector<std::string> result;
size_t cursor_begin = 0;
for (size_t cursor_end = 0; cursor_end < source.length(); ++cursor_end)
{
for (auto &separator : separators)
{
if (strncmp(source.c_str() + cursor_end, separator.c_str(), separator.length()) == 0)
{
std::string candidate = source.substr(cursor_begin, cursor_end - cursor_begin);
if (!is_skip_empty || !candidate.empty())
result.push_back(candidate);
cursor_begin = cursor_end + separator.length();
cursor_end = cursor_begin - 1;
break;
}
}
}
if (cursor_begin != source.length())
{
result.push_back(source.substr(cursor_begin));
}
return std::move(result);
}
std::string fmt::merge(std::vector<std::string> source, const std::string& separator)
{
std::string result;
for (auto &s : source)
{
result += s + separator;
}
return result;
}
std::string fmt::merge(std::initializer_list<std::vector<std::string>> sources, const std::string& separator)
{
std::string result;
for (auto &v : sources)
{
result += fmt::merge(v, separator);
}
return result;
}
std::string fmt::tolower(std::string source)
{
std::transform(source.begin(), source.end(), source.begin(), ::tolower);
return source;
}

5
Utilities/StrFmt.h
View file

@ -192,4 +192,9 @@ namespace fmt{
void Replace(std::string &str, const std::string &searchterm, const std::string& replaceterm);
std::vector<std::string> rSplit(const std::string& source, const std::string& delim);
std::vector<std::string> split(const std::string& source, std::initializer_list<std::string> separators, bool is_skip_empty = true);
std::string merge(std::vector<std::string> source, const std::string& separator);
std::string merge(std::initializer_list<std::vector<std::string>> sources, const std::string& separator);
std::string tolower(std::string source);
}

250
rpcs3/Emu/FS/VFS.cpp
View file

@ -4,18 +4,49 @@
#include "Emu/HDD/HDD.h"
#include "vfsDeviceLocalFile.h"
#include "Ini.h"
#include "Emu/System.h"
#undef CreateFile // TODO: what's wrong with it?
#undef CreateFile
int sort_devices(const void* _a, const void* _b)
std::vector<std::string> simplify_path_blocks(const std::string& path)
{
const vfsDevice& a = **(const vfsDevice**)_a;
const vfsDevice& b = **(const vfsDevice**)_b;
std::vector<std::string> path_blocks = std::move(fmt::split(fmt::tolower(path), { "/", "\\" }));
if(a.GetPs3Path().length() > b.GetPs3Path().length()) return 1;
if(a.GetPs3Path().length() < b.GetPs3Path().length()) return -1;
for (size_t i = 0; i < path_blocks.size(); ++i)
{
if (path_blocks[i] == ".")
{
path_blocks.erase(path_blocks.begin() + i--);
}
else if (i && path_blocks[i] == "..")
{
path_blocks.erase(path_blocks.begin() + (i - 1), path_blocks.begin() + (i + 1));
i--;
}
}
return 0;
return path_blocks;
}
std::string simplify_path(const std::string& path, bool is_dir)
{
std::vector<std::string> path_blocks = simplify_path_blocks(path);
std::string result;
if (path_blocks.empty())
return result;
if (is_dir)
{
result = fmt::merge(path_blocks, "/");
}
else
{
result = fmt::merge(std::vector<std::string>(path_blocks.begin(), path_blocks.end() - 1), "/") + path_blocks[path_blocks.size() - 1];
}
return result;
}
VFS::~VFS()
@ -25,24 +56,62 @@ VFS::~VFS()
void VFS::Mount(const std::string& ps3_path, const std::string& local_path, vfsDevice* device)
{
UnMount(ps3_path);
std::string simpl_ps3_path = simplify_path(ps3_path, true);
device->SetPath(ps3_path, local_path);
UnMount(simpl_ps3_path);
device->SetPath(simpl_ps3_path, simplify_path(local_path, true));
m_devices.push_back(device);
if(m_devices.size() > 1)
if (m_devices.size() > 1)
{
//std::qsort(m_devices.GetPtr(), m_devices.GetCount(), sizeof(vfsDevice*), sort_devices);
std::sort(m_devices.begin(), m_devices.end(), [](vfsDevice *a, vfsDevice *b) { return b->GetPs3Path().length() < a->GetPs3Path().length(); });
}
}
void VFS::Link(const std::string& mount_point, const std::string& ps3_path)
{
links[simplify_path_blocks(mount_point)] = simplify_path_blocks(ps3_path);
}
std::string VFS::GetLinked(std::string ps3_path) const
{
ps3_path = fmt::tolower(ps3_path);
auto path_blocks = fmt::split(ps3_path, { "/", "\\" });
for (auto link : links)
{
if (path_blocks.size() < link.first.size())
continue;
bool is_ok = true;
for (size_t i = 0; i < link.first.size(); ++i)
{
if (link.first[i] != path_blocks[i])
{
is_ok = false;
break;
}
}
if (is_ok)
return fmt::merge({ link.second, std::vector<std::string>(path_blocks.begin() + link.first.size(), path_blocks.end()) }, "/");
}
return ps3_path;
}
void VFS::UnMount(const std::string& ps3_path)
{
for(u32 i=0; i<m_devices.size(); ++i)
std::string simpl_ps3_path = simplify_path(ps3_path, true);
for (u32 i = 0; i < m_devices.size(); ++i)
{
if(!m_devices[i]->GetPs3Path().compare(ps3_path))
if (!strcmp(m_devices[i]->GetPs3Path().c_str(), simpl_ps3_path.c_str()))
{
delete m_devices[i];
m_devices.erase(m_devices.begin() +i);
return;
@ -63,9 +132,9 @@ void VFS::UnMountAll()
vfsFileBase* VFS::OpenFile(const std::string& ps3_path, vfsOpenMode mode) const
{
std::string path;
if(vfsDevice* dev = GetDevice(ps3_path, path))
if (vfsDevice* dev = GetDevice(ps3_path, path))
{
if(vfsFileBase* res = dev->GetNewFileStream())
if (vfsFileBase* res = dev->GetNewFileStream())
{
res->Open(path, mode);
return res;
@ -79,9 +148,9 @@ vfsDirBase* VFS::OpenDir(const std::string& ps3_path) const
{
std::string path;
if(vfsDevice* dev = GetDevice(ps3_path, path))
if (vfsDevice* dev = GetDevice(ps3_path, path))
{
if(vfsDirBase* res = dev->GetNewDirStream())
if (vfsDirBase* res = dev->GetNewDirStream())
{
res->Open(path);
return res;
@ -94,11 +163,11 @@ vfsDirBase* VFS::OpenDir(const std::string& ps3_path) const
bool VFS::CreateFile(const std::string& ps3_path) const
{
std::string path;
if(vfsDevice* dev = GetDevice(ps3_path, path))
if (vfsDevice* dev = GetDevice(ps3_path, path))
{
std::shared_ptr<vfsFileBase> res(dev->GetNewFileStream());
if(res)
if (res)
{
return res->Create(path);
}
@ -110,11 +179,11 @@ bool VFS::CreateFile(const std::string& ps3_path) const
bool VFS::CreateDir(const std::string& ps3_path) const
{
std::string path;
if(vfsDevice* dev = GetDevice(ps3_path, path))
if (vfsDevice* dev = GetDevice(ps3_path, path))
{
std::shared_ptr<vfsDirBase> res(dev->GetNewDirStream());
if(res)
if (res)
{
return res->Create(path);
}
@ -126,11 +195,11 @@ bool VFS::CreateDir(const std::string& ps3_path) const
bool VFS::RemoveFile(const std::string& ps3_path) const
{
std::string path;
if(vfsDevice* dev = GetDevice(ps3_path, path))
if (vfsDevice* dev = GetDevice(ps3_path, path))
{
std::shared_ptr<vfsFileBase> res(dev->GetNewFileStream());
if(res)
if (res)
{
return res->Remove(path);
}
@ -142,11 +211,11 @@ bool VFS::RemoveFile(const std::string& ps3_path) const
bool VFS::RemoveDir(const std::string& ps3_path) const
{
std::string path;
if(vfsDevice* dev = GetDevice(ps3_path, path))
if (vfsDevice* dev = GetDevice(ps3_path, path))
{
std::shared_ptr<vfsDirBase> res(dev->GetNewDirStream());
if(res)
if (res)
{
return res->Remove(path);
}
@ -158,11 +227,11 @@ bool VFS::RemoveDir(const std::string& ps3_path) const
bool VFS::ExistsFile(const std::string& ps3_path) const
{
std::string path;
if(vfsDevice* dev = GetDevice(ps3_path, path))
if (vfsDevice* dev = GetDevice(ps3_path, path))
{
std::shared_ptr<vfsFileBase> res(dev->GetNewFileStream());
if(res)
if (res)
{
return res->Exists(path);
}
@ -174,11 +243,11 @@ bool VFS::ExistsFile(const std::string& ps3_path) const
bool VFS::ExistsDir(const std::string& ps3_path) const
{
std::string path;
if(vfsDevice* dev = GetDevice(ps3_path, path))
if (vfsDevice* dev = GetDevice(ps3_path, path))
{
std::shared_ptr<vfsDirBase> res(dev->GetNewDirStream());
if(res)
if (res)
{
return res->IsExists(path);
}
@ -190,11 +259,11 @@ bool VFS::ExistsDir(const std::string& ps3_path) const
bool VFS::RenameFile(const std::string& ps3_path_from, const std::string& ps3_path_to) const
{
std::string path;
if(vfsDevice* dev = GetDevice(ps3_path_from, path))
if (vfsDevice* dev = GetDevice(ps3_path_from, path))
{
std::shared_ptr<vfsFileBase> res(dev->GetNewFileStream());
if(res)
if (res)
{
return res->Rename(path, ps3_path_to);
}
@ -206,11 +275,11 @@ bool VFS::RenameFile(const std::string& ps3_path_from, const std::string& ps3_pa
bool VFS::RenameDir(const std::string& ps3_path_from, const std::string& ps3_path_to) const
{
std::string path;
if(vfsDevice* dev = GetDevice(ps3_path_from, path))
if (vfsDevice* dev = GetDevice(ps3_path_from, path))
{
std::shared_ptr<vfsDirBase> res(dev->GetNewDirStream());
if(res)
if (res)
{
return res->Rename(path, ps3_path_to);
}
@ -221,53 +290,108 @@ bool VFS::RenameDir(const std::string& ps3_path_from, const std::string& ps3_pat
vfsDevice* VFS::GetDevice(const std::string& ps3_path, std::string& path) const
{
u32 max_eq;
s32 max_i=-1;
for(u32 i=0; i<m_devices.size(); ++i)
auto try_get_device = [this, &path](const std::string& ps3_path) -> vfsDevice*
{
const u32 eq = m_devices[i]->CmpPs3Path(ps3_path);
std::vector<std::string> ps3_path_blocks = simplify_path_blocks(ps3_path);
size_t max_eq = 0;
int max_i = -1;
if(max_i < 0 || eq > max_eq)
for (u32 i = 0; i < m_devices.size(); ++i)
{
max_eq = eq;
max_i = i;
}
}
std::vector<std::string> dev_ps3_path_blocks = simplify_path_blocks(m_devices[i]->GetPs3Path());
if(max_i < 0) return nullptr;
path = vfsDevice::GetWinPath(m_devices[max_i]->GetLocalPath(), ps3_path.substr(max_eq, ps3_path.length() - max_eq));
return m_devices[max_i];
if (ps3_path_blocks.size() < dev_ps3_path_blocks.size())
continue;
size_t eq = 0;
for (; eq < dev_ps3_path_blocks.size(); ++eq)
{
if (strcmp(ps3_path_blocks[eq].c_str(), dev_ps3_path_blocks[eq].c_str()))
{
break;
}
}
if (eq > max_eq)
{
max_eq = eq;
max_i = i;
}
}
if (max_i < 0)
return nullptr;
path = m_devices[max_i]->GetLocalPath();
for (u32 i = max_eq; i < ps3_path_blocks.size(); i++)
{
path += "/" + ps3_path_blocks[i];
}
path = simplify_path(path, false);
return m_devices[max_i];
};
if (auto res = try_get_device(GetLinked(ps3_path)))
return res;
if (auto res = try_get_device(GetLinked(cwd + ps3_path)))
return res;
return nullptr;
}
vfsDevice* VFS::GetDeviceLocal(const std::string& local_path, std::string& path) const
{
u32 max_eq;
s32 max_i=-1;
size_t max_eq = 0;
int max_i = -1;
rFileName file_path(local_path);
file_path.Normalize();
std::string mormalized_path = file_path.GetFullPath();
std::vector<std::string> local_path_blocks = simplify_path_blocks(local_path);
for(u32 i=0; i<m_devices.size(); ++i)
for (u32 i = 0; i < m_devices.size(); ++i)
{
const u32 eq = m_devices[i]->CmpLocalPath(mormalized_path);
std::vector<std::string> dev_local_path_blocks_blocks = simplify_path_blocks(m_devices[i]->GetLocalPath());
if(max_i < 0 || eq > max_eq)
if (local_path_blocks.size() < dev_local_path_blocks_blocks.size())
continue;
size_t eq = 0;
for (; eq < dev_local_path_blocks_blocks.size(); ++eq)
{
if (strcmp(local_path_blocks[eq].c_str(), dev_local_path_blocks_blocks[eq].c_str()))
{
break;
}
}
if (eq > max_eq)
{
max_eq = eq;
max_i = i;
}
}
if(max_i < 0) return nullptr;
if (max_i < 0)
return nullptr;
path = m_devices[max_i]->GetPs3Path();
for (u32 i = max_eq; i < local_path_blocks.size(); i++)
{
path += "/" + local_path_blocks[i];
}
path = simplify_path(path, false);
path = vfsDevice::GetPs3Path(m_devices[max_i]->GetPs3Path(), local_path.substr(max_eq, local_path.length() - max_eq));
return m_devices[max_i];
}
void VFS::Init(const std::string& path)
{
cwd = simplify_path(path, true);
UnMountAll();
std::vector<VFSManagerEntry> entries;
@ -293,10 +417,12 @@ void VFS::Init(const std::string& path)
std::string mpath = entry.path;
// TODO: This shouldn't use current dir
fmt::Replace(mpath,"$(EmulatorDir)", ".");
fmt::Replace(mpath,"$(GameDir)", vfsDevice::GetRoot(path));
fmt::Replace(mpath, "$(EmulatorDir)", Emu.GetEmulatorPath());
fmt::Replace(mpath, "$(GameDir)", cwd);
Mount(entry.mount, mpath, dev);
}
Link("/app_home/", cwd);
}
void VFS::SaveLoadDevices(std::vector<VFSManagerEntry>& res, bool is_load)
@ -305,21 +431,19 @@ void VFS::SaveLoadDevices(std::vector<VFSManagerEntry>& res, bool is_load)
entries_count.Init("count", "VFSManager");
int count = 0;
if(is_load)
if (is_load)
{
count = entries_count.LoadValue(count);
if(!count)
if (!count)
{
res.emplace_back(vfsDevice_LocalFile, "$(EmulatorDir)/dev_hdd0/", "/dev_hdd0/");
res.emplace_back(vfsDevice_LocalFile, "$(EmulatorDir)/dev_hdd1/", "/dev_hdd1/");
res.emplace_back(vfsDevice_LocalFile, "$(EmulatorDir)/dev_flash/", "/dev_flash/");
res.emplace_back(vfsDevice_LocalFile, "$(EmulatorDir)/dev_usb000/", "/dev_usb000/");
res.emplace_back(vfsDevice_LocalFile, "$(EmulatorDir)/dev_usb000/", "/dev_usb/");
res.emplace_back(vfsDevice_LocalFile, "$(GameDir)", "/app_home/");
res.emplace_back(vfsDevice_LocalFile, "$(GameDir)/../", "/dev_bdvd/");
res.emplace_back(vfsDevice_LocalFile, "", "/host_root/");
res.emplace_back(vfsDevice_LocalFile, "$(GameDir)", "/");
return;
}
@ -344,7 +468,7 @@ void VFS::SaveLoadDevices(std::vector<VFSManagerEntry>& res, bool is_load)
entry_mount.Init(fmt::Format("mount[%d]", i), "VFSManager");
entry_device.Init(fmt::Format("device[%d]", i), "VFSManager");
if(is_load)
if (is_load)
{
res[i] = VFSManagerEntry();
res[i].path = entry_path.LoadValue("");

20
rpcs3/Emu/FS/VFS.h
View file

@ -1,4 +1,5 @@
#pragma once
#include <map>
class vfsDevice;
struct vfsFileBase;
@ -42,20 +43,39 @@ struct VFSManagerEntry
}
};
std::vector<std::string> simplify_path_blocks(const std::string& path);
std::string simplify_path(const std::string& path, bool is_dir);
struct VFS
{
~VFS();
std::string cwd;
//TODO: find out where these are supposed to be deleted or just make it shared_ptr
//and also make GetDevice and GetDeviceLocal return shared_ptr then.
// A vfsDevice will be deleted when they're unmounted or the VFS struct is destroyed.
// This will cause problems if other code stores the pointer returned by GetDevice/GetDeviceLocal
// and tries to use it after the device is unmounted.
std::vector<vfsDevice *> m_devices;
struct links_sorter
{
bool operator()(const std::vector<std::string>& a, const std::vector<std::string>& b)
{
return b.size() < a.size();
}
};
std::map<std::vector<std::string>, std::vector<std::string>, links_sorter> links;
void Mount(const std::string& ps3_path, const std::string& local_path, vfsDevice* device);
void Link(const std::string& mount_point, const std::string& ps3_path);
void UnMount(const std::string& ps3_path);
void UnMountAll();
std::string GetLinked(std::string ps3_path) const;
vfsFileBase* OpenFile(const std::string& ps3_path, vfsOpenMode mode) const;
vfsDirBase* OpenDir(const std::string& ps3_path) const;
bool CreateFile(const std::string& ps3_path) const;

79
rpcs3/Emu/FS/vfsDir.cpp
View file

@ -1,6 +1,7 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "vfsDevice.h"
#include "VFS.h"
#include "vfsDir.h"
@ -10,7 +11,7 @@ vfsDir::vfsDir()
{
// TODO: proper implementation
// m_stream is nullptr here. So open root until a proper dir is given
Open("/");
//Open("/");
}
vfsDir::vfsDir(const std::string& path)
@ -26,37 +27,78 @@ bool vfsDir::Open(const std::string& path)
m_stream.reset(Emu.GetVFS().OpenDir(path));
return m_stream && m_stream->IsOpened();
DirEntryInfo info;
m_cwd = simplify_path(Emu.GetVFS().GetLinked(0 && m_stream && m_stream->IsOpened() ? m_stream->GetPath() : path), true);
auto blocks = simplify_path_blocks(GetPath());
for (auto dev : Emu.GetVFS().m_devices)
{
auto dev_blocks = simplify_path_blocks(dev->GetPs3Path());
if (dev_blocks.size() < (blocks.size() + 1))
{
continue;
}
bool is_ok = true;
for (size_t i = 0; i < blocks.size(); ++i)
{
if (strcmp(dev_blocks[i].c_str(), blocks[i].c_str()))
{
is_ok = false;
break;
}
}
if (is_ok)
{
info.name = dev_blocks[blocks.size()];
m_entries.push_back(info);
}
}
if (m_stream && m_stream->IsOpened())
{
m_entries.insert(m_entries.begin(), m_stream->GetEntries().begin(), m_stream->GetEntries().end());
}
return !m_entries.empty();
}
bool vfsDir::Create(const std::string& path)
{
return m_stream->Create(path);
return Emu.GetVFS().CreateDir(path);
}
bool vfsDir::IsExists(const std::string& path) const
{
return m_stream->IsExists(path);
}
auto path_blocks = simplify_path_blocks(path);
const std::vector<DirEntryInfo>& vfsDir::GetEntries() const
{
return m_stream->GetEntries();
if (path_blocks.empty())
return false;
std::string dir_name = path_blocks[path_blocks.size() - 1];
for (const auto entry : vfsDir(path + "/.."))
{
if (!strcmp(entry->name.c_str(), dir_name.c_str()))
return true;
}
return false;
}
bool vfsDir::Rename(const std::string& from, const std::string& to)
{
return m_stream->Rename(from, to);
return Emu.GetVFS().RenameDir(from, to);
}
bool vfsDir::Remove(const std::string& path)
{
return m_stream->Remove(path);
}
const DirEntryInfo* vfsDir::Read()
{
return m_stream->Read();
return Emu.GetVFS().RemoveDir(path);
}
void vfsDir::Close()
@ -64,12 +106,7 @@ void vfsDir::Close()
m_stream.reset();
}
std::string vfsDir::GetPath() const
{
return m_stream->GetPath();
}
bool vfsDir::IsOpened() const
{
return m_stream && m_stream->IsOpened();
return !m_entries.empty();
}

4
rpcs3/Emu/FS/vfsDir.h
View file

@ -13,13 +13,11 @@ public:
virtual bool Open(const std::string& path) override;
virtual bool IsOpened() const override;
virtual bool IsExists(const std::string& path) const override;
virtual const std::vector<DirEntryInfo>& GetEntries() const override;
virtual void Close() override;
virtual std::string GetPath() const override;
//virtual std::string GetPath() const override;
virtual bool Create(const std::string& path) override;
//virtual bool Create(const DirEntryInfo& info) override;
virtual bool Rename(const std::string& from, const std::string& to) override;
virtual bool Remove(const std::string& path) override;
virtual const DirEntryInfo* Read() override;
};

8
rpcs3/Emu/FS/vfsDirBase.cpp
View file

@ -32,7 +32,7 @@ bool vfsDirBase::IsOpened() const
bool vfsDirBase::IsExists(const std::string& path) const
{
return rExists(path);
return false;
}
const std::vector<DirEntryInfo>& vfsDirBase::GetEntries() const
@ -58,3 +58,9 @@ const DirEntryInfo* vfsDirBase::Read()
return &m_entries[m_pos++];
}
const DirEntryInfo* vfsDirBase::First()
{
m_pos = 0;
return Read();
}

53
rpcs3/Emu/FS/vfsDirBase.h
View file

@ -53,4 +53,57 @@ public:
virtual bool Rename(const std::string& from, const std::string& to) = 0;
virtual bool Remove(const std::string& path) = 0;
virtual const DirEntryInfo* Read();
virtual const DirEntryInfo* First();
class iterator
{
vfsDirBase *parent;
const DirEntryInfo* data;
public:
iterator(vfsDirBase* parent)
: parent(parent)
, data(parent->First())
{
}
iterator(const DirEntryInfo* data)
: parent(parent)
, data(data)
{
}
iterator& operator++()
{
data = parent->Read();
return *this;
}
iterator operator++(int)
{
const DirEntryInfo* olddata = data;
data = parent->Read();
return iterator(olddata);
}
const DirEntryInfo* operator *()
{
return data;
}
bool operator!=(iterator other) const
{
return data != other.data;
}
};
iterator begin()
{
return iterator(this);
}
iterator end()
{
return iterator((const DirEntryInfo*)nullptr);
}
};

7
rpcs3/Emu/FS/vfsLocalDir.cpp
View file

@ -21,7 +21,7 @@ bool vfsLocalDir::Open(const std::string& path)
std::string name;
for(bool is_ok = dir.GetFirst(&name); is_ok; is_ok = dir.GetNext(&name))
{
std::string dir_path = path + name;
std::string dir_path = path + "/" + name;
m_entries.emplace_back();
// TODO: Use same info structure as fileinfo?
@ -46,6 +46,11 @@ bool vfsLocalDir::Create(const std::string& path)
return rMkpath(path);
}
bool vfsLocalDir::IsExists(const std::string& path) const
{
return rIsDir(path);
}
bool vfsLocalDir::Rename(const std::string& from, const std::string& to)
{
return false;

1
rpcs3/Emu/FS/vfsLocalDir.h
View file

@ -18,4 +18,5 @@ public:
virtual bool Rename(const std::string& from, const std::string& to) override;
virtual bool Remove(const std::string& path) override;
virtual bool IsOpened() const override;
virtual bool IsExists(const std::string& path) const;
};

33
rpcs3/Emu/Memory/vm.h
View file

@ -219,4 +219,37 @@ namespace vm
assert(location < memory_location_count);
return g_locations[location];
}
class stack
{
u32 m_begin;
u32 m_size;
int m_page_size;
int m_position;
u8 m_align;
public:
void init(u32 begin, u32 size, u32 page_size = 180, u8 align = 0x10)
{
m_begin = begin;
m_size = size;
m_page_size = page_size;
m_position = 0;
m_align = align;
}
u32 alloc_new_page()
{
assert(m_position + m_page_size < (int)m_size);
m_position += (int)m_page_size;
return m_begin + m_position;
}
u32 dealloc_new_page()
{
assert(m_position - m_page_size > 0);
m_position -= (int)m_page_size;
return m_begin + m_position;
}
};
}

2
rpcs3/Emu/RSX/RSXThread.cpp
View file

@ -2270,7 +2270,7 @@ void RSXThread::Task()
if(cmd == 0)
{
LOG_ERROR(Log::RSX, "null cmd: cmd=0x%x, put=0x%x, get=0x%x (addr=0x%x)", cmd, put, get, (u32)Memory.RSXIOMem.RealAddr(get));
Emu.Pause();
//Emu.Pause();
//HACK! We shouldn't be here
m_ctrl->get = get + (count + 1) * 4;
continue;

4
rpcs3/Emu/RSX/sysutil_video.h
View file

@ -16,8 +16,8 @@ enum VideoErrorCode
enum CellVideoOut
{
CELL_VIDEO_OUT_PRIMARY,
CELL_VIDEO_OUT_SECONDARY,
CELL_VIDEO_OUT_PRIMARY = 0,
CELL_VIDEO_OUT_SECONDARY = 1,
};
enum CellVideoOutResolutionId

17
rpcs3/Emu/SysCalls/ModuleManager.h
View file

@ -10,7 +10,6 @@ class ModuleManager
std::vector<ModuleFunc *> m_modules_funcs_list;
std::vector<Module> m_mod_init; //owner of Module
bool initialized;
std::unordered_map<u32, u32> m_registered_functions;
public:
ModuleManager();
@ -26,20 +25,4 @@ public:
u32 GetFuncNumById(u32 id);
Module* GetModuleByName(const std::string& name);
Module* GetModuleById(u16 id);
void register_function(u32 fnid, u32 fstub)
{
m_registered_functions[fnid] = fstub;
}
bool get_function_stub(u32 fnid, be_t<u32>& res)
{
auto f = m_registered_functions.find(fnid);
if (f == m_registered_functions.end())
return false;
res = f->second;
return true;
}
};

35
rpcs3/Emu/SysCalls/Modules.cpp
View file

@ -62,10 +62,12 @@ Module::~Module()
{
UnLoad();
for (int i = 0; i < m_funcs_list.size(); i++)
for (auto &i : m_funcs_list)
{
delete m_funcs_list[i];
delete i.second;
}
m_funcs_list.clear();
}
void Module::Load()
@ -75,12 +77,10 @@ void Module::Load()
if(m_load_func) m_load_func();
for(u32 i=0; i<m_funcs_list.size(); ++i)
for (auto &i : m_funcs_list)
{
Emu.GetModuleManager().AddFunc(m_funcs_list[i]);
Emu.GetModuleManager().AddFunc(i.second);
}
SetLoaded(true);
}
void Module::UnLoad()
@ -90,6 +90,11 @@ void Module::UnLoad()
if(m_unload_func) m_unload_func();
for (auto &i : m_funcs_list)
{
i.second->lle_func.set(0);
}
// TODO: Re-enable this when needed
// This was disabled because some functions would get unloaded and
// some games tried to use them, thus only printing a TODO message
@ -106,16 +111,14 @@ bool Module::Load(u32 id)
if(Emu.GetModuleManager().IsLoadedFunc(id))
return false;
for(u32 i=0; i<m_funcs_list.size(); ++i)
{
if(m_funcs_list[i]->id == id)
{
Emu.GetModuleManager().AddFunc(m_funcs_list[i]);
return true;
}
}
auto res = m_funcs_list.find(id);
return false;
if (res == m_funcs_list.end())
return false;
Emu.GetModuleManager().AddFunc(res->second);
return true;
}
bool Module::UnLoad(u32 id)
@ -177,7 +180,7 @@ void fix_import(Module* module, u32 func, u32 addr)
{
using namespace PPU_instr;
vm::ptr<u32>& ptr = (vm::ptr<u32>&)addr;
vm::ptr<u32> ptr = vm::ptr<u32>::make(addr);
*ptr++ = ADDIS(11, 0, func >> 16);
*ptr++ = ORI(11, 11, func & 0xffff);

31
rpcs3/Emu/SysCalls/Modules.h
View file

@ -9,10 +9,12 @@ struct ModuleFunc
{
u32 id;
func_caller* func;
vm::ptr<void(*)()> lle_func;
ModuleFunc(u32 id, func_caller* func)
ModuleFunc(u32 id, func_caller* func, vm::ptr<void(*)()> lle_func = vm::ptr<void(*)()>::make(0))
: id(id)
, func(func)
, lle_func(lle_func)
{
}
@ -57,7 +59,7 @@ class Module : public LogBase
void PushNewFuncSub(SFunc* func);
public:
std::vector<ModuleFunc*> m_funcs_list;
std::unordered_map<u32, ModuleFunc*> m_funcs_list;
Module(u16 id, const char* name, void(*load)() = nullptr, void(*unload)() = nullptr);
@ -66,6 +68,16 @@ public:
Module &operator =(Module &other) = delete;
Module &operator =(Module &&other);
ModuleFunc* GetFunc(u32 id)
{
auto res = m_funcs_list.find(id);
if (res == m_funcs_list.end())
return nullptr;
return res->second;
}
~Module();
@ -114,9 +126,20 @@ public:
}
bool RemoveId(u32 id);
void RegisterLLEFunc(u32 id, vm::ptr<void(*)()> func)
{
if (auto f = GetFunc(id))
{
f->lle_func = func;
return;
}
m_funcs_list[id] = new ModuleFunc(id, nullptr, func);
}
template<typename T> __forceinline void AddFunc(u32 id, T func);
template<typename T> __forceinline void AddFunc(const char* name, T func);
template<typename T> __forceinline void AddFunc(const char* name, T func);
template<typename T> __forceinline void AddFuncSub(const char group[8], const u64 ops[], const char* name, T func);
};
@ -125,7 +148,7 @@ u32 getFunctionId(const char* name);
template<typename T>
__forceinline void Module::AddFunc(u32 id, T func)
{
m_funcs_list.emplace_back(new ModuleFunc(id, bind_func(func)));
m_funcs_list[id] = new ModuleFunc(id, bind_func(func));
}
template<typename T>

8
rpcs3/Emu/SysCalls/Modules/cellGame.cpp
View file

@ -30,7 +30,7 @@ int cellGameBootCheck(vm::ptr<u32> type, vm::ptr<u32> attributes, vm::ptr<CellGa
size->sysSizeKB = 0;
}
vfsFile f("/app_home/PARAM.SFO");
vfsFile f("/app_home/../PARAM.SFO");
if (!f.IsOpened())
{
cellGame->Error("cellGameBootCheck(): CELL_GAME_ERROR_ACCESS_ERROR (cannot open PARAM.SFO)");
@ -100,7 +100,7 @@ int cellGamePatchCheck(vm::ptr<CellGameContentSize> size, u32 reserved_addr)
size->sysSizeKB = 0;
}
vfsFile f("/app_home/PARAM.SFO");
vfsFile f("/app_home/../PARAM.SFO");
if (!f.IsOpened())
{
cellGame->Error("cellGamePatchCheck(): CELL_GAME_ERROR_ACCESS_ERROR (cannot open PARAM.SFO)");
@ -336,7 +336,7 @@ int cellGameGetParamInt(u32 id, vm::ptr<u32> value)
cellGame->Warning("cellGameGetParamInt(id=%d, value_addr=0x%x)", id, value.addr());
// TODO: Access through cellGame***Check functions
vfsFile f("/app_home/PARAM.SFO");
vfsFile f("/app_home/../PARAM.SFO");
PSFLoader psf(f);
if(!psf.Load(false))
return CELL_GAME_ERROR_FAILURE;
@ -359,7 +359,7 @@ int cellGameGetParamString(u32 id, vm::ptr<char> buf, u32 bufsize)
cellGame->Warning("cellGameGetParamString(id=%d, buf_addr=0x%x, bufsize=%d)", id, buf.addr(), bufsize);
// TODO: Access through cellGame***Check functions
vfsFile f("/app_home/PARAM.SFO");
vfsFile f("/app_home/../PARAM.SFO");
PSFLoader psf(f);
if(!psf.Load(false))
return CELL_GAME_ERROR_FAILURE;

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

@ -96,7 +96,7 @@ int sceNpTrophyCreateContext(vm::ptr<u32> context, vm::ptr<SceNpCommunicationId>
// TODO: There are other possible errors
// TODO: Is the TROPHY.TRP file necessarily located in this path?
vfsDir dir("/app_home/TROPDIR/");
vfsDir dir("/app_home/../TROPDIR/");
if(!dir.IsOpened())
return SCE_NP_TROPHY_ERROR_CONF_DOES_NOT_EXIST;
@ -105,7 +105,7 @@ int sceNpTrophyCreateContext(vm::ptr<u32> context, vm::ptr<SceNpCommunicationId>
{
if (entry->flags & DirEntry_TypeDir)
{
vfsStream* stream = Emu.GetVFS().OpenFile("/app_home/TROPDIR/" + entry->name + "/TROPHY.TRP", vfsRead);
vfsStream* stream = Emu.GetVFS().OpenFile("/app_home/../TROPDIR/" + entry->name + "/TROPHY.TRP", vfsRead);
if (stream && stream->IsOpened())
{

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

@ -40,7 +40,7 @@ s32 cellFsOpen(vm::ptr<const char> path, s32 flags, vm::ptr<be_t<u32>> fd, vm::p
LV2_LOCK(0);
s32 _oflags = flags;
if(flags & CELL_O_CREAT)
if (flags & CELL_O_CREAT)
{
_oflags &= ~CELL_O_CREAT;
Emu.GetVFS().CreateFile(_path);
@ -48,7 +48,7 @@ s32 cellFsOpen(vm::ptr<const char> path, s32 flags, vm::ptr<be_t<u32>> fd, vm::p
vfsOpenMode o_mode;
switch(flags & CELL_O_ACCMODE)
switch (flags & CELL_O_ACCMODE)
{
case CELL_O_RDONLY:
_oflags &= ~CELL_O_RDONLY;
@ -88,7 +88,7 @@ s32 cellFsOpen(vm::ptr<const char> path, s32 flags, vm::ptr<be_t<u32>> fd, vm::p
break;
}
if(_oflags != 0)
if (_oflags != 0)
{
sys_fs->Error("\"%s\" has unknown flags! flags: 0x%08x", path.get_ptr(), flags);
return CELL_EINVAL;
@ -102,7 +102,7 @@ s32 cellFsOpen(vm::ptr<const char> path, s32 flags, vm::ptr<be_t<u32>> fd, vm::p
vfsFileBase* stream = Emu.GetVFS().OpenFile(_path, o_mode);
if(!stream || !stream->IsOpened())
if (!stream || !stream->IsOpened())
{
delete stream;
sys_fs->Error("\"%s\" not found! flags: 0x%08x", path.get_ptr(), flags);
@ -124,9 +124,11 @@ s32 cellFsRead(u32 fd, vm::ptr<void> buf, u64 nbytes, vm::ptr<be_t<u64>> nread)
LV2_LOCK(0);
vfsStream* file;
if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
if (!sys_fs->CheckId(fd, file))
return CELL_ESRCH;
if (nbytes != (u32)nbytes) return CELL_ENOMEM;
if (nbytes != (u32)nbytes)
return CELL_ENOMEM;
// TODO: checks
@ -145,7 +147,7 @@ s32 cellFsWrite(u32 fd, vm::ptr<const void> buf, u64 nbytes, vm::ptr<u64> nwrite
LV2_LOCK(0);
vfsStream* file;
if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
if (!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
if (nbytes != (u32)nbytes) return CELL_ENOMEM;
@ -164,7 +166,7 @@ s32 cellFsClose(u32 fd)
LV2_LOCK(0);
if(!Emu.GetIdManager().RemoveID(fd))
if (!Emu.GetIdManager().RemoveID(fd))
return CELL_ESRCH;
return CELL_OK;
@ -177,7 +179,7 @@ s32 cellFsOpendir(vm::ptr<const char> path, vm::ptr<u32> fd)
LV2_LOCK(0);
vfsDirBase* dir = Emu.GetVFS().OpenDir(path.get_ptr());
if(!dir || !dir->IsOpened())
if (!dir || !dir->IsOpened())
{
delete dir;
return CELL_ENOENT;
@ -194,11 +196,11 @@ s32 cellFsReaddir(u32 fd, vm::ptr<CellFsDirent> dir, vm::ptr<u64> nread)
LV2_LOCK(0);
vfsDirBase* directory;
if(!sys_fs->CheckId(fd, directory))
if (!sys_fs->CheckId(fd, directory))
return CELL_ESRCH;
const DirEntryInfo* info = directory->Read();
if(info)
if (info)
{
dir->d_type = (info->flags & DirEntry_TypeFile) ? CELL_FS_TYPE_REGULAR : CELL_FS_TYPE_DIRECTORY;
dir->d_namlen = u8(std::min((u32)info->name.length(), (u32)CELL_MAX_FS_FILE_NAME_LENGTH));
@ -219,7 +221,7 @@ s32 cellFsClosedir(u32 fd)
LV2_LOCK(0);
if(!Emu.GetIdManager().RemoveID(fd))
if (!Emu.GetIdManager().RemoveID(fd))
return CELL_ESRCH;
return CELL_OK;
@ -276,9 +278,8 @@ s32 cellFsFstat(u32 fd, vm::ptr<CellFsStat> sb)
IDType type;
vfsStream* file;
if(!sys_fs->CheckId(fd, file, type) || type != TYPE_FS_FILE) {
if (!sys_fs->CheckId(fd, file, type) || type != TYPE_FS_FILE)
return CELL_ESRCH;
}
sb->st_mode =
CELL_FS_S_IRUSR | CELL_FS_S_IWUSR | CELL_FS_S_IXUSR |
@ -305,9 +306,10 @@ s32 cellFsMkdir(vm::ptr<const char> path, u32 mode)
const std::string _path = path.get_ptr();
if(Emu.GetVFS().ExistsDir(_path))
if (vfsDir().IsExists(_path))
return CELL_EEXIST;
if(!Emu.GetVFS().CreateDir(_path))
if (!Emu.GetVFS().CreateDir(_path))
return CELL_EBUSY;
return CELL_OK;
@ -378,10 +380,10 @@ s32 cellFsRmdir(vm::ptr<const char> path)
std::string _path = path.get_ptr();
vfsDir d;
if(!d.IsExists(_path))
if (!d.IsExists(_path))
return CELL_ENOENT;
if(!d.Remove(_path))
if (!d.Remove(_path))
return CELL_EBUSY;
return CELL_OK;
@ -395,7 +397,7 @@ s32 cellFsUnlink(vm::ptr<const char> path)
std::string _path = path.get_ptr();
if (Emu.GetVFS().ExistsDir(_path))
if (vfsDir().IsExists(_path))
return CELL_EISDIR;
if (!Emu.GetVFS().ExistsFile(_path))
@ -426,9 +428,9 @@ s32 cellFsLseek(u32 fd, s64 offset, u32 whence, vm::ptr<be_t<u64>> pos)
IDType type;
vfsStream* file;
if (!sys_fs->CheckId(fd, file, type) || type != TYPE_FS_FILE) {
if (!sys_fs->CheckId(fd, file, type) || type != TYPE_FS_FILE)
return CELL_ESRCH;
}
*pos = file->Seek(offset, seek_mode);
return CELL_OK;
}
@ -441,9 +443,9 @@ s32 cellFsFtruncate(u32 fd, u64 size)
IDType type;
vfsStream* file;
if (!sys_fs->CheckId(fd, file, type) || type != TYPE_FS_FILE) {
if (!sys_fs->CheckId(fd, file, type) || type != TYPE_FS_FILE)
return CELL_ESRCH;
}
u64 initialSize = file->GetSize();
if (initialSize < size)
@ -471,7 +473,7 @@ s32 cellFsTruncate(vm::ptr<const char> path, u64 size)
LV2_LOCK(0);
vfsFile f(path.get_ptr(), vfsReadWrite);
if(!f.IsOpened())
if (!f.IsOpened())
{
sys_fs->Warning("cellFsTruncate: \"%s\" not found.", path.get_ptr());
return CELL_ENOENT;
@ -504,7 +506,8 @@ s32 cellFsFGetBlockSize(u32 fd, vm::ptr<u64> sector_size, vm::ptr<u64> block_siz
LV2_LOCK(0);
vfsStream* file;
if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
if (!sys_fs->CheckId(fd, file))
return CELL_ESRCH;
*sector_size = 4096; // ?
*block_size = 4096; // ?
@ -547,11 +550,11 @@ s32 cellFsGetDirectoryEntries(u32 fd, vm::ptr<CellFsDirectoryEntry> entries, u32
LV2_LOCK(0);
vfsDirBase* directory;
if(!sys_fs->CheckId(fd, directory))
if (!sys_fs->CheckId(fd, directory))
return CELL_ESRCH;
const DirEntryInfo* info = directory->Read();
if(info)
if (info)
{
entries->attribute.st_mode =
CELL_FS_S_IRUSR | CELL_FS_S_IWUSR | CELL_FS_S_IXUSR |
@ -585,17 +588,16 @@ s32 cellFsStReadInit(u32 fd, vm::ptr<CellFsRingBuffer> ringbuf)
LV2_LOCK(0);
vfsStream* file;
if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
if (!sys_fs->CheckId(fd, file))
return CELL_ESRCH;
fs_config.m_ring_buffer = *ringbuf;
// If the size is less than 1MB
if(ringbuf->ringbuf_size < 0x40000000) {
if (ringbuf->ringbuf_size < 0x40000000)
fs_config.m_alloc_mem_size = (((u32)ringbuf->ringbuf_size + 64 * 1024 - 1) / (64 * 1024)) * (64 * 1024);
}
else {
else
fs_config.m_alloc_mem_size = (((u32)ringbuf->ringbuf_size + 1024 * 1024 - 1) / (1024 * 1024)) * (1024 * 1024);
}
// alloc memory
fs_config.m_buffer = (u32)Memory.Alloc(fs_config.m_alloc_mem_size, 1024);
@ -613,7 +615,8 @@ s32 cellFsStReadFinish(u32 fd)
LV2_LOCK(0);
vfsStream* file;
if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
if (!sys_fs->CheckId(fd, file))
return CELL_ESRCH;
Memory.Free(fs_config.m_buffer);
fs_config.m_fs_status = CELL_FS_ST_NOT_INITIALIZED;
@ -628,7 +631,8 @@ s32 cellFsStReadGetRingBuf(u32 fd, vm::ptr<CellFsRingBuffer> ringbuf)
LV2_LOCK(0);
vfsStream* file;
if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
if (!sys_fs->CheckId(fd, file))
return CELL_ESRCH;
*ringbuf = fs_config.m_ring_buffer;
@ -644,7 +648,8 @@ s32 cellFsStReadGetStatus(u32 fd, vm::ptr<u64> status)
LV2_LOCK(0);
vfsStream* file;
if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
if (!sys_fs->CheckId(fd, file))
return CELL_ESRCH;
*status = fs_config.m_fs_status;
@ -658,7 +663,8 @@ s32 cellFsStReadGetRegid(u32 fd, vm::ptr<u64> regid)
LV2_LOCK(0);
vfsStream* file;
if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
if (!sys_fs->CheckId(fd, file))
return CELL_ESRCH;
*regid = fs_config.m_regid;
@ -672,7 +678,8 @@ s32 cellFsStReadStart(u32 fd, u64 offset, u64 size)
LV2_LOCK(0);
vfsStream* file;
if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
if (!sys_fs->CheckId(fd, file))
return CELL_ESRCH;
fs_config.m_current_addr = fs_config.m_buffer + (u32)offset;
fs_config.m_fs_status = CELL_FS_ST_PROGRESS;
@ -687,7 +694,8 @@ s32 cellFsStReadStop(u32 fd)
LV2_LOCK(0);
vfsStream* file;
if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
if (!sys_fs->CheckId(fd, file))
return CELL_ESRCH;
fs_config.m_fs_status = CELL_FS_ST_STOP;
@ -701,7 +709,8 @@ s32 cellFsStRead(u32 fd, u32 buf_addr, u64 size, vm::ptr<u64> rsize)
LV2_LOCK(0);
vfsStream* file;
if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
if (!sys_fs->CheckId(fd, file))
return CELL_ESRCH;
// TODO: use ringbuffer (fs_config)
fs_config.m_regid += size;
@ -721,7 +730,8 @@ s32 cellFsStReadGetCurrentAddr(u32 fd, vm::ptr<u32> addr, vm::ptr<u64> size)
LV2_LOCK(0);
vfsStream* file;
if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
if (!sys_fs->CheckId(fd, file))
return CELL_ESRCH;
return CELL_OK;
}
@ -733,7 +743,8 @@ s32 cellFsStReadPutCurrentAddr(u32 fd, u32 addr_addr, u64 size)
LV2_LOCK(0);
vfsStream* file;
if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
if (!sys_fs->CheckId(fd, file))
return CELL_ESRCH;
return CELL_OK;
}
@ -745,7 +756,8 @@ s32 cellFsStReadWait(u32 fd, u64 size)
LV2_LOCK(0);
vfsStream* file;
if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
if (!sys_fs->CheckId(fd, file))
return CELL_ESRCH;
return CELL_OK;
}
@ -757,7 +769,8 @@ s32 cellFsStReadWaitCallback(u32 fd, u64 size, vm::ptr<void (*)(int xfd, u64 xsi
LV2_LOCK(0);
vfsStream* file;
if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
if (!sys_fs->CheckId(fd, file))
return CELL_ESRCH;
return CELL_OK;
}

10
rpcs3/Emu/SysCalls/lv2/sys_event_flag.cpp
View file

@ -30,9 +30,7 @@ u32 EventFlag::check()
}
if (m_protocol == SYS_SYNC_PRIORITY)
{
target = sq.pop_prio();
}
return target;
}
@ -42,13 +40,13 @@ s32 sys_event_flag_create(vm::ptr<u32> eflag_id, vm::ptr<sys_event_flag_attr> at
sys_event_flag.Warning("sys_event_flag_create(eflag_id_addr=0x%x, attr_addr=0x%x, init=0x%llx)",
eflag_id.addr(), attr.addr(), init);
if (eflag_id.addr() == NULL)
if (!eflag_id)
{
sys_event_flag.Error("sys_event_flag_create(): invalid memory access (eflag_id_addr=0x%x)", eflag_id.addr());
return CELL_EFAULT;
}
if (attr.addr() == NULL)
if (!attr)
{
sys_event_flag.Error("sys_event_flag_create(): invalid memory access (attr_addr=0x%x)", attr.addr());
return CELL_EFAULT;
@ -64,9 +62,7 @@ s32 sys_event_flag_create(vm::ptr<u32> eflag_id, vm::ptr<sys_event_flag_attr> at
}
if (attr->pshared.ToBE() != se32(0x200))
{
return CELL_EINVAL;
}
switch (attr->type.ToBE())
{
@ -370,7 +366,7 @@ s32 sys_event_flag_get(u32 eflag_id, vm::ptr<u64> flags)
{
sys_event_flag.Log("sys_event_flag_get(eflag_id=%d, flags_addr=0x%x)", eflag_id, flags.addr());
if (flags.addr() == NULL)
if (!flags)
{
sys_event_flag.Error("sys_event_flag_create(): invalid memory access (flags_addr=0x%x)", flags.addr());
return CELL_EFAULT;

2
rpcs3/Emu/SysCalls/lv2/sys_memory.cpp
View file

@ -28,7 +28,7 @@ s32 sys_memory_allocate(u32 size, u32 flags, u32 alloc_addr_addr)
default: return CELL_EINVAL;
}
if(!addr)
if (!addr)
return CELL_ENOMEM;
// Write back the start address of the allocated area.

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

@ -73,16 +73,27 @@ void sys_game_process_exitspawn(
envp++;
}
for (auto &arg : argv){
for (auto &arg : argv) {
sys_process.Log("argument: %s", arg.c_str());
}
for (auto &en : env){
for (auto &en : env) {
sys_process.Log("env_argument: %s", en.c_str());
}
//TODO: execute the file in <path> with the args in argv
//and the environment parameters in envp and copy the data
//from data_addr into the adress space of the new process
//then kill the current process
Emu.Pause();
sys_process.Success("Process finished");
CallAfter([]()
{
Emu.Stop();
});
return;
}
@ -121,16 +132,27 @@ void sys_game_process_exitspawn2(
envp++;
}
for (auto &arg : argv){
for (auto &arg : argv) {
sys_process.Log("argument: %s", arg.c_str());
}
for (auto &en : env){
for (auto &en : env) {
sys_process.Log("env_argument: %s", en.c_str());
}
//TODO: execute the file in <path> with the args in argv
//and the environment parameters in envp and copy the data
//from data_addr into the adress space of the new process
//then kill the current process
Emu.Pause();
sys_process.Success("Process finished");
CallAfter([]()
{
Emu.Stop();
});
return;
}

2
rpcs3/Emu/System.cpp
View file

@ -192,7 +192,7 @@ void Emulator::Load()
LOG_NOTICE(LOADER, "Loading '%s'...", m_path.c_str());
GetInfo().Reset();
GetVFS().Init(m_path);
GetVFS().Init(rFileName(m_path).GetPath());
LOG_NOTICE(LOADER, " "); //used to be skip_line
LOG_NOTICE(LOADER, "Mount info:");

11
rpcs3/Emu/System.h
View file

@ -112,6 +112,7 @@ class Emulator
public:
std::string m_path;
std::string m_elf_path;
std::string m_emu_path;
std::string m_title_id;
u32 m_ppu_thr_stop;
s32 m_sdk_version;
@ -128,6 +129,16 @@ public:
return m_elf_path;
}
std::string GetEmulatorPath() const
{
return m_emu_path;
}
void SetEmulatorPath(const std::string& path)
{
m_emu_path = path;
}
std::recursive_mutex& GetCoreMutex() { return m_core_mutex; }
CPUThreadManager& GetCPU() { return *m_thread_manager; }

6
rpcs3/Gui/GameViewer.cpp
View file

@ -112,7 +112,7 @@ void GameViewer::LoadGames()
m_games.clear();
for(const DirEntryInfo* info = dir.Read(); info; info = dir.Read())
for(const DirEntryInfo* info : dir)
{
if(info->flags & DirEntry_TypeDir)
{
@ -182,7 +182,7 @@ void GameViewer::ShowData()
void GameViewer::Refresh()
{
Emu.GetVFS().Init(m_path);
Emu.GetVFS().Init("/");
LoadGames();
LoadPSF();
ShowData();
@ -210,7 +210,7 @@ void GameViewer::DClick(wxListEvent& event)
Debug::AutoPause::getInstance().Reload();
Emu.GetVFS().Init(path);
Emu.GetVFS().Init("/");
std::string local_path;
if (Emu.GetVFS().GetDevice(path, local_path) && !Emu.BootGame(local_path)) {
LOG_ERROR(HLE, "Boot error: elf not found! [%s]", path.c_str());

2
rpcs3/Gui/KernelExplorer.cpp
View file

@ -147,7 +147,7 @@ void KernelExplorer::Update()
sprintf(name, "Modules (%d)", count);
const auto& node = m_tree->AppendItem(root, name);
const auto& objects = Emu.GetIdManager().GetTypeIDs(TYPE_PRX);
sprintf(name, "Segment List (%d)", 2 * objects.size()); // TODO: Assuming 2 segments per PRX file is not good
sprintf(name, "Segment List (%l)", 2 * objects.size()); // TODO: Assuming 2 segments per PRX file is not good
m_tree->AppendItem(node, name);
for (const auto& id : objects)
{

47
rpcs3/Gui/LLEModulesManager.cpp
View file

@ -13,19 +13,20 @@ LLEModulesManagerFrame::LLEModulesManagerFrame(wxWindow* parent) : FrameBase(par
wxBoxSizer *s_p_panel = new wxBoxSizer(wxVERTICAL);
wxPanel *p_main = new wxPanel(this);
m_check_list = new wxCheckListBox(p_main, wxID_ANY);
s_p_panel->Add(m_check_list, 0, wxEXPAND | wxALL, 5);
s_p_panel->Add(m_check_list, 1, wxEXPAND | wxALL, 5);
p_main->SetSizerAndFit(s_p_panel);
s_panel->Add(p_main, 0, wxEXPAND | wxALL, 5);
s_panel->Add(p_main, 1, wxEXPAND | wxALL, 5);
SetSizerAndFit(s_panel);
Refresh();
//Bind(wxEVT_CHECKLISTBOX, [this](wxCommandEvent& event) { UpdateSelection(); });
Bind(wxEVT_SIZE, [p_main, this](wxSizeEvent& event) { p_main->SetSize(GetClientSize()); m_check_list->SetSize(p_main->GetClientSize() - wxSize(10, 10)); });
Bind(wxEVT_CHECKLISTBOX, [this](wxCommandEvent& event) { UpdateSelection(event.GetInt()); event.Skip(); });
Bind(wxEVT_SIZE, [p_main, this](wxSizeEvent& event) { p_main->SetSize(GetClientSize()); m_check_list->SetSize(p_main->GetClientSize() - wxSize(10, 10)); event.Skip(); });
}
void LLEModulesManagerFrame::Refresh()
{
m_check_list->Clear();
m_funcs.clear();
std::string path = "/dev_flash/sys/external/";
@ -34,7 +35,7 @@ void LLEModulesManagerFrame::Refresh()
vfsDir dir(path);
loader::handlers::elf64 sprx_loader;
for (const DirEntryInfo* info = dir.Read(); info; info = dir.Read())
for (const auto info : dir)
{
if (info->flags & DirEntry_TypeFile)
{
@ -49,17 +50,45 @@ void LLEModulesManagerFrame::Refresh()
continue;
}
sprx_loader.load();
//loader::handlers::elf64::sprx_info info;
//sprx_loader.load_sprx(info);
m_check_list->Check(m_check_list->Append(sprx_loader.sprx_get_module_name() +
" v" + std::to_string((int)sprx_loader.m_sprx_module_info.version[0]) + "." + std::to_string((int)sprx_loader.m_sprx_module_info.version[1])));
std::string name = sprx_loader.sprx_get_module_name();
bool is_skip = false;
for (auto &i : m_funcs)
{
if (i == name)
{
is_skip = true;
break;
}
}
if (is_skip)
continue;
m_funcs.push_back(name);
IniEntry<bool> load_lib;
load_lib.Init(name, "LLE");
m_check_list->Check(m_check_list->Append(name +
" v" + std::to_string((int)sprx_loader.m_sprx_module_info.version[0]) +
"." + std::to_string((int)sprx_loader.m_sprx_module_info.version[1])),
load_lib.LoadValue(false));
}
}
Emu.GetVFS().UnMountAll();
}
void LLEModulesManagerFrame::UpdateSelection()
void LLEModulesManagerFrame::UpdateSelection(int index)
{
if (index < 0)
return;
IniEntry<bool> load_lib;
load_lib.Init(m_funcs[index], "LLE");
load_lib.SaveValue(m_check_list->IsChecked(index));
}

3
rpcs3/Gui/LLEModulesManager.h
View file

@ -5,9 +5,10 @@
class LLEModulesManagerFrame : public FrameBase
{
wxCheckListBox *m_check_list;
std::vector<std::string> m_funcs;
public:
LLEModulesManagerFrame(wxWindow *parent);
void Refresh();
void UpdateSelection();
void UpdateSelection(int index);
};

114
rpcs3/Loader/ELF64.cpp
View file

@ -3,6 +3,7 @@
#include "Utilities/rFile.h"
#include "Emu/FS/vfsStream.h"
#include "Emu/FS/vfsFile.h"
#include "Emu/FS/vfsDir.h"
#include "Emu/Memory/Memory.h"
#include "Emu/System.h"
#include "Emu/SysCalls/SysCalls.h"
@ -12,6 +13,7 @@
#include "Emu/Cell/PPUInstrTable.h"
#include "Emu/CPU/CPUThreadManager.h"
#include "ELF64.h"
#include "Ini.h"
using namespace PPU_instr;
@ -43,8 +45,6 @@ namespace loader
return broken_file;
}
LOG_WARNING(LOADER, "m_ehdr.e_type = 0x%x", m_ehdr.e_type.ToLE());
if (m_ehdr.e_machine != MACHINE_PPC64 && m_ehdr.e_machine != MACHINE_SPU)
{
LOG_ERROR(LOADER, "Unknown elf64 machine type: 0x%x", m_ehdr.e_machine.ToLE());
@ -73,8 +73,6 @@ namespace loader
if (is_sprx())
{
LOG_NOTICE(LOADER, "SPRX loading...");
m_stream->Seek(handler::get_stream_offset() + m_phdrs[0].p_paddr.addr());
m_stream->Read(&m_sprx_module_info, sizeof(sprx_module_info));
@ -94,7 +92,7 @@ namespace loader
{
for (auto &phdr : m_phdrs)
{
switch (phdr.p_type.ToLE())
switch ((u32)phdr.p_type)
{
case 0x1: //load
if (phdr.p_memsz)
@ -127,6 +125,8 @@ namespace loader
m_stream->Seek(handler::get_stream_offset() + phdr.p_paddr.addr());
m_stream->Read(&module_info, sizeof(module_info));
LOG_ERROR(LOADER, "%s (%x):", module_info.name, (u32)module_info.toc);
info.name = std::string((const char*)module_info.name, 28);
info.rtoc = module_info.toc;
int import_count = (module_info.imports_end - module_info.imports_start) / sizeof(sys_prx_library_info_t);
@ -149,12 +149,12 @@ namespace loader
{
char name[27];
m_stream->Seek(handler::get_stream_offset() + phdr.p_offset + lib.name_addr);
modulename = std::string(name, m_stream->Read(name, sizeof(name)));
m_stream->Read(name, sizeof(name));
modulename = std::string(name);
LOG_ERROR(LOADER, "**** %s", name);
}
//ModuleManager& manager = Emu.GetModuleManager();
//Module* module = manager.GetModuleByName(modulename);
auto &module = info.modules[modulename];
LOG_ERROR(LOADER, "**** 0x%x - 0x%x - 0x%x", (u32)lib.unk4, (u32)lib.unk5, (u32)lib.unk6);
@ -167,7 +167,7 @@ namespace loader
m_stream->Seek(handler::get_stream_offset() + phdr.p_offset + lib.fstub_addr + i * sizeof(fstub));
m_stream->Read(&fstub, sizeof(fstub));
info.exports[fnid] = fstub;
module.exports[fnid] = fstub;
//LOG_NOTICE(LOADER, "Exported function '%s' in '%s' module (LLE)", SysCalls::GetHLEFuncName(fnid).c_str(), module_name.c_str());
LOG_ERROR(LOADER, "**** %s: [%s] -> 0x%x", modulename.c_str(), SysCalls::GetHLEFuncName(fnid).c_str(), (u32)fstub);
@ -201,17 +201,17 @@ namespace loader
switch ((u32)rel.type)
{
case 1:
LOG_ERROR(LOADER, "**** RELOCATION(1): 0x%x <- 0x%x", ADDR, (u32)(info.segments[rel.index_value].begin.addr() + rel.ptr.addr()));
LOG_WARNING(LOADER, "**** RELOCATION(1): 0x%x <- 0x%x", ADDR, (u32)(info.segments[rel.index_value].begin.addr() + rel.ptr.addr()));
*vm::ptr<u32>::make(ADDR) = info.segments[rel.index_value].begin.addr() + rel.ptr.addr();
break;
case 4:
LOG_ERROR(LOADER, "**** RELOCATION(4): 0x%x <- 0x%x", ADDR, (u16)(rel.ptr.addr()));
LOG_WARNING(LOADER, "**** RELOCATION(4): 0x%x <- 0x%x", ADDR, (u16)(rel.ptr.addr()));
*vm::ptr<u16>::make(ADDR) = (u16)(u64)rel.ptr.addr();
break;
case 5:
LOG_ERROR(LOADER, "**** RELOCATION(5): 0x%x <- 0x%x", ADDR, (u16)(info.segments[rel.index_value].begin.addr() >> 16));
LOG_WARNING(LOADER, "**** RELOCATION(5): 0x%x <- 0x%x", ADDR, (u16)(info.segments[rel.index_value].begin.addr() >> 16));
*vm::ptr<u16>::make(ADDR) = info.segments[rel.index_value].begin.addr() >> 16;
break;
@ -230,20 +230,23 @@ namespace loader
}
}
for (auto &e : info.exports)
for (auto &m : info.modules)
{
u32 stub = e.second;
for (auto &s : info.segments)
for (auto &e : m.second.exports)
{
if (stub >= s.initial_addr.addr() && stub < s.initial_addr.addr() + s.size_file)
{
stub += s.begin.addr() - s.initial_addr.addr();
break;
}
}
u32 stub = e.second;
e.second = stub;
for (auto &s : info.segments)
{
if (stub >= s.initial_addr.addr() && stub < s.initial_addr.addr() + s.size_file)
{
stub += s.begin.addr() - s.initial_addr.addr();
break;
}
}
e.second = stub;
}
}
return ok;
@ -266,12 +269,12 @@ namespace loader
std::vector<u32> stop_funcs;
//load modules
static const char* lle_modules[] = { "lv2", "sre", "l10n", "gcm_sys", "fs" };
//TODO: for (auto &module : lle_modules)
char* module; if (0)
vfsDir lle_dir("/dev_flash/sys/external");
for (const auto module : lle_dir)
{
elf64 sprx_handler;
vfsFile fsprx(std::string("/dev_flash/sys/external/lib") + module + ".sprx");
vfsFile fsprx(lle_dir.GetPath() + "/" + module->name);
if (fsprx.IsOpened())
{
@ -279,21 +282,52 @@ namespace loader
if (sprx_handler.is_sprx())
{
IniEntry<bool> load_lib;
load_lib.Init(sprx_handler.sprx_get_module_name(), "LLE");
if (!load_lib.LoadValue(false))
{
LOG_ERROR(LOADER, "skipped lle library '%s'", sprx_handler.sprx_get_module_name().c_str());
continue;
}
else
{
LOG_WARNING(LOADER, "loading lle library '%s'", sprx_handler.sprx_get_module_name().c_str());
}
sprx_info info;
sprx_handler.load_sprx(info);
std::unordered_map<u32, u32>::iterator f;
if ((f = info.exports.find(0xbc9a0086)) != info.exports.end())
start_funcs.push_back(f->second);
if ((f = info.exports.find(0xab779874)) != info.exports.end())
stop_funcs.push_back(f->second);
for (auto &e : info.exports)
for (auto &m : info.modules)
{
if (e.first != 0xbc9a0086 && e.first != 0xab779874)
Emu.GetModuleManager().register_function(e.first, e.second);
if (m.first == "")
{
for (auto &e : m.second.exports)
{
switch (e.first)
{
case 0xbc9a0086: start_funcs.push_back(e.second); break;
case 0xab779874: stop_funcs.push_back(e.second); break;
default: LOG_ERROR(LOADER, "unknown special func 0x%08x in '%s' library", e.first, info.name.c_str()); break;
}
}
continue;
}
Module* module = Emu.GetModuleManager().GetModuleByName(m.first);
if (!module)
{
LOG_ERROR(LOADER, "unknown module '%s' in '%s' library", m.first.c_str(), info.name.c_str());
module = new Module(-1, m.first.c_str());
}
for (auto &e : m.second.exports)
{
module->RegisterLLEFunc(e.first, vm::ptr<void(*)()>::make(e.second));
}
}
}
}
@ -469,8 +503,9 @@ namespace loader
for (u32 i = 0; i < stub->s_imports; ++i)
{
const u32 nid = stub->s_nid[i];
auto func = module ? module->GetFunc(nid) : nullptr;
if (!Emu.GetModuleManager().get_function_stub(nid, stub->s_text[i]))
if (!func || !func->lle_func)
{
dst[i] = stub_data;
@ -490,6 +525,7 @@ namespace loader
}
else
{
stub->s_text[i] = func->lle_func.addr();
//Is function auto exported, than we can use it
LOG_NOTICE(LOADER, "Imported function '%s' in '%s' module (LLE: 0x%x)", SysCalls::GetHLEFuncName(nid).c_str(), module_name.c_str(), (u32)stub->s_text[i]);
}

12
rpcs3/Loader/ELF64.h
View file

@ -131,8 +131,16 @@ namespace loader
struct sprx_info
{
std::unordered_map<u32, u32> exports;
std::unordered_map<u32, u32> imports;
std::string name;
u32 rtoc;
struct module_info
{
std::unordered_map<u32, u32> exports;
std::unordered_map<u32, u32> imports;
};
std::unordered_map<std::string, module_info> modules;
std::vector<sprx_segment_info> segments;
};

11
rpcs3/rpcs3.cpp
View file

@ -40,6 +40,8 @@ wxDEFINE_EVENT(wxEVT_DBG_COMMAND, wxCommandEvent);
IMPLEMENT_APP(Rpcs3App)
Rpcs3App* TheApp;
std::string simplify_path(const std::string& path, bool is_dir);
bool Rpcs3App::OnInit()
{
SetSendDbgCommandCallback([](DbgCommand id, CPUThread* t)
@ -128,16 +130,17 @@ bool Rpcs3App::OnInit()
wxInitAllImageHandlers();
// RPCS3 assumes the current working directory is the folder where it is contained, so we make sure this is true
const wxString executablePath = wxStandardPaths::Get().GetExecutablePath();
wxSetWorkingDirectory(wxPathOnly(executablePath));
const wxString executablePath = wxPathOnly(wxStandardPaths::Get().GetExecutablePath());
wxSetWorkingDirectory(executablePath);
main_thread = std::this_thread::get_id();
Ini.Load();
Emu.Init();
Emu.SetEmulatorPath(executablePath.ToStdString());
m_MainFrame = new MainFrame();
SetTopWindow(m_MainFrame);
Emu.Init();
m_MainFrame->Show();
m_MainFrame->DoSettings(true);