kern: implement KThreadLocalPage

libraries/libmesosphere/include/mesosphere/kern_k_thread_local_page.hpp

@@ -0,0 +1,93 @@
+/*
+ * 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 <mesosphere/kern_common.hpp>
+#include <mesosphere/kern_select_cpu.hpp>
+#include <mesosphere/kern_slab_helpers.hpp>
+#include <mesosphere/kern_k_page_buffer.hpp>
+
+namespace ams::kern {
+
+    class KThread;
+    class KProcess;
+
+    class KThreadLocalPage : public util::IntrusiveRedBlackTreeBaseNode<KThreadLocalPage>, public KSlabAllocated<KThreadLocalPage> {
+        public:
+            static constexpr size_t RegionsPerPage = PageSize / ams::svc::ThreadLocalRegionSize;
+            static_assert(RegionsPerPage > 0);
+        private:
+            KProcessAddress virt_addr;
+            KProcess *owner;
+            bool is_region_free[RegionsPerPage];
+        public:
+            constexpr explicit KThreadLocalPage(KProcessAddress addr) : virt_addr(addr), owner(nullptr), is_region_free() {
+                for (size_t i = 0; i < RegionsPerPage; i++) {
+                    this->is_region_free[i] = true;
+                }
+            }
+
+            constexpr explicit KThreadLocalPage() : KThreadLocalPage(Null<KProcessAddress>) { /* ... */ }
+
+            constexpr ALWAYS_INLINE KProcessAddress GetAddress() const { return this->virt_addr; }
+        private:
+            constexpr ALWAYS_INLINE KProcessAddress GetRegionAddress(size_t i) {
+                return this->GetAddress() + i * ams::svc::ThreadLocalRegionSize;
+            }
+
+            constexpr ALWAYS_INLINE bool Contains(KProcessAddress addr) {
+                return this->GetAddress() <= addr && addr < this->GetAddress() + PageSize;
+            }
+
+            constexpr ALWAYS_INLINE size_t GetRegionIndex(KProcessAddress addr) {
+                MESOSPHERE_ASSERT(util::IsAligned(GetInteger(addr), ams::svc::ThreadLocalRegionSize));
+                MESOSPHERE_ASSERT(this->Contains(addr));
+                return (addr - this->GetAddress()) / ams::svc::ThreadLocalRegionSize;
+            }
+        public:
+            Result Initialize(KProcess *process);
+            Result Finalize();
+
+            KProcessAddress Reserve();
+            void Release(KProcessAddress addr);
+
+            bool IsAllUsed() const {
+                for (size_t i = 0; i < RegionsPerPage; i++) {
+                    if (this->is_region_free[i]) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+
+            bool IsAllFree() const {
+                for (size_t i = 0; i < RegionsPerPage; i++) {
+                    if (!this->is_region_free[i]) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+
+            bool IsAnyUsed() const {
+                return !this->IsAllFree();
+            }
+
+            bool IsAnyFree() const {
+                return !this->IsAllUsed();
+            }
+    };
+
+}