improve readability of invalid allocations

Author: mazunki

api/mem/alloc.hpp

@@ -5,6 +5,7 @@
 #include <mem/allocator.hpp>
 
 namespace os::mem {
+  static constexpr size_t PAGE_SZ = 4096;  // TODO: put elsewhere
 
   using Raw_allocator = buddy::Alloc<false>;
 

api/mem/alloc/arena.hpp

@@ -0,0 +1,167 @@
+#ifndef MEM_ALLOC_ARENA_HPP
+#define MEM_ALLOC_ARENA_HPP
+
+#include "kprint"
+#include <cstdint>
+#include <cstddef>
+#include <list>
+#include <algorithm>
+
+namespace os::mem {
+
+struct Region { uintptr_t addr; size_t size; };
+
+class Arena {
+public:
+  static constexpr size_t PAGE_SZ = 4096;
+
+  Arena(uintptr_t base, size_t size)
+    : base_{align_up(base, PAGE_SZ)}, size_{align_down(size, PAGE_SZ)} {
+    if (size_) free_.push_back({base_, size_});
+  }
+
+  void* allocate(size_t len) noexcept {
+    return allocate_aligned(PAGE_SZ, len);
+  }
+
+  void* allocate_aligned(size_t alignment, size_t len) noexcept {
+    alignment = std::max(alignment, PAGE_SZ);
+    len = align_up(len, PAGE_SZ);
+
+    for (auto it = free_.begin(); it != free_.end(); ++it) {
+      uintptr_t a = align_up(it->addr, alignment);
+      if (a + len > it->addr + it->size) continue;
+
+      // split left
+      if (a > it->addr) {
+        Region left{it->addr, a - it->addr};
+        it->addr = a;
+        it->size -= left.size;
+        free_.insert(std::upper_bound(free_.begin(), free_.end(), left, cmp), left);
+      }
+
+      // split right
+      const uintptr_t end = it->addr + len;
+      const uintptr_t it_end = it->addr + it->size;
+      if (end < it_end) {
+        Region right{end, it_end - end};
+        it->size = len;
+        free_.insert(std::upper_bound(free_.begin(), free_.end(), right, cmp), right);
+      }
+
+      void* ret = (void*)it->addr;
+      free_.erase(it);
+      return ret;
+    }
+    return nullptr;
+  }
+
+  void* allocate_at(void* addr, size_t len) noexcept {
+    // assumes region is deallocated
+    kprintf("[arena] allocating at %p, %zu bytes", addr, len);
+
+    uintptr_t a = (uintptr_t)addr;
+    len = align_up(len, PAGE_SZ);
+    if (a < base_ || a + len > base_ + size_) return nullptr;
+
+    for (auto it = free_.begin(); it != free_.end(); ++it) {
+      const uintptr_t start = it->addr;
+      const uintptr_t end   = start + it->size;
+      if (a >= start && a + len <= end) {
+        Region left{start, a - start};
+        Region right{a + len, end - (a + len)};
+        free_.erase(it);
+        if (left.size)
+          free_.insert(std::upper_bound(free_.begin(), free_.end(), left, cmp), left);
+        if (right.size)
+          free_.insert(std::upper_bound(free_.begin(), free_.end(), right, cmp), right);
+        return addr;
+      }
+    }
+    return nullptr;
+  }
+
+  void deallocate(void* addr, size_t len) noexcept {
+    if (!addr || !len) return;
+    Region r{align_down((uintptr_t)addr, PAGE_SZ), align_up(len, PAGE_SZ)};
+
+    auto it = std::upper_bound(free_.begin(), free_.end(), r, cmp);
+    if (it != free_.begin()) {
+      auto prev = std::prev(it);
+      if (prev->addr + prev->size == r.addr) {
+        prev->size += r.size;
+        maybe_merge_with_next(prev);
+        return;
+      }
+    }
+    it = free_.insert(it, r);
+    maybe_merge_with_next(it);
+  }
+
+  bool is_range_free(uintptr_t a, size_t len) const noexcept {
+    len = align_up(len, PAGE_SZ);
+    for (auto& r : free_) {
+      if (a >= r.addr && a + len <= r.addr + r.size) {
+        return true;
+      }
+      if (a + len <= r.addr) {
+        break;  // past it
+      }
+    }
+    return false;
+  }
+
+  size_t bytes_free() const noexcept {
+    size_t s = 0;
+    for (auto& r : free_) s += r.size;
+    return s;
+  }
+
+  size_t bytes_used() const noexcept {
+    return size_ - bytes_free();
+  }
+
+  uintptr_t allocation_end() const noexcept {
+    if (free_.empty()) return base_ + size_;
+    auto last = std::prev(free_.end());
+    if (last->addr + last->size == base_ + size_) return last->addr;
+    return base_ + size_;
+  }
+
+  void reset() {
+    free_.clear();
+    if (size_) free_.push_back({base_, size_});
+  }
+
+  // alignment helpers
+  template<typename T>
+  static constexpr T align_up(T x, size_t a) noexcept {
+    return (x + a - 1) & ~(T)(a - 1);
+  }
+  template<typename T>
+  static constexpr T align_down(T x, size_t a) noexcept {
+    return x & ~(T)(a - 1);
+  }
+
+private:
+  static inline bool cmp(const Region& a, const Region& b) noexcept {
+    return a.addr < b.addr;
+  }
+
+  void maybe_merge_with_next(std::list<Region>::iterator it) {
+    auto nx = std::next(it);
+    if (nx != free_.end() && it->addr + it->size == nx->addr) {
+      it->size += nx->size;
+      free_.erase(nx);
+    }
+  }
+
+  uintptr_t base_{0};
+  size_t size_{0};
+  std::list<Region> free_;
+};
+
+} // namespace os::mem
+
+#endif // MEM_ALLOC_ARENA_HPP
+

api/mem/alloc/buddy.hpp

@@ -53,6 +53,8 @@ namespace util {
 }
 
 namespace os::mem::buddy {
+  static constexpr size_t PAGE_SZ = 4096;
+
   using namespace util::literals;
   using namespace util::bitops;
 

api/mem/flags.hpp

@@ -2,15 +2,30 @@
 #define	MEM_FLAGS_HPP
 
 #include <cstdint>
+#include <sys/mman.h>
 #include <util/bitops.hpp>
 
+// TODO: separate architecture-specific Access flags from allocation-specific
 namespace os::mem {
   enum class Access : uint8_t {
       none = 0,
       read = 1,
       write = 2,
       execute = 4
     };
+}
+
+namespace os::mem::alloc {
+  enum class Sharing : uint64_t {
+    Anonymous     = MAP_ANONYMOUS,       // not backed by any file
+    Shared        = MAP_SHARED,          // shared with other processes, changes are carried to underlying file
+    Private       = MAP_PRIVATE,         // copy-on-write. (note: changes to underlying files post-mapping is unspecified)
+    FixedOverride = MAP_FIXED,           // place mapping at address. underlying [data:data+length) is discarded
+    FixedFriendly = MAP_FIXED_NOREPLACE  // same as fixed, but fails if region was occuppied
+  };
+
+  using Flags = os::mem::alloc::Sharing;  // FIXME: ::Sharing should be its own type for exclusivity
+  using Protection = os::mem::Access;  // HACK: works since we're assuming x86
 } // os::mem
 
 namespace util {
@@ -21,6 +36,14 @@ namespace util {
       static constexpr bool enable = true;
     };
   }
+
+  inline namespace bitops {
+    template<>
+    struct enable_bitmask_ops<os::mem::alloc::Sharing> {
+      using type = typename std::underlying_type<os::mem::alloc::Sharing>::type;
+      static constexpr bool enable = true;
+    };
+  }
 }
 
 #endif // MEM_FLAGS_HPP

api/mem/vmap.hpp

@@ -5,6 +5,8 @@
 #include <util/units.hpp>
 #include <mem/flags.hpp>
 #include <mem/memmap.hpp>
+#include <mem/alloc/buddy.hpp>
+#include <mem/allocator.hpp>
 #include <expects>
 #include <algorithm>
 #include <cstdio>

api/util/bitops.hpp

@@ -128,6 +128,21 @@ has_flag(E field, E flags){
   return (field & flags) == flags ;
 }
 
+// bool missing_flag(flag)
+template<typename E>
+constexpr typename std::enable_if<enable_bitmask_ops<E>::enable, bool>::type
+missing_flag(E flag){
+  using base_type = typename std::underlying_type<E>::type;
+  return not static_cast<base_type>(flag);
+}
+
+// bool missing_flag(field, flags)
+template<typename E>
+constexpr typename std::enable_if<enable_bitmask_ops<E>::enable, bool>::type
+missing_flag(E field, E flags){
+  return (field & flags) != flags ;
+}
+
 
 // Enable for uint8_t
 template<>