kern: Implement KAutoObject, KSlabHeap, KLightLock

2025-05-20 01:45:07 -04:00 · 2020-01-29 22:06:25 -08:00 · 2020-01-29 22:06:25 -08:00 · 2faf3d33b5
commit 2faf3d33b5
parent bb4ade30e4
16 changed files with 923 additions and 5 deletions
--- a/libraries/libmesosphere/include/mesosphere/kern_k_class_token.hpp
+++ b/libraries/libmesosphere/include/mesosphere/kern_k_class_token.hpp
@ -0,0 +1,127 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <mesosphere/kern_panic.hpp>
+#include <mesosphere/kern_k_typed_address.hpp>
+
+namespace ams::kern {
+
+    class KAutoObject;
+
+    class KClassTokenGenerator {
+        public:
+            using TokenBaseType = u16;
+        public:
+            static constexpr size_t BaseClassBits = 8;
+            static constexpr size_t FinalClassBits = (sizeof(TokenBaseType) * CHAR_BIT) - BaseClassBits;
+            /* One bit per base class. */
+            static constexpr size_t NumBaseClasses = BaseClassBits;
+            /* Final classes are permutations of three bits. */
+            static constexpr size_t NumFinalClasses = [] {
+                TokenBaseType index = 0;
+                for (size_t i = 0; i < FinalClassBits; i++) {
+                    for (size_t j = i + 1; j < FinalClassBits; j++) {
+                        for (size_t k = j + 1; k < FinalClassBits; k++) {
+                            index++;
+                        }
+                    }
+                }
+                return index;
+            }();
+        private:
+            template<TokenBaseType Index>
+            static constexpr inline TokenBaseType BaseClassToken = BIT(Index);
+
+            template<TokenBaseType Index>
+            static constexpr inline TokenBaseType FinalClassToken = [] {
+                TokenBaseType index = 0;
+                for (size_t i = 0; i < FinalClassBits; i++) {
+                    for (size_t j = i + 1; j < FinalClassBits; j++) {
+                        for (size_t k = j + 1; k < FinalClassBits; k++) {
+                            if ((index++) == Index) {
+                                return ((1ul << i) | (1ul << j) | (1ul << k)) << BaseClassBits;
+                            }
+                        }
+                    }
+                }
+                __builtin_unreachable();
+            }();
+
+            template<typename T>
+            static constexpr inline TokenBaseType GetClassToken() {
+                static_assert(std::is_base_of<KAutoObject, T>::value);
+                if constexpr (std::is_same<T, KAutoObject>::value) {
+                    static_assert(T::ObjectType == ObjectType::BaseClassesStart);
+                    return BaseClassToken<0>;
+                } else if constexpr (!std::is_final<T>::value) {
+                    static_assert(ObjectType::BaseClassesStart < T::ObjectType && T::ObjectType < ObjectType::BaseClassesEnd);
+                    constexpr auto ClassIndex = static_cast<TokenBaseType>(T::ObjectType) - static_cast<TokenBaseType>(ObjectType::BaseClassesStart);
+                    return BaseClassToken<ClassIndex> | GetClassToken<typename T::BaseClass>();
+                } else if constexpr (ObjectType::FinalClassesStart <= T::ObjectType && T::ObjectType < ObjectType::FinalClassesEnd) {
+                    constexpr auto ClassIndex = static_cast<TokenBaseType>(T::ObjectType) - static_cast<TokenBaseType>(ObjectType::FinalClassesStart);
+                    return FinalClassToken<ClassIndex> | GetClassToken<typename T::BaseClass>();
+                } else {
+                    static_assert(!std::is_same<T, T>::value, "GetClassToken: Invalid Type");
+                }
+            };
+        public:
+            enum class ObjectType {
+                BaseClassesStart = 0,
+
+                KAutoObject = BaseClassesStart,
+                KSynchronizationObject,
+                KReadableEvent,
+
+                BaseClassesEnd,
+
+                FinalClassesStart = BaseClassesEnd,
+
+                KInterruptEvent = FinalClassesStart,
+                KDebug,
+                KThread,
+                KServerPort,
+                KServerSession,
+                KClientPort,
+                KClientSession,
+                KProcess,
+                KResourceLimit,
+                KLightSession,
+                KPort,
+                KSession,
+                KSharedMemory,
+                KEvent,
+                KWritableEvent,
+                KLightClientSession,
+                KLightServerSession,
+                KTransferMemory,
+                KDeviceAddressSpace,
+                KSessionRequest,
+                KCodeMemory,
+
+                FinalClassesEnd = FinalClassesStart + NumFinalClasses,
+            };
+
+            template<typename T>
+            static constexpr inline TokenBaseType ClassToken = GetClassToken<T>();
+    };
+
+    using ClassTokenType = KClassTokenGenerator::TokenBaseType;
+
+    template<typename T>
+    static constexpr inline ClassTokenType ClassToken = KClassTokenGenerator::ClassToken<T>;
+
+}