eden-emu
/
eden
mirror of https://git.eden-emu.dev/eden-emu/eden.git
1
0
Fork 0
Code Releases Wiki Activity
Browse Source

Add for windows and Android

lizzie 2 weeks ago
committed by crueter
parent
e3c63f08f1
commit
f7c356746b
2 changed files with 355 additions and 324 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 171
      src/common/fs/file.cpp
  2. 32
      src/common/fs/file.h

171
src/common/fs/file.cpp
View File

@ -18,6 +18,7 @@
#ifdef _WIN32 #ifdef _WIN32
#include <io.h> #include <io.h>
#include <share.h> #include <share.h>
#include <windows.h>
#else #else
#include <unistd.h> #include <unistd.h>
#include <sys/mman.h> #include <sys/mman.h>
@ -248,40 +249,13 @@ FileType IOFile::GetType() const {
return file_type; return file_type;
} }
void IOFile::Open(const fs::path& path, FileAccessMode mode, FileType type, FileShareFlag flag) {
Close();
file_path = path;
file_access_mode = mode;
file_type = type;
errno = 0;
#ifdef _WIN32
if (flag != FileShareFlag::ShareNone) {
file = _wfsopen(path.c_str(), AccessModeToWStr(mode, type), ToWindowsFileShareFlag(flag));
} else {
_wfopen_s(&file, path.c_str(), AccessModeToWStr(mode, type));
}
#elif ANDROID
if (Android::IsContentUri(path)) {
ASSERT_MSG(mode == FileAccessMode::Read, "Content URI file access is for read-only!");
auto const fd = Android::OpenContentUri(path, Android::OpenMode::Read);
if (fd != -1) {
file = fdopen(fd, "r");
if (errno != 0 && file == nullptr)
LOG_ERROR(Common_Filesystem, "Error opening file: {}, error: {}", path.c_str(), strerror(errno));
} else {
LOG_ERROR(Common_Filesystem, "Error opening file: {}", path.c_str());
}
} else {
file = std::fopen(path.c_str(), AccessModeToStr(mode, type));
}
#elif defined(__HAIKU__) || defined(__managarm__) || defined(__OPENORBIS__) || defined(__APPLE__)
file = std::fopen(path.c_str(), AccessModeToStr(mode, type));
#elif defined(__unix__)
if (type == FileType::BinaryFile && mode == FileAccessMode::Read) {
#ifdef __unix__
int PlatformMapReadOnly(IOFile& io, const char* path) {
io.mmap_fd = open(path., O_RDONLY);
if (io.mmap_fd > 0) {
struct stat st; struct stat st;
mmap_fd = open(path.c_str(), O_RDONLY);
fstat(mmap_fd, &st);
mmap_size = st.st_size;
fstat(io.mmap_fd, &st);
io.mmap_size = st.st_size;
int map_flags = MAP_PRIVATE; int map_flags = MAP_PRIVATE;
#ifdef MAP_PREFAULT_READ #ifdef MAP_PREFAULT_READ
@ -315,17 +289,96 @@ void IOFile::Open(const fs::path& path, FileAccessMode mode, FileType type, File
u64 big_file_threshold = 512_MiB; u64 big_file_threshold = 512_MiB;
map_flags |= u64(st.st_size) >= big_file_threshold ? MAP_ALIGNED_SUPER : 0; map_flags |= u64(st.st_size) >= big_file_threshold ? MAP_ALIGNED_SUPER : 0;
#endif #endif
mmap_base = (u8*)mmap(nullptr, mmap_size, PROT_READ, map_flags, mmap_fd, 0);
if (mmap_base == MAP_FAILED) {
close(mmap_fd);
mmap_fd = -1;
io.mmap_base = (u8*)mmap(nullptr, io.mmap_size, PROT_READ, map_flags, io.mmap_fd, 0);
if (io.mmap_base == MAP_FAILED) {
close(io.mmap_fd);
io.mmap_fd = -1;
} else { } else {
posix_madvise(mmap_base, mmap_size, POSIX_MADV_WILLNEED);
posix_madvise(mmap_base, io.mmap_size, POSIX_MADV_WILLNEED);
} }
} }
// mmap(2) failed or simply we can't use it
if (mmap_fd == -1) {
return io.mmap_fd;
}
void PlatformUnmap(IOFile& io) {
if (io.mmap_fd != -1) {
munmap(io.mmap_base, io.mmap_size);
close(io.mmap_fd);
io.mmap_fd = -1;
}
}
#else
int PlatformMapReadOnly(IOFile& io, const char* path) {
io.file_handle = CreateFileA(path, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, nullptr);
if (HANDLE(io.file_handle) != INVALID_HANDLE_VALUE) {
io.mapping_handle = CreateFileMappingW(file_handle, nullptr, PAGE_READONLY, 0, 0, nullptr);
if (io.mapping_handle) {
io.mmap_base = (char const*)MapViewOfFile(HANDLE(io.mapping_handle), FILE_MAP_READ, 0, 0, 0);
if (io.mmap_base) {
_LARGE_INTEGER pvalue;
GetFileSizeEx(file_handle, &pvalue);
io.mmap_size = uint32_t(pvalue.QuadPart);
} else {
CloseHandle(io.mapping_handle);
CloseHandle(io.file_handle);
return -1;
}
} else {
CloseHandle(io.file_handle);
return -1;
}
}
return 0;
}
void PlatformUnmap(IOFile& io) {
if(io.mapping_handle) {
if(io.mmap_base)
UnmapViewOfFile(HANDLE(io.mmap_base));
CloseHandle(HANDLE(io.mapping_handle));
}
if(io.file_handle != INVALID_HANDLE_VALUE)
CloseHandle(HANDLE(io.file_handle));
}
#endif
void IOFile::Open(const fs::path& path, FileAccessMode mode, FileType type, FileShareFlag flag) {
Close();
file_path = path;
file_access_mode = mode;
file_type = type;
errno = 0;
#ifdef _WIN32
if (flag != FileShareFlag::ShareNone) {
file = _wfsopen(path.c_str(), AccessModeToWStr(mode, type), ToWindowsFileShareFlag(flag));
} else {
_wfopen_s(&file, path.c_str(), AccessModeToWStr(mode, type));
}
#elif ANDROID
if (Android::IsContentUri(path)) {
ASSERT_MSG(mode == FileAccessMode::Read, "Content URI file access is for read-only!");
if (PlatformMapReadOnly(*this, path.c_str()) == -1) {
LOG_ERROR(Common_Filesystem, "Error mmap'ing file: {}", path.c_str());
int const fd = Android::OpenContentUri(path, Android::OpenMode::Read);
if (fd != -1) {
file = fdopen(fd, "r");
if (errno != 0 && file == nullptr)
LOG_ERROR(Common_Filesystem, "Error opening file: {}, error: {}", path.c_str(), strerror(errno));
} else {
LOG_ERROR(Common_Filesystem, "Error opening file: {}", path.c_str());
}
}
} else {
file = std::fopen(path.c_str(), AccessModeToStr(mode, type));
}
#elif defined(__HAIKU__) || defined(__managarm__) || defined(__OPENORBIS__) || defined(__APPLE__)
file = std::fopen(path.c_str(), AccessModeToStr(mode, type)); file = std::fopen(path.c_str(), AccessModeToStr(mode, type));
#elif defined(__unix__)
if (type == FileType::BinaryFile && mode == FileAccessMode::Read) {
if (PlatformMapReadOnly(*this, path.c_str()) == -1) {
LOG_ERROR(Common_Filesystem, "Error mmap'ing file: {}", path.c_str());
}
}
if (mmap_fd == -1) {
file = std::fopen(path.c_str(), AccessModeToStr(mode, type)); // mmap(2) failed or simply we can't use it
} }
#else #else
// Some other fancy OS (ahem fucking Darwin/Mac OSX) // Some other fancy OS (ahem fucking Darwin/Mac OSX)
@ -339,13 +392,7 @@ void IOFile::Open(const fs::path& path, FileAccessMode mode, FileType type, File
} }
void IOFile::Close() { void IOFile::Close() {
#ifdef __unix__
if (mmap_fd != -1) {
munmap(mmap_base, mmap_size);
close(mmap_fd);
mmap_fd = -1;
}
#endif
PlatformUnmap(*this);
if (file) { if (file) {
errno = 0; errno = 0;
const auto close_result = std::fclose(file) == 0; const auto close_result = std::fclose(file) == 0;
@ -359,11 +406,7 @@ void IOFile::Close() {
} }
bool IOFile::IsOpen() const { bool IOFile::IsOpen() const {
#ifdef __unix__
return file != nullptr || mmap_fd != -1;
#else
return file != nullptr;
#endif
return file != nullptr || IsMappedFile();
} }
std::string IOFile::ReadString(size_t length) const { std::string IOFile::ReadString(size_t length) const {
@ -380,9 +423,7 @@ size_t IOFile::WriteString(std::span<const char> string) const {
} }
bool IOFile::Flush() const { bool IOFile::Flush() const {
#ifdef __unix__
ASSERT(mmap_fd == -1);
#endif
ASSERT(!IsMappedFile());
if (file) { if (file) {
errno = 0; errno = 0;
auto const flush_result = std::fflush(file) == 0; auto const flush_result = std::fflush(file) == 0;
@ -397,9 +438,7 @@ bool IOFile::Flush() const {
} }
bool IOFile::Commit() const { bool IOFile::Commit() const {
#ifdef __unix__
ASSERT(mmap_fd == -1);
#endif
ASSERT(!IsMappedFile());
if (file) { if (file) {
errno = 0; errno = 0;
#ifdef _WIN32 #ifdef _WIN32
@ -418,9 +457,7 @@ bool IOFile::Commit() const {
} }
bool IOFile::SetSize(u64 size) const { bool IOFile::SetSize(u64 size) const {
#ifdef __unix__
ASSERT(mmap_fd == -1);
#endif
ASSERT(!IsMappedFile());
if (file) { if (file) {
errno = 0; errno = 0;
#ifdef _WIN32 #ifdef _WIN32
@ -439,10 +476,8 @@ bool IOFile::SetSize(u64 size) const {
} }
u64 IOFile::GetSize() const { u64 IOFile::GetSize() const {
#ifdef __unix__
if (mmap_fd != -1)
if (IsMappedFile())
return mmap_size; return mmap_size;
#endif
if (file) { if (file) {
// Flush any unwritten buffered data into the file prior to retrieving the file mmap_size. // Flush any unwritten buffered data into the file prior to retrieving the file mmap_size.
std::fflush(file); std::fflush(file);
@ -476,8 +511,7 @@ u64 IOFile::GetSize() const {
} }
bool IOFile::Seek(s64 offset, SeekOrigin origin) const { bool IOFile::Seek(s64 offset, SeekOrigin origin) const {
#ifdef __unix__
if (mmap_fd != -1) {
if (IsMappedFile()) {
// fuck you to whoever made this method const // fuck you to whoever made this method const
switch (origin) { switch (origin) {
case SeekOrigin::SetOrigin: case SeekOrigin::SetOrigin:
@ -492,7 +526,6 @@ bool IOFile::Seek(s64 offset, SeekOrigin origin) const {
} }
return true; return true;
} }
#endif
if (file) { if (file) {
errno = 0; errno = 0;
const auto seek_result = fseeko(file, offset, ToSeekOrigin(origin)) == 0; const auto seek_result = fseeko(file, offset, ToSeekOrigin(origin)) == 0;
@ -507,12 +540,10 @@ bool IOFile::Seek(s64 offset, SeekOrigin origin) const {
} }
s64 IOFile::Tell() const { s64 IOFile::Tell() const {
#ifdef __unix__
if (mmap_fd != -1) {
if (IsMappedFile()) {
errno = 0; errno = 0;
return s64(mmap_offset); return s64(mmap_offset);
} }
#endif
if (file) { if (file) {
errno = 0; errno = 0;
return ftello(file); return ftello(file);

32
src/common/fs/file.h
View File

@ -268,12 +268,10 @@ public:
template <typename T> template <typename T>
[[nodiscard]] size_t ReadSpan(std::span<T> data) const { [[nodiscard]] size_t ReadSpan(std::span<T> data) const {
static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable."); static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
#ifdef __unix__
if (mmap_fd != -1) {
if (IsMappedFile()) {
std::memcpy(data.data(), mmap_base + mmap_offset, sizeof(T) * data.size()); std::memcpy(data.data(), mmap_base + mmap_offset, sizeof(T) * data.size());
return data.size(); return data.size();
} }
#endif
return IsOpen() ? std::fread(data.data(), sizeof(T), data.size(), file) : 0; return IsOpen() ? std::fread(data.data(), sizeof(T), data.size(), file) : 0;
} }
@ -295,12 +293,10 @@ public:
template <typename T> template <typename T>
[[nodiscard]] size_t WriteSpan(std::span<const T> data) const { [[nodiscard]] size_t WriteSpan(std::span<const T> data) const {
static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable."); static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
#ifdef __unix__
if (mmap_fd != -1) {
if (IsMappedFile()) {
std::memcpy(mmap_base + mmap_offset, data.data(), sizeof(T) * data.size()); std::memcpy(mmap_base + mmap_offset, data.data(), sizeof(T) * data.size());
return data.size(); return data.size();
} }
#endif
return IsOpen() ? std::fwrite(data.data(), sizeof(T), data.size(), file) : 0; return IsOpen() ? std::fwrite(data.data(), sizeof(T), data.size(), file) : 0;
} }
@ -324,12 +320,10 @@ public:
[[nodiscard]] bool ReadObject(T& object) const { [[nodiscard]] bool ReadObject(T& object) const {
static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable."); static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
static_assert(!std::is_pointer_v<T>, "T must not be a pointer to an object."); static_assert(!std::is_pointer_v<T>, "T must not be a pointer to an object.");
#ifdef __unix__
if (mmap_fd != -1) {
if (IsMappedFile()) {
std::memcpy(&object, mmap_base + mmap_offset, sizeof(T)); std::memcpy(&object, mmap_base + mmap_offset, sizeof(T));
return sizeof(T); return sizeof(T);
} }
#endif
return IsOpen() ? std::fread(&object, sizeof(T), 1, file) == 1 : false; return IsOpen() ? std::fread(&object, sizeof(T), 1, file) == 1 : false;
} }
@ -352,12 +346,10 @@ public:
[[nodiscard]] bool WriteObject(const T& object) const { [[nodiscard]] bool WriteObject(const T& object) const {
static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable."); static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
static_assert(!std::is_pointer_v<T>, "T must not be a pointer to an object."); static_assert(!std::is_pointer_v<T>, "T must not be a pointer to an object.");
#ifdef __unix__
if (mmap_fd != -1) {
if (IsMappedFile()) {
std::memcpy(mmap_base + mmap_offset, &object, sizeof(T)); std::memcpy(mmap_base + mmap_offset, &object, sizeof(T));
return sizeof(T); return sizeof(T);
} }
#endif
return IsOpen() ? std::fwrite(&object, sizeof(T), 1, file) == 1 : false; return IsOpen() ? std::fwrite(&object, sizeof(T), 1, file) == 1 : false;
} }
@ -446,13 +438,21 @@ private:
FileAccessMode file_access_mode{}; FileAccessMode file_access_mode{};
FileType file_type{}; FileType file_type{};
std::FILE* file = nullptr; std::FILE* file = nullptr;
#ifdef __unix__
// Any decent system should have mmap() for files
// Systems with artifical mmap() limitations should simply change the logic within file.cpp
// and reduce the threshold for which the mmap() is set to
#ifdef _WIN32
void *mapping_handle = nullptr;
void *file_handle = nullptr;
bool IsMappedFile() { return file_handle != nullptr; }
#else // POSIX
int mmap_fd = -1; int mmap_fd = -1;
bool IsMappedFile() { return mmap_fd != -1; }
#endif
u8* mmap_base = nullptr; u8* mmap_base = nullptr;
size_t mmap_size = 0; size_t mmap_size = 0;
// fuck you
mutable off_t mmap_offset = 0;
#endif
mutable off_t mmap_offset = 0; // fuck you
}; };
} // namespace Common::FS } // namespace Common::FS
Write Preview
Loading…
Cancel
Save