From 9438c9203b7be20147b990ff05e1d99190d18928 Mon Sep 17 00:00:00 2001 From: Fabian Imhof Date: Thu, 20 Feb 2025 09:38:28 +0000 Subject: added new and delete override --- arch/x86_64/include/arch/kernel/interrupt.hpp | 26 +++++++++++++++++++++ .../arch/memory/heap/linked_list_allocator.hpp | 2 ++ .../arch/memory/heap/new_delete_override.hpp | 27 ++++++++++++++++++++++ 3 files changed, 55 insertions(+) create mode 100644 arch/x86_64/include/arch/kernel/interrupt.hpp create mode 100644 arch/x86_64/include/arch/memory/heap/new_delete_override.hpp (limited to 'arch/x86_64/include') diff --git a/arch/x86_64/include/arch/kernel/interrupt.hpp b/arch/x86_64/include/arch/kernel/interrupt.hpp new file mode 100644 index 0000000..521318d --- /dev/null +++ b/arch/x86_64/include/arch/kernel/interrupt.hpp @@ -0,0 +1,26 @@ +#ifndef TEACHOS_ARCH_X86_64_KERNEL_INTERRUPT_HPP +#define TEACHOS_ARCH_X86_64_KERNEL_INTERRUPT_HPP + +#include + +namespace teachos::arch::kernel +{ + struct stack_frame + { + std::uint16_t instruction_pointer; + std::uint16_t cs; + std::uint16_t flags; + std::uint16_t sp; + std::uint16_t ss; + }; + + /** + * @brief Handles an interrupt + * + * https://clang.llvm.org/docs/AttributeReference.html#interrupt-x86 + */ + __attribute__((interrupt)) extern "C" auto interrupt_handler(struct stack_frame * frame) -> void; + +} // namespace teachos::arch::kernel + +#endif // TEACHOS_ARCH_X86_64_KERNEL_INTERRUPT_HPP diff --git a/arch/x86_64/include/arch/memory/heap/linked_list_allocator.hpp b/arch/x86_64/include/arch/memory/heap/linked_list_allocator.hpp index 06b21bb..99c9218 100644 --- a/arch/x86_64/include/arch/memory/heap/linked_list_allocator.hpp +++ b/arch/x86_64/include/arch/memory/heap/linked_list_allocator.hpp @@ -127,6 +127,8 @@ namespace teachos::arch::memory::heap shared::mutex mutex; ///< Mutex to ensure only one thread calls allocate or deallocate at once. }; + extern linked_list_allocator kernel_heap; + } // namespace teachos::arch::memory::heap #endif // TEACHOS_ARCH_X86_64_MEMORY_HEAP_LINKED_LIST_ALLOCATOR_HPP diff --git a/arch/x86_64/include/arch/memory/heap/new_delete_override.hpp b/arch/x86_64/include/arch/memory/heap/new_delete_override.hpp new file mode 100644 index 0000000..c51c737 --- /dev/null +++ b/arch/x86_64/include/arch/memory/heap/new_delete_override.hpp @@ -0,0 +1,27 @@ +#ifndef TEACHOS_ARCH_X86_64_MEMORY_NEW_DELETE_OVERRIDE_CONCEPT_HPP +#define TEACHOS_ARCH_X86_64_MEMORY_NEW_DELETE_OVERRIDE_CONCEPT_HPP + +#include "linked_list_allocator.hpp" +#include + +void * operator new(std::size_t size) { teachos::arch::memory::heap::kernel_heap.allocate(size); } + +void operator delete(void * pointer) noexcept { teachos::arch::memory::heap::kernel_heap.deallocate(pointer, 64); } + +void operator delete(void * pointer, std::size_t size) noexcept +{ + teachos::arch::memory::heap::kernel_heap.deallocate(pointer, size); +} + +void * operator new[](std::size_t size) { teachos::arch::memory::heap::kernel_heap.allocate(size); } + +void operator delete[](void * pointer) noexcept +{ + // NOPE +} + +void operator delete[](void * pointer, std::size_t size) noexcept +{ + teachos::arch::memory::heap::kernel_heap.deallocate(pointer, size); +} +#endif // TEACHOS_ARCH_X86_64_KERNEL_NEW_DELETE_OVERRIDE_HPP \ No newline at end of file -- cgit v1.2.3 From bff6c39a8d4571cd5c41e3926d5fc1428916f32c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matteo=20Gm=C3=BCr?= Date: Thu, 20 Feb 2025 10:07:03 +0000 Subject: Create global heap allocator attempt --- .../arch/memory/heap/global_heap_allocator.hpp | 46 ++++++++++++++++++++++ .../arch/memory/heap/new_delete_override.hpp | 27 ------------- 2 files changed, 46 insertions(+), 27 deletions(-) create mode 100644 arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp delete mode 100644 arch/x86_64/include/arch/memory/heap/new_delete_override.hpp (limited to 'arch/x86_64/include') diff --git a/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp b/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp new file mode 100644 index 0000000..b7b2073 --- /dev/null +++ b/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp @@ -0,0 +1,46 @@ +#ifndef TEACHOS_ARCH_X86_64_MEMORY_HEAP_GLOBAL_HEAP_ALLOCATOR_HPP +#define TEACHOS_ARCH_X86_64_MEMORY_HEAP_GLOBAL_HEAP_ALLOCATOR_HPP + +#include "arch/memory/heap/linked_list_allocator.hpp" + +namespace teachos::arch::memory::heap +{ + struct global_heap_allocator + { + static auto allocate(std::size_t size) -> void *; + + static auto deallocate(void * pointer, std::size_t size) -> void; + }; +} // namespace teachos::arch::memory::heap + +auto operator new(std::size_t size) -> void * +{ + return teachos::arch::memory::heap::global_heap_allocator::allocate(size); +} + +auto operator delete(void * pointer) noexcept -> void +{ + teachos::arch::memory::heap::global_heap_allocator::deallocate(pointer, 64); +} + +auto operator delete(void * pointer, std::size_t size) noexcept -> void +{ + teachos::arch::memory::heap::global_heap_allocator::deallocate(pointer, size); +} + +auto operator new[](std::size_t size) -> void * +{ + return teachos::arch::memory::heap::global_heap_allocator::allocate(size); +} + +auto operator delete[](void * pointer) noexcept -> void +{ + teachos::arch::memory::heap::global_heap_allocator::deallocate(pointer, 64); +} + +auto operator delete[](void * pointer, std::size_t size) noexcept -> void +{ + teachos::arch::memory::heap::global_heap_allocator::deallocate(pointer, size); +} + +#endif // TEACHOS_ARCH_X86_64_MEMORY_HEAP_GLOBAL_HEAP_ALLOCATOR_HPP diff --git a/arch/x86_64/include/arch/memory/heap/new_delete_override.hpp b/arch/x86_64/include/arch/memory/heap/new_delete_override.hpp deleted file mode 100644 index c51c737..0000000 --- a/arch/x86_64/include/arch/memory/heap/new_delete_override.hpp +++ /dev/null @@ -1,27 +0,0 @@ -#ifndef TEACHOS_ARCH_X86_64_MEMORY_NEW_DELETE_OVERRIDE_CONCEPT_HPP -#define TEACHOS_ARCH_X86_64_MEMORY_NEW_DELETE_OVERRIDE_CONCEPT_HPP - -#include "linked_list_allocator.hpp" -#include - -void * operator new(std::size_t size) { teachos::arch::memory::heap::kernel_heap.allocate(size); } - -void operator delete(void * pointer) noexcept { teachos::arch::memory::heap::kernel_heap.deallocate(pointer, 64); } - -void operator delete(void * pointer, std::size_t size) noexcept -{ - teachos::arch::memory::heap::kernel_heap.deallocate(pointer, size); -} - -void * operator new[](std::size_t size) { teachos::arch::memory::heap::kernel_heap.allocate(size); } - -void operator delete[](void * pointer) noexcept -{ - // NOPE -} - -void operator delete[](void * pointer, std::size_t size) noexcept -{ - teachos::arch::memory::heap::kernel_heap.deallocate(pointer, size); -} -#endif // TEACHOS_ARCH_X86_64_KERNEL_NEW_DELETE_OVERRIDE_HPP \ No newline at end of file -- cgit v1.2.3 From 6c4ce82c3f9cc920bcde74fc10fdfd39b477b9f4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matteo=20Gm=C3=BCr?= Date: Thu, 20 Feb 2025 10:41:11 +0000 Subject: Fix compilation issues --- .../arch/memory/heap/global_heap_allocator.hpp | 33 ++++++---------------- 1 file changed, 9 insertions(+), 24 deletions(-) (limited to 'arch/x86_64/include') diff --git a/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp b/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp index b7b2073..871f4f8 100644 --- a/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp +++ b/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp @@ -10,37 +10,22 @@ namespace teachos::arch::memory::heap static auto allocate(std::size_t size) -> void *; static auto deallocate(void * pointer, std::size_t size) -> void; + + private: + static linked_list_allocator allocator; }; } // namespace teachos::arch::memory::heap -auto operator new(std::size_t size) -> void * -{ - return teachos::arch::memory::heap::global_heap_allocator::allocate(size); -} +auto operator new(std::size_t size) -> void *; -auto operator delete(void * pointer) noexcept -> void -{ - teachos::arch::memory::heap::global_heap_allocator::deallocate(pointer, 64); -} +auto operator delete(void * pointer) noexcept -> void; -auto operator delete(void * pointer, std::size_t size) noexcept -> void -{ - teachos::arch::memory::heap::global_heap_allocator::deallocate(pointer, size); -} +auto operator delete(void * pointer, std::size_t size) noexcept -> void; -auto operator new[](std::size_t size) -> void * -{ - return teachos::arch::memory::heap::global_heap_allocator::allocate(size); -} +auto operator new[](std::size_t size) -> void *; -auto operator delete[](void * pointer) noexcept -> void -{ - teachos::arch::memory::heap::global_heap_allocator::deallocate(pointer, 64); -} +auto operator delete[](void * pointer) noexcept -> void; -auto operator delete[](void * pointer, std::size_t size) noexcept -> void -{ - teachos::arch::memory::heap::global_heap_allocator::deallocate(pointer, size); -} +auto operator delete[](void * pointer, std::size_t size) noexcept -> void; #endif // TEACHOS_ARCH_X86_64_MEMORY_HEAP_GLOBAL_HEAP_ALLOCATOR_HPP -- cgit v1.2.3 From cd502936227e48a36d9e933d26aac2ee29d3bc29 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matteo=20Gm=C3=BCr?= Date: Thu, 20 Feb 2025 10:58:17 +0000 Subject: Add singelton implementation for global heap allocator --- arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'arch/x86_64/include') diff --git a/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp b/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp index 871f4f8..f391936 100644 --- a/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp +++ b/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp @@ -12,7 +12,7 @@ namespace teachos::arch::memory::heap static auto deallocate(void * pointer, std::size_t size) -> void; private: - static linked_list_allocator allocator; + static auto get_underlying_allocator() -> linked_list_allocator &; }; } // namespace teachos::arch::memory::heap -- cgit v1.2.3 From 27874721a35fe7ccde843c7ab88ab72e74fe6b42 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matteo=20Gm=C3=BCr?= Date: Thu, 20 Feb 2025 12:14:30 +0000 Subject: Make allocation type configurable --- .../include/arch/memory/heap/global_heap_allocator.hpp | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) (limited to 'arch/x86_64/include') diff --git a/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp b/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp index f391936..a4ece57 100644 --- a/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp +++ b/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp @@ -5,6 +5,13 @@ namespace teachos::arch::memory::heap { + enum class heap_allocator_type : uint8_t + { + NONE, + BUMP, + LINKED_LIST + }; + struct global_heap_allocator { static auto allocate(std::size_t size) -> void *; @@ -12,7 +19,11 @@ namespace teachos::arch::memory::heap static auto deallocate(void * pointer, std::size_t size) -> void; private: - static auto get_underlying_allocator() -> linked_list_allocator &; + static heap_allocator_type allocator_type; + + static auto register_heap_allocator_type(heap_allocator_type new_type) -> void; + + static auto create_or_get() -> linked_list_allocator &; }; } // namespace teachos::arch::memory::heap -- cgit v1.2.3 From 00fd8cf8f72d6c5c3d6150f3ec833ded9e34b2b1 Mon Sep 17 00:00:00 2001 From: Fabian Imhof Date: Thu, 20 Feb 2025 16:05:19 +0000 Subject: add heap_allocator base class --- arch/x86_64/include/arch/memory/heap/bump_allocator.hpp | 4 +++- .../include/arch/memory/heap/global_heap_allocator.hpp | 6 +++--- arch/x86_64/include/arch/memory/heap/heap_allocator.hpp | 16 ++++++++++++++++ .../include/arch/memory/heap/linked_list_allocator.hpp | 3 ++- 4 files changed, 24 insertions(+), 5 deletions(-) create mode 100644 arch/x86_64/include/arch/memory/heap/heap_allocator.hpp (limited to 'arch/x86_64/include') diff --git a/arch/x86_64/include/arch/memory/heap/bump_allocator.hpp b/arch/x86_64/include/arch/memory/heap/bump_allocator.hpp index 545b72f..209f8b3 100644 --- a/arch/x86_64/include/arch/memory/heap/bump_allocator.hpp +++ b/arch/x86_64/include/arch/memory/heap/bump_allocator.hpp @@ -1,6 +1,8 @@ #ifndef TEACHOS_ARCH_X86_64_MEMORY_HEAP_BUMP_ALLOCATOR_HPP #define TEACHOS_ARCH_X86_64_MEMORY_HEAP_BUMP_ALLOCATOR_HPP +#include "arch/memory/heap/heap_allocator.hpp" + #include #include @@ -10,7 +12,7 @@ namespace teachos::arch::memory::heap * @brief Simple heap allocator, which allocates linearly and leaks all allocated memory, because it does not really * deallocate anything. */ - struct bump_allocator + struct bump_allocator : heap_allocator { /** * @brief Constructor. diff --git a/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp b/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp index a4ece57..e8555df 100644 --- a/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp +++ b/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp @@ -14,6 +14,8 @@ namespace teachos::arch::memory::heap struct global_heap_allocator { + static auto register_heap_allocator_type(heap_allocator_type new_type) -> void; + static auto allocate(std::size_t size) -> void *; static auto deallocate(void * pointer, std::size_t size) -> void; @@ -21,9 +23,7 @@ namespace teachos::arch::memory::heap private: static heap_allocator_type allocator_type; - static auto register_heap_allocator_type(heap_allocator_type new_type) -> void; - - static auto create_or_get() -> linked_list_allocator &; + static auto create_or_get() -> heap_allocator &; }; } // namespace teachos::arch::memory::heap diff --git a/arch/x86_64/include/arch/memory/heap/heap_allocator.hpp b/arch/x86_64/include/arch/memory/heap/heap_allocator.hpp new file mode 100644 index 0000000..9e37bd4 --- /dev/null +++ b/arch/x86_64/include/arch/memory/heap/heap_allocator.hpp @@ -0,0 +1,16 @@ +#ifndef TEACHOS_ARCH_X86_64_MEMORY_HEAP_HEAP_ALLOCATOR_HPP +#define TEACHOS_ARCH_X86_64_MEMORY_HEAP_HEAP_ALLOCATOR_HPP + +#include + +namespace teachos::arch::memory::heap +{ + struct heap_allocator + { + virtual auto allocate(std::size_t size) -> void * = 0; + + virtual auto deallocate(void * pointer, std::size_t size) -> void = 0; + }; +} // namespace teachos::arch::memory::heap + +#endif // TEACHOS_ARCH_X86_64_MEMORY_HEAP_HEAP_ALLOCATOR_HPP diff --git a/arch/x86_64/include/arch/memory/heap/linked_list_allocator.hpp b/arch/x86_64/include/arch/memory/heap/linked_list_allocator.hpp index 99c9218..966e28e 100644 --- a/arch/x86_64/include/arch/memory/heap/linked_list_allocator.hpp +++ b/arch/x86_64/include/arch/memory/heap/linked_list_allocator.hpp @@ -1,6 +1,7 @@ #ifndef TEACHOS_ARCH_X86_64_MEMORY_HEAP_LINKED_LIST_ALLOCATOR_HPP #define TEACHOS_ARCH_X86_64_MEMORY_HEAP_LINKED_LIST_ALLOCATOR_HPP +#include "arch/memory/heap/heap_allocator.hpp" #include "arch/memory/heap/memory_block.hpp" #include "arch/shared/mutex.hpp" @@ -10,7 +11,7 @@ namespace teachos::arch::memory::heap * @brief Sorted by address list of memory holes (free memory). Uses free holes itself to save the information, * containing the size and pointer to the next hole. Resulting in a singly linked list. */ - struct linked_list_allocator + struct linked_list_allocator : heap_allocator { /** * @brief Constructor. -- cgit v1.2.3 From 405b5b1018397bff48e32c75e10a6b3b58bb6a20 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matteo=20Gm=C3=BCr?= Date: Fri, 21 Feb 2025 14:13:39 +0000 Subject: Update factory method code --- .../include/arch/memory/heap/bump_allocator.hpp | 4 ++-- arch/x86_64/include/arch/memory/heap/concept.hpp | 22 ---------------------- .../arch/memory/heap/global_heap_allocator.hpp | 8 ++++---- .../include/arch/memory/heap/heap_allocator.hpp | 5 +++++ 4 files changed, 11 insertions(+), 28 deletions(-) delete mode 100644 arch/x86_64/include/arch/memory/heap/concept.hpp (limited to 'arch/x86_64/include') diff --git a/arch/x86_64/include/arch/memory/heap/bump_allocator.hpp b/arch/x86_64/include/arch/memory/heap/bump_allocator.hpp index 209f8b3..d5f4561 100644 --- a/arch/x86_64/include/arch/memory/heap/bump_allocator.hpp +++ b/arch/x86_64/include/arch/memory/heap/bump_allocator.hpp @@ -34,7 +34,7 @@ namespace teachos::arch::memory::heap * @param size Amount of memory to allocate. * @return Address of the first byte to the allocated area */ - auto allocate(std::size_t size) -> void *; + auto allocate(std::size_t size) -> void * override; /** * @brief Deallocates heap memory at the specified location. @@ -44,7 +44,7 @@ namespace teachos::arch::memory::heap * @param pointer Pointer to the location which should be deallocated. * @param size Size of the underlying memory area we want to deallocate. */ - auto deallocate(void * pointer, std::size_t size) -> void; + auto deallocate(void * pointer, std::size_t size) -> void override; private: std::size_t heap_start; ///< Start of the allocatable heap area diff --git a/arch/x86_64/include/arch/memory/heap/concept.hpp b/arch/x86_64/include/arch/memory/heap/concept.hpp deleted file mode 100644 index e22e35f..0000000 --- a/arch/x86_64/include/arch/memory/heap/concept.hpp +++ /dev/null @@ -1,22 +0,0 @@ -#ifndef TEACHOS_ARCH_X86_64_MEMORY_HEAP_CONCEPT_HPP -#define TEACHOS_ARCH_X86_64_MEMORY_HEAP_CONCEPT_HPP - -#include - -namespace teachos::arch::memory::heap -{ - std::size_t constexpr HEAP_START = 0x100000000; - std::size_t constexpr HEAP_SIZE = 100 * 1024; - - /** - * @brief Heap allocator concept required for allocating and managing free space on the heap. - */ - template - concept HeapAllocator = requires(T t, uint8_t * pointer, std::size_t size) { - { t.allocate(size) } -> std::same_as; - { t.deallocate(pointer, size) } -> std::same_as; - }; - -} // namespace teachos::arch::memory::heap - -#endif // TEACHOS_ARCH_X86_64_MEMORY_HEAP_CONCEPT_HPP diff --git a/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp b/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp index e8555df..1b1d964 100644 --- a/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp +++ b/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp @@ -1,7 +1,7 @@ #ifndef TEACHOS_ARCH_X86_64_MEMORY_HEAP_GLOBAL_HEAP_ALLOCATOR_HPP #define TEACHOS_ARCH_X86_64_MEMORY_HEAP_GLOBAL_HEAP_ALLOCATOR_HPP -#include "arch/memory/heap/linked_list_allocator.hpp" +#include "arch/memory/heap/heap_allocator.hpp" namespace teachos::arch::memory::heap { @@ -14,16 +14,16 @@ namespace teachos::arch::memory::heap struct global_heap_allocator { - static auto register_heap_allocator_type(heap_allocator_type new_type) -> void; + static auto register_heap_allocator(heap_allocator_type new_type) -> void; static auto allocate(std::size_t size) -> void *; static auto deallocate(void * pointer, std::size_t size) -> void; private: - static heap_allocator_type allocator_type; + static heap_allocator * allocator_instance; - static auto create_or_get() -> heap_allocator &; + static auto get() -> heap_allocator &; }; } // namespace teachos::arch::memory::heap diff --git a/arch/x86_64/include/arch/memory/heap/heap_allocator.hpp b/arch/x86_64/include/arch/memory/heap/heap_allocator.hpp index 9e37bd4..62ba963 100644 --- a/arch/x86_64/include/arch/memory/heap/heap_allocator.hpp +++ b/arch/x86_64/include/arch/memory/heap/heap_allocator.hpp @@ -5,8 +5,13 @@ namespace teachos::arch::memory::heap { + std::size_t constexpr HEAP_START = 0x100000000; + std::size_t constexpr HEAP_SIZE = 100 * 1024; + struct heap_allocator { + virtual ~heap_allocator() {} + virtual auto allocate(std::size_t size) -> void * = 0; virtual auto deallocate(void * pointer, std::size_t size) -> void = 0; -- cgit v1.2.3 From 93cc8aa1c0e4ba991f0503c609702e1c63a240c7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matteo=20Gm=C3=BCr?= Date: Fri, 21 Feb 2025 15:23:51 +0000 Subject: Add documentation to new components --- .../arch/memory/heap/global_heap_allocator.hpp | 49 ++++++++++++++++++++-- .../include/arch/memory/heap/heap_allocator.hpp | 22 ++++++++++ .../include/arch/memory/heap/memory_block.hpp | 1 - .../include/arch/memory/paging/page_entry.hpp | 3 +- 4 files changed, 68 insertions(+), 7 deletions(-) (limited to 'arch/x86_64/include') diff --git a/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp b/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp index 1b1d964..6719bec 100644 --- a/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp +++ b/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp @@ -5,24 +5,65 @@ namespace teachos::arch::memory::heap { + /** + * @brief Possible types that should be constructed by the register_heap_allocator factory method. + * Creates the underlying heap allocator instance that is then used by all global allocations using new and delete + */ enum class heap_allocator_type : uint8_t { - NONE, - BUMP, - LINKED_LIST + NONE, ///< Don't use any heap allocation implementation, this will result in all calls of new and delte halting + ///< further execution of the kernel + BUMP, ///< Use the bump allocator as the heap allocation implementation, be aware that using this allocator leaks + ///< memory, because there is no delete implementation + LINKED_LIST ///< Use the linked list allocator as the heap implementation, recommended because it does not leak + ///< memory and }; + /** + * @brief Global instance of a heap allocator implementation created by the factory method pattern @see + * https://refactoring.guru/design-patterns/factory-method for more information. + * + * @note Can only be registered once and only once the kernel and the heap part of the kernel has been remapped + * successfully. If the instance is created before than the device will abort, because it acceses unmapped memory + * areas. + */ struct global_heap_allocator { + /** + * @brief Registers the heap allocation implementation that should be used by the global heap allocator. + * Meaning all future calls to the global new or delete will be forwarded to the allocate and deallocate calls of + * the underlying heap allocation implementation + * + * @param new_type Type of the heap allocation implementation we want to instantiate + */ static auto register_heap_allocator(heap_allocator_type new_type) -> void; + /** + * @brief Allocates the given amount of memory and returns the pointer to the start of the allocatable memory area. + * Simply forwards the call to the allocate method of the registered heap_allocation implementation + * + * @param size Amount of bytes that should be allocated + * @return void* Pointer to the start of the allocatable memory area + */ static auto allocate(std::size_t size) -> void *; + /** + * @brief Deallocated the given amount of memory starting from the given pointer address. + * Simply forwards the call to the deallocate method of the registered heap_allocation implementation + * + * @param pointer Previously allocated memory area, that should now be freed + * @param size Size of the memory area we want to free + */ static auto deallocate(void * pointer, std::size_t size) -> void; private: - static heap_allocator * allocator_instance; + static heap_allocator * allocator_instance; ///< Instance used to actually allocate and deallocate + /** + * @brief Either returns the previously registered heap allocated or halts furthere execution + * + * @return Reference to the registered heap allocation + */ static auto get() -> heap_allocator &; }; } // namespace teachos::arch::memory::heap diff --git a/arch/x86_64/include/arch/memory/heap/heap_allocator.hpp b/arch/x86_64/include/arch/memory/heap/heap_allocator.hpp index 62ba963..1519155 100644 --- a/arch/x86_64/include/arch/memory/heap/heap_allocator.hpp +++ b/arch/x86_64/include/arch/memory/heap/heap_allocator.hpp @@ -8,12 +8,34 @@ namespace teachos::arch::memory::heap std::size_t constexpr HEAP_START = 0x100000000; std::size_t constexpr HEAP_SIZE = 100 * 1024; + /** + * @brief Heap allocator interface containing methods required to allocate and deallocate heap memory areas + */ struct heap_allocator { + /** + * @brief Virtual default destructor, created to ensure that if a pointer to this class is used and deleted, we will + * also call the derived base class destructor. Deleting a base class destructor that does not have a virtual + * destructor is undefined behaviour, because the derived class destructor originally instantiated with new is never + * called. This can cause potential memory leaks, because derived classes can not clean up their internal members as + * expected and instead simply leak them + */ virtual ~heap_allocator() {} + /** + * @brief Allocates the given amount of memory and returns the pointer to the start of the allocatable memory area + * + * @param size Amount of bytes that should be allocated + * @return void* Pointer to the start of the allocatable memory area + */ virtual auto allocate(std::size_t size) -> void * = 0; + /** + * @brief Deallocated the given amount of memory starting from the given pointer address + * + * @param pointer Previously allocated memory area, that should now be freed + * @param size Size of the memory area we want to free + */ virtual auto deallocate(void * pointer, std::size_t size) -> void = 0; }; } // namespace teachos::arch::memory::heap diff --git a/arch/x86_64/include/arch/memory/heap/memory_block.hpp b/arch/x86_64/include/arch/memory/heap/memory_block.hpp index b9a2254..e1cd288 100644 --- a/arch/x86_64/include/arch/memory/heap/memory_block.hpp +++ b/arch/x86_64/include/arch/memory/heap/memory_block.hpp @@ -32,7 +32,6 @@ namespace teachos::arch::memory::heap ///< size variable and the pointer to the next hole. memory_block * next; ///< Optional pointer to the next free memory, holds nullptr if there is none. }; - } // namespace teachos::arch::memory::heap #endif // TEACHOS_ARCH_X86_64_MEMORY_HEAP_MEMORY_BLOCK_HPP diff --git a/arch/x86_64/include/arch/memory/paging/page_entry.hpp b/arch/x86_64/include/arch/memory/paging/page_entry.hpp index 876ea3c..1de31b5 100644 --- a/arch/x86_64/include/arch/memory/paging/page_entry.hpp +++ b/arch/x86_64/include/arch/memory/paging/page_entry.hpp @@ -49,14 +49,13 @@ namespace teachos::arch::memory::paging explicit entry(uint64_t flags); /** - * @brief Converts the given elf section flags into the corresponding correct entry flags. + * @brief Creates a new entry converting the given elf section flags into the corresponding correct entry flags. * * @note Enables us to set the correct flags on a entry depending on which elf section it is contained in. For * example entries of .text sections should be executable and read only or entries of .data sections should be * writable but not executable. * * @param elf_flags Elf section flags we want to convert into entry flags. - * @return Entry that has the corresponding bit flags set. */ explicit entry(multiboot::elf_section_flags elf_flags); -- cgit v1.2.3 From fcc586a846562e024c1cd77042634494cf380bd8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matteo=20Gm=C3=BCr?= Date: Sun, 23 Feb 2025 10:27:46 +0000 Subject: Adjust linked list allocator to allow for deallocation without passing size parameter and with arbitrary size --- .../include/arch/memory/heap/bump_allocator.hpp | 15 +++------------ .../arch/memory/heap/global_heap_allocator.hpp | 5 ++--- .../include/arch/memory/heap/heap_allocator.hpp | 6 +++--- .../arch/memory/heap/linked_list_allocator.hpp | 21 +++++---------------- 4 files changed, 13 insertions(+), 34 deletions(-) (limited to 'arch/x86_64/include') diff --git a/arch/x86_64/include/arch/memory/heap/bump_allocator.hpp b/arch/x86_64/include/arch/memory/heap/bump_allocator.hpp index d5f4561..74734af 100644 --- a/arch/x86_64/include/arch/memory/heap/bump_allocator.hpp +++ b/arch/x86_64/include/arch/memory/heap/bump_allocator.hpp @@ -28,23 +28,14 @@ namespace teachos::arch::memory::heap // Nothing to do } - /** - * @brief Allocates the specified amount of memory in the heap. - * - * @param size Amount of memory to allocate. - * @return Address of the first byte to the allocated area - */ auto allocate(std::size_t size) -> void * override; /** - * @brief Deallocates heap memory at the specified location. - * - * @note Simply does nothing, because this allocator leaks all memory. + * @copybrief heap_allocator::deallocate * - * @param pointer Pointer to the location which should be deallocated. - * @param size Size of the underlying memory area we want to deallocate. + * @note Simply does nothing, because this allocator leaks all memory */ - auto deallocate(void * pointer, std::size_t size) -> void override; + auto deallocate(void * pointer) -> void override; private: std::size_t heap_start; ///< Start of the allocatable heap area diff --git a/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp b/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp index 6719bec..a1621b5 100644 --- a/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp +++ b/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp @@ -48,13 +48,12 @@ namespace teachos::arch::memory::heap static auto allocate(std::size_t size) -> void *; /** - * @brief Deallocated the given amount of memory starting from the given pointer address. + * @brief Deallocated all memory associated with the memory area starting from the given pointer address. * Simply forwards the call to the deallocate method of the registered heap_allocation implementation * * @param pointer Previously allocated memory area, that should now be freed - * @param size Size of the memory area we want to free */ - static auto deallocate(void * pointer, std::size_t size) -> void; + static auto deallocate(void * pointer) -> void; private: static heap_allocator * allocator_instance; ///< Instance used to actually allocate and deallocate diff --git a/arch/x86_64/include/arch/memory/heap/heap_allocator.hpp b/arch/x86_64/include/arch/memory/heap/heap_allocator.hpp index 1519155..01657f2 100644 --- a/arch/x86_64/include/arch/memory/heap/heap_allocator.hpp +++ b/arch/x86_64/include/arch/memory/heap/heap_allocator.hpp @@ -31,12 +31,12 @@ namespace teachos::arch::memory::heap virtual auto allocate(std::size_t size) -> void * = 0; /** - * @brief Deallocated the given amount of memory starting from the given pointer address + * @brief Deallocates all memory associated with the given pointer address. + * Simply deallocates the amount of memory created with the corresponding call to allocate * * @param pointer Previously allocated memory area, that should now be freed - * @param size Size of the memory area we want to free */ - virtual auto deallocate(void * pointer, std::size_t size) -> void = 0; + virtual auto deallocate(void * pointer) -> void = 0; }; } // namespace teachos::arch::memory::heap diff --git a/arch/x86_64/include/arch/memory/heap/linked_list_allocator.hpp b/arch/x86_64/include/arch/memory/heap/linked_list_allocator.hpp index 966e28e..d53756d 100644 --- a/arch/x86_64/include/arch/memory/heap/linked_list_allocator.hpp +++ b/arch/x86_64/include/arch/memory/heap/linked_list_allocator.hpp @@ -22,7 +22,7 @@ namespace teachos::arch::memory::heap linked_list_allocator(std::size_t heap_start, std::size_t heap_end); /** - * @brief Allocates the specified amount of memory in the heap. + * @copybrief heap_allocator::allocate * * @note The specified size is used to find a free memory block with the exact same size, meaning we can remove that * free memory block from the free list and simply return its address. Or it has to be big enough to hold the size @@ -32,21 +32,10 @@ namespace teachos::arch::memory::heap * they received more memory than wanted. Therefore the memory would simply be unused and because it is neither * allocated nor deallocated would never be indexed by the free memory list. We would therefore permanently loose * that memory, to prevent that allocation into free memory blocks like that are impossible. - * - * @param size Amount of memory to allocate. - * @return Address of the first byte to the allocated area */ - auto allocate(std::size_t size) -> void *; + auto allocate(std::size_t size) -> void * override; - /** - * @brief Deallocates heap memory at the specified location. - * - * @note Simply does nothing, because this allocator leaks all memory. - * - * @param pointer Pointer to the location which should be deallocated. - * @param size Size of the underlying memory area we want to deallocate. - */ - auto deallocate(void * pointer, std::size_t size) -> void; + auto deallocate(void * pointer) -> void override; private: /** @@ -79,8 +68,8 @@ namespace teachos::arch::memory::heap * * @return Previous start address of the memory block we just split, because it can now be used for the allocation. */ - auto split_free_memory_block(memory_block * previous_block, memory_block * current_block, - std::size_t size) -> void *; + auto split_free_memory_block(memory_block * previous_block, memory_block * current_block, std::size_t size) + -> void *; /** * @brief Removes a free memory block from the free list and returns its address so the caller can allocate into it. -- cgit v1.2.3 From 191e7ef3001e422c2f58efe7381d13932e1c1537 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matteo=20Gm=C3=BCr?= Date: Mon, 24 Feb 2025 08:40:46 +0000 Subject: Add noexpect to deallocate calls --- arch/x86_64/include/arch/memory/heap/bump_allocator.hpp | 2 +- arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp | 2 +- arch/x86_64/include/arch/memory/heap/heap_allocator.hpp | 2 +- arch/x86_64/include/arch/memory/heap/linked_list_allocator.hpp | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) (limited to 'arch/x86_64/include') diff --git a/arch/x86_64/include/arch/memory/heap/bump_allocator.hpp b/arch/x86_64/include/arch/memory/heap/bump_allocator.hpp index 74734af..011f45c 100644 --- a/arch/x86_64/include/arch/memory/heap/bump_allocator.hpp +++ b/arch/x86_64/include/arch/memory/heap/bump_allocator.hpp @@ -35,7 +35,7 @@ namespace teachos::arch::memory::heap * * @note Simply does nothing, because this allocator leaks all memory */ - auto deallocate(void * pointer) -> void override; + auto deallocate(void * pointer) noexcept -> void override; private: std::size_t heap_start; ///< Start of the allocatable heap area diff --git a/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp b/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp index a1621b5..dff837e 100644 --- a/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp +++ b/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp @@ -53,7 +53,7 @@ namespace teachos::arch::memory::heap * * @param pointer Previously allocated memory area, that should now be freed */ - static auto deallocate(void * pointer) -> void; + static auto deallocate(void * pointer) noexcept -> void; private: static heap_allocator * allocator_instance; ///< Instance used to actually allocate and deallocate diff --git a/arch/x86_64/include/arch/memory/heap/heap_allocator.hpp b/arch/x86_64/include/arch/memory/heap/heap_allocator.hpp index 01657f2..6aed3d8 100644 --- a/arch/x86_64/include/arch/memory/heap/heap_allocator.hpp +++ b/arch/x86_64/include/arch/memory/heap/heap_allocator.hpp @@ -36,7 +36,7 @@ namespace teachos::arch::memory::heap * * @param pointer Previously allocated memory area, that should now be freed */ - virtual auto deallocate(void * pointer) -> void = 0; + virtual auto deallocate(void * pointer) noexcept -> void = 0; }; } // namespace teachos::arch::memory::heap diff --git a/arch/x86_64/include/arch/memory/heap/linked_list_allocator.hpp b/arch/x86_64/include/arch/memory/heap/linked_list_allocator.hpp index d53756d..df9e370 100644 --- a/arch/x86_64/include/arch/memory/heap/linked_list_allocator.hpp +++ b/arch/x86_64/include/arch/memory/heap/linked_list_allocator.hpp @@ -35,7 +35,7 @@ namespace teachos::arch::memory::heap */ auto allocate(std::size_t size) -> void * override; - auto deallocate(void * pointer) -> void override; + auto deallocate(void * pointer) noexcept -> void override; private: /** -- cgit v1.2.3 From 2cbaf2d52bd9379e5c6e4a0d018b25d1c882193d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matteo=20Gm=C3=BCr?= Date: Tue, 25 Feb 2025 14:41:03 +0000 Subject: Create inital custom version of c++ vector --- arch/x86_64/include/arch/stl/vector.hpp | 193 ++++++++++++++++++++++++++++++++ 1 file changed, 193 insertions(+) create mode 100644 arch/x86_64/include/arch/stl/vector.hpp (limited to 'arch/x86_64/include') diff --git a/arch/x86_64/include/arch/stl/vector.hpp b/arch/x86_64/include/arch/stl/vector.hpp new file mode 100644 index 0000000..62be704 --- /dev/null +++ b/arch/x86_64/include/arch/stl/vector.hpp @@ -0,0 +1,193 @@ +#ifndef TEACHOS_ARCH_X86_64_STL_VECTOR_HPP +#define TEACHOS_ARCH_X86_64_STL_VECTOR_HPP + +#include "arch/exception_handling/panic.hpp" +#include "arch/shared/container.hpp" +#include "arch/shared/contiguous_pointer_iterator.hpp" + +#include + +namespace teachos::arch::stl +{ + /** + * @brief Custom vector implementation mirroring the std::vector to allow for the usage of STL functionality with our + * custom memory management + * + * @tparam T Element the vector instance should contain + */ + template + struct vector + { + /** + * @brief Defaulted constructor. Initalizes empty vector + */ + vector() = default; + + /** + * @brief Constructs data with the given amount of elements containg the given value or alterantively the default + * constructed value + * + * @param capacity Amount of elements we want to create and set the given value for + * @param initial Inital value of all elements in the underlying data array + */ + vector(size_t capacity, T initial = T{}) + : capacity(capacity) + , size(capacity) + , data(new T[capacity]{}) + { + auto const begin = data; + auto const end = data + size; + vector_container container{begin, end}; + std::ranges::fill(container, inital); + } + + /** + * @brief Copy constructor + * + * @note Allocates underlying data container with the same capacity as vector we are copying from and copies all + * elements from it + * + * @param other Other instance of vector we want to copy the data from + */ + vector(vector const & other) + : size(size) + , capacity(capacity) + { + delete[] data; + data = new T[capacity]{}; + + auto const begin = other.data; + auto const end = other.data + size; + vector_container container{begin, end}; + std::ranges::copy(container, data); + } + + /** + * @brief Copy assignment operator + * + * @note Allocates underlying data container with the same capacity as vector we are copying from and copies all + * elements from it + * + * @param other Other instance of vector we want to copy the data from + * @return Newly created copy + */ + vector & operator=(vector const & other) + { + delete[] data; + size = other.size(); + capacity = other.capacity(); + data = new T[capacity]{}; + + auto const begin = other.data; + auto const end = other.data + size; + vector_container container{begin, end}; + std::ranges::copy(container, data); + return *this; + } + + /** + * @brief Destructor + */ + ~vector() { delete[] data; } + + /** + * @brief Amount of elements currently contained in this vector, will fill up until we have reached the capacity. If + * that is the case the capacity is increased automatically + * + * @return Current amount of elements + */ + size_t size() const { return size; } + + /** + * @brief Amount of space the vector currently has, can be different than the size, because we allocate more than we + * exactly require to decrease the amount of allocations and deallocation to improve speed + * + * @return Current amount of space the vector has for elements + */ + size_t capacity() const { return capacity; } + + /** + * @brief Array indexing operator. Allowing to access element at the given index + * + * @note Does not do any bounds checks use at() for that + * + * @param index Index we want to access elements at + * @return Reference to the underlying element + */ + T & operator[](size_t index) { return data[index]; } + + /** + * @brief Array indexing operator. Allowing to access element at the given index + * + * @note Ensures we do not access element outside of the bounds of the array, if we do further execution is halted + * + * @param index Index we want to access elements at + * @return Reference to the underlying element + */ + T & at(size_t index) + { + if (index >= size) + { + exception_handling::panic("[Vector] Attempted to read element at invalid index"); + } + return this->operator[](size); + } + + void push_back(T & const element) {} + + void emplace_back(T && const element) + { + // If no cacacity, increase capacity + if (size == capacity) + { + reserve(capacity * 2); + } + + data[size] = element; + size++; + } + + void pop_back() + { + if (size <= 0) + { + exception_handling::panic("[Vector] Attempted to pop back last element of already empty vector"); + } + size--; + } + + T & front() { return *data; } + + T & back() { return *(data + size); } + + void reserve(size_t new_capacity) + { + if (new_capacity < size) + { + // Creating new array with less capacity than is required to keep all current elements makes no sense + return; + } + + T * temp = new T[new_capacity]; + + auto const begin = other.data; + auto const end = other.data + capacity; + vector_container container{begin, end}; + std::ranges::copy(container, temp); + + delete[] data; + capacity = new_capacity; + data = temp; + } + + private: + T * data = {}; ///< Pointer to the first element in the underlying data container + size_t capacity = {}; ///< Amount of space for elements in the underlying data container + size_t size = {}; ///< Amount of elements in the underlying data container + + typedef shared::container> vector_container; + }; + +} // namespace teachos::arch::stl + +#endif // TEACHOS_ARCH_X86_64_STL_VECTOR_HPP -- cgit v1.2.3 From 462a4e09b1a67562dd1a122936c1ad0fc1771e0e Mon Sep 17 00:00:00 2001 From: Fabian Imhof Date: Thu, 27 Feb 2025 07:15:03 +0000 Subject: add smart pointers --- arch/x86_64/include/arch/stl/shared_pointer.hpp | 120 ++++++++++++++++++++++++ arch/x86_64/include/arch/stl/unique_pointer.hpp | 68 ++++++++++++++ 2 files changed, 188 insertions(+) create mode 100644 arch/x86_64/include/arch/stl/shared_pointer.hpp create mode 100644 arch/x86_64/include/arch/stl/unique_pointer.hpp (limited to 'arch/x86_64/include') diff --git a/arch/x86_64/include/arch/stl/shared_pointer.hpp b/arch/x86_64/include/arch/stl/shared_pointer.hpp new file mode 100644 index 0000000..79a9f82 --- /dev/null +++ b/arch/x86_64/include/arch/stl/shared_pointer.hpp @@ -0,0 +1,120 @@ +#ifndef TEACHOS_ARCH_X86_64_STL_SHARED_POINTER_HPP +#define TEACHOS_ARCH_X86_64_STL_SHARED_POINTER_HPP + +namespace teachos::arch::stl +{ + template + struct shared_pointer + { + explicit shared_pointer(T * pointer = nullptr) + : pointer(pointer) + , ref_count(new std::atomic(pointer != nullptr ? 1 : 0)) + { + } + + shared_pointer(const shared_pointer & other) + : pointer(other.pointer) + , ref_count(other.ref_count) + { + if (pointer != nullptr) + { + ++(*ref_count); + } + } + + shared_pointer(shared_pointer && other) noexcept + : pointer(other.pointer) + , ref_count(other.ref_count) + { + other.pointer = nullptr; + other.ref_count = nullptr; + } + + shared_pointer & operator=(const shared_pointer & other) + { + if (this != &other) + { + cleanup(); + pointer = other.pointer; + ref_count = other.ref_count; + + if (pointer != nullptr) + { + ++(*ref_count); + } + } + + return *this; + } + + shared_pointer & operator=(shared_pointer && other) noexcept + { + if (this != &other) + { + cleanup(); + pointer = other.pointer; + ref_count = other.ref_count; + other.pointer = nullptr; + other.ref_count = nullptr; + } + + return *this; + } + + ~shared_pointer() { cleanup(); } + + void cleanup() + { + if (pointer != nullptr && ref_count != nullptr && --(*ref_count) == 0) + { + delete pointer; + delete ref_count; + } + } + + void reset(T * p = nullptr) + { + cleanup(); + pointer = p; + ref_count = new std::atomic(p != nullptr ? 1 : 0); + } + + void swap(shared_pointer & other) + { + std::swap(pointer, other.pointer); + std::swap(ref_count, other.ref_count); + } + + T & operator*() const { return *pointer; } + + T * operator->() const { return pointer; } + + T * get() const { return pointer; } + + int use_count() const + { + if (pointer != nullptr) + { + return *ref_count; + } + + return 0; + } + + bool unique() const { return use_count() == 1; } + + explicit operator bool() const { return pointer != nullptr; } + + private: + T * pointer; + std::atomic * ref_count; + }; + + template + shared_pointer make_shared(Args &&... args) + { + return shared_pointer(new T(std::forward(args)...)); + } +} // namespace teachos::arch::stl + +#endif // TEACHOS_ARCH_X86_64_STL_SHARED_POINTER_HPP \ No newline at end of file diff --git a/arch/x86_64/include/arch/stl/unique_pointer.hpp b/arch/x86_64/include/arch/stl/unique_pointer.hpp new file mode 100644 index 0000000..0ec3c38 --- /dev/null +++ b/arch/x86_64/include/arch/stl/unique_pointer.hpp @@ -0,0 +1,68 @@ +#ifndef TEACHOS_ARCH_X86_64_STL_UNIQUE_POINTER_HPP +#define TEACHOS_ARCH_X86_64_STL_UNIQUE_POINTER_HPP + +namespace teachos::arch::stl +{ + template + struct unique_pointer + { + explicit unique_pointer(T * ptr = nullptr) + : pointer(ptr) + { + } + + ~unique_pointer() { delete pointer; } + + unique_pointer(const unique_pointer &) = delete; + unique_pointer & operator=(const unique_pointer &) = delete; + + unique_pointer(unique_pointer && other) noexcept + : pointer(other.pointer) + { + other.pointer = nullptr; + } + + unique_pointer & operator=(unique_pointer && other) noexcept + { + if (this != &other) + { + delete pointer; + pointer = other.pointer; + other.pointer = nullptr; + } + return *this; + } + + T & operator*() const { return *pointer; } + + T * operator->() const { return pointer; } + + T * get() const { return pointer; } + + T * release() + { + T * temp = pointer; + pointer = nullptr; + return temp; + } + + void reset(T * ptr = nullptr) + { + delete pointer; + pointer = ptr; + } + + void swap(unique_pointer & other) { std::swap(pointer, other.pointer); } + + private: + T * pointer; + }; + + template + unique_pointer make_unique(Args &&... args) + { + return unique_pointer(new T(std::forward(args)...)); + } +} // namespace teachos::arch::stl + +#endif // TEACHOS_ARCH_X86_64_STL_UNIQUE_POINTER_HPP \ No newline at end of file -- cgit v1.2.3 From dc86ba14f5d9cae44f9922f7a9627369e4a3172e Mon Sep 17 00:00:00 2001 From: Fabian Imhof Date: Thu, 27 Feb 2025 07:49:38 +0000 Subject: remove interrupt.hpp --- arch/x86_64/include/arch/kernel/interrupt.hpp | 26 -------------------------- 1 file changed, 26 deletions(-) delete mode 100644 arch/x86_64/include/arch/kernel/interrupt.hpp (limited to 'arch/x86_64/include') diff --git a/arch/x86_64/include/arch/kernel/interrupt.hpp b/arch/x86_64/include/arch/kernel/interrupt.hpp deleted file mode 100644 index 521318d..0000000 --- a/arch/x86_64/include/arch/kernel/interrupt.hpp +++ /dev/null @@ -1,26 +0,0 @@ -#ifndef TEACHOS_ARCH_X86_64_KERNEL_INTERRUPT_HPP -#define TEACHOS_ARCH_X86_64_KERNEL_INTERRUPT_HPP - -#include - -namespace teachos::arch::kernel -{ - struct stack_frame - { - std::uint16_t instruction_pointer; - std::uint16_t cs; - std::uint16_t flags; - std::uint16_t sp; - std::uint16_t ss; - }; - - /** - * @brief Handles an interrupt - * - * https://clang.llvm.org/docs/AttributeReference.html#interrupt-x86 - */ - __attribute__((interrupt)) extern "C" auto interrupt_handler(struct stack_frame * frame) -> void; - -} // namespace teachos::arch::kernel - -#endif // TEACHOS_ARCH_X86_64_KERNEL_INTERRUPT_HPP -- cgit v1.2.3