feat(bitmap): change bm_ funcs to class bitmap

CMakeLists.txt

@@ -51,7 +51,6 @@ set(KERNEL_MAIN_SOURCES src/fs/fat.cpp
                         src/kernel/hw/timer.c
                         src/kernel/event/event.cpp
                         src/kernel/signal.cpp
-                        src/types/bitmap.c
                         src/types/elf.cpp
                         src/types/libstdcpp.cpp
                         include/asm/port_io.h
@@ -76,7 +75,7 @@ set(KERNEL_MAIN_SOURCES src/fs/fat.cpp
                         include/kernel/hw/timer.h
                         include/kernel/input/keycodes.h
                         include/kernel/input/input_event.h
-                        include/types/bitmap.h
+                        include/types/bitmap.hpp
                         include/types/buffer.hpp
                         include/types/elf.hpp
                         include/types/hash_map.hpp

include/types/bitmap.h

@@ -1,15 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-int bm_test(uint8_t* bm, size_t n);
-void bm_set(uint8_t* bm, size_t n);
-void bm_clear(uint8_t* bm, size_t n);
-
-#ifdef __cplusplus
-}
-#endif

include/types/bitmap.hpp

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <cstddef>
+#include <functional>
+
+namespace types {
+
+class bitmap {
+public:
+    using deleter_type = std::function<void(unsigned char*, std::size_t)>;
+
+private:
+    deleter_type m_del;
+    unsigned char* m_bm;
+    std::size_t m_size;
+
+    static constexpr std::size_t SZ = sizeof(unsigned char);
+
+public:
+    constexpr bitmap(const deleter_type& del, unsigned char* bm, std::size_t size)
+        : m_del(del), m_bm(bm), m_size(size) {}
+    constexpr bitmap(deleter_type&& del, unsigned char* bm, std::size_t size)
+        : m_del(std::move(del)), m_bm(bm), m_size(size) {}
+
+    explicit constexpr bitmap(std::size_t size)
+    {
+        m_size = (size / SZ) + ((size % SZ) ? 1 : 0);
+        m_bm = new unsigned char[m_size] {};
+        m_del = [](unsigned char* bm, std::size_t) {
+            delete[] bm;
+        };
+    }
+
+    bitmap(const bitmap&) = delete;
+    
+    constexpr ~bitmap()
+    { m_del(m_bm, m_size); }
+    
+    constexpr bool test(std::size_t n) const
+    { return (m_bm[n / SZ] & (1 << (n % SZ))) != 0; }
+
+    constexpr void set(std::size_t n)
+    { m_bm[n / SZ] |= (1 << (n % SZ)); }
+
+    constexpr void clear(std::size_t n)
+    { m_bm[n / SZ] &= (~(1 << (n % SZ))); }
+
+    constexpr std::size_t size() const noexcept
+    { return m_size; }
+};
+
+} // namespace types

include/types/types.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include "bitmap.h"
 #include "size.h"
 #include "status.h"
 #include "stdint.h"

src/kernel/mem.cpp

@@ -12,7 +12,7 @@
 #include <stdint.h>
 #include <stdio.h>
 #include <types/allocator.hpp>
-#include <types/bitmap.h>
+#include <types/bitmap.hpp>
 #include <types/size.h>
 #include <types/status.h>
 
@@ -23,7 +23,10 @@
 // ---------------------
 
 static size_t mem_size;
-static uint8_t mem_bitmap[1024 * 1024 / 8];
+static uint8_t _mem_bitmap[1024 * 1024 / 8];
+static types::bitmap mem_bitmap(
+    [](unsigned char*, std::size_t){}, _mem_bitmap,
+    1024 * 1024);
 
 // global
 segment_descriptor gdt[6];
@@ -67,15 +70,6 @@ void operator delete[](void* ptr, size_t)
     types::__allocator::m_palloc->free(ptr);
 }
 
-inline void mark_page(page_t n)
-{
-    bm_set(mem_bitmap, n);
-}
-inline void free_page(page_t n)
-{
-    bm_clear(mem_bitmap, n);
-}
-
 constexpr void mark_addr_len(pptr_t start, size_t n)
 {
     if (n == 0)
@@ -83,7 +77,7 @@ constexpr void mark_addr_len(pptr_t start, size_t n)
     page_t start_page = align_down<12>(start) >> 12;
     page_t end_page = align_up<12>(start + n) >> 12;
     for (page_t i = start_page; i < end_page; ++i)
-        mark_page(i);
+        mem_bitmap.set(i);
 }
 
 constexpr void free_addr_len(pptr_t start, size_t n)
@@ -93,7 +87,7 @@ constexpr void free_addr_len(pptr_t start, size_t n)
     page_t start_page = align_down<12>(start) >> 12;
     page_t end_page = align_up<12>(start + n) >> 12;
     for (page_t i = start_page; i < end_page; ++i)
-        free_page(i);
+        mem_bitmap.clear(i);
 }
 
 constexpr void mark_addr_range(pptr_t start, pptr_t end)
@@ -108,9 +102,10 @@ constexpr void free_addr_range(pptr_t start, pptr_t end)
 
 page_t __alloc_raw_page(void)
 {
-    for (size_t i = 0; i < sizeof(mem_bitmap); ++i) {
-        if (bm_test(mem_bitmap, i) == 0) {
-            bm_set(mem_bitmap, i);
+    const auto size = mem_bitmap.size();
+    for (size_t i = 0; i < size; ++i) {
+        if (mem_bitmap.test(i) == 0) {
+            mem_bitmap.set(i);
             return i;
         }
     }
@@ -119,7 +114,7 @@ page_t __alloc_raw_page(void)
 
 void __free_raw_page(page_t pg)
 {
-    bm_clear(mem_bitmap, pg);
+    mem_bitmap.clear(pg);
 }
 
 page allocate_page(void)
@@ -379,7 +374,9 @@ struct mapped_area {
 static types::hash_map<page_t, mapped_area,
     types::linux_hasher, types::kernel_ident_allocator>
     mapped;
-static uint8_t freebm[0x400 / 8];
+static uint8_t _freebm[0x400 / 8];
+static types::bitmap freebm(
+    [](unsigned char*, std::size_t){}, _freebm, 0x400);
 } // namespace __physmapper
 
 void* kernel::pmap(page_t pg)
@@ -394,7 +391,7 @@ void* kernel::pmap(page_t pg)
     }
 
     for (int i = 2; i < 0x400; ++i) {
-        if (bm_test(__physmapper::freebm, i) == 0) {
+        if (__physmapper::freebm.test(i) == 0) {
             auto* pte = pmap_pt + i;
             pte->v = 0x3;
             pte->in.page = pg;
@@ -402,7 +399,7 @@ void* kernel::pmap(page_t pg)
             void* ptr = vptradd(mapped_start, 0x1000 * i);
             invalidate_tlb(ptr);
 
-            bm_set(__physmapper::freebm, i);
+            __physmapper::freebm.set(i);
             __physmapper::mapped.emplace(pg,
                 __physmapper::mapped_area { 1, ptr });
             return ptr;
@@ -433,6 +430,6 @@ void kernel::pfree(page_t pg)
     pte->v = 0;
     invalidate_tlb(ptr);
 
-    bm_clear(__physmapper::freebm, i);
+    __physmapper::freebm.clear(i);
     __physmapper::mapped.remove(iter);
 }

src/kernel/process.cpp

@@ -13,7 +13,7 @@
 #include <stdint.h>
 #include <stdio.h>
 #include <types/allocator.hpp>
-#include <types/bitmap.h>
+#include <types/bitmap.hpp>
 #include <types/cplusplus.hpp>
 #include <types/elf.hpp>
 #include <types/hash_map.hpp>
@@ -46,19 +46,20 @@ struct no_irq_guard {
 
 } // namespace kernel
 
-namespace __thd {
-inline uint8_t __kstack_bmp[(0x1000000 - 0xc00000) / 0x2000 / 8];
-inline int __allocated;
-} // namespace __thd
+static types::bitmap* pkstack_bmp;
 
 void thread::alloc_kstack(void)
 {
-    for (int i = 0; i < __thd::__allocated; ++i) {
-        if (bm_test(__thd::__kstack_bmp, i) == 0) {
+    static int __allocated;
+    if (!pkstack_bmp)
+        pkstack_bmp = new types::bitmap((0x1000000 - 0xc00000) / 0x2000);
+
+    for (int i = 0; i < __allocated; ++i) {
+        if (pkstack_bmp->test(i) == 0) {
             pkstack = 0xffc00000 + THREAD_KERNEL_STACK_SIZE * (i + 1);
             esp = reinterpret_cast<uint32_t*>(pkstack);
 
-            bm_set(__thd::__kstack_bmp, i);
+            pkstack_bmp->set(i);
             return;
         }
     }
@@ -67,18 +68,18 @@ void thread::alloc_kstack(void)
     kernel::paccess pa(0x00005);
     auto pt = (pt_t)pa.ptr();
     assert(pt);
-    pte_t* pte = *pt + __thd::__allocated * 2;
+    pte_t* pte = *pt + __allocated * 2;
 
     pte[0].v = 0x3;
     pte[0].in.page = __alloc_raw_page();
     pte[1].v = 0x3;
     pte[1].in.page = __alloc_raw_page();
 
-    pkstack = 0xffc00000 + THREAD_KERNEL_STACK_SIZE * (__thd::__allocated + 1);
+    pkstack = 0xffc00000 + THREAD_KERNEL_STACK_SIZE * (__allocated + 1);
     esp = reinterpret_cast<uint32_t*>(pkstack);
 
-    bm_set(__thd::__kstack_bmp, __thd::__allocated);
-    ++__thd::__allocated;
+    pkstack_bmp->set(__allocated);
+    ++__allocated;
 }
 
 void thread::free_kstack(uint32_t p)
@@ -86,7 +87,7 @@ void thread::free_kstack(uint32_t p)
     p -= 0xffc00000;
     p /= THREAD_KERNEL_STACK_SIZE;
     p -= 1;
-    bm_clear(__thd::__kstack_bmp, p);
+    pkstack_bmp->clear(p);
 }
 
 process::process(process&& val)

src/kinit.cpp

@@ -15,7 +15,6 @@
 #include <kernel/vga.hpp>
 #include <stdint.h>
 #include <stdio.h>
-#include <types/bitmap.h>
 #include <types/status.h>
 #include <types/types.h>
 

src/types/bitmap.c

@@ -1,22 +0,0 @@
-#include <types/bitmap.h>
-
-#define SZ (8)
-
-size_t make_bm_size(size_t n)
-{
-    return sizeof(size_t) + (n / SZ) + ((n % SZ) ? 1 : 0);
-}
-
-int bm_test(uint8_t* bm, size_t n)
-{
-    return (bm[n / SZ] & (1 << (n % SZ))) != 0;
-}
-
-void bm_set(uint8_t* bm, size_t n)
-{
-    bm[n / SZ] |= (1 << (n % SZ));
-}
-void bm_clear(uint8_t* bm, size_t n)
-{
-    bm[n / SZ] &= (~(1 << (n % SZ)));
-}