From 2589143798ddc30aaa6da6f29846670494adc016 Mon Sep 17 00:00:00 2001 From: DH Date: Fri, 10 Oct 2025 19:56:11 +0300 Subject: [PATCH] kernel: split context and allocator & initial implementation of process/thread local objects --- kernel/include/kernel/GlobalKernelObject.hpp | 139 ----------- kernel/include/kernel/KernelObject.hpp | 180 ++++++++++++++ kernel/orbis/CMakeLists.txt | 1 + .../include/orbis/GlobalKernelObject.hpp | 26 --- .../orbis/include/orbis/KernelAllocator.hpp | 12 +- kernel/orbis/include/orbis/KernelContext.hpp | 39 ++-- kernel/orbis/include/orbis/KernelObject.hpp | 108 +++++++++ kernel/orbis/include/orbis/evf.hpp | 2 +- kernel/orbis/include/orbis/file.hpp | 2 +- kernel/orbis/include/orbis/module/Module.hpp | 22 +- kernel/orbis/include/orbis/thread/Process.hpp | 6 +- kernel/orbis/src/KernelAllocator.cpp | 221 ++++++++++++++++++ kernel/orbis/src/KernelContext.cpp | 162 +------------ kernel/orbis/src/ipmi.cpp | 54 ++--- kernel/orbis/src/sys/sys_cpuset.cpp | 4 +- kernel/orbis/src/sys/sys_event.cpp | 6 +- kernel/orbis/src/sys/sys_exit.cpp | 4 +- kernel/orbis/src/sys/sys_sce.cpp | 36 +-- kernel/orbis/src/sys/sys_sig.cpp | 2 +- kernel/orbis/src/sys/sys_sysctl.cpp | 34 +-- kernel/orbis/src/umtx.cpp | 4 +- rpcsx/core/src/watchdog.cpp | 8 +- rpcsx/gpu/Device.cpp | 6 +- rpcsx/gpu/Pipe.cpp | 4 +- rpcsx/io-device.cpp | 4 +- rpcsx/iodev/blockpool.cpp | 4 +- rpcsx/iodev/dce.cpp | 22 +- rpcsx/iodev/dmem.cpp | 2 +- rpcsx/iodev/gc.cpp | 28 +-- rpcsx/iodev/hid.cpp | 10 +- rpcsx/ipmi.cpp | 48 ++-- rpcsx/main.cpp | 147 ++++++------ rpcsx/ops.cpp | 16 +- rpcsx/vm.cpp | 8 +- 34 files changed, 774 insertions(+), 597 deletions(-) delete mode 100644 kernel/include/kernel/GlobalKernelObject.hpp create mode 100644 kernel/include/kernel/KernelObject.hpp delete mode 100644 kernel/orbis/include/orbis/GlobalKernelObject.hpp create mode 100644 kernel/orbis/include/orbis/KernelObject.hpp create mode 100644 kernel/orbis/src/KernelAllocator.cpp diff --git a/kernel/include/kernel/GlobalKernelObject.hpp b/kernel/include/kernel/GlobalKernelObject.hpp deleted file mode 100644 index 506cfbd24..000000000 --- a/kernel/include/kernel/GlobalKernelObject.hpp +++ /dev/null @@ -1,139 +0,0 @@ -#pragma once - -#include "rx/LinkedNode.hpp" -#include "rx/Serializer.hpp" -#include - -namespace kernel { - -namespace detail { -struct GlobalObjectCtl { - void (*construct)(); - void (*destruct)(); - void (*serialize)(rx::Serializer &); - void (*deserialize)(rx::Deserializer &); -}; - -template struct GlobalKernelObjectInstance { - static inline T *instance = nullptr; - - static inline rx::LinkedNode ctl = { - .object = { - .construct = +[] { instance->construct(); }, - .destruct = +[] { instance->destruct(); }, - .serialize = +[](rx::Serializer &s) { instance->serialize(s); }, - .deserialize = +[](rx::Deserializer &s) { instance->deserialize(s); }, - }, - }; -}; -} // namespace detail - -template struct GlobalKernelObjectStorage { - template static void AddObject() { - auto node = &detail::GlobalKernelObjectInstance::ctl; - auto head = GetHead(); - if (head) { - head->prev = node; - node->next = head; - } - - *GetHeadPtr() = node; - } - - static void ConstructAll() { - for (auto it = GetHead(); it != nullptr; it = it->next) { - it->object.construct(); - } - } - - static void DestructAll() { - for (auto it = GetHead(); it != nullptr; it = it->next) { - it->object.destruct(); - } - } - - static void SerializeAll(rx::Serializer &s) { - for (auto it = GetHead(); it != nullptr; it = it->next) { - it->object.serialize(s); - } - } - - static void DeserializeAll(rx::Deserializer &s) { - for (auto it = GetHead(); it != nullptr; it = it->next) { - it->object.deserialize(s); - } - } - -private: - static rx::LinkedNode *GetHead() { - return *GetHeadPtr(); - } - - static rx::LinkedNode **GetHeadPtr() { - static rx::LinkedNode *registry; - return ®istry; - } -}; - -template - requires std::is_default_constructible_v -class GlobalKernelObject { - union U { - T object; - - U() {} - ~U() {} - }; - - U mHolder; - -public: - template GlobalKernelObject() { - auto &instance = - detail::GlobalKernelObjectInstance::instance; - assert(instance == nullptr); - instance = this; - GlobalKernelObjectStorage::template AddObject< - GlobalKernelObject>(); - } - - T *operator->() { return &mHolder.object; } - const T *operator->() const { return &mHolder.object; } - T &operator*() { return mHolder.object; } - const T &operator*() const { return mHolder.object; } - operator T &() { return mHolder.object; } - operator const T &() const { return mHolder.object; } - - void serialize(rx::Serializer &s) - requires rx::Serializable - { - s.serialize(mHolder.object); - } - - void deserialize(rx::Deserializer &s) - requires rx::Serializable - { - std::construct_at(&mHolder.object); - s.deserialize(mHolder.object); - } - - T &get() { return mHolder.object; } - const T &get() const { return mHolder.object; } - -private: - template - requires(std::is_constructible_v) - void construct(Args &&...args) noexcept( - std::is_nothrow_constructible_v) { - std::construct_at(&mHolder.object, std::forward(args)...); - } - - template - void destruct() noexcept(std::is_nothrow_destructible_v) { - mHolder.object.~T(); - } - - friend detail::GlobalKernelObjectInstance; -}; -} // namespace kernel diff --git a/kernel/include/kernel/KernelObject.hpp b/kernel/include/kernel/KernelObject.hpp new file mode 100644 index 000000000..5fe28f3ce --- /dev/null +++ b/kernel/include/kernel/KernelObject.hpp @@ -0,0 +1,180 @@ +#pragma once + +#include "rx/Rc.hpp" +#include "rx/Serializer.hpp" +#include "rx/TypeId.hpp" +#include +#include + +namespace kernel { +class KernelObjectBase : public rx::RcBase { + rx::TypeId mType; + +public: + KernelObjectBase(rx::TypeId type) : mType(type) {} + [[nodiscard]] rx::TypeId getType() const { return mType; } + + template [[nodiscard]] bool isa() const { + return mType == rx::TypeId::get(); + } +}; + +template +struct KernelObject : KernelObjectBase, StateT { + template + KernelObject(Args &&...args) + : KernelObjectBase(rx::TypeId::get()), + StateT(std::forward(args)...) {} + + virtual void serialize(rx::Serializer &s) const { + if constexpr (requires(const KernelObject &instance) { + instance.lock(); + instance.unlock(); + }) { + std::lock_guard lock(*this); + s.serialize(static_cast(*this)); + } else { + s.serialize(static_cast(*this)); + } + } + + virtual void deserialize(rx::Deserializer &s) { + s.deserialize(static_cast(*this)); + } +}; + +namespace detail { +struct StaticObjectCtl { + std::size_t offset = -1ull; + void (*construct)(void *object); + void (*destruct)(void *object); + void (*serialize)(void *object, rx::Serializer &); + void (*deserialize)(void *object, rx::Deserializer &); + + template constexpr static StaticObjectCtl Create() { + return { + .construct = + +[](void *object) { + std::construct_at(reinterpret_cast(object)); + }, + .destruct = +[](void *object) { reinterpret_cast(object)->~T(); }, + .serialize = + +[](void *object, rx::Serializer &serializer) { + serializer.serialize(*reinterpret_cast(object)); + }, + .deserialize = + +[](void *object, rx::Deserializer &deserializer) { + deserializer.deserialize(*reinterpret_cast(object)); + }, + }; + } +}; + +struct GlobalScope; +struct ProcessScope; +struct ThreadScope; +} // namespace detail + +template std::byte *getScopeStorage(); + +template +struct StaticKernelObjectStorage { + template static std::uint32_t Allocate() { + auto &instance = GetInstance(); + + auto object = detail::StaticObjectCtl::Create(); + instance.m_registry.push_back(object); + + auto offset = instance.m_size; + offset = rx::alignUp(offset, alignof(T)); + instance.m_registry.back().offset = offset; + instance.m_size = offset + sizeof(T); + instance.m_alignment = + std::max(alignof(T), instance.m_alignment); + // std::printf( + // "%s::Allocate(%s, %zu, %zu) -> %zu\n", + // rx::TypeId::get>().getName().data(), rx::TypeId::get().getName().data(), + // sizeof(T), alignof(T), offset); + return offset; + } + + static std::size_t GetSize() { return GetInstance().m_size; } + static std::size_t GetAlignment() { return GetInstance().m_alignment; } + static std::byte *getScopeStorage() { + return kernel::getScopeStorage(); + } + + static void ConstructAll() { + auto &instance = GetInstance(); + auto storage = getScopeStorage(); + + for (auto objectCtl : instance.m_registry) { + objectCtl.construct(storage + objectCtl.offset); + } + } + + static void DestructAll() { + auto &instance = GetInstance(); + auto storage = getScopeStorage(); + + for (auto objectCtl : instance.m_registry) { + objectCtl.destruct(storage + objectCtl.offset); + } + } + + static void SerializeAll(rx::Serializer &s) { + auto &instance = GetInstance(); + auto storage = getScopeStorage(); + + s.serialize(instance.m_size); + s.serialize(instance.m_registry.size()); + + for (auto objectCtl : instance.m_registry) { + objectCtl.serialize(storage + objectCtl.offset, s); + } + } + + static void DeserializeAll(rx::Deserializer &s) { + auto &instance = GetInstance(); + auto storage = getScopeStorage(); + + auto size = s.deserialize(); + auto registrySize = s.deserialize(); + + if (size != instance.m_size || registrySize != instance.m_registry.size()) { + s.setFailure(); + return; + } + + for (auto objectCtl : instance.m_registry) { + objectCtl.deserialize(storage + objectCtl.offset, s); + } + } + +private: + static StaticKernelObjectStorage &GetInstance() { + static StaticKernelObjectStorage instance; + return instance; + } + + std::vector m_registry; + std::size_t m_size = 0; + std::size_t m_alignment = 1; +}; + +template +class StaticObjectRef { + std::uint32_t mOffset; + +public: + explicit StaticObjectRef(std::uint32_t offset) : mOffset(offset) {} + + T *get() { + return reinterpret_cast(getScopeStorage() + + mOffset); + } + + T *operator->() { return get(); } +}; +} // namespace kernel diff --git a/kernel/orbis/CMakeLists.txt b/kernel/orbis/CMakeLists.txt index 003b91709..a4c92210a 100644 --- a/kernel/orbis/CMakeLists.txt +++ b/kernel/orbis/CMakeLists.txt @@ -7,6 +7,7 @@ add_library(obj.orbis-kernel OBJECT src/event.cpp src/evf.cpp src/ipmi.cpp + src/KernelAllocator.cpp src/KernelContext.cpp src/umtx.cpp src/sys/sys_acct.cpp diff --git a/kernel/orbis/include/orbis/GlobalKernelObject.hpp b/kernel/orbis/include/orbis/GlobalKernelObject.hpp deleted file mode 100644 index 755b55d41..000000000 --- a/kernel/orbis/include/orbis/GlobalKernelObject.hpp +++ /dev/null @@ -1,26 +0,0 @@ -#pragma once -#include - -namespace orbis { -struct OrbisNamespace; - -template -using GlobalKernelObject = kernel::GlobalKernelObject; - -template GlobalKernelObject createGlobalObject() { - return {}; -} - -inline void constructAllGlobals() { - kernel::GlobalKernelObjectStorage::ConstructAll(); -} -inline void destructAllGlobals() { - kernel::GlobalKernelObjectStorage::DestructAll(); -} - -template T &getGlobalObject() { - assert(detail::GlobalKernelObjectInstance>::instance); - return kernel::detail::GlobalKernelObjectInstance< - OrbisNamespace, GlobalKernelObject>::instance->get(); -} -} // namespace orbis diff --git a/kernel/orbis/include/orbis/KernelAllocator.hpp b/kernel/orbis/include/orbis/KernelAllocator.hpp index b8b8012f7..49e7a08a3 100644 --- a/kernel/orbis/include/orbis/KernelAllocator.hpp +++ b/kernel/orbis/include/orbis/KernelAllocator.hpp @@ -10,7 +10,6 @@ #include namespace orbis { -inline namespace utils { void *kalloc(std::size_t size, std::size_t align); void kfree(void *ptr, std::size_t size); template struct kallocator { @@ -51,7 +50,6 @@ template , typename Pred = std::equal_to> using kunmap = std::unordered_map>>; -} // namespace utils template requires(std::is_constructible_v) @@ -61,17 +59,17 @@ T *knew(Args &&...args) { struct DynamicObject final : T { using T::T; - void operator delete(void *pointer) { utils::kfree(pointer, sizeof(T)); } + void operator delete(void *pointer) { kfree(pointer, sizeof(T)); } }; auto loc = static_cast( - utils::kalloc(sizeof(DynamicObject), alignof(DynamicObject))); + kalloc(sizeof(DynamicObject), alignof(DynamicObject))); return std::construct_at(loc, std::forward(args)...); } else { static_assert(!std::is_polymorphic_v, "Polymorphic type should be derived from rx::RcBase"); - auto loc = static_cast(utils::kalloc(sizeof(T), alignof(T))); + auto loc = static_cast(kalloc(sizeof(T), alignof(T))); return std::construct_at(loc, std::forward(args)...); } } @@ -80,8 +78,10 @@ T *knew(Args &&...args) { template void kdelete(T *ptr) { static_assert(std::is_final_v, "Uncertain type size"); ptr->~T(); - utils::kfree(ptr, sizeof(T)); + kfree(ptr, sizeof(T)); } // clang-format on +void initializeAllocator(); +void deinitializeAllocator(); } // namespace orbis diff --git a/kernel/orbis/include/orbis/KernelContext.hpp b/kernel/orbis/include/orbis/KernelContext.hpp index 7f59c1bf4..7d6312c55 100644 --- a/kernel/orbis/include/orbis/KernelContext.hpp +++ b/kernel/orbis/include/orbis/KernelContext.hpp @@ -1,7 +1,7 @@ #pragma once #include "AppInfo.hpp" #include "Budget.hpp" -#include "KernelAllocator.hpp" +#include "KernelObject.hpp" #include "evf.hpp" #include "ipmi.hpp" #include "orbis/note.hpp" @@ -50,12 +50,7 @@ public: long getTscFreq(); - void *kalloc(std::size_t size, - std::size_t align = __STDCPP_DEFAULT_NEW_ALIGNMENT__); - void kfree(void *ptr, std::size_t size); - - std::pair createEventFlag(utils::kstring name, - std::int32_t flags, + std::pair createEventFlag(kstring name, std::int32_t flags, std::uint64_t initPattern) { std::lock_guard lock(m_evf_mtx); @@ -78,7 +73,7 @@ public: return {}; } - std::pair createSemaphore(utils::kstring name, + std::pair createSemaphore(kstring name, std::uint32_t attrs, std::int32_t initCount, std::int32_t maxCount) { @@ -100,8 +95,7 @@ public: return {}; } - std::pair, ErrorCode> - createIpmiServer(utils::kstring name) { + std::pair, ErrorCode> createIpmiServer(kstring name) { std::lock_guard lock(m_sem_mtx); auto [it, inserted] = mIpmiServers.try_emplace(std::move(name), nullptr); @@ -128,15 +122,14 @@ public: return {}; } - std::tuple &, - std::unique_lock> + std::tuple &, std::unique_lock> getKernelEnv() { std::unique_lock lock(m_kenv_mtx); return {m_kenv, std::move(lock)}; } void setKernelEnv(std::string_view key, std::string_view value) { - auto &kenvValue = m_kenv[utils::kstring(key)]; + auto &kenvValue = m_kenv[kstring(key)]; auto len = std::min(sizeof(kenvValue) - 1, value.size()); std::memcpy(kenvValue, value.data(), len); kenvValue[len] = '0'; @@ -177,14 +170,10 @@ public: return processTypeBudgets[static_cast(processType)]; } + void serialize(rx::Serializer &) const {} + void deserialize(rx::Deserializer &) {} + private: - rx::shared_mutex m_heap_mtx; - rx::shared_mutex m_heap_map_mtx; - void *m_heap_next = this + 1; - - utils::kmultimap m_free_heap; - utils::kmultimap m_used_node; - std::atomic m_tsc_freq{0}; rx::shared_mutex m_thread_id_mtx; @@ -193,17 +182,17 @@ private: rx::LinkedNode *m_processes = nullptr; rx::shared_mutex m_evf_mtx; - utils::kmap> m_event_flags; + kmap> m_event_flags; rx::shared_mutex m_sem_mtx; - utils::kmap> m_semaphores; + kmap> m_semaphores; rx::shared_mutex mIpmiServerMtx; - utils::kmap> mIpmiServers; + kmap> mIpmiServers; rx::shared_mutex m_kenv_mtx; - utils::kmap m_kenv; // max size: 127 + '\0' + kmap m_kenv; // max size: 127 + '\0' }; -extern KernelContext &g_context; +extern GlobalObjectRef g_context; } // namespace orbis diff --git a/kernel/orbis/include/orbis/KernelObject.hpp b/kernel/orbis/include/orbis/KernelObject.hpp new file mode 100644 index 000000000..cdd6714f2 --- /dev/null +++ b/kernel/orbis/include/orbis/KernelObject.hpp @@ -0,0 +1,108 @@ +#pragma once +#include + +namespace orbis { +struct OrbisNamespace; + +template +using GlobalObjectRef = + kernel::StaticObjectRef; + +template +using ProcessLocalObjectRef = + kernel::StaticObjectRef; + +template +using ThreadLocalObjectRef = + kernel::StaticObjectRef; + +template +GlobalObjectRef createGlobalObject() { + auto layoutOffset = kernel::StaticKernelObjectStorage< + OrbisNamespace, kernel::detail::GlobalScope>::template Allocate(); + + return GlobalObjectRef(layoutOffset); +} + +template +kernel::StaticObjectRef +createProcessLocalObject() { + auto layoutOffset = kernel::StaticKernelObjectStorage< + OrbisNamespace, + kernel::detail::ProcessScope>::template Allocate(); + return kernel::StaticObjectRef(layoutOffset); +} + +template +kernel::StaticObjectRef +createThreadLocalObject() { + auto layoutOffset = kernel::StaticKernelObjectStorage< + OrbisNamespace, kernel::detail::ThreadScope>::template Allocate(); + return kernel::StaticObjectRef(layoutOffset); +} + +inline void constructAllGlobals() { + kernel::StaticKernelObjectStorage< + OrbisNamespace, kernel::detail::GlobalScope>::ConstructAll(); +} + +inline void constructAllProcessLocals() { + kernel::StaticKernelObjectStorage< + OrbisNamespace, kernel::detail::ProcessScope>::ConstructAll(); +} + +inline void constructAllThreadLocals() { + kernel::StaticKernelObjectStorage< + OrbisNamespace, kernel::detail::ThreadScope>::ConstructAll(); +} + +inline void destructAllGlobals() { + kernel::StaticKernelObjectStorage::DestructAll(); +} + +inline void destructAllProcessLocals() { + kernel::StaticKernelObjectStorage< + OrbisNamespace, kernel::detail::ProcessScope>::DestructAll(); +} + +inline void destructAllThreadLocals() { + kernel::StaticKernelObjectStorage::DestructAll(); +} + +inline void serializeAllGlobals(rx::Serializer &s) { + kernel::StaticKernelObjectStorage< + OrbisNamespace, kernel::detail::GlobalScope>::SerializeAll(s); +} + +inline void serializeAllProcessLocals(rx::Serializer &s) { + kernel::StaticKernelObjectStorage< + OrbisNamespace, kernel::detail::ProcessScope>::SerializeAll(s); +} + +inline void serializeAllThreadLocals(rx::Serializer &s) { + kernel::StaticKernelObjectStorage< + OrbisNamespace, kernel::detail::ThreadScope>::SerializeAll(s); +} + +inline void deserializeAllGlobals(rx::Deserializer &s) { + kernel::StaticKernelObjectStorage< + OrbisNamespace, kernel::detail::GlobalScope>::DeserializeAll(s); +} + +inline void deserializeAllProcessLocals(rx::Deserializer &s) { + kernel::StaticKernelObjectStorage< + OrbisNamespace, kernel::detail::ProcessScope>::DeserializeAll(s); +} + +inline void deserializeAllThreadLocals(rx::Deserializer &s) { + kernel::StaticKernelObjectStorage< + OrbisNamespace, kernel::detail::ThreadScope>::DeserializeAll(s); +} +} // namespace orbis diff --git a/kernel/orbis/include/orbis/evf.hpp b/kernel/orbis/include/orbis/evf.hpp index b9536a173..781f4ef3b 100644 --- a/kernel/orbis/include/orbis/evf.hpp +++ b/kernel/orbis/include/orbis/evf.hpp @@ -57,7 +57,7 @@ struct EventFlag final { }; rx::shared_mutex queueMtx; - utils::kvector waitingThreads; + kvector waitingThreads; enum class NotifyType { Set, Cancel, Destroy }; diff --git a/kernel/orbis/include/orbis/file.hpp b/kernel/orbis/include/orbis/file.hpp index 2b89c03fb..26cf5bf64 100644 --- a/kernel/orbis/include/orbis/file.hpp +++ b/kernel/orbis/include/orbis/file.hpp @@ -82,7 +82,7 @@ struct File : rx::RcBase { int flags = 0; int mode = 0; int hostFd = -1; - utils::kvector dirEntries; + kvector dirEntries; bool noBlock() const { return (flags & 4) != 0; } }; diff --git a/kernel/orbis/include/orbis/module/Module.hpp b/kernel/orbis/include/orbis/module/Module.hpp index b1f30f84b..4b17537a3 100644 --- a/kernel/orbis/include/orbis/module/Module.hpp +++ b/kernel/orbis/include/orbis/module/Module.hpp @@ -21,7 +21,7 @@ enum class DynType : std::uint8_t { }; struct ModuleNeeded { - utils::kstring name; + kstring name; std::uint16_t version; std::uint64_t attr; bool isExport; @@ -67,7 +67,7 @@ struct Relocation { struct Module final { Process *proc{}; - utils::kstring vfsPath; + kstring vfsPath; char moduleName[256]{}; char soName[256]{}; ModuleHandle id{}; @@ -110,15 +110,15 @@ struct Module final { bool isTlsDone = false; - utils::kstring interp; - utils::kvector symbols; - utils::kvector pltRelocations; - utils::kvector nonPltRelocations; - utils::kvector neededModules; - utils::kvector neededLibraries; - utils::kvector> importedModules; - utils::kvector> namespaceModules; - utils::kvector needed; + kstring interp; + kvector symbols; + kvector pltRelocations; + kvector nonPltRelocations; + kvector neededModules; + kvector neededLibraries; + kvector> importedModules; + kvector> namespaceModules; + kvector needed; std::atomic references{0}; diff --git a/kernel/orbis/include/orbis/thread/Process.hpp b/kernel/orbis/include/orbis/thread/Process.hpp index ac9c296db..ed3c0e36e 100644 --- a/kernel/orbis/include/orbis/thread/Process.hpp +++ b/kernel/orbis/include/orbis/thread/Process.hpp @@ -93,13 +93,13 @@ struct Process final { // Named objects for debugging rx::shared_mutex namedObjMutex; - utils::kmap namedObjNames; + kmap namedObjNames; rx::OwningIdMap namedObjIds; - utils::kmap sigActions; + kmap sigActions; // Named memory ranges for debugging rx::shared_mutex namedMemMutex; - utils::kmap namedMem; + kmap namedMem; }; } // namespace orbis diff --git a/kernel/orbis/src/KernelAllocator.cpp b/kernel/orbis/src/KernelAllocator.cpp new file mode 100644 index 000000000..1e46dea86 --- /dev/null +++ b/kernel/orbis/src/KernelAllocator.cpp @@ -0,0 +1,221 @@ +#include "KernelAllocator.hpp" +#include "KernelObject.hpp" +#include "rx/Serializer.hpp" +#include "rx/SharedMutex.hpp" +#include "rx/print.hpp" +#include + +static const std::uint64_t g_allocProtWord = 0xDEADBEAFBADCAFE1; +static constexpr std::uintptr_t kHeapBaseAddress = 0x00000600'0000'0000; +static constexpr auto kHeapSize = 0x1'0000'0000; +static constexpr int kDebugHeap = 0; + +namespace orbis { +struct KernelMemoryResource { + mutable rx::shared_mutex m_heap_mtx; + rx::shared_mutex m_heap_map_mtx; + void *m_heap_next = nullptr; + + kmultimap m_free_heap; + kmultimap m_used_node; + + ~KernelMemoryResource() { + ::munmap(std::bit_cast(kHeapBaseAddress), kHeapSize); + } + + void *kalloc(std::size_t size, + std::size_t align = __STDCPP_DEFAULT_NEW_ALIGNMENT__); + void kfree(void *ptr, std::size_t size); + + void serialize(rx::Serializer &) const { + // FIXME: implement + } + void deserialize(rx::Deserializer &) { + // FIXME: implement + } + + void lock() const { m_heap_mtx.lock(); } + void unlock() const { m_heap_mtx.unlock(); } +}; + +static KernelMemoryResource *sMemoryResource; +static std::byte *sGlobalStorage; +using GlobalStorage = + kernel::StaticKernelObjectStorage; + +void initializeAllocator() { + auto ptr = (std::byte *)::mmap(std::bit_cast(kHeapBaseAddress), + kHeapSize, PROT_READ | PROT_WRITE, + MAP_SHARED | MAP_ANONYMOUS | MAP_FIXED, -1, 0); + + if (ptr == MAP_FAILED) { + perror("mmap failed"); + FILE *maps = std::fopen("/proc/self/maps", "r"); + char *line = nullptr; + std::size_t size = 0; + while (getline(&line, &size, maps) > 0) { + std::puts(line); + } + + std::free(line); + std::fclose(maps); + std::abort(); + } + + sMemoryResource = new (ptr) KernelMemoryResource(); + sMemoryResource->m_heap_next = ptr + sizeof(KernelMemoryResource); + + rx::print(stderr, "global: size {}, alignment {}\n", GlobalStorage::GetSize(), + GlobalStorage::GetAlignment()); + // allocate whole global storage + sGlobalStorage = (std::byte *)sMemoryResource->kalloc( + GlobalStorage::GetSize(), GlobalStorage::GetAlignment()); +} + +void deinitializeAllocator() { + sMemoryResource->kfree(sGlobalStorage, GlobalStorage::GetSize()); + delete sMemoryResource; + sMemoryResource = nullptr; + sGlobalStorage = nullptr; +} + +void *KernelMemoryResource::kalloc(std::size_t size, std::size_t align) { + size = (size + (__STDCPP_DEFAULT_NEW_ALIGNMENT__ - 1)) & + ~(__STDCPP_DEFAULT_NEW_ALIGNMENT__ - 1); + if (!size) + std::abort(); + + if (m_heap_map_mtx.try_lock()) { + std::lock_guard lock(m_heap_map_mtx, std::adopt_lock); + + // Try to reuse previously freed block + for (auto [it, end] = m_free_heap.equal_range(size); it != end; ++it) { + auto result = it->second; + if (!(std::bit_cast(result) & (align - 1))) { + auto node = m_free_heap.extract(it); + node.key() = 0; + node.mapped() = nullptr; + m_used_node.insert(m_used_node.begin(), std::move(node)); + + // std::fprintf(stderr, "kalloc: reuse %p-%p, size = %lx\n", result, + // (char *)result + size, size); + + if (kDebugHeap > 0) { + std::memcpy(std::bit_cast(result) + size, + &g_allocProtWord, sizeof(g_allocProtWord)); + } + return result; + } + } + } + + std::lock_guard lock(m_heap_mtx); + align = std::max(align, __STDCPP_DEFAULT_NEW_ALIGNMENT__); + auto heap = reinterpret_cast(m_heap_next); + heap = (heap + (align - 1)) & ~(align - 1); + + if (kDebugHeap > 1) { + if (auto diff = (heap + size + sizeof(g_allocProtWord)) % 4096; diff != 0) { + heap += 4096 - diff; + heap &= ~(align - 1); + } + } + + if (heap + size > kHeapBaseAddress + kHeapSize) { + std::fprintf(stderr, "out of kernel memory"); + std::abort(); + } + // Check overflow + if (heap + size < heap) { + std::fprintf(stderr, "too big allocation"); + std::abort(); + } + + // std::fprintf(stderr, "kalloc: allocate %lx-%lx, size = %lx, align=%lx\n", + // heap, heap + size, size, align); + + auto result = reinterpret_cast(heap); + if (kDebugHeap > 0) { + std::memcpy(std::bit_cast(result) + size, &g_allocProtWord, + sizeof(g_allocProtWord)); + } + + if (kDebugHeap > 0) { + m_heap_next = + reinterpret_cast(heap + size + sizeof(g_allocProtWord)); + } else { + m_heap_next = reinterpret_cast(heap + size); + } + + if (kDebugHeap > 1) { + heap = reinterpret_cast(m_heap_next); + align = std::min(align, 4096); + heap = (heap + (align - 1)) & ~(align - 1); + size = 4096; + // std::fprintf(stderr, "kalloc: protect %lx-%lx, size = %lx, align=%lx\n", + // heap, heap + size, size, align); + + auto result = ::mmap(reinterpret_cast(heap), size, PROT_NONE, + MAP_FIXED | MAP_ANONYMOUS | MAP_SHARED, -1, 0); + if (result == MAP_FAILED) { + std::fprintf(stderr, "failed to protect memory"); + std::abort(); + } + m_heap_next = reinterpret_cast(heap + size); + } + + return result; +} + +void KernelMemoryResource::kfree(void *ptr, std::size_t size) { + size = (size + (__STDCPP_DEFAULT_NEW_ALIGNMENT__ - 1)) & + ~(__STDCPP_DEFAULT_NEW_ALIGNMENT__ - 1); + if (!size) + std::abort(); + + if (std::bit_cast(ptr) < kHeapBaseAddress || + std::bit_cast(ptr) + size > + kHeapBaseAddress + kHeapSize) { + std::fprintf(stderr, "kfree: invalid address"); + std::abort(); + } + + if (kDebugHeap > 0) { + if (std::memcmp(std::bit_cast(ptr) + size, &g_allocProtWord, + sizeof(g_allocProtWord)) != 0) { + std::fprintf(stderr, "kernel heap corruption\n"); + std::abort(); + } + + std::memset(ptr, 0xcc, size + sizeof(g_allocProtWord)); + } + + // std::fprintf(stderr, "kfree: release %p-%p, size = %lx\n", ptr, + // (char *)ptr + size, size); + + std::lock_guard lock(m_heap_map_mtx); + if (!m_used_node.empty()) { + auto node = m_used_node.extract(m_used_node.begin()); + node.key() = size; + node.mapped() = ptr; + m_free_heap.insert(std::move(node)); + } else { + m_free_heap.emplace(size, ptr); + } +} + +void kfree(void *ptr, std::size_t size) { + return sMemoryResource->kfree(ptr, size); +} + +void *kalloc(std::size_t size, std::size_t align) { + return sMemoryResource->kalloc(size, align); +} +} // namespace orbis + +template <> +std::byte * +kernel::getScopeStorage() { + return orbis::sGlobalStorage; +} diff --git a/kernel/orbis/src/KernelContext.cpp b/kernel/orbis/src/KernelContext.cpp index bd1d28687..8e3ddd98b 100644 --- a/kernel/orbis/src/KernelContext.cpp +++ b/kernel/orbis/src/KernelContext.cpp @@ -1,4 +1,5 @@ #include "orbis/KernelContext.hpp" +#include "KernelObject.hpp" #include "orbis/thread/Process.hpp" #include "orbis/thread/ProcessOps.hpp" #include "orbis/utils/Logs.hpp" @@ -13,37 +14,10 @@ #include #include -static const std::uint64_t g_allocProtWord = 0xDEADBEAFBADCAFE1; -static constexpr std::uintptr_t kHeapBaseAddress = 0x00000600'0000'0000; -static constexpr auto kHeapSize = 0x1'0000'0000; -static constexpr int kDebugHeap = 0; - namespace orbis { +GlobalObjectRef g_context = createGlobalObject(); thread_local Thread *g_currentThread; -KernelContext &g_context = *[]() -> KernelContext * { - // Allocate global shared kernel memory - // TODO: randomize for hardening and reduce size - auto ptr = mmap(std::bit_cast(kHeapBaseAddress), kHeapSize, - PROT_READ | PROT_WRITE, - MAP_SHARED | MAP_ANONYMOUS | MAP_FIXED, -1, 0); - if (ptr == MAP_FAILED) { - perror("mmap failed"); - FILE *maps = fopen("/proc/self/maps", "r"); - char *line = nullptr; - std::size_t size = 0; - while (getline(&line, &size, maps) > 0) { - std::printf("%s", line); - } - - free(line); - fclose(maps); - std::abort(); - } - - return new (ptr) KernelContext; -}(); - KernelContext::KernelContext() { // std::printf("orbis::KernelContext initialized, addr=%p\n", this); // std::printf("TSC frequency: %lu\n", getTscFreq()); @@ -158,138 +132,6 @@ long KernelContext::getTscFreq() { return m_tsc_freq.load(); } -void *KernelContext::kalloc(std::size_t size, std::size_t align) { - size = (size + (__STDCPP_DEFAULT_NEW_ALIGNMENT__ - 1)) & - ~(__STDCPP_DEFAULT_NEW_ALIGNMENT__ - 1); - if (!size) - std::abort(); - - if (m_heap_map_mtx.try_lock()) { - std::lock_guard lock(m_heap_map_mtx, std::adopt_lock); - - // Try to reuse previously freed block - for (auto [it, end] = m_free_heap.equal_range(size); it != end; ++it) { - auto result = it->second; - if (!(std::bit_cast(result) & (align - 1))) { - auto node = m_free_heap.extract(it); - node.key() = 0; - node.mapped() = nullptr; - m_used_node.insert(m_used_node.begin(), std::move(node)); - - // std::fprintf(stderr, "kalloc: reuse %p-%p, size = %lx\n", result, - // (char *)result + size, size); - - if (kDebugHeap > 0) { - std::memcpy(std::bit_cast(result) + size, - &g_allocProtWord, sizeof(g_allocProtWord)); - } - return result; - } - } - } - - std::lock_guard lock(m_heap_mtx); - align = std::max(align, __STDCPP_DEFAULT_NEW_ALIGNMENT__); - auto heap = reinterpret_cast(m_heap_next); - heap = (heap + (align - 1)) & ~(align - 1); - - if (kDebugHeap > 1) { - if (auto diff = (heap + size + sizeof(g_allocProtWord)) % 4096; diff != 0) { - heap += 4096 - diff; - heap &= ~(align - 1); - } - } - - if (heap + size > kHeapBaseAddress + kHeapSize) { - std::fprintf(stderr, "out of kernel memory"); - std::abort(); - } - // Check overflow - if (heap + size < heap) { - std::fprintf(stderr, "too big allocation"); - std::abort(); - } - - // std::fprintf(stderr, "kalloc: allocate %lx-%lx, size = %lx, align=%lx\n", - // heap, heap + size, size, align); - - auto result = reinterpret_cast(heap); - if (kDebugHeap > 0) { - std::memcpy(std::bit_cast(result) + size, &g_allocProtWord, - sizeof(g_allocProtWord)); - } - - if (kDebugHeap > 0) { - m_heap_next = - reinterpret_cast(heap + size + sizeof(g_allocProtWord)); - } else { - m_heap_next = reinterpret_cast(heap + size); - } - - if (kDebugHeap > 1) { - heap = reinterpret_cast(m_heap_next); - align = std::min(align, 4096); - heap = (heap + (align - 1)) & ~(align - 1); - size = 4096; - // std::fprintf(stderr, "kalloc: protect %lx-%lx, size = %lx, align=%lx\n", - // heap, heap + size, size, align); - - auto result = ::mmap(reinterpret_cast(heap), size, PROT_NONE, - MAP_FIXED | MAP_ANONYMOUS | MAP_SHARED, -1, 0); - if (result == MAP_FAILED) { - std::fprintf(stderr, "failed to protect memory"); - std::abort(); - } - m_heap_next = reinterpret_cast(heap + size); - } - - return result; -} - -void KernelContext::kfree(void *ptr, std::size_t size) { - size = (size + (__STDCPP_DEFAULT_NEW_ALIGNMENT__ - 1)) & - ~(__STDCPP_DEFAULT_NEW_ALIGNMENT__ - 1); - if (!size) - std::abort(); - - if (std::bit_cast(ptr) < kHeapBaseAddress || - std::bit_cast(ptr) + size > - kHeapBaseAddress + kHeapSize) { - std::fprintf(stderr, "kfree: invalid address"); - std::abort(); - } - - if (kDebugHeap > 0) { - if (std::memcmp(std::bit_cast(ptr) + size, &g_allocProtWord, - sizeof(g_allocProtWord)) != 0) { - std::fprintf(stderr, "kernel heap corruption\n"); - std::abort(); - } - - std::memset(ptr, 0xcc, size + sizeof(g_allocProtWord)); - } - - // std::fprintf(stderr, "kfree: release %p-%p, size = %lx\n", ptr, - // (char *)ptr + size, size); - - std::lock_guard lock(m_heap_map_mtx); - if (!m_used_node.empty()) { - auto node = m_used_node.extract(m_used_node.begin()); - node.key() = size; - node.mapped() = ptr; - m_free_heap.insert(std::move(node)); - } else { - m_free_heap.emplace(size, ptr); - } -} - -inline namespace utils { -void kfree(void *ptr, std::size_t size) { return g_context.kfree(ptr, size); } -void *kalloc(std::size_t size, std::size_t align) { - return g_context.kalloc(size, align); -} -} // namespace utils - inline namespace logs { template <> void log_class_string::format(std::string &out, const void *arg) { diff --git a/kernel/orbis/src/ipmi.cpp b/kernel/orbis/src/ipmi.cpp index fe56efe54..0eb824f25 100644 --- a/kernel/orbis/src/ipmi.cpp +++ b/kernel/orbis/src/ipmi.cpp @@ -30,7 +30,7 @@ orbis::ErrorCode orbis::ipmiCreateServer(Process *proc, void *serverImpl, const char *name, const IpmiCreateServerConfig &config, rx::Ref &result) { - auto [server, errorCode] = g_context.createIpmiServer(name); + auto [server, errorCode] = g_context->createIpmiServer(name); ORBIS_RET_ON_ERROR(errorCode); server->serverImpl = serverImpl; @@ -44,9 +44,9 @@ orbis::ErrorCode orbis::ipmiCreateServer(Process *proc, void *serverImpl, orbis::ErrorCode orbis::ipmiCreateSession(Thread *thread, void *sessionImpl, ptr userData, rx::Ref &result) { - std::unique_lock ipmiMapLock(g_context.ipmiMap.mutex); + std::unique_lock ipmiMapLock(g_context->ipmiMap.mutex); - for (auto [kid, obj] : g_context.ipmiMap) { + for (auto [kid, obj] : g_context->ipmiMap) { auto server = dynamic_cast(obj); if (server == nullptr) { continue; @@ -104,7 +104,7 @@ orbis::SysResult orbis::sysIpmiCreateClient(Thread *thread, ptr result, ORBIS_RET_ON_ERROR(ipmiCreateClient(thread->tproc, _params.clientImpl, _name, _config, client)); - auto kid = g_context.ipmiMap.insert(std::move(client)); + auto kid = g_context->ipmiMap.insert(std::move(client)); if (kid == -1) { return ErrorCode::MFILE; @@ -139,7 +139,7 @@ orbis::SysResult orbis::sysIpmiCreateServer(Thread *thread, ptr result, ORBIS_RET_ON_ERROR(ureadString(_name, sizeof(_name), _params.name)); ORBIS_RET_ON_ERROR(ipmiCreateServer(thread->tproc, _params.serverImpl, _name, _config, server)); - auto kid = g_context.ipmiMap.insert(std::move(server)); + auto kid = g_context->ipmiMap.insert(std::move(server)); if (kid == -1) { return ErrorCode::MFILE; @@ -184,7 +184,7 @@ orbis::SysResult orbis::sysIpmiCreateSession(Thread *thread, ptr result, ORBIS_RET_ON_ERROR( ipmiCreateSession(thread, _params.sessionImpl, _userData.data, session)); - auto kid = g_context.ipmiMap.insert(std::move(session)); + auto kid = g_context->ipmiMap.insert(std::move(session)); if (kid == -1) { return ErrorCode::MFILE; @@ -233,7 +233,7 @@ orbis::SysResult orbis::sysIpmiServerReceivePacket(Thread *thread, ORBIS_RET_ON_ERROR( uread(_params, ptr(params))); - auto server = g_context.ipmiMap.get(kid).cast(); + auto server = g_context->ipmiMap.get(kid).cast(); if (server == nullptr) { return ErrorCode::INVAL; @@ -301,7 +301,7 @@ orbis::SysResult orbis::sysIpmiSendConnectResult(Thread *thread, ORBIS_LOG_NOTICE(__FUNCTION__, kid); - auto ipmiObject = g_context.ipmiMap.get(kid); + auto ipmiObject = g_context->ipmiMap.get(kid); if (ipmiObject == nullptr) { return ErrorCode::INVAL; } @@ -352,7 +352,7 @@ orbis::SysResult orbis::sysIpmiSessionRespondSync(Thread *thread, return ErrorCode::INVAL; } - auto session = g_context.ipmiMap.get(kid).cast(); + auto session = g_context->ipmiMap.get(kid).cast(); if (session == nullptr) { return ErrorCode::INVAL; @@ -422,7 +422,7 @@ orbis::SysResult orbis::sysIpmiClientInvokeAsyncMethod(Thread *thread, return ErrorCode::INVAL; } - auto client = g_context.ipmiMap.get(kid).cast(); + auto client = g_context->ipmiMap.get(kid).cast(); if (client == nullptr) { return ErrorCode::INVAL; @@ -513,7 +513,7 @@ orbis::SysResult orbis::sysImpiSessionRespondAsync(Thread *thread, return ErrorCode::INVAL; } - auto session = g_context.ipmiMap.get(kid).cast(); + auto session = g_context->ipmiMap.get(kid).cast(); if (session == nullptr) { return ErrorCode::INVAL; @@ -572,7 +572,7 @@ orbis::SysResult orbis::sysIpmiClientTryGetResult(Thread *thread, IpmiTryGetResultParams _params; ORBIS_RET_ON_ERROR(uread(_params, (ptr)params)); - auto client = g_context.ipmiMap.get(kid).cast(); + auto client = g_context->ipmiMap.get(kid).cast(); if (client == nullptr) { return ErrorCode::INVAL; @@ -649,7 +649,7 @@ orbis::SysResult orbis::sysIpmiClientGetMessage(Thread *thread, return ErrorCode::INVAL; } - auto client = g_context.ipmiMap.get(kid).cast(); + auto client = g_context->ipmiMap.get(kid).cast(); if (client == nullptr) { return ErrorCode::INVAL; @@ -750,7 +750,7 @@ orbis::SysResult orbis::sysIpmiClientTryGetMessage(Thread *thread, return ErrorCode::INVAL; } - auto client = g_context.ipmiMap.get(kid).cast(); + auto client = g_context->ipmiMap.get(kid).cast(); if (client == nullptr) { return ErrorCode::INVAL; @@ -804,7 +804,7 @@ orbis::SysResult orbis::sysIpmiSessionTrySendMessage(Thread *thread, return ErrorCode::INVAL; } - auto session = g_context.ipmiMap.get(kid).cast(); + auto session = g_context->ipmiMap.get(kid).cast(); if (session == nullptr) { return ErrorCode::INVAL; @@ -847,7 +847,7 @@ orbis::SysResult orbis::sysIpmiClientDisconnect(Thread *thread, return ErrorCode::INVAL; } - auto client = g_context.ipmiMap.get(kid).cast(); + auto client = g_context->ipmiMap.get(kid).cast(); if (client == nullptr) { return ErrorCode::INVAL; @@ -873,7 +873,7 @@ orbis::SysResult orbis::sysIpmiSessionGetClientPid(Thread *thread, return ErrorCode::INVAL; } - auto session = g_context.ipmiMap.get(kid).cast(); + auto session = g_context->ipmiMap.get(kid).cast(); if (session == nullptr) { return ErrorCode::INVAL; @@ -900,7 +900,7 @@ orbis::sysIpmiClientInvokeSyncMethod(Thread *thread, ptr result, uint kid, return ErrorCode::INVAL; } - auto client = g_context.ipmiMap.get(kid).cast(); + auto client = g_context->ipmiMap.get(kid).cast(); if (client == nullptr) { return ErrorCode::INVAL; @@ -1040,7 +1040,7 @@ orbis::SysResult orbis::sysIpmiClientConnect(Thread *thread, ptr result, return ErrorCode::INVAL; } - auto client = g_context.ipmiMap.get(kid).cast(); + auto client = g_context->ipmiMap.get(kid).cast(); if (client == nullptr) { return ErrorCode::INVAL; @@ -1053,7 +1053,7 @@ orbis::SysResult orbis::sysIpmiClientConnect(Thread *thread, ptr result, IpmiClientConnectParams _params; ORBIS_RET_ON_ERROR(uread(_params, ptr(params))); - auto server = g_context.findIpmiServer(client->name); + auto server = g_context->findIpmiServer(client->name); if (server == nullptr) { return SysResult::notAnError(ErrorCode::NOENT); @@ -1173,7 +1173,7 @@ orbis::SysResult orbis::sysIpmiSessionGetClientAppId(Thread *thread, return ErrorCode::INVAL; } - auto session = g_context.ipmiMap.get(kid).cast(); + auto session = g_context->ipmiMap.get(kid).cast(); if (session == nullptr) { return ErrorCode::INVAL; @@ -1198,7 +1198,7 @@ orbis::SysResult orbis::sysIpmiSessionGetUserData(Thread *thread, return ErrorCode::INVAL; } - auto session = g_context.ipmiMap.get(kid).cast(); + auto session = g_context->ipmiMap.get(kid).cast(); if (session == nullptr) { return ErrorCode::INVAL; @@ -1221,7 +1221,7 @@ orbis::SysResult orbis::sysIpmiServerGetName(Thread *thread, ptr result, return ErrorCode::INVAL; } - auto server = g_context.ipmiMap.get(kid).cast(); + auto server = g_context->ipmiMap.get(kid).cast(); if (server == nullptr) { return ErrorCode::INVAL; @@ -1246,7 +1246,7 @@ orbis::SysResult orbis::sysIpmiClientGetName(Thread *thread, ptr result, return ErrorCode::INVAL; } - auto client = g_context.ipmiMap.get(kid).cast(); + auto client = g_context->ipmiMap.get(kid).cast(); if (client == nullptr) { return ErrorCode::INVAL; @@ -1283,7 +1283,7 @@ orbis::SysResult orbis::sysIpmiClientWaitEventFlag(Thread *thread, IpmiWaitEventFlagParam _params; ORBIS_RET_ON_ERROR(uread(_params, ptr(params))); - auto client = g_context.ipmiMap.get(kid).cast(); + auto client = g_context->ipmiMap.get(kid).cast(); if (client == nullptr) { return ErrorCode::INVAL; @@ -1344,7 +1344,7 @@ orbis::SysResult orbis::sysIpmiClientPollEventFlag(Thread *thread, IpmiPollEventFlagParam _params; ORBIS_RET_ON_ERROR(uread(_params, ptr(params))); - auto client = g_context.ipmiMap.get(kid).cast(); + auto client = g_context->ipmiMap.get(kid).cast(); if (client == nullptr) { return ErrorCode::INVAL; @@ -1384,7 +1384,7 @@ orbis::SysResult orbis::sysIpmiSessionSetEventFlag(Thread *thread, IpmiSetEventFlagParam _params; ORBIS_RET_ON_ERROR(uread(_params, ptr(params))); - auto session = g_context.ipmiMap.get(kid).cast(); + auto session = g_context->ipmiMap.get(kid).cast(); if (session == nullptr) { return ErrorCode::INVAL; diff --git a/kernel/orbis/src/sys/sys_cpuset.cpp b/kernel/orbis/src/sys/sys_cpuset.cpp index 6e2af6f6c..12163a6ba 100644 --- a/kernel/orbis/src/sys/sys_cpuset.cpp +++ b/kernel/orbis/src/sys/sys_cpuset.cpp @@ -97,7 +97,7 @@ orbis::SysResult orbis::sys_cpuset_getaffinity(Thread *thread, cpulevel_t level, if (id == ~id_t(0) || id == thread->tproc->pid) { whichProcess = thread->tproc; } else { - whichProcess = g_context.findProcessById(id); + whichProcess = g_context->findProcessById(id); if (whichProcess == nullptr) { return ErrorCode::SRCH; @@ -163,7 +163,7 @@ orbis::SysResult orbis::sys_cpuset_setaffinity(Thread *thread, cpulevel_t level, } else { ORBIS_LOG_ERROR(__FUNCTION__, "process not found", level, which, id, cpusetsize); - whichProcess = g_context.findProcessById(id); + whichProcess = g_context->findProcessById(id); if (whichProcess == nullptr) { return ErrorCode::SRCH; diff --git a/kernel/orbis/src/sys/sys_event.cpp b/kernel/orbis/src/sys/sys_event.cpp index dbf7d2bfc..950c89765 100644 --- a/kernel/orbis/src/sys/sys_event.cpp +++ b/kernel/orbis/src/sys/sys_event.cpp @@ -89,7 +89,7 @@ static SysResult keventChange(KQueue *kq, KEvent &change, Thread *thread) { nodeIt = kq->notes.begin(); if (change.filter == kEvFiltProc) { - auto process = g_context.findProcessById(change.ident); + auto process = g_context->findProcessById(change.ident); if (process == nullptr) { return ErrorCode::SRCH; } @@ -124,7 +124,7 @@ static SysResult keventChange(KQueue *kq, KEvent &change, Thread *thread) { } } else if (change.filter == kEvFiltGraphicsCore || change.filter == kEvFiltDisplay) { - g_context.deviceEventEmitter->subscribe(&*nodeIt); + g_context->deviceEventEmitter->subscribe(&*nodeIt); } } } @@ -185,7 +185,7 @@ static SysResult keventChange(KQueue *kq, KEvent &change, Thread *thread) { nodeIt->event.data |= 1000ull << 16; // clock kq->cv.notify_all(kq->mtx); - } else if (g_context.fwType == FwType::Ps5 && + } else if (g_context->fwType == FwType::Ps5 && change.filter == kEvFiltGraphicsCore && change.ident == 0) { nodeIt->triggered = true; kq->cv.notify_all(kq->mtx); diff --git a/kernel/orbis/src/sys/sys_exit.cpp b/kernel/orbis/src/sys/sys_exit.cpp index 968d24d55..a6bfd27c4 100644 --- a/kernel/orbis/src/sys/sys_exit.cpp +++ b/kernel/orbis/src/sys/sys_exit.cpp @@ -25,7 +25,7 @@ orbis::SysResult orbis::sys_wait4(Thread *thread, sint pid, ptr status, int hostPid = pid; if (pid > 0) { - auto process = g_context.findProcessById(pid); + auto process = g_context->findProcessById(pid); if (process == nullptr) { return ErrorCode::SRCH; } @@ -42,7 +42,7 @@ orbis::SysResult orbis::sys_wait4(Thread *thread, sint pid, ptr status, ORBIS_LOG_ERROR(__FUNCTION__, pid, status, options, rusage, result, stat); - auto process = g_context.findProcessByHostId(result); + auto process = g_context->findProcessByHostId(result); if (process == nullptr) { ORBIS_LOG_ERROR("host process not found", result); continue; diff --git a/kernel/orbis/src/sys/sys_sce.cpp b/kernel/orbis/src/sys/sys_sce.cpp index 9ae80777e..a5cba82cc 100644 --- a/kernel/orbis/src/sys/sys_sce.cpp +++ b/kernel/orbis/src/sys/sys_sce.cpp @@ -80,7 +80,7 @@ orbis::SysResult orbis::sys_regmgr_call(Thread *thread, uint32_t op, // ORBIS_LOG_ERROR(__FUNCTION__, op, id, len); // thread->where(); - std::lock_guard lock(orbis::g_context.regMgrMtx); + std::lock_guard lock(orbis::g_context->regMgrMtx); if (op == 1) { // set int @@ -89,7 +89,7 @@ orbis::SysResult orbis::sys_regmgr_call(Thread *thread, uint32_t op, } ORBIS_LOG_ERROR(__FUNCTION__, op, id, *(std::uint32_t *)value); - g_context.regMgrInt[id] = *(std::uint32_t *)value; + g_context->regMgrInt[id] = *(std::uint32_t *)value; return {}; } if (op == 2) { @@ -98,8 +98,8 @@ orbis::SysResult orbis::sys_regmgr_call(Thread *thread, uint32_t op, return ErrorCode::INVAL; } - auto intValIt = g_context.regMgrInt.find(id); - if (intValIt == g_context.regMgrInt.end()) { + auto intValIt = g_context->regMgrInt.find(id); + if (intValIt == g_context->regMgrInt.end()) { ORBIS_LOG_ERROR("registry int entry not exists", op, id, len); thread->where(); // return ErrorCode::NOENT; @@ -774,7 +774,7 @@ orbis::SysResult orbis::sys_budget_create(Thread *thread, ptr name, BudgetInfo _resources[kMaxBudgets]; ORBIS_RET_ON_ERROR(uread(_resources, resources, count)); - auto processTypeBudget = g_context.getProcessTypeBudget(processType); + auto processTypeBudget = g_context->getProcessTypeBudget(processType); int invalidResourceCount = 0; for (auto &resource : std::span(_resources, count)) { @@ -804,7 +804,7 @@ orbis::SysResult orbis::sys_budget_create(Thread *thread, ptr name, rx::Ref budget = orbis::knew(_name, processType, std::span(_resources, count)); - auto id = g_context.budgets.insert(budget); + auto id = g_context->budgets.insert(budget); thread->retval[0] = id; return {}; } @@ -845,9 +845,9 @@ orbis::SysResult orbis::sys_budget_get(Thread *thread, sint id, } budget = - g_context.getProcessTypeBudget(static_cast(id)); + g_context->getProcessTypeBudget(static_cast(id)); } else { - budget = g_context.budgets.get(id); + budget = g_context->budgets.get(id); if (!budget) { return ErrorCode::SRCH; @@ -873,7 +873,7 @@ orbis::SysResult orbis::sys_budget_set(Thread *thread, sint budgetId) { return ErrorCode::NOSYS; } - auto budget = g_context.budgets.get(budgetId); + auto budget = g_context->budgets.get(budgetId); if (!budget) { return ErrorCode::SRCH; } @@ -940,7 +940,7 @@ orbis::SysResult orbis::sys_dmem_container(Thread *thread, uint id) { orbis::SysResult orbis::sys_get_authinfo(Thread *thread, pid_t pid, ptr info) { - auto process = pid > 0 ? g_context.findProcessById(pid) : thread->tproc; + auto process = pid > 0 ? g_context->findProcessById(pid) : thread->tproc; if (process == nullptr) { return ErrorCode::SRCH; } @@ -1188,7 +1188,7 @@ orbis::SysResult orbis::sys_randomized_path(Thread *thread, sint type, } orbis::SysResult orbis::sys_rdup(Thread *thread, sint pid, sint fd) { ORBIS_LOG_TODO(__FUNCTION__, pid, fd); - for (auto it = g_context.getProcessList(); it != nullptr; it = it->next) { + for (auto it = g_context->getProcessList(); it != nullptr; it = it->next) { auto &p = it->object; if (p.pid != pid) { continue; @@ -1297,7 +1297,7 @@ orbis::SysResult orbis::sys_budget_get_ptype(Thread *thread, sint pid) { if (pid < 0 || pid == thread->tproc->pid) { process = thread->tproc; } else { - process = g_context.findProcessById(pid); + process = g_context->findProcessById(pid); if (!process) { return ErrorCode::SRCH; @@ -1344,7 +1344,7 @@ orbis::SysResult orbis::sys_thr_get_name(Thread *thread, lwpid_t lwpid, searchThread = thread->tproc->threadsMap.get(lwpid - thread->tproc->pid); if (searchThread == nullptr) { - if (auto process = g_context.findProcessById(lwpid)) { + if (auto process = g_context->findProcessById(lwpid)) { searchThread = process->threadsMap.get(lwpid - process->pid); } } @@ -1446,7 +1446,7 @@ orbis::SysResult orbis::sys_ipmimgr_call(Thread *thread, uint op, uint kid, return sysIpmiSessionSetEventFlag(thread, result, kid, params, paramsSz); } - if (auto ipmi = g_context.ipmiMap.get(kid)) { + if (auto ipmi = g_context->ipmiMap.get(kid)) { if (auto client = ipmi.cast()) { ORBIS_LOG_TODO(__FUNCTION__, thread->tid, op, client->name, result, params, paramsSz); @@ -1652,7 +1652,7 @@ orbis::sys_get_kernel_mem_statistics(Thread *thread /* TODO */) { orbis::SysResult orbis::sys_get_sdk_compiled_version(Thread *thread, ptr path) { ORBIS_LOG_ERROR(__FUNCTION__, path); - thread->retval[0] = g_context.sdkVersion; + thread->retval[0] = g_context->sdkVersion; return {}; } orbis::SysResult orbis::sys_app_state_change(Thread *thread, sint state) { @@ -1680,7 +1680,7 @@ orbis::SysResult orbis::sys_budget_get_ptype_of_budget(Thread *thread, return ErrorCode::NOSYS; } - rx::Ref budget = g_context.budgets.get(budgetId); + rx::Ref budget = g_context->budgets.get(budgetId); if (!budget) { return ErrorCode::SRCH; @@ -1877,10 +1877,10 @@ orbis::SysResult orbis::sys_begin_app_mount(Thread *thread, rx::Ref appInfo = orbis::knew(); AppInfoEx *appInfoData = appInfo.get(); - auto handle = g_context.appInfos.insert(appInfo); + auto handle = g_context->appInfos.insert(appInfo); ORBIS_LOG_TODO(__FUNCTION__, handle); thread->where(); - if (handle == decltype(g_context.appInfos)::npos) { + if (handle == decltype(g_context->appInfos)::npos) { return ErrorCode::DOOFUS; } diff --git a/kernel/orbis/src/sys/sys_sig.cpp b/kernel/orbis/src/sys/sys_sig.cpp index 95f15f4dd..13fcd2a0d 100644 --- a/kernel/orbis/src/sys/sys_sig.cpp +++ b/kernel/orbis/src/sys/sys_sig.cpp @@ -114,7 +114,7 @@ orbis::SysResult orbis::sys_kill(Thread *thread, sint pid, sint signum) { int hostPid = pid; if (pid > 0) { - auto process = g_context.findProcessById(pid); + auto process = g_context->findProcessById(pid); if (process == nullptr) { return ErrorCode::SRCH; } diff --git a/kernel/orbis/src/sys/sys_sysctl.cpp b/kernel/orbis/src/sys/sys_sysctl.cpp index 6fe5f8870..1f09f0103 100644 --- a/kernel/orbis/src/sys/sys_sysctl.cpp +++ b/kernel/orbis/src/sys/sys_sysctl.cpp @@ -92,7 +92,7 @@ SysResult kern_sysctl(Thread *thread, ptr name, uint namelen, // 4.17.0.0.3.0 if (name[0] == net && name[1] == 17 && name[2] == 0 && name[3] == 0 && name[4] == 3 && name[5] == 0) { - if (g_context.fwSdkVersion == 0) { + if (g_context->fwSdkVersion == 0) { // proto fw return {}; } @@ -197,7 +197,7 @@ SysResult kern_sysctl(Thread *thread, ptr name, uint namelen, return ErrorCode::INVAL; } - auto budget = g_context.budgets.get(thread->tproc->budgetId); + auto budget = g_context->budgets.get(thread->tproc->budgetId); auto fmem = budget->get(BudgetResource::Fmem); *(uint64_t *)old = fmem.total; return {}; @@ -208,7 +208,7 @@ SysResult kern_sysctl(Thread *thread, ptr name, uint namelen, return ErrorCode::INVAL; } - auto budget = g_context.budgets.get(thread->tproc->budgetId); + auto budget = g_context->budgets.get(thread->tproc->budgetId); auto fmem = budget->get(BudgetResource::Fmem); auto result = (uint64_t *)old; @@ -225,7 +225,7 @@ SysResult kern_sysctl(Thread *thread, ptr name, uint namelen, ORBIS_LOG_ERROR("KERN_PROC_PROC 2"); if (namelen >= 4) { - auto process = g_context.findProcessById(name[3]); + auto process = g_context->findProcessById(name[3]); if (process == nullptr || process->exitStatus.has_value()) { return ErrorCode::SRCH; } @@ -245,7 +245,7 @@ SysResult kern_sysctl(Thread *thread, ptr name, uint namelen, } if (name[0] == kern && name[1] == proc && name[2] == 55) { - if (g_context.fwType != FwType::Ps5) { + if (g_context->fwType != FwType::Ps5) { return orbis::ErrorCode::INVAL; } @@ -259,7 +259,7 @@ SysResult kern_sysctl(Thread *thread, ptr name, uint namelen, if (name[0] == kern && name[1] == proc && name[2] == 36) { Process *process = thread->tproc; if (process->pid != name[3]) { - process = g_context.findProcessById(name[3]); + process = g_context->findProcessById(name[3]); if (process == nullptr) { ORBIS_LOG_ERROR("get sdk version by pid: process not found", name[3], thread->tproc->pid); @@ -276,7 +276,7 @@ SysResult kern_sysctl(Thread *thread, ptr name, uint namelen, auto sdkVersion = process->sdkVersion; if (sdkVersion == 0) { - sdkVersion = g_context.fwSdkVersion; + sdkVersion = g_context->fwSdkVersion; } ORBIS_RET_ON_ERROR(uwrite(ptr(old), sdkVersion)); @@ -290,7 +290,7 @@ SysResult kern_sysctl(Thread *thread, ptr name, uint namelen, // 1 - 14 - 35 - pid Process *process = thread->tproc; if (process->pid != name[3] && name[3] != -1) { - process = g_context.findProcessById(name[3]); + process = g_context->findProcessById(name[3]); if (process == nullptr) { ORBIS_LOG_ERROR("appinfo process not found", name[3], thread->tproc->pid); @@ -384,7 +384,7 @@ SysResult kern_sysctl(Thread *thread, ptr name, uint namelen, } if (name[0] == kern && name[1] == proc && name[2] == 64) { - auto appInfo = g_context.appInfos.get(name[3]); + auto appInfo = g_context->appInfos.get(name[3]); if (appInfo == nullptr) { return ErrorCode::SRCH; // ? } @@ -418,7 +418,7 @@ SysResult kern_sysctl(Thread *thread, ptr name, uint namelen, if (name[0] == 1 && name[1] == proc && name[2] == 65) { // AppInfo by appId get/set // 1 - 14 - 65 - appId - auto appInfo = g_context.appInfos.get(name[3]); + auto appInfo = g_context->appInfos.get(name[3]); if (appInfo == nullptr) { ORBIS_LOG_ERROR("appinfo appId not found", name[3], thread->tproc->pid); return ErrorCode::SRCH; @@ -461,7 +461,7 @@ SysResult kern_sysctl(Thread *thread, ptr name, uint namelen, if (name[0] == kern && name[1] == proc && name[2] == 68) { Process *process = thread->tproc; if (process->pid != name[3]) { - process = g_context.findProcessById(name[3]); + process = g_context->findProcessById(name[3]); if (process == nullptr) { ORBIS_LOG_ERROR("get ps5 sdk version by pid: process not found", name[3], thread->tproc->pid); @@ -478,7 +478,7 @@ SysResult kern_sysctl(Thread *thread, ptr name, uint namelen, auto sdkVersion = process->sdkVersion; if (sdkVersion == 0) { - sdkVersion = g_context.fwSdkVersion; + sdkVersion = g_context->fwSdkVersion; } ORBIS_RET_ON_ERROR(uwrite(ptr(old), sdkVersion)); @@ -699,7 +699,7 @@ SysResult kern_sysctl(Thread *thread, ptr name, uint namelen, dest[count++] = budgets; dest[count++] = mlock_avail; } else if (searchName == "hw.sce_main_socid") { - if (g_context.fwType != FwType::Ps5) { + if (g_context->fwType != FwType::Ps5) { return ErrorCode::INVAL; } @@ -844,7 +844,7 @@ SysResult kern_sysctl(Thread *thread, ptr name, uint namelen, return ErrorCode::INVAL; } - *(std::uint32_t *)old = g_context.safeMode; + *(std::uint32_t *)old = g_context->safeMode; } if (new_ != nullptr && newlen == 4) { ORBIS_LOG_ERROR("sysctl: set kern.init_safe_mode", @@ -902,7 +902,7 @@ SysResult kern_sysctl(Thread *thread, ptr name, uint namelen, return {}; case sysctl_hw::sce_main_socid: - if (g_context.fwType != FwType::Ps5) { + if (g_context->fwType != FwType::Ps5) { return ErrorCode::INVAL; } if (*oldlenp != 4 || new_ != nullptr || newlen != 0) { @@ -933,13 +933,13 @@ SysResult kern_sysctl(Thread *thread, ptr name, uint namelen, return ErrorCode::INVAL; } - if (g_context.fwType != FwType::Ps5 && + if (g_context->fwType != FwType::Ps5 && std::string_view((char *)thread->tproc->appInfo.titleId) == "NPXS20973") { ORBIS_LOG_ERROR("get tsc freq: returning patched value"); *(uint64_t *)old = 1000000; } else { - *(uint64_t *)old = g_context.getTscFreq(); + *(uint64_t *)old = g_context->getTscFreq(); } return {}; } diff --git a/kernel/orbis/src/umtx.cpp b/kernel/orbis/src/umtx.cpp index 7719163f5..cd8352653 100644 --- a/kernel/orbis/src/umtx.cpp +++ b/kernel/orbis/src/umtx.cpp @@ -1,5 +1,5 @@ #include "orbis/umtx.hpp" -#include "GlobalKernelObject.hpp" +#include "KernelObject.hpp" #include "error.hpp" #include "orbis-config.hpp" #include "orbis/thread.hpp" @@ -25,7 +25,7 @@ struct UmtxCond { struct UmtxChain { rx::shared_mutex mtx; - using queue_type = utils::kmultimap; + using queue_type = kmultimap; queue_type sleep_queue; queue_type spare_queue; diff --git a/rpcsx/core/src/watchdog.cpp b/rpcsx/core/src/watchdog.cpp index 499498a02..5719a83e7 100644 --- a/rpcsx/core/src/watchdog.cpp +++ b/rpcsx/core/src/watchdog.cpp @@ -32,7 +32,7 @@ enum class MessageId { }; static void runGPU() { - if (g_gpuPid != 0 || orbis::g_context.gpuDevice != nullptr) { + if (g_gpuPid != 0 || orbis::g_context->gpuDevice != nullptr) { return; } @@ -54,8 +54,8 @@ static void runGPU() { amdgpu::DeviceCtl gpu; { pthread_setname_np(pthread_self(), "rpcsx-gpu"); - std::lock_guard lock(orbis::g_context.gpuDeviceMtx); - if (orbis::g_context.gpuDevice != nullptr) { + std::lock_guard lock(orbis::g_context->gpuDeviceMtx); + if (orbis::g_context->gpuDevice != nullptr) { std::exit(0); } @@ -66,7 +66,7 @@ static void runGPU() { ::close(logFd); gpu = amdgpu::DeviceCtl::createDevice(); - orbis::g_context.gpuDevice = gpu.getOpaque(); + orbis::g_context->gpuDevice = gpu.getOpaque(); } gpu.start(); diff --git a/rpcsx/gpu/Device.cpp b/rpcsx/gpu/Device.cpp index c0f1cd2d5..bef00c03d 100644 --- a/rpcsx/gpu/Device.cpp +++ b/rpcsx/gpu/Device.cpp @@ -344,7 +344,7 @@ void Device::start() { } std::jthread vblankThread([](const std::stop_token &stopToken) { - orbis::g_context.deviceEventEmitter->emit( + orbis::g_context->deviceEventEmitter->emit( orbis::kEvFiltDisplay, [=](orbis::KNote *note) -> std::optional { if (DisplayEvent(note->event.ident >> 48) == @@ -362,7 +362,7 @@ void Device::start() { std::chrono::duration_cast(period); std::this_thread::sleep_until(prevVBlank); - orbis::g_context.deviceEventEmitter->emit( + orbis::g_context->deviceEventEmitter->emit( orbis::kEvFiltDisplay, [=](orbis::KNote *note) -> std::optional { if (DisplayEvent(note->event.ident >> 48) == DisplayEvent::VBlank) { @@ -941,7 +941,7 @@ void Device::flip(std::uint32_t pid, int bufferIndex, std::uint64_t arg) { flip(pid, bufferIndex, arg, vk::context->swapchainImages[imageIndex], vk::context->swapchainImageViews[imageIndex]); - orbis::g_context.deviceEventEmitter->emit( + orbis::g_context->deviceEventEmitter->emit( orbis::kEvFiltDisplay, [=](orbis::KNote *note) -> std::optional { if (DisplayEvent(note->event.ident >> 48) == DisplayEvent::Flip) { diff --git a/rpcsx/gpu/Pipe.cpp b/rpcsx/gpu/Pipe.cpp index e1adfb206..741cb6376 100644 --- a/rpcsx/gpu/Pipe.cpp +++ b/rpcsx/gpu/Pipe.cpp @@ -345,7 +345,7 @@ bool ComputePipe::releaseMem(Ring &ring) { } if (intSel) { - orbis::g_context.deviceEventEmitter->emit( + orbis::g_context->deviceEventEmitter->emit( orbis::kEvFiltGraphicsCore, [=, this](orbis::KNote *note) -> std::optional { if (note->event.ident == kGcEventCompute0RelMem + index) { @@ -1375,7 +1375,7 @@ bool GraphicsPipe::eventWriteEop(Ring &ring) { } if (intSel != 0) { - orbis::g_context.deviceEventEmitter->emit( + orbis::g_context->deviceEventEmitter->emit( orbis::kEvFiltGraphicsCore, [=](orbis::KNote *note) -> std::optional { if (note->event.ident == kGcEventGfxEop) { diff --git a/rpcsx/io-device.cpp b/rpcsx/io-device.cpp index 557bdefe6..b1d7cc2f9 100644 --- a/rpcsx/io-device.cpp +++ b/rpcsx/io-device.cpp @@ -40,7 +40,7 @@ struct HostFile : orbis::File { }; struct SocketFile : orbis::File { - orbis::utils::kstring name; + orbis::kstring name; int dom = -1; int type = -1; int prot = -1; @@ -846,7 +846,7 @@ orbis::ErrorCode HostFsDevice::open(rx::Ref *file, } // Assume the file is a directory and try to read direntries - orbis::utils::kvector dirEntries; + orbis::kvector dirEntries; char hostEntryBuffer[sizeof(dirent64) * 4]; while (true) { auto r = getdents64(hostFd, hostEntryBuffer, sizeof(hostEntryBuffer)); diff --git a/rpcsx/iodev/blockpool.cpp b/rpcsx/iodev/blockpool.cpp index 3d5c76e1d..045b85d04 100644 --- a/rpcsx/iodev/blockpool.cpp +++ b/rpcsx/iodev/blockpool.cpp @@ -31,7 +31,7 @@ static orbis::ErrorCode blockpool_ioctl(orbis::File *file, ORBIS_LOG_TODO("blockpool expand", args->len, args->searchStart, args->searchEnd, args->flags); - auto dmem = orbis::g_context.dmemDevice.rawStaticCast(); + auto dmem = orbis::g_context->dmemDevice.rawStaticCast(); std::lock_guard lock(dmem->mtx); std::uint64_t start = args->searchStart; ORBIS_RET_ON_ERROR( @@ -64,7 +64,7 @@ static orbis::ErrorCode blockpool_mmap(orbis::File *file, void **address, return orbis::ErrorCode::NOMEM; } - auto dmem = orbis::g_context.dmemDevice.rawStaticCast(); + auto dmem = orbis::g_context->dmemDevice.rawStaticCast(); auto mapped = reinterpret_cast(vm::map( *address, size, prot, flags, vm::kMapInternalReserveOnly, blockPool)); diff --git a/rpcsx/iodev/dce.cpp b/rpcsx/iodev/dce.cpp index d405cfce2..845d25d5f 100644 --- a/rpcsx/iodev/dce.cpp +++ b/rpcsx/iodev/dce.cpp @@ -148,7 +148,7 @@ static void runBridge(int vmId) { std::thread{[=] { pthread_setname_np(pthread_self(), "Bridge"); - auto gpu = amdgpu::DeviceCtl{orbis::g_context.gpuDevice}; + auto gpu = amdgpu::DeviceCtl{orbis::g_context->gpuDevice}; auto &gpuCtx = gpu.getContext(); std::vector fetchedCommands; fetchedCommands.reserve(std::size(gpuCtx.cpuCacheCommands)); @@ -247,7 +247,7 @@ static void initDceMemory(DceDevice *device) { return; } - auto dmem = orbis::g_context.dmemDevice.cast(); + auto dmem = orbis::g_context->dmemDevice.cast(); std::uint64_t start = 0; if (dmem->allocate(&start, ~0ull, kDceControlMemorySize, 0x100000, 1) != orbis::ErrorCode{}) { @@ -278,12 +278,12 @@ static orbis::ErrorCode dce_ioctl(orbis::File *file, std::uint64_t request, void *argp, orbis::Thread *thread) { auto device = static_cast(file->device.get()); - auto gpu = amdgpu::DeviceCtl{orbis::g_context.gpuDevice}; + auto gpu = amdgpu::DeviceCtl{orbis::g_context->gpuDevice}; auto &gpuCtx = gpu.getContext(); // std::this_thread::sleep_for(std::chrono::seconds(5)); - if (orbis::g_context.fwType == orbis::FwType::Ps5) { + if (orbis::g_context->fwType == orbis::FwType::Ps5) { if (request == 0x80308217) { auto args = reinterpret_cast(argp); @@ -489,7 +489,7 @@ static orbis::ErrorCode dce_ioctl(orbis::File *file, std::uint64_t request, } else if (args->id == 1) { // Mode set - orbis::g_context.deviceEventEmitter->emit( + orbis::g_context->deviceEventEmitter->emit( orbis::kEvFiltDisplay, [](orbis::KNote *note) -> std::optional { if ((note->event.ident >> 48) == 0x64) { @@ -603,7 +603,7 @@ static orbis::ErrorCode dce_mmap(orbis::File *file, void **address, ORBIS_LOG_FATAL("dce mmap", address, size, offset); auto dce = file->device.cast(); initDceMemory(dce.get()); - auto dmem = orbis::g_context.dmemDevice.cast(); + auto dmem = orbis::g_context->dmemDevice.cast(); return dmem->mmap(address, size, prot, flags, dce->dmemOffset + offset); } @@ -614,15 +614,15 @@ static const orbis::FileOps ops = { static void createGpu() { { - std::lock_guard lock(orbis::g_context.gpuDeviceMtx); - if (orbis::g_context.gpuDevice != nullptr) { + std::lock_guard lock(orbis::g_context->gpuDeviceMtx); + if (orbis::g_context->gpuDevice != nullptr) { return; } rx::createGpuDevice(); } - while (orbis::g_context.gpuDevice == nullptr) { + while (orbis::g_context->gpuDevice == nullptr) { } } @@ -642,9 +642,9 @@ void DceDevice::initializeProcess(orbis::Process *process) { createGpu(); auto vmId = allocateVmId(); - std::lock_guard lock(orbis::g_context.gpuDeviceMtx); + std::lock_guard lock(orbis::g_context->gpuDeviceMtx); { - auto gpu = amdgpu::DeviceCtl{orbis::g_context.gpuDevice}; + auto gpu = amdgpu::DeviceCtl{orbis::g_context->gpuDevice}; gpu.submitMapProcess(process->pid, vmId); process->vmId = vmId; } diff --git a/rpcsx/iodev/dmem.cpp b/rpcsx/iodev/dmem.cpp index aefed276c..f8060bd01 100644 --- a/rpcsx/iodev/dmem.cpp +++ b/rpcsx/iodev/dmem.cpp @@ -73,7 +73,7 @@ orbis::ErrorCode DmemDevice::mmap(void **address, std::uint64_t len, return orbis::ErrorCode::INVAL; } - if (auto gpu = amdgpu::DeviceCtl{orbis::g_context.gpuDevice}) { + if (auto gpu = amdgpu::DeviceCtl{orbis::g_context->gpuDevice}) { gpu.submitMapMemory(orbis::g_currentThread->tproc->pid, reinterpret_cast(result), len, memoryType, index, prot, directMemoryStart); diff --git a/rpcsx/iodev/gc.cpp b/rpcsx/iodev/gc.cpp index 8c564c9aa..8d09aac95 100644 --- a/rpcsx/iodev/gc.cpp +++ b/rpcsx/iodev/gc.cpp @@ -56,7 +56,7 @@ static orbis::ErrorCode gc_ioctl(orbis::File *file, std::uint64_t request, switch (request) { case 0xc008811b: // get submit done flag ptr? if (device->submitArea == nullptr) { - auto dmem = orbis::g_context.dmemDevice.staticCast(); + auto dmem = orbis::g_context->dmemDevice.staticCast(); std::uint64_t start = 0; auto err = dmem->allocate(&start, ~0, vm::kPageSize, 0, 0); if (err != orbis::ErrorCode{}) { @@ -78,7 +78,7 @@ static orbis::ErrorCode gc_ioctl(orbis::File *file, std::uint64_t request, break; case 0xc004812e: { - if (orbis::g_context.fwType != orbis::FwType::Ps5) { + if (orbis::g_context->fwType != orbis::FwType::Ps5) { return orbis::ErrorCode::INVAL; } @@ -94,7 +94,7 @@ static orbis::ErrorCode gc_ioctl(orbis::File *file, std::uint64_t request, } case 0xc0488131: { - if (orbis::g_context.fwType != orbis::FwType::Ps5) { + if (orbis::g_context->fwType != orbis::FwType::Ps5) { return orbis::ErrorCode::INVAL; } @@ -123,7 +123,7 @@ static orbis::ErrorCode gc_ioctl(orbis::File *file, std::uint64_t request, // thread->where(); - if (auto gpu = amdgpu::DeviceCtl{orbis::g_context.gpuDevice}) { + if (auto gpu = amdgpu::DeviceCtl{orbis::g_context->gpuDevice}) { if (args->contextControl[0]) { gpu.submitGfxCommand(gcFile->gfxPipe, orbis::g_currentThread->tproc->vmId, @@ -155,7 +155,7 @@ static orbis::ErrorCode gc_ioctl(orbis::File *file, std::uint64_t request, } case 0xc0188132: { - if (orbis::g_context.fwType != orbis::FwType::Ps5) { + if (orbis::g_context->fwType != orbis::FwType::Ps5) { return orbis::ErrorCode::INVAL; } @@ -186,7 +186,7 @@ static orbis::ErrorCode gc_ioctl(orbis::File *file, std::uint64_t request, // args->submits[i].unk1); // } - if (auto gpu = amdgpu::DeviceCtl{orbis::g_context.gpuDevice}) { + if (auto gpu = amdgpu::DeviceCtl{orbis::g_context->gpuDevice}) { for (unsigned i = 0; i < args->count / 2; ++i) { auto addressLo = static_cast(args->submits[i].address); auto addressHi = @@ -215,7 +215,7 @@ static orbis::ErrorCode gc_ioctl(orbis::File *file, std::uint64_t request, }; auto args = reinterpret_cast(argp); - if (auto gpu = amdgpu::DeviceCtl{orbis::g_context.gpuDevice}) { + if (auto gpu = amdgpu::DeviceCtl{orbis::g_context->gpuDevice}) { for (unsigned i = 0; i < args->count; ++i) { gpu.submitGfxCommand(gcFile->gfxPipe, orbis::g_currentThread->tproc->vmId, @@ -236,7 +236,7 @@ static orbis::ErrorCode gc_ioctl(orbis::File *file, std::uint64_t request, }; auto args = reinterpret_cast(argp); - if (auto gpu = amdgpu::DeviceCtl{orbis::g_context.gpuDevice}) { + if (auto gpu = amdgpu::DeviceCtl{orbis::g_context->gpuDevice}) { gpu.waitForIdle(); gpu.submitSwitchBuffer(orbis::g_currentThread->tproc->gfxRing); } else { @@ -258,7 +258,7 @@ static orbis::ErrorCode gc_ioctl(orbis::File *file, std::uint64_t request, auto args = reinterpret_cast(argp); - if (auto gpu = amdgpu::DeviceCtl{orbis::g_context.gpuDevice}) { + if (auto gpu = amdgpu::DeviceCtl{orbis::g_context->gpuDevice}) { for (unsigned i = 0; i < args->count; ++i) { gpu.submitGfxCommand(gcFile->gfxPipe, orbis::g_currentThread->tproc->vmId, @@ -277,7 +277,7 @@ static orbis::ErrorCode gc_ioctl(orbis::File *file, std::uint64_t request, } case 0xc0048116: { // submit done? - if (auto gpu = amdgpu::DeviceCtl{orbis::g_context.gpuDevice}) { + if (auto gpu = amdgpu::DeviceCtl{orbis::g_context->gpuDevice}) { // gpu.waitForIdle(); } else { return orbis::ErrorCode::BUSY; @@ -285,7 +285,7 @@ static orbis::ErrorCode gc_ioctl(orbis::File *file, std::uint64_t request, } case 0xc0048117: - if (auto gpu = amdgpu::DeviceCtl{orbis::g_context.gpuDevice}) { + if (auto gpu = amdgpu::DeviceCtl{orbis::g_context->gpuDevice}) { gpu.waitForIdle(); } else { return orbis::ErrorCode::BUSY; @@ -354,7 +354,7 @@ static orbis::ErrorCode gc_ioctl(orbis::File *file, std::uint64_t request, args->queueId, args->vqueueId, args->ringBaseAddress, args->readPtrAddress, args->doorbell, args->ringSize); - if (auto gpu = amdgpu::DeviceCtl{orbis::g_context.gpuDevice}) { + if (auto gpu = amdgpu::DeviceCtl{orbis::g_context->gpuDevice}) { gpu.mapComputeQueue(thread->tproc->vmId, args->meId, args->pipeId, args->queueId, args->vqueueId, args->ringBaseAddress, args->readPtrAddress, args->doorbell, @@ -379,7 +379,7 @@ static orbis::ErrorCode gc_ioctl(orbis::File *file, std::uint64_t request, ORBIS_LOG_ERROR("gc ioctl ding dong for workload", args->meId, args->pipeId, args->queueId, args->nextStartOffsetInDw); - if (auto gpu = amdgpu::DeviceCtl{orbis::g_context.gpuDevice}) { + if (auto gpu = amdgpu::DeviceCtl{orbis::g_context->gpuDevice}) { gpu.submitComputeQueue(args->meId, args->pipeId, args->queueId, args->nextStartOffsetInDw); gpu.waitForIdle(); @@ -471,7 +471,7 @@ orbis::ErrorCode GcDevice::open(rx::Ref *file, const char *path, } void GcDevice::addClient(orbis::Process *process) { - auto dce = orbis::g_context.dceDevice.rawStaticCast(); + auto dce = orbis::g_context->dceDevice.rawStaticCast(); dce->initializeProcess(process); std::lock_guard lock(mtx); diff --git a/rpcsx/iodev/hid.cpp b/rpcsx/iodev/hid.cpp index 149a0812a..50283c19d 100644 --- a/rpcsx/iodev/hid.cpp +++ b/rpcsx/iodev/hid.cpp @@ -35,7 +35,7 @@ static orbis::ErrorCode hid_ioctl(orbis::File *file, std::uint64_t request, return {}; case 0x8004486e: - if (orbis::g_context.fwType != orbis::FwType::Ps5) { + if (orbis::g_context->fwType != orbis::FwType::Ps5) { return orbis::ErrorCode::INVAL; } @@ -48,7 +48,7 @@ static orbis::ErrorCode hid_ioctl(orbis::File *file, std::uint64_t request, return {}; case 0xc0484851: { - if (orbis::g_context.fwType != orbis::FwType::Ps5) { + if (orbis::g_context->fwType != orbis::FwType::Ps5) { return orbis::ErrorCode::INVAL; } @@ -78,7 +78,7 @@ static orbis::ErrorCode hid_ioctl(orbis::File *file, std::uint64_t request, thread->where(); if (args->op == 6) { - if (auto gpu = amdgpu::DeviceCtl{orbis::g_context.gpuDevice}) { + if (auto gpu = amdgpu::DeviceCtl{orbis::g_context->gpuDevice}) { *args->result = 1; *args->status = 1; @@ -106,7 +106,7 @@ static orbis::ErrorCode hid_ioctl(orbis::File *file, std::uint64_t request, // ORBIS_LOG_ERROR("hid read state", args.hidId, args.unk0, args.state, // args.unk2, args.connected, args.unk4, args.unk5); - if (auto gpu = amdgpu::DeviceCtl{orbis::g_context.gpuDevice}) { + if (auto gpu = amdgpu::DeviceCtl{orbis::g_context->gpuDevice}) { *args.state = gpu.getContext().kbPadState; *args.connected = 1; *args.unk4 = 1; // is wireless? @@ -130,7 +130,7 @@ static orbis::ErrorCode hid_ioctl(orbis::File *file, std::uint64_t request, orbis::uint padding; orbis::ptr unk5; }; - if (auto gpu = amdgpu::DeviceCtl{orbis::g_context.gpuDevice}) { + if (auto gpu = amdgpu::DeviceCtl{orbis::g_context->gpuDevice}) { auto args = *reinterpret_cast(argp); *args.state = gpu.getContext().kbPadState; thread->retval[0] = 1; diff --git a/rpcsx/ipmi.cpp b/rpcsx/ipmi.cpp index 3bc2401fa..b66d7c7e1 100644 --- a/rpcsx/ipmi.cpp +++ b/rpcsx/ipmi.cpp @@ -162,7 +162,7 @@ orbis::Semaphore *ipmi::createSemaphore(std::string_view name, uint32_t attrs, uint64_t initCount, uint64_t maxCount) { auto result = orbis::g_context - .createSemaphore(orbis::kstring(name), attrs, initCount, maxCount) + ->createSemaphore(orbis::kstring(name), attrs, initCount, maxCount) .first; std::memcpy(result->name, name.data(), name.size()); result->name[name.size()] = 0; @@ -172,14 +172,14 @@ orbis::Semaphore *ipmi::createSemaphore(std::string_view name, uint32_t attrs, orbis::EventFlag *ipmi::createEventFlag(std::string_view name, uint32_t attrs, uint64_t initPattern) { return orbis::g_context - .createEventFlag(orbis::kstring(name), attrs, initPattern) + ->createEventFlag(orbis::kstring(name), attrs, initPattern) .first; } void ipmi::createShm(const char *name, uint32_t flags, uint32_t mode, uint64_t size) { rx::Ref shm; - auto shmDevice = orbis::g_context.shmDevice.staticCast(); + auto shmDevice = orbis::g_context->shmDevice.staticCast(); shmDevice->open(&shm, name, flags, mode, nullptr); shm->ops->truncate(shm.get(), size, nullptr); } @@ -357,11 +357,11 @@ ipmi::IpmiServer &ipmi::createIpmiServer(orbis::Process *process, if ((packet.info.type & ~0x8010) == 0x41) { auto msgHeader = std::bit_cast( packet.message.data()); - auto process = orbis::g_context.findProcessById(msgHeader->pid); + auto process = orbis::g_context->findProcessById(msgHeader->pid); if (process == nullptr) { continue; } - auto client = orbis::g_context.ipmiMap.get(packet.info.clientKid) + auto client = orbis::g_context->ipmiMap.get(packet.info.clientKid) .cast(); if (client == nullptr) { continue; @@ -378,11 +378,11 @@ ipmi::IpmiServer &ipmi::createIpmiServer(orbis::Process *process, if ((packet.info.type & ~0x10) == 0x43) { auto msgHeader = (orbis::IpmiAsyncMessageHeader *)packet.message.data(); - auto process = orbis::g_context.findProcessById(msgHeader->pid); + auto process = orbis::g_context->findProcessById(msgHeader->pid); if (process == nullptr) { continue; } - auto client = orbis::g_context.ipmiMap.get(packet.info.clientKid) + auto client = orbis::g_context->ipmiMap.get(packet.info.clientKid) .cast(); if (client == nullptr) { continue; @@ -448,7 +448,7 @@ void ipmi::createAudioSystemObjects(orbis::Process *process) { std::snprintf(buffer, sizeof(buffer), "sceAudioOutMix%x", args.threadId); auto [eventFlag, inserted] = - orbis::g_context.createEventFlag(buffer, 0x100, 0); + orbis::g_context->createEventFlag(buffer, 0x100, 0); if (!inserted) { return 17; // FIXME: verify @@ -571,10 +571,10 @@ void ipmi::createShellCoreObjects(orbis::Process *process) { createIpmiServer(process, "SceLoginMgrServer"); int lnsStatusServer; - if (orbis::g_context.fwType == orbis::FwType::Ps5) { + if (orbis::g_context->fwType == orbis::FwType::Ps5) { lnsStatusServer = 0x30010; } else { - if (orbis::g_context.fwSdkVersion > 0x6000000) { + if (orbis::g_context->fwSdkVersion > 0x6000000) { lnsStatusServer = 0x30013; } else { lnsStatusServer = 0x30010; @@ -603,12 +603,12 @@ void ipmi::createShellCoreObjects(orbis::Process *process) { return 0; }) .addSyncMethodStub( - orbis::g_context.fwSdkVersion > 0x6000000 ? 0x30033 : 0x3002e, + orbis::g_context->fwSdkVersion > 0x6000000 ? 0x30033 : 0x3002e, []() -> std::int32_t { - auto commonDialog = std::get<0>(orbis::g_context.dialogs.front()); + auto commonDialog = std::get<0>(orbis::g_context->dialogs.front()); auto currentDialogId = *reinterpret_cast(commonDialog + 4); - auto currentDialog = std::get<0>(orbis::g_context.dialogs.back()); + auto currentDialog = std::get<0>(orbis::g_context->dialogs.back()); if (currentDialogId == 5) { std::int32_t titleSize = 8192; std::int32_t buttonNameSize = 64; @@ -640,7 +640,7 @@ void ipmi::createShellCoreObjects(orbis::Process *process) { return 0; }) .addSyncMethod( - orbis::g_context.fwSdkVersion > 0x6000000 ? 0x30044 : 0x3003f, + orbis::g_context->fwSdkVersion > 0x6000000 ? 0x30044 : 0x3003f, [=](std::vector>, const std::vector> &inData) -> std::int32_t { struct InitDialogArgs { @@ -673,23 +673,23 @@ void ipmi::createShellCoreObjects(orbis::Process *process) { perror("mmap"); std::abort(); } - orbis::g_context.dialogs.emplace_back(shmAddress, - controlStat.st_size); + orbis::g_context->dialogs.emplace_back(shmAddress, + controlStat.st_size); return 0; }) .addSyncMethod( - orbis::g_context.fwSdkVersion > 0x6000000 ? 0x30045 : 0x30040, + orbis::g_context->fwSdkVersion > 0x6000000 ? 0x30045 : 0x30040, [=](std::vector>, const std::vector> &inData) -> std::int32_t { - if (!orbis::g_context.dialogs.empty()) { + if (!orbis::g_context->dialogs.empty()) { auto currentDialogAddr = - std::get<0>(orbis::g_context.dialogs.back()); + std::get<0>(orbis::g_context->dialogs.back()); auto currentDialogSize = - std::get<1>(orbis::g_context.dialogs.back()); + std::get<1>(orbis::g_context->dialogs.back()); ORBIS_LOG_TODO("Unmap shm after unlinking", currentDialogAddr, currentDialogSize); rx::mem::unmap(currentDialogAddr, currentDialogSize); - orbis::g_context.dialogs.pop_back(); + orbis::g_context->dialogs.pop_back(); } return 0; }); @@ -706,7 +706,7 @@ void ipmi::createShellCoreObjects(orbis::Process *process) { } std::strncpy((char *)out, result.data(), result.size() + 1); size = result.size() + 1; - orbis::g_context.createEventFlag(orbis::kstring(result), 0x200, 0); + orbis::g_context->createEventFlag(orbis::kstring(result), 0x200, 0); return 0; }) .addSyncMethodStub(0xd); @@ -977,8 +977,8 @@ void ipmi::createShellCoreObjects(orbis::Process *process) { std::strncpy((char *)outData[0].data(), result.data(), result.size() + 1); outData[0].resize(result.size() + 1); - orbis::g_context.createEventFlag(orbis::kstring(result), 0x200, - 0); + orbis::g_context->createEventFlag(orbis::kstring(result), 0x200, + 0); outData[1] = toBytes(0); return 0; diff --git a/rpcsx/main.cpp b/rpcsx/main.cpp index 84de7eaed..0a2f06c98 100644 --- a/rpcsx/main.cpp +++ b/rpcsx/main.cpp @@ -26,8 +26,10 @@ #include #include -#include + +#include #include +#include #include #include #include @@ -80,7 +82,7 @@ handle_signal(int sig, siginfo_t *info, void *ucontext) { prot |= PROT_EXEC; } - auto gpuDevice = amdgpu::DeviceCtl{orbis::g_context.gpuDevice}; + auto gpuDevice = amdgpu::DeviceCtl{orbis::g_context->gpuDevice}; if (gpuDevice && (prot & (isWrite ? PROT_WRITE : PROT_READ)) != 0) { auto &gpuContext = gpuDevice.getContext(); @@ -357,10 +359,10 @@ static void onSysExit(orbis::Thread *thread, int id, uint64_t *args, static void guestInitDev() { auto dmem1 = createDmemCharacterDevice(1); - orbis::g_context.dmemDevice = dmem1; + orbis::g_context->dmemDevice = dmem1; auto dce = createDceCharacterDevice(); - orbis::g_context.dceDevice = dce; + orbis::g_context->dceDevice = dce; auto ttyFd = ::open("tty.txt", O_CREAT | O_TRUNC | O_WRONLY, 0666); auto consoleDev = createConsoleCharacterDevice(STDIN_FILENO, ttyFd); @@ -464,7 +466,7 @@ static void guestInitDev() { vfs::addDevice("cayman/reg", createCaymanRegCharacterDevice()); vfs::addDevice("hctrl", createHidCharacterDevice()); - if (orbis::g_context.fwType == orbis::FwType::Ps5) { + if (orbis::g_context->fwType == orbis::FwType::Ps5) { vfs::addDevice("iccnvs4", createIccPowerCharacterDevice()); vfs::addDevice("ajmi", createAjmCharacterDevice()); vfs::addDevice("ssd0", createHddCharacterDevice(0x100000000)); @@ -515,8 +517,8 @@ static void guestInitDev() { }); auto shm = createShmDevice(); - orbis::g_context.shmDevice = shm; - orbis::g_context.blockpoolDevice = createBlockPoolDevice(); + orbis::g_context->shmDevice = shm; + orbis::g_context->blockpoolDevice = createBlockPoolDevice(); } static void guestInitFd(orbis::Thread *mainThread) { @@ -533,8 +535,8 @@ static void guestInitFd(orbis::Thread *mainThread) { } static orbis::Process *createGuestProcess() { - auto pid = orbis::g_context.allocatePid() * 10000 + 1; - return orbis::g_context.createProcess(pid); + auto pid = orbis::g_context->allocatePid() * 10000 + 1; + return orbis::g_context->createProcess(pid); } static orbis::Thread *createGuestThread() { @@ -590,7 +592,7 @@ int guestExec(orbis::Thread *mainThread, ExecEnv execEnv, mainThread->tproc->type = orbis::ProcessType::Ps5; mainThread->tproc->sysent = &orbis::ps5_sysvec; } else { - if (orbis::g_context.fwType == orbis::FwType::Ps4) { + if (orbis::g_context->fwType == orbis::FwType::Ps4) { mainThread->tproc->sysent = &orbis::ps4_sysvec; } else { mainThread->tproc->sysent = &orbis::ps5_sysvec; @@ -670,11 +672,11 @@ ExecEnv guestCreateExecEnv(orbis::Thread *mainThread, mainThread->tproc->sdkVersion = processParam->sdkVersion; } - if (orbis::g_context.sdkVersion == 0 && mainThread->tproc->sdkVersion != 0) { - orbis::g_context.sdkVersion = mainThread->tproc->sdkVersion; + if (orbis::g_context->sdkVersion == 0 && mainThread->tproc->sdkVersion != 0) { + orbis::g_context->sdkVersion = mainThread->tproc->sdkVersion; } if (mainThread->tproc->sdkVersion == 0) { - mainThread->tproc->sdkVersion = orbis::g_context.sdkVersion; + mainThread->tproc->sdkVersion = orbis::g_context->sdkVersion; } if (executableModule->dynType == orbis::DynType::None) { @@ -713,7 +715,7 @@ ExecEnv guestCreateExecEnv(orbis::Thread *mainThread, std::abort(); } - if (orbis::g_context.fwType == orbis::FwType::Ps4) { + if (orbis::g_context->fwType == orbis::FwType::Ps4) { for (auto sym : libkernel->symbols) { if (sym.id == 0xd2f4e7e480cc53d0) { auto address = (uint64_t)libkernel->base + sym.address; @@ -736,20 +738,20 @@ ExecEnv guestCreateExecEnv(orbis::Thread *mainThread, } } - if (orbis::g_context.fwSdkVersion == 0) { + if (orbis::g_context->fwSdkVersion == 0) { auto moduleParam = reinterpret_cast(libkernel->moduleParam); auto fwSdkVersion = moduleParam // + sizeof(uint64_t) // size + sizeof(uint64_t); // magic - orbis::g_context.fwSdkVersion = *(uint32_t *)fwSdkVersion; - std::printf("fw sdk version: %x\n", orbis::g_context.fwSdkVersion); + orbis::g_context->fwSdkVersion = *(uint32_t *)fwSdkVersion; + std::printf("fw sdk version: %x\n", orbis::g_context->fwSdkVersion); } - if (orbis::g_context.fwType == orbis::FwType::Unknown) { + if (orbis::g_context->fwType == orbis::FwType::Unknown) { if (libkernel->dynType == orbis::DynType::Ps4) { - orbis::g_context.fwType = orbis::FwType::Ps4; + orbis::g_context->fwType = orbis::FwType::Ps4; } else { - orbis::g_context.fwType = orbis::FwType::Ps5; + orbis::g_context->fwType = orbis::FwType::Ps5; } } @@ -787,7 +789,7 @@ static orbis::SysResult launchDaemon(orbis::Thread *thread, std::string path, std::vector argv, std::vector envv, orbis::AppInfoEx appInfo) { - auto childPid = orbis::g_context.allocatePid() * 10000 + 1; + auto childPid = orbis::g_context->allocatePid() * 10000 + 1; auto flag = orbis::knew>(); *flag = false; @@ -803,7 +805,7 @@ static orbis::SysResult launchDaemon(orbis::Thread *thread, std::string path, return {}; } - auto process = orbis::g_context.createProcess(childPid); + auto process = orbis::g_context->createProcess(childPid); auto logFd = ::open(("log-" + std::to_string(childPid) + ".txt").c_str(), O_CREAT | O_TRUNC | O_WRONLY, 0666); @@ -918,14 +920,14 @@ int main(int argc, const char *argv[]) { return 1; } - orbis::g_context.deviceEventEmitter = orbis::knew(); - bool enableAudioIpmi = false; bool asRoot = false; bool isSystem = false; bool isSafeMode = false; int argIndex = 1; + orbis::initializeAllocator(); + while (argIndex < argc) { if (argv[argIndex] == std::string_view("--mount") || argv[argIndex] == std::string_view("-m")) { @@ -1041,9 +1043,10 @@ int main(int argc, const char *argv[]) { } setupSigHandlers(); + orbis::constructAllGlobals(); + orbis::g_context->deviceEventEmitter = orbis::knew(); rx::startWatchdog(); - rx::createGpuDevice(); vfs::initialize(); @@ -1057,8 +1060,8 @@ int main(int argc, const char *argv[]) { rx::thread::initialize(); // vm::printHostStats(); - orbis::g_context.allocatePid(); - auto initProcess = orbis::g_context.createProcess(asRoot ? 1 : 10); + orbis::g_context->allocatePid(); + auto initProcess = orbis::g_context->createProcess(asRoot ? 1 : 10); // pthread_setname_np(pthread_self(), "10.MAINTHREAD"); int status = 0; @@ -1149,20 +1152,20 @@ int main(int argc, const char *argv[]) { vm::initialize(initProcess->pid); - auto bigAppBudget = orbis::g_context.createProcessTypeBudget( + auto bigAppBudget = orbis::g_context->createProcessTypeBudget( orbis::Budget::ProcessType::BigApp, "big app budget", bigAppBudgetInfo); // FIXME: define following budgets - orbis::g_context.createProcessTypeBudget(orbis::Budget::ProcessType::MiniApp, - "mini-app budget", bigAppBudgetInfo); - orbis::g_context.createProcessTypeBudget(orbis::Budget::ProcessType::System, - "system budget", bigAppBudgetInfo); - orbis::g_context.createProcessTypeBudget( + orbis::g_context->createProcessTypeBudget( + orbis::Budget::ProcessType::MiniApp, "mini-app budget", bigAppBudgetInfo); + orbis::g_context->createProcessTypeBudget(orbis::Budget::ProcessType::System, + "system budget", bigAppBudgetInfo); + orbis::g_context->createProcessTypeBudget( orbis::Budget::ProcessType::NonGameMiniApp, "non-game mini-app budget", bigAppBudgetInfo); if (isSystem) { - orbis::g_context.safeMode = isSafeMode ? 1 : 0; + orbis::g_context->safeMode = isSafeMode ? 1 : 0; initProcess->authInfo = {.unk0 = 0x380000000000000f, .caps = { @@ -1209,7 +1212,7 @@ int main(int argc, const char *argv[]) { }; initProcess->budgetProcessType = orbis::Budget::ProcessType::BigApp; - initProcess->budgetId = orbis::g_context.budgets.insert(bigAppBudget); + initProcess->budgetId = orbis::g_context->budgets.insert(bigAppBudget); initProcess->isInSandbox = true; } @@ -1259,55 +1262,53 @@ int main(int argc, const char *argv[]) { auto execEnv = guestCreateExecEnv(mainThread, executableModule, isSystem); if (isSystem && executableModule->dynType == orbis::DynType::None) { - orbis::g_context.fwType = orbis::FwType::Ps5; + orbis::g_context->fwType = orbis::FwType::Ps5; executableModule->dynType = orbis::DynType::Ps5; } guestInitDev(); guestInitFd(mainThread); - orbis::constructAllGlobals(); - // data transfer mode // 0 - normal // 1 - source // 2 - ? - orbis::g_context.regMgrInt[0x2110000] = 0; + orbis::g_context->regMgrInt[0x2110000] = 0; - orbis::g_context.regMgrInt[0x20b0000] = 1; // prefer X - orbis::g_context.regMgrInt[0x2020000] = 1; // region + orbis::g_context->regMgrInt[0x20b0000] = 1; // prefer X + orbis::g_context->regMgrInt[0x2020000] = 1; // region - // orbis::g_context.regMgrInt[0x2130000] = 0x1601; - orbis::g_context.regMgrInt[0x2130000] = 0; - orbis::g_context.regMgrInt[0x73800200] = 1; - orbis::g_context.regMgrInt[0x73800300] = 0; - orbis::g_context.regMgrInt[0x73800400] = 0; - orbis::g_context.regMgrInt[0x73800500] = 0; // enable log + // orbis::g_context->regMgrInt[0x2130000] = 0x1601; + orbis::g_context->regMgrInt[0x2130000] = 0; + orbis::g_context->regMgrInt[0x73800200] = 1; + orbis::g_context->regMgrInt[0x73800300] = 0; + orbis::g_context->regMgrInt[0x73800400] = 0; + orbis::g_context->regMgrInt[0x73800500] = 0; // enable log // user settings - orbis::g_context.regMgrInt[0x7800100] = 0; - orbis::g_context.regMgrInt[0x7810100] = 0; - orbis::g_context.regMgrInt[0x7820100] = 0; - orbis::g_context.regMgrInt[0x7830100] = 0; - orbis::g_context.regMgrInt[0x7840100] = 0; - orbis::g_context.regMgrInt[0x7850100] = 0; - orbis::g_context.regMgrInt[0x7860100] = 0; - orbis::g_context.regMgrInt[0x7870100] = 0; - orbis::g_context.regMgrInt[0x7880100] = 0; - orbis::g_context.regMgrInt[0x7890100] = 0; - orbis::g_context.regMgrInt[0x78a0100] = 0; - orbis::g_context.regMgrInt[0x78b0100] = 0; - orbis::g_context.regMgrInt[0x78c0100] = 0; - orbis::g_context.regMgrInt[0x78d0100] = 0; - orbis::g_context.regMgrInt[0x78e0100] = 0; - orbis::g_context.regMgrInt[0x78f0100] = 0; + orbis::g_context->regMgrInt[0x7800100] = 0; + orbis::g_context->regMgrInt[0x7810100] = 0; + orbis::g_context->regMgrInt[0x7820100] = 0; + orbis::g_context->regMgrInt[0x7830100] = 0; + orbis::g_context->regMgrInt[0x7840100] = 0; + orbis::g_context->regMgrInt[0x7850100] = 0; + orbis::g_context->regMgrInt[0x7860100] = 0; + orbis::g_context->regMgrInt[0x7870100] = 0; + orbis::g_context->regMgrInt[0x7880100] = 0; + orbis::g_context->regMgrInt[0x7890100] = 0; + orbis::g_context->regMgrInt[0x78a0100] = 0; + orbis::g_context->regMgrInt[0x78b0100] = 0; + orbis::g_context->regMgrInt[0x78c0100] = 0; + orbis::g_context->regMgrInt[0x78d0100] = 0; + orbis::g_context->regMgrInt[0x78e0100] = 0; + orbis::g_context->regMgrInt[0x78f0100] = 0; - orbis::g_context.regMgrInt[0x2040000] = 0; // do not require initial setup - orbis::g_context.regMgrInt[0x2800600] = 0; // IDU version - orbis::g_context.regMgrInt[0x2860100] = 0; // IDU mode - orbis::g_context.regMgrInt[0x2860300] = 0; // Arcade mode - orbis::g_context.regMgrInt[0x7010000] = 0; // auto login - orbis::g_context.regMgrInt[0x9010000] = 0; // video out color effect + orbis::g_context->regMgrInt[0x2040000] = 0; // do not require initial setup + orbis::g_context->regMgrInt[0x2800600] = 0; // IDU version + orbis::g_context->regMgrInt[0x2860100] = 0; // IDU mode + orbis::g_context->regMgrInt[0x2860300] = 0; // Arcade mode + orbis::g_context->regMgrInt[0x7010000] = 0; // auto login + orbis::g_context->regMgrInt[0x9010000] = 0; // video out color effect if (!isSystem) { ipmi::createMiniSysCoreObjects(initProcess); @@ -1342,8 +1343,8 @@ int main(int argc, const char *argv[]) { }}); // confirmed to work and known method of initialization since 5.05 // version - if (orbis::g_context.fwType != orbis::FwType::Ps5 && - orbis::g_context.fwSdkVersion >= 0x5050000) { + if (orbis::g_context->fwType != orbis::FwType::Ps5 && + orbis::g_context->fwSdkVersion >= 0x5050000) { auto fakeIpmiThread = createGuestThread(); ipmi::audioIpmiClient = ipmi::createIpmiClient(fakeIpmiThread, "SceSysAudioSystemIpc"); @@ -1370,7 +1371,7 @@ int main(int argc, const char *argv[]) { int32_t unk8 = 0x2; char unk9[24]{0}; } data2; - std::uint32_t method = orbis::g_context.fwSdkVersion >= 0x8000000 + std::uint32_t method = orbis::g_context->fwSdkVersion >= 0x8000000 ? 0x1234002c : 0x1234002b; ipmi::audioIpmiClient.sendSyncMessage(method, data1, data2); @@ -1378,7 +1379,7 @@ int main(int argc, const char *argv[]) { } } - if (orbis::g_context.fwType == orbis::FwType::Ps5 && !isSystem) { + if (orbis::g_context->fwType == orbis::FwType::Ps5 && !isSystem) { ipmi::createIpmiServer(initProcess, "SceShareLibIpmiService"); ipmi::createIpmiServer(initProcess, "SceSysAvControlIpc"); ipmi::createShm("SceAvControl", 0xa02, 0x1a4, 4096); diff --git a/rpcsx/ops.cpp b/rpcsx/ops.cpp index d7a26ed61..f563c6cb2 100644 --- a/rpcsx/ops.cpp +++ b/rpcsx/ops.cpp @@ -214,7 +214,7 @@ orbis::SysResult dmem_mmap(orbis::Thread *thread, orbis::caddr_t addr, orbis::size_t len, orbis::sint memoryType, orbis::sint prot, sint flags, orbis::off_t directMemoryStart) { - auto dmem = static_cast(orbis::g_context.dmemDevice.get()); + auto dmem = static_cast(orbis::g_context->dmemDevice.get()); void *address = addr; auto result = dmem->mmap(&address, len, prot, flags, directMemoryStart); if (result != ErrorCode{}) { @@ -303,7 +303,7 @@ orbis::SysResult open(orbis::Thread *thread, orbis::ptr path, orbis::SysResult shm_open(orbis::Thread *thread, const char *path, orbis::sint flags, orbis::sint mode, rx::Ref *file) { - auto dev = static_cast(orbis::g_context.shmDevice.get()); + auto dev = static_cast(orbis::g_context->shmDevice.get()); return dev->open(file, path, flags, mode, thread); } orbis::SysResult unlink(orbis::Thread *thread, orbis::ptr path) { @@ -326,7 +326,7 @@ orbis::SysResult rename(Thread *thread, ptr from, orbis::SysResult blockpool_open(orbis::Thread *thread, rx::Ref *file) { - auto dev = static_cast(orbis::g_context.blockpoolDevice.get()); + auto dev = static_cast(orbis::g_context->blockpoolDevice.get()); return dev->open(file, nullptr, 0, 0, thread); } @@ -334,7 +334,7 @@ orbis::SysResult blockpool_map(orbis::Thread *thread, orbis::caddr_t addr, orbis::size_t len, orbis::sint prot, orbis::sint flags) { auto blockpool = - static_cast(orbis::g_context.blockpoolDevice.get()); + static_cast(orbis::g_context->blockpoolDevice.get()); void *address = addr; auto result = blockpool->map(&address, len, prot, flags, thread); if (result != ErrorCode{}) { @@ -347,7 +347,7 @@ orbis::SysResult blockpool_map(orbis::Thread *thread, orbis::caddr_t addr, orbis::SysResult blockpool_unmap(orbis::Thread *thread, orbis::caddr_t addr, orbis::size_t len) { auto blockpool = - static_cast(orbis::g_context.blockpoolDevice.get()); + static_cast(orbis::g_context->blockpoolDevice.get()); return blockpool->unmap(addr, len, thread); } @@ -379,7 +379,7 @@ orbis::SysResult socketPair(orbis::Thread *thread, orbis::sint domain, } orbis::SysResult shm_unlink(orbis::Thread *thread, const char *path) { - auto dev = static_cast(orbis::g_context.shmDevice.get()); + auto dev = static_cast(orbis::g_context->shmDevice.get()); return dev->unlink(path, false, thread); } @@ -760,7 +760,7 @@ SysResult processNeeded(Thread *thread) { } SysResult fork(Thread *thread, slong flags) { - auto childPid = g_context.allocatePid() * 10000 + 1; + auto childPid = g_context->allocatePid() * 10000 + 1; ORBIS_LOG_TODO(__FUNCTION__, flags, childPid, thread->tid); thread->where(); auto flag = knew>(); @@ -783,7 +783,7 @@ SysResult fork(Thread *thread, slong flags) { return {}; } - auto process = g_context.createProcess(childPid); + auto process = g_context->createProcess(childPid); process->hostPid = ::getpid(); process->sysent = thread->tproc->sysent; process->onSysEnter = thread->tproc->onSysEnter; diff --git a/rpcsx/vm.cpp b/rpcsx/vm.cpp index 5ce577008..d201e68d3 100644 --- a/rpcsx/vm.cpp +++ b/rpcsx/vm.cpp @@ -970,8 +970,8 @@ void *vm::map(void *addr, std::uint64_t len, std::int32_t prot, } if (auto thr = orbis::g_currentThread) { - std::lock_guard lock(orbis::g_context.gpuDeviceMtx); - if (auto gpu = amdgpu::DeviceCtl{orbis::g_context.gpuDevice}) { + std::lock_guard lock(orbis::g_context->gpuDeviceMtx); + if (auto gpu = amdgpu::DeviceCtl{orbis::g_context->gpuDevice}) { gpu.submitMapMemory(thr->tproc->pid, address, len, -1, -1, prot, address - kMinAddress); } @@ -1027,7 +1027,7 @@ bool vm::unmap(void *addr, std::uint64_t size) { gBlocks[(address >> kBlockShift) - kFirstBlock].removeFlags( (address & kBlockMask) >> kPageShift, pages, ~0); if (auto thr = orbis::g_currentThread) { - if (auto gpu = amdgpu::DeviceCtl{orbis::g_context.gpuDevice}) { + if (auto gpu = amdgpu::DeviceCtl{orbis::g_context->gpuDevice}) { gpu.submitUnmapMemory(thr->tproc->pid, address, size); } } else { @@ -1072,7 +1072,7 @@ bool vm::protect(void *addr, std::uint64_t size, std::int32_t prot) { if (auto thr = orbis::g_currentThread) { std::println("memory prot: {:x}", prot); - if (auto gpu = amdgpu::DeviceCtl{orbis::g_context.gpuDevice}) { + if (auto gpu = amdgpu::DeviceCtl{orbis::g_context->gpuDevice}) { gpu.submitProtectMemory(thr->tproc->pid, address, size, prot); } } else if (prot >> 4) {