steam-frame/SpeedBreakerProject--speedbreaker
1
0 Fork 0
mirror of https://github.com/SpeedBreakerProject/speedbreaker.git synced 2026-10-17 20:01:22 +02:00
Code Issues Packages Projects Releases 7 Wiki Activity
Files
main
SpeedBreakerProject--speedb…/runtime/kernel/xam.cpp
T
SpeedBreaker ProjectandClaude Opus 5.5 a6ade41b9f SpeedBreaker v0.1.0 
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-08 13:25:54 +00:00

558 lines
18 KiB
C++
Raw Permalink Blame History

// Adapted from Unleashed Recompiled (https://github.com/hedge-dev/UnleashedRecomp),
// GPL-3.0-or-later. Modified for SpeedBreaker: silent stubs and the input (hid/SDL)
// exports are removed; input returns in Phase 6 on our own SDL3 layer.
#include <stdafx.h>
#include "xam.h"
#include "xdm.h"
#include <cpu/guest_thread.h>
#include <ranges>
#include <unordered_set>
#include "xxHashMap.h"
#include <user/paths.h>
#include "overlapped.h"
#include <kernel/function.h>
#include <fstream>
namespace
{
constexpr uint32_t XAM_ERROR_IO_PENDING = 0x3E5;
constexpr uint32_t XAM_ERROR_ALREADY_EXISTS = 0xB7;
constexpr uint32_t XAM_ERROR_FUNCTION_FAILED = 0x65B;
// Asynchronous XAM calls (Xenia's CompleteOverlappedImmediate): with an
// XOVERLAPPED the result goes there, its event is signalled, and the
// call itself returns ERROR_IO_PENDING.
uint32_t XamComplete(XXOVERLAPPED* overlapped, uint32_t result, uint32_t extended = 0, uint32_t length = 0)
{
if (!overlapped)
return result;
CompleteOverlapped(overlapped, result, extended, length);
return XAM_ERROR_IO_PENDING;
}
}
struct XamListener : KernelObject
{
uint32_t id{};
uint64_t areas{};
std::vector<std::tuple<uint32_t, uint32_t>> notifications;
XamListener(const XamListener&) = delete;
XamListener& operator=(const XamListener&) = delete;
XamListener();
~XamListener();
};
struct XamEnumeratorBase : KernelObject
{
virtual uint32_t Next(void* buffer)
{
return -1;
}
};
template<typename TIterator = std::vector<XHOSTCONTENT_DATA>::iterator>
struct XamEnumerator : XamEnumeratorBase
{
uint32_t fetch;
size_t size;
TIterator position;
TIterator begin;
TIterator end;
XamEnumerator() = default;
XamEnumerator(uint32_t fetch, size_t size, TIterator begin, TIterator end) : fetch(fetch), size(size), position(begin), begin(begin), end(end)
{
}
uint32_t Next(void* buffer) override
{
if (position == end)
{
return -1;
}
if (buffer == nullptr)
{
for (size_t i = 0; i < fetch; i++)
{
if (position == end)
{
return i == 0 ? -1 : i;
}
++position;
}
}
for (size_t i = 0; i < fetch; i++)
{
if (position == end)
{
return i == 0 ? -1 : i;
}
memcpy(buffer, &*position, size);
++position;
buffer = (void*)((size_t)buffer + size);
}
return fetch;
}
};
std::array<xxHashMap<XHOSTCONTENT_DATA>, 3> gContentRegistry{};
static void ScanSavedContent();
std::unordered_set<XamListener*> gListeners{};
// Listeners and their queues: guest threads, and the main thread (the
// runtime's settings menu announces itself as system UI).
std::mutex gListenersMutex;
xxHashMap<std::string> gRootMap;
std::string_view XamGetRootPath(const std::string_view& root)
{
const auto result = gRootMap.find(StringHash(root));
if (result == gRootMap.end())
return "";
return result->second;
}
void XamRootCreate(const std::string_view& root, const std::string_view& path)
{
gRootMap.emplace(StringHash(root), path);
}
XamListener::XamListener()
{
std::lock_guard lock(gListenersMutex);
gListeners.insert(this);
}
XamListener::~XamListener()
{
std::lock_guard lock(gListenersMutex);
gListeners.erase(this);
}
XCONTENT_DATA XamMakeContent(uint32_t type, const std::string_view& name)
{
XCONTENT_DATA data{ 1, type };
strncpy(data.szFileName, name.data(), sizeof(data.szFileName));
return data;
}
void XamRegisterContent(const XCONTENT_DATA& data, const std::string_view& root)
{
const auto idx = data.dwContentType - 1;
gContentRegistry[idx].emplace(StringHash(data.szFileName), XHOSTCONTENT_DATA{ data }).first->second.szRoot = root;
}
void XamRegisterContent(uint32_t type, const std::string_view name, const std::string_view& root)
{
XCONTENT_DATA data{ 1, type, {}, "" };
strncpy(data.szFileName, name.data(), sizeof(data.szFileName));
XamRegisterContent(data, root);
}
uint32_t XamNotifyCreateListener(uint64_t qwAreas)
{
auto* listener = CreateKernelObject<XamListener>();
listener->areas = qwAreas;
return GetKernelHandle(listener);
}
void XamNotifyEnqueueEvent(uint32_t dwId, uint32_t dwParam)
{
std::lock_guard lock(gListenersMutex);
for (const auto& listener : gListeners)
{
if (((1 << MSG_AREA(dwId)) & listener->areas) == 0)
continue;
listener->notifications.emplace_back(dwId, dwParam);
}
}
bool XNotifyGetNext(uint32_t hNotification, uint32_t dwMsgFilter, be<uint32_t>* pdwId, be<uint32_t>* pParam)
{
auto& listener = *GetKernelObject<XamListener>(hNotification);
std::lock_guard lock(gListenersMutex);
if (dwMsgFilter)
{
for (size_t i = 0; i < listener.notifications.size(); i++)
{
if (std::get<0>(listener.notifications[i]) == dwMsgFilter)
{
if (pdwId)
*pdwId = std::get<0>(listener.notifications[i]);
if (pParam)
*pParam = std::get<1>(listener.notifications[i]);
listener.notifications.erase(listener.notifications.begin() + i);
return true;
}
}
}
else
{
if (listener.notifications.empty())
return false;
if (pdwId)
*pdwId = std::get<0>(listener.notifications[0]);
if (pParam)
*pParam = std::get<1>(listener.notifications[0]);
listener.notifications.erase(listener.notifications.begin());
return true;
}
return false;
}
uint32_t XamShowMessageBoxUI(uint32_t dwUserIndex, be<uint16_t>* wszTitle, be<uint16_t>* wszText, uint32_t cButtons,
xpointer<be<uint16_t>>* pwszButtons, uint32_t dwFocusButton, uint32_t dwFlags, be<uint32_t>* pResult, XXOVERLAPPED* pOverlapped)
{
*pResult = cButtons ? cButtons - 1 : 0;
#if _DEBUG
assert("XamShowMessageBoxUI encountered!" && false);
#elif _WIN32
// This code is Win32-only as it'll most likely crash, misbehave or
// cause corruption due to using a different type of memory than what
// wchar_t is on Linux. Windows uses 2 bytes while Linux uses 4 bytes.
std::vector<std::wstring> texts{};
texts.emplace_back(reinterpret_cast<wchar_t*>(wszTitle));
texts.emplace_back(reinterpret_cast<wchar_t*>(wszText));
for (size_t i = 0; i < cButtons; i++)
texts.emplace_back(reinterpret_cast<wchar_t*>(pwszButtons[i].get()));
for (auto& text : texts)
{
for (size_t i = 0; i < text.size(); i++)
ByteSwapInplace(text[i]);
}
wprintf(L"[XamShowMessageBoxUI] !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
wprintf(L"[XamShowMessageBoxUI] If you are encountering this message and the game has ceased functioning,\n");
wprintf(L"[XamShowMessageBoxUI] please report it at https://github.com/SpeedBreakerProject/speedbreaker/issues.\n");
wprintf(L"[XamShowMessageBoxUI] !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
wprintf(L"[XamShowMessageBoxUI] %ls\n", texts[0].c_str());
wprintf(L"[XamShowMessageBoxUI] %ls\n", texts[1].c_str());
wprintf(L"[XamShowMessageBoxUI] ");
for (size_t i = 0; i < cButtons; i++)
{
wprintf(L"%ls", texts[2 + i].c_str());
if (i != cButtons - 1)
wprintf(L" | ");
}
wprintf(L"\n");
wprintf(L"[XamShowMessageBoxUI] Defaulted to button: %d\n", pResult->get());
wprintf(L"[XamShowMessageBoxUI] !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
#endif
XamNotifyEnqueueEvent(9, 0);
return XamComplete(pOverlapped, ERROR_SUCCESS);
}
uint32_t XamContentCreateEnumerator(uint32_t dwUserIndex, uint32_t DeviceID, uint32_t dwContentType,
uint32_t dwContentFlags, uint32_t cItem, be<uint32_t>* pcbBuffer, be<uint32_t>* phEnum)
{
if (dwUserIndex != 0)
{
GuestThread::SetLastError(ERROR_NO_SUCH_USER);
return 0xFFFFFFFF;
}
ScanSavedContent();
const auto& registry = gContentRegistry[dwContentType - 1];
const auto& values = registry | std::views::values;
auto* enumerator = CreateKernelObject<XamEnumerator<decltype(values.begin())>>(cItem, sizeof(_XCONTENT_DATA), values.begin(), values.end());
if (pcbBuffer)
*pcbBuffer = sizeof(_XCONTENT_DATA) * cItem;
*phEnum = GetKernelHandle(enumerator);
return 0;
}
uint32_t XamEnumerate(uint32_t hEnum, uint32_t dwFlags, void* pvBuffer, uint32_t cbBuffer, be<uint32_t>* pcItemsReturned, XXOVERLAPPED* pOverlapped)
{
auto* enumerator = GetKernelObject<XamEnumeratorBase>(hEnum);
const auto count = enumerator->Next(pvBuffer);
if (count == -1)
{
if (pcItemsReturned)
*pcItemsReturned = 0;
return pOverlapped ? XamComplete(pOverlapped, XAM_ERROR_FUNCTION_FAILED, 0x80070000 | ERROR_NO_MORE_FILES)
: ERROR_NO_MORE_FILES;
}
if (pcItemsReturned)
*pcItemsReturned = count;
return XamComplete(pOverlapped, ERROR_SUCCESS, 0, count);
}
// Content packages (saves) live in one directory each under the save path,
// with the package's XCONTENT_DATA beside it as <name>.xcontent so saves
// are found again (and enumerated with their display names) after a restart.
static std::filesystem::path ContentRoot(const XCONTENT_DATA& data)
{
if (data.dwContentType == XCONTENTTYPE_SAVEDATA)
{
std::string name(data.szFileName, strnlen(data.szFileName, sizeof(data.szFileName)));
for (char& c : name)
if (c == '/' || c == '\\' || c == ':' || (c == '.' && &c == &name[0]))
c = '_';
return GetSavePath(true) / name;
}
if (data.dwContentType == XCONTENTTYPE_DLC)
return GetGamePath() / "dlc";
return GetGamePath();
}
static void ScanSavedContent()
{
static bool scanned = false;
if (scanned)
return;
scanned = true;
std::error_code ec;
for (const auto& entry : std::filesystem::directory_iterator(GetSavePath(true), ec))
{
if (entry.path().extension() != ".xcontent")
continue;
XCONTENT_DATA data{};
std::ifstream f(entry.path(), std::ios::binary);
if (!f.read(reinterpret_cast<char*>(&data), sizeof(data)) || data.dwContentType != XCONTENTTYPE_SAVEDATA)
continue;
std::filesystem::path root = ContentRoot(data);
if (!std::filesystem::is_directory(root, ec))
continue;
XamRegisterContent(data, (const char*)root.u8string().c_str());
fprintf(stderr, "[xam] found save \"%.*s\"\n", int(strnlen(data.szFileName, sizeof(data.szFileName))), data.szFileName);
}
}
uint32_t XamContentCreateEx(uint32_t dwUserIndex, const char* szRootName, const XCONTENT_DATA* pContentData,
uint32_t dwContentFlags, be<uint32_t>* pdwDisposition, be<uint32_t>* pdwLicenseMask,
uint32_t dwFileCacheSize, uint64_t uliContentSize, PXXOVERLAPPED pOverlapped)
{
ScanSavedContent();
auto& registry = gContentRegistry[pContentData->dwContentType - 1];
const auto existing = registry.find(StringHash(pContentData->szFileName));
const bool exists = existing != registry.end();
const auto mode = dwContentFlags & 0xF; // CREATE_NEW 1, CREATE_ALWAYS 2, OPEN_EXISTING 3, OPEN_ALWAYS 4, TRUNCATE_EXISTING 5
if (pdwLicenseMask)
*pdwLicenseMask = 0xFFFFFFFF;
if (exists && mode == 1)
return XamComplete(pOverlapped, XAM_ERROR_ALREADY_EXISTS);
if (!exists && (mode == OPEN_EXISTING || mode == 5))
{
if (pdwDisposition)
*pdwDisposition = XCONTENT_NEW;
return XamComplete(pOverlapped, ERROR_PATH_NOT_FOUND);
}
if (mode < 1 || mode > 5)
return XamComplete(pOverlapped, ERROR_PATH_NOT_FOUND);
if (exists)
{
if (pdwDisposition)
*pdwDisposition = XCONTENT_EXISTING;
XamRootCreate(szRootName, existing->second.szRoot);
return XamComplete(pOverlapped, ERROR_SUCCESS);
}
std::filesystem::path root = ContentRoot(*pContentData);
std::error_code ec;
std::filesystem::create_directories(root, ec);
if (pContentData->dwContentType == XCONTENTTYPE_SAVEDATA)
{
std::filesystem::path meta = root;
meta += ".xcontent";
std::ofstream f(meta, std::ios::binary | std::ios::trunc);
f.write(reinterpret_cast<const char*>(pContentData), sizeof(XCONTENT_DATA));
}
const std::string rootString = (const char*)root.u8string().c_str();
XamRegisterContent(*pContentData, rootString);
XamRootCreate(szRootName, rootString);
if (pdwDisposition)
*pdwDisposition = XCONTENT_NEW;
return XamComplete(pOverlapped, ERROR_SUCCESS);
}
uint32_t XamContentClose(const char* szRootName, XXOVERLAPPED* pOverlapped)
{
gRootMap.erase(StringHash(szRootName));
return XamComplete(pOverlapped, ERROR_SUCCESS);
}
uint32_t XamContentGetDeviceData(uint32_t DeviceID, XDEVICE_DATA* pDeviceData)
{
pDeviceData->DeviceID = DeviceID;
pDeviceData->DeviceType = XCONTENTDEVICETYPE_HDD;
pDeviceData->ulDeviceBytes = 0x10000000;
pDeviceData->ulDeviceFreeBytes = 0x10000000;
const char* name = "Hard Drive";
for (size_t i = 0; i <= strlen(name); i++)
pDeviceData->wszName[i] = uint16_t(name[i]);
return 0;
}
// ---------------------------------------------------------------------------
// More content exports (SpeedBreaker; semantics from Xenia's xam_content.cc).
// The only device is the hard drive, id 1.
namespace
{
constexpr uint32_t XAM_ERROR_FILE_NOT_FOUND = 0x2;
constexpr uint32_t XAM_ERROR_INSUFFICIENT_BUFFER = 0x7A;
constexpr uint32_t XAM_ERROR_DEVICE_NOT_CONNECTED = 0x48F;
std::filesystem::path ThumbnailPath(const XCONTENT_DATA& data)
{
std::filesystem::path p = ContentRoot(data);
p += ".thumbnail.png";
return p;
}
}
uint32_t XamContentGetDeviceName(uint32_t deviceId, be<uint16_t>* name, uint32_t capacity)
{
if ((deviceId & 0xFFFF) != 1)
return XAM_ERROR_DEVICE_NOT_CONNECTED;
const char* text = "Hard Drive";
size_t n = strlen(text);
if (capacity < n + 1)
return XAM_ERROR_INSUFFICIENT_BUFFER;
for (size_t i = 0; i < n; i++)
name[i] = uint16_t(text[i]);
name[n] = 0;
return ERROR_SUCCESS;
}
uint32_t XamContentCreate(uint32_t userIndex, const char* rootName, const XCONTENT_DATA* data, uint32_t flags,
be<uint32_t>* disposition, be<uint32_t>* licenseMask, XXOVERLAPPED* overlapped)
{
return XamContentCreateEx(userIndex, rootName, data, flags, disposition, licenseMask, 0, 0, overlapped);
}
uint32_t XamContentDelete(uint32_t userIndex, const XCONTENT_DATA* data, XXOVERLAPPED* overlapped)
{
ScanSavedContent();
auto& registry = gContentRegistry[data->dwContentType - 1];
auto it = registry.find(StringHash(data->szFileName));
if (it == registry.end())
return XamComplete(overlapped, XAM_ERROR_FILE_NOT_FOUND);
std::error_code ec;
std::filesystem::path root = ContentRoot(*data);
if (data->dwContentType == XCONTENTTYPE_SAVEDATA)
{
std::filesystem::remove_all(root, ec);
std::filesystem::path meta = root;
meta += ".xcontent";
std::filesystem::remove(meta, ec);
std::filesystem::remove(ThumbnailPath(*data), ec);
}
registry.erase(it);
fprintf(stderr, "[xam] deleted content \"%.*s\"\n", int(strnlen(data->szFileName, sizeof(data->szFileName))), data->szFileName);
return XamComplete(overlapped, ERROR_SUCCESS);
}
uint32_t XamContentFlush(const char* rootName, XXOVERLAPPED* overlapped)
{
return XamComplete(overlapped, ERROR_SUCCESS);
}
uint32_t XamContentGetLicenseMask(be<uint32_t>* mask, XXOVERLAPPED* overlapped)
{
if (mask)
*mask = 0xFFFFFFFF;
return XamComplete(overlapped, ERROR_SUCCESS);
}
uint32_t XamContentGetThumbnail(uint32_t userIndex, const XCONTENT_DATA* data, uint8_t* buffer, be<uint32_t>* bufferSize,
XXOVERLAPPED* overlapped)
{
std::ifstream f(ThumbnailPath(*data), std::ios::binary | std::ios::ate);
if (!f)
return XamComplete(overlapped, XAM_ERROR_FILE_NOT_FOUND);
uint32_t size = uint32_t(f.tellg());
uint32_t capacity = bufferSize ? uint32_t(*bufferSize) : 0;
if (bufferSize)
*bufferSize = size;
if (!buffer || capacity < size)
return XamComplete(overlapped, buffer ? XAM_ERROR_INSUFFICIENT_BUFFER : ERROR_SUCCESS);
f.seekg(0);
f.read(reinterpret_cast<char*>(buffer), size);
return XamComplete(overlapped, ERROR_SUCCESS);
}
uint32_t XamContentSetThumbnail(uint32_t userIndex, const XCONTENT_DATA* data, const uint8_t* buffer, uint32_t size,
XXOVERLAPPED* overlapped)
{
std::ofstream f(ThumbnailPath(*data), std::ios::binary | std::ios::trunc);
f.write(reinterpret_cast<const char*>(buffer), size);
return XamComplete(overlapped, ERROR_SUCCESS);
}
// Voice: no headset, no voice objects (Xenia).
uint32_t XamVoiceHeadsetPresent(uint32_t voice) { return 0; }
uint32_t XamVoiceCreate(uint32_t unk1, uint32_t unk2, be<uint32_t>* out) { if (out) *out = 0; return 5; /* ERROR_ACCESS_DENIED */ }
uint32_t XamVoiceClose(uint32_t voice) { return 0; }
uint32_t XamVoiceSubmitPacket(uint32_t voice, uint32_t size, uint32_t data) { return 0; }
// Sign-in UI: user 0 is always signed in; show and close the "UI" at once.
uint32_t XamShowSigninUI(uint32_t paneCount, uint32_t flags)
{
XamNotifyEnqueueEvent(9, 1);
XamNotifyEnqueueEvent(9, 0);
return ERROR_SUCCESS;
}
GUEST_FUNCTION_HOOK(__imp__XamContentGetDeviceName, XamContentGetDeviceName);
GUEST_FUNCTION_HOOK(__imp__XamContentCreate, XamContentCreate);
GUEST_FUNCTION_HOOK(__imp__XamContentDelete, XamContentDelete);
GUEST_FUNCTION_HOOK(__imp__XamContentFlush, XamContentFlush);
GUEST_FUNCTION_HOOK(__imp__XamContentGetLicenseMask, XamContentGetLicenseMask);
GUEST_FUNCTION_HOOK(__imp__XamContentGetThumbnail, XamContentGetThumbnail);
GUEST_FUNCTION_HOOK(__imp__XamContentSetThumbnail, XamContentSetThumbnail);
GUEST_FUNCTION_HOOK(__imp__XamVoiceHeadsetPresent, XamVoiceHeadsetPresent);
GUEST_FUNCTION_HOOK(__imp__XamVoiceCreate, XamVoiceCreate);
GUEST_FUNCTION_HOOK(__imp__XamVoiceClose, XamVoiceClose);
GUEST_FUNCTION_HOOK(__imp__XamVoiceSubmitPacket, XamVoiceSubmitPacket);
GUEST_FUNCTION_HOOK(__imp__XamShowSigninUI, XamShowSigninUI);
Reference in new issue View Git Blame Copy Permalink