file_object.h

Go to the documentation of this file.

 
#pragma once
 
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
#include <rex/platform.h>
#include <rex/types.h>
#include <rex/assert.h>
#include <rex/platform/thread.h>
#include <rex/utility.h>
#include <rex/platform/sync.h>
#include <rex/result.h>
#include <rex/kernel/types/status.h>
#include <rex/kernel/types/io.h>
#include <rex/kernel/object/object.h>
 
namespace rex {
namespace filesystem {
class IDirectory;
class IFile;
class IFileSystem;
struct FileStat;
}  // namespace filesystem
namespace kernel {
class TitleRuntime;
}  // namespace kernel
}  // namespace rex
 
namespace rex::kernel {
 
class IObjectTable;
 
enum class SeekOrigin : u8 {
  kBegin = 0,
  kCurrent = 1,
  kEnd = 2,
};

class X_FILE_DIRECTORY_INFORMATION {
 public:
  be_u32 next_entry_offset; 
  be_u32 file_index;
  be_u64 creation_time;
  be_u64 last_access_time;
  be_u64 last_write_time;
  be_u64 change_time;
  be_u64 end_of_file;
  be_u64 allocation_size; 
  be_u32 attributes;
  be_u32 file_name_length; 
  char file_name[1];       

  void Write(u8* base, u32 guest_address) {
    u8* dst = base + guest_address;
    u8* src = reinterpret_cast<u8*>(this);
    X_FILE_DIRECTORY_INFORMATION* right;
    do {
      auto left = reinterpret_cast<X_FILE_DIRECTORY_INFORMATION*>(dst);
      right = reinterpret_cast<X_FILE_DIRECTORY_INFORMATION*>(src);
      left->next_entry_offset = right->next_entry_offset;
      left->file_index = right->file_index;
      left->creation_time = right->creation_time;
      left->last_access_time = right->last_access_time;
      left->last_write_time = right->last_write_time;
      left->change_time = right->change_time;
      left->end_of_file = right->end_of_file;
      left->allocation_size = right->allocation_size;
      left->attributes = right->attributes;
      left->file_name_length = right->file_name_length;
      std::memcpy(left->file_name, right->file_name, right->file_name_length);
 
      dst += right->next_entry_offset;
      src += right->next_entry_offset;
    } while (right->next_entry_offset != 0);
  }
};
REX_STATIC_ASSERT_SIZE(X_FILE_DIRECTORY_INFORMATION, 0x48);

class IOpenedFile {
 public:
  virtual ~IOpenedFile() = default;

  virtual X_STATUS Read(u32 buffer_address, u32 buffer_length, u64 byte_offset, u32* out_bytes_read,
                        u32 apc_context, bool notify_completion = true) = 0;

  virtual X_STATUS Write(u32 buffer_address, u32 buffer_length, u64 byte_offset,
                         u32* out_bytes_written, u32 apc_context) = 0;

  virtual u64 Seek(i64 distance, SeekOrigin origin) = 0;

  virtual X_STATUS SetLengthToPosition() = 0;

  virtual void SetFindPattern(std::string_view pattern) = 0;

  virtual std::optional<filesystem::FileStat> FindNext() = 0;
 
  virtual u64 GetSize() = 0;
 
  virtual std::string GetAbsolutePath() = 0;
};
 
struct FileObject : IOpenedFile {
  REX_KERNEL_API FileObject(std::unique_ptr<filesystem::IFile> file_in, bool synchronous);

  REX_KERNEL_API ~FileObject();
 
  std::unique_ptr<filesystem::IFile> file;
  std::unique_ptr<rex::platform::Event> async_event;
  mutable std::mutex file_lock;    
  std::mutex completion_port_lock; 
  std::vector<std::pair<u32, X_HANDLE>> completion_ports;
  IObjectTable* port_table = nullptr;
  PropagateConst<std::unique_ptr<filesystem::IDirectory>> find;
  bool is_synchronous = false;
  TitleRuntime* owner = nullptr;

  REX_KERNEL_API X_STATUS ReadScatter(TitleRuntime& runtime, u32 segments_address, u32 length,
                                      u64 byte_offset, u32* out_bytes_read, u32 apc_context);

  REX_KERNEL_API X_STATUS Read(TitleRuntime& runtime, u32 buffer_address, u32 buffer_length,
                               u64 byte_offset, u32* out_bytes_read, u32 apc_context,
                               bool notify_completion = true);
 
  X_STATUS Read(u32 buffer_address, u32 buffer_length, u64 byte_offset, u32* out_bytes_read,
                u32 apc_context, bool notify_completion = true) override {
    return Read(*owner, buffer_address, buffer_length, byte_offset, out_bytes_read, apc_context,
                notify_completion);
  }

  REX_KERNEL_API X_STATUS Write(TitleRuntime& runtime, u32 buffer_address, u32 buffer_length,
                                u64 byte_offset, u32* out_bytes_written, u32 apc_context);
 
  X_STATUS Write(u32 buffer_address, u32 buffer_length, u64 byte_offset, u32* out_bytes_written,
                 u32 apc_context) override {
    return Write(*owner, buffer_address, buffer_length, byte_offset, out_bytes_written,
                 apc_context);
  }

  REX_KERNEL_API X_STATUS QueryDirectory(TitleRuntime& runtime,
                                         X_FILE_DIRECTORY_INFORMATION* out_info, size_t length,
                                         std::string_view file_name, bool restart);

  REX_KERNEL_API X_STATUS SetLength(u64 length);

  REX_KERNEL_API X_STATUS SetAllocation(u64 size);

  REX_KERNEL_API X_STATUS Rename(filesystem::IFileSystem& file_system, std::string_view path,
                                 bool replace_existing, FileObject* root);
 
  REX_KERNEL_API u64 Seek(i64 distance, SeekOrigin origin) override;
 
  REX_KERNEL_API X_STATUS SetLengthToPosition() override;
 
  REX_KERNEL_API void SetPosition(u64 value);
 
  REX_KERNEL_API u64 GetPosition();
 
  REX_KERNEL_API void SetFindPattern(std::string_view pattern) override;
 
  REX_KERNEL_API std::optional<filesystem::FileStat> FindNext() override;
 
  REX_KERNEL_API u64 GetSize() override;
 
  REX_KERNEL_API std::string GetAbsolutePath() override;

  REX_KERNEL_API void RegisterIOCompletionPort(TitleRuntime& runtime, u32 key, X_HANDLE port);
 
 private:
  X_STATUS ReadInternal(TitleRuntime& runtime, u32 buffer_address, u32 buffer_length,
                        u64 byte_offset, u32* out_bytes_read, u32 apc_context,
                        bool notify_completion);
 
  u64 position_ = 0; 
};
 
}  // namespace rex::kernel