libretro: add VFS support

Author: cscd98

Source/Core/Common/CommonFuncs.h

@@ -30,10 +30,8 @@
 #define fseeko _fseeki64
 #define ftello _ftelli64
 #define atoll _atoi64
-#ifndef stat
+#ifndef __MINGW32__
 #define stat _stat64
-#endif
-#ifndef fstat
 #define fstat _fstat64
 #endif
 #define fileno _fileno

Source/Core/Common/DirectIOFile.cpp

@@ -32,6 +32,10 @@
 
 #include "Common/Assert.h"
 
+#ifdef __LIBRETRO__
+#include "DolphinLibretro/Common/File.h"
+#endif
+
 namespace File
 {
 DirectIOFile::DirectIOFile() = default;
@@ -79,6 +83,17 @@ bool DirectIOFile::Open(const std::string& path, AccessMode access_mode, OpenMod
   if (access_mode == AccessMode::Read && open_mode == OpenMode::Truncate)
     return false;
 
+#ifdef __LIBRETRO__
+  if (Libretro::File::HasVFS())
+  {
+    // used in Duplicate() later
+    m_path = path;
+
+    return Libretro::File::Open(path, access_mode, open_mode,
+                                m_vfs_handle, m_mode, m_hints, m_current_offset);
+  }
+#endif
+
 #if defined(_WIN32)
   DWORD desired_access = GENERIC_READ | GENERIC_WRITE;
   if (access_mode == AccessMode::Read)
@@ -168,6 +183,15 @@ bool DirectIOFile::Close()
 
   m_current_offset = 0;
 
+#ifdef __LIBRETRO__
+  if (Libretro::File::HasVFS())
+  {
+    int result = Libretro::File::Close(m_vfs_handle);
+    m_vfs_handle = nullptr;
+    return result == 0;
+  }
+#endif
+
 #if defined(_WIN32)
   return CloseHandle(std::exchange(m_handle, INVALID_HANDLE_VALUE)) != 0;
 #else
@@ -177,6 +201,11 @@ bool DirectIOFile::Close()
 
 bool DirectIOFile::IsOpen() const
 {
+#ifdef __LIBRETRO__
+  if (Libretro::File::HasVFS())
+    return m_vfs_handle != nullptr;
+#endif
+
 #if defined(_WIN32)
   return m_handle != INVALID_HANDLE_VALUE;
 #else
@@ -216,6 +245,17 @@ static bool OverlappedTransfer(HANDLE handle, u64 offset, auto* data_ptr, u64 si
 
 bool DirectIOFile::OffsetRead(u64 offset, u8* out_ptr, u64 size)
 {
+#ifdef __LIBRETRO__
+  if (Libretro::File::HasVFS())
+  {
+    if (Libretro::File::Seek(m_vfs_handle, offset, SEEK_SET) < 0)
+      return false;
+
+    int64_t bytes_read = Libretro::File::ReadBytes(m_vfs_handle, out_ptr, size);
+    return bytes_read == static_cast<int64_t>(size);
+  }
+#endif
+
 #if defined(_WIN32)
   return OverlappedTransfer<ReadFile>(m_handle, offset, out_ptr, size);
 #else
@@ -225,6 +265,17 @@ bool DirectIOFile::OffsetRead(u64 offset, u8* out_ptr, u64 size)
 
 bool DirectIOFile::OffsetWrite(u64 offset, const u8* in_ptr, u64 size)
 {
+#ifdef __LIBRETRO__
+  if (Libretro::File::HasVFS())
+  {
+    if (Libretro::File::Seek(m_vfs_handle, offset, SEEK_SET) < 0)
+      return false;
+
+    int64_t bytes_written = Libretro::File::WriteBytes(m_vfs_handle, in_ptr, size);
+    return bytes_written == static_cast<int64_t>(size);
+  }
+#endif
+
 #if defined(_WIN32)
   return OverlappedTransfer<WriteFile>(m_handle, offset, in_ptr, size);
 #else
@@ -234,6 +285,11 @@ bool DirectIOFile::OffsetWrite(u64 offset, const u8* in_ptr, u64 size)
 
 u64 DirectIOFile::GetSize() const
 {
+#ifdef __LIBRETRO__
+  if (Libretro::File::HasVFS())
+    return Libretro::File::GetSize(m_vfs_handle);
+#endif
+
 #if defined(_WIN32)
   LARGE_INTEGER result{};
   if (GetFileSizeEx(m_handle, &result) != 0)
@@ -275,6 +331,11 @@ bool DirectIOFile::Seek(s64 offset, SeekOrigin origin)
 
 bool DirectIOFile::Flush()
 {
+#ifdef __LIBRETRO__
+  if (Libretro::File::HasVFS())
+    return Libretro::File::Flush(m_vfs_handle) == 0;
+#endif
+
 #if defined(_WIN32)
   return FlushFileBuffers(m_handle) != 0;
 #else
@@ -284,6 +345,16 @@ bool DirectIOFile::Flush()
 
 void DirectIOFile::Swap(DirectIOFile& other)
 {
+#ifdef __LIBRETRO__
+  if (Libretro::File::HasVFS())
+  {
+    std::swap(m_vfs_handle, other.m_vfs_handle);
+    std::swap(m_path, other.m_path);
+    std::swap(m_mode, other.m_mode);
+    std::swap(m_hints, other.m_hints);
+  }
+#endif
+
 #if defined(_WIN32)
   std::swap(m_handle, other.m_handle);
 #else
@@ -299,6 +370,30 @@ DirectIOFile DirectIOFile::Duplicate() const
   if (!IsOpen())
     return result;
 
+#ifdef __LIBRETRO__
+  if (Libretro::File::HasVFS())
+  {
+    // We need to reopen the file, since VFS handles cannot be duplicated.
+    result.m_vfs_handle = Libretro::File::Open(
+      m_path, m_mode, m_hints);
+
+    if (result.m_vfs_handle)
+    {
+      result.m_path = m_path;
+      result.m_mode = m_mode;
+      result.m_hints = m_hints;
+
+      // Restore offset if possible
+      Libretro::File::Seek(
+        result.m_vfs_handle,
+        m_current_offset,
+        SEEK_SET);
+      result.m_current_offset = m_current_offset;
+    }
+    return result;
+  }
+#endif
+
 #if defined(_WIN32)
   const auto current_process = GetCurrentProcess();
   if (DuplicateHandle(current_process, m_handle, current_process, &result.m_handle, 0, FALSE,
@@ -319,6 +414,11 @@ DirectIOFile DirectIOFile::Duplicate() const
 
 bool Resize(DirectIOFile& file, u64 size)
 {
+#ifdef __LIBRETRO__
+  if (Libretro::File::HasVFS())
+    return Libretro::File::Truncate(file.m_vfs_handle, size) == 0;
+#endif
+
 #if defined(_WIN32)
   // This operation is not "atomic", but it's the only thing we're using the file pointer for.
   // Concurrent `Resize` would need some external synchronization to prevent race regardless.
@@ -333,6 +433,11 @@ bool Resize(DirectIOFile& file, u64 size)
 bool Rename(DirectIOFile& file, const std::string& source_path [[maybe_unused]],
             const std::string& destination_path)
 {
+#ifdef __LIBRETRO__
+  if (Libretro::File::HasVFS())
+    return file.IsOpen() && Libretro::File::Rename(source_path, destination_path);
+#endif
+
 #if defined(_WIN32)
   const auto dest_name = UTF8ToWString(destination_path);
   const auto dest_name_byte_size = DWORD(dest_name.size() * sizeof(WCHAR));
@@ -354,6 +459,11 @@ bool Rename(DirectIOFile& file, const std::string& source_path [[maybe_unused]],
 
 bool Delete(DirectIOFile& file, const std::string& filename)
 {
+#ifdef __LIBRETRO__
+  if (Libretro::File::HasVFS())
+    return file.IsOpen() && Libretro::File::Delete(filename);
+#endif
+
 #if defined(_WIN32)
   FILE_DISPOSITION_INFO info{.DeleteFile = TRUE};
   return SetFileInformationByHandle(file.GetHandle(), FileDispositionInfo, &info, sizeof(info)) !=

Source/Core/Common/DirectIOFile.h

@@ -111,6 +111,11 @@ class DirectIOFile final
 
   auto GetHandle() const
   {
+#ifdef __LIBRETRO__
+  if (Libretro::File::HasVFS())
+    ERROR_LOG_FMT(COMMON, "VFS: Attempt to use std::FILE in DirectIO which should not happen in VFS mode");
+#endif
+
 #if defined(_WIN32)
     return m_handle;
 #else
@@ -133,6 +138,15 @@ class DirectIOFile final
 #endif
 
   u64 m_current_offset{};
+
+#ifdef __LIBRETRO__
+  retro_vfs_file_handle* m_vfs_handle = nullptr;
+  std::string m_path;
+  unsigned m_mode{};
+  unsigned m_hints{};
+
+  friend bool Resize(DirectIOFile& file, u64 size);
+#endif
 };
 
 // These take an open file handle to avoid failures from other processes trying to open our files.