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

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