fabi/Xenia-Canary
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove vfs dependency on kernel, implement I/O completion ports

Browse Source
This commit is contained in:
Dr. Chat
2015-12-15 16:52:41 -06:00
committed by Ben Vanik
parent a5c22ec214
commit bcacb9b127
21 changed files with 385 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
src/xenia/vfs/devices/disc_image_entry.cc
View File

@@ -26,11 +26,8 @@ DiscImageEntry::DiscImageEntry(Device* device, Entry* parent, std::string path,
DiscImageEntry::~DiscImageEntry() = default;
X_STATUS DiscImageEntry::Open(kernel::KernelState* kernel_state,
uint32_t desired_access,
kernel::object_ref<kernel::XFile>* out_file) {
*out_file = kernel::object_ref<kernel::XFile>(
new DiscImageFile(kernel_state, desired_access, this));
X_STATUS DiscImageEntry::Open(uint32_t desired_access, File** out_file) {
*out_file = new DiscImageFile(desired_access, this);
return X_STATUS_SUCCESS;
}

3
src/xenia/vfs/devices/disc_image_entry.h
View File

@@ -32,8 +32,7 @@ class DiscImageEntry : public Entry {
size_t data_offset() const { return data_offset_; }
size_t data_size() const { return data_size_; }
X_STATUS Open(kernel::KernelState* kernel_state, uint32_t desired_access,
kernel::object_ref<kernel::XFile>* out_file) override;
X_STATUS Open(uint32_t desired_access, File** out_file) override;
bool can_map() const override { return true; }
std::unique_ptr<MappedMemory> OpenMapped(MappedMemory::Mode mode,

7
src/xenia/vfs/devices/disc_image_file.cc
View File

@@ -16,12 +16,13 @@
namespace xe {
namespace vfs {
DiscImageFile::DiscImageFile(kernel::KernelState* kernel_state,
uint32_t file_access, DiscImageEntry* entry)
: XFile(kernel_state, file_access, entry), entry_(entry) {}
DiscImageFile::DiscImageFile(uint32_t file_access, DiscImageEntry* entry)
: File(file_access, entry), entry_(entry) {}
DiscImageFile::~DiscImageFile() = default;
void DiscImageFile::Destroy() { delete this; }
X_STATUS DiscImageFile::ReadSync(void* buffer, size_t buffer_length,
size_t byte_offset, size_t* out_bytes_read) {
if (byte_offset >= entry_->size()) {

14
src/xenia/vfs/devices/disc_image_file.h
View File

@@ -10,22 +10,26 @@
#ifndef XENIA_VFS_DEVICES_DISC_IMAGE_FILE_H_
#define XENIA_VFS_DEVICES_DISC_IMAGE_FILE_H_
#include "xenia/kernel/xfile.h"
#include "xenia/vfs/file.h"
namespace xe {
namespace vfs {
class DiscImageEntry;
class DiscImageFile : public kernel::XFile {
class DiscImageFile : public File {
public:
DiscImageFile(kernel::KernelState* kernel_state, uint32_t file_access,
DiscImageEntry* entry);
DiscImageFile(uint32_t file_access, DiscImageEntry* entry);
~DiscImageFile() override;
protected:
void Destroy() override;
X_STATUS ReadSync(void* buffer, size_t buffer_length, size_t byte_offset,
size_t* out_bytes_read) override;
X_STATUS WriteSync(const void* buffer, size_t buffer_length,
size_t byte_offset, size_t* out_bytes_written) override {
return X_STATUS_ACCESS_DENIED;
}
private:
DiscImageEntry* entry_;

8
src/xenia/vfs/devices/host_path_entry.cc
View File

@@ -14,6 +14,7 @@
#include "xenia/base/mapped_memory.h"
#include "xenia/base/math.h"
#include "xenia/base/string.h"
#include "xenia/vfs/device.h"
#include "xenia/vfs/devices/host_path_file.h"
namespace xe {
@@ -47,9 +48,7 @@ HostPathEntry* HostPathEntry::Create(Device* device, Entry* parent,
return entry;
}
X_STATUS HostPathEntry::Open(kernel::KernelState* kernel_state,
uint32_t desired_access,
kernel::object_ref<kernel::XFile>* out_file) {
X_STATUS HostPathEntry::Open(uint32_t desired_access, File** out_file) {
if (is_read_only() && (desired_access & (FileAccess::kFileWriteData |
FileAccess::kFileAppendData))) {
XELOGE("Attempting to open file for write access on read-only device");
@@ -61,8 +60,7 @@ X_STATUS HostPathEntry::Open(kernel::KernelState* kernel_state,
// TODO(benvanik): pick correct response.
return X_STATUS_NO_SUCH_FILE;
}
*out_file = kernel::object_ref<kernel::XFile>(new HostPathFile(
kernel_state, desired_access, this, std::move(file_handle)));
*out_file = new HostPathFile(desired_access, this, std::move(file_handle));
return X_STATUS_SUCCESS;
}

3
src/xenia/vfs/devices/host_path_entry.h
View File

@@ -32,8 +32,7 @@ class HostPathEntry : public Entry {
const std::wstring& local_path() { return local_path_; }
X_STATUS Open(kernel::KernelState* kernel_state, uint32_t desired_access,
kernel::object_ref<kernel::XFile>* out_file) override;
X_STATUS Open(uint32_t desired_access, File** out_file) override;
bool can_map() const override { return true; }
std::unique_ptr<MappedMemory> OpenMapped(MappedMemory::Mode mode,

12
src/xenia/vfs/devices/host_path_file.cc
View File

@@ -15,17 +15,17 @@ namespace xe {
namespace vfs {
HostPathFile::HostPathFile(
kernel::KernelState* kernel_state, uint32_t file_access,
HostPathEntry* entry,
uint32_t file_access, HostPathEntry* entry,
std::unique_ptr<xe::filesystem::FileHandle> file_handle)
: XFile(kernel_state, file_access, entry),
file_handle_(std::move(file_handle)) {}
: File(file_access, entry), file_handle_(std::move(file_handle)) {}
HostPathFile::~HostPathFile() = default;
void HostPathFile::Destroy() { delete this; }
X_STATUS HostPathFile::ReadSync(void* buffer, size_t buffer_length,
size_t byte_offset, size_t* out_bytes_read) {
if (!(file_access() & FileAccess::kFileReadData)) {
if (!(file_access_ & FileAccess::kFileReadData)) {
return X_STATUS_ACCESS_DENIED;
}
@@ -39,7 +39,7 @@ X_STATUS HostPathFile::ReadSync(void* buffer, size_t buffer_length,
X_STATUS HostPathFile::WriteSync(const void* buffer, size_t buffer_length,
size_t byte_offset,
size_t* out_bytes_written) {
if (!(file_access() &
if (!(file_access_ &
(FileAccess::kFileWriteData | FileAccess::kFileAppendData))) {
return X_STATUS_ACCESS_DENIED;
}

10
src/xenia/vfs/devices/host_path_file.h
View File

@@ -13,21 +13,21 @@
#include <string>
#include "xenia/base/filesystem.h"
#include "xenia/kernel/xfile.h"
#include "xenia/vfs/file.h"
namespace xe {
namespace vfs {
class HostPathEntry;
class HostPathFile : public kernel::XFile {
class HostPathFile : public File {
public:
HostPathFile(kernel::KernelState* kernel_state, uint32_t file_access,
HostPathEntry* entry,
HostPathFile(uint32_t file_access, HostPathEntry* entry,
std::unique_ptr<xe::filesystem::FileHandle> file_handle);
~HostPathFile() override;
protected:
void Destroy() override;
X_STATUS ReadSync(void* buffer, size_t buffer_length, size_t byte_offset,
size_t* out_bytes_read) override;
X_STATUS WriteSync(const void* buffer, size_t buffer_length,

7
src/xenia/vfs/devices/stfs_container_entry.cc
View File

@@ -24,11 +24,8 @@ StfsContainerEntry::StfsContainerEntry(Device* device, Entry* parent,
StfsContainerEntry::~StfsContainerEntry() = default;
X_STATUS StfsContainerEntry::Open(kernel::KernelState* kernel_state,
uint32_t desired_access,
kernel::object_ref<kernel::XFile>* out_file) {
*out_file = kernel::object_ref<kernel::XFile>(
new StfsContainerFile(kernel_state, desired_access, this));
X_STATUS StfsContainerEntry::Open(uint32_t desired_access, File** out_file) {
*out_file = new StfsContainerFile(desired_access, this);
return X_STATUS_SUCCESS;
}

4
src/xenia/vfs/devices/stfs_container_entry.h
View File

@@ -16,6 +16,7 @@
#include "xenia/base/filesystem.h"
#include "xenia/base/mapped_memory.h"
#include "xenia/vfs/entry.h"
#include "xenia/vfs/file.h"
namespace xe {
namespace vfs {
@@ -32,8 +33,7 @@ class StfsContainerEntry : public Entry {
size_t data_offset() const { return data_offset_; }
size_t data_size() const { return data_size_; }
X_STATUS Open(kernel::KernelState* kernel_state, uint32_t desired_access,
kernel::object_ref<kernel::XFile>* out_file) override;
X_STATUS Open(uint32_t desired_access, File** out_file) override;
struct BlockRecord {
size_t offset;

7
src/xenia/vfs/devices/stfs_container_file.cc
View File

@@ -16,13 +16,14 @@
namespace xe {
namespace vfs {
StfsContainerFile::StfsContainerFile(kernel::KernelState* kernel_state,
uint32_t file_access,
StfsContainerFile::StfsContainerFile(uint32_t file_access,
StfsContainerEntry* entry)
: XFile(kernel_state, file_access, entry), entry_(entry) {}
: File(file_access, entry) {}
StfsContainerFile::~StfsContainerFile() = default;
void StfsContainerFile::Destroy() { delete this; }
X_STATUS StfsContainerFile::ReadSync(void* buffer, size_t buffer_length,
size_t byte_offset,
size_t* out_bytes_read) {

16
src/xenia/vfs/devices/stfs_container_file.h
View File

@@ -10,22 +10,28 @@
#ifndef XENIA_VFS_DEVICES_STFS_CONTAINER_FILE_H_
#define XENIA_VFS_DEVICES_STFS_CONTAINER_FILE_H_
#include "xenia/kernel/xfile.h"
#include "xenia/vfs/file.h"
#include "xenia/xbox.h"
namespace xe {
namespace vfs {
class StfsContainerEntry;
class StfsContainerFile : public kernel::XFile {
class StfsContainerFile : public File {
public:
StfsContainerFile(kernel::KernelState* kernel_state, uint32_t file_access,
StfsContainerEntry* entry);
StfsContainerFile(uint32_t file_access, StfsContainerEntry* entry);
~StfsContainerFile() override;
protected:
void Destroy() override;
X_STATUS ReadSync(void* buffer, size_t buffer_length, size_t byte_offset,
size_t* out_bytes_read) override;
X_STATUS WriteSync(const void* buffer, size_t buffer_length,
size_t byte_offset, size_t* out_bytes_written) override {
return X_STATUS_ACCESS_DENIED;
}
private:
StfsContainerEntry* entry_;