From fac9d74344cbe654466975ce5ca166054df6f6e1 Mon Sep 17 00:00:00 2001 From: Raul Tambre Date: Sat, 17 Oct 2015 20:47:18 +0300 Subject: [PATCH 1/4] Lots of defect fixes --- Utilities/File.cpp | 8 +- Utilities/VirtualMemory.cpp | 17 +- Utilities/VirtualMemory.h | 5 +- Utilities/rPlatform.cpp | 15 +- rpcs3/Crypto/lz.cpp | 6 + rpcs3/Crypto/unedat.cpp | 17 +- rpcs3/Crypto/unpkg.cpp | 6 +- rpcs3/Crypto/unself.cpp | 94 +++++++-- rpcs3/Crypto/utils.cpp | 1 + rpcs3/Emu/HDD/HDD.cpp | 186 ++++++++++++++---- rpcs3/Emu/HDD/HDD.h | 32 +-- rpcs3/Emu/Io/MouseHandler.h | 2 + rpcs3/Emu/Memory/MemoryBlock.h | 10 +- .../RSX/Common/FragmentProgramDecompiler.cpp | 1 + .../RSX/Common/VertexProgramDecompiler.cpp | 2 +- rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp | 10 +- rpcs3/Emu/SysCalls/Modules/cellResc.cpp | 7 +- rpcs3/Emu/SysCalls/Modules/cellSail.cpp | 3 +- rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp | 4 +- rpcs3/Gui/GSFrame.h | 2 +- rpcs3/Gui/MainFrame.cpp | 8 +- 21 files changed, 341 insertions(+), 95 deletions(-) diff --git a/Utilities/File.cpp b/Utilities/File.cpp index 8ef949a65e..7b1c3c9256 100644 --- a/Utilities/File.cpp +++ b/Utilities/File.cpp @@ -327,7 +327,13 @@ int OSCopyFile(const char* source, const char* destination, bool overwrite) //sendfile will work with non-socket output (i.e. regular file) on Linux 2.6.33+ off_t bytesCopied = 0; struct stat fileinfo = { 0 }; - fstat(input, &fileinfo); + + s32 ret = fstat(input, &fileinfo); + if (ret < 0) + { + return -1; + } + int result = sendfile(output, input, &bytesCopied, fileinfo.st_size) == -1 ? -1 : 0; #endif diff --git a/Utilities/VirtualMemory.cpp b/Utilities/VirtualMemory.cpp index 05614b714b..3aab2576b6 100644 --- a/Utilities/VirtualMemory.cpp +++ b/Utilities/VirtualMemory.cpp @@ -1,4 +1,5 @@ #include "stdafx.h" +#include "Utilities/Log.h" #include "VirtualMemory.h" #ifdef _WIN32 #include @@ -21,13 +22,23 @@ namespace memory_helper #endif } - void commit_page_memory(void* pointer, size_t page_size) + s32 commit_page_memory(void* pointer, size_t page_size) { #ifdef _WIN32 - VirtualAlloc((u8*)pointer, page_size, MEM_COMMIT, PAGE_READWRITE); + if (VirtualAlloc((u8*)pointer, page_size, MEM_COMMIT, PAGE_READWRITE) == NULL) + { + LOG_ERROR(HLE, "commit_page_memory VirtualAlloc failed."); + return -1; + } #else - mprotect((u8*)pointer, page_size, PROT_READ | PROT_WRITE); + s32 ret = mprotect((u8*)pointer, page_size, PROT_READ | PROT_WRITE) + if (ret < 0) + { + LOG_ERROR(HLE, "commit_page_memory mprotect failed. (%d)", ret); + return -1; + } #endif + return 0; } void free_reserved_memory(void* pointer, size_t size) diff --git a/Utilities/VirtualMemory.h b/Utilities/VirtualMemory.h index ecce48db2e..76181ae2e9 100644 --- a/Utilities/VirtualMemory.h +++ b/Utilities/VirtualMemory.h @@ -12,8 +12,11 @@ namespace memory_helper * Commit page_size bytes of virtual memory starting at pointer. * That is, bake reserved memory with physical memory. * pointer should belong to a range of reserved memory. + * + * Returns 0, if was successful. + * Returns -1, if was unsuccessful. */ - void commit_page_memory(void* pointer, size_t page_size); + s32 commit_page_memory(void* pointer, size_t page_size); /** * Free memory alloced via reserve_memory. diff --git a/Utilities/rPlatform.cpp b/Utilities/rPlatform.cpp index ba1bee9455..6efd198563 100644 --- a/Utilities/rPlatform.cpp +++ b/Utilities/rPlatform.cpp @@ -1,5 +1,6 @@ #include "stdafx.h" #include "restore_new.h" +#include "Utilities/Log.h" #pragma warning(push) #pragma message("TODO: remove wx dependency: ") #pragma warning(disable : 4996) @@ -42,7 +43,8 @@ void rImage::SaveFile(const std::string& name, rImageType type) std::string rPlatform::getConfigDir() { static std::string dir = "."; - if (dir == ".") { + if (dir == ".") + { #ifdef _WIN32 dir = ""; //mkdir(dir.c_str()); @@ -54,7 +56,16 @@ std::string rPlatform::getConfigDir() else // Just in case dir = "./config"; dir = dir + "/rpcs3/"; - mkdir(dir.c_str(), 0777); + + s32 ret = mkdir(dir.c_str(), 0777) + if (ret == EEXIST) + { + LOG_WARNING(HLE, "Configuration directory already exists. (%s)", dir); + } + else if (ret < 0) + { + LOG_ERROR(HLE, "An error occured during the creation of the configuration directory. (%d)", ret); + } #endif } return dir; diff --git a/rpcs3/Crypto/lz.cpp b/rpcs3/Crypto/lz.cpp index f28431fc6e..e2290e3793 100644 --- a/rpcs3/Crypto/lz.cpp +++ b/rpcs3/Crypto/lz.cpp @@ -253,11 +253,17 @@ int decompress(unsigned char *out, unsigned char *in, unsigned int size) // Underflow. if (buf_start < out) + { + delete[] tmp; return -1; + } // Overflow. if (buf_end > end) + { + delete[] tmp; return -1; + } // Update offset. offset = ((((int)(buf_end - out)) + 1) & 1) + 6; diff --git a/rpcs3/Crypto/unedat.cpp b/rpcs3/Crypto/unedat.cpp index de43050ab5..38f9de8c76 100644 --- a/rpcs3/Crypto/unedat.cpp +++ b/rpcs3/Crypto/unedat.cpp @@ -291,7 +291,10 @@ int decrypt_data(const fs::file* in, const fs::file* out, EDAT_HEADER *edat, NPD { if (verbose) LOG_WARNING(LOADER, "EDAT: Block at offset 0x%llx has invalid hash!", (u64)offset); - + + delete[] enc_data; + delete[] dec_data; + delete[] b_key; return 1; } } @@ -337,6 +340,7 @@ int decrypt_data(const fs::file* in, const fs::file* out, EDAT_HEADER *edat, NPD delete[] enc_data; delete[] dec_data; + delete[] b_key; } return 0; @@ -389,7 +393,11 @@ int check_data(unsigned char *key, EDAT_HEADER *edat, NPD_HEADER *npd, const fs: f->read(header, 0xA0); // Read in the header and metadata section hashes. - f->seek(0x90); + if (f->seek(0x90) < 0) + { + LOG_ERROR(LOADER, "EDAT: Seeking header at 0x90 failed."); + } + f->read(metadata_hash, 0x10); f->read(header_hash, 0x10); @@ -445,7 +453,10 @@ int check_data(unsigned char *key, EDAT_HEADER *edat, NPD_HEADER *npd, const fs: while (bytes_to_read > 0) { // Locate the metadata blocks. - f->seek(metadata_section_offset); + if (f->seek(metadata_section_offset) < 0) + { + LOG_ERROR(LOADER, "EDAT: Seeking metadata blocks at %u failed.", metadata_section_offset); + } // Read in the metadata. f->read(metadata + bytes_read, metadata_section_size); diff --git a/rpcs3/Crypto/unpkg.cpp b/rpcs3/Crypto/unpkg.cpp index b2400f509a..fd8a899d7f 100644 --- a/rpcs3/Crypto/unpkg.cpp +++ b/rpcs3/Crypto/unpkg.cpp @@ -86,7 +86,11 @@ bool UnpackPKG(const fs::file& pkg_f, const std::string& dir, volatile f64& prog // Define decryption subfunction (`psp` arg selects the key for specific block) auto decrypt = [&](u64 offset, u64 size, bool psp) -> u64 { - pkg_f.seek(start_offset + header.data_offset + offset); + if (pkg_f.seek(start_offset + header.data_offset + offset) < 0) + { + LOG_ERROR(LOADER, "PKG: Package file seek to %u failed.", start_offset + header.data_offset + offset); + return -1; + } // Read the data and set available size const u64 read = pkg_f.read(buf.get(), size); diff --git a/rpcs3/Crypto/unself.cpp b/rpcs3/Crypto/unself.cpp index 6f8533c096..7d879e5919 100644 --- a/rpcs3/Crypto/unself.cpp +++ b/rpcs3/Crypto/unself.cpp @@ -890,7 +890,7 @@ bool SELFDecrypter::DecryptNPDRM(u8 *metadata, u32 metadata_size) memcpy(klicensee_key, key_v.GetKlicenseeKey(), 0x10); // Use klicensee if available. - if (klicensee_key != NULL) + if (memcmp(klicensee_key, key_v.GetKlicenseeKey(), 0x10) != 0) memcpy(npdrm_key, klicensee_key, 0x10); if (ctrl->npdrm.license == 1) // Network license. @@ -1077,7 +1077,7 @@ bool SELFDecrypter::MakeElf(const std::string& elf, bool isElf32) { // Create a new ELF file. fs::file e(elf, fom::write | fom::create | fom::trunc); - if(!e) + if (!e) { LOG_ERROR(LOADER, "Could not create ELF file! (%s)", elf.c_str()); return false; @@ -1092,8 +1092,10 @@ bool SELFDecrypter::MakeElf(const std::string& elf, bool isElf32) WriteEhdr(e, elf32_hdr); // Write program headers. - for(u32 i = 0; i < elf32_hdr.e_phnum; ++i) + for (u32 i = 0; i < elf32_hdr.e_phnum; ++i) + { WritePhdr(e, phdr32_arr[i]); + } for (unsigned int i = 0; i < meta_hdr.section_count; i++) { @@ -1101,7 +1103,12 @@ bool SELFDecrypter::MakeElf(const std::string& elf, bool isElf32) if (meta_shdr[i].type == 2) { // Seek to the program header data offset and write the data. - e.seek(phdr32_arr[meta_shdr[i].program_idx].p_offset); + if (e.seek(phdr32_arr[meta_shdr[i].program_idx].p_offset) < 0) + { + LOG_ERROR(LOADER, "MakeElf program header data seek to %u failed.", phdr32_arr[meta_shdr[i].program_idx].p_offset); + return false; + } + e.write(data_buf + data_buf_offset, meta_shdr[i].data_size); // Advance the data buffer offset by data size. @@ -1110,12 +1117,18 @@ bool SELFDecrypter::MakeElf(const std::string& elf, bool isElf32) } // Write section headers. - if(self_hdr.se_shdroff != 0) + if (self_hdr.se_shdroff != 0) { - e.seek(elf32_hdr.e_shoff); + if (e.seek(elf32_hdr.e_shoff) < 0) + { + LOG_ERROR(LOADER, "MakeElf section header seek to %u failed.", elf32_hdr.e_shoff); + return false; + } - for(u32 i = 0; i < elf32_hdr.e_shnum; ++i) + for (u32 i = 0; i < elf32_hdr.e_shnum; ++i) + { WriteShdr(e, shdr32_arr[i]); + } } } else @@ -1124,8 +1137,10 @@ bool SELFDecrypter::MakeElf(const std::string& elf, bool isElf32) WriteEhdr(e, elf64_hdr); // Write program headers. - for(u32 i = 0; i < elf64_hdr.e_phnum; ++i) + for (u32 i = 0; i < elf64_hdr.e_phnum; ++i) + { WritePhdr(e, phdr64_arr[i]); + } // Write data. for (unsigned int i = 0; i < meta_hdr.section_count; i++) @@ -1152,7 +1167,12 @@ bool SELFDecrypter::MakeElf(const std::string& elf, bool isElf32) decomp_stream_out.CopyTo(decomp_buf, phdr64_arr[meta_shdr[i].program_idx].p_filesz); // Seek to the program header data offset and write the data. - e.seek(phdr64_arr[meta_shdr[i].program_idx].p_offset); + if (e.seek(phdr64_arr[meta_shdr[i].program_idx].p_offset) < 0) + { + LOG_ERROR(LOADER, "MakeElf program header data seek to %u failed.", phdr64_arr[meta_shdr[i].program_idx].p_offset); + return false; + } + e.write(decomp_buf, phdr64_arr[meta_shdr[i].program_idx].p_filesz); // Release the decompression buffer. @@ -1161,7 +1181,12 @@ bool SELFDecrypter::MakeElf(const std::string& elf, bool isElf32) else { // Seek to the program header data offset and write the data. - e.seek(phdr64_arr[meta_shdr[i].program_idx].p_offset); + if (e.seek(phdr64_arr[meta_shdr[i].program_idx].p_offset) < 0) + { + LOG_ERROR(LOADER, "MakeElf program header data seek to %u failed.", phdr64_arr[meta_shdr[i].program_idx].p_offset); + return false; + } + e.write(data_buf + data_buf_offset, meta_shdr[i].data_size); } @@ -1171,12 +1196,18 @@ bool SELFDecrypter::MakeElf(const std::string& elf, bool isElf32) } // Write section headers. - if(self_hdr.se_shdroff != 0) + if (self_hdr.se_shdroff != 0) { - e.seek(elf64_hdr.e_shoff); + if (e.seek(elf64_hdr.e_shoff) < 0) + { + LOG_ERROR(LOADER, "MakeElf section header seek to %u failed.", elf64_hdr.e_shoff); + return false; + } - for(u32 i = 0; i < elf64_hdr.e_shnum; ++i) + for (u32 i = 0; i < elf64_hdr.e_shnum; ++i) + { WriteShdr(e, shdr64_arr[i]); + } } } @@ -1246,7 +1277,13 @@ bool IsSelfElf32(const std::string& path) // Locate the class byte and check it. u8 elf_class[0x8]; - f.Seek(sh.se_elfoff); + + if (f.Seek(sh.se_elfoff) < 0) + { + LOG_ERROR(LOADER, "IsSelfElf32 seek to %u failed.", sh.se_elfoff); + return false; + } + f.Read(elf_class, 0x8); return (elf_class[4] == 1); @@ -1257,34 +1294,49 @@ bool CheckDebugSelf(const std::string& self, const std::string& elf) // Open the SELF file. fs::file s(self); - if(!s) + if (!s) { LOG_ERROR(LOADER, "Could not open SELF file! (%s)", self.c_str()); return false; } // Get the key version. - s.seek(0x08); + if (s.seek(0x08) < 0) + { + LOG_ERROR(LOADER, "Seeking debug (S)ELF at 0x08 failed."); + return false; + } + u16 key_version; s.read(&key_version, sizeof(key_version)); // Check for DEBUG version. - if(swap16(key_version) == 0x8000) + if (swap16(key_version) == 0x8000) { LOG_WARNING(LOADER, "Debug SELF detected! Removing fake header..."); // Get the real elf offset. - s.seek(0x10); + if (s.seek(0x10) < 0) + { + LOG_ERROR(LOADER, "Seeking debug (S)ELF at 0x10 failed."); + return false; + } + u64 elf_offset; s.read(&elf_offset, sizeof(elf_offset)); // Start at the real elf offset. elf_offset = swap64(elf_offset); - s.seek(elf_offset); + + if (s.seek(elf_offset) < 0) + { + LOG_ERROR(LOADER, "Seeking debug (S)ELF at %u failed.", elf_offset); + return false; + } // Write the real ELF file back. fs::file e(elf, fom::write | fom::create | fom::trunc); - if(!e) + if (!e) { LOG_ERROR(LOADER, "Could not create ELF file! (%s)", elf.c_str()); return false; @@ -1293,7 +1345,9 @@ bool CheckDebugSelf(const std::string& self, const std::string& elf) // Copy the data. char buf[2048]; while (ssize_t size = s.read(buf, 2048)) + { e.write(buf, size); + } return true; } diff --git a/rpcs3/Crypto/utils.cpp b/rpcs3/Crypto/utils.cpp index 2cba01afb8..079d84edae 100644 --- a/rpcs3/Crypto/utils.cpp +++ b/rpcs3/Crypto/utils.cpp @@ -96,6 +96,7 @@ void hex_to_bytes(unsigned char *data, const char *hex_str, unsigned int str_len // Copy back to our array. memcpy(data, out, data_length); + free(out); } } diff --git a/rpcs3/Emu/HDD/HDD.cpp b/rpcs3/Emu/HDD/HDD.cpp index 0faf654618..719f2fdcd8 100644 --- a/rpcs3/Emu/HDD/HDD.cpp +++ b/rpcs3/Emu/HDD/HDD.cpp @@ -19,7 +19,7 @@ void vfsHDDManager::CreateEntry(vfsHDD_Entry& entry) CreateBlock(entry); } -void vfsHDDManager::CreateHDD(const std::string& path, u64 size, u64 block_size) +s32 vfsHDDManager::CreateHDD(const std::string& path, u64 size, u64 block_size) { fs::file f(path, fom::write | fom::create | fom::trunc); @@ -47,8 +47,16 @@ void vfsHDDManager::CreateHDD(const std::string& path, u64 size, u64 block_size) } u8 null = 0; - f.seek(hdr.block_count * hdr.block_size - sizeof(null)); + + if (f.seek(hdr.block_count * hdr.block_size - sizeof(null)) < 0) + { + LOG_ERROR(HLE, "CreateHDD seek to %u failed.", hdr.block_count * hdr.block_size - sizeof(null)); + return -1; + } + f.write(&null, sizeof(null)); + + return 0; } void vfsHDDManager::Format() @@ -99,50 +107,99 @@ void vfsHDDFile::RemoveBlocks(u64 start_block) } } -void vfsHDDFile::WriteBlock(u64 block, const vfsHDD_Block& data) +s32 vfsHDDFile::WriteBlock(u64 block, const vfsHDD_Block& data) { - m_hdd.Seek(block * m_hdd_info.block_size); + if (m_hdd.Seek(block * m_hdd_info.block_size) < 0) + { + LOG_ERROR(HLE, "WriteBlock seek to %u failed.", block * m_hdd_info.block_size); + return -1; + } + m_hdd.Write(&data, sizeof(vfsHDD_Block)); + + return 0; } -void vfsHDDFile::ReadBlock(u64 block, vfsHDD_Block& data) +s32 vfsHDDFile::ReadBlock(u64 block, vfsHDD_Block& data) { - m_hdd.Seek(block * m_hdd_info.block_size); + if (m_hdd.Seek(block * m_hdd_info.block_size) < 0) + { + LOG_ERROR(HLE, "ReadBlock seek to %u failed.", block * m_hdd_info.block_size); + return -1; + } + m_hdd.Read(&data, sizeof(vfsHDD_Block)); + + return 0; } -void vfsHDDFile::WriteEntry(u64 block, const vfsHDD_Entry& data) +s32 vfsHDDFile::WriteEntry(u64 block, const vfsHDD_Entry& data) { - m_hdd.Seek(block * m_hdd_info.block_size); + if (m_hdd.Seek(block * m_hdd_info.block_size) < 0) + { + LOG_ERROR(HLE, "WriteEntry seek to %u failed.", block * m_hdd_info.block_size); + return -1; + } + m_hdd.Write(&data, sizeof(vfsHDD_Entry)); + + return 0; } -void vfsHDDFile::ReadEntry(u64 block, vfsHDD_Entry& data) +s32 vfsHDDFile::ReadEntry(u64 block, vfsHDD_Entry& data) { - m_hdd.Seek(block * m_hdd_info.block_size); + if (m_hdd.Seek(block * m_hdd_info.block_size) < 0) + { + LOG_ERROR(HLE, "ReadEntry seek to %u failed.", block * m_hdd_info.block_size); + return -1; + } + m_hdd.Read(&data, sizeof(vfsHDD_Entry)); + + return 0; } -void vfsHDDFile::ReadEntry(u64 block, vfsHDD_Entry& data, std::string& name) +s32 vfsHDDFile::ReadEntry(u64 block, vfsHDD_Entry& data, std::string& name) { - m_hdd.Seek(block * m_hdd_info.block_size); + if (m_hdd.Seek(block * m_hdd_info.block_size) < 0) + { + LOG_ERROR(HLE, "ReadEntry seek to %u failed.", block * m_hdd_info.block_size); + return -1; + } + m_hdd.Read(&data, sizeof(vfsHDD_Entry)); name.resize(GetMaxNameLen()); m_hdd.Read(&name.front(), GetMaxNameLen()); + + return 0; } -void vfsHDDFile::ReadEntry(u64 block, std::string& name) +s32 vfsHDDFile::ReadEntry(u64 block, std::string& name) { - m_hdd.Seek(block * m_hdd_info.block_size + sizeof(vfsHDD_Entry)); + if (m_hdd.Seek(block * m_hdd_info.block_size + sizeof(vfsHDD_Entry)) < 0) + { + LOG_ERROR(HLE, "ReadEntry seek to %u failed.", block * m_hdd_info.block_size + sizeof(vfsHDD_Entry)); + return -1; + } + name.resize(GetMaxNameLen()); m_hdd.Read(&name.front(), GetMaxNameLen()); + + return 0; } -void vfsHDDFile::WriteEntry(u64 block, const vfsHDD_Entry& data, const std::string& name) +s32 vfsHDDFile::WriteEntry(u64 block, const vfsHDD_Entry& data, const std::string& name) { - m_hdd.Seek(block * m_hdd_info.block_size); + if (m_hdd.Seek(block * m_hdd_info.block_size) < 0) + { + LOG_ERROR(HLE, "WriteEntry seek to %u failed.", block * m_hdd_info.block_size); + return -1; + } + m_hdd.Write(&data, sizeof(vfsHDD_Entry)); m_hdd.Write(name.c_str(), std::min(GetMaxNameLen() - 1, name.length() + 1)); + + return 0; } void vfsHDDFile::Open(u64 info_block) @@ -361,7 +418,13 @@ vfsHDD::vfsHDD(vfsDevice* device, const std::string& hdd_path) LOG_ERROR(HLE, "Bad block size!"); m_hdd_info.block_size = 2048; } - m_hdd_file.Seek(m_cur_dir_block * m_hdd_info.block_size); + + if (m_hdd_file.Seek(m_cur_dir_block * m_hdd_info.block_size) < 0) + { + LOG_ERROR(HLE, "vfsHDD initialization seek to %u failed.", m_cur_dir_block * m_hdd_info.block_size); + return; + } + m_hdd_file.Read(&m_cur_dir, sizeof(vfsHDD_Entry)); } @@ -392,14 +455,22 @@ bool vfsHDD::SearchEntry(const std::string& name, u64& entry_block, u64* parent_ return false; } -int vfsHDD::OpenDir(const std::string& name) +s32 vfsHDD::OpenDir(const std::string& name) { LOG_WARNING(HLE, "OpenDir(%s)", name.c_str()); u64 entry_block; if (!SearchEntry(name, entry_block)) + { + LOG_ERROR(HLE, "OpenDir could not find the entry. (%s)", name); return -1; + } - m_hdd_file.Seek(entry_block * m_hdd_info.block_size); + if (m_hdd_file.Seek(entry_block * m_hdd_info.block_size) < 0) + { + LOG_ERROR(HLE, "OpenDir seek to %u failed.", entry_block * m_hdd_info.block_size); + return -1; + } + vfsHDD_Entry entry; m_hdd_file.Read(&entry, sizeof(vfsHDD_Entry)); if (entry.type == vfsHDD_Entry_File) @@ -443,50 +514,99 @@ u64 vfsHDD::FindFreeBlock() return 0; } -void vfsHDD::WriteBlock(u64 block, const vfsHDD_Block& data) +s32 vfsHDD::WriteBlock(u64 block, const vfsHDD_Block& data) { - m_hdd_file.Seek(block * m_hdd_info.block_size); + if (m_hdd_file.Seek(block * m_hdd_info.block_size) < 0) + { + LOG_ERROR(HLE, "WriteBlock seek to %u failed.", block * m_hdd_info.block_size); + return -1; + } + m_hdd_file.Write(&data, sizeof(vfsHDD_Block)); + + return 0; } -void vfsHDD::ReadBlock(u64 block, vfsHDD_Block& data) +s32 vfsHDD::ReadBlock(u64 block, vfsHDD_Block& data) { - m_hdd_file.Seek(block * m_hdd_info.block_size); + if (m_hdd_file.Seek(block * m_hdd_info.block_size) < 0) + { + LOG_ERROR(HLE, "ReadBlock seek to %u failed.", block * m_hdd_info.block_size); + return -1; + } + m_hdd_file.Read(&data, sizeof(vfsHDD_Block)); + + return 0; } -void vfsHDD::WriteEntry(u64 block, const vfsHDD_Entry& data) +s32 vfsHDD::WriteEntry(u64 block, const vfsHDD_Entry& data) { - m_hdd_file.Seek(block * m_hdd_info.block_size); + if (m_hdd_file.Seek(block * m_hdd_info.block_size) < 0) + { + LOG_ERROR(HLE, "WriteEntry seek to %u failed.", block * m_hdd_info.block_size); + return -1; + } + m_hdd_file.Write(&data, sizeof(vfsHDD_Entry)); + + return 0; } -void vfsHDD::ReadEntry(u64 block, vfsHDD_Entry& data) +s32 vfsHDD::ReadEntry(u64 block, vfsHDD_Entry& data) { - m_hdd_file.Seek(block * m_hdd_info.block_size); + if (m_hdd_file.Seek(block * m_hdd_info.block_size) < 0) + { + LOG_ERROR(HLE, "ReadEntry seek to %u failed.", block * m_hdd_info.block_size); + return -1; + } + m_hdd_file.Read(&data, sizeof(vfsHDD_Entry)); + + return 0; } -void vfsHDD::ReadEntry(u64 block, vfsHDD_Entry& data, std::string& name) +s32 vfsHDD::ReadEntry(u64 block, vfsHDD_Entry& data, std::string& name) { - m_hdd_file.Seek(block * m_hdd_info.block_size); + if (m_hdd_file.Seek(block * m_hdd_info.block_size) < 0) + { + LOG_ERROR(HLE, "ReadEntry seek to %u failed.", block * m_hdd_info.block_size); + return -1; + } + m_hdd_file.Read(&data, sizeof(vfsHDD_Entry)); name.resize(GetMaxNameLen()); m_hdd_file.Read(&name.front(), GetMaxNameLen()); + + return 0; } -void vfsHDD::ReadEntry(u64 block, std::string& name) +s32 vfsHDD::ReadEntry(u64 block, std::string& name) { - m_hdd_file.Seek(block * m_hdd_info.block_size + sizeof(vfsHDD_Entry)); + if (m_hdd_file.Seek(block * m_hdd_info.block_size + sizeof(vfsHDD_Entry)) < 0) + { + LOG_ERROR(HLE, "ReadEntry seek to %u failed.", block * m_hdd_info.block_size + sizeof(vfsHDD_Entry)); + return -1; + } + name.resize(GetMaxNameLen()); m_hdd_file.Read(&name.front(), GetMaxNameLen()); + + return 0; } -void vfsHDD::WriteEntry(u64 block, const vfsHDD_Entry& data, const std::string& name) +s32 vfsHDD::WriteEntry(u64 block, const vfsHDD_Entry& data, const std::string& name) { - m_hdd_file.Seek(block * m_hdd_info.block_size); + if (m_hdd_file.Seek(block * m_hdd_info.block_size) < 0) + { + LOG_ERROR(HLE, "WriteEntry seek to %u failed.", block * m_hdd_info.block_size); + return -1; + } + m_hdd_file.Write(&data, sizeof(vfsHDD_Entry)); m_hdd_file.Write(name.c_str(), std::min(GetMaxNameLen() - 1, name.length() + 1)); + + return 0; } bool vfsHDD::Create(vfsHDD_EntryType type, const std::string& name) diff --git a/rpcs3/Emu/HDD/HDD.h b/rpcs3/Emu/HDD/HDD.h index 5a81b3ea5a..a50fca669c 100644 --- a/rpcs3/Emu/HDD/HDD.h +++ b/rpcs3/Emu/HDD/HDD.h @@ -47,7 +47,7 @@ public: static void CreateEntry(vfsHDD_Entry& entry); - static void CreateHDD(const std::string& path, u64 size, u64 block_size); + static s32 CreateHDD(const std::string& path, u64 size, u64 block_size); void Format(); @@ -68,19 +68,19 @@ class vfsHDDFile void RemoveBlocks(u64 start_block); - void WriteBlock(u64 block, const vfsHDD_Block& data); + s32 WriteBlock(u64 block, const vfsHDD_Block& data); - void ReadBlock(u64 block, vfsHDD_Block& data); + s32 ReadBlock(u64 block, vfsHDD_Block& data); - void WriteEntry(u64 block, const vfsHDD_Entry& data); + s32 WriteEntry(u64 block, const vfsHDD_Entry& data); - void ReadEntry(u64 block, vfsHDD_Entry& data); + s32 ReadEntry(u64 block, vfsHDD_Entry& data); - void ReadEntry(u64 block, vfsHDD_Entry& data, std::string& name); + s32 ReadEntry(u64 block, vfsHDD_Entry& data, std::string& name); - void ReadEntry(u64 block, std::string& name); + s32 ReadEntry(u64 block, std::string& name); - void WriteEntry(u64 block, const vfsHDD_Entry& data, const std::string& name); + s32 WriteEntry(u64 block, const vfsHDD_Entry& data, const std::string& name); force_inline u32 GetMaxNameLen() const { @@ -156,25 +156,25 @@ public: bool SearchEntry(const std::string& name, u64& entry_block, u64* parent_block = nullptr); - int OpenDir(const std::string& name); + s32 OpenDir(const std::string& name); bool Rename(const std::string& from, const std::string& to); u64 FindFreeBlock(); - void WriteBlock(u64 block, const vfsHDD_Block& data); + s32 WriteBlock(u64 block, const vfsHDD_Block& data); - void ReadBlock(u64 block, vfsHDD_Block& data); + s32 ReadBlock(u64 block, vfsHDD_Block& data); - void WriteEntry(u64 block, const vfsHDD_Entry& data); + s32 WriteEntry(u64 block, const vfsHDD_Entry& data); - void ReadEntry(u64 block, vfsHDD_Entry& data); + s32 ReadEntry(u64 block, vfsHDD_Entry& data); - void ReadEntry(u64 block, vfsHDD_Entry& data, std::string& name); + s32 ReadEntry(u64 block, vfsHDD_Entry& data, std::string& name); - void ReadEntry(u64 block, std::string& name); + s32 ReadEntry(u64 block, std::string& name); - void WriteEntry(u64 block, const vfsHDD_Entry& data, const std::string& name); + s32 WriteEntry(u64 block, const vfsHDD_Entry& data, const std::string& name); bool Create(vfsHDD_EntryType type, const std::string& name); diff --git a/rpcs3/Emu/Io/MouseHandler.h b/rpcs3/Emu/Io/MouseHandler.h index 2e6167b676..9eba9c6ba0 100644 --- a/rpcs3/Emu/Io/MouseHandler.h +++ b/rpcs3/Emu/Io/MouseHandler.h @@ -92,6 +92,8 @@ struct Mouse : m_data() , m_rawdata() { + x_pos = 0; + y_pos = 0; } }; diff --git a/rpcs3/Emu/Memory/MemoryBlock.h b/rpcs3/Emu/Memory/MemoryBlock.h index 75a1cc8b52..1f1df7d848 100644 --- a/rpcs3/Emu/Memory/MemoryBlock.h +++ b/rpcs3/Emu/Memory/MemoryBlock.h @@ -1,5 +1,7 @@ #pragma once +#include "Utilities/Log.h" + struct MemInfo { u32 addr; @@ -82,7 +84,13 @@ public: u32 RealAddr(u32 addr) { u32 realAddr = 0; - getRealAddr(addr, realAddr); + + if (!getRealAddr(addr, realAddr)) + { + LOG_ERROR(HLE, "Getting the real address failed. (addr=%u)", addr); + return 0; + } + return realAddr; } diff --git a/rpcs3/Emu/RSX/Common/FragmentProgramDecompiler.cpp b/rpcs3/Emu/RSX/Common/FragmentProgramDecompiler.cpp index 4829fc0747..e8348420c3 100644 --- a/rpcs3/Emu/RSX/Common/FragmentProgramDecompiler.cpp +++ b/rpcs3/Emu/RSX/Common/FragmentProgramDecompiler.cpp @@ -291,6 +291,7 @@ template std::string FragmentProgramDecompiler::GetSRC(T src) case 3: // ??? Used by a few games, what is it? LOG_ERROR(RSX, "Src type 3 used, please report this to a developer."); + break; default: LOG_ERROR(RSX, "Bad src type %d", u32{ src.reg_type }); diff --git a/rpcs3/Emu/RSX/Common/VertexProgramDecompiler.cpp b/rpcs3/Emu/RSX/Common/VertexProgramDecompiler.cpp index dd47e05978..585931c544 100644 --- a/rpcs3/Emu/RSX/Common/VertexProgramDecompiler.cpp +++ b/rpcs3/Emu/RSX/Common/VertexProgramDecompiler.cpp @@ -108,7 +108,7 @@ std::string VertexProgramDecompiler::GetSRC(const u32 n) if (swizzle != f) ret += '.' + swizzle; - bool abs; + bool abs = false; switch (n) { diff --git a/rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp b/rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp index ec9b8de301..6a212017ff 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp @@ -123,7 +123,7 @@ s32 cellNetCtlGetInfo(s32 code, vm::ptr info) free(pAddresses); #else struct ifaddrs *ifaddr, *ifa; - int family, n; + s32 family, n; if (getifaddrs(&ifaddr) == -1) { @@ -146,9 +146,7 @@ s32 cellNetCtlGetInfo(s32 code, vm::ptr info) if (family == AF_INET) { - s32 fd, status; - - fd = open("/proc/net/dev", O_RDONLY); + u32 fd = open("/proc/net/dev", O_RDONLY); struct ifreq freq; if (ioctl(fd, SIOCGIFMTU, &freq) == -1) @@ -212,7 +210,7 @@ s32 cellNetCtlGetInfo(s32 code, vm::ptr info) free(pAdapterInfo); #else struct ifaddrs *ifaddr, *ifa; - int family, n; + s32 family, n; if (getifaddrs(&ifaddr) == -1) { @@ -293,7 +291,7 @@ s32 cellNetCtlGetInfo(s32 code, vm::ptr info) free(pAdapterInfo); #else struct ifaddrs *ifaddr, *ifa; - int family, n; + s32 family, n; if (getifaddrs(&ifaddr) == -1) { diff --git a/rpcs3/Emu/SysCalls/Modules/cellResc.cpp b/rpcs3/Emu/SysCalls/Modules/cellResc.cpp index 6d47658569..7d77a9adb2 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellResc.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellResc.cpp @@ -344,14 +344,17 @@ s32 CalculateSurfaceByteSize(u32 mode, CellRescDsts *dsts) s32 CalculateMaxColorBuffersSize() { - s32 oneBufSize, bufNum, totalBufSize, maxBufSize; + s32 index, oneBufSize, bufNum, totalBufSize, maxBufSize; maxBufSize = 0; for (u32 bufMode = CELL_RESC_720x480; bufMode <= CELL_RESC_1920x1080; bufMode <<= 1) { if (s_rescInternalInstance->m_initConfig.supportModes & bufMode) { - oneBufSize = CalculateSurfaceByteSize(bufMode, &(s_rescInternalInstance->m_rescDsts[GetRescDestsIndex(bufMode)])); + if ((index = GetRescDestsIndex(bufMode)) != 0) + { + oneBufSize = CalculateSurfaceByteSize(bufMode, &(s_rescInternalInstance->m_rescDsts[index])); + } bufNum = cellRescGetNumColorBuffers(bufMode, s_rescInternalInstance->m_initConfig.palTemporalMode, 0); totalBufSize = oneBufSize * bufNum; maxBufSize = (maxBufSize > totalBufSize) ? maxBufSize : totalBufSize; diff --git a/rpcs3/Emu/SysCalls/Modules/cellSail.cpp b/rpcs3/Emu/SysCalls/Modules/cellSail.cpp index 1699b7ebb5..f9a28b7bd6 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellSail.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellSail.cpp @@ -866,7 +866,8 @@ s32 cellSailPlayerRemoveDescriptor(vm::ptr pSelf, vm::ptrdescriptors > 0) { ppDesc = pSelf->registeredDescriptors[pSelf->descriptors]; - delete &pSelf->registeredDescriptors[pSelf->descriptors]; + // TODO: Figure out how properly free a descriptor. Use game specified memory dealloc function? + //delete &pSelf->registeredDescriptors[pSelf->descriptors]; pSelf->descriptors--; } diff --git a/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp b/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp index d99d2a9545..6fa6b7ab35 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp @@ -224,8 +224,8 @@ s32 cellSysCacheMount(vm::ptr param) cellSysutil.Warning("cellSysCacheMount(param=*0x%x)", param); // TODO: implement - char id[CELL_SYSCACHE_ID_SIZE]; - strncpy(id, param->cacheId, CELL_SYSCACHE_ID_SIZE); + char id[CELL_SYSCACHE_ID_SIZE] = { '\0' }; + strncpy(id, param->cacheId, CELL_SYSCACHE_ID_SIZE - 1); strncpy(param->getCachePath, ("/dev_hdd1/cache/"s + id + "/").c_str(), CELL_SYSCACHE_PATH_MAX); param->getCachePath[CELL_SYSCACHE_PATH_MAX - 1] = '\0'; Emu.GetVFS().CreateDir(param->getCachePath); diff --git a/rpcs3/Gui/GSFrame.h b/rpcs3/Gui/GSFrame.h index b39ff860fe..4fa0f52560 100644 --- a/rpcs3/Gui/GSFrame.h +++ b/rpcs3/Gui/GSFrame.h @@ -3,7 +3,7 @@ class GSFrame : public wxFrame, public GSFrameBase { - u64 m_frames; + u64 m_frames = 0; public: GSFrame(const wxString& title); diff --git a/rpcs3/Gui/MainFrame.cpp b/rpcs3/Gui/MainFrame.cpp index 46158a53df..16ef7877b9 100644 --- a/rpcs3/Gui/MainFrame.cpp +++ b/rpcs3/Gui/MainFrame.cpp @@ -262,7 +262,13 @@ void MainFrame::InstallPkg(wxCommandEvent& WXUNUSED(event)) // Fetch title ID from the header char title_id[10] = "?????????"; - pkg_f.seek(55); + + if (!pkg_f.seek(55)) + { + LOG_ERROR(LOADER, "PKG: Failed to seek offset 55."); + return; + } + pkg_f.read(title_id, 9); pkg_f.seek(0); From 9c2f48cd1d0a48712fc978cf21e5ec6c9149fa02 Mon Sep 17 00:00:00 2001 From: Raul Tambre Date: Fri, 23 Oct 2015 17:42:34 +0300 Subject: [PATCH 2/4] More defect fixes, added some error codes --- Utilities/VirtualMemory.cpp | 39 ++++-- Utilities/VirtualMemory.h | 19 ++- Utilities/rPlatform.cpp | 2 +- rpcs3/Crypto/unedat.cpp | 17 ++- rpcs3/Crypto/unself.cpp | 5 +- rpcs3/Emu/HDD/HDD.cpp | 178 +++++++++++++++--------- rpcs3/Emu/HDD/HDD.h | 10 +- rpcs3/Emu/RSX/CgBinaryVertexProgram.cpp | 2 +- rpcs3/Emu/System.cpp | 2 + 9 files changed, 190 insertions(+), 84 deletions(-) diff --git a/Utilities/VirtualMemory.cpp b/Utilities/VirtualMemory.cpp index 3aab2576b6..b018bb2e1f 100644 --- a/Utilities/VirtualMemory.cpp +++ b/Utilities/VirtualMemory.cpp @@ -16,10 +16,20 @@ namespace memory_helper void* reserve_memory(size_t size) { #ifdef _WIN32 - return VirtualAlloc(NULL, size, MEM_RESERVE, PAGE_NOACCESS); + void* ret = VirtualAlloc(NULL, size, MEM_RESERVE, PAGE_NOACCESS); + if (ret == NULL) + { + LOG_ERROR(HLE, "reserve_memory VirtualAlloc failed."); + return (void*)VM_FAILURE; + } #else - return mmap(nullptr, size, PROT_NONE, MAP_ANON | MAP_PRIVATE, -1, 0); + void* ret = mmap(nullptr, size, PROT_NONE, MAP_ANON | MAP_PRIVATE, -1, 0); + if (ret == (void*)VM_FAILURE) + { + LOG_ERROR(HLE, "reserve_memory mmap failed."); + } #endif + return ret; } s32 commit_page_memory(void* pointer, size_t page_size) @@ -28,25 +38,34 @@ namespace memory_helper if (VirtualAlloc((u8*)pointer, page_size, MEM_COMMIT, PAGE_READWRITE) == NULL) { LOG_ERROR(HLE, "commit_page_memory VirtualAlloc failed."); - return -1; + return VM_FAILURE; } #else - s32 ret = mprotect((u8*)pointer, page_size, PROT_READ | PROT_WRITE) - if (ret < 0) + s32 ret = mprotect((u8*)pointer, page_size, PROT_READ | PROT_WRITE); + if (ret < VM_SUCCESS) { LOG_ERROR(HLE, "commit_page_memory mprotect failed. (%d)", ret); - return -1; + return VM_FAILURE; } #endif - return 0; + return VM_SUCCESS; } - void free_reserved_memory(void* pointer, size_t size) + s32 free_reserved_memory(void* pointer, size_t size) { #ifdef _WIN32 - VirtualFree(pointer, 0, MEM_RELEASE); + if (VirtualFree(pointer, 0, MEM_RELEASE) == 0) + { + LOG_ERROR(HLE, "free_reserved_memory VirtualFree failed."); + return VM_FAILURE; + } #else - munmap(pointer, size); + if (munmap(pointer, size) != VM_SUCCESS) + { + LOG_ERROR(HLE, "free_reserved_memory munmap failed."); + return VM_FAILURE; + } #endif + return VM_SUCCESS; } } diff --git a/Utilities/VirtualMemory.h b/Utilities/VirtualMemory.h index 76181ae2e9..1810bf0c71 100644 --- a/Utilities/VirtualMemory.h +++ b/Utilities/VirtualMemory.h @@ -1,10 +1,20 @@ #pragma once +// Failure codes for the functions +enum +{ + VM_SUCCESS = 0, + VM_FAILURE = -1, +}; + namespace memory_helper { /** * Reserve size bytes of virtual memory and returns it. * The memory should be commited before usage. + * + * Returns the base address of the allocated region of pages, if successful. + * Returns (void*)VM_FAILURE, if unsuccessful. */ void* reserve_memory(size_t size); @@ -13,13 +23,16 @@ namespace memory_helper * That is, bake reserved memory with physical memory. * pointer should belong to a range of reserved memory. * - * Returns 0, if was successful. - * Returns -1, if was unsuccessful. + * Returns VM_SUCCESS, if successful. + * Returns VM_FAILURE, if unsuccessful. */ s32 commit_page_memory(void* pointer, size_t page_size); /** * Free memory alloced via reserve_memory. + * + * Returns VM_SUCCESS, if successful. + * Returns VM_FAILURE, if unsuccessful. */ - void free_reserved_memory(void* pointer, size_t size); + s32 free_reserved_memory(void* pointer, size_t size); } \ No newline at end of file diff --git a/Utilities/rPlatform.cpp b/Utilities/rPlatform.cpp index 6efd198563..09ad275522 100644 --- a/Utilities/rPlatform.cpp +++ b/Utilities/rPlatform.cpp @@ -57,7 +57,7 @@ std::string rPlatform::getConfigDir() dir = "./config"; dir = dir + "/rpcs3/"; - s32 ret = mkdir(dir.c_str(), 0777) + s32 ret = mkdir(dir.c_str(), 0777); if (ret == EEXIST) { LOG_WARNING(HLE, "Configuration directory already exists. (%s)", dir); diff --git a/rpcs3/Crypto/unedat.cpp b/rpcs3/Crypto/unedat.cpp index 38f9de8c76..134697e67c 100644 --- a/rpcs3/Crypto/unedat.cpp +++ b/rpcs3/Crypto/unedat.cpp @@ -164,15 +164,19 @@ int decrypt_data(const fs::file* in, const fs::file* out, EDAT_HEADER *edat, NPD unsigned char empty_iv[0x10] = {}; // Decrypt the metadata. - int i; - for (i = 0; i < block_num; i++) + for (int i = 0; i < block_num; i++) { memset(hash_result, 0, 0x14); if ((edat->flags & EDAT_COMPRESSED_FLAG) != 0) { metadata_sec_offset = metadata_offset + (unsigned long long) i * metadata_section_size; - in->seek(metadata_sec_offset); + + if (in->seek(metadata_sec_offset) < 0) + { + LOG_ERROR(LOADER, "EDAT: Seeking medata section offset at %u failed.", metadata_sec_offset); + return 1; + } unsigned char metadata[0x20]; memset(metadata, 0, 0x20); @@ -244,7 +248,12 @@ int decrypt_data(const fs::file* in, const fs::file* out, EDAT_HEADER *edat, NPD memset(hash, 0, 0x10); memset(key_result, 0, 0x10); - in->seek(offset); + if (in->seek(offset) < 0) + { + LOG_ERROR(LOADER, "EDAT: Seeking offset at %u failed.", offset); + return 1; + } + in->read(enc_data, length); // Generate a key for the current block. diff --git a/rpcs3/Crypto/unself.cpp b/rpcs3/Crypto/unself.cpp index 7d879e5919..036dc759dc 100644 --- a/rpcs3/Crypto/unself.cpp +++ b/rpcs3/Crypto/unself.cpp @@ -890,8 +890,9 @@ bool SELFDecrypter::DecryptNPDRM(u8 *metadata, u32 metadata_size) memcpy(klicensee_key, key_v.GetKlicenseeKey(), 0x10); // Use klicensee if available. - if (memcmp(klicensee_key, key_v.GetKlicenseeKey(), 0x10) != 0) - memcpy(npdrm_key, klicensee_key, 0x10); + // FIXME: Check is always false. + /*if (klicensee_key != NULL) + memcpy(npdrm_key, klicensee_key, 0x10);*/ if (ctrl->npdrm.license == 1) // Network license. { diff --git a/rpcs3/Emu/HDD/HDD.cpp b/rpcs3/Emu/HDD/HDD.cpp index 719f2fdcd8..4a5ca5e798 100644 --- a/rpcs3/Emu/HDD/HDD.cpp +++ b/rpcs3/Emu/HDD/HDD.cpp @@ -48,15 +48,15 @@ s32 vfsHDDManager::CreateHDD(const std::string& path, u64 size, u64 block_size) u8 null = 0; - if (f.seek(hdr.block_count * hdr.block_size - sizeof(null)) < 0) + if (f.seek(hdr.block_count * hdr.block_size - sizeof(null)) < HDD_OK) { LOG_ERROR(HLE, "CreateHDD seek to %u failed.", hdr.block_count * hdr.block_size - sizeof(null)); - return -1; + return HDD_SEEK_FAILURE; } f.write(&null, sizeof(null)); - return 0; + return HDD_OK; } void vfsHDDManager::Format() @@ -76,17 +76,27 @@ bool vfsHDDFile::goto_block(u64 n) return false; } - m_hdd.Seek(m_info.data_block * m_hdd_info.block_size); + if (m_hdd.Seek(m_info.data_block * m_hdd_info.block_size) < HDD_OK) + { + LOG_ERROR(HLE, "goto_block seek to %u failed.", m_info.data_block * m_hdd_info.block_size); + return false; + } + block_info.next_block = m_info.data_block; - for (u64 i = 0; i= m_hdd_info.block_count) { return false; } - m_hdd.Seek(block_info.next_block * m_hdd_info.block_size); + if (m_hdd.Seek(block_info.next_block * m_hdd_info.block_size) < HDD_OK) + { + LOG_ERROR(HLE, "goto_block seek to %u failed.", block_info.next_block * m_hdd_info.block_size); + return false; + } + m_hdd.Read(&block_info, sizeof(vfsHDD_Block)); } @@ -109,97 +119,97 @@ void vfsHDDFile::RemoveBlocks(u64 start_block) s32 vfsHDDFile::WriteBlock(u64 block, const vfsHDD_Block& data) { - if (m_hdd.Seek(block * m_hdd_info.block_size) < 0) + if (m_hdd.Seek(block * m_hdd_info.block_size) < HDD_OK) { LOG_ERROR(HLE, "WriteBlock seek to %u failed.", block * m_hdd_info.block_size); - return -1; + return HDD_SEEK_FAILURE; } m_hdd.Write(&data, sizeof(vfsHDD_Block)); - return 0; + return HDD_OK; } s32 vfsHDDFile::ReadBlock(u64 block, vfsHDD_Block& data) { - if (m_hdd.Seek(block * m_hdd_info.block_size) < 0) + if (m_hdd.Seek(block * m_hdd_info.block_size) < HDD_OK) { LOG_ERROR(HLE, "ReadBlock seek to %u failed.", block * m_hdd_info.block_size); - return -1; + return HDD_SEEK_FAILURE; } m_hdd.Read(&data, sizeof(vfsHDD_Block)); - return 0; + return HDD_OK; } s32 vfsHDDFile::WriteEntry(u64 block, const vfsHDD_Entry& data) { - if (m_hdd.Seek(block * m_hdd_info.block_size) < 0) + if (m_hdd.Seek(block * m_hdd_info.block_size) < HDD_OK) { LOG_ERROR(HLE, "WriteEntry seek to %u failed.", block * m_hdd_info.block_size); - return -1; + return HDD_SEEK_FAILURE; } m_hdd.Write(&data, sizeof(vfsHDD_Entry)); - return 0; + return HDD_OK; } s32 vfsHDDFile::ReadEntry(u64 block, vfsHDD_Entry& data) { - if (m_hdd.Seek(block * m_hdd_info.block_size) < 0) + if (m_hdd.Seek(block * m_hdd_info.block_size) < HDD_OK) { LOG_ERROR(HLE, "ReadEntry seek to %u failed.", block * m_hdd_info.block_size); - return -1; + return HDD_SEEK_FAILURE; } m_hdd.Read(&data, sizeof(vfsHDD_Entry)); - return 0; + return HDD_OK; } s32 vfsHDDFile::ReadEntry(u64 block, vfsHDD_Entry& data, std::string& name) { - if (m_hdd.Seek(block * m_hdd_info.block_size) < 0) + if (m_hdd.Seek(block * m_hdd_info.block_size) < HDD_OK) { LOG_ERROR(HLE, "ReadEntry seek to %u failed.", block * m_hdd_info.block_size); - return -1; + return HDD_SEEK_FAILURE; } m_hdd.Read(&data, sizeof(vfsHDD_Entry)); name.resize(GetMaxNameLen()); m_hdd.Read(&name.front(), GetMaxNameLen()); - return 0; + return HDD_OK; } s32 vfsHDDFile::ReadEntry(u64 block, std::string& name) { - if (m_hdd.Seek(block * m_hdd_info.block_size + sizeof(vfsHDD_Entry)) < 0) + if (m_hdd.Seek(block * m_hdd_info.block_size + sizeof(vfsHDD_Entry)) < HDD_OK) { LOG_ERROR(HLE, "ReadEntry seek to %u failed.", block * m_hdd_info.block_size + sizeof(vfsHDD_Entry)); - return -1; + return HDD_SEEK_FAILURE; } name.resize(GetMaxNameLen()); m_hdd.Read(&name.front(), GetMaxNameLen()); - return 0; + return HDD_OK; } s32 vfsHDDFile::WriteEntry(u64 block, const vfsHDD_Entry& data, const std::string& name) { - if (m_hdd.Seek(block * m_hdd_info.block_size) < 0) + if (m_hdd.Seek(block * m_hdd_info.block_size) < HDD_OK) { LOG_ERROR(HLE, "WriteEntry seek to %u failed.", block * m_hdd_info.block_size); - return -1; + return HDD_SEEK_FAILURE; } m_hdd.Write(&data, sizeof(vfsHDD_Entry)); m_hdd.Write(name.c_str(), std::min(GetMaxNameLen() - 1, name.length() + 1)); - return 0; + return HDD_OK; } void vfsHDDFile::Open(u64 info_block) @@ -214,7 +224,7 @@ u64 vfsHDDFile::FindFreeBlock() { vfsHDD_Block block_info; - for (u64 i = 0; i(block_size - m_position, size); vfsHDD_Block cur_block_info; - m_hdd.Seek(m_cur_block * m_hdd_info.block_size); + + if (m_hdd.Seek(m_cur_block * m_hdd_info.block_size) < HDD_OK) + { + LOG_ERROR(HLE, "Read seek to %u failed.", m_cur_block * m_hdd_info.block_size); + return HDD_SEEK_FAILURE; + } + m_hdd.Read(&cur_block_info, sizeof(vfsHDD_Block)); - m_hdd.Seek(m_cur_block * m_hdd_info.block_size + sizeof(vfsHDD_Block)+m_position); + + if (m_hdd.Seek(m_cur_block * m_hdd_info.block_size + sizeof(vfsHDD_Block) + m_position) < HDD_OK) + { + LOG_ERROR(HLE, "Read seek to %u failed.", m_cur_block * m_hdd_info.block_size + sizeof(vfsHDD_Block) + m_position); + return HDD_SEEK_FAILURE; + } + m_hdd.Read(dst, rsize); size -= rsize; m_position += rsize; @@ -278,7 +309,12 @@ u64 vfsHDDFile::Read(void* dst, u64 size) m_cur_block = cur_block_info.next_block; rsize = std::min(block_size, size); - m_hdd.Seek(cur_block_info.next_block * m_hdd_info.block_size); + if (m_hdd.Seek(cur_block_info.next_block * m_hdd_info.block_size) < HDD_OK) + { + LOG_ERROR(HLE, "Read seek to %u failed.", cur_block_info.next_block * m_hdd_info.block_size); + return HDD_SEEK_FAILURE; + } + m_hdd.Read(&cur_block_info, sizeof(vfsHDD_Block)); if (m_hdd.Read((u8*)dst + offset, rsize) != rsize) @@ -329,7 +365,12 @@ u64 vfsHDDFile::Write(const void* src, u64 size) if (wsize) { - m_hdd.Seek(m_cur_block * m_hdd_info.block_size + sizeof(vfsHDD_Block)+m_position); + if (m_hdd.Seek(m_cur_block * m_hdd_info.block_size + sizeof(vfsHDD_Block) + m_position) < HDD_OK) + { + LOG_ERROR(HLE, "Write seek to %u failed.", m_cur_block * m_hdd_info.block_size + sizeof(vfsHDD_Block) + m_position); + return HDD_SEEK_FAILURE; + } + m_hdd.Write(src, wsize); size -= wsize; m_info.size += wsize; @@ -359,7 +400,13 @@ u64 vfsHDDFile::Write(const void* src, u64 size) wsize = std::min(block_size, size); block_info.next_block = m_cur_block; - m_hdd.Seek(last_block * m_hdd_info.block_size); + + if (m_hdd.Seek(last_block * m_hdd_info.block_size) < HDD_OK) + { + LOG_ERROR(HLE, "Write seek to %u failed.", last_block * m_hdd_info.block_size); + return HDD_SEEK_FAILURE; + } + if (m_hdd.Write(&block_info, sizeof(vfsHDD_Block)) != sizeof(vfsHDD_Block)) { m_position = 0; @@ -368,13 +415,20 @@ u64 vfsHDDFile::Write(const void* src, u64 size) } block_info.next_block = 0; - m_hdd.Seek(m_cur_block * m_hdd_info.block_size); + + if (m_hdd.Seek(m_cur_block * m_hdd_info.block_size) < HDD_OK) + { + LOG_ERROR(HLE, "Write seek to %u failed.", m_cur_block * m_hdd_info.block_size); + return HDD_SEEK_FAILURE; + } + if (m_hdd.Write(&block_info, sizeof(vfsHDD_Block)) != sizeof(vfsHDD_Block)) { m_position = 0; SaveInfo(); return offset; } + if ((m_position = m_hdd.Write((u8*)src + offset, wsize)) != wsize) { m_info.size += wsize; @@ -419,7 +473,7 @@ vfsHDD::vfsHDD(vfsDevice* device, const std::string& hdd_path) m_hdd_info.block_size = 2048; } - if (m_hdd_file.Seek(m_cur_dir_block * m_hdd_info.block_size) < 0) + if (m_hdd_file.Seek(m_cur_dir_block * m_hdd_info.block_size) < HDD_OK) { LOG_ERROR(HLE, "vfsHDD initialization seek to %u failed.", m_cur_dir_block * m_hdd_info.block_size); return; @@ -462,13 +516,13 @@ s32 vfsHDD::OpenDir(const std::string& name) if (!SearchEntry(name, entry_block)) { LOG_ERROR(HLE, "OpenDir could not find the entry. (%s)", name); - return -1; + return HDD_ENTRY_NOT_FOUND; } - if (m_hdd_file.Seek(entry_block * m_hdd_info.block_size) < 0) + if (m_hdd_file.Seek(entry_block * m_hdd_info.block_size) < HDD_OK) { LOG_ERROR(HLE, "OpenDir seek to %u failed.", entry_block * m_hdd_info.block_size); - return -1; + return HDD_SEEK_FAILURE; } vfsHDD_Entry entry; @@ -479,7 +533,7 @@ s32 vfsHDD::OpenDir(const std::string& name) m_cur_dir_block = entry.data_block; ReadEntry(m_cur_dir_block, m_cur_dir); - return 0; + return HDD_OK; } bool vfsHDD::Rename(const std::string& from, const std::string& to) @@ -501,7 +555,7 @@ u64 vfsHDD::FindFreeBlock() { vfsHDD_Block block_info; - for (u64 i = 0; i(GetMaxNameLen() - 1, name.length() + 1)); - return 0; + return HDD_OK; } bool vfsHDD::Create(vfsHDD_EntryType type, const std::string& name) diff --git a/rpcs3/Emu/HDD/HDD.h b/rpcs3/Emu/HDD/HDD.h index a50fca669c..ff8fc476df 100644 --- a/rpcs3/Emu/HDD/HDD.h +++ b/rpcs3/Emu/HDD/HDD.h @@ -5,6 +5,14 @@ static const u64 g_hdd_magic = *(u64*)"PS3eHDD\0"; static const u16 g_hdd_version = 0x0001; +// Return codes +enum +{ + HDD_OK = 0, + HDD_SEEK_FAILURE = 0x400, + HDD_ENTRY_NOT_FOUND = 0x401, +}; + struct vfsHDD_Block { struct @@ -114,7 +122,7 @@ public: return m_cur_block * m_hdd_info.block_size + m_position; // ??? } - void SaveInfo(); + s32 SaveInfo(); u64 Read(void* dst, u64 size); diff --git a/rpcs3/Emu/RSX/CgBinaryVertexProgram.cpp b/rpcs3/Emu/RSX/CgBinaryVertexProgram.cpp index 71c8dbe0fe..44a11f338a 100644 --- a/rpcs3/Emu/RSX/CgBinaryVertexProgram.cpp +++ b/rpcs3/Emu/RSX/CgBinaryVertexProgram.cpp @@ -116,7 +116,7 @@ std::string CgBinaryDisasm::GetSRCDisasm(const u32 n) if (swizzle != f) ret += '.' + swizzle; - bool abs; + bool abs = false; switch (n) { diff --git a/rpcs3/Emu/System.cpp b/rpcs3/Emu/System.cpp index 1299703045..25d063377e 100644 --- a/rpcs3/Emu/System.cpp +++ b/rpcs3/Emu/System.cpp @@ -48,6 +48,7 @@ Emulator::Emulator() : m_status(Stopped) , m_mode(DisAsm) , m_rsx_callback(0) + , m_cpu_thr_stop(0) , m_thread_manager(new CPUThreadManager()) , m_pad_manager(new PadManager()) , m_keyboard_manager(new KeyboardManager()) @@ -453,6 +454,7 @@ void Emulator::Stop() } m_rsx_callback = 0; + m_cpu_thr_stop = 0; // TODO: check finalization order From 5d5a4f804b2b8fd711f13fefff53201081b9693b Mon Sep 17 00:00:00 2001 From: Raul Tambre Date: Sun, 8 Nov 2015 13:42:41 +0200 Subject: [PATCH 3/4] Replace most returns with CHECK_ASSERTION Also fix some Seek methods return types being unsigned, while returning negative errors. Added the CHECK_ASSERTION macro checks in a couple more places. Simplified CHECK_ASSERTION macro usage. --- Utilities/File.cpp | 8 +- Utilities/VirtualMemory.cpp | 42 +---- Utilities/VirtualMemory.h | 20 +- Utilities/rPlatform.cpp | 10 +- rpcs3/Crypto/unedat.cpp | 38 ++-- rpcs3/Crypto/unpkg.cpp | 6 +- rpcs3/Crypto/unself.cpp | 101 ++++------ rpcs3/Emu/HDD/HDD.cpp | 237 ++++++------------------ rpcs3/Emu/HDD/HDD.h | 40 ++-- rpcs3/Emu/Memory/MemoryBlock.h | 2 +- rpcs3/Emu/SysCalls/Modules/cellFs.cpp | 32 ++-- rpcs3/Emu/SysCalls/Modules/cellResc.cpp | 7 +- rpcs3/Gui/AutoPauseManager.cpp | 4 +- rpcs3/Gui/MainFrame.cpp | 6 +- 14 files changed, 159 insertions(+), 394 deletions(-) diff --git a/Utilities/File.cpp b/Utilities/File.cpp index 7b1c3c9256..8ef949a65e 100644 --- a/Utilities/File.cpp +++ b/Utilities/File.cpp @@ -327,13 +327,7 @@ int OSCopyFile(const char* source, const char* destination, bool overwrite) //sendfile will work with non-socket output (i.e. regular file) on Linux 2.6.33+ off_t bytesCopied = 0; struct stat fileinfo = { 0 }; - - s32 ret = fstat(input, &fileinfo); - if (ret < 0) - { - return -1; - } - + fstat(input, &fileinfo); int result = sendfile(output, input, &bytesCopied, fileinfo.st_size) == -1 ? -1 : 0; #endif diff --git a/Utilities/VirtualMemory.cpp b/Utilities/VirtualMemory.cpp index b018bb2e1f..5a2d00e901 100644 --- a/Utilities/VirtualMemory.cpp +++ b/Utilities/VirtualMemory.cpp @@ -17,55 +17,29 @@ namespace memory_helper { #ifdef _WIN32 void* ret = VirtualAlloc(NULL, size, MEM_RESERVE, PAGE_NOACCESS); - if (ret == NULL) - { - LOG_ERROR(HLE, "reserve_memory VirtualAlloc failed."); - return (void*)VM_FAILURE; - } + CHECK_ASSERTION(ret != NULL); #else void* ret = mmap(nullptr, size, PROT_NONE, MAP_ANON | MAP_PRIVATE, -1, 0); - if (ret == (void*)VM_FAILURE) - { - LOG_ERROR(HLE, "reserve_memory mmap failed."); - } + CHECK_ASSERTION(ret != 0); #endif return ret; } - s32 commit_page_memory(void* pointer, size_t page_size) + void commit_page_memory(void* pointer, size_t page_size) { #ifdef _WIN32 - if (VirtualAlloc((u8*)pointer, page_size, MEM_COMMIT, PAGE_READWRITE) == NULL) - { - LOG_ERROR(HLE, "commit_page_memory VirtualAlloc failed."); - return VM_FAILURE; - } + CHECK_ASSERTION(VirtualAlloc((u8*)pointer, page_size, MEM_COMMIT, PAGE_READWRITE) != NULL); #else - s32 ret = mprotect((u8*)pointer, page_size, PROT_READ | PROT_WRITE); - if (ret < VM_SUCCESS) - { - LOG_ERROR(HLE, "commit_page_memory mprotect failed. (%d)", ret); - return VM_FAILURE; - } + CHECK_ASSERTION(mprotect((u8*)pointer, page_size, PROT_READ | PROT_WRITE) != -1); #endif - return VM_SUCCESS; } - s32 free_reserved_memory(void* pointer, size_t size) + void free_reserved_memory(void* pointer, size_t size) { #ifdef _WIN32 - if (VirtualFree(pointer, 0, MEM_RELEASE) == 0) - { - LOG_ERROR(HLE, "free_reserved_memory VirtualFree failed."); - return VM_FAILURE; - } + CHECK_ASSERTION(VirtualFree(pointer, 0, MEM_RELEASE) != 0); #else - if (munmap(pointer, size) != VM_SUCCESS) - { - LOG_ERROR(HLE, "free_reserved_memory munmap failed."); - return VM_FAILURE; - } + CHECK_ASSERTION(munmap(pointer, size) == 0); #endif - return VM_SUCCESS; } } diff --git a/Utilities/VirtualMemory.h b/Utilities/VirtualMemory.h index 1810bf0c71..ecce48db2e 100644 --- a/Utilities/VirtualMemory.h +++ b/Utilities/VirtualMemory.h @@ -1,20 +1,10 @@ #pragma once -// Failure codes for the functions -enum -{ - VM_SUCCESS = 0, - VM_FAILURE = -1, -}; - namespace memory_helper { /** * Reserve size bytes of virtual memory and returns it. * The memory should be commited before usage. - * - * Returns the base address of the allocated region of pages, if successful. - * Returns (void*)VM_FAILURE, if unsuccessful. */ void* reserve_memory(size_t size); @@ -22,17 +12,11 @@ namespace memory_helper * Commit page_size bytes of virtual memory starting at pointer. * That is, bake reserved memory with physical memory. * pointer should belong to a range of reserved memory. - * - * Returns VM_SUCCESS, if successful. - * Returns VM_FAILURE, if unsuccessful. */ - s32 commit_page_memory(void* pointer, size_t page_size); + void commit_page_memory(void* pointer, size_t page_size); /** * Free memory alloced via reserve_memory. - * - * Returns VM_SUCCESS, if successful. - * Returns VM_FAILURE, if unsuccessful. */ - s32 free_reserved_memory(void* pointer, size_t size); + void free_reserved_memory(void* pointer, size_t size); } \ No newline at end of file diff --git a/Utilities/rPlatform.cpp b/Utilities/rPlatform.cpp index 09ad275522..1b21be5b6c 100644 --- a/Utilities/rPlatform.cpp +++ b/Utilities/rPlatform.cpp @@ -10,6 +10,7 @@ #ifndef _WIN32 #include +#include #endif #include "rPlatform.h" @@ -57,14 +58,9 @@ std::string rPlatform::getConfigDir() dir = "./config"; dir = dir + "/rpcs3/"; - s32 ret = mkdir(dir.c_str(), 0777); - if (ret == EEXIST) + if (mkdir(dir.c_str(), 0777) == -1) { - LOG_WARNING(HLE, "Configuration directory already exists. (%s)", dir); - } - else if (ret < 0) - { - LOG_ERROR(HLE, "An error occured during the creation of the configuration directory. (%d)", ret); + printf("An error occured during the creation of the configuration directory. (%d)", errno); } #endif } diff --git a/rpcs3/Crypto/unedat.cpp b/rpcs3/Crypto/unedat.cpp index 134697e67c..011e9a701f 100644 --- a/rpcs3/Crypto/unedat.cpp +++ b/rpcs3/Crypto/unedat.cpp @@ -172,12 +172,8 @@ int decrypt_data(const fs::file* in, const fs::file* out, EDAT_HEADER *edat, NPD { metadata_sec_offset = metadata_offset + (unsigned long long) i * metadata_section_size; - if (in->seek(metadata_sec_offset) < 0) - { - LOG_ERROR(LOADER, "EDAT: Seeking medata section offset at %u failed.", metadata_sec_offset); - return 1; - } - + CHECK_ASSERTION(in->seek(metadata_sec_offset) != -1); + unsigned char metadata[0x20]; memset(metadata, 0, 0x20); in->read(metadata, 0x20); @@ -205,7 +201,7 @@ int decrypt_data(const fs::file* in, const fs::file* out, EDAT_HEADER *edat, NPD { // If FLAG 0x20, the metadata precedes each data block. metadata_sec_offset = metadata_offset + (unsigned long long) i * (metadata_section_size + length); - in->seek(metadata_sec_offset); + CHECK_ASSERTION(in->seek(metadata_sec_offset) != -1); unsigned char metadata[0x20]; memset(metadata, 0, 0x20); @@ -226,7 +222,7 @@ int decrypt_data(const fs::file* in, const fs::file* out, EDAT_HEADER *edat, NPD else { metadata_sec_offset = metadata_offset + (unsigned long long) i * metadata_section_size; - in->seek(metadata_sec_offset); + CHECK_ASSERTION(in->seek(metadata_sec_offset) != -1); in->read(hash_result, 0x10); offset = metadata_offset + (unsigned long long) i * edat->block_size + (unsigned long long) block_num * metadata_section_size; @@ -248,11 +244,7 @@ int decrypt_data(const fs::file* in, const fs::file* out, EDAT_HEADER *edat, NPD memset(hash, 0, 0x10); memset(key_result, 0, 0x10); - if (in->seek(offset) < 0) - { - LOG_ERROR(LOADER, "EDAT: Seeking offset at %u failed.", offset); - return 1; - } + CHECK_ASSERTION(in->seek(offset) != -1); in->read(enc_data, length); @@ -357,7 +349,7 @@ int decrypt_data(const fs::file* in, const fs::file* out, EDAT_HEADER *edat, NPD int check_data(unsigned char *key, EDAT_HEADER *edat, NPD_HEADER *npd, const fs::file* f, bool verbose) { - f->seek(0); + CHECK_ASSERTION(f->seek(0) != -1); unsigned char header[0xA0]; unsigned char empty_header[0xA0]; unsigned char header_hash[0x10]; @@ -402,10 +394,7 @@ int check_data(unsigned char *key, EDAT_HEADER *edat, NPD_HEADER *npd, const fs: f->read(header, 0xA0); // Read in the header and metadata section hashes. - if (f->seek(0x90) < 0) - { - LOG_ERROR(LOADER, "EDAT: Seeking header at 0x90 failed."); - } + CHECK_ASSERTION(f->seek(0x90) != -1); f->read(metadata_hash, 0x10); f->read(header_hash, 0x10); @@ -462,10 +451,7 @@ int check_data(unsigned char *key, EDAT_HEADER *edat, NPD_HEADER *npd, const fs: while (bytes_to_read > 0) { // Locate the metadata blocks. - if (f->seek(metadata_section_offset) < 0) - { - LOG_ERROR(LOADER, "EDAT: Seeking metadata blocks at %u failed.", metadata_section_offset); - } + CHECK_ASSERTION(f->seek(metadata_section_offset) != -1); // Read in the metadata. f->read(metadata + bytes_read, metadata_section_size); @@ -512,9 +498,9 @@ int check_data(unsigned char *key, EDAT_HEADER *edat, NPD_HEADER *npd, const fs: // Read in the metadata and header signatures. - f->seek(0xB0); + CHECK_ASSERTION(f->seek(0xB0) != -1); f->read(metadata_signature, 0x28); - f->seek(0xD8); + CHECK_ASSERTION(f->seek(0xD8) != -1); f->read(header_signature, 0x28); // Checking metadata signature. @@ -530,7 +516,7 @@ int check_data(unsigned char *key, EDAT_HEADER *edat, NPD_HEADER *npd, const fs: { int metadata_buf_size = block_num * 0x10; unsigned char *metadata_buf = new unsigned char[metadata_buf_size]; - f->seek(metadata_offset); + CHECK_ASSERTION(f->seek(metadata_offset) != -1); f->read(metadata_buf, metadata_buf_size); sha1(metadata_buf, metadata_buf_size, signature_hash); delete[] metadata_buf; @@ -563,7 +549,7 @@ int check_data(unsigned char *key, EDAT_HEADER *edat, NPD_HEADER *npd, const fs: // Setup header signature hash. memset(signature_hash, 0, 20); unsigned char *header_buf = new unsigned char[0xD8]; - f->seek(0x00); + CHECK_ASSERTION(f->seek(0x00) != -1); f->read(header_buf, 0xD8); sha1(header_buf, 0xD8, signature_hash ); delete[] header_buf; diff --git a/rpcs3/Crypto/unpkg.cpp b/rpcs3/Crypto/unpkg.cpp index fd8a899d7f..03168d734c 100644 --- a/rpcs3/Crypto/unpkg.cpp +++ b/rpcs3/Crypto/unpkg.cpp @@ -86,11 +86,7 @@ bool UnpackPKG(const fs::file& pkg_f, const std::string& dir, volatile f64& prog // Define decryption subfunction (`psp` arg selects the key for specific block) auto decrypt = [&](u64 offset, u64 size, bool psp) -> u64 { - if (pkg_f.seek(start_offset + header.data_offset + offset) < 0) - { - LOG_ERROR(LOADER, "PKG: Package file seek to %u failed.", start_offset + header.data_offset + offset); - return -1; - } + CHECK_ASSERTION(pkg_f.seek(start_offset + header.data_offset + offset) != -1); // Read the data and set available size const u64 read = pkg_f.read(buf.get(), size); diff --git a/rpcs3/Crypto/unself.cpp b/rpcs3/Crypto/unself.cpp index 036dc759dc..c307a9de6b 100644 --- a/rpcs3/Crypto/unself.cpp +++ b/rpcs3/Crypto/unself.cpp @@ -698,7 +698,7 @@ SELFDecrypter::SELFDecrypter(vfsStream& s) bool SELFDecrypter::LoadHeaders(bool isElf32) { // Read SCE header. - self_f.Seek(0); + CHECK_ASSERTION(self_f.Seek(0) != -1); sce_hdr.Load(self_f); // Check SCE magic. @@ -712,11 +712,12 @@ bool SELFDecrypter::LoadHeaders(bool isElf32) self_hdr.Load(self_f); // Read the APP INFO. - self_f.Seek(self_hdr.se_appinfooff); + CHECK_ASSERTION(self_f.Seek(self_hdr.se_appinfooff) != -1); app_info.Load(self_f); // Read ELF header. - self_f.Seek(self_hdr.se_elfoff); + CHECK_ASSERTION(self_f.Seek(self_hdr.se_elfoff) != -1); + if (isElf32) elf32_hdr.Load(self_f); else @@ -741,13 +742,16 @@ bool SELFDecrypter::LoadHeaders(bool isElf32) else { phdr64_arr.clear(); - if(elf64_hdr.e_phoff == 0 && elf64_hdr.e_phnum) + + if (elf64_hdr.e_phoff == 0 && elf64_hdr.e_phnum) { LOG_ERROR(LOADER, "SELF: ELF program header offset is null!"); return false; } - self_f.Seek(self_hdr.se_phdroff); - for(u32 i = 0; i < elf64_hdr.e_phnum; ++i) + + CHECK_ASSERTION(self_f.Seek(self_hdr.se_phdroff) != -1); + + for (u32 i = 0; i < elf64_hdr.e_phnum; ++i) { phdr64_arr.emplace_back(); phdr64_arr.back().Load(self_f); @@ -757,7 +761,7 @@ bool SELFDecrypter::LoadHeaders(bool isElf32) // Read section info. secinfo_arr.clear(); - self_f.Seek(self_hdr.se_secinfoff); + CHECK_ASSERTION(self_f.Seek(self_hdr.se_secinfoff) != -1); for(u32 i = 0; i < ((isElf32) ? elf32_hdr.e_phnum : elf64_hdr.e_phnum); ++i) { @@ -766,12 +770,12 @@ bool SELFDecrypter::LoadHeaders(bool isElf32) } // Read SCE version info. - self_f.Seek(self_hdr.se_sceveroff); + CHECK_ASSERTION(self_f.Seek(self_hdr.se_sceveroff) != -1); scev_info.Load(self_f); // Read control info. ctrlinfo_arr.clear(); - self_f.Seek(self_hdr.se_controloff); + CHECK_ASSERTION(self_f.Seek(self_hdr.se_controloff) != -1); u32 i = 0; while(i < self_hdr.se_controlsize) @@ -786,12 +790,15 @@ bool SELFDecrypter::LoadHeaders(bool isElf32) if (isElf32) { shdr32_arr.clear(); - if(elf32_hdr.e_shoff == 0 && elf32_hdr.e_shnum) + + if (elf32_hdr.e_shoff == 0 && elf32_hdr.e_shnum) { LOG_WARNING(LOADER, "SELF: ELF section header offset is null!"); return true; } - self_f.Seek(self_hdr.se_shdroff); + + CHECK_ASSERTION(self_f.Seek(self_hdr.se_shdroff) != -1); + for(u32 i = 0; i < elf32_hdr.e_shnum; ++i) { shdr32_arr.emplace_back(); @@ -801,12 +808,14 @@ bool SELFDecrypter::LoadHeaders(bool isElf32) else { shdr64_arr.clear(); - if(elf64_hdr.e_shoff == 0 && elf64_hdr.e_shnum) + if (elf64_hdr.e_shoff == 0 && elf64_hdr.e_shnum) { LOG_WARNING(LOADER, "SELF: ELF section header offset is null!"); return true; } - self_f.Seek(self_hdr.se_shdroff); + + CHECK_ASSERTION(self_f.Seek(self_hdr.se_shdroff) != -1); + for(u32 i = 0; i < elf64_hdr.e_shnum; ++i) { shdr64_arr.emplace_back(); @@ -890,9 +899,8 @@ bool SELFDecrypter::DecryptNPDRM(u8 *metadata, u32 metadata_size) memcpy(klicensee_key, key_v.GetKlicenseeKey(), 0x10); // Use klicensee if available. - // FIXME: Check is always false. - /*if (klicensee_key != NULL) - memcpy(npdrm_key, klicensee_key, 0x10);*/ + if (klicensee_key != NULL) + memcpy(npdrm_key, klicensee_key, 0x10); if (ctrl->npdrm.license == 1) // Network license. { @@ -942,11 +950,11 @@ bool SELFDecrypter::LoadMetadata() u8 *metadata_headers = (u8 *)malloc(metadata_headers_size); // Locate and read the encrypted metadata info. - self_f.Seek(sce_hdr.se_meta + sizeof(sce_hdr)); + CHECK_ASSERTION(self_f.Seek(sce_hdr.se_meta + sizeof(sce_hdr)) != -1); self_f.Read(metadata_info, metadata_info_size); // Locate and read the encrypted metadata header and section header. - self_f.Seek(sce_hdr.se_meta + sizeof(sce_hdr) + metadata_info_size); + CHECK_ASSERTION(self_f.Seek(sce_hdr.se_meta + sizeof(sce_hdr) + metadata_info_size) != -1); self_f.Read(metadata_headers, metadata_headers_size); // Find the right keyset from the key vault. @@ -1049,7 +1057,7 @@ bool SELFDecrypter::DecryptData() u8 *buf = (u8 *)malloc(meta_shdr[i].data_size); // Seek to the section data offset and read the encrypted data. - self_f.Seek(meta_shdr[i].data_offset); + CHECK_ASSERTION(self_f.Seek(meta_shdr[i].data_offset) != -1); self_f.Read(buf, meta_shdr[i].data_size); // Zero out our ctr nonce. @@ -1104,11 +1112,7 @@ bool SELFDecrypter::MakeElf(const std::string& elf, bool isElf32) if (meta_shdr[i].type == 2) { // Seek to the program header data offset and write the data. - if (e.seek(phdr32_arr[meta_shdr[i].program_idx].p_offset) < 0) - { - LOG_ERROR(LOADER, "MakeElf program header data seek to %u failed.", phdr32_arr[meta_shdr[i].program_idx].p_offset); - return false; - } + CHECK_ASSERTION(e.seek(phdr32_arr[meta_shdr[i].program_idx].p_offset) != -1); e.write(data_buf + data_buf_offset, meta_shdr[i].data_size); @@ -1120,11 +1124,7 @@ bool SELFDecrypter::MakeElf(const std::string& elf, bool isElf32) // Write section headers. if (self_hdr.se_shdroff != 0) { - if (e.seek(elf32_hdr.e_shoff) < 0) - { - LOG_ERROR(LOADER, "MakeElf section header seek to %u failed.", elf32_hdr.e_shoff); - return false; - } + CHECK_ASSERTION(e.seek(elf32_hdr.e_shoff) != -1); for (u32 i = 0; i < elf32_hdr.e_shnum; ++i) { @@ -1168,11 +1168,8 @@ bool SELFDecrypter::MakeElf(const std::string& elf, bool isElf32) decomp_stream_out.CopyTo(decomp_buf, phdr64_arr[meta_shdr[i].program_idx].p_filesz); // Seek to the program header data offset and write the data. - if (e.seek(phdr64_arr[meta_shdr[i].program_idx].p_offset) < 0) - { - LOG_ERROR(LOADER, "MakeElf program header data seek to %u failed.", phdr64_arr[meta_shdr[i].program_idx].p_offset); - return false; - } + + CHECK_ASSERTION(e.seek(phdr64_arr[meta_shdr[i].program_idx].p_offset) != -1); e.write(decomp_buf, phdr64_arr[meta_shdr[i].program_idx].p_filesz); @@ -1182,11 +1179,7 @@ bool SELFDecrypter::MakeElf(const std::string& elf, bool isElf32) else { // Seek to the program header data offset and write the data. - if (e.seek(phdr64_arr[meta_shdr[i].program_idx].p_offset) < 0) - { - LOG_ERROR(LOADER, "MakeElf program header data seek to %u failed.", phdr64_arr[meta_shdr[i].program_idx].p_offset); - return false; - } + CHECK_ASSERTION(e.seek(phdr64_arr[meta_shdr[i].program_idx].p_offset) != -1); e.write(data_buf + data_buf_offset, meta_shdr[i].data_size); } @@ -1199,11 +1192,7 @@ bool SELFDecrypter::MakeElf(const std::string& elf, bool isElf32) // Write section headers. if (self_hdr.se_shdroff != 0) { - if (e.seek(elf64_hdr.e_shoff) < 0) - { - LOG_ERROR(LOADER, "MakeElf section header seek to %u failed.", elf64_hdr.e_shoff); - return false; - } + CHECK_ASSERTION(e.seek(elf64_hdr.e_shoff) != -1); for (u32 i = 0; i < elf64_hdr.e_shnum; ++i) { @@ -1279,11 +1268,7 @@ bool IsSelfElf32(const std::string& path) // Locate the class byte and check it. u8 elf_class[0x8]; - if (f.Seek(sh.se_elfoff) < 0) - { - LOG_ERROR(LOADER, "IsSelfElf32 seek to %u failed.", sh.se_elfoff); - return false; - } + CHECK_ASSERTION(f.Seek(sh.se_elfoff) != -1); f.Read(elf_class, 0x8); @@ -1302,11 +1287,7 @@ bool CheckDebugSelf(const std::string& self, const std::string& elf) } // Get the key version. - if (s.seek(0x08) < 0) - { - LOG_ERROR(LOADER, "Seeking debug (S)ELF at 0x08 failed."); - return false; - } + CHECK_ASSERTION(s.seek(0x08) != -1); u16 key_version; s.read(&key_version, sizeof(key_version)); @@ -1317,11 +1298,7 @@ bool CheckDebugSelf(const std::string& self, const std::string& elf) LOG_WARNING(LOADER, "Debug SELF detected! Removing fake header..."); // Get the real elf offset. - if (s.seek(0x10) < 0) - { - LOG_ERROR(LOADER, "Seeking debug (S)ELF at 0x10 failed."); - return false; - } + CHECK_ASSERTION(s.seek(0x10) != -1); u64 elf_offset; s.read(&elf_offset, sizeof(elf_offset)); @@ -1329,11 +1306,7 @@ bool CheckDebugSelf(const std::string& self, const std::string& elf) // Start at the real elf offset. elf_offset = swap64(elf_offset); - if (s.seek(elf_offset) < 0) - { - LOG_ERROR(LOADER, "Seeking debug (S)ELF at %u failed.", elf_offset); - return false; - } + CHECK_ASSERTION(s.seek(elf_offset) != -1); // Write the real ELF file back. fs::file e(elf, fom::write | fom::create | fom::trunc); diff --git a/rpcs3/Emu/HDD/HDD.cpp b/rpcs3/Emu/HDD/HDD.cpp index 4a5ca5e798..769f2ebf43 100644 --- a/rpcs3/Emu/HDD/HDD.cpp +++ b/rpcs3/Emu/HDD/HDD.cpp @@ -19,7 +19,7 @@ void vfsHDDManager::CreateEntry(vfsHDD_Entry& entry) CreateBlock(entry); } -s32 vfsHDDManager::CreateHDD(const std::string& path, u64 size, u64 block_size) +void vfsHDDManager::CreateHDD(const std::string& path, u64 size, u64 block_size) { fs::file f(path, fom::write | fom::create | fom::trunc); @@ -48,15 +48,9 @@ s32 vfsHDDManager::CreateHDD(const std::string& path, u64 size, u64 block_size) u8 null = 0; - if (f.seek(hdr.block_count * hdr.block_size - sizeof(null)) < HDD_OK) - { - LOG_ERROR(HLE, "CreateHDD seek to %u failed.", hdr.block_count * hdr.block_size - sizeof(null)); - return HDD_SEEK_FAILURE; - } + CHECK_ASSERTION(f.seek(hdr.block_count * hdr.block_size - sizeof(null)) != -1); f.write(&null, sizeof(null)); - - return HDD_OK; } void vfsHDDManager::Format() @@ -76,11 +70,7 @@ bool vfsHDDFile::goto_block(u64 n) return false; } - if (m_hdd.Seek(m_info.data_block * m_hdd_info.block_size) < HDD_OK) - { - LOG_ERROR(HLE, "goto_block seek to %u failed.", m_info.data_block * m_hdd_info.block_size); - return false; - } + CHECK_ASSERTION(m_hdd.Seek(m_info.data_block * m_hdd_info.block_size) != -1); block_info.next_block = m_info.data_block; @@ -91,11 +81,7 @@ bool vfsHDDFile::goto_block(u64 n) return false; } - if (m_hdd.Seek(block_info.next_block * m_hdd_info.block_size) < HDD_OK) - { - LOG_ERROR(HLE, "goto_block seek to %u failed.", block_info.next_block * m_hdd_info.block_size); - return false; - } + CHECK_ASSERTION(m_hdd.Seek(block_info.next_block * m_hdd_info.block_size) != -1); m_hdd.Read(&block_info, sizeof(vfsHDD_Block)); } @@ -117,99 +103,57 @@ void vfsHDDFile::RemoveBlocks(u64 start_block) } } -s32 vfsHDDFile::WriteBlock(u64 block, const vfsHDD_Block& data) +void vfsHDDFile::WriteBlock(u64 block, const vfsHDD_Block& data) { - if (m_hdd.Seek(block * m_hdd_info.block_size) < HDD_OK) - { - LOG_ERROR(HLE, "WriteBlock seek to %u failed.", block * m_hdd_info.block_size); - return HDD_SEEK_FAILURE; - } + CHECK_ASSERTION(m_hdd.Seek(block * m_hdd_info.block_size) != -1); m_hdd.Write(&data, sizeof(vfsHDD_Block)); - - return HDD_OK; } -s32 vfsHDDFile::ReadBlock(u64 block, vfsHDD_Block& data) +void vfsHDDFile::ReadBlock(u64 block, vfsHDD_Block& data) { - if (m_hdd.Seek(block * m_hdd_info.block_size) < HDD_OK) - { - LOG_ERROR(HLE, "ReadBlock seek to %u failed.", block * m_hdd_info.block_size); - return HDD_SEEK_FAILURE; - } + CHECK_ASSERTION(m_hdd.Seek(block * m_hdd_info.block_size) != -1); m_hdd.Read(&data, sizeof(vfsHDD_Block)); - - return HDD_OK; } -s32 vfsHDDFile::WriteEntry(u64 block, const vfsHDD_Entry& data) +void vfsHDDFile::WriteEntry(u64 block, const vfsHDD_Entry& data) { - if (m_hdd.Seek(block * m_hdd_info.block_size) < HDD_OK) - { - LOG_ERROR(HLE, "WriteEntry seek to %u failed.", block * m_hdd_info.block_size); - return HDD_SEEK_FAILURE; - } + CHECK_ASSERTION(m_hdd.Seek(block * m_hdd_info.block_size) != -1); m_hdd.Write(&data, sizeof(vfsHDD_Entry)); - - return HDD_OK; } -s32 vfsHDDFile::ReadEntry(u64 block, vfsHDD_Entry& data) +void vfsHDDFile::ReadEntry(u64 block, vfsHDD_Entry& data) { - if (m_hdd.Seek(block * m_hdd_info.block_size) < HDD_OK) - { - LOG_ERROR(HLE, "ReadEntry seek to %u failed.", block * m_hdd_info.block_size); - return HDD_SEEK_FAILURE; - } + CHECK_ASSERTION(m_hdd.Seek(block * m_hdd_info.block_size) != -1); m_hdd.Read(&data, sizeof(vfsHDD_Entry)); - - return HDD_OK; } -s32 vfsHDDFile::ReadEntry(u64 block, vfsHDD_Entry& data, std::string& name) +void vfsHDDFile::ReadEntry(u64 block, vfsHDD_Entry& data, std::string& name) { - if (m_hdd.Seek(block * m_hdd_info.block_size) < HDD_OK) - { - LOG_ERROR(HLE, "ReadEntry seek to %u failed.", block * m_hdd_info.block_size); - return HDD_SEEK_FAILURE; - } + CHECK_ASSERTION(m_hdd.Seek(block * m_hdd_info.block_size) != -1); m_hdd.Read(&data, sizeof(vfsHDD_Entry)); name.resize(GetMaxNameLen()); m_hdd.Read(&name.front(), GetMaxNameLen()); - - return HDD_OK; } -s32 vfsHDDFile::ReadEntry(u64 block, std::string& name) +void vfsHDDFile::ReadEntry(u64 block, std::string& name) { - if (m_hdd.Seek(block * m_hdd_info.block_size + sizeof(vfsHDD_Entry)) < HDD_OK) - { - LOG_ERROR(HLE, "ReadEntry seek to %u failed.", block * m_hdd_info.block_size + sizeof(vfsHDD_Entry)); - return HDD_SEEK_FAILURE; - } + CHECK_ASSERTION(m_hdd.Seek(block * m_hdd_info.block_size + sizeof(vfsHDD_Entry)) != -1); name.resize(GetMaxNameLen()); m_hdd.Read(&name.front(), GetMaxNameLen()); - - return HDD_OK; } -s32 vfsHDDFile::WriteEntry(u64 block, const vfsHDD_Entry& data, const std::string& name) +void vfsHDDFile::WriteEntry(u64 block, const vfsHDD_Entry& data, const std::string& name) { - if (m_hdd.Seek(block * m_hdd_info.block_size) < HDD_OK) - { - LOG_ERROR(HLE, "WriteEntry seek to %u failed.", block * m_hdd_info.block_size); - return HDD_SEEK_FAILURE; - } + CHECK_ASSERTION(m_hdd.Seek(block * m_hdd_info.block_size) != -1); m_hdd.Write(&data, sizeof(vfsHDD_Entry)); m_hdd.Write(name.c_str(), std::min(GetMaxNameLen() - 1, name.length() + 1)); - - return HDD_OK; } void vfsHDDFile::Open(u64 info_block) @@ -248,19 +192,13 @@ bool vfsHDDFile::Seek(u64 pos) return true; } -s32 vfsHDDFile::SaveInfo() +void vfsHDDFile::SaveInfo() { - m_hdd.Seek(m_info_block * m_hdd_info.block_size); + CHECK_ASSERTION(m_hdd.Seek(m_info_block * m_hdd_info.block_size) != -1); - if (m_hdd.Seek(m_info_block * m_hdd_info.block_size) < HDD_OK) - { - LOG_ERROR(HLE, "SaveInfo seek to %u failed.", m_info_block * m_hdd_info.block_size); - return HDD_SEEK_FAILURE; - } + CHECK_ASSERTION(m_hdd.Seek(m_info_block * m_hdd_info.block_size) != -1); m_hdd.Write(&m_info, sizeof(vfsHDD_Entry)); - - return HDD_OK; } u64 vfsHDDFile::Read(void* dst, u64 size) @@ -275,19 +213,11 @@ u64 vfsHDDFile::Read(void* dst, u64 size) vfsHDD_Block cur_block_info; - if (m_hdd.Seek(m_cur_block * m_hdd_info.block_size) < HDD_OK) - { - LOG_ERROR(HLE, "Read seek to %u failed.", m_cur_block * m_hdd_info.block_size); - return HDD_SEEK_FAILURE; - } + CHECK_ASSERTION(m_hdd.Seek(m_cur_block * m_hdd_info.block_size) != -1); m_hdd.Read(&cur_block_info, sizeof(vfsHDD_Block)); - if (m_hdd.Seek(m_cur_block * m_hdd_info.block_size + sizeof(vfsHDD_Block) + m_position) < HDD_OK) - { - LOG_ERROR(HLE, "Read seek to %u failed.", m_cur_block * m_hdd_info.block_size + sizeof(vfsHDD_Block) + m_position); - return HDD_SEEK_FAILURE; - } + CHECK_ASSERTION(m_hdd.Seek(m_cur_block * m_hdd_info.block_size + sizeof(vfsHDD_Block) + m_position) != -1); m_hdd.Read(dst, rsize); size -= rsize; @@ -309,11 +239,7 @@ u64 vfsHDDFile::Read(void* dst, u64 size) m_cur_block = cur_block_info.next_block; rsize = std::min(block_size, size); - if (m_hdd.Seek(cur_block_info.next_block * m_hdd_info.block_size) < HDD_OK) - { - LOG_ERROR(HLE, "Read seek to %u failed.", cur_block_info.next_block * m_hdd_info.block_size); - return HDD_SEEK_FAILURE; - } + CHECK_ASSERTION(m_hdd.Seek(cur_block_info.next_block * m_hdd_info.block_size) != -1); m_hdd.Read(&cur_block_info, sizeof(vfsHDD_Block)); @@ -365,11 +291,7 @@ u64 vfsHDDFile::Write(const void* src, u64 size) if (wsize) { - if (m_hdd.Seek(m_cur_block * m_hdd_info.block_size + sizeof(vfsHDD_Block) + m_position) < HDD_OK) - { - LOG_ERROR(HLE, "Write seek to %u failed.", m_cur_block * m_hdd_info.block_size + sizeof(vfsHDD_Block) + m_position); - return HDD_SEEK_FAILURE; - } + CHECK_ASSERTION(m_hdd.Seek(m_cur_block * m_hdd_info.block_size + sizeof(vfsHDD_Block) + m_position) != -1); m_hdd.Write(src, wsize); size -= wsize; @@ -401,11 +323,7 @@ u64 vfsHDDFile::Write(const void* src, u64 size) block_info.next_block = m_cur_block; - if (m_hdd.Seek(last_block * m_hdd_info.block_size) < HDD_OK) - { - LOG_ERROR(HLE, "Write seek to %u failed.", last_block * m_hdd_info.block_size); - return HDD_SEEK_FAILURE; - } + CHECK_ASSERTION(m_hdd.Seek(last_block * m_hdd_info.block_size) != -1); if (m_hdd.Write(&block_info, sizeof(vfsHDD_Block)) != sizeof(vfsHDD_Block)) { @@ -416,11 +334,7 @@ u64 vfsHDDFile::Write(const void* src, u64 size) block_info.next_block = 0; - if (m_hdd.Seek(m_cur_block * m_hdd_info.block_size) < HDD_OK) - { - LOG_ERROR(HLE, "Write seek to %u failed.", m_cur_block * m_hdd_info.block_size); - return HDD_SEEK_FAILURE; - } + CHECK_ASSERTION(m_hdd.Seek(m_cur_block * m_hdd_info.block_size) != -1); if (m_hdd.Write(&block_info, sizeof(vfsHDD_Block)) != sizeof(vfsHDD_Block)) { @@ -473,11 +387,7 @@ vfsHDD::vfsHDD(vfsDevice* device, const std::string& hdd_path) m_hdd_info.block_size = 2048; } - if (m_hdd_file.Seek(m_cur_dir_block * m_hdd_info.block_size) < HDD_OK) - { - LOG_ERROR(HLE, "vfsHDD initialization seek to %u failed.", m_cur_dir_block * m_hdd_info.block_size); - return; - } + CHECK_ASSERTION(m_hdd_file.Seek(m_cur_dir_block * m_hdd_info.block_size) != -1); m_hdd_file.Read(&m_cur_dir, sizeof(vfsHDD_Entry)); } @@ -513,27 +423,26 @@ s32 vfsHDD::OpenDir(const std::string& name) { LOG_WARNING(HLE, "OpenDir(%s)", name.c_str()); u64 entry_block; + if (!SearchEntry(name, entry_block)) { - LOG_ERROR(HLE, "OpenDir could not find the entry. (%s)", name); - return HDD_ENTRY_NOT_FOUND; + return -1; } - if (m_hdd_file.Seek(entry_block * m_hdd_info.block_size) < HDD_OK) - { - LOG_ERROR(HLE, "OpenDir seek to %u failed.", entry_block * m_hdd_info.block_size); - return HDD_SEEK_FAILURE; - } + CHECK_ASSERTION(m_hdd_file.Seek(entry_block * m_hdd_info.block_size) != -1); vfsHDD_Entry entry; m_hdd_file.Read(&entry, sizeof(vfsHDD_Entry)); + if (entry.type == vfsHDD_Entry_File) + { return 1; + } m_cur_dir_block = entry.data_block; ReadEntry(m_cur_dir_block, m_cur_dir); - return HDD_OK; + return 0; } bool vfsHDD::Rename(const std::string& from, const std::string& to) @@ -568,99 +477,57 @@ u64 vfsHDD::FindFreeBlock() return 0; } -s32 vfsHDD::WriteBlock(u64 block, const vfsHDD_Block& data) +void vfsHDD::WriteBlock(u64 block, const vfsHDD_Block& data) { - if (m_hdd_file.Seek(block * m_hdd_info.block_size) < HDD_OK) - { - LOG_ERROR(HLE, "WriteBlock seek to %u failed.", block * m_hdd_info.block_size); - return HDD_SEEK_FAILURE; - } + CHECK_ASSERTION(m_hdd_file.Seek(block * m_hdd_info.block_size) != -1); m_hdd_file.Write(&data, sizeof(vfsHDD_Block)); - - return HDD_OK; } -s32 vfsHDD::ReadBlock(u64 block, vfsHDD_Block& data) +void vfsHDD::ReadBlock(u64 block, vfsHDD_Block& data) { - if (m_hdd_file.Seek(block * m_hdd_info.block_size) < HDD_OK) - { - LOG_ERROR(HLE, "ReadBlock seek to %u failed.", block * m_hdd_info.block_size); - return HDD_SEEK_FAILURE; - } + CHECK_ASSERTION(m_hdd_file.Seek(block * m_hdd_info.block_size) != -1); m_hdd_file.Read(&data, sizeof(vfsHDD_Block)); - - return HDD_OK; } -s32 vfsHDD::WriteEntry(u64 block, const vfsHDD_Entry& data) +void vfsHDD::WriteEntry(u64 block, const vfsHDD_Entry& data) { - if (m_hdd_file.Seek(block * m_hdd_info.block_size) < HDD_OK) - { - LOG_ERROR(HLE, "WriteEntry seek to %u failed.", block * m_hdd_info.block_size); - return HDD_SEEK_FAILURE; - } + CHECK_ASSERTION(m_hdd_file.Seek(block * m_hdd_info.block_size) != -1); m_hdd_file.Write(&data, sizeof(vfsHDD_Entry)); - - return HDD_OK; } -s32 vfsHDD::ReadEntry(u64 block, vfsHDD_Entry& data) +void vfsHDD::ReadEntry(u64 block, vfsHDD_Entry& data) { - if (m_hdd_file.Seek(block * m_hdd_info.block_size) < HDD_OK) - { - LOG_ERROR(HLE, "ReadEntry seek to %u failed.", block * m_hdd_info.block_size); - return HDD_SEEK_FAILURE; - } + CHECK_ASSERTION(m_hdd_file.Seek(block * m_hdd_info.block_size) != -1); m_hdd_file.Read(&data, sizeof(vfsHDD_Entry)); - - return HDD_OK; } -s32 vfsHDD::ReadEntry(u64 block, vfsHDD_Entry& data, std::string& name) +void vfsHDD::ReadEntry(u64 block, vfsHDD_Entry& data, std::string& name) { - if (m_hdd_file.Seek(block * m_hdd_info.block_size) < HDD_OK) - { - LOG_ERROR(HLE, "ReadEntry seek to %u failed.", block * m_hdd_info.block_size); - return HDD_SEEK_FAILURE; - } + CHECK_ASSERTION(m_hdd_file.Seek(block * m_hdd_info.block_size) != -1); m_hdd_file.Read(&data, sizeof(vfsHDD_Entry)); name.resize(GetMaxNameLen()); m_hdd_file.Read(&name.front(), GetMaxNameLen()); - - return HDD_OK; } -s32 vfsHDD::ReadEntry(u64 block, std::string& name) +void vfsHDD::ReadEntry(u64 block, std::string& name) { - if (m_hdd_file.Seek(block * m_hdd_info.block_size + sizeof(vfsHDD_Entry)) < HDD_OK) - { - LOG_ERROR(HLE, "ReadEntry seek to %u failed.", block * m_hdd_info.block_size + sizeof(vfsHDD_Entry)); - return HDD_SEEK_FAILURE; - } + CHECK_ASSERTION(m_hdd_file.Seek(block * m_hdd_info.block_size + sizeof(vfsHDD_Entry)) != -1); name.resize(GetMaxNameLen()); m_hdd_file.Read(&name.front(), GetMaxNameLen()); - - return HDD_OK; } -s32 vfsHDD::WriteEntry(u64 block, const vfsHDD_Entry& data, const std::string& name) +void vfsHDD::WriteEntry(u64 block, const vfsHDD_Entry& data, const std::string& name) { - if (m_hdd_file.Seek(block * m_hdd_info.block_size) < HDD_OK) - { - LOG_ERROR(HLE, "WriteEntry seek to %u failed.", block * m_hdd_info.block_size); - return HDD_SEEK_FAILURE; - } + CHECK_ASSERTION(m_hdd_file.Seek(block * m_hdd_info.block_size) != -1); m_hdd_file.Write(&data, sizeof(vfsHDD_Entry)); m_hdd_file.Write(name.c_str(), std::min(GetMaxNameLen() - 1, name.length() + 1)); - - return HDD_OK; } bool vfsHDD::Create(vfsHDD_EntryType type, const std::string& name) @@ -793,13 +660,13 @@ bool vfsHDD::Open(const std::string& path, u32 mode) { if (pos - from > 1) { - int res = OpenDir(std::string(s + from, pos)); + s32 res = OpenDir(std::string(s + from, pos)); + if (res == -1) { return false; } - - if (res == 1) + else if (res == 1) { file_pos = from; } diff --git a/rpcs3/Emu/HDD/HDD.h b/rpcs3/Emu/HDD/HDD.h index ff8fc476df..9bbc651f23 100644 --- a/rpcs3/Emu/HDD/HDD.h +++ b/rpcs3/Emu/HDD/HDD.h @@ -5,14 +5,6 @@ static const u64 g_hdd_magic = *(u64*)"PS3eHDD\0"; static const u16 g_hdd_version = 0x0001; -// Return codes -enum -{ - HDD_OK = 0, - HDD_SEEK_FAILURE = 0x400, - HDD_ENTRY_NOT_FOUND = 0x401, -}; - struct vfsHDD_Block { struct @@ -55,7 +47,7 @@ public: static void CreateEntry(vfsHDD_Entry& entry); - static s32 CreateHDD(const std::string& path, u64 size, u64 block_size); + static void CreateHDD(const std::string& path, u64 size, u64 block_size); void Format(); @@ -76,19 +68,19 @@ class vfsHDDFile void RemoveBlocks(u64 start_block); - s32 WriteBlock(u64 block, const vfsHDD_Block& data); + void WriteBlock(u64 block, const vfsHDD_Block& data); - s32 ReadBlock(u64 block, vfsHDD_Block& data); + void ReadBlock(u64 block, vfsHDD_Block& data); - s32 WriteEntry(u64 block, const vfsHDD_Entry& data); + void WriteEntry(u64 block, const vfsHDD_Entry& data); - s32 ReadEntry(u64 block, vfsHDD_Entry& data); + void ReadEntry(u64 block, vfsHDD_Entry& data); - s32 ReadEntry(u64 block, vfsHDD_Entry& data, std::string& name); + void ReadEntry(u64 block, vfsHDD_Entry& data, std::string& name); - s32 ReadEntry(u64 block, std::string& name); + void ReadEntry(u64 block, std::string& name); - s32 WriteEntry(u64 block, const vfsHDD_Entry& data, const std::string& name); + void WriteEntry(u64 block, const vfsHDD_Entry& data, const std::string& name); force_inline u32 GetMaxNameLen() const { @@ -122,7 +114,7 @@ public: return m_cur_block * m_hdd_info.block_size + m_position; // ??? } - s32 SaveInfo(); + void SaveInfo(); u64 Read(void* dst, u64 size); @@ -170,19 +162,19 @@ public: u64 FindFreeBlock(); - s32 WriteBlock(u64 block, const vfsHDD_Block& data); + void WriteBlock(u64 block, const vfsHDD_Block& data); - s32 ReadBlock(u64 block, vfsHDD_Block& data); + void ReadBlock(u64 block, vfsHDD_Block& data); - s32 WriteEntry(u64 block, const vfsHDD_Entry& data); + void WriteEntry(u64 block, const vfsHDD_Entry& data); - s32 ReadEntry(u64 block, vfsHDD_Entry& data); + void ReadEntry(u64 block, vfsHDD_Entry& data); - s32 ReadEntry(u64 block, vfsHDD_Entry& data, std::string& name); + void ReadEntry(u64 block, vfsHDD_Entry& data, std::string& name); - s32 ReadEntry(u64 block, std::string& name); + void ReadEntry(u64 block, std::string& name); - s32 WriteEntry(u64 block, const vfsHDD_Entry& data, const std::string& name); + void WriteEntry(u64 block, const vfsHDD_Entry& data, const std::string& name); bool Create(vfsHDD_EntryType type, const std::string& name); diff --git a/rpcs3/Emu/Memory/MemoryBlock.h b/rpcs3/Emu/Memory/MemoryBlock.h index 1f1df7d848..113f4835d1 100644 --- a/rpcs3/Emu/Memory/MemoryBlock.h +++ b/rpcs3/Emu/Memory/MemoryBlock.h @@ -87,7 +87,7 @@ public: if (!getRealAddr(addr, realAddr)) { - LOG_ERROR(HLE, "Getting the real address failed. (addr=%u)", addr); + LOG_ERROR(HLE, "Getting the real address failed. (addr=0x%x)", addr); return 0; } diff --git a/rpcs3/Emu/SysCalls/Modules/cellFs.cpp b/rpcs3/Emu/SysCalls/Modules/cellFs.cpp index c2c36a3c81..232771d4b6 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellFs.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellFs.cpp @@ -265,11 +265,11 @@ s32 cellFsReadWithOffset(u32 fd, u64 offset, vm::ptr buf, u64 buffer_size, const auto old_position = file->file->Tell(); - file->file->Seek(offset); + CHECK_ASSERTION(file->file->Seek(offset) != -1); const auto read = file->file->Read(buf.get_ptr(), buffer_size); - file->file->Seek(old_position); + CHECK_ASSERTION(file->file->Seek(old_position) != -1); if (nread) { @@ -296,11 +296,11 @@ s32 cellFsWriteWithOffset(u32 fd, u64 offset, vm::cptr buf, u64 data_size, const auto old_position = file->file->Tell(); - file->file->Seek(offset); + CHECK_ASSERTION(file->file->Seek(offset) != -1); const auto written = file->file->Write(buf.get_ptr(), data_size); - file->file->Seek(old_position); + CHECK_ASSERTION(file->file->Seek(old_position) != -1); if (nwrite) { @@ -508,9 +508,9 @@ s32 cellFsStReadStart(u32 fd, u64 offset, u64 size) // read data auto old = file->file->Tell(); - file->file->Seek(offset + file->st_total_read); + CHECK_ASSERTION(file->file->Seek(offset + file->st_total_read) != -1); auto res = file->file->Read(vm::base(position), file->st_block_size); - file->file->Seek(old); + CHECK_ASSERTION(file->file->Seek(old) != -1); // notify file->st_total_read += res; @@ -803,17 +803,27 @@ s32 sdata_unpack(const std::string& packed_file, const std::string& unpacked_fil } if (flags & 0x20) - packed_stream->Seek(0x100); + { + CHECK_ASSERTION(packed_stream->Seek(0x100) != -1); + } else - packed_stream->Seek(startOffset); + { + CHECK_ASSERTION(packed_stream->Seek(startOffset) != -1); + } for (u32 i = 0; i < blockCount; i++) { if (flags & 0x20) - packed_stream->Seek(packed_stream->Tell() + t1); + { + s64 cur; + CHECK_ASSERTION((cur = packed_stream->Tell()) != -1); + CHECK_ASSERTION(packed_stream->Seek(cur + t1) != -1); + } if (!(blockCount - i - 1)) + { blockSize = (u32)(filesizeOutput - i * blockSize); + } packed_stream->Read(buffer + 256, blockSize); unpacked_stream->Write(buffer + 256, blockSize); @@ -883,11 +893,11 @@ void fsAio(vm::ptr aio, bool write, s32 xid, fs_aio_cb_t func) const auto old_position = file->file->Tell(); - file->file->Seek(aio->offset); + CHECK_ASSERTION(file->file->Seek(aio->offset) != -1); result = write ? file->file->Write(aio->buf.get_ptr(), aio->size) : file->file->Read(aio->buf.get_ptr(), aio->size); - file->file->Seek(old_position); + CHECK_ASSERTION(file->file->Seek(old_position) != -1); } // should be executed directly by FS AIO thread diff --git a/rpcs3/Emu/SysCalls/Modules/cellResc.cpp b/rpcs3/Emu/SysCalls/Modules/cellResc.cpp index 7d77a9adb2..03812a55cf 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellResc.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellResc.cpp @@ -344,17 +344,14 @@ s32 CalculateSurfaceByteSize(u32 mode, CellRescDsts *dsts) s32 CalculateMaxColorBuffersSize() { - s32 index, oneBufSize, bufNum, totalBufSize, maxBufSize; + s32 oneBufSize, bufNum, totalBufSize, maxBufSize; maxBufSize = 0; for (u32 bufMode = CELL_RESC_720x480; bufMode <= CELL_RESC_1920x1080; bufMode <<= 1) { if (s_rescInternalInstance->m_initConfig.supportModes & bufMode) { - if ((index = GetRescDestsIndex(bufMode)) != 0) - { - oneBufSize = CalculateSurfaceByteSize(bufMode, &(s_rescInternalInstance->m_rescDsts[index])); - } + oneBufSize = CalculateSurfaceByteSize(bufMode, &(s_rescInternalInstance->m_rescDsts[GetRescDestsIndex(bufMode)])); bufNum = cellRescGetNumColorBuffers(bufMode, s_rescInternalInstance->m_initConfig.palTemporalMode, 0); totalBufSize = oneBufSize * bufNum; maxBufSize = (maxBufSize > totalBufSize) ? maxBufSize : totalBufSize; diff --git a/rpcs3/Gui/AutoPauseManager.cpp b/rpcs3/Gui/AutoPauseManager.cpp index 6e31e05f77..fd3abd43a1 100644 --- a/rpcs3/Gui/AutoPauseManager.cpp +++ b/rpcs3/Gui/AutoPauseManager.cpp @@ -79,7 +79,7 @@ void AutoPauseManagerDialog::LoadEntries(void) u32 num; size_t fmax = list.size(); size_t fcur = 0; - list.seek(0); + CHECK_ASSERTION(list.seek(0) != -1); while (fcur <= fmax - sizeof(u32)) { list.read(&num, sizeof(u32)); @@ -99,7 +99,7 @@ void AutoPauseManagerDialog::SaveEntries(void) fs::file list("pause.bin", fom::write | fom::create | fom::trunc); //System calls ID and Function calls ID are all u32 iirc. u32 num = 0; - list.seek(0); + CHECK_ASSERTION(list.seek(0) != -1); for (size_t i = 0; i < m_entries.size(); ++i) { if (num == 0xFFFFFFFF) continue; diff --git a/rpcs3/Gui/MainFrame.cpp b/rpcs3/Gui/MainFrame.cpp index 16ef7877b9..5d5c96e546 100644 --- a/rpcs3/Gui/MainFrame.cpp +++ b/rpcs3/Gui/MainFrame.cpp @@ -263,11 +263,7 @@ void MainFrame::InstallPkg(wxCommandEvent& WXUNUSED(event)) // Fetch title ID from the header char title_id[10] = "?????????"; - if (!pkg_f.seek(55)) - { - LOG_ERROR(LOADER, "PKG: Failed to seek offset 55."); - return; - } + CHECK_ASSERTION(pkg_f.seek(55) != -1); pkg_f.read(title_id, 9); pkg_f.seek(0); From 2a5f5c0dc23782a4d35327f95a159eed677a29f1 Mon Sep 17 00:00:00 2001 From: Raul Tambre Date: Sun, 8 Nov 2015 13:47:08 +0200 Subject: [PATCH 4/4] Add new VS Update 1 database format to .gitignore It can be enabled in options, under C/C++ -> Editor. It's experimental, but should be faster. It will be introduced in Update 1. --- .gitignore | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 29903b8549..8c771d5ef8 100644 --- a/.gitignore +++ b/.gitignore @@ -51,9 +51,10 @@ /bin/*.exp rpcs3/git-version.h -# Visual Studio Profiler Files +# Visual Studio Files *.vspx *.psess +*.VC.* # Copyrighted files /bin/data/