lib/generic/lru: fix alignment of struct lru

diff --git a/daemon/engine.c b/daemon/engine.c
index 486bb610ca6ef00c17dcb65854fe187d0d3e7790..618a33570a73eceb06751da056cc716ee2f74954 100644 (file)
--- a/daemon/engine.c
+++ b/daemon/engine.c
@@ -576,9 +576,9 @@ static int init_resolver(struct engine *engine)
        /* Empty init; filled via ./lua/config.lua */
        kr_zonecut_init(&engine->resolver.root_hints, (const uint8_t *)"", engine->pool);
        /* Open NS rtt + reputation cache */
-       lru_create(&engine->resolver.cache_rtt, LRU_RTT_SIZE, engine->pool, NULL);
-       lru_create(&engine->resolver.cache_rep, LRU_REP_SIZE, engine->pool, NULL);
-       lru_create(&engine->resolver.cache_cookie, LRU_COOKIES_SIZE, engine->pool, NULL);
+       lru_create(&engine->resolver.cache_rtt, LRU_RTT_SIZE, NULL, NULL);
+       lru_create(&engine->resolver.cache_rep, LRU_REP_SIZE, NULL, NULL);
+       lru_create(&engine->resolver.cache_cookie, LRU_COOKIES_SIZE, NULL, NULL);
 
        /* Load basic modules */
        engine_register(engine, "iterate", NULL, NULL);
@@ -711,7 +711,7 @@ void engine_deinit(struct engine *engine)
        kr_zonecut_deinit(&engine->resolver.root_hints);
        kr_cache_close(&engine->resolver.cache);
 
-       /* The lru keys are currently malloc-ated and need to be freed. */
+       /* The LRUs are currently malloc-ated and need to be freed. */
        lru_free(engine->resolver.cache_rtt);
        lru_free(engine->resolver.cache_rep);
        lru_free(engine->resolver.cache_cookie);

diff --git a/lib/generic/lru.c b/lib/generic/lru.c
index 12bba4ed728954f69892e704be2f1ca2577c5baa..98d9033e0f10a5d5a4790edbbb31a8b97468b823 100644 (file)
--- a/lib/generic/lru.c
+++ b/lib/generic/lru.c
@@ -16,6 +16,7 @@
 
 #include "lib/generic/lru.h"
 #include "contrib/murmurhash3/murmurhash3.h"
+#include "contrib/ucw/mempool.h"
 
 typedef struct lru_group lru_group_t;
 
@@ -108,6 +109,15 @@ KR_EXPORT struct lru * lru_create_impl(uint max_slots, knot_mm_t *mm_array, knot
        group_count = 1 << log_groups;
        assert(max_slots <= group_count * LRU_ASSOC && group_count * LRU_ASSOC < 2 * max_slots);
 
+       /* Get a sufficiently aligning mm_array if NULL is passed. */
+       if (!mm_array) {
+               static knot_mm_t mm_array_default = { 0 };
+               if (!mm_array_default.ctx)
+                       mm_ctx_init_aligned(&mm_array_default, __alignof(struct lru));
+               mm_array = &mm_array_default;
+       }
+       assert(mm_array->alloc != mm_malloc && mm_array->alloc != (knot_mm_alloc_t)mp_alloc);
+
        size_t size = offsetof(struct lru, groups[group_count]);
        struct lru *lru = mm_alloc(mm_array, size);
        if (unlikely(lru == NULL))

diff --git a/lib/generic/lru.h b/lib/generic/lru.h
index b5c9bcd6939e9cfac731fd9ce4c1636f803f09c8..1e195c6dceb5f873109166ac19d07d42b0fa3ad3 100644 (file)
--- a/lib/generic/lru.h
+++ b/lib/generic/lru.h
@@ -88,6 +88,7 @@
  * @param ptable pointer to a pointer to the LRU
  * @param max_slots number of slots
  * @param mm_ctx_array memory context to use for the huge array, NULL for default
+ *     If you pass your own, it needs to produce CACHE_ALIGNED allocations (ubsan).
  * @param mm_ctx memory context to use for individual key-value pairs, NULL for default
  *
  * @note The pointers to memory contexts need to remain valid

diff --git a/lib/utils.c b/lib/utils.c
index 6e63f997177e2ca9efbf43d35ef58c8e36c9e18e..09194bf0edce5b09dc620c4907902ed043177bcb 100644 (file)
--- a/lib/utils.c
+++ b/lib/utils.c
@@ -71,6 +71,18 @@ void *mm_malloc(void *ctx, size_t n)
        (void)ctx;
        return malloc(n);
 }
+void *mm_malloc_aligned(void *ctx, size_t n)
+{
+       size_t alignment = (size_t)ctx;
+       void *res;
+       int err = posix_memalign(&res, alignment, n);
+       if (err == 0) {
+               return res;
+       } else {
+               assert(err == -1 && errno == ENOMEM);
+               return NULL;
+       }
+}
 
 /*
  * Macros.

diff --git a/lib/utils.h b/lib/utils.h
index 8deef4efe7446d74a5629b2d307a2719fa355184..8dabd05da81c8b9e0dacc57c615ac45a3630a6a1 100644 (file)
--- a/lib/utils.h
+++ b/lib/utils.h
@@ -135,6 +135,8 @@ void *mm_realloc(knot_mm_t *mm, void *what, size_t size, size_t prev_size);
 
 /** Trivial malloc() wrapper. */
 void *mm_malloc(void *ctx, size_t n);
+/** posix_memalign() wrapper. */
+void *mm_malloc_aligned(void *ctx, size_t n);
 
 /** Initialize mm with standard malloc+free. */
 static inline void mm_ctx_init(knot_mm_t *mm)
@@ -143,6 +145,20 @@ static inline void mm_ctx_init(knot_mm_t *mm)
        mm->alloc = mm_malloc;
        mm->free = free;
 }
+
+/** Initialize mm with malloc+free with higher alignment (a power of two). */
+static inline void mm_ctx_init_aligned(knot_mm_t *mm, size_t alignment)
+{
+       assert(__builtin_popcount(alignment) == 1);
+       mm->ctx = (uint8_t *)NULL + alignment; /*< roundabout to satisfy linters */
+       /* posix_memalign() doesn't allow alignment < sizeof(void*),
+        * and there's no point in using it for small values anyway,
+        * as plain malloc() guarantees at least max_align_t.
+        * Nitpick: we might use that type when assuming C11. */
+       mm->alloc = alignment > sizeof(void*) ? mm_malloc_aligned : mm_malloc;
+       mm->free = free;
+}
+
 /* @endcond */
 
 /** A strcmp() variant directly usable for qsort() on an array of strings. */