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

Merge branch 'master' into linux_windowing

Browse Source
This commit is contained in:
Triang3l
2021-08-26 22:58:14 +03:00
parent 005e0e21c1 f6f524b814
commit 7edfdc2672
813 changed files with 429062 additions and 250262 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
src/xenia/kernel/kernel_state.cc
View File

@@ -316,6 +316,17 @@ void KernelState::SetExecutableModule(object_ref<UserModule> module) {
*variable_ptr = executable_module_->hmodule_ptr();
}
// Setup the kernel's ExLoadedImageName field
export_entry = processor()->export_resolver()->GetExportByOrdinal(
"xboxkrnl.exe", ordinals::ExLoadedImageName);
if (export_entry) {
char* variable_ptr =
memory()->TranslateVirtual<char*>(export_entry->variable_ptr);
xe::string_util::copy_truncating(
variable_ptr, executable_module_->path(),
xboxkrnl::XboxkrnlModule::kExLoadedImageNameSize);
}
// Spin up deferred dispatch worker.
// TODO(benvanik): move someplace more appropriate (out of ctor, but around
// here).
@@ -758,7 +769,7 @@ void KernelState::CompleteOverlappedDeferredEx(
bool KernelState::Save(ByteStream* stream) {
XELOGD("Serializing the kernel...");
stream->Write('KRNL');
stream->Write(kKernelSaveSignature);
// Save the object table
object_table_.Save(stream);
@@ -828,7 +839,7 @@ bool KernelState::Save(ByteStream* stream) {
bool KernelState::Restore(ByteStream* stream) {
// Check the magic value.
if (stream->Read<uint32_t>() != 'KRNL') {
if (stream->Read<uint32_t>() != kKernelSaveSignature) {
return false;
}

2
src/xenia/kernel/kernel_state.h
View File

@@ -41,6 +41,8 @@ class Processor;
namespace xe {
namespace kernel {
constexpr fourcc_t kKernelSaveSignature = make_fourcc("KRNL");
class Dispatcher;
class XHostThread;
class KernelModule;

10
src/xenia/kernel/user_module.cc
View File

@@ -134,13 +134,15 @@ X_STATUS UserModule::LoadFromFile(const std::string_view path) {
X_STATUS UserModule::LoadFromMemory(const void* addr, const size_t length) {
auto processor = kernel_state()->processor();
auto magic = xe::load_and_swap<uint32_t>(addr);
if (magic == 'XEX2' || magic == 'XEX1') {
be<fourcc_t> magic;
magic.value = xe::load<fourcc_t>(addr);
if (magic == xe::cpu::kXEX2Signature || magic == xe::cpu::kXEX1Signature) {
module_format_ = kModuleFormatXex;
} else if (magic == 0x7F454C46 /* 0x7F 'ELF' */) {
} else if (magic == xe::cpu::kElfSignature) {
module_format_ = kModuleFormatElf;
} else {
auto magic16 = xe::load_and_swap<uint16_t>(addr);
be<uint16_t> magic16;
magic16.value = xe::load<uint16_t>(addr);
if (magic16 == 0x4D5A) {
XELOGE("XNA executables are not yet implemented");
return X_STATUS_NOT_IMPLEMENTED;

3
src/xenia/kernel/util/export_table_post.inc
View File

@@ -2,13 +2,12 @@
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
// Post-include file for an export table.
#undef FLAG
#undef XE_EXPORT

5
src/xenia/kernel/util/export_table_pre.inc
View File

@@ -2,7 +2,7 @@
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
@@ -22,8 +22,7 @@
* my_module_export_table, xe::countof(my_module_export_table));
*/
#define XE_EXPORT(module, ordinal, name, type) \
xe::cpu::Export(ordinal, xe::cpu::Export::Type::type, #name)
#define FLAG(t) kXEKernelExportFlag##t
#define FLAG(t) kXEKernelExportFlag##t

12
src/xenia/kernel/util/gameinfo_utils.cc
View File

@@ -13,9 +13,9 @@ namespace xe {
namespace kernel {
namespace util {
constexpr uint32_t kGameInfoExecMagic = 'EXEC';
constexpr uint32_t kGameInfoCommMagic = 'COMM';
constexpr uint32_t kGameInfoTitlMagic = 'TITL';
constexpr fourcc_t kGameInfoExecSignature = make_fourcc("EXEC");
constexpr fourcc_t kGameInfoCommSignature = make_fourcc("COMM");
constexpr fourcc_t kGameInfoTitlSignature = make_fourcc("TITL");
GameInfoWrapper::GameInfoWrapper(const uint8_t* data, size_t data_size)
: data_(data), data_size_(data_size) {
@@ -31,7 +31,7 @@ GameInfoWrapper::GameInfoWrapper(const uint8_t* data, size_t data_size)
data_offset += sizeof(GameInfoBlockHeader);
switch (block_header->magic) {
case kGameInfoExecMagic:
case kGameInfoExecSignature:
exec_.virtual_titleid =
reinterpret_cast<const char*>(data_ + data_offset);
data_offset += exec_.VirtualTitleIdLength + 1;
@@ -41,12 +41,12 @@ GameInfoWrapper::GameInfoWrapper(const uint8_t* data, size_t data_size)
reinterpret_cast<const char*>(data_ + data_offset);
data_offset += exec_.BuildDescriptionLength + 1;
break;
case kGameInfoCommMagic:
case kGameInfoCommSignature:
assert_true(block_header->block_size == sizeof(GameInfoBlockComm));
comm_ = reinterpret_cast<const GameInfoBlockComm*>(data_ + data_offset);
data_offset += block_header->block_size;
break;
case kGameInfoTitlMagic:
case kGameInfoTitlSignature:
assert_true(block_header->block_size == sizeof(GameInfoBlockTitl));
titl_ = reinterpret_cast<const GameInfoBlockTitl*>(data_ + data_offset);
data_offset += block_header->block_size;

4
src/xenia/kernel/util/object_table.cc
View File

@@ -205,6 +205,10 @@ X_STATUS ObjectTable::RemoveHandle(X_HANDLE handle) {
XELOGI("Removed handle:{:08X} for {}", handle, typeid(*object).name());
// Remove object name from mapping to prevent naming collision.
if (!object->name().empty()) {
RemoveNameMapping(object->name());
}
// Release now that the object has been removed from the table.
object->Release();
}

3
src/xenia/kernel/util/ordinal_table_post.inc
View File

@@ -2,12 +2,11 @@
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
// Post-include file for an ordinal table.
#undef XE_EXPORT

7
src/xenia/kernel/util/ordinal_table_pre.inc
View File

@@ -2,7 +2,7 @@
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
@@ -21,7 +21,4 @@
* #include "xenia/kernel/util/ordinal_table_post.inc"
*/
#define XE_EXPORT(module, ordinal, name, type) \
name = ordinal
#define XE_EXPORT(module, ordinal, name, type) name = ordinal

54
src/xenia/kernel/util/shim_utils.h
View File

@@ -12,6 +12,7 @@
#include <cstring>
#include <string>
#include <type_traits>
#include "third_party/fmt/include/fmt/format.h"
#include "xenia/base/byte_order.h"
@@ -28,7 +29,7 @@ namespace kernel {
using PPCContext = xe::cpu::ppc::PPCContext;
#define SHIM_CALL void __cdecl
#define SHIM_CALL void
#define SHIM_SET_MAPPING(library_name, export_name, shim_data) \
export_resolver->SetFunctionMapping( \
library_name, ordinals::export_name, \
@@ -531,13 +532,18 @@ xe::cpu::Export* RegisterExport(R (*fn)(Ps&...), const char* name,
cvars::log_high_frequency_kernel_calls)) {
PrintKernelCall(export_entry, params);
}
auto result =
KernelTrampoline(FN, std::forward<std::tuple<Ps...>>(params),
std::make_index_sequence<sizeof...(Ps)>());
result.Store(ppc_context);
if (export_entry->tags &
(xe::cpu::ExportTag::kLog | xe::cpu::ExportTag::kLogResult)) {
// TODO(benvanik): log result.
if constexpr (std::is_void<R>::value) {
KernelTrampoline(FN, std::forward<std::tuple<Ps...>>(params),
std::make_index_sequence<sizeof...(Ps)>());
} else {
auto result =
KernelTrampoline(FN, std::forward<std::tuple<Ps...>>(params),
std::make_index_sequence<sizeof...(Ps)>());
result.Store(ppc_context);
if (export_entry->tags &
(xe::cpu::ExportTag::kLog | xe::cpu::ExportTag::kLogResult)) {
// TODO(benvanik): log result.
}
}
}
};
@@ -545,38 +551,6 @@ xe::cpu::Export* RegisterExport(R (*fn)(Ps&...), const char* name,
return export_entry;
}
template <KernelModuleId MODULE, uint16_t ORDINAL, typename... Ps>
xe::cpu::Export* RegisterExport(void (*fn)(Ps&...), const char* name,
xe::cpu::ExportTag::type tags) {
static const auto export_entry = new cpu::Export(
ORDINAL, xe::cpu::Export::Type::kFunction, name,
tags | xe::cpu::ExportTag::kImplemented | xe::cpu::ExportTag::kLog);
static void (*FN)(Ps & ...) = fn;
struct X {
static void Trampoline(PPCContext* ppc_context) {
++export_entry->function_data.call_count;
Param::Init init = {
ppc_context,
0,
};
// Using braces initializer instead of make_tuple because braces
// enforce execution order across compilers.
// The make_tuple order is undefined per the C++ standard and
// cause inconsitencies between msvc and clang.
std::tuple<Ps...> params = {Ps(init)...};
if (export_entry->tags & xe::cpu::ExportTag::kLog &&
(!(export_entry->tags & xe::cpu::ExportTag::kHighFrequency) ||
cvars::log_high_frequency_kernel_calls)) {
PrintKernelCall(export_entry, params);
}
KernelTrampoline(FN, std::forward<std::tuple<Ps...>>(params),
std::make_index_sequence<sizeof...(Ps)>());
}
};
export_entry->function_data.trampoline = &X::Trampoline;
return export_entry;
}
} // namespace shim
using xe::cpu::ExportTag;

12
src/xenia/kernel/util/xdbf_utils.cc
View File

@@ -13,9 +13,9 @@ namespace xe {
namespace kernel {
namespace util {
constexpr uint32_t kXdbfMagicXdbf = 'XDBF';
constexpr uint32_t kXdbfMagicXstc = 'XSTC';
constexpr uint32_t kXdbfMagicXstr = 'XSTR';
constexpr fourcc_t kXdbfSignatureXdbf = make_fourcc("XDBF");
constexpr fourcc_t kXdbfSignatureXstc = make_fourcc("XSTC");
constexpr fourcc_t kXdbfSignatureXstr = make_fourcc("XSTR");
XdbfWrapper::XdbfWrapper(const uint8_t* data, size_t data_size)
: data_(data), data_size_(data_size) {
@@ -28,7 +28,7 @@ XdbfWrapper::XdbfWrapper(const uint8_t* data, size_t data_size)
header_ = reinterpret_cast<const XbdfHeader*>(ptr);
ptr += sizeof(XbdfHeader);
if (header_->magic != kXdbfMagicXdbf) {
if (header_->magic != kXdbfSignatureXdbf) {
data_ = nullptr;
return;
}
@@ -65,7 +65,7 @@ std::string XdbfWrapper::GetStringTableEntry(XLanguage language,
auto xstr_head =
reinterpret_cast<const XdbfXstrHeader*>(language_block.buffer);
assert_true(xstr_head->magic == kXdbfMagicXstr);
assert_true(xstr_head->magic == kXdbfSignatureXstr);
assert_true(xstr_head->version == 1);
const uint8_t* ptr = language_block.buffer + sizeof(XdbfXstrHeader);
@@ -94,7 +94,7 @@ XLanguage XdbfGameData::default_language() const {
return XLanguage::kEnglish;
}
auto xstc = reinterpret_cast<const XdbfXstc*>(block.buffer);
assert_true(xstc->magic == kXdbfMagicXstc);
assert_true(xstc->magic == kXdbfSignatureXstc);
return static_cast<XLanguage>(static_cast<uint32_t>(xstc->default_language));
}

7
src/xenia/kernel/util/xex2_info.h
View File

@@ -529,6 +529,13 @@ struct xex2_import_library {
}
};
struct xex2_opt_generic_u32 {
xe::be<uint32_t> size;
xe::be<uint32_t> values[1];
uint32_t count() const { return (size - 4) / 4; }
};
struct xex2_opt_header {
xe::be<uint32_t> key; // 0x0

14
src/xenia/kernel/xam/apps/xam_app.cc
View File

@@ -52,20 +52,14 @@ X_HRESULT XamApp::DispatchMessageSync(uint32_t message, uint32_t buffer_ptr,
if (!e || !buffer || !extra) {
return X_E_INVALIDARG;
}
assert_true(extra->magic == 'XEN\0');
assert_true(extra->magic == kXObjSignature);
if (data->buffer_size) {
std::memset(buffer, 0, data->buffer_size);
}
uint32_t item_count = 0;
auto result = e->WriteItems(data->buffer_ptr, buffer, data->buffer_size,
&item_count);
assert_true(XSUCCEEDED(result));
assert_true(item_count <= 1);
if (XSUCCEEDED(result) && item_count == 1) {
auto content_data = reinterpret_cast<XCONTENT_AGGREGATE_DATA*>(buffer);
// TODO(gibbed): WTF?
*reinterpret_cast<be<uint32_t>*>(&buffer[0x140]) =
content_data->title_id;
auto result = e->WriteItems(data->buffer_ptr, buffer, &item_count);
if (result == X_ERROR_SUCCESS && item_count >= 1) {
if (data->length_ptr) {
auto length_ptr =
memory_->TranslateVirtual<be<uint32_t>*>(data->length_ptr);

19
src/xenia/kernel/xam/apps/xgi_app.cc
View File

@@ -2,7 +2,7 @@
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2015 Ben Vanik. All rights reserved. *
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
@@ -80,8 +80,10 @@ X_HRESULT XgiApp::DispatchMessageSync(uint32_t message, uint32_t buffer_ptr,
return X_E_SUCCESS;
}
case 0x000B0011: {
// TODO(DrChat): Figure out what this is again
} break;
// TODO(PermaNull): reverse buffer contents.
XELOGD("XGISessionDelete");
return X_STATUS_SUCCESS;
}
case 0x000B0012: {
assert_true(buffer_length == 0x14);
uint32_t session_ptr = xe::load_and_swap<uint32_t>(buffer + 0x0);
@@ -95,6 +97,17 @@ X_HRESULT XgiApp::DispatchMessageSync(uint32_t message, uint32_t buffer_ptr,
user_count, unk_0, user_index_array, private_slots_array);
return X_E_SUCCESS;
}
case 0x000B0014: {
// Gets Jetpac XBLA in game
// get high score table?
XELOGD("XGI_unknown");
return X_STATUS_SUCCESS;
}
case 0x000B0015: {
// send high scores?
XELOGD("XGI_unknown");
return X_STATUS_SUCCESS;
}
case 0x000B0041: {
assert_true(!buffer_length || buffer_length == 32);
// 00000000 2789fecc 00000000 00000000 200491e0 00000000 200491f0 20049340

18
src/xenia/kernel/xam/apps/xlivebase_app.cc
View File

@@ -2,7 +2,7 @@
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2015 Ben Vanik. All rights reserved. *
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
@@ -41,18 +41,28 @@ X_HRESULT XLiveBaseApp::DispatchMessageSync(uint32_t message,
xe::store_and_swap<uint32_t>(buffer + 0, 1); // XONLINE_NAT_OPEN
return X_E_SUCCESS;
}
case 0x00058007: {
// Occurs if title calls XOnlineGetServiceInfo, expects dwServiceId
// and pServiceInfo. pServiceInfo should contain pointer to
// XONLINE_SERVICE_INFO structure.
XELOGD("CXLiveLogon::GetServiceInfo({:08X}, {:08X})", buffer_ptr,
buffer_length);
return 0x80151802; // ERROR_CONNECTION_INVALID
}
case 0x00058020: {
// 0x00058004 is called right before this.
// We should create a XamEnumerate-able empty list here, but I'm not
// sure of the format.
// buffer_length seems to be the same ptr sent to 0x00058004.
XELOGD("XLiveBaseFriendsCreateEnumerator({:08X}, {:08X}) unimplemented",
XELOGD("CXLiveFriends::Enumerate({:08X}, {:08X}) unimplemented",
buffer_ptr, buffer_length);
return X_E_FAIL;
}
case 0x00058023: {
XELOGD("XliveBaseUnk58023({:08X}, {:08X}) unimplemented", buffer_ptr,
buffer_length);
XELOGD(
"CXLiveMessaging::XMessageGameInviteGetAcceptedInfo({:08X}, {:08X}) "
"unimplemented",
buffer_ptr, buffer_length);
return X_E_FAIL;
}
case 0x00058046: {

106
src/xenia/kernel/xam/content_manager.cc
View File

@@ -15,6 +15,7 @@
#include "xenia/base/filesystem.h"
#include "xenia/base/string.h"
#include "xenia/kernel/kernel_state.h"
#include "xenia/kernel/xfile.h"
#include "xenia/kernel/xobject.h"
#include "xenia/vfs/devices/host_path_device.h"
@@ -30,7 +31,7 @@ static int content_device_id_ = 0;
ContentPackage::ContentPackage(KernelState* kernel_state,
const std::string_view root_name,
const ContentData& data,
const XCONTENT_AGGREGATE_DATA& data,
const std::filesystem::path& package_path)
: kernel_state_(kernel_state), root_name_(root_name) {
device_path_ = fmt::format("\\Device\\Content\\{0}\\", ++content_device_id_);
@@ -57,63 +58,49 @@ ContentManager::ContentManager(KernelState* kernel_state,
ContentManager::~ContentManager() = default;
std::filesystem::path ContentManager::ResolvePackageRoot(
uint32_t content_type) {
auto title_id = fmt::format("{:8X}", kernel_state_->title_id());
std::string type_name;
switch (content_type) {
case 1:
// Save games.
type_name = "00000001";
break;
case 2:
// DLC from the marketplace.
type_name = "00000002";
break;
case 3:
// Publisher content?
type_name = "00000003";
break;
case 0x000D0000:
// ???
type_name = "000D0000";
break;
default:
assert_unhandled_case(data.content_type);
return std::filesystem::path();
XContentType content_type, uint32_t title_id) {
if (title_id == kCurrentlyRunningTitleId) {
title_id = kernel_state_->title_id();
}
auto title_id_str = fmt::format("{:08X}", title_id);
auto content_type_str = fmt::format("{:08X}", uint32_t(content_type));
// Package root path:
// content_root/title_id/type_name/
return root_path_ / title_id / type_name;
// content_root/title_id/content_type/
return root_path_ / title_id_str / content_type_str;
}
std::filesystem::path ContentManager::ResolvePackagePath(
const ContentData& data) {
const XCONTENT_AGGREGATE_DATA& data) {
// Content path:
// content_root/title_id/type_name/data_file_name/
auto package_root = ResolvePackageRoot(data.content_type);
return package_root / xe::to_path(data.file_name);
// content_root/title_id/content_type/data_file_name/
auto package_root = ResolvePackageRoot(data.content_type, data.title_id);
return package_root / xe::to_path(data.file_name());
}
std::vector<ContentData> ContentManager::ListContent(uint32_t device_id,
uint32_t content_type) {
std::vector<ContentData> result;
std::vector<XCONTENT_AGGREGATE_DATA> ContentManager::ListContent(
uint32_t device_id, XContentType content_type, uint32_t title_id) {
std::vector<XCONTENT_AGGREGATE_DATA> result;
if (title_id == kCurrentlyRunningTitleId) {
title_id = kernel_state_->title_id();
}
// Search path:
// content_root/title_id/type_name/*
auto package_root = ResolvePackageRoot(content_type);
auto package_root = ResolvePackageRoot(content_type, title_id);
auto file_infos = xe::filesystem::ListFiles(package_root);
for (const auto& file_info : file_infos) {
if (file_info.type != xe::filesystem::FileInfo::Type::kDirectory) {
// Directories only.
continue;
}
ContentData content_data;
XCONTENT_AGGREGATE_DATA content_data;
content_data.device_id = device_id;
content_data.content_type = content_type;
content_data.display_name = xe::path_to_utf16(file_info.name);
content_data.file_name = xe::path_to_utf8(file_info.name);
content_data.set_display_name(xe::path_to_utf16(file_info.name));
content_data.set_file_name(xe::path_to_utf8(file_info.name));
content_data.title_id = title_id;
result.emplace_back(std::move(content_data));
}
@@ -121,7 +108,7 @@ std::vector<ContentData> ContentManager::ListContent(uint32_t device_id,
}
std::unique_ptr<ContentPackage> ContentManager::ResolvePackage(
const std::string_view root_name, const ContentData& data) {
const std::string_view root_name, const XCONTENT_AGGREGATE_DATA& data) {
auto package_path = ResolvePackagePath(data);
if (!std::filesystem::exists(package_path)) {
return nullptr;
@@ -134,13 +121,13 @@ std::unique_ptr<ContentPackage> ContentManager::ResolvePackage(
return package;
}
bool ContentManager::ContentExists(const ContentData& data) {
bool ContentManager::ContentExists(const XCONTENT_AGGREGATE_DATA& data) {
auto path = ResolvePackagePath(data);
return std::filesystem::exists(path);
}
X_RESULT ContentManager::CreateContent(const std::string_view root_name,
const ContentData& data) {
const XCONTENT_AGGREGATE_DATA& data) {
auto global_lock = global_critical_region_.Acquire();
if (open_packages_.count(string_key(root_name))) {
@@ -167,7 +154,7 @@ X_RESULT ContentManager::CreateContent(const std::string_view root_name,
}
X_RESULT ContentManager::OpenContent(const std::string_view root_name,
const ContentData& data) {
const XCONTENT_AGGREGATE_DATA& data) {
auto global_lock = global_critical_region_.Acquire();
if (open_packages_.count(string_key(root_name))) {
@@ -197,6 +184,7 @@ X_RESULT ContentManager::CloseContent(const std::string_view root_name) {
if (it == open_packages_.end()) {
return X_ERROR_FILE_NOT_FOUND;
}
CloseOpenedFilesFromContent(root_name);
auto package = it->second;
open_packages_.erase(it);
@@ -205,8 +193,8 @@ X_RESULT ContentManager::CloseContent(const std::string_view root_name) {
return X_ERROR_SUCCESS;
}
X_RESULT ContentManager::GetContentThumbnail(const ContentData& data,
std::vector<uint8_t>* buffer) {
X_RESULT ContentManager::GetContentThumbnail(
const XCONTENT_AGGREGATE_DATA& data, std::vector<uint8_t>* buffer) {
auto global_lock = global_critical_region_.Acquire();
auto package_path = ResolvePackagePath(data);
auto thumb_path = package_path / kThumbnailFileName;
@@ -224,8 +212,8 @@ X_RESULT ContentManager::GetContentThumbnail(const ContentData& data,
}
}
X_RESULT ContentManager::SetContentThumbnail(const ContentData& data,
std::vector<uint8_t> buffer) {
X_RESULT ContentManager::SetContentThumbnail(
const XCONTENT_AGGREGATE_DATA& data, std::vector<uint8_t> buffer) {
auto global_lock = global_critical_region_.Acquire();
auto package_path = ResolvePackagePath(data);
std::filesystem::create_directories(package_path);
@@ -240,7 +228,7 @@ X_RESULT ContentManager::SetContentThumbnail(const ContentData& data,
}
}
X_RESULT ContentManager::DeleteContent(const ContentData& data) {
X_RESULT ContentManager::DeleteContent(const XCONTENT_AGGREGATE_DATA& data) {
auto global_lock = global_critical_region_.Acquire();
if (IsContentOpen(data)) {
@@ -265,13 +253,35 @@ std::filesystem::path ContentManager::ResolveGameUserContentPath() {
return root_path_ / title_id / kGameUserContentDirName / user_name;
}
bool ContentManager::IsContentOpen(const ContentData& data) const {
bool ContentManager::IsContentOpen(const XCONTENT_AGGREGATE_DATA& data) const {
return std::any_of(open_packages_.cbegin(), open_packages_.cend(),
[data](std::pair<string_key, ContentPackage*> content) {
return data == content.second->GetPackageContentData();
});
}
void ContentManager::CloseOpenedFilesFromContent(
const std::string_view root_name) {
// TODO(Gliniak): Cleanup this code to care only about handles
// related to provided content
const std::vector<object_ref<XFile>> all_files_handles =
kernel_state_->object_table()->GetObjectsByType<XFile>(
XObject::Type::File);
std::string resolved_path = "";
kernel_state_->file_system()->FindSymbolicLink(std::string(root_name) + ':',
resolved_path);
for (const object_ref<XFile>& file : all_files_handles) {
std::string file_path = file->entry()->absolute_path();
bool is_file_inside_content = utf8::starts_with(file_path, resolved_path);
if (is_file_inside_content) {
file->ReleaseHandle();
}
}
}
} // namespace xam
} // namespace kernel
} // namespace xe

184
src/xenia/kernel/xam/content_manager.h
View File

@@ -31,107 +31,108 @@ namespace xe {
namespace kernel {
namespace xam {
// If set in XCONTENT_AGGREGATE_DATA, will be substituted with the running
// titles ID
// TODO: check if actual x360 kernel/xam has a value similar to this
constexpr uint32_t kCurrentlyRunningTitleId = 0xFFFFFFFF;
struct XCONTENT_DATA {
be<uint32_t> device_id;
be<uint32_t> content_type;
be<XContentType> content_type;
union {
be<uint16_t> display_name[128];
char16_t display_name_chars[128];
};
char file_name[42];
uint8_t padding[2];
};
static_assert_size(XCONTENT_DATA, 308);
// this should be be<uint16_t>, but that stops copy constructor being
// generated...
uint16_t uint[128];
char16_t chars[128];
} display_name_raw;
struct XCONTENT_AGGREGATE_DATA {
be<uint32_t> device_id;
be<uint32_t> content_type;
union {
be<uint16_t> display_name[128];
char16_t display_name_chars[128];
};
char file_name[42];
char file_name_raw[42];
// Some games use this padding field as a null-terminator, as eg.
// DLC packages usually fill the entire file_name_raw array
// Not every game sets it to 0 though, so make sure any file_name_raw reads
// only go up to 42 chars!
uint8_t padding[2];
bool operator==(const XCONTENT_DATA& other) const {
// Package is located via device_id/content_type/file_name, so only need to
// compare those
return device_id == other.device_id && content_type == other.content_type &&
file_name() == other.file_name();
}
std::u16string display_name() const {
return load_and_swap<std::u16string>(display_name_raw.uint);
}
std::string file_name() const {
std::string value;
value.assign(file_name_raw,
std::min(strlen(file_name_raw), countof(file_name_raw)));
return value;
}
void set_display_name(const std::u16string_view value) {
// Some games (eg Goldeneye XBLA) require multiple null-terminators for it
// to read the string properly, blanking the array should take care of that
std::fill_n(display_name_raw.chars, countof(display_name_raw.chars), 0);
string_util::copy_and_swap_truncating(display_name_raw.chars, value,
countof(display_name_raw.chars));
}
void set_file_name(const std::string_view value) {
std::fill_n(file_name_raw, countof(file_name_raw), 0);
string_util::copy_maybe_truncating<string_util::Safety::IKnowWhatIAmDoing>(
file_name_raw, value, xe::countof(file_name_raw));
// Some games rely on padding field acting as a null-terminator...
padding[0] = padding[1] = 0;
}
};
static_assert_size(XCONTENT_DATA, 0x134);
struct XCONTENT_AGGREGATE_DATA : XCONTENT_DATA {
be<uint64_t> unk134; // some titles store XUID here?
be<uint32_t> title_id;
};
static_assert_size(XCONTENT_AGGREGATE_DATA, 312);
struct ContentData {
uint32_t device_id;
uint32_t content_type;
std::u16string display_name;
std::string file_name;
ContentData() = default;
bool operator==(const ContentData& rhs) const {
return device_id == rhs.device_id && content_type == rhs.content_type &&
file_name == rhs.file_name;
XCONTENT_AGGREGATE_DATA() = default;
XCONTENT_AGGREGATE_DATA(const XCONTENT_DATA& other) {
device_id = other.device_id;
content_type = other.content_type;
set_display_name(other.display_name());
set_file_name(other.file_name());
padding[0] = padding[1] = 0;
unk134 = 0;
title_id = kCurrentlyRunningTitleId;
}
explicit ContentData(const XCONTENT_DATA& data) {
device_id = data.device_id;
content_type = data.content_type;
display_name = xe::load_and_swap<std::u16string>(data.display_name);
file_name = xe::load_and_swap<std::string>(data.file_name);
}
void Write(XCONTENT_DATA* data) const {
data->device_id = device_id;
data->content_type = content_type;
xe::string_util::copy_and_swap_truncating(
data->display_name_chars, display_name,
xe::countof(data->display_name_chars));
xe::string_util::copy_maybe_truncating<
string_util::Safety::IKnowWhatIAmDoing>(data->file_name, file_name,
xe::countof(data->file_name));
}
};
struct ContentAggregateData {
uint32_t device_id;
uint32_t content_type;
std::u16string display_name;
std::string file_name;
uint32_t title_id;
ContentAggregateData() = default;
explicit ContentAggregateData(const XCONTENT_AGGREGATE_DATA& data) {
device_id = data.device_id;
content_type = data.content_type;
display_name = xe::load_and_swap<std::u16string>(data.display_name);
file_name = xe::load_and_swap<std::string>(data.file_name);
title_id = data.title_id;
}
void Write(XCONTENT_AGGREGATE_DATA* data) const {
data->device_id = device_id;
data->content_type = content_type;
xe::string_util::copy_and_swap_truncating(
data->display_name_chars, display_name,
xe::countof(data->display_name_chars));
xe::string_util::copy_maybe_truncating<
string_util::Safety::IKnowWhatIAmDoing>(data->file_name, file_name,
xe::countof(data->file_name));
data->title_id = title_id;
bool operator==(const XCONTENT_AGGREGATE_DATA& other) const {
// Package is located via device_id/title_id/content_type/file_name, so only
// need to compare those
return device_id == other.device_id && title_id == other.title_id &&
content_type == other.content_type &&
file_name() == other.file_name();
}
};
static_assert_size(XCONTENT_AGGREGATE_DATA, 0x148);
class ContentPackage {
public:
ContentPackage(KernelState* kernel_state, const std::string_view root_name,
const ContentData& data,
const XCONTENT_AGGREGATE_DATA& data,
const std::filesystem::path& package_path);
~ContentPackage();
const ContentData& GetPackageContentData() const { return content_data_; }
const XCONTENT_AGGREGATE_DATA& GetPackageContentData() const {
return content_data_;
}
private:
KernelState* kernel_state_;
std::string root_name_;
std::string device_path_;
ContentData content_data_;
XCONTENT_AGGREGATE_DATA content_data_;
};
class ContentManager {
@@ -140,29 +141,32 @@ class ContentManager {
const std::filesystem::path& root_path);
~ContentManager();
std::vector<ContentData> ListContent(uint32_t device_id,
uint32_t content_type);
std::vector<XCONTENT_AGGREGATE_DATA> ListContent(uint32_t device_id,
XContentType content_type,
uint32_t title_id = -1);
std::unique_ptr<ContentPackage> ResolvePackage(
const std::string_view root_name, const ContentData& data);
const std::string_view root_name, const XCONTENT_AGGREGATE_DATA& data);
bool ContentExists(const ContentData& data);
bool ContentExists(const XCONTENT_AGGREGATE_DATA& data);
X_RESULT CreateContent(const std::string_view root_name,
const ContentData& data);
const XCONTENT_AGGREGATE_DATA& data);
X_RESULT OpenContent(const std::string_view root_name,
const ContentData& data);
const XCONTENT_AGGREGATE_DATA& data);
X_RESULT CloseContent(const std::string_view root_name);
X_RESULT GetContentThumbnail(const ContentData& data,
X_RESULT GetContentThumbnail(const XCONTENT_AGGREGATE_DATA& data,
std::vector<uint8_t>* buffer);
X_RESULT SetContentThumbnail(const ContentData& data,
X_RESULT SetContentThumbnail(const XCONTENT_AGGREGATE_DATA& data,
std::vector<uint8_t> buffer);
X_RESULT DeleteContent(const ContentData& data);
X_RESULT DeleteContent(const XCONTENT_AGGREGATE_DATA& data);
std::filesystem::path ResolveGameUserContentPath();
bool IsContentOpen(const ContentData& data) const;
bool IsContentOpen(const XCONTENT_AGGREGATE_DATA& data) const;
void CloseOpenedFilesFromContent(const std::string_view root_name);
private:
std::filesystem::path ResolvePackageRoot(uint32_t content_type);
std::filesystem::path ResolvePackagePath(const ContentData& data);
std::filesystem::path ResolvePackageRoot(XContentType content_type,
uint32_t title_id = -1);
std::filesystem::path ResolvePackagePath(const XCONTENT_AGGREGATE_DATA& data);
KernelState* kernel_state_;
std::filesystem::path root_path_;

259
src/xenia/kernel/xam/xam_content.cc
View File

@@ -86,8 +86,8 @@ dword_result_t XamContentCreateEnumerator(dword_t user_index, dword_t device_id,
*buffer_size_ptr = sizeof(XCONTENT_DATA) * items_per_enumerate;
}
auto e = object_ref<XStaticEnumerator>(new XStaticEnumerator(
kernel_state(), items_per_enumerate, sizeof(XCONTENT_DATA)));
auto e = make_object<XStaticEnumerator<XCONTENT_DATA>>(kernel_state(),
items_per_enumerate);
auto result = e->Initialize(0xFF, 0xFE, 0x20005, 0x20007, 0);
if (XFAILED(result)) {
return result;
@@ -96,11 +96,11 @@ dword_result_t XamContentCreateEnumerator(dword_t user_index, dword_t device_id,
if (!device_info || device_info->device_id == DummyDeviceId::HDD) {
// Get all content data.
auto content_datas = kernel_state()->content_manager()->ListContent(
static_cast<uint32_t>(DummyDeviceId::HDD), content_type);
static_cast<uint32_t>(DummyDeviceId::HDD),
XContentType(uint32_t(content_type)));
for (const auto& content_data : content_datas) {
auto item = reinterpret_cast<XCONTENT_DATA*>(e->AppendItem());
assert_not_null(item);
content_data.Write(item);
auto item = e->AppendItem();
*item = content_data;
}
}
@@ -116,99 +116,126 @@ dword_result_t XamContentCreateEnumerator(dword_t user_index, dword_t device_id,
}
DECLARE_XAM_EXPORT1(XamContentCreateEnumerator, kContent, kImplemented);
dword_result_t xeXamContentCreate(dword_t user_index, lpstring_t root_name,
lpvoid_t content_data_ptr,
dword_t content_data_size, dword_t flags,
lpdword_t disposition_ptr,
lpdword_t license_mask_ptr,
dword_t cache_size, qword_t content_size,
lpvoid_t overlapped_ptr) {
XCONTENT_AGGREGATE_DATA content_data;
if (content_data_size == sizeof(XCONTENT_DATA)) {
content_data = *content_data_ptr.as<XCONTENT_DATA*>();
} else if (content_data_size == sizeof(XCONTENT_AGGREGATE_DATA)) {
content_data = *content_data_ptr.as<XCONTENT_AGGREGATE_DATA*>();
} else {
assert_always();
return X_ERROR_INVALID_PARAMETER;
}
auto content_manager = kernel_state()->content_manager();
if (overlapped_ptr && disposition_ptr) {
*disposition_ptr = 0;
}
auto run = [content_manager, root_name = root_name.value(), flags,
content_data, disposition_ptr, license_mask_ptr](
uint32_t& extended_error, uint32_t& length) -> X_RESULT {
X_RESULT result = X_ERROR_INVALID_PARAMETER;
bool create = false;
bool open = false;
switch (flags & 0xF) {
case 1: // CREATE_NEW
// Fail if exists.
if (content_manager->ContentExists(content_data)) {
result = X_ERROR_ALREADY_EXISTS;
} else {
create = true;
}
break;
case 2: // CREATE_ALWAYS
// Overwrite existing, if any.
if (content_manager->ContentExists(content_data)) {
content_manager->DeleteContent(content_data);
create = true;
} else {
create = true;
}
break;
case 3: // OPEN_EXISTING
// Open only if exists.
if (!content_manager->ContentExists(content_data)) {
result = X_ERROR_PATH_NOT_FOUND;
} else {
open = true;
}
break;
case 4: // OPEN_ALWAYS
// Create if needed.
if (!content_manager->ContentExists(content_data)) {
create = true;
} else {
open = true;
}
break;
case 5: // TRUNCATE_EXISTING
// Fail if doesn't exist, if does exist delete and recreate.
if (!content_manager->ContentExists(content_data)) {
result = X_ERROR_PATH_NOT_FOUND;
} else {
content_manager->DeleteContent(content_data);
create = true;
}
break;
default:
assert_unhandled_case(flags & 0xF);
break;
}
// creation result
// 0 = ?
// 1 = created
// 2 = opened
uint32_t disposition = create ? 1 : 2;
if (disposition_ptr) {
*disposition_ptr = disposition;
}
if (create) {
result = content_manager->CreateContent(root_name, content_data);
} else if (open) {
result = content_manager->OpenContent(root_name, content_data);
}
if (license_mask_ptr && XSUCCEEDED(result)) {
*license_mask_ptr = 0; // Stub!
}
extended_error = X_HRESULT_FROM_WIN32(result);
length = disposition;
return result;
};
if (!overlapped_ptr) {
uint32_t extended_error, length;
return run(extended_error, length);
} else {
kernel_state()->CompleteOverlappedDeferredEx(run, overlapped_ptr);
return X_ERROR_IO_PENDING;
}
}
dword_result_t XamContentCreateEx(dword_t user_index, lpstring_t root_name,
lpvoid_t content_data_ptr, dword_t flags,
lpdword_t disposition_ptr,
lpdword_t license_mask_ptr,
dword_t cache_size, qword_t content_size,
lpvoid_t overlapped_ptr) {
X_RESULT result = X_ERROR_INVALID_PARAMETER;
auto content_data =
static_cast<ContentData>(*content_data_ptr.as<XCONTENT_DATA*>());
auto content_manager = kernel_state()->content_manager();
bool create = false;
bool open = false;
switch (flags & 0xF) {
case 1: // CREATE_NEW
// Fail if exists.
if (content_manager->ContentExists(content_data)) {
result = X_ERROR_ALREADY_EXISTS;
} else {
create = true;
}
break;
case 2: // CREATE_ALWAYS
// Overwrite existing, if any.
if (content_manager->ContentExists(content_data)) {
content_manager->DeleteContent(content_data);
create = true;
} else {
create = true;
}
break;
case 3: // OPEN_EXISTING
// Open only if exists.
if (!content_manager->ContentExists(content_data)) {
result = X_ERROR_PATH_NOT_FOUND;
} else {
open = true;
}
break;
case 4: // OPEN_ALWAYS
// Create if needed.
if (!content_manager->ContentExists(content_data)) {
create = true;
} else {
open = true;
}
break;
case 5: // TRUNCATE_EXISTING
// Fail if doesn't exist, if does exist delete and recreate.
if (!content_manager->ContentExists(content_data)) {
result = X_ERROR_PATH_NOT_FOUND;
} else {
content_manager->DeleteContent(content_data);
create = true;
}
break;
default:
assert_unhandled_case(flags & 0xF);
break;
}
// creation result
// 0 = ?
// 1 = created
// 2 = opened
uint32_t disposition = create ? 1 : 2;
if (disposition_ptr) {
// In case when overlapped_ptr exist we should clear disposition_ptr first
// however we're executing it immediately, so it's not required
*disposition_ptr = disposition;
}
if (create) {
result = content_manager->CreateContent(root_name.value(), content_data);
} else if (open) {
result = content_manager->OpenContent(root_name.value(), content_data);
}
if (license_mask_ptr && XSUCCEEDED(result)) {
*license_mask_ptr = 0; // Stub!
}
if (overlapped_ptr) {
X_RESULT extended_error = X_HRESULT_FROM_WIN32(result);
if (int32_t(extended_error) < 0) {
result = X_ERROR_FUNCTION_FAILED;
}
kernel_state()->CompleteOverlappedImmediateEx(overlapped_ptr, result,
extended_error, disposition);
return X_ERROR_IO_PENDING;
} else {
return result;
}
return xeXamContentCreate(user_index, root_name, content_data_ptr,
sizeof(XCONTENT_DATA), flags, disposition_ptr,
license_mask_ptr, cache_size, content_size,
overlapped_ptr);
}
DECLARE_XAM_EXPORT1(XamContentCreateEx, kContent, kImplemented);
@@ -217,9 +244,9 @@ dword_result_t XamContentCreate(dword_t user_index, lpstring_t root_name,
lpdword_t disposition_ptr,
lpdword_t license_mask_ptr,
lpvoid_t overlapped_ptr) {
return XamContentCreateEx(user_index, root_name, content_data_ptr, flags,
disposition_ptr, license_mask_ptr, 0, 0,
overlapped_ptr);
return xeXamContentCreate(user_index, root_name, content_data_ptr,
sizeof(XCONTENT_DATA), flags, disposition_ptr,
license_mask_ptr, 0, 0, overlapped_ptr);
}
DECLARE_XAM_EXPORT1(XamContentCreate, kContent, kImplemented);
@@ -227,7 +254,8 @@ dword_result_t XamContentCreateInternal(
lpstring_t root_name, lpvoid_t content_data_ptr, dword_t flags,
lpdword_t disposition_ptr, lpdword_t license_mask_ptr, dword_t cache_size,
qword_t content_size, lpvoid_t overlapped_ptr) {
return XamContentCreateEx(0xFE, root_name, content_data_ptr, flags,
return xeXamContentCreate(0xFE, root_name, content_data_ptr,
sizeof(XCONTENT_AGGREGATE_DATA), flags,
disposition_ptr, license_mask_ptr, cache_size,
content_size, overlapped_ptr);
}
@@ -277,20 +305,26 @@ dword_result_t XamContentGetCreator(dword_t user_index,
lpunknown_t overlapped_ptr) {
auto result = X_ERROR_SUCCESS;
auto content_data =
static_cast<ContentData>(*content_data_ptr.as<XCONTENT_DATA*>());
XCONTENT_AGGREGATE_DATA content_data = *content_data_ptr.as<XCONTENT_DATA*>();
if (content_data.content_type == 1) {
// User always creates saves.
*is_creator_ptr = 1;
if (creator_xuid_ptr) {
*creator_xuid_ptr = kernel_state()->user_profile()->xuid();
bool content_exists =
kernel_state()->content_manager()->ContentExists(content_data);
if (content_exists) {
if (content_data.content_type == XContentType::kSavedGame) {
// User always creates saves.
*is_creator_ptr = 1;
if (creator_xuid_ptr) {
*creator_xuid_ptr = kernel_state()->user_profile()->xuid();
}
} else {
*is_creator_ptr = 0;
if (creator_xuid_ptr) {
*creator_xuid_ptr = 0;
}
}
} else {
*is_creator_ptr = 0;
if (creator_xuid_ptr) {
*creator_xuid_ptr = 0;
}
result = X_ERROR_PATH_NOT_FOUND;
}
if (overlapped_ptr) {
@@ -309,8 +343,7 @@ dword_result_t XamContentGetThumbnail(dword_t user_index,
lpunknown_t overlapped_ptr) {
assert_not_null(buffer_size_ptr);
uint32_t buffer_size = *buffer_size_ptr;
auto content_data =
static_cast<ContentData>(*content_data_ptr.as<XCONTENT_DATA*>());
XCONTENT_AGGREGATE_DATA content_data = *content_data_ptr.as<XCONTENT_DATA*>();
// Get thumbnail (if it exists).
std::vector<uint8_t> buffer;
@@ -346,8 +379,7 @@ dword_result_t XamContentSetThumbnail(dword_t user_index,
lpvoid_t content_data_ptr,
lpvoid_t buffer_ptr, dword_t buffer_size,
lpunknown_t overlapped_ptr) {
auto content_data =
static_cast<ContentData>(*content_data_ptr.as<XCONTENT_DATA*>());
XCONTENT_AGGREGATE_DATA content_data = *content_data_ptr.as<XCONTENT_DATA*>();
// Buffer is PNG data.
auto buffer = std::vector<uint8_t>((uint8_t*)buffer_ptr,
@@ -366,8 +398,7 @@ DECLARE_XAM_EXPORT1(XamContentSetThumbnail, kContent, kImplemented);
dword_result_t XamContentDelete(dword_t user_index, lpvoid_t content_data_ptr,
lpunknown_t overlapped_ptr) {
auto content_data =
static_cast<ContentData>(*content_data_ptr.as<XCONTENT_DATA*>());
XCONTENT_AGGREGATE_DATA content_data = *content_data_ptr.as<XCONTENT_DATA*>();
auto result = kernel_state()->content_manager()->DeleteContent(content_data);

68
src/xenia/kernel/xam/xam_content_aggregate.cc
View File

@@ -11,6 +11,7 @@
#include "xenia/base/math.h"
#include "xenia/base/string_util.h"
#include "xenia/kernel/kernel_state.h"
#include "xenia/kernel/user_module.h"
#include "xenia/kernel/util/shim_utils.h"
#include "xenia/kernel/xam/xam_content_device.h"
#include "xenia/kernel/xam/xam_private.h"
@@ -22,14 +23,15 @@ namespace xe {
namespace kernel {
namespace xam {
void AddODDContentTest(object_ref<XStaticEnumerator> e, uint32_t content_type) {
void AddODDContentTest(object_ref<XStaticEnumerator<XCONTENT_AGGREGATE_DATA>> e,
XContentType content_type) {
auto root_entry = kernel_state()->file_system()->ResolvePath(
"game:\\Content\\0000000000000000");
if (!root_entry) {
return;
}
auto content_type_path = fmt::format("{:08X}", content_type);
auto content_type_path = fmt::format("{:08X}", uint32_t(content_type));
xe::filesystem::WildcardEngine title_find_engine;
title_find_engine.SetRule("????????");
@@ -60,16 +62,15 @@ void AddODDContentTest(object_ref<XStaticEnumerator> e, uint32_t content_type) {
break;
}
auto item = reinterpret_cast<XCONTENT_AGGREGATE_DATA*>(e->AppendItem());
auto item = e->AppendItem();
assert_not_null(item);
ContentAggregateData content_aggregate_data = {};
content_aggregate_data.device_id =
static_cast<uint32_t>(DummyDeviceId::ODD);
content_aggregate_data.content_type = content_type;
content_aggregate_data.display_name = to_utf16(content_entry->name());
content_aggregate_data.file_name = content_entry->name();
content_aggregate_data.title_id = title_id;
content_aggregate_data.Write(item);
if (item) {
item->device_id = static_cast<uint32_t>(DummyDeviceId::ODD);
item->content_type = content_type;
item->set_display_name(to_utf16(content_entry->name()));
item->set_file_name(content_entry->name());
item->title_id = title_id;
}
}
}
}
@@ -87,36 +88,47 @@ dword_result_t XamContentAggregateCreateEnumerator(qword_t xuid,
return X_E_INVALIDARG;
}
auto e = object_ref<XStaticEnumerator>(new XStaticEnumerator(
kernel_state(), 1, sizeof(XCONTENT_AGGREGATE_DATA)));
auto e = make_object<XStaticEnumerator<XCONTENT_AGGREGATE_DATA>>(
kernel_state(), 1);
X_KENUMERATOR_CONTENT_AGGREGATE* extra;
auto result = e->Initialize(0xFF, 0xFE, 0x2000E, 0x20010, 0, &extra);
if (XFAILED(result)) {
return result;
}
extra->magic = 'XEN\0';
extra->magic = kXObjSignature;
extra->handle = e->handle();
auto content_type_enum = XContentType(uint32_t(content_type));
if (!device_info || device_info->device_type == DeviceType::HDD) {
// Get all content data.
auto content_datas = kernel_state()->content_manager()->ListContent(
static_cast<uint32_t>(DummyDeviceId::HDD), content_type);
for (const auto& content_data : content_datas) {
auto item = reinterpret_cast<XCONTENT_AGGREGATE_DATA*>(e->AppendItem());
assert_not_null(item);
ContentAggregateData content_aggregate_data = {};
content_aggregate_data.device_id = content_data.device_id;
content_aggregate_data.content_type = content_data.content_type;
content_aggregate_data.display_name = content_data.display_name;
content_aggregate_data.file_name = content_data.file_name;
content_aggregate_data.title_id = kernel_state()->title_id();
content_aggregate_data.Write(item);
// Fetch any alternate title IDs defined in the XEX header
// (used by games to load saves from other titles, etc)
std::vector<uint32_t> title_ids{kCurrentlyRunningTitleId};
auto exe_module = kernel_state()->GetExecutableModule();
if (exe_module && exe_module->xex_module()) {
const auto& alt_ids = exe_module->xex_module()->opt_alternate_title_ids();
std::copy(alt_ids.cbegin(), alt_ids.cend(),
std::back_inserter(title_ids));
}
for (auto& title_id : title_ids) {
// Get all content data.
auto content_datas = kernel_state()->content_manager()->ListContent(
static_cast<uint32_t>(DummyDeviceId::HDD), content_type_enum,
title_id);
for (const auto& content_data : content_datas) {
auto item = e->AppendItem();
assert_not_null(item);
if (item) {
*item = content_data;
}
}
}
}
if (!device_info || device_info->device_type == DeviceType::ODD) {
AddODDContentTest(e, content_type);
AddODDContentTest(e, content_type_enum);
}
XELOGD("XamContentAggregateCreateEnumerator: added {} items to enumerator",

7
src/xenia/kernel/xam/xam_content_device.cc
View File

@@ -139,8 +139,8 @@ dword_result_t XamContentCreateDeviceEnumerator(dword_t content_type,
*buffer_size_ptr = sizeof(X_CONTENT_DEVICE_DATA) * max_count;
}
auto e = object_ref<XStaticEnumerator>(new XStaticEnumerator(
kernel_state(), max_count, sizeof(X_CONTENT_DEVICE_DATA)));
auto e = make_object<XStaticEnumerator<X_CONTENT_DEVICE_DATA>>(kernel_state(),
max_count);
auto result = e->Initialize(0xFE, 0xFE, 0x2000A, 0x20009, 0);
if (XFAILED(result)) {
return result;
@@ -148,7 +148,8 @@ dword_result_t XamContentCreateDeviceEnumerator(dword_t content_type,
for (const auto& device_info : dummy_device_infos_) {
// Copy our dummy device into the enumerator
auto device_data = (X_CONTENT_DEVICE_DATA*)e->AppendItem();
auto device_data = e->AppendItem();
assert_not_null(device_data);
if (device_data) {
device_data->device_id = static_cast<uint32_t>(device_info->device_id);
device_data->device_type =

53
src/xenia/kernel/xam/xam_enum.cc
View File

@@ -32,49 +32,36 @@ uint32_t xeXamEnumerate(uint32_t handle, uint32_t flags, lpvoid_t buffer_ptr,
uint32_t overlapped_ptr) {
assert_true(flags == 0);
X_RESULT result;
uint32_t item_count = 0;
auto e = kernel_state()->object_table()->LookupObject<XEnumerator>(handle);
if (!e) {
result = X_ERROR_INVALID_HANDLE;
} else if (!buffer_ptr) {
result = X_ERROR_INVALID_PARAMETER;
} else {
size_t needed_buffer_size = e->item_size() * e->items_per_enumerate();
uint32_t actual_buffer_size = buffer_size;
if (buffer_size == e->items_per_enumerate()) {
actual_buffer_size = static_cast<uint32_t>(needed_buffer_size);
// Known culprits:
// Final Fight: Double Impact (saves)
XELOGW(
"Broken usage of XamEnumerate! buffer size={:X} vs actual "
"size={:X} (item size={:X}, items per enumerate={})",
buffer_size, actual_buffer_size, e->item_size(),
e->items_per_enumerate());
}
result = X_ERROR_INSUFFICIENT_BUFFER;
if (actual_buffer_size >= needed_buffer_size) {
buffer_ptr.Zero(actual_buffer_size);
result =
e->WriteItems(buffer_ptr.guest_address(), buffer_ptr.as<uint8_t*>(),
actual_buffer_size, &item_count);
}
return X_ERROR_INVALID_HANDLE;
}
auto run = [e, buffer_ptr](uint32_t& extended_error,
uint32_t& length) -> X_RESULT {
X_RESULT result;
uint32_t item_count = 0;
if (!buffer_ptr) {
result = X_ERROR_INVALID_PARAMETER;
} else {
result = e->WriteItems(buffer_ptr.guest_address(),
buffer_ptr.as<uint8_t*>(), &item_count);
}
extended_error = X_HRESULT_FROM_WIN32(result);
length = item_count;
return result;
};
if (items_returned) {
assert_true(!overlapped_ptr);
uint32_t extended_error;
uint32_t item_count;
X_RESULT result = run(extended_error, item_count);
*items_returned = result == X_ERROR_SUCCESS ? item_count : 0;
return result;
} else if (overlapped_ptr) {
assert_true(!items_returned);
kernel_state()->CompleteOverlappedImmediateEx(
overlapped_ptr,
result == X_ERROR_SUCCESS ? X_ERROR_SUCCESS : X_ERROR_FUNCTION_FAILED,
X_HRESULT_FROM_WIN32(result),
result == X_ERROR_SUCCESS ? item_count : 0);
kernel_state()->CompleteOverlappedDeferredEx(run, overlapped_ptr);
return X_ERROR_IO_PENDING;
} else {
assert_always();

2
src/xenia/kernel/xam/xam_module_export_groups.inc
View File

@@ -2,7 +2,7 @@
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2020 Ben Vanik. All rights reserved. *
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/

25
src/xenia/kernel/xam/xam_net.cc
View File

@@ -2,7 +2,7 @@
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
@@ -107,9 +107,9 @@ struct XWSAOVERLAPPED {
xe::be<uint32_t> internal_high;
union {
struct {
xe::be<uint32_t> offset;
xe::be<uint32_t> offset_high;
};
xe::be<uint32_t> low;
xe::be<uint32_t> high;
} offset; // must be named to avoid GCC error
xe::be<uint32_t> pointer;
};
xe::be<uint32_t> event_handle;
@@ -306,9 +306,11 @@ dword_result_t NetDll_WSARecvFrom(dword_t caller, dword_t socket,
//}
}
return 0;
// we're not going to be receiving packets any time soon
// return error so we don't wait on that - Cancerous
return -1;
}
DECLARE_XAM_EXPORT1(NetDll_WSARecvFrom, kNetworking, kStub);
DECLARE_XAM_EXPORT2(NetDll_WSARecvFrom, kNetworking, kStub, kHighFrequency);
// If the socket is a VDP socket, buffer 0 is the game data length, and buffer 1
// is the unencrypted game data.
@@ -598,7 +600,18 @@ dword_result_t NetDll_XNetQosListen(dword_t caller, lpvoid_t id, lpvoid_t data,
DECLARE_XAM_EXPORT1(NetDll_XNetQosListen, kNetworking, kStub);
dword_result_t NetDll_inet_addr(lpstring_t addr_ptr) {
if (!addr_ptr) {
return -1;
}
uint32_t addr = inet_addr(addr_ptr);
// https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-inet_addr#return-value
// Based on console research it seems like x360 uses old version of inet_addr
// In case of empty string it return 0 instead of -1
if (addr == -1 && !addr_ptr.value().length()) {
return 0;
}
return xe::byte_swap(addr);
}
DECLARE_XAM_EXPORT1(NetDll_inet_addr, kNetworking, kImplemented);

3
src/xenia/kernel/xam/xam_table.inc
View File

@@ -2,7 +2,7 @@
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
@@ -10,6 +10,7 @@
// This is a partial file designed to be included by other files when
// constructing various tables.
// clang-format off
XE_EXPORT(xam, 0x00000001, NetDll_WSAStartup, kFunction),
XE_EXPORT(xam, 0x00000002, NetDll_WSACleanup, kFunction),

32
src/xenia/kernel/xam/xam_task.cc
View File

@@ -11,6 +11,7 @@
#include "xenia/base/string_util.h"
#include "xenia/cpu/processor.h"
#include "xenia/kernel/kernel_state.h"
#include "xenia/kernel/user_module.h"
#include "xenia/kernel/util/shim_utils.h"
#include "xenia/kernel/xam/xam_module.h"
#include "xenia/kernel/xam/xam_private.h"
@@ -40,24 +41,37 @@ static_assert_size(XTASK_MESSAGE, 0x1C);
dword_result_t XamTaskSchedule(lpvoid_t callback,
pointer_t<XTASK_MESSAGE> message,
dword_t unknown, lpdword_t handle_ptr) {
assert_zero(unknown);
lpdword_t unknown, lpdword_t handle_ptr) {
// TODO(gibbed): figure out what this is for
*handle_ptr = 12345;
XELOGW("!! Executing scheduled task ({:08X}) synchronously, PROBABLY BAD !! ",
uint32_t stack_size = kernel_state()->GetExecutableModule()->stack_size();
// Stack must be aligned to 16kb pages
stack_size = std::max((uint32_t)0x4000, ((stack_size + 0xFFF) & 0xFFFFF000));
auto thread =
object_ref<XThread>(new XThread(kernel_state(), stack_size, 0, callback,
message.guest_address(), 0, true));
X_STATUS result = thread->Create();
if (XFAILED(result)) {
// Failed!
XELOGE("XAM task creation failed: {:08X}", result);
return result;
}
XELOGD("XAM task ({:08X}) scheduled asynchronously",
callback.guest_address());
// TODO(gibbed): this is supposed to be async... let's cheat.
auto thread_state = XThread::GetCurrentThread()->thread_state();
uint64_t args[] = {message.guest_address()};
auto result = kernel_state()->processor()->Execute(thread_state, callback,
args, xe::countof(args));
return X_STATUS_SUCCESS;
}
DECLARE_XAM_EXPORT2(XamTaskSchedule, kNone, kImplemented, kSketchy);
dword_result_t XamTaskShouldExit(dword_t r3) { return 0; }
DECLARE_XAM_EXPORT2(XamTaskShouldExit, kNone, kStub, kSketchy);
void RegisterTaskExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}

22
src/xenia/kernel/xam/xam_user.cc
View File

@@ -546,7 +546,13 @@ DECLARE_XAM_EXPORT1(XamUserAreUsersFriends, kUserProfiles, kStub);
dword_result_t XamShowSigninUI(dword_t unk, dword_t unk_mask) {
// Mask values vary. Probably matching user types? Local/remote?
// Games seem to sit and loop until we trigger this notification.
// To fix game modes that display a 4 profile signin UI (even if playing
// alone):
// XN_SYS_SIGNINCHANGED
kernel_state()->BroadcastNotification(0x0000000A, 1);
// Games seem to sit and loop until we trigger this notification:
// XN_SYS_UI (off)
kernel_state()->BroadcastNotification(0x00000009, 0);
return X_ERROR_SUCCESS;
}
@@ -601,7 +607,7 @@ class XStaticAchievementEnumerator : public XEnumerator {
}
uint32_t WriteItems(uint32_t buffer_ptr, uint8_t* buffer_data,
uint32_t buffer_size, uint32_t* written_count) override {
uint32_t* written_count) override {
size_t count =
std::min(items_.size() - current_item_, items_per_enumerate());
if (!count) {
@@ -609,9 +615,6 @@ class XStaticAchievementEnumerator : public XEnumerator {
}
size_t size = count * item_size();
if (size > buffer_size) {
return X_ERROR_INSUFFICIENT_BUFFER;
}
auto details = reinterpret_cast<X_ACHIEVEMENT_DETAILS*>(buffer_data);
size_t string_offset =
@@ -737,6 +740,9 @@ dword_result_t XamReadTileToTexture(dword_t unknown, dword_t title_id,
lpvoid_t buffer_ptr, dword_t stride,
dword_t height, dword_t overlapped_ptr) {
// TODO(gibbed): unknown=0,2,3,9
if (!tile_id) {
return X_ERROR_INVALID_PARAMETER;
}
size_t size = size_t(stride) * size_t(height);
std::memset(buffer_ptr, 0xFF, size);
@@ -770,8 +776,10 @@ DECLARE_XAM_EXPORT1(XamSessionCreateHandle, kUserProfiles, kStub);
dword_result_t XamSessionRefObjByHandle(dword_t handle, lpdword_t obj_ptr) {
assert_true(handle == 0xCAFEDEAD);
*obj_ptr = 0;
return X_ERROR_FUNCTION_FAILED;
// TODO(PermaNull): Implement this properly,
// For the time being returning 0xDEADF00D will prevent crashing.
*obj_ptr = 0xDEADF00D;
return X_ERROR_SUCCESS;
}
DECLARE_XAM_EXPORT1(XamSessionRefObjByHandle, kUserProfiles, kStub);

3
src/xenia/kernel/xbdm/xbdm_table.inc
View File

@@ -2,7 +2,7 @@
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
@@ -10,6 +10,7 @@
// This is a partial file designed to be included by other files when
// constructing various tables.
// clang-format off
XE_EXPORT(xbdm, 0x00000001, DmAllocatePool, kFunction),
XE_EXPORT(xbdm, 0x00000002, DmAllocatePoolWithTag, kFunction),

4
src/xenia/kernel/xboxkrnl/xboxkrnl_error.cc
View File

@@ -997,7 +997,7 @@ uint32_t xeRtlNtStatusToDosError(uint32_t source_status) {
if (!result) {
break;
}
XELOGI("RtlNtStatusToDosError {:X} => {:X}", status, result);
XELOGI("xeRtlNtStatusToDosError {:X} => {:X}", status, result);
return result;
}
++error_table;
@@ -1007,7 +1007,7 @@ uint32_t xeRtlNtStatusToDosError(uint32_t source_status) {
return status & 0xFFFF;
}
XELOGE("RtlNtStatusToDosError lookup NOT IMPLEMENTED");
XELOGE("xeRtlNtStatusToDosError lookup NOT IMPLEMENTED");
return 317; // ERROR_MR_MID_NOT_FOUND
}

101
src/xenia/kernel/xboxkrnl/xboxkrnl_io.cc
View File

@@ -357,11 +357,7 @@ dword_result_t NtWriteFile(dword_t file_handle, dword_t event_handle,
pointer_t<X_IO_STATUS_BLOCK> io_status_block,
lpvoid_t buffer, dword_t buffer_length,
lpqword_t byte_offset_ptr) {
// Async not supported yet.
assert_zero(apc_routine);
X_STATUS result = X_STATUS_SUCCESS;
uint32_t info = 0;
// Grab event to signal.
bool signal_event = false;
@@ -386,30 +382,37 @@ dword_result_t NtWriteFile(dword_t file_handle, dword_t event_handle,
buffer.guest_address(), buffer_length,
byte_offset_ptr ? static_cast<uint64_t>(*byte_offset_ptr) : -1,
&bytes_written, apc_context);
if (XSUCCEEDED(result)) {
info = bytes_written;
if (io_status_block) {
io_status_block->status = result;
io_status_block->information = static_cast<uint32_t>(bytes_written);
}
// Queue the APC callback. It must be delivered via the APC mechanism even
// though were are completing immediately.
// Low bit probably means do not queue to IO ports.
if ((uint32_t)apc_routine & ~1) {
if (apc_context) {
auto thread = XThread::GetCurrentThread();
thread->EnqueueApc(static_cast<uint32_t>(apc_routine) & ~1u,
apc_context, io_status_block, 0);
}
}
if (!file->is_synchronous()) {
result = X_STATUS_PENDING;
}
if (io_status_block) {
io_status_block->status = X_STATUS_SUCCESS;
io_status_block->information = info;
}
// Mark that we should signal the event now. We do this after
// we have written the info out.
signal_event = true;
} else {
// X_STATUS_PENDING if not returning immediately.
result = X_STATUS_PENDING;
info = 0;
if (io_status_block) {
io_status_block->status = X_STATUS_SUCCESS;
io_status_block->information = info;
io_status_block->status = X_STATUS_PENDING;
io_status_block->information = 0;
}
}
}
@@ -458,7 +461,8 @@ dword_result_t NtSetIoCompletion(dword_t handle, dword_t key_context,
port->QueueNotification(notification);
return X_STATUS_SUCCESS;
}
DECLARE_XBOXKRNL_EXPORT1(NtSetIoCompletion, kFileSystem, kImplemented);
DECLARE_XBOXKRNL_EXPORT2(NtSetIoCompletion, kFileSystem, kImplemented,
kHighFrequency);
// Dequeues a packet from the completion port.
dword_result_t NtRemoveIoCompletion(
@@ -473,7 +477,9 @@ dword_result_t NtRemoveIoCompletion(
status = X_STATUS_INVALID_HANDLE;
}
uint64_t timeout_ticks = timeout ? static_cast<uint32_t>(*timeout) : 0u;
uint64_t timeout_ticks =
timeout ? static_cast<uint32_t>(*timeout)
: static_cast<uint64_t>(std::numeric_limits<int64_t>::min());
XIOCompletion::IONotification notification;
if (port->WaitForNotification(timeout_ticks, &notification)) {
if (key_context) {
@@ -493,7 +499,8 @@ dword_result_t NtRemoveIoCompletion(
return status;
}
DECLARE_XBOXKRNL_EXPORT1(NtRemoveIoCompletion, kFileSystem, kImplemented);
DECLARE_XBOXKRNL_EXPORT2(NtRemoveIoCompletion, kFileSystem, kImplemented,
kHighFrequency);
dword_result_t NtQueryFullAttributesFile(
pointer_t<X_OBJECT_ATTRIBUTES> obj_attribs,
@@ -667,6 +674,66 @@ dword_result_t FscSetCacheElementCount(dword_t unk_0, dword_t unk_1) {
}
DECLARE_XBOXKRNL_EXPORT1(FscSetCacheElementCount, kFileSystem, kStub);
dword_result_t NtDeviceIoControlFile(
dword_t handle, dword_t event_handle, dword_t apc_routine,
dword_t apc_context, dword_t io_status_block, dword_t io_control_code,
lpvoid_t input_buffer, dword_t input_buffer_len, lpvoid_t output_buffer,
dword_t output_buffer_len) {
// Called by XMountUtilityDrive cache-mounting code
// (checks if the returned values look valid, values below seem to pass the
// checks)
const uint32_t cache_size = 0xFF000;
const uint32_t X_IOCTL_DISK_GET_DRIVE_GEOMETRY = 0x70000;
const uint32_t X_IOCTL_DISK_GET_PARTITION_INFO = 0x74004;
if (io_control_code == X_IOCTL_DISK_GET_DRIVE_GEOMETRY) {
if (output_buffer_len < 0x8) {
assert_always();
return X_STATUS_BUFFER_TOO_SMALL;
}
xe::store_and_swap<uint32_t>(output_buffer, cache_size / 512);
xe::store_and_swap<uint32_t>(output_buffer + 4, 512);
} else if (io_control_code == X_IOCTL_DISK_GET_PARTITION_INFO) {
if (output_buffer_len < 0x10) {
assert_always();
return X_STATUS_BUFFER_TOO_SMALL;
}
xe::store_and_swap<uint64_t>(output_buffer, 0);
xe::store_and_swap<uint64_t>(output_buffer + 8, cache_size);
} else {
XELOGD("NtDeviceIoControlFile(0x{:X}) - unhandled IOCTL!",
uint32_t(io_control_code));
assert_always();
return X_STATUS_INVALID_PARAMETER;
}
return X_STATUS_SUCCESS;
}
DECLARE_XBOXKRNL_EXPORT1(NtDeviceIoControlFile, kFileSystem, kStub);
dword_result_t IoCreateDevice(dword_t device_struct, dword_t r4, dword_t r5,
dword_t r6, dword_t r7, lpdword_t out_struct) {
// Called from XMountUtilityDrive XAM-task code
// That code tries writing things to a pointer at out_struct+0x18
// We'll alloc some scratch space for it so it doesn't cause any exceptions
// 0x24 is guessed size from accesses to out_struct - likely incorrect
auto out_guest = kernel_memory()->SystemHeapAlloc(0x24);
auto out = kernel_memory()->TranslateVirtual<uint8_t*>(out_guest);
memset(out, 0, 0x24);
// XMountUtilityDrive writes some kind of header here
// 0x1000 bytes should be enough to store it
auto out_guest2 = kernel_memory()->SystemHeapAlloc(0x1000);
xe::store_and_swap(out + 0x18, out_guest2);
*out_struct = out_guest;
return X_STATUS_SUCCESS;
}
DECLARE_XBOXKRNL_EXPORT1(IoCreateDevice, kFileSystem, kStub);
void RegisterIoExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}

7
src/xenia/kernel/xboxkrnl/xboxkrnl_io_info.cc
View File

@@ -126,6 +126,13 @@ dword_result_t NtQueryInformationFile(
out_length = sizeof(*info);
break;
}
case XFileAlignmentInformation: {
// Requested by XMountUtilityDrive XAM-task
auto info = info_ptr.as<uint32_t*>();
*info = 0; // FILE_BYTE_ALIGNMENT?
out_length = sizeof(*info);
break;
}
default: {
// Unsupported, for now.
assert_always();

10
src/xenia/kernel/xboxkrnl/xboxkrnl_module.cc
View File

@@ -189,6 +189,16 @@ XboxkrnlModule::XboxkrnlModule(Emulator* emulator, KernelState* kernel_state)
ordinals::XexExecutableModuleHandle,
ppXexExecutableModuleHandle);
// ExLoadedImageName (char*)
// The full path to loaded image/xex including its name.
// Used usually in custom dashboards (Aurora)
// Todo(Gliniak): Confirm that official kernel always allocate space for this
// variable.
uint32_t ppExLoadedImageName =
memory_->SystemHeapAlloc(kExLoadedImageNameSize);
export_resolver_->SetVariableMapping(
"xboxkrnl.exe", ordinals::ExLoadedImageName, ppExLoadedImageName);
// ExLoadedCommandLine (char*)
// The name of the xex. Not sure this is ever really used on real devices.
// Perhaps it's how swap disc/etc data is sent?

2
src/xenia/kernel/xboxkrnl/xboxkrnl_module.h
View File

@@ -27,6 +27,8 @@ namespace xboxkrnl {
class XboxkrnlModule : public KernelModule {
public:
static constexpr size_t kExLoadedImageNameSize = 255 + 1;
XboxkrnlModule(Emulator* emulator, KernelState* kernel_state);
virtual ~XboxkrnlModule();

73
src/xenia/kernel/xboxkrnl/xboxkrnl_strings.cc
View File

@@ -19,6 +19,9 @@
#include "xenia/kernel/xthread.h"
#include "xenia/xbox.h"
DEFINE_bool(log_string_format_kernel_calls, false,
"Log kernel calls with the kHighFrequency tag.", "Logging");
namespace xe {
namespace kernel {
namespace xboxkrnl {
@@ -830,7 +833,14 @@ SHIM_CALL DbgPrint_shim(PPCContext* ppc_context, KernelState* kernel_state) {
return;
}
XELOGD("(DbgPrint) {}", data.str());
// trim whitespace from end of message
auto str = data.str();
str.erase(std::find_if(str.rbegin(), str.rend(),
[](uint8_t c) { return !std::isspace(c); })
.base(),
str.end());
XELOGI("(DbgPrint) {}", str);
SHIM_SET_RETURN_32(X_STATUS_SUCCESS);
}
@@ -841,8 +851,11 @@ SHIM_CALL _snprintf_shim(PPCContext* ppc_context, KernelState* kernel_state) {
int32_t buffer_count = SHIM_GET_ARG_32(1);
uint32_t format_ptr = SHIM_GET_ARG_32(2);
XELOGD("_snprintf({:08X}, {}, {:08X}, ...)", buffer_ptr, buffer_count,
format_ptr);
if (cvars::log_high_frequency_kernel_calls) {
XELOGD("_snprintf({:08X}, {}, {:08X}({}), ...)", buffer_ptr, buffer_count,
format_ptr,
xe::load_and_swap<std::string>(SHIM_MEM_ADDR(format_ptr)));
}
if (buffer_ptr == 0 || buffer_count <= 0 || format_ptr == 0) {
SHIM_SET_RETURN_32(-1);
@@ -877,7 +890,10 @@ SHIM_CALL sprintf_shim(PPCContext* ppc_context, KernelState* kernel_state) {
uint32_t buffer_ptr = SHIM_GET_ARG_32(0);
uint32_t format_ptr = SHIM_GET_ARG_32(1);
XELOGD("sprintf({:08X}, {:08X}, ...)", buffer_ptr, format_ptr);
if (cvars::log_high_frequency_kernel_calls) {
XELOGD("sprintf({:08X}, {:08X}({}), ...)", buffer_ptr, format_ptr,
xe::load_and_swap<std::string>(SHIM_MEM_ADDR(format_ptr)));
}
if (buffer_ptr == 0 || format_ptr == 0) {
SHIM_SET_RETURN_32(-1);
@@ -906,8 +922,12 @@ SHIM_CALL _snwprintf_shim(PPCContext* ppc_context, KernelState* kernel_state) {
int32_t buffer_count = SHIM_GET_ARG_32(1);
uint32_t format_ptr = SHIM_GET_ARG_32(2);
XELOGD("_snwprintf({:08X}, {}, {:08X}, ...)", buffer_ptr, buffer_count,
format_ptr);
if (cvars::log_high_frequency_kernel_calls) {
XELOGD("_snwprintf({:08X}, {}, {:08X}({}), ...)", buffer_ptr, buffer_count,
format_ptr,
xe::to_utf8(
xe::load_and_swap<std::u16string>(SHIM_MEM_ADDR(format_ptr))));
}
if (buffer_ptr == 0 || buffer_count <= 0 || format_ptr == 0) {
SHIM_SET_RETURN_32(-1);
@@ -942,7 +962,11 @@ SHIM_CALL swprintf_shim(PPCContext* ppc_context, KernelState* kernel_state) {
uint32_t buffer_ptr = SHIM_GET_ARG_32(0);
uint32_t format_ptr = SHIM_GET_ARG_32(1);
XELOGD("swprintf({:08X}, {:08X}, ...)", buffer_ptr, format_ptr);
if (cvars::log_high_frequency_kernel_calls) {
XELOGD("swprintf({:08X}, {:08X}({}), ...)", buffer_ptr, format_ptr,
xe::to_utf8(
xe::load_and_swap<std::u16string>(SHIM_MEM_ADDR(format_ptr))));
}
if (buffer_ptr == 0 || format_ptr == 0) {
SHIM_SET_RETURN_32(-1);
@@ -972,8 +996,11 @@ SHIM_CALL _vsnprintf_shim(PPCContext* ppc_context, KernelState* kernel_state) {
uint32_t format_ptr = SHIM_GET_ARG_32(2);
uint32_t arg_ptr = SHIM_GET_ARG_32(3);
XELOGD("_vsnprintf({:08X}, {}, {:08X}, {:08X})", buffer_ptr, buffer_count,
format_ptr, arg_ptr);
if (cvars::log_high_frequency_kernel_calls) {
XELOGD("_vsnprintf({:08X}, {}, {:08X}({}), {:08X})", buffer_ptr,
buffer_count, format_ptr,
xe::load_and_swap<std::string>(SHIM_MEM_ADDR(format_ptr)), arg_ptr);
}
if (buffer_ptr == 0 || buffer_count <= 0 || format_ptr == 0) {
SHIM_SET_RETURN_32(-1);
@@ -1012,8 +1039,13 @@ SHIM_CALL _vsnwprintf_shim(PPCContext* ppc_context, KernelState* kernel_state) {
uint32_t format_ptr = SHIM_GET_ARG_32(2);
uint32_t arg_ptr = SHIM_GET_ARG_32(3);
XELOGD("_vsnwprintf({:08X}, {}, {:08X}, {:08X})", buffer_ptr, buffer_count,
format_ptr, arg_ptr);
if (cvars::log_high_frequency_kernel_calls) {
XELOGD("_vsnwprintf({:08X}, {}, {:08X}({}), {:08X})", buffer_ptr,
buffer_count, format_ptr,
xe::to_utf8(
xe::load_and_swap<std::u16string>(SHIM_MEM_ADDR(format_ptr))),
arg_ptr);
}
if (buffer_ptr == 0 || buffer_count <= 0 || format_ptr == 0) {
SHIM_SET_RETURN_32(-1);
@@ -1051,7 +1083,10 @@ SHIM_CALL vsprintf_shim(PPCContext* ppc_context, KernelState* kernel_state) {
uint32_t format_ptr = SHIM_GET_ARG_32(1);
uint32_t arg_ptr = SHIM_GET_ARG_32(2);
XELOGD("vsprintf({:08X}, {:08X}, {:08X})", buffer_ptr, format_ptr, arg_ptr);
if (cvars::log_high_frequency_kernel_calls) {
XELOGD("vsprintf({:08X}, {:08X}({}), {:08X})", buffer_ptr, format_ptr,
xe::load_and_swap<std::string>(SHIM_MEM_ADDR(format_ptr)), arg_ptr);
}
if (buffer_ptr == 0 || format_ptr == 0) {
SHIM_SET_RETURN_32(-1);
@@ -1079,7 +1114,12 @@ SHIM_CALL _vscwprintf_shim(PPCContext* ppc_context, KernelState* kernel_state) {
uint32_t format_ptr = SHIM_GET_ARG_32(0);
uint32_t arg_ptr = SHIM_GET_ARG_32(1);
XELOGD("_vscwprintf({:08X}, {:08X})", format_ptr, arg_ptr);
if (cvars::log_high_frequency_kernel_calls) {
XELOGD("_vscwprintf({:08X}({}), {:08X})", format_ptr,
xe::to_utf8(
xe::load_and_swap<std::u16string>(SHIM_MEM_ADDR(format_ptr))),
arg_ptr);
}
if (format_ptr == 0) {
SHIM_SET_RETURN_32(-1);
@@ -1102,7 +1142,12 @@ SHIM_CALL vswprintf_shim(PPCContext* ppc_context, KernelState* kernel_state) {
uint32_t format_ptr = SHIM_GET_ARG_32(1);
uint32_t arg_ptr = SHIM_GET_ARG_32(2);
XELOGD("vswprintf({:08X}, {:08X}, {:08X})", buffer_ptr, format_ptr, arg_ptr);
if (cvars::log_high_frequency_kernel_calls) {
XELOGD("vswprintf({:08X}, {:08X}({}), {:08X})", buffer_ptr, format_ptr,
xe::to_utf8(
xe::load_and_swap<std::u16string>(SHIM_MEM_ADDR(format_ptr))),
arg_ptr);
}
if (buffer_ptr == 0 || format_ptr == 0) {
SHIM_SET_RETURN_32(-1);

3
src/xenia/kernel/xboxkrnl/xboxkrnl_table.inc
View File

@@ -2,7 +2,7 @@
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
@@ -10,6 +10,7 @@
// This is a partial file designed to be included by other files when
// constructing various tables.
// clang-format off
XE_EXPORT(xboxkrnl, 0x00000001, DbgBreakPoint, kFunction),
XE_EXPORT(xboxkrnl, 0x00000002, DbgBreakPointWithStatus, kFunction),

8
src/xenia/kernel/xboxkrnl/xboxkrnl_threading.cc
View File

@@ -960,14 +960,14 @@ void KeReleaseSpinLockFromRaisedIrql(lpdword_t lock_ptr) {
DECLARE_XBOXKRNL_EXPORT2(KeReleaseSpinLockFromRaisedIrql, kThreading,
kImplemented, kHighFrequency);
void KeEnterCriticalRegion() { XThread::EnterCriticalRegion(); }
void KeEnterCriticalRegion() {
XThread::GetCurrentThread()->EnterCriticalRegion();
}
DECLARE_XBOXKRNL_EXPORT2(KeEnterCriticalRegion, kThreading, kImplemented,
kHighFrequency);
void KeLeaveCriticalRegion() {
XThread::LeaveCriticalRegion();
XThread::GetCurrentThread()->CheckApcs();
XThread::GetCurrentThread()->LeaveCriticalRegion();
}
DECLARE_XBOXKRNL_EXPORT2(KeLeaveCriticalRegion, kThreading, kImplemented,
kHighFrequency);

52
src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc
View File

@@ -344,7 +344,7 @@ dword_result_t VdRetrainEDRAM(unknown_t unk0, unknown_t unk1, unknown_t unk2,
DECLARE_XBOXKRNL_EXPORT1(VdRetrainEDRAM, kVideo, kStub);
void VdSwap(lpvoid_t buffer_ptr, // ptr into primary ringbuffer
lpvoid_t fetch_ptr, // frontbuffer texture fetch
lpvoid_t fetch_ptr, // frontbuffer Direct3D 9 texture header fetch
lpunknown_t unk2, // system writeback ptr
lpunknown_t unk3, // buffer from VdGetSystemCommandBuffer
lpunknown_t unk4, // from VdGetSystemCommandBuffer (0xBEEF0001)
@@ -361,23 +361,29 @@ void VdSwap(lpvoid_t buffer_ptr, // ptr into primary ringbuffer
namespace xenos = xe::gpu::xenos;
xenos::xe_gpu_texture_fetch_t fetch;
xenos::xe_gpu_texture_fetch_t gpu_fetch;
xe::copy_and_swap_32_unaligned(
&fetch, reinterpret_cast<uint32_t*>(fetch_ptr.host_address()), 6);
&gpu_fetch, reinterpret_cast<uint32_t*>(fetch_ptr.host_address()), 6);
// Kernel virtual -> GPU physical.
uint32_t frontbuffer_address = fetch.base_address << 12;
assert_true(*frontbuffer_ptr == frontbuffer_address);
frontbuffer_address =
kernel_memory()->GetPhysicalAddress(frontbuffer_address);
assert_true(frontbuffer_address != UINT32_MAX);
if (frontbuffer_address == UINT32_MAX) {
// The fetch constant passed is not a true GPU fetch constant, but rather, the
// fetch constant stored in the Direct3D 9 texture header, which contains the
// address in one of the virtual mappings of the physical memory rather than
// the physical address itself. We're emulating swapping in the GPU subsystem,
// which works with GPU memory addresses (physical addresses directly) from
// proper fetch constants like ones used to bind textures to shaders, not CPU
// MMU addresses, so translation from virtual to physical is needed.
uint32_t frontbuffer_virtual_address = gpu_fetch.base_address << 12;
assert_true(*frontbuffer_ptr == frontbuffer_virtual_address);
uint32_t frontbuffer_physical_address =
kernel_memory()->GetPhysicalAddress(frontbuffer_virtual_address);
assert_true(frontbuffer_physical_address != UINT32_MAX);
if (frontbuffer_physical_address == UINT32_MAX) {
// Xenia-specific safety check.
XELOGE("VdSwap: Invalid front buffer virtual address 0x{:08X}",
fetch.base_address << 12);
frontbuffer_virtual_address);
return;
}
fetch.base_address = frontbuffer_address >> 12;
gpu_fetch.base_address = frontbuffer_physical_address >> 12;
auto texture_format = gpu::xenos::TextureFormat(texture_format_ptr.value());
auto color_space = *color_space_ptr;
@@ -385,8 +391,8 @@ void VdSwap(lpvoid_t buffer_ptr, // ptr into primary ringbuffer
texture_format ==
gpu::xenos::TextureFormat::k_2_10_10_10_AS_16_16_16_16);
assert_true(color_space == 0); // RGB(0)
assert_true(*width == 1 + fetch.size_2d.width);
assert_true(*height == 1 + fetch.size_2d.height);
assert_true(*width == 1 + gpu_fetch.size_2d.width);
assert_true(*height == 1 + gpu_fetch.size_2d.height);
// The caller seems to reserve 64 words (256b) in the primary ringbuffer
// for this method to do what it needs. We just zero them out and send a
@@ -398,19 +404,19 @@ void VdSwap(lpvoid_t buffer_ptr, // ptr into primary ringbuffer
uint32_t offset = 0;
auto dwords = buffer_ptr.as_array<uint32_t>();
// Write in the texture fetch.
// Write in the GPU texture fetch.
dwords[offset++] =
xenos::MakePacketType0(gpu::XE_GPU_REG_SHADER_CONSTANT_FETCH_00_0, 6);
dwords[offset++] = fetch.dword_0;
dwords[offset++] = fetch.dword_1;
dwords[offset++] = fetch.dword_2;
dwords[offset++] = fetch.dword_3;
dwords[offset++] = fetch.dword_4;
dwords[offset++] = fetch.dword_5;
dwords[offset++] = gpu_fetch.dword_0;
dwords[offset++] = gpu_fetch.dword_1;
dwords[offset++] = gpu_fetch.dword_2;
dwords[offset++] = gpu_fetch.dword_3;
dwords[offset++] = gpu_fetch.dword_4;
dwords[offset++] = gpu_fetch.dword_5;
dwords[offset++] = xenos::MakePacketType3(xenos::PM4_XE_SWAP, 4);
dwords[offset++] = 'SWAP';
dwords[offset++] = frontbuffer_address;
dwords[offset++] = xe::gpu::xenos::kSwapSignature;
dwords[offset++] = frontbuffer_physical_address;
dwords[offset++] = *width;
dwords[offset++] = *height;

32
src/xenia/kernel/xenumerator.cc
View File

@@ -21,7 +21,7 @@ XEnumerator::XEnumerator(KernelState* kernel_state, size_t items_per_enumerate,
XEnumerator::~XEnumerator() = default;
X_STATUS XEnumerator::Initialize(uint32_t user_index, uint32_t app_id,
uint32_t message, uint32_t message2,
uint32_t open_message, uint32_t close_message,
uint32_t flags, uint32_t extra_size,
void** extra_buffer) {
auto native_object = CreateNative(sizeof(X_KENUMERATOR) + extra_size);
@@ -30,8 +30,8 @@ X_STATUS XEnumerator::Initialize(uint32_t user_index, uint32_t app_id,
}
auto guest_object = reinterpret_cast<X_KENUMERATOR*>(native_object);
guest_object->app_id = app_id;
guest_object->message = message;
guest_object->message2 = message2;
guest_object->open_message = open_message;
guest_object->close_message = close_message;
guest_object->user_index = user_index;
guest_object->items_per_enumerate =
static_cast<uint32_t>(items_per_enumerate_);
@@ -44,32 +44,28 @@ X_STATUS XEnumerator::Initialize(uint32_t user_index, uint32_t app_id,
}
X_STATUS XEnumerator::Initialize(uint32_t user_index, uint32_t app_id,
uint32_t message, uint32_t message2,
uint32_t open_message, uint32_t close_message,
uint32_t flags) {
return Initialize(user_index, app_id, message, message2, flags, 0, nullptr);
return Initialize(user_index, app_id, open_message, close_message, flags, 0,
nullptr);
}
uint8_t* XStaticEnumerator::AppendItem() {
buffer_.resize(++item_count_ * item_size());
auto ptr =
const_cast<uint8_t*>(buffer_.data() + (item_count_ - 1) * item_size());
return ptr;
uint8_t* XStaticUntypedEnumerator::AppendItem() {
size_t offset = buffer_.size();
buffer_.resize(offset + item_size());
item_count_++;
return const_cast<uint8_t*>(&buffer_.data()[offset]);
}
uint32_t XStaticEnumerator::WriteItems(uint32_t buffer_ptr,
uint8_t* buffer_data,
uint32_t buffer_size,
uint32_t* written_count) {
uint32_t XStaticUntypedEnumerator::WriteItems(uint32_t buffer_ptr,
uint8_t* buffer_data,
uint32_t* written_count) {
size_t count = std::min(item_count_ - current_item_, items_per_enumerate());
if (!count) {
return X_ERROR_NO_MORE_FILES;
}
size_t size = count * item_size();
if (size > buffer_size) {
return X_ERROR_INSUFFICIENT_BUFFER;
}
size_t offset = current_item_ * item_size();
std::memcpy(buffer_data, buffer_.data() + offset, size);

50
src/xenia/kernel/xenumerator.h
View File

@@ -22,8 +22,8 @@ namespace kernel {
struct X_KENUMERATOR {
be<uint32_t> app_id;
be<uint32_t> message;
be<uint32_t> message2;
be<uint32_t> open_message;
be<uint32_t> close_message;
be<uint32_t> user_index;
be<uint32_t> items_per_enumerate;
be<uint32_t> flags;
@@ -43,19 +43,21 @@ class XEnumerator : public XObject {
size_t item_size);
virtual ~XEnumerator();
X_STATUS Initialize(uint32_t user_index, uint32_t app_id, uint32_t message,
uint32_t message2, uint32_t flags, uint32_t extra_size,
void** extra_buffer);
X_STATUS Initialize(uint32_t user_index, uint32_t app_id,
uint32_t open_message, uint32_t close_message,
uint32_t flags, uint32_t extra_size, void** extra_buffer);
X_STATUS Initialize(uint32_t user_index, uint32_t app_id, uint32_t message,
uint32_t message2, uint32_t flags);
X_STATUS Initialize(uint32_t user_index, uint32_t app_id,
uint32_t open_message, uint32_t close_message,
uint32_t flags);
template <typename T>
X_STATUS Initialize(uint32_t user_index, uint32_t app_id, uint32_t message,
uint32_t message2, uint32_t flags, T** extra) {
X_STATUS Initialize(uint32_t user_index, uint32_t app_id,
uint32_t open_message, uint32_t close_message,
uint32_t flags, T** extra) {
void* dummy;
auto result = Initialize(user_index, app_id, message, message2, flags,
static_cast<uint32_t>(sizeof(T)), &dummy);
auto result = Initialize(user_index, app_id, open_message, close_message,
flags, static_cast<uint32_t>(sizeof(T)), &dummy);
if (extra) {
*extra = XFAILED(result) ? nullptr : static_cast<T*>(dummy);
}
@@ -63,7 +65,6 @@ class XEnumerator : public XObject {
}
virtual uint32_t WriteItems(uint32_t buffer_ptr, uint8_t* buffer_data,
uint32_t buffer_size,
uint32_t* written_count) = 0;
size_t item_size() const { return item_size_; }
@@ -74,10 +75,10 @@ class XEnumerator : public XObject {
size_t item_size_;
};
class XStaticEnumerator : public XEnumerator {
class XStaticUntypedEnumerator : public XEnumerator {
public:
XStaticEnumerator(KernelState* kernel_state, size_t items_per_enumerate,
size_t item_size)
XStaticUntypedEnumerator(KernelState* kernel_state,
size_t items_per_enumerate, size_t item_size)
: XEnumerator(kernel_state, items_per_enumerate, item_size),
item_count_(0),
current_item_(0) {}
@@ -87,7 +88,7 @@ class XStaticEnumerator : public XEnumerator {
uint8_t* AppendItem();
uint32_t WriteItems(uint32_t buffer_ptr, uint8_t* buffer_data,
uint32_t buffer_size, uint32_t* written_count) override;
uint32_t* written_count) override;
private:
size_t item_count_;
@@ -95,6 +96,23 @@ class XStaticEnumerator : public XEnumerator {
std::vector<uint8_t> buffer_;
};
template <typename T>
class XStaticEnumerator : public XStaticUntypedEnumerator {
public:
XStaticEnumerator(KernelState* kernel_state, size_t items_per_enumerate)
: XStaticUntypedEnumerator(kernel_state, items_per_enumerate, sizeof(T)) {
}
T* AppendItem() {
return reinterpret_cast<T*>(XStaticUntypedEnumerator::AppendItem());
}
void AppendItem(const T& item) {
auto ptr = AppendItem();
item.Write(ptr);
}
};
} // namespace kernel
} // namespace xe

2
src/xenia/kernel/xiocompletion.cc
View File

@@ -30,7 +30,7 @@ bool XIOCompletion::WaitForNotification(uint64_t wait_ticks,
IONotification* notify) {
auto ms = std::chrono::milliseconds(TimeoutTicksToMs(wait_ticks));
auto res = threading::Wait(notification_semaphore_.get(), false, ms);
if (res == threading::WaitResult::kSuccess || !wait_ticks) {
if (res == threading::WaitResult::kSuccess) {
std::unique_lock<std::mutex> lock(notification_lock_);
assert_false(notifications_.empty());

4
src/xenia/kernel/xmodule.cc
View File

@@ -71,7 +71,7 @@ uint32_t XModule::GetHandleFromHModule(void* hmodule) {
bool XModule::Save(ByteStream* stream) {
XELOGD("XModule {:08X} ({})", handle(), path());
stream->Write('XMOD');
stream->Write(kModuleSaveSignature);
stream->Write(path());
stream->Write(hmodule_ptr_);
@@ -85,7 +85,7 @@ bool XModule::Save(ByteStream* stream) {
object_ref<XModule> XModule::Restore(KernelState* kernel_state,
ByteStream* stream) {
if (stream->Read<uint32_t>() != 'XMOD') {
if (stream->Read<uint32_t>() != kModuleSaveSignature) {
return nullptr;
}

2
src/xenia/kernel/xmodule.h
View File

@@ -19,6 +19,8 @@
namespace xe {
namespace kernel {
constexpr fourcc_t kModuleSaveSignature = make_fourcc("XMOD");
// https://www.nirsoft.net/kernel_struct/vista/LDR_DATA_TABLE_ENTRY.html
// HMODULE points to this struct!
struct X_LDR_DATA_TABLE_ENTRY {

2
src/xenia/kernel/xobject.cc
View File

@@ -381,7 +381,7 @@ object_ref<XObject> XObject::GetNativeObject(KernelState* kernel_state,
as_type = header->type;
}
if (header->wait_list_flink == 'XEN\0') {
if (header->wait_list_flink == kXObjSignature) {
// Already initialized.
// TODO: assert if the type of the object != as_type
uint32_t handle = header->wait_list_blink;

10
src/xenia/kernel/xobject.h
View File

@@ -27,6 +27,8 @@ class Emulator;
namespace xe {
namespace kernel {
constexpr fourcc_t kXObjSignature = make_fourcc('X', 'E', 'N', '\0');
class KernelState;
template <typename T>
@@ -214,7 +216,7 @@ class XObject {
// Stash native pointer into X_DISPATCH_HEADER
static void StashHandle(X_DISPATCH_HEADER* header, uint32_t handle) {
header->wait_list_flink = 'XEN\0';
header->wait_list_flink = kXObjSignature;
header->wait_list_blink = handle;
}
@@ -346,6 +348,12 @@ bool operator!=(std::nullptr_t _Left, const object_ref<_Ty>& _Right) noexcept {
return (!(_Left == _Right));
}
template <class T, class... Args>
std::enable_if_t<!std::is_array<T>::value, object_ref<T>> make_object(
Args&&... args) {
return object_ref<T>(new T(std::forward<Args>(args)...));
}
template <typename T>
object_ref<T> retain_object(T* ptr) {
if (ptr) ptr->Retain();

31
src/xenia/kernel/xthread.cc
View File

@@ -226,7 +226,7 @@ void XThread::InitializeGuestObject() {
}
bool XThread::AllocateStack(uint32_t size) {
auto heap = memory()->LookupHeap(0x40000000);
auto heap = memory()->LookupHeap(kStackAddressRangeBegin);
auto alignment = heap->page_size();
auto padding = heap->page_size() * 2; // Guard page size * 2
@@ -234,10 +234,10 @@ bool XThread::AllocateStack(uint32_t size) {
auto actual_size = size + padding;
uint32_t address = 0;
if (!heap->AllocRange(0x40000000, 0x7F000000, actual_size, alignment,
kMemoryAllocationReserve | kMemoryAllocationCommit,
kMemoryProtectRead | kMemoryProtectWrite, false,
&address)) {
if (!heap->AllocRange(
kStackAddressRangeBegin, kStackAddressRangeEnd, actual_size,
alignment, kMemoryAllocationReserve | kMemoryAllocationCommit,
kMemoryProtectRead | kMemoryProtectWrite, false, &address)) {
return false;
}
@@ -258,7 +258,7 @@ bool XThread::AllocateStack(uint32_t size) {
void XThread::FreeStack() {
if (stack_alloc_base_) {
auto heap = memory()->LookupHeap(0x40000000);
auto heap = memory()->LookupHeap(kStackAddressRangeBegin);
heap->Release(stack_alloc_base_);
stack_alloc_base_ = 0;
@@ -578,11 +578,15 @@ void XThread::Reenter(uint32_t address) {
}
void XThread::EnterCriticalRegion() {
xe::global_critical_region::mutex().lock();
guest_object<X_KTHREAD>()->apc_disable_count--;
}
void XThread::LeaveCriticalRegion() {
xe::global_critical_region::mutex().unlock();
auto kthread = guest_object<X_KTHREAD>();
auto apc_disable_count = ++kthread->apc_disable_count;
if (apc_disable_count == 0) {
CheckApcs();
}
}
uint32_t XThread::RaiseIrql(uint32_t new_irql) {
@@ -593,11 +597,11 @@ void XThread::LowerIrql(uint32_t new_irql) { irql_ = new_irql; }
void XThread::CheckApcs() { DeliverAPCs(); }
void XThread::LockApc() { EnterCriticalRegion(); }
void XThread::LockApc() { global_critical_region_.mutex().lock(); }
void XThread::UnlockApc(bool queue_delivery) {
bool needs_apc = apc_list_.HasPending();
LeaveCriticalRegion();
global_critical_region_.mutex().unlock();
if (needs_apc && queue_delivery) {
thread_->QueueUserCallback([this]() { DeliverAPCs(); });
}
@@ -632,7 +636,8 @@ void XThread::DeliverAPCs() {
// https://www.drdobbs.com/inside-nts-asynchronous-procedure-call/184416590?pgno=7
auto processor = kernel_state()->processor();
LockApc();
while (apc_list_.HasPending()) {
auto kthread = guest_object<X_KTHREAD>();
while (apc_list_.HasPending() && kthread->apc_disable_count == 0) {
// Get APC entry (offset for LIST_ENTRY offset) and cache what we need.
// Calling the routine may delete the memory/overwrite it.
uint32_t apc_ptr = apc_list_.Shift() - 8;
@@ -915,7 +920,7 @@ bool XThread::Save(ByteStream* stream) {
return false;
}
stream->Write('THRD');
stream->Write(kThreadSaveSignature);
stream->Write(thread_name_);
ThreadSavedState state;
@@ -971,7 +976,7 @@ object_ref<XThread> XThread::Restore(KernelState* kernel_state,
return nullptr;
}
if (stream->Read<uint32_t>() != 'THRD') {
if (stream->Read<uint32_t>() != kThreadSaveSignature) {
XELOGE("Could not restore XThread - invalid magic!");
return nullptr;
}

13
src/xenia/kernel/xthread.h
View File

@@ -25,6 +25,8 @@
namespace xe {
namespace kernel {
constexpr fourcc_t kThreadSaveSignature = make_fourcc("THRD");
class XEvent;
constexpr uint32_t X_CREATE_SUSPENDED = 0x00000001;
@@ -111,7 +113,9 @@ struct X_KTHREAD {
uint8_t unk_8B; // 0x8B
uint8_t unk_8C[0x10]; // 0x8C
xe::be<uint32_t> unk_9C; // 0x9C
uint8_t unk_A0[0x1C]; // 0xA0
uint8_t unk_A0[0x10]; // 0xA0
int32_t apc_disable_count; // 0xB0
uint8_t unk_B4[0x8]; // 0xB4
uint8_t suspend_count; // 0xBC
uint8_t unk_BD; // 0xBD
uint8_t unk_BE; // 0xBE
@@ -145,6 +149,9 @@ class XThread : public XObject, public cpu::Thread {
public:
static const XObject::Type kObjectType = XObject::Type::Thread;
static constexpr uint32_t kStackAddressRangeBegin = 0x70000000;
static constexpr uint32_t kStackAddressRangeEnd = 0x7F000000;
struct CreationParams {
uint32_t stack_size;
uint32_t xapi_thread_startup;
@@ -190,8 +197,8 @@ class XThread : public XObject, public cpu::Thread {
virtual void Reenter(uint32_t address);
static void EnterCriticalRegion();
static void LeaveCriticalRegion();
void EnterCriticalRegion();
void LeaveCriticalRegion();
uint32_t RaiseIrql(uint32_t new_irql);
void LowerIrql(uint32_t new_irql);