diff --git a/libraries/libmesosphere/include/mesosphere.hpp b/libraries/libmesosphere/include/mesosphere.hpp index 2950f09e0..85a4bc3a6 100644 --- a/libraries/libmesosphere/include/mesosphere.hpp +++ b/libraries/libmesosphere/include/mesosphere.hpp @@ -50,6 +50,7 @@ #include #include #include +#include /* Miscellaneous objects. */ #include diff --git a/libraries/libmesosphere/include/mesosphere/arch/arm64/kern_cpu.hpp b/libraries/libmesosphere/include/mesosphere/arch/arm64/kern_cpu.hpp index 89dec0318..c32801f16 100644 --- a/libraries/libmesosphere/include/mesosphere/arch/arm64/kern_cpu.hpp +++ b/libraries/libmesosphere/include/mesosphere/arch/arm64/kern_cpu.hpp @@ -108,9 +108,16 @@ namespace ams::kern::arm64::cpu { NOINLINE void SynchronizeAllCores(); /* Cache management helpers. */ + void ClearPageToZeroImpl(void *); void FlushEntireDataCacheShared(); void FlushEntireDataCacheLocal(); + ALWAYS_INLINE void ClearPageToZero(void *page) { + MESOSPHERE_ASSERT(util::IsAligned(reinterpret_cast(page), PageSize)); + MESOSPHERE_ASSERT(page != nullptr); + ClearPageToZeroImpl(page); + } + ALWAYS_INLINE void InvalidateEntireTlb() { __asm__ __volatile__("tlbi vmalle1is" ::: "memory"); EnsureInstructionConsistency(); diff --git a/libraries/libmesosphere/include/mesosphere/arch/arm64/kern_k_page_table.hpp b/libraries/libmesosphere/include/mesosphere/arch/arm64/kern_k_page_table.hpp new file mode 100644 index 000000000..9fdc66164 --- /dev/null +++ b/libraries/libmesosphere/include/mesosphere/arch/arm64/kern_k_page_table.hpp @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#pragma once +#include +#include +#include +#include +#include + +namespace ams::kern::arm64 { + + class KPageTable : public KPageTableBase { + NON_COPYABLE(KPageTable); + NON_MOVEABLE(KPageTable); + private: + KPageTableManager *manager; + u64 ttbr; + u8 asid; + public: + constexpr KPageTable() : KPageTableBase(), manager(), ttbr(), asid() { /* ... */ } + + static NOINLINE void Initialize(s32 core_id); + + Result InitializeForKernel(void *table, KVirtualAddress start, KVirtualAddress end); + Result Finalize(); + }; + +} diff --git a/libraries/libmesosphere/include/mesosphere/arch/arm64/kern_k_page_table_impl.hpp b/libraries/libmesosphere/include/mesosphere/arch/arm64/kern_k_page_table_impl.hpp new file mode 100644 index 000000000..671b967a6 --- /dev/null +++ b/libraries/libmesosphere/include/mesosphere/arch/arm64/kern_k_page_table_impl.hpp @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#pragma once +#include +#include +#include +#include + +namespace ams::kern::arm64 { + + /* TODO: This seems worse than KInitialPageTable. Can we fulfill Nintendo's API using KInitialPageTable? */ + /* KInitialPageTable is significantly nicer, but doesn't have KPageTableImpl's traversal semantics. */ + /* Perhaps we could implement those on top of it? */ + class KPageTableImpl { + NON_COPYABLE(KPageTableImpl); + NON_MOVEABLE(KPageTableImpl); + private: + u64 *table; + bool is_kernel; + u32 num_entries; + public: + constexpr KPageTableImpl() : table(), is_kernel(), num_entries() { /* ... */ } + + void InitializeForKernel(void *tb, KVirtualAddress start, KVirtualAddress end); + + u64 *Finalize(); + }; + +} diff --git a/libraries/libmesosphere/include/mesosphere/arch/arm64/kern_k_process_page_table.hpp b/libraries/libmesosphere/include/mesosphere/arch/arm64/kern_k_process_page_table.hpp new file mode 100644 index 000000000..78ca53722 --- /dev/null +++ b/libraries/libmesosphere/include/mesosphere/arch/arm64/kern_k_process_page_table.hpp @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#pragma once +#include +#include + +namespace ams::kern::arm64 { + + class KProcessPageTable { + + }; + +} diff --git a/libraries/libmesosphere/include/mesosphere/arch/arm64/kern_k_supervisor_page_table.hpp b/libraries/libmesosphere/include/mesosphere/arch/arm64/kern_k_supervisor_page_table.hpp new file mode 100644 index 000000000..02f435f86 --- /dev/null +++ b/libraries/libmesosphere/include/mesosphere/arch/arm64/kern_k_supervisor_page_table.hpp @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#pragma once +#include +#include +#include + +namespace ams::kern::arm64 { + + class KSupervisorPageTable { + private: + KPageTable page_table; + u64 ttbr0[cpu::NumCores]; + public: + constexpr KSupervisorPageTable() : page_table(), ttbr0() { /* ... */ } + + void Initialize(s32 core_id); + void Finalize(s32 core_id); + }; + +} diff --git a/libraries/libmesosphere/include/mesosphere/kern_k_page_table_base.hpp b/libraries/libmesosphere/include/mesosphere/kern_k_page_table_base.hpp new file mode 100644 index 000000000..33ca66932 --- /dev/null +++ b/libraries/libmesosphere/include/mesosphere/kern_k_page_table_base.hpp @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#pragma once +#include +#include +#include +#include +#include +#include + +namespace ams::kern { + + class KPageTableBase { + NON_COPYABLE(KPageTableBase); + NON_MOVEABLE(KPageTableBase); + private: + /* TODO: All other members. */ + /* There are a substantial number of them. */ + KPageTableImpl impl; + public: + constexpr KPageTableBase() : impl() { /* ... */ } + + Result InitializeForKernel(bool is_64_bit, void *table, KVirtualAddress start, KVirtualAddress end); + + void Finalize(); + public: + static ALWAYS_INLINE KVirtualAddress GetLinearVirtualAddress(KPhysicalAddress addr) { + return KMemoryLayout::GetLinearVirtualAddress(addr); + } + + static ALWAYS_INLINE KPhysicalAddress GetLinearPhysicalAddress(KVirtualAddress addr) { + return KMemoryLayout::GetLinearPhysicalAddress(addr); + } + }; + +} diff --git a/libraries/libmesosphere/include/mesosphere/kern_kernel.hpp b/libraries/libmesosphere/include/mesosphere/kern_kernel.hpp index 6e6ab05f6..459252910 100644 --- a/libraries/libmesosphere/include/mesosphere/kern_kernel.hpp +++ b/libraries/libmesosphere/include/mesosphere/kern_kernel.hpp @@ -34,6 +34,21 @@ namespace ams::kern { class KMemoryBlockSlabManager; class KBlockInfoManager; + + +#if defined(ATMOSPHERE_ARCH_ARM64) + + namespace arm64 { + class KSupervisorPageTable; + } + using ams::kern::arm64::KSupervisorPageTable; + +#else + + #error "Unknown architecture for KSupervisorPageTable forward declare" + +#endif + class Kernel { public: enum class State : u8 { @@ -55,6 +70,7 @@ namespace ams::kern { static KMemoryBlockSlabManager s_app_memory_block_manager; static KMemoryBlockSlabManager s_sys_memory_block_manager; static KBlockInfoManager s_block_info_manager; + static KSupervisorPageTable s_supervisor_page_table; private: static ALWAYS_INLINE KCoreLocalContext &GetCoreLocalContext() { return reinterpret_cast(cpu::GetCoreLocalRegionAddress())->current.context; @@ -118,6 +134,14 @@ namespace ams::kern { static ALWAYS_INLINE KBlockInfoManager &GetBlockInfoManager() { return s_block_info_manager; } + + static ALWAYS_INLINE KPageTableManager &GetPageTableManager() { + return s_page_table_manager; + } + + static ALWAYS_INLINE KSupervisorPageTable &GetKernelPageTable() { + return s_supervisor_page_table; + } }; } diff --git a/libraries/libmesosphere/include/mesosphere/kern_select_page_table.hpp b/libraries/libmesosphere/include/mesosphere/kern_select_page_table.hpp new file mode 100644 index 000000000..694f32d1f --- /dev/null +++ b/libraries/libmesosphere/include/mesosphere/kern_select_page_table.hpp @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#pragma once +#include + +#if defined(ATMOSPHERE_ARCH_ARM64) + + #include + #include + #include + namespace ams::kern { + using ams::kern::arm64::KPageTable; + using ams::kern::arm64::KSupervisorPageTable; + using ams::kern::arm64::KProcessPageTable; + } + +#else + + #error "Unknown architecture for KPageTable" + +#endif diff --git a/libraries/libmesosphere/include/mesosphere/kern_select_page_table_impl.hpp b/libraries/libmesosphere/include/mesosphere/kern_select_page_table_impl.hpp new file mode 100644 index 000000000..90f4c33e0 --- /dev/null +++ b/libraries/libmesosphere/include/mesosphere/kern_select_page_table_impl.hpp @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#pragma once +#include + +#if defined(ATMOSPHERE_ARCH_ARM64) + + #include + namespace ams::kern { + using ams::kern::arm64::KPageTableImpl; + } + +#else + + #error "Unknown architecture for KPageTableImpl" + +#endif diff --git a/libraries/libmesosphere/source/arch/arm64/kern_cpu_asm.s b/libraries/libmesosphere/source/arch/arm64/kern_cpu_asm.s index fbc000e8b..4adb36b21 100644 --- a/libraries/libmesosphere/source/arch/arm64/kern_cpu_asm.s +++ b/libraries/libmesosphere/source/arch/arm64/kern_cpu_asm.s @@ -61,3 +61,139 @@ _ZN3ams4kern5arm643cpu23SynchronizeAllCoresImplEPii: 5: stlr wzr, [x0] ret + + +/* ams::kern::arm64::cpu::ClearPageToZero(void *) */ +.section .text._ZN3ams4kern5arm643cpu19ClearPageToZeroImplEPv, "ax", %progbits +.global _ZN3ams4kern5arm643cpu19ClearPageToZeroImplEPv +.type _ZN3ams4kern5arm643cpu19ClearPageToZeroImplEPv, %function +_ZN3ams4kern5arm643cpu19ClearPageToZeroImplEPv: + /* Efficiently clear the page using dc zva. */ + dc zva, x0 + add x8, x0, #0x040 + dc zva, x8 + add x8, x0, #0x080 + dc zva, x8 + add x8, x0, #0x0c0 + dc zva, x8 + add x8, x0, #0x100 + dc zva, x8 + add x8, x0, #0x140 + dc zva, x8 + add x8, x0, #0x180 + dc zva, x8 + add x8, x0, #0x1c0 + dc zva, x8 + add x8, x0, #0x200 + dc zva, x8 + add x8, x0, #0x240 + dc zva, x8 + add x8, x0, #0x280 + dc zva, x8 + add x8, x0, #0x2c0 + dc zva, x8 + add x8, x0, #0x300 + dc zva, x8 + add x8, x0, #0x340 + dc zva, x8 + add x8, x0, #0x380 + dc zva, x8 + add x8, x0, #0x3c0 + dc zva, x8 + add x8, x0, #0x400 + dc zva, x8 + add x8, x0, #0x440 + dc zva, x8 + add x8, x0, #0x480 + dc zva, x8 + add x8, x0, #0x4c0 + dc zva, x8 + add x8, x0, #0x500 + dc zva, x8 + add x8, x0, #0x540 + dc zva, x8 + add x8, x0, #0x580 + dc zva, x8 + add x8, x0, #0x5c0 + dc zva, x8 + add x8, x0, #0x600 + dc zva, x8 + add x8, x0, #0x640 + dc zva, x8 + add x8, x0, #0x680 + dc zva, x8 + add x8, x0, #0x6c0 + dc zva, x8 + add x8, x0, #0x700 + dc zva, x8 + add x8, x0, #0x740 + dc zva, x8 + add x8, x0, #0x780 + dc zva, x8 + add x8, x0, #0x7c0 + dc zva, x8 + add x8, x0, #0x800 + dc zva, x8 + add x8, x0, #0x840 + dc zva, x8 + add x8, x0, #0x880 + dc zva, x8 + add x8, x0, #0x8c0 + dc zva, x8 + add x8, x0, #0x900 + dc zva, x8 + add x8, x0, #0x940 + dc zva, x8 + add x8, x0, #0x980 + dc zva, x8 + add x8, x0, #0x9c0 + dc zva, x8 + add x8, x0, #0xa00 + dc zva, x8 + add x8, x0, #0xa40 + dc zva, x8 + add x8, x0, #0xa80 + dc zva, x8 + add x8, x0, #0xac0 + dc zva, x8 + add x8, x0, #0xb00 + dc zva, x8 + add x8, x0, #0xb40 + dc zva, x8 + add x8, x0, #0xb80 + dc zva, x8 + add x8, x0, #0xbc0 + dc zva, x8 + add x8, x0, #0xc00 + dc zva, x8 + add x8, x0, #0xc40 + dc zva, x8 + add x8, x0, #0xc80 + dc zva, x8 + add x8, x0, #0xcc0 + dc zva, x8 + add x8, x0, #0xd00 + dc zva, x8 + add x8, x0, #0xd40 + dc zva, x8 + add x8, x0, #0xd80 + dc zva, x8 + add x8, x0, #0xdc0 + dc zva, x8 + add x8, x0, #0xe00 + dc zva, x8 + add x8, x0, #0xe40 + dc zva, x8 + add x8, x0, #0xe80 + dc zva, x8 + add x8, x0, #0xec0 + dc zva, x8 + add x8, x0, #0xf00 + dc zva, x8 + add x8, x0, #0xf40 + dc zva, x8 + add x8, x0, #0xf80 + dc zva, x8 + add x8, x0, #0xfc0 + dc zva, x8 + ret \ No newline at end of file diff --git a/libraries/libmesosphere/source/arch/arm64/kern_k_page_table.cpp b/libraries/libmesosphere/source/arch/arm64/kern_k_page_table.cpp new file mode 100644 index 000000000..07663da03 --- /dev/null +++ b/libraries/libmesosphere/source/arch/arm64/kern_k_page_table.cpp @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#include + +namespace ams::kern::arm64 { + + void KPageTable::Initialize(s32 core_id) { + /* Nothing actually needed here. */ + } + + Result KPageTable::InitializeForKernel(void *table, KVirtualAddress start, KVirtualAddress end) { + /* Initialize basic fields. */ + this->asid = 0; + this->manager = std::addressof(Kernel::GetPageTableManager()); + + /* Allocate a page for ttbr. */ + const u64 asid_tag = (static_cast(this->asid) << 48ul); + const KVirtualAddress page = this->manager->Allocate(); + MESOSPHERE_ASSERT(page != Null); + cpu::ClearPageToZero(GetVoidPointer(page)); + this->ttbr = GetInteger(KPageTableBase::GetLinearPhysicalAddress(page)) | asid_tag; + + /* Initialize the base page table. */ + MESOSPHERE_R_ABORT_UNLESS(KPageTableBase::InitializeForKernel(true, table, start, end)); + + return ResultSuccess(); + } + + Result KPageTable::Finalize() { + MESOSPHERE_TODO_IMPLEMENT(); + } +} diff --git a/libraries/libmesosphere/source/arch/arm64/kern_k_page_table_impl.cpp b/libraries/libmesosphere/source/arch/arm64/kern_k_page_table_impl.cpp new file mode 100644 index 000000000..06bee77cb --- /dev/null +++ b/libraries/libmesosphere/source/arch/arm64/kern_k_page_table_impl.cpp @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#include + +namespace ams::kern::arm64 { + + namespace { + + constexpr size_t PageBits = __builtin_ctzll(PageSize); + constexpr size_t NumLevels = 3; + constexpr size_t LevelBits = 9; + static_assert(NumLevels > 0); + + constexpr size_t AddressBits = (NumLevels - 1) * LevelBits + PageBits; + static_assert(AddressBits <= BITSIZEOF(u64)); + constexpr size_t AddressSpaceSize = (1ull << AddressBits); + + } + + void KPageTableImpl::InitializeForKernel(void *tb, KVirtualAddress start, KVirtualAddress end) { + this->table = static_cast(tb); + this->is_kernel = true; + this->num_entries = util::AlignUp(end - start, AddressSpaceSize) / AddressSpaceSize; + } + + u64 *KPageTableImpl::Finalize() { + return this->table; + } + +} diff --git a/libraries/libmesosphere/source/arch/arm64/kern_k_supervisor_page_table.cpp b/libraries/libmesosphere/source/arch/arm64/kern_k_supervisor_page_table.cpp new file mode 100644 index 000000000..07bd400ef --- /dev/null +++ b/libraries/libmesosphere/source/arch/arm64/kern_k_supervisor_page_table.cpp @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#include + +namespace ams::kern::arm64 { + + void KSupervisorPageTable::Initialize(s32 core_id) { + /* Get the identity mapping ttbr0. */ + this->ttbr0[core_id] = cpu::GetTtbr0El1(); + + /* Set sctlr_el1 */ + MESOSPHERE_TODO("Set bit in SCTLR_EL1"); + cpu::EnsureInstructionConsistency(); + + /* Invalidate the entire TLB. */ + cpu::InvalidateEntireTlb(); + cpu::EnsureInstructionConsistency(); + + /* If core 0, initialize our base page table. */ + if (core_id == 0) { + /* TODO: constexpr defines. */ + const u64 ttbr1 = cpu::GetTtbr1El1() & 0xFFFFFFFFFFFFul; + const u64 kernel_vaddr_start = 0xFFFFFF8000000000ul; + const u64 kernel_vaddr_end = 0xFFFFFFFFFFE00000ul; + void *table = GetVoidPointer(KPageTableBase::GetLinearVirtualAddress(ttbr1)); + this->page_table.InitializeForKernel(table, kernel_vaddr_start, kernel_vaddr_end); + } + } + + void KSupervisorPageTable::Finalize(s32 core_id) { + MESOSPHERE_TODO_IMPLEMENT(); + } +} diff --git a/libraries/libmesosphere/source/kern_k_page_table_base.cpp b/libraries/libmesosphere/source/kern_k_page_table_base.cpp new file mode 100644 index 000000000..3c48501ce --- /dev/null +++ b/libraries/libmesosphere/source/kern_k_page_table_base.cpp @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#include +#include + +namespace ams::kern { + + Result KPageTableBase::InitializeForKernel(bool is_64_bit, void *table, KVirtualAddress start, KVirtualAddress end) { + /* Initialize impl table. */ + this->impl.InitializeForKernel(table, start, end); + + /* Initialize our members. */ + MESOSPHERE_TODO("KPageTableBase member initialization"); + + /* Initialize our memory block manager. */ + MESOSPHERE_TODO("R_TRY(this->memory_block_manager.Initialize(this->address_space_start, this->address_space_end, this->GetMemoryBlockSlabManager()));"); + + return ResultSuccess(); + } + + void KPageTableBase::Finalize() { + MESOSPHERE_TODO("this->memory_block_manager.Finalize(this->GetMemoryBlockSlabManager());"); + MESOSPHERE_TODO("cpu::InvalidateEntireInstructionCache();"); + } +} diff --git a/libraries/libmesosphere/source/kern_kernel.cpp b/libraries/libmesosphere/source/kern_kernel.cpp index cbb42739f..09bc065c2 100644 --- a/libraries/libmesosphere/source/kern_kernel.cpp +++ b/libraries/libmesosphere/source/kern_kernel.cpp @@ -27,6 +27,7 @@ namespace ams::kern { KMemoryBlockSlabManager Kernel::s_app_memory_block_manager; KMemoryBlockSlabManager Kernel::s_sys_memory_block_manager; KBlockInfoManager Kernel::s_block_info_manager; + KSupervisorPageTable Kernel::s_supervisor_page_table; namespace { diff --git a/libraries/libmesosphere/source/kern_main.cpp b/libraries/libmesosphere/source/kern_main.cpp index 4157f86ad..4fc9792f4 100644 --- a/libraries/libmesosphere/source/kern_main.cpp +++ b/libraries/libmesosphere/source/kern_main.cpp @@ -74,8 +74,8 @@ namespace ams::kern { /* Initialize the supervisor page table for each core. */ DoOnEachCoreInOrder(core_id, [=]() ALWAYS_INLINE_LAMBDA { - MESOSPHERE_TODO("KPageTable::Initialize();"); - MESOSPHERE_TODO("Kernel::GetSupervisorPageTable().Initialize();"); + KPageTable::Initialize(core_id); + Kernel::GetKernelPageTable().Initialize(core_id); }); /* Set ttbr0 for each core. */