Merge pull request #383

CHANGES

@@ -1,3 +1,11 @@
+2.8.0-dev.9 | 2023-12-04 16:02:54 +0100
+
+  * Fix MBR allocations for >= 1024 bytes (Dominik Charousset, Corelight)
+
+    When trying to allocate a single object with size >= 1024, the current
+    implementation crashes with a stack overflow. This patch allows blocks
+    to exceed the hard-coded size limit to accommodate larger objects.
+
 2.8.0-dev.7 | 2023-11-16 16:54:09 +0100
 
   * Fix error::context (Dominik Charousset, Corelight)

VERSION

@@ -1 +1 @@
-2.8.0-dev.7
+2.8.0-dev.9

include/broker/detail/monotonic_buffer_resource.hh

@@ -11,7 +11,7 @@ namespace broker::detail {
 class monotonic_buffer_resource {
 public:
   monotonic_buffer_resource() {
-    allocate_block(nullptr);
+    allocate_block(nullptr, 0);
   }
 
   monotonic_buffer_resource(const monotonic_buffer_resource&) = delete;
@@ -38,7 +38,7 @@ private:
     void* bytes;
   };
 
-  void allocate_block(block* prev_block);
+  void allocate_block(block* prev_block, size_t min_size);
 
   void destroy() noexcept;
 

src/detail/monotonic_buffer_resource.cc

@@ -1,5 +1,6 @@
 #include "broker/detail/monotonic_buffer_resource.hh"
 
+#include <algorithm>
 #include <cstdlib>
 #include <memory>
 
@@ -15,23 +16,27 @@ constexpr size_t block_size = 1024;
 } // namespace
 
 void* monotonic_buffer_resource::allocate(size_t num_bytes, size_t alignment) {
-  if (auto res = std::align(alignment, num_bytes, current_->bytes,
-                            remaining_)) {
-    current_->bytes = static_cast<std::byte*>(res) + num_bytes;
-    remaining_ -= num_bytes;
-    return res;
-  } else {
-    allocate_block(current_);
-    return allocate(num_bytes, alignment);
+  auto res = std::align(alignment, num_bytes, current_->bytes, remaining_);
+  if (res == nullptr) {
+    allocate_block(current_, num_bytes);
+    res = std::align(alignment, num_bytes, current_->bytes, remaining_);
+    if (res == nullptr)
+      throw std::bad_alloc();
   }
+  current_->bytes = static_cast<std::byte*>(res) + num_bytes;
+  remaining_ -= num_bytes;
+  return res;
 }
 
-void monotonic_buffer_resource::allocate_block(block* prev_block) {
-  if (auto vptr = malloc(block_size)) {
+void monotonic_buffer_resource::allocate_block(block* prev_block,
+                                               size_t min_size) {
+  auto size = std::max(block_size,
+                       min_size + sizeof(block) + sizeof(max_align_t));
+  if (auto vptr = malloc(size)) {
     current_ = static_cast<block*>(vptr);
     current_->next = prev_block;
     current_->bytes = static_cast<std::byte*>(vptr) + sizeof(block);
-    remaining_ = block_size - sizeof(block);
+    remaining_ = size - sizeof(block);
   } else {
     throw std::bad_alloc();
   }