dahjah/shadPS4
1
0
Fork 0
mirror of https://github.com/shadps4-emu/shadPS4.git synced 2026-04-26 04:35:24 -06:00
Code Issues Packages Projects Releases Wiki Activity

Fixed PFS dirents returning empty on 1st entry

Browse Source 
Muted annoyances
This commit is contained in:
Marek Ledworowski 2025-11-18 21:25:30 +01:00
parent 5eb1280b05
commit ef9d91082a
3 changed files with 21 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/core/file_sys/quasifs/src/quasifs_inode_quasi_directory_pfs.cpp
View File

@ -100,9 +100,9 @@ s64 DirectoryPFS::getdents(void* buf, u32 count, s64 offset, s64* basep) {
// if this dirent breaks alignment, skip
// dirents are count-aligned here, excess data is simply not written
if (Common::AlignUp(buffer_position, count) !=
Common::AlignUp(buffer_position + pfs_dirent->d_reclen, count))
break;
// if (Common::AlignUp(buffer_position, count) !=
// Common::AlignUp(buffer_position + pfs_dirent->d_reclen, count))
// break;
// we're transposing u32 into smaller types, so there miiight be some issues
// reclen for both is the same despite difference in var sizes, extra 0s are padded after

60
src/core/libraries/kernel/file_system.cpp
View File

@ -44,9 +44,9 @@ namespace Libraries::Kernel {
static QuasiFS::QFS* g_qfs = Common::Singleton<QuasiFS::QFS>::Instance();
s32 PS4_SYSV_ABI open(const char* raw_path, s32 flags, u16 mode) {
LOG_INFO(Kernel_Fs, "path = {} flags = {:#x} mode = {:#o}", raw_path, flags, mode);
int result = g_qfs->Operation.Open(raw_path, flags, mode);
LOG_INFO(Kernel_Fs, "path = {} flags = {:#x} mode = {:#o} result = {}", raw_path, flags, mode,
result);
if (result < 0)
*__Error() = -result;
return result;
@ -67,7 +67,7 @@ s32 PS4_SYSV_ABI sceKernelOpen(const char* path, s32 flags, /* SceKernelMode*/ u
s32 PS4_SYSV_ABI close(s32 fd) {
int result = g_qfs->Operation.Close(fd);
LOG_INFO(Kernel_Fs, "fd = {} result = {}", fd, result);
if (result < 0)
*__Error() = -result;
return result;
@ -220,8 +220,8 @@ s64 PS4_SYSV_ABI sceKernelRead(s32 fd, void* buf, u64 nbytes) {
}
s32 PS4_SYSV_ABI posix_mkdir(const char* path, u16 mode) {
LOG_INFO(Kernel_Fs, "path = {} mode = {:#o}", path, mode);
int result = g_qfs->Operation.MKDir(path, mode);
LOG_INFO(Kernel_Fs, "path = {} mode = {:#o} result = {}", path, mode, result);
if (result < 0)
*__Error() = -result;
return result;
@ -260,39 +260,14 @@ s32 PS4_SYSV_ABI sceKernelRmdir(const char* path) {
}
s32 PS4_SYSV_ABI posix_stat(const char* path, OrbisKernelStat* sb) {
LOG_DEBUG(Kernel_Fs, "(PARTIAL) path = {}", path);
int result = g_qfs->Operation.Stat(path, sb);
LOG_INFO(Kernel_Fs, "path = {} result = {}", path, result);
if (result < 0) {
*__Error() = -result;
return -1;
}
return ORBIS_OK;
// const auto path_name = mnt->GetHostPath(path);
// std::memset(sb, 0, sizeof(OrbisKernelStat));
// const bool is_dir = std::filesystem::is_directory(path_name);
// const bool is_file = std::filesystem::is_regular_file(path_name);
// if (!is_dir && !is_file) {
// *__Error() = POSIX_ENOENT;
// return -1;
// }
// if (std::filesystem::is_directory(path_name)) {
// sb->st_mode = 0000777u | 0040000u;
// sb->st_size = 65536;
// sb->st_blksize = 65536;
// sb->st_blocks = 128;
// // TODO incomplete
// } else {
// sb->st_mode = 0000777u | 0100000u;
// sb->st_size = static_cast<s64>(std::filesystem::file_size(path_name));
// sb->st_blksize = 512;
// sb->st_blocks = (sb->st_size + 511) / 512;
// // TODO incomplete
// }
return ORBIS_OK;
}
s32 PS4_SYSV_ABI sceKernelStat(const char* path, OrbisKernelStat* sb) {
@ -315,9 +290,8 @@ s32 PS4_SYSV_ABI sceKernelCheckReachability(const char* path) {
}
s32 PS4_SYSV_ABI fstat(s32 fd, OrbisKernelStat* sb) {
LOG_DEBUG(Kernel_Fs, "(PARTIAL) fd = {}", fd);
int result = g_qfs->Operation.FStat(fd, sb);
LOG_INFO(Kernel_Fs, "fd = {} result = {}", fd, result);
if (result < 0) {
*__Error() = -result;
return -1;
@ -362,24 +336,6 @@ s32 PS4_SYSV_ABI fstat(s32 fd, OrbisKernelStat* sb) {
// UNREACHABLE_MSG("{}", u32(file->type.load()));
// }
// sb->st_dev = st.st_dev;
// sb->st_ino = st.st_ino;
// sb->st_mode = st.st_mode;
// sb->st_nlink = st.st_nlink;
// sb->st_uid = st.st_uid;
// sb->st_gid = st.st_gid;
// sb-> st_rdev=st.st_
// sb->st_atim = st.st_atim;
// sb->st_mtim = st.st_mtim;
// sb-> st_ctim=st.st_
// sb->st_size = st.st_size;
// sb->st_blocks = st.st_blocks;
// sb->st_blksize = st.st_blksize;
// sb->st_flags = st.st_flags;
// sb-> st_gen=st.st_
// sb-> st_lspare=st.st_
// OrbisKernelTimespec st_birthtim;
}
s32 PS4_SYSV_ABI posix_fstat(s32 fd, OrbisKernelStat* sb) {
@ -805,8 +761,8 @@ s32 PS4_SYSV_ABI posix_select(s32 nfds, fd_set_posix* readfds, fd_set_posix* wri
#else
s32 PS4_SYSV_ABI posix_select(s32 nfds, fd_set* readfds, fd_set* writefds, fd_set* exceptfds,
OrbisKernelTimeval* timeout) {
LOG_DEBUG(Kernel_Fs, "nfds = {}, readfds = {}, writefds = {}, exceptfds = {}, timeout = {}",
nfds, fmt::ptr(readfds), fmt::ptr(writefds), fmt::ptr(exceptfds), fmt::ptr(timeout));
LOG_INFO(Kernel_Fs, "nfds = {}, readfds = {}, writefds = {}, exceptfds = {}, timeout = {}",
nfds, fmt::ptr(readfds), fmt::ptr(writefds), fmt::ptr(exceptfds), fmt::ptr(timeout));
auto* h = Common::Singleton<Core::FileSys::HandleTable>::Instance();
fd_set read_host, write_host, except_host;

20
src/core/libraries/kernel/memory.cpp
View File

@ -63,10 +63,10 @@ s32 PS4_SYSV_ABI sceKernelAllocateDirectMemory(s64 searchStart, s64 searchEnd, u
*physAddrOut = static_cast<s64>(phys_addr);
LOG_INFO(Kernel_Vmm,
"searchStart = {:#x}, searchEnd = {:#x}, len = {:#x}, "
"alignment = {:#x}, memoryType = {:#x}, physAddrOut = {:#x}",
searchStart, searchEnd, len, alignment, memoryType, phys_addr);
// LOG_INFO(Kernel_Vmm,
// "searchStart = {:#x}, searchEnd = {:#x}, len = {:#x}, "
// "alignment = {:#x}, memoryType = {:#x}, physAddrOut = {:#x}",
// searchStart, searchEnd, len, alignment, memoryType, phys_addr);
return ORBIS_OK;
}
@ -123,7 +123,7 @@ s32 PS4_SYSV_ABI sceKernelAvailableDirectMemorySize(u64 searchStart, u64 searchE
s32 PS4_SYSV_ABI sceKernelVirtualQuery(const void* addr, s32 flags, OrbisVirtualQueryInfo* info,
u64 infoSize) {
LOG_INFO(Kernel_Vmm, "called addr = {}, flags = {:#x}", fmt::ptr(addr), flags);
// LOG_INFO(Kernel_Vmm, "called addr = {}, flags = {:#x}", fmt::ptr(addr), flags);
auto* memory = Core::Memory::Instance();
return memory->VirtualQuery(std::bit_cast<VAddr>(addr), flags, info);
}
@ -160,10 +160,10 @@ s32 PS4_SYSV_ABI sceKernelReserveVirtualRange(void** addr, u64 len, s32 flags, u
s32 PS4_SYSV_ABI sceKernelMapNamedDirectMemory(void** addr, u64 len, s32 prot, s32 flags,
s64 phys_addr, u64 alignment, const char* name) {
LOG_INFO(Kernel_Vmm,
"in_addr = {}, len = {:#x}, prot = {:#x}, flags = {:#x}, "
"phys_addr = {:#x}, alignment = {:#x}, name = '{}'",
fmt::ptr(*addr), len, prot, flags, phys_addr, alignment, name);
// LOG_INFO(Kernel_Vmm,
// "in_addr = {}, len = {:#x}, prot = {:#x}, flags = {:#x}, "
// "phys_addr = {:#x}, alignment = {:#x}, name = '{}'",
// fmt::ptr(*addr), len, prot, flags, phys_addr, alignment, name);
if (len == 0 || !Common::Is16KBAligned(len)) {
LOG_ERROR(Kernel_Vmm, "Map size is either zero or not 16KB aligned!");
@ -200,7 +200,7 @@ s32 PS4_SYSV_ABI sceKernelMapNamedDirectMemory(void** addr, u64 len, s32 prot, s
const auto ret = memory->MapMemory(addr, in_addr, len, mem_prot, map_flags,
Core::VMAType::Direct, name, false, phys_addr, alignment);
LOG_INFO(Kernel_Vmm, "out_addr = {}", fmt::ptr(*addr));
// LOG_INFO(Kernel_Vmm, "out_addr = {}", fmt::ptr(*addr));
return ret;
}