kern: Implement KAutoObject, KSlabHeap, KLightLock

libraries/libmesosphere/include/mesosphere/kern_k_slab_heap.hpp

@@ -0,0 +1,183 @@
+/*
+ * 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 {
+
+    namespace impl {
+
+        class KSlabHeapImpl {
+            NON_COPYABLE(KSlabHeapImpl);
+            NON_MOVEABLE(KSlabHeapImpl);
+            public:
+                struct Node {
+                    Node *next;
+                };
+            private:
+                std::atomic<Node *> head;
+                size_t              obj_size;
+            public:
+                constexpr KSlabHeapImpl() : head(nullptr), obj_size(0) { /* ... */ }
+
+                void Initialize(size_t size) {
+                    MESOSPHERE_INIT_ABORT_UNLESS(this->head == nullptr);
+                    this->obj_size = size;
+                }
+
+                Node *GetHead() const {
+                    return this->head;
+                }
+
+                size_t GetObjectSize() const {
+                    return this->obj_size;
+                }
+
+                void *Allocate() {
+                    Node *ret = this->head.load();
+
+                    do {
+                        if (AMS_UNLIKELY(ret == nullptr)) {
+                            break;
+                        }
+                    } while (!this->head.compare_exchange_weak(ret, ret->next));
+
+                    return ret;
+                }
+
+                void Free(void *obj) {
+                    Node *node = reinterpret_cast<Node *>(obj);
+
+                    Node *cur_head = this->head.load();
+                    do {
+                        node->next = cur_head;
+                    } while (!this->head.compare_exchange_weak(cur_head, node));
+                }
+        };
+
+    }
+
+    class KSlabHeapBase {
+        NON_COPYABLE(KSlabHeapBase);
+        NON_MOVEABLE(KSlabHeapBase);
+        private:
+            using Impl = impl::KSlabHeapImpl;
+        private:
+            Impl impl;
+            uintptr_t peak;
+            uintptr_t start;
+            uintptr_t end;
+        private:
+            ALWAYS_INLINE Impl *GetImpl() {
+                return std::addressof(this->impl);
+            }
+            ALWAYS_INLINE const Impl *GetImpl() const {
+                return std::addressof(this->impl);
+            }
+        public:
+            constexpr KSlabHeapBase() : impl(), peak(0), start(0), end(0) { /* ... */ }
+
+            ALWAYS_INLINE bool Contains(uintptr_t address) const {
+                return this->start <= address && address < this->end;
+            }
+
+            void InitializeImpl(size_t obj_size, void *memory, size_t memory_size) {
+                /* Ensure we don't initialize a slab using null memory. */
+                MESOSPHERE_ABORT_UNLESS(memory != nullptr);
+
+                /* Initialize the base allocator. */
+                this->GetImpl()->Initialize(obj_size);
+
+                /* Set our tracking variables. */
+                const size_t num_obj = (memory_size / obj_size);
+                this->start = reinterpret_cast<uintptr_t>(memory);
+                this->end = this->start + num_obj * obj_size;
+                this->peak = this->start;
+
+                /* Free the objects. */
+                u8 *cur = reinterpret_cast<u8 *>(this->end);
+
+                for (size_t i = 0; i < num_obj; i++) {
+                    cur -= obj_size;
+                    this->GetImpl()->Free(cur);
+                }
+            }
+
+            size_t GetSlabHeapSize() const {
+                return (this->end - this->start) / this->GetObjectSize();
+            }
+
+            size_t GetObjectSize() const {
+                return this->GetImpl()->GetObjectSize();
+            }
+
+            void *AllocateImpl() {
+                void *obj = this->GetImpl()->Allocate();
+
+                /* TODO: under some debug define, track the peak for statistics, as N does? */
+
+                return obj;
+            }
+
+            void FreeImpl(void *obj) {
+                /* Don't allow freeing an object that wasn't allocated from this heap. */
+                MESOSPHERE_ABORT_UNLESS(this->Contains(reinterpret_cast<uintptr_t>(obj)));
+
+                this->GetImpl()->Free(obj);
+            }
+
+            size_t GetObjectIndexImpl(const void *obj) const {
+                return (reinterpret_cast<uintptr_t>(obj) - this->start) / this->GetObjectSize();
+            }
+
+            size_t GetPeakIndex() const {
+                return this->GetObjectIndexImpl(reinterpret_cast<const void *>(this->peak));
+            }
+
+            uintptr_t GetSlabHeapAddress() const {
+                return this->start;
+            }
+    };
+
+    template<typename T>
+    class KSlabHeap : public KSlabHeapBase {
+        public:
+            constexpr KSlabHeap() : KSlabHeapBase() { /* ... */ }
+
+            void Initialize(void *memory, size_t memory_size) {
+                this->InitializeImpl(sizeof(T), memory, memory_size);
+            }
+
+            T *Allocate() {
+                T *obj = reinterpret_cast<T *>(this->AllocateImpl());
+                if (AMS_LIKELY(obj != nullptr)) {
+                    new (obj) T();
+                }
+                return obj;
+            }
+
+            void Free(T *obj) {
+                this->FreeImpl(obj);
+            }
+
+            size_t GetObjectIndex(const T *obj) const {
+                return this->GetObjectIndexImpl(obj);
+            }
+    };
+
+}