mirror of
https://git.eden-emu.dev/eden-emu/eden
synced 2026-04-20 06:08:56 +02:00
[common, core] remove uneeded memory indirection overhead at startup (#3306)
for core stuff: just remove unique ptrs that dont need any pointer stability at all (afterall its an allocation within an allocation so yeah) for fibers: Main reasoning behind this is because virtualBuffer<> is stupidly fucking expensive and it also clutters my fstat view ALSO mmap is a syscall, syscalls are bad for performance or whatever ALSO std::vector<> is better suited for handling this kind of "fixed size thing where its like big but not THAT big" (512 KiB isn't going to kill your memory usage for each fiber...) for core.cpp stuff - inlines stuff into std::optional<> as opposed to std::unique_ptr<> (because yknow, we are making the Impl from an unique_ptr, allocating within an allocation is unnecessary) - reorganizes the structures a bit so padding doesnt screw us up (it's not perfect but eh saves a measly 44 bytes) - removes unused/dead code - uses std::vector<> instead of std::deque<> no perf impact expected, maybe some initialisation boost but very minimal impact nonethless lto gets rid of most calls anyways - the heavy issue is with shared_ptr and the cache coherency from the atomics... but i clumped them together because well, they kinda do not suffer from cache coherency - hopefully not a mistake this balloons the size of Impl to about 1.67 MB - which is fine because we throw it in the stack anyways REST OF INTERFACES: most of them ballooned in size as well, but overhead is ok since its an allocation within an alloc, no stack is used (when it comes to storing these i mean) Signed-off-by: lizzie lizzie@eden-emu.dev Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3306 Reviewed-by: CamilleLaVey <camillelavey99@gmail.com> Reviewed-by: MaranBr <maranbr@eden-emu.dev> Co-authored-by: lizzie <lizzie@eden-emu.dev> Co-committed-by: lizzie <lizzie@eden-emu.dev>
This commit is contained in:
lizzie
crueter
parent
5768600c8b
commit
83a28dc251
40 changed files with 2602 additions and 2963 deletions
|
|
@ -1148,9 +1148,17 @@ Result KProcess::GetThreadList(s32* out_num_threads, KProcessAddress out_thread_
|
|||
void KProcess::Switch(KProcess* cur_process, KProcess* next_process) {}
|
||||
|
||||
KProcess::KProcess(KernelCore& kernel)
|
||||
: KAutoObjectWithSlabHeapAndContainer(kernel), m_page_table{kernel}, m_state_lock{kernel},
|
||||
m_list_lock{kernel}, m_cond_var{kernel.System()}, m_address_arbiter{kernel.System()},
|
||||
m_handle_table{kernel}, m_exclusive_monitor{}, m_memory{kernel.System()} {}
|
||||
: KAutoObjectWithSlabHeapAndContainer(kernel)
|
||||
, m_exclusive_monitor{}
|
||||
, m_memory{kernel.System()}
|
||||
, m_handle_table{kernel}
|
||||
, m_page_table{kernel}
|
||||
, m_state_lock{kernel}
|
||||
, m_list_lock{kernel}
|
||||
, m_cond_var{kernel.System()}
|
||||
, m_address_arbiter{kernel.System()}
|
||||
{}
|
||||
|
||||
KProcess::~KProcess() = default;
|
||||
|
||||
Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std::size_t code_size,
|
||||
|
|
|
|||
|
|
@ -66,60 +66,55 @@ public:
|
|||
|
||||
private:
|
||||
using SharedMemoryInfoList = Common::IntrusiveListBaseTraits<KSharedMemoryInfo>::ListType;
|
||||
using TLPTree =
|
||||
Common::IntrusiveRedBlackTreeBaseTraits<KThreadLocalPage>::TreeType<KThreadLocalPage>;
|
||||
using TLPTree = Common::IntrusiveRedBlackTreeBaseTraits<KThreadLocalPage>::TreeType<KThreadLocalPage>;
|
||||
using TLPIterator = TLPTree::iterator;
|
||||
|
||||
private:
|
||||
KProcessPageTable m_page_table;
|
||||
std::atomic<size_t> m_used_kernel_memory_size{};
|
||||
TLPTree m_fully_used_tlp_tree{};
|
||||
TLPTree m_partially_used_tlp_tree{};
|
||||
s32 m_ideal_core_id{};
|
||||
KResourceLimit* m_resource_limit{};
|
||||
KSystemResource* m_system_resource{};
|
||||
size_t m_memory_release_hint{};
|
||||
State m_state{};
|
||||
KLightLock m_state_lock;
|
||||
KLightLock m_list_lock;
|
||||
KConditionVariable m_cond_var;
|
||||
KAddressArbiter m_address_arbiter;
|
||||
std::array<u64, 4> m_entropy{};
|
||||
bool m_is_signaled{};
|
||||
bool m_is_initialized{};
|
||||
u32 m_pointer_buffer_size = 0x8000; // Default pointer buffer size (can be game-specific later)
|
||||
bool m_is_application{};
|
||||
bool m_is_default_application_system_resource{};
|
||||
bool m_is_hbl{};
|
||||
std::array<char, 13> m_name{};
|
||||
std::atomic<u16> m_num_running_threads{};
|
||||
Svc::CreateProcessFlag m_flags{};
|
||||
KMemoryManager::Pool m_memory_pool{};
|
||||
s64 m_schedule_count{};
|
||||
KCapabilities m_capabilities{};
|
||||
u64 m_program_id{};
|
||||
u64 m_process_id{};
|
||||
KProcessAddress m_code_address{};
|
||||
size_t m_code_size{};
|
||||
size_t m_main_thread_stack_size{};
|
||||
size_t m_max_process_memory{};
|
||||
u32 m_version{};
|
||||
KHandleTable m_handle_table;
|
||||
KProcessAddress m_plr_address{};
|
||||
KThread* m_exception_thread{};
|
||||
ThreadList m_thread_list{};
|
||||
SharedMemoryInfoList m_shared_memory_list{};
|
||||
bool m_is_suspended{};
|
||||
bool m_is_immortal{};
|
||||
bool m_is_handle_table_initialized{};
|
||||
std::array<std::unique_ptr<Core::ArmInterface>, Core::Hardware::NUM_CPU_CORES>
|
||||
m_arm_interfaces{};
|
||||
std::array<std::unique_ptr<Core::ArmInterface>, Core::Hardware::NUM_CPU_CORES> m_arm_interfaces{};
|
||||
std::array<KThread*, Core::Hardware::NUM_CPU_CORES> m_running_threads{};
|
||||
std::array<u64, Core::Hardware::NUM_CPU_CORES> m_running_thread_idle_counts{};
|
||||
std::array<u64, Core::Hardware::NUM_CPU_CORES> m_running_thread_switch_counts{};
|
||||
std::array<KThread*, Core::Hardware::NUM_CPU_CORES> m_pinned_threads{};
|
||||
std::array<DebugWatchpoint, Core::Hardware::NUM_WATCHPOINTS> m_watchpoints{};
|
||||
std::map<KProcessAddress, u64> m_debug_page_refcounts{};
|
||||
#ifdef HAS_NCE
|
||||
std::unordered_map<u64, u64> m_post_handlers{};
|
||||
#endif
|
||||
std::unique_ptr<Core::ExclusiveMonitor> m_exclusive_monitor;
|
||||
Core::Memory::Memory m_memory;
|
||||
KCapabilities m_capabilities{};
|
||||
KProcessAddress m_code_address{};
|
||||
KHandleTable m_handle_table;
|
||||
KProcessAddress m_plr_address{};
|
||||
ThreadList m_thread_list{};
|
||||
SharedMemoryInfoList m_shared_memory_list{};
|
||||
KProcessPageTable m_page_table;
|
||||
std::atomic<size_t> m_used_kernel_memory_size{};
|
||||
TLPTree m_fully_used_tlp_tree{};
|
||||
TLPTree m_partially_used_tlp_tree{};
|
||||
State m_state{};
|
||||
KLightLock m_state_lock;
|
||||
KLightLock m_list_lock;
|
||||
KConditionVariable m_cond_var;
|
||||
KAddressArbiter m_address_arbiter;
|
||||
std::array<u64, 4> m_entropy{};
|
||||
u32 m_pointer_buffer_size = 0x8000; // Default pointer buffer size (can be game-specific later)
|
||||
std::array<char, 13> m_name{};
|
||||
Svc::CreateProcessFlag m_flags{};
|
||||
KMemoryManager::Pool m_memory_pool{};
|
||||
|
||||
KResourceLimit* m_resource_limit{};
|
||||
KSystemResource* m_system_resource{};
|
||||
KThread* m_exception_thread{};
|
||||
|
||||
size_t m_code_size{};
|
||||
size_t m_main_thread_stack_size{};
|
||||
size_t m_max_process_memory{};
|
||||
size_t m_memory_release_hint{};
|
||||
s64 m_schedule_count{};
|
||||
u64 m_program_id{};
|
||||
u64 m_process_id{};
|
||||
|
||||
std::atomic<s64> m_cpu_time{};
|
||||
std::atomic<s64> m_num_process_switches{};
|
||||
std::atomic<s64> m_num_thread_switches{};
|
||||
|
|
@ -128,11 +123,20 @@ private:
|
|||
std::atomic<s64> m_num_ipc_messages{};
|
||||
std::atomic<s64> m_num_ipc_replies{};
|
||||
std::atomic<s64> m_num_ipc_receives{};
|
||||
#ifdef HAS_NCE
|
||||
std::unordered_map<u64, u64> m_post_handlers{};
|
||||
#endif
|
||||
std::unique_ptr<Core::ExclusiveMonitor> m_exclusive_monitor;
|
||||
Core::Memory::Memory m_memory;
|
||||
|
||||
s32 m_ideal_core_id{};
|
||||
u32 m_version{};
|
||||
|
||||
std::atomic<u16> m_num_running_threads{};
|
||||
|
||||
bool m_is_signaled : 1 = false;
|
||||
bool m_is_initialized : 1 = false;
|
||||
bool m_is_application : 1 = false;
|
||||
bool m_is_default_application_system_resource : 1 = false;
|
||||
bool m_is_hbl : 1 = false;
|
||||
bool m_is_suspended : 1 = false;
|
||||
bool m_is_immortal : 1 = false;
|
||||
bool m_is_handle_table_initialized : 1 = false;
|
||||
|
||||
private:
|
||||
Result StartTermination();
|
||||
|
|
|
|||
|
|
@ -88,11 +88,11 @@ struct KernelCore::Impl {
|
|||
}
|
||||
|
||||
void Initialize(KernelCore& kernel) {
|
||||
hardware_timer = std::make_unique<Kernel::KHardwareTimer>(kernel);
|
||||
hardware_timer.emplace(kernel);
|
||||
hardware_timer->Initialize();
|
||||
|
||||
global_object_list_container = std::make_unique<KAutoObjectWithListContainer>(kernel);
|
||||
global_scheduler_context = std::make_unique<Kernel::GlobalSchedulerContext>(kernel);
|
||||
global_object_list_container.emplace(kernel);
|
||||
global_scheduler_context.emplace(kernel);
|
||||
|
||||
// Derive the initial memory layout from the emulated board
|
||||
Init::InitializeSlabResourceCounts(kernel);
|
||||
|
|
@ -212,10 +212,9 @@ struct KernelCore::Impl {
|
|||
|
||||
void InitializePhysicalCores() {
|
||||
for (u32 i = 0; i < Core::Hardware::NUM_CPU_CORES; i++) {
|
||||
const s32 core{static_cast<s32>(i)};
|
||||
|
||||
schedulers[i] = std::make_unique<Kernel::KScheduler>(system.Kernel());
|
||||
cores[i] = std::make_unique<Kernel::PhysicalCore>(system.Kernel(), i);
|
||||
auto const core = s32(i);
|
||||
schedulers[i].emplace(system.Kernel());
|
||||
cores[i].emplace(system.Kernel(), i);
|
||||
|
||||
auto* main_thread{Kernel::KThread::Create(system.Kernel())};
|
||||
main_thread->SetCurrentCore(core);
|
||||
|
|
@ -280,57 +279,56 @@ struct KernelCore::Impl {
|
|||
size -= rc_size;
|
||||
|
||||
// Initialize the resource managers' shared page manager.
|
||||
resource_manager_page_manager = std::make_unique<KDynamicPageManager>();
|
||||
resource_manager_page_manager.emplace();
|
||||
resource_manager_page_manager->Initialize(address, size, std::max<size_t>(PageSize, KPageBufferSlabHeap::BufferSize));
|
||||
|
||||
// Initialize the KPageBuffer slab heap.
|
||||
page_buffer_slab_heap.Initialize(system);
|
||||
|
||||
// Initialize the fixed-size slabheaps.
|
||||
app_memory_block_heap = std::make_unique<KMemoryBlockSlabHeap>();
|
||||
sys_memory_block_heap = std::make_unique<KMemoryBlockSlabHeap>();
|
||||
block_info_heap = std::make_unique<KBlockInfoSlabHeap>();
|
||||
app_memory_block_heap->Initialize(resource_manager_page_manager.get(), ApplicationMemoryBlockSlabHeapSize);
|
||||
sys_memory_block_heap->Initialize(resource_manager_page_manager.get(), SystemMemoryBlockSlabHeapSize);
|
||||
block_info_heap->Initialize(resource_manager_page_manager.get(), BlockInfoSlabHeapSize);
|
||||
app_memory_block_heap.emplace();
|
||||
sys_memory_block_heap.emplace();
|
||||
block_info_heap.emplace();
|
||||
app_memory_block_heap->Initialize(std::addressof(*resource_manager_page_manager), ApplicationMemoryBlockSlabHeapSize);
|
||||
sys_memory_block_heap->Initialize(std::addressof(*resource_manager_page_manager), SystemMemoryBlockSlabHeapSize);
|
||||
block_info_heap->Initialize(std::addressof(*resource_manager_page_manager), BlockInfoSlabHeapSize);
|
||||
|
||||
// Reserve all but a fixed number of remaining pages for the page table heap.
|
||||
const size_t num_pt_pages = resource_manager_page_manager->GetCount() - resource_manager_page_manager->GetUsed() - ReservedDynamicPageCount;
|
||||
page_table_heap = std::make_unique<KPageTableSlabHeap>();
|
||||
page_table_heap.emplace();
|
||||
|
||||
// TODO(bunnei): Pass in address once we support kernel virtual memory allocations.
|
||||
page_table_heap->Initialize(
|
||||
resource_manager_page_manager.get(), num_pt_pages,
|
||||
std::addressof(*resource_manager_page_manager), num_pt_pages,
|
||||
/*GetPointer<KPageTableManager::RefCount>(address + size)*/ nullptr);
|
||||
|
||||
// Setup the slab managers.
|
||||
KDynamicPageManager* const app_dynamic_page_manager = nullptr;
|
||||
KDynamicPageManager* const sys_dynamic_page_manager =
|
||||
/*KTargetSystem::IsDynamicResourceLimitsEnabled()*/ true
|
||||
? resource_manager_page_manager.get()
|
||||
: nullptr;
|
||||
app_memory_block_manager = std::make_unique<KMemoryBlockSlabManager>();
|
||||
sys_memory_block_manager = std::make_unique<KMemoryBlockSlabManager>();
|
||||
app_block_info_manager = std::make_unique<KBlockInfoManager>();
|
||||
sys_block_info_manager = std::make_unique<KBlockInfoManager>();
|
||||
app_page_table_manager = std::make_unique<KPageTableManager>();
|
||||
sys_page_table_manager = std::make_unique<KPageTableManager>();
|
||||
? std::addressof(*resource_manager_page_manager) : nullptr;
|
||||
app_memory_block_manager.emplace();
|
||||
sys_memory_block_manager.emplace();
|
||||
app_block_info_manager.emplace();
|
||||
sys_block_info_manager.emplace();
|
||||
app_page_table_manager.emplace();
|
||||
sys_page_table_manager.emplace();
|
||||
|
||||
app_memory_block_manager->Initialize(app_dynamic_page_manager, app_memory_block_heap.get());
|
||||
sys_memory_block_manager->Initialize(sys_dynamic_page_manager, sys_memory_block_heap.get());
|
||||
app_memory_block_manager->Initialize(app_dynamic_page_manager, std::addressof(*app_memory_block_heap));
|
||||
sys_memory_block_manager->Initialize(sys_dynamic_page_manager, std::addressof(*sys_memory_block_heap));
|
||||
|
||||
app_block_info_manager->Initialize(app_dynamic_page_manager, block_info_heap.get());
|
||||
sys_block_info_manager->Initialize(sys_dynamic_page_manager, block_info_heap.get());
|
||||
app_block_info_manager->Initialize(app_dynamic_page_manager, std::addressof(*block_info_heap));
|
||||
sys_block_info_manager->Initialize(sys_dynamic_page_manager, std::addressof(*block_info_heap));
|
||||
|
||||
app_page_table_manager->Initialize(app_dynamic_page_manager, page_table_heap.get());
|
||||
sys_page_table_manager->Initialize(sys_dynamic_page_manager, page_table_heap.get());
|
||||
app_page_table_manager->Initialize(app_dynamic_page_manager, std::addressof(*page_table_heap));
|
||||
sys_page_table_manager->Initialize(sys_dynamic_page_manager, std::addressof(*page_table_heap));
|
||||
|
||||
// Check that we have the correct number of dynamic pages available.
|
||||
ASSERT(resource_manager_page_manager->GetCount() - resource_manager_page_manager->GetUsed() == ReservedDynamicPageCount);
|
||||
|
||||
// Create the system page table managers.
|
||||
app_system_resource = std::make_unique<KSystemResource>(kernel);
|
||||
sys_system_resource = std::make_unique<KSystemResource>(kernel);
|
||||
app_system_resource.emplace(kernel);
|
||||
sys_system_resource.emplace(kernel);
|
||||
KAutoObject::Create(std::addressof(*app_system_resource));
|
||||
KAutoObject::Create(std::addressof(*sys_system_resource));
|
||||
|
||||
|
|
@ -349,7 +347,7 @@ struct KernelCore::Impl {
|
|||
}
|
||||
|
||||
void InitializeGlobalData(KernelCore& kernel) {
|
||||
object_name_global_data = std::make_unique<KObjectNameGlobalData>(kernel);
|
||||
object_name_global_data.emplace(kernel);
|
||||
}
|
||||
|
||||
void MakeApplicationProcess(KProcess* process) {
|
||||
|
|
@ -431,7 +429,7 @@ struct KernelCore::Impl {
|
|||
}
|
||||
|
||||
void DeriveInitialMemoryLayout() {
|
||||
memory_layout = std::make_unique<KMemoryLayout>();
|
||||
memory_layout.emplace();
|
||||
|
||||
// Insert the root region for the virtual memory tree, from which all other regions will
|
||||
// derive.
|
||||
|
|
@ -726,7 +724,7 @@ struct KernelCore::Impl {
|
|||
|
||||
void InitializeMemoryLayout() {
|
||||
// Initialize the memory manager.
|
||||
memory_manager = std::make_unique<KMemoryManager>(system);
|
||||
memory_manager.emplace(system);
|
||||
const auto& management_region = memory_layout->GetPoolManagementRegion();
|
||||
ASSERT(management_region.GetEndAddress() != 0);
|
||||
memory_manager->Initialize(management_region.GetAddress(), management_region.GetSize());
|
||||
|
|
@ -774,8 +772,8 @@ struct KernelCore::Impl {
|
|||
std::mutex process_list_lock;
|
||||
std::vector<KProcess*> process_list;
|
||||
KProcess* application_process{};
|
||||
std::unique_ptr<Kernel::GlobalSchedulerContext> global_scheduler_context;
|
||||
std::unique_ptr<Kernel::KHardwareTimer> hardware_timer;
|
||||
std::optional<Kernel::GlobalSchedulerContext> global_scheduler_context;
|
||||
std::optional<Kernel::KHardwareTimer> hardware_timer;
|
||||
|
||||
Init::KSlabResourceCounts slab_resource_counts{};
|
||||
KResourceLimit* system_resource_limit{};
|
||||
|
|
@ -784,9 +782,9 @@ struct KernelCore::Impl {
|
|||
|
||||
std::shared_ptr<Core::Timing::EventType> preemption_event;
|
||||
|
||||
std::unique_ptr<KAutoObjectWithListContainer> global_object_list_container;
|
||||
std::optional<KAutoObjectWithListContainer> global_object_list_container;
|
||||
|
||||
std::unique_ptr<KObjectNameGlobalData> object_name_global_data;
|
||||
std::optional<KObjectNameGlobalData> object_name_global_data;
|
||||
|
||||
std::unordered_set<KAutoObject*> registered_objects;
|
||||
std::unordered_set<KAutoObject*> registered_in_use_objects;
|
||||
|
|
@ -794,28 +792,28 @@ struct KernelCore::Impl {
|
|||
std::mutex server_lock;
|
||||
std::vector<std::unique_ptr<Service::ServerManager>> server_managers;
|
||||
|
||||
std::array<std::unique_ptr<Kernel::PhysicalCore>, Core::Hardware::NUM_CPU_CORES> cores;
|
||||
std::array<std::optional<Kernel::PhysicalCore>, Core::Hardware::NUM_CPU_CORES> cores;
|
||||
|
||||
// Next host thead ID to use, 0-3 IDs represent core threads, >3 represent others
|
||||
std::atomic<u32> next_host_thread_id{Core::Hardware::NUM_CPU_CORES};
|
||||
|
||||
// Kernel memory management
|
||||
std::unique_ptr<KMemoryManager> memory_manager;
|
||||
std::optional<KMemoryManager> memory_manager;
|
||||
|
||||
// Resource managers
|
||||
std::unique_ptr<KDynamicPageManager> resource_manager_page_manager;
|
||||
std::unique_ptr<KPageTableSlabHeap> page_table_heap;
|
||||
std::unique_ptr<KMemoryBlockSlabHeap> app_memory_block_heap;
|
||||
std::unique_ptr<KMemoryBlockSlabHeap> sys_memory_block_heap;
|
||||
std::unique_ptr<KBlockInfoSlabHeap> block_info_heap;
|
||||
std::unique_ptr<KPageTableManager> app_page_table_manager;
|
||||
std::unique_ptr<KPageTableManager> sys_page_table_manager;
|
||||
std::unique_ptr<KMemoryBlockSlabManager> app_memory_block_manager;
|
||||
std::unique_ptr<KMemoryBlockSlabManager> sys_memory_block_manager;
|
||||
std::unique_ptr<KBlockInfoManager> app_block_info_manager;
|
||||
std::unique_ptr<KBlockInfoManager> sys_block_info_manager;
|
||||
std::unique_ptr<KSystemResource> app_system_resource;
|
||||
std::unique_ptr<KSystemResource> sys_system_resource;
|
||||
std::optional<KDynamicPageManager> resource_manager_page_manager;
|
||||
std::optional<KPageTableSlabHeap> page_table_heap;
|
||||
std::optional<KMemoryBlockSlabHeap> app_memory_block_heap;
|
||||
std::optional<KMemoryBlockSlabHeap> sys_memory_block_heap;
|
||||
std::optional<KBlockInfoSlabHeap> block_info_heap;
|
||||
std::optional<KPageTableManager> app_page_table_manager;
|
||||
std::optional<KPageTableManager> sys_page_table_manager;
|
||||
std::optional<KMemoryBlockSlabManager> app_memory_block_manager;
|
||||
std::optional<KMemoryBlockSlabManager> sys_memory_block_manager;
|
||||
std::optional<KBlockInfoManager> app_block_info_manager;
|
||||
std::optional<KBlockInfoManager> sys_block_info_manager;
|
||||
std::optional<KSystemResource> app_system_resource;
|
||||
std::optional<KSystemResource> sys_system_resource;
|
||||
|
||||
// Shared memory for services
|
||||
Kernel::KSharedMemory* hid_shared_mem{};
|
||||
|
|
@ -825,10 +823,10 @@ struct KernelCore::Impl {
|
|||
Kernel::KSharedMemory* hidbus_shared_mem{};
|
||||
|
||||
// Memory layout
|
||||
std::unique_ptr<KMemoryLayout> memory_layout;
|
||||
std::optional<KMemoryLayout> memory_layout;
|
||||
|
||||
std::array<KThread*, Core::Hardware::NUM_CPU_CORES> shutdown_threads{};
|
||||
std::array<std::unique_ptr<Kernel::KScheduler>, Core::Hardware::NUM_CPU_CORES> schedulers{};
|
||||
std::array<std::optional<Kernel::KScheduler>, Core::Hardware::NUM_CPU_CORES> schedulers{};
|
||||
|
||||
bool is_multicore{};
|
||||
std::atomic_bool is_shutting_down{};
|
||||
|
|
@ -948,12 +946,9 @@ const Kernel::PhysicalCore& KernelCore::CurrentPhysicalCore() const {
|
|||
}
|
||||
|
||||
Kernel::KScheduler* KernelCore::CurrentScheduler() {
|
||||
const u32 core_id = impl->GetCurrentHostThreadID();
|
||||
if (core_id >= Core::Hardware::NUM_CPU_CORES) {
|
||||
// This is expected when called from not a guest thread
|
||||
return {};
|
||||
}
|
||||
return impl->schedulers[core_id].get();
|
||||
if (auto const core_id = impl->GetCurrentHostThreadID(); core_id < Core::Hardware::NUM_CPU_CORES)
|
||||
return std::addressof(*impl->schedulers[core_id]);
|
||||
return {}; // This is expected when called from not a guest thread
|
||||
}
|
||||
|
||||
Kernel::KHardwareTimer& KernelCore::HardwareTimer() {
|
||||
|
|
|
|||
|
|
@ -95,9 +95,9 @@ struct Applet {
|
|||
bool request_exit_to_library_applet_at_execute_next_program_enabled{};
|
||||
|
||||
// Channels
|
||||
std::deque<std::vector<u8>> user_channel_launch_parameter{};
|
||||
std::deque<std::vector<u8>> preselected_user_launch_parameter{};
|
||||
std::deque<std::vector<u8>> friend_invitation_storage_channel{};
|
||||
std::vector<std::vector<u8>> user_channel_launch_parameter{};
|
||||
std::vector<std::vector<u8>> preselected_user_launch_parameter{};
|
||||
std::vector<std::vector<u8>> friend_invitation_storage_channel{};
|
||||
|
||||
// Context Stack
|
||||
std::stack<SharedPointer<IStorage>> context_stack{};
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@
|
|||
#include <algorithm>
|
||||
#include <cstring>
|
||||
#include <vector>
|
||||
#include <boost/container/static_vector.hpp>
|
||||
|
||||
#include "common/assert.h"
|
||||
#include "common/common_types.h"
|
||||
|
|
@ -40,96 +41,51 @@ constexpr u32 EXPECTED_MAGIC{0x36f81a1e}; // What we expect the encrypted bfttf
|
|||
constexpr u64 SHARED_FONT_MEM_SIZE{0x1100000};
|
||||
constexpr FontRegion EMPTY_REGION{0, 0};
|
||||
|
||||
static void DecryptSharedFont(const std::vector<u32>& input, Kernel::PhysicalMemory& output,
|
||||
std::size_t& offset) {
|
||||
ASSERT_MSG(offset + (input.size() * sizeof(u32)) < SHARED_FONT_MEM_SIZE,
|
||||
"Shared fonts exceeds 17mb!");
|
||||
ASSERT_MSG(input[0] == EXPECTED_MAGIC, "Failed to derive key, unexpected magic number");
|
||||
|
||||
static void DecryptSharedFont(const std::span<u32 const> input, std::span<u8> output, std::size_t& offset) {
|
||||
ASSERT(offset + (input.size() * sizeof(u32)) < SHARED_FONT_MEM_SIZE && "Shared fonts exceeds 17mb!");
|
||||
ASSERT(input[0] == EXPECTED_MAGIC && "Failed to derive key, unexpected magic number");
|
||||
const u32 KEY = input[0] ^ EXPECTED_RESULT; // Derive key using an inverse xor
|
||||
std::vector<u32> transformed_font(input.size());
|
||||
// TODO(ogniK): Figure out a better way to do this
|
||||
std::transform(input.begin(), input.end(), transformed_font.begin(),
|
||||
[&KEY](u32 font_data) { return Common::swap32(font_data ^ KEY); });
|
||||
std::transform(input.begin(), input.end(), transformed_font.begin(), [&KEY](u32 font_data) { return Common::swap32(font_data ^ KEY); });
|
||||
transformed_font[1] = Common::swap32(transformed_font[1]) ^ KEY; // "re-encrypt" the size
|
||||
std::memcpy(output.data() + offset, transformed_font.data(),
|
||||
transformed_font.size() * sizeof(u32));
|
||||
std::memcpy(output.data() + offset, transformed_font.data(), transformed_font.size() * sizeof(u32));
|
||||
offset += transformed_font.size() * sizeof(u32);
|
||||
}
|
||||
|
||||
void DecryptSharedFontToTTF(const std::vector<u32>& input, std::vector<u8>& output) {
|
||||
ASSERT_MSG(input[0] == EXPECTED_MAGIC, "Failed to derive key, unexpected magic number");
|
||||
|
||||
if (input.size() < 2) {
|
||||
LOG_ERROR(Service_NS, "Input font is empty");
|
||||
return;
|
||||
}
|
||||
|
||||
const u32 KEY = input[0] ^ EXPECTED_RESULT; // Derive key using an inverse xor
|
||||
std::vector<u32> transformed_font(input.size());
|
||||
// TODO(ogniK): Figure out a better way to do this
|
||||
std::transform(input.begin(), input.end(), transformed_font.begin(),
|
||||
[&KEY](u32 font_data) { return Common::swap32(font_data ^ KEY); });
|
||||
std::memcpy(output.data(), transformed_font.data() + 2,
|
||||
(transformed_font.size() - 2) * sizeof(u32));
|
||||
std::transform(input.begin(), input.end(), transformed_font.begin(), [&KEY](u32 font_data) { return Common::swap32(font_data ^ KEY); });
|
||||
std::memcpy(output.data(), transformed_font.data() + 2, (transformed_font.size() - 2) * sizeof(u32));
|
||||
}
|
||||
|
||||
void EncryptSharedFont(const std::vector<u32>& input, std::vector<u8>& output,
|
||||
std::size_t& offset) {
|
||||
ASSERT_MSG(offset + (input.size() * sizeof(u32)) < SHARED_FONT_MEM_SIZE,
|
||||
"Shared fonts exceeds 17mb!");
|
||||
|
||||
void EncryptSharedFont(const std::vector<u32>& input, std::vector<u8>& output, std::size_t& offset) {
|
||||
ASSERT(offset + (input.size() * sizeof(u32)) < SHARED_FONT_MEM_SIZE && "Shared fonts exceeds 17mb!");
|
||||
const auto key = Common::swap32(EXPECTED_RESULT ^ EXPECTED_MAGIC);
|
||||
std::vector<u32> transformed_font(input.size() + 2);
|
||||
transformed_font[0] = Common::swap32(EXPECTED_MAGIC);
|
||||
transformed_font[1] = Common::swap32(static_cast<u32>(input.size() * sizeof(u32))) ^ key;
|
||||
std::transform(input.begin(), input.end(), transformed_font.begin() + 2,
|
||||
[key](u32 in) { return in ^ key; });
|
||||
std::memcpy(output.data() + offset, transformed_font.data(),
|
||||
transformed_font.size() * sizeof(u32));
|
||||
std::transform(input.begin(), input.end(), transformed_font.begin() + 2, [key](u32 in) { return in ^ key; });
|
||||
std::memcpy(output.data() + offset, transformed_font.data(), transformed_font.size() * sizeof(u32));
|
||||
offset += transformed_font.size() * sizeof(u32);
|
||||
}
|
||||
|
||||
// Helper function to make BuildSharedFontsRawRegions a bit nicer
|
||||
static u32 GetU32Swapped(const u8* data) {
|
||||
u32 value;
|
||||
std::memcpy(&value, data, sizeof(value));
|
||||
return Common::swap32(value);
|
||||
}
|
||||
|
||||
struct IPlatformServiceManager::Impl {
|
||||
const FontRegion& GetSharedFontRegion(std::size_t index) const {
|
||||
if (index >= shared_font_regions.size() || shared_font_regions.empty()) {
|
||||
// No font fallback
|
||||
return EMPTY_REGION;
|
||||
}
|
||||
return shared_font_regions.at(index);
|
||||
return index < shared_font_regions.size() ? shared_font_regions[index] : EMPTY_REGION;
|
||||
}
|
||||
|
||||
void BuildSharedFontsRawRegions(const Kernel::PhysicalMemory& input) {
|
||||
// As we can derive the xor key we can just populate the offsets
|
||||
// based on the shared memory dump
|
||||
unsigned cur_offset = 0;
|
||||
|
||||
for (std::size_t i = 0; i < SHARED_FONTS.size(); i++) {
|
||||
// Out of shared fonts/invalid font
|
||||
if (GetU32Swapped(input.data() + cur_offset) != EXPECTED_RESULT) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Derive key within inverse xor
|
||||
const u32 KEY = GetU32Swapped(input.data() + cur_offset) ^ EXPECTED_MAGIC;
|
||||
const u32 SIZE = GetU32Swapped(input.data() + cur_offset + 4) ^ KEY;
|
||||
shared_font_regions.push_back(FontRegion{cur_offset + 8, SIZE});
|
||||
cur_offset += SIZE + 8;
|
||||
}
|
||||
}
|
||||
|
||||
/// Backing memory for the shared font data
|
||||
std::shared_ptr<Kernel::PhysicalMemory> shared_font;
|
||||
|
||||
// Automatically populated based on shared_fonts dump or system archives.
|
||||
std::vector<FontRegion> shared_font_regions;
|
||||
// 6 builtin fonts + extra 2 for whatever may come after
|
||||
boost::container::static_vector<FontRegion, 8> shared_font_regions;
|
||||
/// Backing memory for the shared font data
|
||||
std::array<u8, SHARED_FONT_MEM_SIZE> shared_font;
|
||||
};
|
||||
|
||||
IPlatformServiceManager::IPlatformServiceManager(Core::System& system_, const char* service_name_)
|
||||
|
|
@ -162,8 +118,6 @@ IPlatformServiceManager::IPlatformServiceManager(Core::System& system_, const ch
|
|||
const auto* nand = fsc.GetSystemNANDContents();
|
||||
std::size_t offset = 0;
|
||||
// Rebuild shared fonts from data ncas or synthesize
|
||||
|
||||
impl->shared_font = std::make_shared<Kernel::PhysicalMemory>(SHARED_FONT_MEM_SIZE);
|
||||
for (auto& font : SHARED_FONTS) {
|
||||
FileSys::VirtualFile romfs;
|
||||
const auto nca =
|
||||
|
|
@ -197,9 +151,8 @@ IPlatformServiceManager::IPlatformServiceManager(Core::System& system_, const ch
|
|||
std::transform(font_data_u32.begin(), font_data_u32.end(), font_data_u32.begin(),
|
||||
Common::swap32);
|
||||
// Font offset and size do not account for the header
|
||||
const FontRegion region{static_cast<u32>(offset + 8),
|
||||
static_cast<u32>((font_data_u32.size() * sizeof(u32)) - 8)};
|
||||
DecryptSharedFont(font_data_u32, *impl->shared_font, offset);
|
||||
const FontRegion region{u32(offset + 8), u32((font_data_u32.size() * sizeof(u32)) - 8)};
|
||||
DecryptSharedFont(font_data_u32, impl->shared_font, offset);
|
||||
impl->shared_font_regions.push_back(region);
|
||||
}
|
||||
}
|
||||
|
|
@ -231,14 +184,12 @@ Result IPlatformServiceManager::GetSharedMemoryAddressOffset(Out<u32> out_shared
|
|||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result IPlatformServiceManager::GetSharedMemoryNativeHandle(
|
||||
OutCopyHandle<Kernel::KSharedMemory> out_shared_memory_native_handle) {
|
||||
Result IPlatformServiceManager::GetSharedMemoryNativeHandle(OutCopyHandle<Kernel::KSharedMemory> out_shared_memory_native_handle) {
|
||||
// Map backing memory for the font data
|
||||
LOG_DEBUG(Service_NS, "called");
|
||||
|
||||
// Create shared font memory object
|
||||
std::memcpy(kernel.GetFontSharedMem().GetPointer(), impl->shared_font->data(),
|
||||
impl->shared_font->size());
|
||||
std::memcpy(kernel.GetFontSharedMem().GetPointer(), impl->shared_font.data(), impl->shared_font.size());
|
||||
|
||||
// FIXME: this shouldn't belong to the kernel
|
||||
*out_shared_memory_native_handle = &kernel.GetFontSharedMem();
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue