Reworked, no version bump

sources/linux.c

@@ -0,0 +1,132 @@
+#include "malunal/config.h"
+
+#if MALUNAL_PLATFORM_LINUX
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include "internal.h"
+
+
+static
+malunal_size_t
+g_platform_page_size = 0;
+
+malunal_size_t
+platform_page_size() {
+  return g_platform_page_size == 0
+    ? g_platform_page_size = sysconf(_SC_PAGE_SIZE)
+    : g_platform_page_size;
+}
+
+
+static
+allocation_error_t
+linux_initialize(
+  impl_mptr_t      allocator,
+  allocator_mptr_t upstream,
+  malunal_size_t   capacity
+) {
+  MALUNAL_UNUSED(allocator);
+  MALUNAL_UNUSED(upstream);
+  MALUNAL_UNUSED(capacity);
+  return ALLOCATION_ERROR_SUCCESS;
+}
+
+static
+allocation_error_t
+linux_finalize(impl_mptr_t allocator) {
+  MALUNAL_UNUSED(allocator);
+  return ALLOCATION_ERROR_SUCCESS;
+}
+
+static
+allocation_result_t
+linux_acquire(
+  impl_mptr_t    allocator,
+  malunal_size_t size
+) {
+  MALUNAL_UNUSED(allocator);
+
+  const malunal_int32_t memops  = PROT_READ | PROT_WRITE;
+  const malunal_int32_t memprms = MAP_PRIVATE | MAP_ANONYMOUS;
+
+  malunal_mptr_t ptr = mmap(0, size, memops, memprms, -1, 0);
+  if (ptr == MAP_FAILED || ptr == NULL_ADDRESS)
+    return (allocation_result_t) {
+      .threw = 1,
+      .error   = ALLOCATION_ERROR_OUT_OF_MEMORY
+    };
+
+  allocator->allocated += size;
+  allocator->reserved  += size;
+  allocator->acquires  += 1;
+  return (allocation_result_t) {
+    .threw   = 0,
+    .address = ptr
+  };
+}
+
+static
+allocation_error_t
+linux_release(
+  impl_mptr_t    allocator,
+  malunal_mptr_t address,
+  malunal_size_t size
+) {
+  MALUNAL_UNUSED(allocator);
+  munmap(address, size);
+  allocator->allocated -= size;
+  allocator->reserved  -= size;
+  allocator->releases  += 1;
+  return ALLOCATION_ERROR_SUCCESS;
+}
+
+static
+allocation_result_t
+linux_reacquire(
+  impl_mptr_t    allocator,
+  malunal_mptr_t address,
+  malunal_size_t oldsize,
+  malunal_size_t newsize
+) {
+  allocation_result_t result = linux_acquire(allocator, newsize);
+  if (result.threw)
+    return result;
+
+  result.address = memcpy(result.address, address, oldsize);
+  linux_release(allocator, address, oldsize);
+  return result;
+}
+
+static const
+virtual_table_t linux_vtable = {
+  .initialize = (allocator_initialize_pfn_t)&linux_initialize,
+  .finalize   = (allocator_finalize_pfn_t)&linux_finalize,
+  .acquire    = (allocator_acquire_pfn_t)&linux_acquire,
+  .reacquire  = (allocator_reacquire_pfn_t)&linux_reacquire,
+  .release    = (allocator_release_pfn_t)&linux_release
+};
+
+allocator_t
+linux_allocator() {
+  implementation_t implementation = {
+    .vtable    = &linux_vtable,
+    .upstream  = NULL_ADDRESS,
+    .context   = NULL_ADDRESS,
+    .allocated = 0,
+    .reserved  = 0,
+    .acquires  = 0,
+    .releases  = 0
+  };
+
+  allocator_t result;
+  memcpy(
+    &result,
+    &implementation,
+    sizeof(implementation_t)
+  );
+
+  return result;
+}
+#endif /* MALUNAL_PLATFORM_LINUX */