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_;

8
src/xenia/vfs/entry.h
View File

@@ -18,7 +18,6 @@
#include "xenia/base/mapped_memory.h"
#include "xenia/base/mutex.h"
#include "xenia/base/string_buffer.h"
#include "xenia/kernel/xobject.h"
#include "xenia/xbox.h"
namespace xe {
@@ -32,6 +31,7 @@ namespace xe {
namespace vfs {
class Device;
class File;
// Matches http://source.winehq.org/source/include/winternl.h#1591.
enum class FileAction {
@@ -106,9 +106,9 @@ class Entry {
bool Delete();
void Touch();
virtual X_STATUS Open(kernel::KernelState* kernel_state,
uint32_t desired_access,
kernel::object_ref<kernel::XFile>* out_file) = 0;
// If successful, out_file points to a new file. When finished, call
// file->Destroy()
virtual X_STATUS Open(uint32_t desired_access, File** out_file) = 0;
virtual bool can_map() const { return false; }
virtual std::unique_ptr<MappedMemory> OpenMapped(MappedMemory::Mode mode,

61
src/xenia/vfs/file.h Normal file
View File

@@ -0,0 +1,61 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2015 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_VFS_FILE_H_
#define XENIA_VFS_FILE_H_
#include <cstdint>
#include "xenia/xbox.h"
namespace xe {
namespace vfs {
class Entry;
class File {
public:
File(uint32_t file_access, Entry* entry)
: file_access_(file_access), entry_(entry) {}
virtual ~File() = default;
virtual void Destroy() = 0;
virtual X_STATUS ReadSync(void* buffer, size_t buffer_length,
size_t byte_offset, size_t* out_bytes_read) = 0;
virtual X_STATUS WriteSync(const void* buffer, size_t buffer_length,
size_t byte_offset, size_t* out_bytes_written) = 0;
// TODO: Parameters
virtual X_STATUS ReadAsync(void* buffer, size_t buffer_length,
size_t byte_offset, size_t* out_bytes_read) {
return X_STATUS_NOT_IMPLEMENTED;
}
// TODO: Parameters
virtual X_STATUS WriteAsync(const void* buffer, size_t buffer_length,
size_t byte_offset, size_t* out_bytes_written) {
return X_STATUS_NOT_IMPLEMENTED;
}
// xe::filesystem::FileAccess
uint32_t file_access() const { return file_access_; }
const Entry* entry() const { return entry_; }
Entry* entry() { return entry_; }
protected:
// xe::filesystem::FileAccess
uint32_t file_access_ = 0;
Entry* entry_ = nullptr;
};
} // namespace vfs
} // namespace xe
#endif // XENIA_VFS_FILE_H_

10
src/xenia/vfs/virtual_file_system.cc
View File

@@ -140,10 +140,10 @@ bool VirtualFileSystem::DeletePath(std::string path) {
return parent->Delete(entry);
}
X_STATUS VirtualFileSystem::OpenFile(
kernel::KernelState* kernel_state, std::string path,
FileDisposition creation_disposition, uint32_t desired_access,
kernel::object_ref<kernel::XFile>* out_file, FileAction* out_action) {
X_STATUS VirtualFileSystem::OpenFile(std::string path,
FileDisposition creation_disposition,
uint32_t desired_access, File** out_file,
FileAction* out_action) {
// Cleanup access.
if (desired_access & FileAccess::kGenericRead) {
desired_access |= FileAccess::kFileReadData;
@@ -253,7 +253,7 @@ X_STATUS VirtualFileSystem::OpenFile(
}
// Open.
auto result = entry->Open(kernel_state, desired_access, out_file);
auto result = entry->Open(desired_access, out_file);
if (XFAILED(result)) {
*out_action = FileAction::kDoesNotExist;
}

8
src/xenia/vfs/virtual_file_system.h
View File

@@ -16,9 +16,9 @@
#include <vector>
#include "xenia/base/mutex.h"
#include "xenia/kernel/xobject.h"
#include "xenia/vfs/device.h"
#include "xenia/vfs/entry.h"
#include "xenia/vfs/file.h"
namespace xe {
namespace vfs {
@@ -39,10 +39,8 @@ class VirtualFileSystem {
Entry* CreatePath(std::string path, uint32_t attributes);
bool DeletePath(std::string path);
X_STATUS OpenFile(kernel::KernelState* kernel_state, std::string path,
FileDisposition creation_disposition,
uint32_t desired_access,
kernel::object_ref<kernel::XFile>* out_file,
X_STATUS OpenFile(std::string path, FileDisposition creation_disposition,
uint32_t desired_access, File** out_file,
FileAction* out_action);
private: