kern: implement capabilities parsing

libraries/libmesosphere/include/mesosphere/arch/arm64/kern_k_interrupt_controller.hpp

@@ -213,6 +213,11 @@ namespace ams::kern::arch::arm64 {
                 this->gicc->eoir = irq;
             }
 
+            bool IsInterruptDefined(s32 irq) {
+                const s32 num_interrupts = std::min(32 + 32 * (this->gicd->typer & 0x1F), static_cast<u32>(NumInterrupts));
+                return (0 <= irq && irq < num_interrupts);
+            }
+
             /* TODO: Implement more KInterruptController functionality. */
         public:
             static constexpr ALWAYS_INLINE bool IsSoftware(s32 id) {

libraries/libmesosphere/include/mesosphere/arch/arm64/kern_k_interrupt_manager.hpp

@@ -67,6 +67,10 @@ namespace ams::kern::arch::arm64 {
             NOINLINE void Initialize(s32 core_id);
             NOINLINE void Finalize(s32 core_id);
 
+            bool IsInterruptDefined(s32 irq) {
+                return this->interrupt_controller.IsInterruptDefined(irq);
+            }
+
             NOINLINE Result BindHandler(KInterruptHandler *handler, s32 irq, s32 core_id, s32 priority, bool manual_clear, bool level);
             NOINLINE Result UnbindHandler(s32 irq, s32 core);
 

libraries/libmesosphere/include/mesosphere/arch/arm64/kern_k_process_page_table.hpp

@@ -31,6 +31,18 @@ namespace ams::kern::arch::arm64 {
 
             void Finalize() { this->page_table.Finalize(); }
 
+            Result MapIo(KPhysicalAddress phys_addr, size_t size, KMemoryPermission perm) {
+                return this->page_table.MapIo(phys_addr, size, perm);
+            }
+
+            Result MapStatic(KPhysicalAddress phys_addr, size_t size, KMemoryPermission perm) {
+                return this->page_table.MapStatic(phys_addr, size, perm);
+            }
+
+            Result MapRegion(KMemoryRegionType region_type, KMemoryPermission perm) {
+                return this->page_table.MapRegion(region_type, perm);
+            }
+
             Result MapPageGroup(KProcessAddress addr, const KPageGroup &pg, KMemoryState state, KMemoryPermission perm) {
                 return this->page_table.MapPageGroup(addr, pg, state, perm);
             }

libraries/libmesosphere/include/mesosphere/kern_k_capabilities.hpp

@@ -24,6 +24,180 @@ namespace ams::kern {
         private:
             static constexpr size_t SvcFlagCount = svc::NumSupervisorCalls / BITSIZEOF(u8);
             static constexpr size_t IrqFlagCount = /* TODO */0x80;
+
+            enum class CapabilityType : u32 {
+                CorePriority  = (1u <<  3) - 1,
+                SyscallMask   = (1u <<  4) - 1,
+                MapRange      = (1u <<  6) - 1,
+                MapIoPage     = (1u <<  7) - 1,
+                MapRegion     = (1u << 10) - 1,
+                InterruptPair = (1u << 11) - 1,
+                ProgramType   = (1u << 13) - 1,
+                KernelVersion = (1u << 14) - 1,
+                HandleTable   = (1u << 15) - 1,
+                DebugFlags    = (1u << 16) - 1,
+
+                Invalid       = 0u,
+                Padding       = ~0u,
+            };
+
+            using RawCapabilityValue = util::BitPack32::Field<0, BITSIZEOF(util::BitPack32), u32>;
+
+            static constexpr CapabilityType GetCapabilityType(const util::BitPack32 cap) {
+                const u32 value = cap.Get<RawCapabilityValue>();
+                return static_cast<CapabilityType>((~value & (value + 1)) - 1);
+            }
+
+            static constexpr u32 GetCapabilityFlag(CapabilityType type) {
+                return static_cast<u32>(type) + 1;
+            }
+
+            static constexpr u32 CountTrailingZero(u32 flag) {
+                for (u32 i = 0; i < BITSIZEOF(u32); i++) {
+                    if (flag & (1u << i)) {
+                        return i;
+                    }
+                }
+                return BITSIZEOF(u32);
+            }
+
+            static constexpr u32 GetCapabilityId(CapabilityType type) {
+                const u32 flag = GetCapabilityFlag(type);
+                if (true /* C++20: std::is_constant_evaluated() */) {
+                    return CountTrailingZero(flag);
+                } else {
+                    return static_cast<u32>(__builtin_ctz(flag));
+                }
+            }
+
+            template<size_t Index, size_t Count, typename T = u32>
+            using Field = util::BitPack32::Field<Index, Count, T>;
+
+            #define DEFINE_FIELD(name, prev, ...) using name = Field<prev::Next, __VA_ARGS__>
+
+            template<CapabilityType Type>
+            static constexpr inline u32 CapabilityFlag = []() -> u32 {
+                return static_cast<u32>(Type) + 1;
+            }();
+
+            template<CapabilityType Type>
+            static constexpr inline u32 CapabilityId = []() -> u32 {
+                const u32 flag = static_cast<u32>(Type) + 1;
+                if (true /* C++20: std::is_constant_evaluated() */) {
+                    for (u32 i = 0; i < BITSIZEOF(u32); i++) {
+                        if (flag & (1u << i)) {
+                            return i;
+                        }
+                    }
+                    return BITSIZEOF(u32);
+                } else {
+                    return __builtin_ctz(flag);
+                }
+            }();
+
+            struct CorePriority {
+                using IdBits = Field<0, CapabilityId<CapabilityType::CorePriority> + 1>;
+
+                DEFINE_FIELD(LowestThreadPriority,  IdBits,                6);
+                DEFINE_FIELD(HighestThreadPriority, LowestThreadPriority,  6);
+                DEFINE_FIELD(MinimumCoreId,         HighestThreadPriority, 8);
+                DEFINE_FIELD(MaximumCoreId,         MinimumCoreId,         8);
+            };
+
+            struct SyscallMask {
+                using IdBits = Field<0, CapabilityId<CapabilityType::SyscallMask> + 1>;
+
+                DEFINE_FIELD(Mask,  IdBits, 24);
+                DEFINE_FIELD(Index, Mask,    3);
+            };
+
+            static constexpr u64 PhysicalMapAllowedMask = (1ul << 36) - 1;
+
+            struct MapRange {
+                using IdBits = Field<0, CapabilityId<CapabilityType::MapRange> + 1>;
+
+                DEFINE_FIELD(Address,  IdBits,  24);
+                DEFINE_FIELD(ReadOnly, Address,  1, bool);
+            };
+
+            struct MapRangeSize {
+                using IdBits = Field<0, CapabilityId<CapabilityType::MapRange> + 1>;
+
+                DEFINE_FIELD(Pages,    IdBits,   20);
+                DEFINE_FIELD(Reserved, Pages,     4);
+                DEFINE_FIELD(Normal,   Reserved,  1, bool);
+            };
+
+            struct MapIoPage {
+                using IdBits = Field<0, CapabilityId<CapabilityType::MapIoPage> + 1>;
+
+                DEFINE_FIELD(Address, IdBits, 24);
+            };
+
+            enum class RegionType : u32 {
+                None              = 0,
+                KernelTraceBuffer = 1,
+                OnMemoryBootImage = 2,
+                DTB               = 3,
+            };
+
+            struct MapRegion {
+                using IdBits = Field<0, CapabilityId<CapabilityType::MapRegion> + 1>;
+
+                DEFINE_FIELD(Region0,   IdBits,      6, RegionType);
+                DEFINE_FIELD(ReadOnly0, Region0,     1, bool);
+                DEFINE_FIELD(Region1,   ReadOnly0,   6, RegionType);
+                DEFINE_FIELD(ReadOnly1, Region1,     1, bool);
+                DEFINE_FIELD(Region2,   ReadOnly1,   6, RegionType);
+                DEFINE_FIELD(ReadOnly2, Region2,     1, bool);
+            };
+
+            static const u32 PaddingInterruptId = 0x3FF;
+
+            struct InterruptPair {
+                using IdBits = Field<0, CapabilityId<CapabilityType::InterruptPair> + 1>;
+
+                DEFINE_FIELD(InterruptId0, IdBits,       10);
+                DEFINE_FIELD(InterruptId1, InterruptId0, 10);
+            };
+
+
+            struct ProgramType {
+                using IdBits = Field<0, CapabilityId<CapabilityType::ProgramType> + 1>;
+
+                DEFINE_FIELD(Type,     IdBits,  3);
+                DEFINE_FIELD(Reserved, Type,   15);
+            };
+
+            struct KernelVersion {
+                using IdBits = Field<0, CapabilityId<CapabilityType::KernelVersion> + 1>;
+
+                DEFINE_FIELD(MinorVersion, IdBits,        4);
+                DEFINE_FIELD(MajorVersion, MinorVersion, 13);
+            };
+
+            struct HandleTable {
+                using IdBits = Field<0, CapabilityId<CapabilityType::HandleTable> + 1>;
+
+                DEFINE_FIELD(Size,     IdBits, 10);
+                DEFINE_FIELD(Reserved, Size,    6);
+            };
+
+            struct DebugFlags {
+                using IdBits = Field<0, CapabilityId<CapabilityType::HandleTable> + 1>;
+
+                DEFINE_FIELD(AllowDebug, IdBits,      1, bool);
+                DEFINE_FIELD(ForceDebug, AllowDebug,  1, bool);
+                DEFINE_FIELD(Reserved,   ForceDebug, 13);
+            };
+
+            #undef DEFINE_FIELD
+
+            static constexpr u32 InitializeOnceFlags = CapabilityFlag<CapabilityType::CorePriority>  |
+                                                       CapabilityFlag<CapabilityType::ProgramType>   |
+                                                       CapabilityFlag<CapabilityType::KernelVersion> |
+                                                       CapabilityFlag<CapabilityType::HandleTable>   |
+                                                       CapabilityFlag<CapabilityType::DebugFlags>;
         private:
             u8 svc_access_flags[SvcFlagCount]{};
             u8 irq_access_flags[IrqFlagCount]{};
@@ -33,6 +207,40 @@ namespace ams::kern {
             s32 handle_table_size{};
             util::BitPack32 intended_kernel_version;
             u32 program_type{};
+        private:
+            bool SetSvcAllowed(u32 id) {
+                constexpr size_t BitsPerWord = BITSIZEOF(this->svc_access_flags[0]);
+                if (id < BITSIZEOF(this->svc_access_flags)) {
+                    this->svc_access_flags[id / BitsPerWord] = (1ul << (id % BitsPerWord));
+                    return true;
+                } else {
+                    return false;
+                }
+            }
+
+            bool SetInterruptAllowed(u32 id) {
+                constexpr size_t BitsPerWord = BITSIZEOF(this->irq_access_flags[0]);
+                if (id < BITSIZEOF(this->irq_access_flags)) {
+                    this->irq_access_flags[id / BitsPerWord] = (1ul << (id % BitsPerWord));
+                    return true;
+                } else {
+                    return false;
+                }
+            }
+
+            Result SetCorePriorityCapability(const util::BitPack32 cap);
+            Result SetSyscallMaskCapability(const util::BitPack32 cap, u32 &set_svc);
+            Result MapRange(const util::BitPack32 cap, const util::BitPack32 size_cap, KProcessPageTable *page_table);
+            Result MapIoPage(const util::BitPack32 cap, KProcessPageTable *page_table);
+            Result MapRegion(const util::BitPack32 cap, KProcessPageTable *page_table);
+            Result SetInterruptPairCapability(const util::BitPack32 cap);
+            Result SetProgramTypeCapability(const util::BitPack32 cap);
+            Result SetKernelVersionCapability(const util::BitPack32 cap);
+            Result SetHandleTableCapability(const util::BitPack32 cap);
+            Result SetDebugFlagsCapability(const util::BitPack32 cap);
+
+            Result SetCapability(const util::BitPack32 cap, u32 &set_flags, u32 &set_svc, KProcessPageTable *page_table);
+            Result SetCapabilities(const u32 *caps, s32 num_caps, KProcessPageTable *page_table);
         public:
             constexpr KCapabilities() : debug_capabilities(0), intended_kernel_version(0) { /* ... */ }
 

libraries/libmesosphere/include/mesosphere/kern_k_page_table_base.hpp

@@ -240,6 +240,10 @@ namespace ams::kern {
                 return this->GetImpl().GetPhysicalAddress(out, virt_addr);
             }
 
+            Result MapIo(KPhysicalAddress phys_addr, size_t size, KMemoryPermission perm);
+            Result MapStatic(KPhysicalAddress phys_addr, size_t size, KMemoryPermission perm);
+            Result MapRegion(KMemoryRegionType region_type, KMemoryPermission perm);
+
             Result MapPages(KProcessAddress *out_addr, size_t num_pages, size_t alignment, KPhysicalAddress phys_addr, KProcessAddress region_start, size_t region_num_pages, KMemoryState state, KMemoryPermission perm) {
                 return this->MapPages(out_addr, num_pages, alignment, phys_addr, true, region_start, region_num_pages, state, perm);
             }

libraries/libmesosphere/include/mesosphere/svc/kern_svc_results.hpp

@@ -55,7 +55,7 @@ namespace ams::kern::svc {
     /* 123 */ using ::ams::svc::ResultSessionClosed;
     /* 124 */ using ::ams::svc::ResultNotHandled;
     /* 125 */ using ::ams::svc::ResultInvalidState;
-    /* 126 */ using ::ams::svc::ResultReservedValue;
+    /* 126 */ using ::ams::svc::ResultReservedUsed;
     /* 127 */ using ::ams::svc::ResultNotSupported;
     /* 128 */ using ::ams::svc::ResultDebug;
     /* 129 */ using ::ams::svc::ResultThreadNotOwned;

libraries/libmesosphere/source/kern_k_capabilities.cpp

@@ -18,7 +18,242 @@
 namespace ams::kern {
 
     Result KCapabilities::Initialize(const u32 *caps, s32 num_caps, KProcessPageTable *page_table) {
-        MESOSPHERE_TODO_IMPLEMENT();
+        /* We're initializing an initial process. */
+        /* Most fields have already been cleared by our constructor. */
+
+        /* Initial processes may run on all cores. */
+        this->core_mask = (1ul << cpu::NumCores) - 1;
+
+        /* Initial processes may use any user priority they like. */
+        this->priority_mask = ~0xFul;
+
+        /* TODO: Here, Nintendo sets the kernel version to (current kernel version). */
+        /* How should we handle this? Not a MESOSPHERE_TODO because it's not critical. */
+
+        /* Parse the capabilities array. */
+        return this->SetCapabilities(caps, num_caps, page_table);
+    }
+
+    Result KCapabilities::SetCorePriorityCapability(const util::BitPack32 cap) {
+        /* We can't set core/priority if we've already set them. */
+        R_UNLESS(this->core_mask    == 0,  svc::ResultInvalidArgument());
+        R_UNLESS(this->priority_mask == 0, svc::ResultInvalidArgument());
+
+        /* Validate the core/priority. */
+        const auto min_core = cap.Get<CorePriority::MinimumCoreId>();
+        const auto max_core = cap.Get<CorePriority::MaximumCoreId>();
+        const auto max_prio  = cap.Get<CorePriority::LowestThreadPriority>();
+        const auto min_prio  = cap.Get<CorePriority::HighestThreadPriority>();
+
+        R_UNLESS(min_core <= max_core,       svc::ResultInvalidCombination());
+        R_UNLESS(min_prio <= max_prio,       svc::ResultInvalidCombination());
+        R_UNLESS(max_core <  cpu::NumCores,  svc::ResultInvalidCoreId());
+
+        MESOSPHERE_ASSERT(max_core < BITSIZEOF(u64));
+        MESOSPHERE_ASSERT(max_prio < BITSIZEOF(u64));
+
+        /* Set core mask. */
+        for (auto core_id = min_core; core_id <= max_core; core_id++) {
+            this->core_mask |= (1ul << core_id);
+        }
+        MESOSPHERE_ASSERT((this->core_mask & ((1ul << cpu::NumCores) - 1)) == this->core_mask);
+
+        /* Set priority mask. */
+        for (auto prio = min_prio; prio <= max_prio; prio++) {
+            this->priority_mask |= (1ul << prio);
+        }
+
+        /* We must have some core/priority we can use. */
+        R_UNLESS(this->core_mask     != 0, svc::ResultInvalidArgument());
+        R_UNLESS(this->priority_mask != 0, svc::ResultInvalidArgument());
+
+        return ResultSuccess();
+    }
+
+    Result KCapabilities::SetSyscallMaskCapability(const util::BitPack32 cap, u32 &set_svc) {
+        /* Validate the index. */
+        const auto mask  = cap.Get<SyscallMask::Mask>();
+        const auto index = cap.Get<SyscallMask::Index>();
+
+        const u32 index_flag = (1u << index);
+        R_UNLESS((set_svc & index_flag) == 0, svc::ResultInvalidCombination());
+        set_svc |= index_flag;
+
+        /* Set SVCs. */
+        for (size_t i = 0; i < SyscallMask::Mask::Count; i++) {
+            const u32 svc_id = SyscallMask::Mask::Count * index + i;
+            if (mask & (1u << i)) {
+                R_UNLESS(this->SetSvcAllowed(svc_id), svc::ResultOutOfRange());
+            }
+        }
+
+        return ResultSuccess();
+    }
+
+    Result KCapabilities::MapRange(const util::BitPack32 cap, const util::BitPack32 size_cap, KProcessPageTable *page_table) {
+        /* Validate reserved bits are unused. */
+        R_UNLESS(size_cap.Get<MapRangeSize::Reserved>() == 0, svc::ResultOutOfRange());
+
+        /* Get/validate address/size */
+        const u64 phys_addr    = cap.Get<MapRange::Address>() * PageSize;
+        const size_t num_pages = size_cap.Get<MapRangeSize::Pages>();
+        const size_t size      = num_pages * PageSize;
+        R_UNLESS(phys_addr == GetInteger(KPhysicalAddress(phys_addr)),    svc::ResultInvalidAddress());
+        R_UNLESS(num_pages != 0,                                          svc::ResultInvalidSize());
+        R_UNLESS(phys_addr < phys_addr + size,                            svc::ResultInvalidAddress());
+        R_UNLESS(((phys_addr + size - 1) & ~PhysicalMapAllowedMask) == 0, svc::ResultInvalidAddress());
+
+        /* Do the mapping. */
+        const KMemoryPermission perm = cap.Get<MapRange::ReadOnly>() ? KMemoryPermission_UserRead : KMemoryPermission_UserReadWrite;
+        if (size_cap.Get<MapRangeSize::Normal>()) {
+            return page_table->MapStatic(phys_addr, size, perm);
+        } else {
+            return page_table->MapIo(phys_addr, size, perm);
+        }
+    }
+
+    Result KCapabilities::MapIoPage(const util::BitPack32 cap, KProcessPageTable *page_table) {
+        /* Get/validate address/size */
+        const u64 phys_addr    = cap.Get<MapIoPage::Address>() * PageSize;
+        const size_t num_pages = 1;
+        const size_t size      = num_pages * PageSize;
+        R_UNLESS(phys_addr == GetInteger(KPhysicalAddress(phys_addr)),    svc::ResultInvalidAddress());
+        R_UNLESS(num_pages != 0,                                          svc::ResultInvalidSize());
+        R_UNLESS(phys_addr < phys_addr + size,                            svc::ResultInvalidAddress());
+        R_UNLESS(((phys_addr + size - 1) & ~PhysicalMapAllowedMask) == 0, svc::ResultInvalidAddress());
+
+        /* Do the mapping. */
+        return page_table->MapIo(phys_addr, size, KMemoryPermission_UserReadWrite);
+    }
+
+    Result KCapabilities::MapRegion(const util::BitPack32 cap, KProcessPageTable *page_table) {
+        /* Define the allowed memory regions. */
+        constexpr KMemoryRegionType MemoryRegions[] = {
+            KMemoryRegionType_None,
+            KMemoryRegionType_KernelTraceBuffer,
+            KMemoryRegionType_OnMemoryBootImage,
+            KMemoryRegionType_DTB,
+        };
+
+        /* Extract regions/read only. */
+        const RegionType types[3] = { cap.Get<MapRegion::Region0>(),   cap.Get<MapRegion::Region1>(),   cap.Get<MapRegion::Region2>(), };
+        const bool          ro[3] = { cap.Get<MapRegion::ReadOnly0>(), cap.Get<MapRegion::ReadOnly1>(), cap.Get<MapRegion::ReadOnly2>(), };
+
+        for (size_t i = 0; i < util::size(types); i++) {
+            const auto type = types[i];
+            const auto perm = ro[i] ? KMemoryPermission_UserRead : KMemoryPermission_UserReadWrite;
+            switch (type) {
+                case RegionType::None:
+                    break;
+                case RegionType::KernelTraceBuffer:
+                case RegionType::OnMemoryBootImage:
+                case RegionType::DTB:
+                    R_TRY(page_table->MapRegion(MemoryRegions[static_cast<u32>(type)], perm));
+                default:
+                    return svc::ResultNotFound();
+            }
+        }
+
+        return ResultSuccess();
+    }
+
+    Result KCapabilities::SetInterruptPairCapability(const util::BitPack32 cap) {
+        /* Extract interrupts. */
+        const u32 ids[2] = { cap.Get<InterruptPair::InterruptId0>(), cap.Get<InterruptPair::InterruptId1>(), };
+
+        for (size_t i = 0; i < util::size(ids); i++) {
+            if (ids[i] != PaddingInterruptId) {
+                R_UNLESS(Kernel::GetInterruptManager().IsInterruptDefined(ids[i]), svc::ResultOutOfRange());
+                R_UNLESS(this->SetInterruptAllowed(ids[i]),                        svc::ResultOutOfRange());
+            }
+        }
+
+        return ResultSuccess();
+    }
+
+    Result KCapabilities::SetProgramTypeCapability(const util::BitPack32 cap) {
+        /* Validate. */
+        R_UNLESS(cap.Get<ProgramType::Reserved>() == 0, svc::ResultReservedUsed());
+
+        this->program_type = cap.Get<ProgramType::Type>();
+        return ResultSuccess();
+    }
+
+    Result KCapabilities::SetKernelVersionCapability(const util::BitPack32 cap) {
+        /* Ensure we haven't set our version before. */
+        R_UNLESS(this->intended_kernel_version.Get<KernelVersion::MajorVersion>() == 0, svc::ResultInvalidArgument());
+
+        /* Set, ensure that we set a valid version. */
+        this->intended_kernel_version = cap;
+        R_UNLESS(this->intended_kernel_version.Get<KernelVersion::MajorVersion>() != 0, svc::ResultInvalidArgument());
+
+        return ResultSuccess();
+    }
+
+    Result KCapabilities::SetHandleTableCapability(const util::BitPack32 cap) {
+        /* Validate. */
+        R_UNLESS(cap.Get<HandleTable::Reserved>() == 0, svc::ResultReservedUsed());
+
+        this->handle_table_size = cap.Get<HandleTable::Size>();
+        return ResultSuccess();
+    }
+
+    Result KCapabilities::SetDebugFlagsCapability(const util::BitPack32 cap) {
+        /* Validate. */
+        R_UNLESS(cap.Get<DebugFlags::Reserved>() == 0, svc::ResultReservedUsed());
+
+        this->debug_capabilities.Set<DebugFlags::AllowDebug>(cap.Get<DebugFlags::AllowDebug>());
+        this->debug_capabilities.Set<DebugFlags::ForceDebug>(cap.Get<DebugFlags::ForceDebug>());
+        return ResultSuccess();
+    }
+
+    Result KCapabilities::SetCapability(const util::BitPack32 cap, u32 &set_flags, u32 &set_svc, KProcessPageTable *page_table) {
+        /* Validate this is a capability we can act on. */
+        const auto type = GetCapabilityType(cap);
+        R_UNLESS(type != CapabilityType::Invalid, svc::ResultInvalidArgument());
+        R_UNLESS(type != CapabilityType::Padding, ResultSuccess());
+
+        /* Check that we haven't already processed this capability. */
+        const auto flag = GetCapabilityFlag(type);
+        R_UNLESS(((set_flags & InitializeOnceFlags) & flag) == 0, svc::ResultInvalidCombination());
+        set_flags |= flag;
+
+        /* Process the capability. */
+        switch (type) {
+            case CapabilityType::CorePriority:  return this->SetCorePriorityCapability(cap);
+            case CapabilityType::SyscallMask:   return this->SetSyscallMaskCapability(cap, set_svc);
+            case CapabilityType::MapIoPage:     return this->MapIoPage(cap, page_table);
+            case CapabilityType::MapRegion:     return this->MapRegion(cap, page_table);
+            case CapabilityType::InterruptPair: return this->SetInterruptPairCapability(cap);
+            case CapabilityType::ProgramType:   return this->SetProgramTypeCapability(cap);
+            case CapabilityType::KernelVersion: return this->SetKernelVersionCapability(cap);
+            case CapabilityType::HandleTable:   return this->SetHandleTableCapability(cap);
+            case CapabilityType::DebugFlags:    return this->SetDebugFlagsCapability(cap);
+            default:                            return svc::ResultInvalidArgument();
+        }
+    }
+
+    Result KCapabilities::SetCapabilities(const u32 *caps, s32 num_caps, KProcessPageTable *page_table) {
+        u32 set_flags = 0, set_svc = 0;
+
+        for (s32 i = 0; i < num_caps; i++) {
+            const util::BitPack32 cap = { caps[i] };
+            if (GetCapabilityType(cap) == CapabilityType::MapRange) {
+                /* Check that the pair cap exists. */
+                R_UNLESS((++i) < num_caps, svc::ResultInvalidCombination());
+
+                /* Check the pair cap is a map range cap. */
+                const util::BitPack32 size_cap = { caps[i] };
+                R_UNLESS(GetCapabilityType(size_cap) == CapabilityType::MapRange, svc::ResultInvalidCombination());
+
+                /* Map the range. */
+                R_TRY(this->MapRange(cap, size_cap, page_table));
+            } else {
+                R_TRY(this->SetCapability(cap, set_flags, set_svc, page_table));
+            }
+        }
+
+        return ResultSuccess();
     }
 
 }

libraries/libmesosphere/source/kern_k_page_table_base.cpp

@@ -629,6 +629,18 @@ namespace ams::kern {
         return cur_block_address == GetHeapVirtualAddress(cur_addr) && cur_block_pages == (cur_size / PageSize);
     }
 
+    Result KPageTableBase::MapIo(KPhysicalAddress phys_addr, size_t size, KMemoryPermission perm) {
+        MESOSPHERE_TODO_IMPLEMENT();
+    }
+
+    Result KPageTableBase::MapStatic(KPhysicalAddress phys_addr, size_t size, KMemoryPermission perm) {
+        MESOSPHERE_TODO_IMPLEMENT();
+    }
+
+    Result KPageTableBase::MapRegion(KMemoryRegionType region_type, KMemoryPermission perm) {
+        MESOSPHERE_TODO_IMPLEMENT();
+    }
+
     Result KPageTableBase::MapPages(KProcessAddress *out_addr, size_t num_pages, size_t alignment, KPhysicalAddress phys_addr, bool is_pa_valid, KProcessAddress region_start, size_t region_num_pages, KMemoryState state, KMemoryPermission perm) {
         MESOSPHERE_ASSERT(util::IsAligned(alignment, PageSize) && alignment >= PageSize);
 

libraries/libvapours/include/vapours/results/svc_results.hpp

@@ -58,7 +58,7 @@ namespace ams::svc {
     R_DEFINE_ERROR_RESULT(SessionClosed,                123);
     R_DEFINE_ERROR_RESULT(NotHandled,                   124);
     R_DEFINE_ERROR_RESULT(InvalidState,                 125);
-    R_DEFINE_ERROR_RESULT(ReservedValue,                126);
+    R_DEFINE_ERROR_RESULT(ReservedUsed,                 126);
     R_DEFINE_ERROR_RESULT(NotSupported,                 127);
     R_DEFINE_ERROR_RESULT(Debug,                        128);
     R_DEFINE_ERROR_RESULT(ThreadNotOwned,               129);