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

xb style.

Browse Source
This commit is contained in:
Ben Vanik
2015-08-07 07:56:57 -07:00
parent 5e08889d93
commit 14beb27ebc
63 changed files with 338 additions and 331 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/xenia/vfs/device.h
View File

@@ -22,7 +22,7 @@ namespace vfs {
class Device {
public:
Device(const std::string& path);
explicit Device(const std::string& path);
virtual ~Device();
virtual bool Initialize() = 0;

39
src/xenia/vfs/devices/disc_image_device.cc
View File

@@ -34,13 +34,13 @@ bool DiscImageDevice::Initialize() {
ParseState state = {0};
state.ptr = mmap_->data();
state.size = mmap_->size();
auto result = Verify(state);
auto result = Verify(&state);
if (result != Error::kSuccess) {
XELOGE("Failed to verify disc image header: %d", result);
return false;
}
result = ReadAllEntries(state, state.ptr + state.root_offset);
result = ReadAllEntries(&state, state.ptr + state.root_offset);
if (result != Error::kSuccess) {
XELOGE("Failed to read all GDFX entries: %d", result);
return false;
@@ -49,15 +49,15 @@ bool DiscImageDevice::Initialize() {
return true;
}
DiscImageDevice::Error DiscImageDevice::Verify(ParseState& state) {
DiscImageDevice::Error DiscImageDevice::Verify(ParseState* state) {
// Find sector 32 of the game partition - try at a few points.
static const size_t likely_offsets[] = {
0x00000000, 0x0000FB20, 0x00020600, 0x0FD90000,
};
bool magic_found = false;
for (size_t n = 0; n < xe::countof(likely_offsets); n++) {
state.game_offset = likely_offsets[n];
if (VerifyMagic(state, state.game_offset + (32 * kXESectorSize))) {
state->game_offset = likely_offsets[n];
if (VerifyMagic(state, state->game_offset + (32 * kXESectorSize))) {
magic_found = true;
break;
}
@@ -68,27 +68,28 @@ DiscImageDevice::Error DiscImageDevice::Verify(ParseState& state) {
}
// Read sector 32 to get FS state.
if (state.size < state.game_offset + (32 * kXESectorSize)) {
if (state->size < state->game_offset + (32 * kXESectorSize)) {
return Error::kErrorReadError;
}
uint8_t* fs_ptr = state.ptr + state.game_offset + (32 * kXESectorSize);
state.root_sector = xe::load<uint32_t>(fs_ptr + 20);
state.root_size = xe::load<uint32_t>(fs_ptr + 24);
state.root_offset = state.game_offset + (state.root_sector * kXESectorSize);
if (state.root_size < 13 || state.root_size > 32 * 1024 * 1024) {
uint8_t* fs_ptr = state->ptr + state->game_offset + (32 * kXESectorSize);
state->root_sector = xe::load<uint32_t>(fs_ptr + 20);
state->root_size = xe::load<uint32_t>(fs_ptr + 24);
state->root_offset =
state->game_offset + (state->root_sector * kXESectorSize);
if (state->root_size < 13 || state->root_size > 32 * 1024 * 1024) {
return Error::kErrorDamagedFile;
}
return Error::kSuccess;
}
bool DiscImageDevice::VerifyMagic(ParseState& state, size_t offset) {
bool DiscImageDevice::VerifyMagic(ParseState* state, size_t offset) {
// Simple check to see if the given offset contains the magic value.
return std::memcmp(state.ptr + offset, "MICROSOFT*XBOX*MEDIA", 20) == 0;
return std::memcmp(state->ptr + offset, "MICROSOFT*XBOX*MEDIA", 20) == 0;
}
DiscImageDevice::Error DiscImageDevice::ReadAllEntries(
ParseState& state, const uint8_t* root_buffer) {
ParseState* state, const uint8_t* root_buffer) {
auto root_entry = new DiscImageEntry(this, nullptr, "", mmap_.get());
root_entry->attributes_ = kFileAttributeDirectory;
root_entry_ = std::unique_ptr<Entry>(root_entry);
@@ -100,7 +101,7 @@ DiscImageDevice::Error DiscImageDevice::ReadAllEntries(
return Error::kSuccess;
}
bool DiscImageDevice::ReadEntry(ParseState& state, const uint8_t* buffer,
bool DiscImageDevice::ReadEntry(ParseState* state, const uint8_t* buffer,
uint16_t entry_ordinal,
DiscImageEntry* parent) {
const uint8_t* p = buffer + (entry_ordinal * 4);
@@ -111,7 +112,7 @@ bool DiscImageDevice::ReadEntry(ParseState& state, const uint8_t* buffer,
size_t length = xe::load<uint32_t>(p + 8);
uint8_t attributes = xe::load<uint8_t>(p + 12);
uint8_t name_length = xe::load<uint8_t>(p + 13);
char* name = (char*)(p + 14);
auto name = reinterpret_cast<const char*>(p + 14);
if (node_l && !ReadEntry(state, buffer, node_l, parent)) {
return false;
@@ -135,20 +136,20 @@ bool DiscImageDevice::ReadEntry(ParseState& state, const uint8_t* buffer,
entry->data_size_ = 0;
if (length) {
// Not a leaf - read in children.
if (state.size < state.game_offset + (sector * kXESectorSize)) {
if (state->size < state->game_offset + (sector * kXESectorSize)) {
// Out of bounds read.
return false;
}
// Read child list.
uint8_t* folder_ptr =
state.ptr + state.game_offset + (sector * kXESectorSize);
state->ptr + state->game_offset + (sector * kXESectorSize);
if (!ReadEntry(state, folder_ptr, 0, entry)) {
return false;
}
}
} else {
// File.
entry->data_offset_ = state.game_offset + (sector * kXESectorSize);
entry->data_offset_ = state->game_offset + (sector * kXESectorSize);
entry->data_size_ = length;
}

8
src/xenia/vfs/devices/disc_image_device.h
View File

@@ -58,10 +58,10 @@ class DiscImageDevice : public Device {
size_t root_size; // Size (bytes) of root.
} ParseState;
Error Verify(ParseState& state);
bool VerifyMagic(ParseState& state, size_t offset);
Error ReadAllEntries(ParseState& state, const uint8_t* root_buffer);
bool ReadEntry(ParseState& state, const uint8_t* buffer,
Error Verify(ParseState* state);
bool VerifyMagic(ParseState* state, size_t offset);
Error ReadAllEntries(ParseState* state, const uint8_t* root_buffer);
bool ReadEntry(ParseState* state, const uint8_t* buffer,
uint16_t entry_ordinal, DiscImageEntry* parent);
};

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

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

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

@@ -10,6 +10,7 @@
#ifndef XENIA_VFS_DEVICES_DISC_IMAGE_ENTRY_H_
#define XENIA_VFS_DEVICES_DISC_IMAGE_ENTRY_H_
#include <string>
#include <vector>
#include "xenia/base/filesystem.h"
@@ -31,8 +32,8 @@ class DiscImageEntry : public Entry {
size_t data_offset() const { return data_offset_; }
size_t data_size() const { return data_size_; }
X_STATUS Open(KernelState* kernel_state, uint32_t desired_access,
object_ref<XFile>* out_file) override;
X_STATUS Open(kernel::KernelState* kernel_state, uint32_t desired_access,
kernel::object_ref<kernel::XFile>* out_file) override;
bool can_map() const override { return true; }
std::unique_ptr<MappedMemory> OpenMapped(MappedMemory::Mode mode,

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

@@ -16,8 +16,8 @@
namespace xe {
namespace vfs {
DiscImageFile::DiscImageFile(KernelState* kernel_state, uint32_t file_access,
DiscImageEntry* entry)
DiscImageFile::DiscImageFile(kernel::KernelState* kernel_state,
uint32_t file_access, DiscImageEntry* entry)
: XFile(kernel_state, file_access, entry), entry_(entry) {}
DiscImageFile::~DiscImageFile() = default;

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

@@ -17,9 +17,9 @@ namespace vfs {
class DiscImageEntry;
class DiscImageFile : public XFile {
class DiscImageFile : public kernel::XFile {
public:
DiscImageFile(KernelState* kernel_state, uint32_t file_access,
DiscImageFile(kernel::KernelState* kernel_state, uint32_t file_access,
DiscImageEntry* entry);
~DiscImageFile() override;

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

@@ -47,8 +47,9 @@ HostPathEntry* HostPathEntry::Create(Device* device, Entry* parent,
return entry;
}
X_STATUS HostPathEntry::Open(KernelState* kernel_state, uint32_t desired_access,
object_ref<XFile>* out_file) {
X_STATUS HostPathEntry::Open(kernel::KernelState* kernel_state,
uint32_t desired_access,
kernel::object_ref<kernel::XFile>* out_file) {
if (is_read_only() && (desired_access & (FileAccess::kFileWriteData |
FileAccess::kFileAppendData))) {
XELOGE("Attempting to open file for write access on read-only device");
@@ -60,8 +61,8 @@ X_STATUS HostPathEntry::Open(KernelState* kernel_state, uint32_t desired_access,
// TODO(benvanik): pick correct response.
return X_STATUS_NO_SUCH_FILE;
}
*out_file = object_ref<XFile>(new HostPathFile(kernel_state, desired_access,
this, std::move(file_handle)));
*out_file = kernel::object_ref<kernel::XFile>(new HostPathFile(
kernel_state, desired_access, this, std::move(file_handle)));
return X_STATUS_SUCCESS;
}

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

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

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

@@ -15,7 +15,8 @@ namespace xe {
namespace vfs {
HostPathFile::HostPathFile(
KernelState* kernel_state, uint32_t file_access, HostPathEntry* entry,
kernel::KernelState* kernel_state, 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)) {}

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

@@ -20,9 +20,9 @@ namespace vfs {
class HostPathEntry;
class HostPathFile : public XFile {
class HostPathFile : public kernel::XFile {
public:
HostPathFile(KernelState* kernel_state, uint32_t file_access,
HostPathFile(kernel::KernelState* kernel_state, uint32_t file_access,
HostPathEntry* entry,
std::unique_ptr<xe::filesystem::FileHandle> file_handle);
~HostPathFile() override;

32
src/xenia/vfs/devices/stfs_container_device.cc
View File

@@ -9,6 +9,9 @@
#include "xenia/vfs/devices/stfs_container_device.h"
#include <algorithm>
#include <vector>
#include "xenia/base/logging.h"
#include "xenia/base/math.h"
#include "xenia/vfs/devices/stfs_container_entry.h"
@@ -16,14 +19,14 @@
namespace xe {
namespace vfs {
#define XEGETUINT24BE(p) \
(((uint32_t)xe::load_and_swap<uint8_t>((p) + 0) << 16) | \
((uint32_t)xe::load_and_swap<uint8_t>((p) + 1) << 8) | \
(uint32_t)xe::load_and_swap<uint8_t>((p) + 2))
#define XEGETUINT24LE(p) \
(((uint32_t)xe::load<uint8_t>((p) + 2) << 16) | \
((uint32_t)xe::load<uint8_t>((p) + 1) << 8) | \
(uint32_t)xe::load<uint8_t>((p) + 0))
uint32_t load_uint24_be(const uint8_t* p) {
return (static_cast<uint32_t>(p[0]) << 16) |
(static_cast<uint32_t>(p[1]) << 8) | static_cast<uint32_t>(p[2]);
}
uint32_t load_uint24_le(const uint8_t* p) {
return (static_cast<uint32_t>(p[2]) << 16) |
(static_cast<uint32_t>(p[1]) << 8) | static_cast<uint32_t>(p[0]);
}
StfsContainerDevice::StfsContainerDevice(const std::string& mount_path,
const std::wstring& local_path)
@@ -150,8 +153,8 @@ StfsContainerDevice::Error StfsContainerDevice::ReadAllEntries(
}
uint8_t filename_length_flags = xe::load_and_swap<uint8_t>(p + 0x28);
// TODO(benvanik): use for allocation_size_?
// uint32_t allocated_block_count = XEGETUINT24LE(p + 0x29);
uint32_t start_block_index = XEGETUINT24LE(p + 0x2F);
// uint32_t allocated_block_count = load_uint24_le(p + 0x29);
uint32_t start_block_index = load_uint24_le(p + 0x2F);
uint16_t path_indicator = xe::load_and_swap<uint16_t>(p + 0x32);
uint32_t file_size = xe::load_and_swap<uint32_t>(p + 0x34);
uint32_t update_timestamp = xe::load_and_swap<uint32_t>(p + 0x38);
@@ -167,7 +170,8 @@ StfsContainerDevice::Error StfsContainerDevice::ReadAllEntries(
auto entry = new StfsContainerEntry(
this, parent_entry,
std::string((char*)filename, filename_length_flags & 0x3F),
std::string(reinterpret_cast<const char*>(filename),
filename_length_flags & 0x3F),
mmap_.get());
// bit 0x40 = consecutive blocks (not fragmented?)
if (filename_length_flags & 0x80) {
@@ -286,7 +290,7 @@ StfsContainerDevice::BlockHash StfsContainerDevice::GetBlockHash(
const uint8_t* hash_data = map_ptr + BlockToOffset(table_index);
const uint8_t* record_data = hash_data + record * 0x18;
uint32_t info = xe::load_and_swap<uint8_t>(record_data + 0x14);
uint32_t next_block_index = XEGETUINT24BE(record_data + 0x15);
uint32_t next_block_index = load_uint24_be(record_data + 0x15);
return {next_block_index, info};
}
@@ -300,12 +304,12 @@ bool StfsVolumeDescriptor::Read(const uint8_t* p) {
reserved = xe::load_and_swap<uint8_t>(p + 0x01);
block_separation = xe::load_and_swap<uint8_t>(p + 0x02);
file_table_block_count = xe::load_and_swap<uint16_t>(p + 0x03);
file_table_block_number = XEGETUINT24BE(p + 0x05);
file_table_block_number = load_uint24_be(p + 0x05);
std::memcpy(top_hash_table_hash, p + 0x08, 0x14);
total_allocated_block_count = xe::load_and_swap<uint32_t>(p + 0x1C);
total_unallocated_block_count = xe::load_and_swap<uint32_t>(p + 0x20);
return true;
};
}
bool StfsHeader::Read(const uint8_t* p) {
std::memcpy(license_entries, p + 0x22C, 0x100);

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

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

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

@@ -10,6 +10,7 @@
#ifndef XENIA_VFS_DEVICES_STFS_CONTAINER_ENTRY_H_
#define XENIA_VFS_DEVICES_STFS_CONTAINER_ENTRY_H_
#include <string>
#include <vector>
#include "xenia/base/filesystem.h"
@@ -31,8 +32,8 @@ class StfsContainerEntry : public Entry {
size_t data_offset() const { return data_offset_; }
size_t data_size() const { return data_size_; }
X_STATUS Open(KernelState* kernel_state, uint32_t desired_access,
object_ref<XFile>* out_file) override;
X_STATUS Open(kernel::KernelState* kernel_state, uint32_t desired_access,
kernel::object_ref<kernel::XFile>* out_file) override;
struct BlockRecord {
size_t offset;

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

@@ -16,7 +16,7 @@
namespace xe {
namespace vfs {
StfsContainerFile::StfsContainerFile(KernelState* kernel_state,
StfsContainerFile::StfsContainerFile(kernel::KernelState* kernel_state,
uint32_t file_access,
StfsContainerEntry* entry)
: XFile(kernel_state, file_access, entry), entry_(entry) {}
@@ -38,7 +38,7 @@ X_STATUS StfsContainerFile::ReadSync(void* buffer, size_t buffer_length,
size_t end_block =
std::min(entry_->block_list().size(),
(size_t)ceil((byte_offset + real_length) / 4096.0));
uint8_t* dest_ptr = (uint8_t*)buffer;
uint8_t* dest_ptr = reinterpret_cast<uint8_t*>(buffer);
size_t remaining_length = real_length;
for (size_t n = start_block; n < end_block; n++) {
auto& record = entry_->block_list()[n];

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

@@ -17,9 +17,9 @@ namespace vfs {
class StfsContainerEntry;
class StfsContainerFile : public XFile {
class StfsContainerFile : public kernel::XFile {
public:
StfsContainerFile(KernelState* kernel_state, uint32_t file_access,
StfsContainerFile(kernel::KernelState* kernel_state, uint32_t file_access,
StfsContainerEntry* entry);
~StfsContainerFile() override;

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

@@ -21,9 +21,6 @@
#include "xenia/xbox.h"
namespace xe {
namespace filesystem {
class WildcardEngine;
} // namespace filesystem
namespace kernel {
class KernelState;
class XFile;
@@ -33,8 +30,6 @@ class XFile;
namespace xe {
namespace vfs {
using namespace xe::kernel;
class Device;
// Matches http://source.winehq.org/source/include/winternl.h#1591.
@@ -110,8 +105,9 @@ class Entry {
bool Delete();
void Touch();
virtual X_STATUS Open(KernelState* kernel_state, uint32_t desired_access,
object_ref<XFile>* out_file) = 0;
virtual X_STATUS Open(kernel::KernelState* kernel_state,
uint32_t desired_access,
kernel::object_ref<kernel::XFile>* out_file) = 0;
virtual bool can_map() const { return false; }
virtual std::unique_ptr<MappedMemory> OpenMapped(MappedMemory::Mode mode,

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

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

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

@@ -39,9 +39,10 @@ class VirtualFileSystem {
Entry* CreatePath(std::string path, uint32_t attributes);
bool DeletePath(std::string path);
X_STATUS OpenFile(KernelState* kernel_state, std::string path,
X_STATUS OpenFile(kernel::KernelState* kernel_state, std::string path,
FileDisposition creation_disposition,
uint32_t desired_access, object_ref<XFile>* out_file,
uint32_t desired_access,
kernel::object_ref<kernel::XFile>* out_file,
FileAction* out_action);
private: