1 files changed, 251 insertions, 0 deletions

diff --git a/firmware/buflib_malloc.c b/firmware/buflib_malloc.c
new file mode 100644
index 0000000000..fdc2b5b925
--- /dev/null
+++ b/firmware/buflib_malloc.c
@@ -0,0 +1,251 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2023 Aidan MacDonald
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+/*
+ * Malloc backed buflib. This is intended for debugging rather than for
+ * serious use - the buffer passed to the context is wasted, and memory
+ * is acquired from malloc() instead. The main point is to make ASAN more
+ * effective by isolating buflib allocations from each other.
+ *
+ * Currently this is a bare-minimum implementation, it doesn't even run
+ * buflib callbacks since it never moves anything. It could later be
+ * extended with stress-testing options, for example by randomly moving
+ * allocations around.
+ */
+
+#include "buflib.h"
+#include "panic.h"
+#include <stdlib.h>
+
+static struct buflib_malloc_handle *get_free_handle(struct buflib_context *ctx)
+{
+    struct buflib_malloc_handle *h;
+    for (size_t i = 0; i < ctx->num_allocs; ++i)
+    {
+        h = &ctx->allocs[i];
+        if (h->size == 0)
+            return h;
+    }
+
+    ctx->num_allocs++;
+    ctx->allocs = realloc(ctx->allocs, ctx->num_allocs * sizeof(*ctx->allocs));
+    if (!ctx->allocs)
+        panicf("buflib %p handle OOM", ctx);
+
+    h = &ctx->allocs[ctx->num_allocs - 1];
+    h->size = 0;
+    return h;
+}
+
+static int get_handle_num(struct buflib_context *ctx,
+                          struct buflib_malloc_handle *handle)
+{
+    return (handle - ctx->allocs) + 1;
+}
+
+static struct buflib_malloc_handle *get_handle(struct buflib_context *ctx,
+                                               int handle)
+{
+    return &ctx->allocs[handle - 1];
+}
+
+struct buflib_callbacks buflib_ops_locked = {
+    .move_callback = NULL,
+    .shrink_callback = NULL,
+    .sync_callback = NULL,
+};
+
+void buflib_init(struct buflib_context *ctx, void *buf, size_t size)
+{
+    ctx->allocs = NULL;
+    ctx->num_allocs = 0;
+    ctx->buf = buf;
+    ctx->bufsize = size;
+}
+
+size_t buflib_available(struct buflib_context *ctx)
+{
+    return ctx->bufsize;
+}
+
+size_t buflib_allocatable(struct buflib_context *ctx)
+{
+    return ctx->bufsize;
+}
+
+bool buflib_context_relocate(struct buflib_context *ctx, void *buf)
+{
+    ctx->buf = buf;
+    return true;
+}
+
+int buflib_alloc(struct buflib_context *ctx, size_t size)
+{
+    return buflib_alloc_ex(ctx, size, NULL);
+}
+
+int buflib_alloc_ex(struct buflib_context *ctx, size_t size,
+                    struct buflib_callbacks *ops)
+{
+    struct buflib_malloc_handle *handle = get_free_handle(ctx);
+
+    handle->data = malloc(size);
+    handle->user = handle->data;
+    handle->size = size;
+    handle->pin_count = 0;
+    handle->ops = ops;
+
+    if (!handle->data)
+        panicf("buflib %p data OOM", ctx);
+
+    return get_handle_num(ctx, handle);
+}
+
+int buflib_alloc_maximum(struct buflib_context* ctx,
+                         size_t *size, struct buflib_callbacks *ops)
+{
+    *size = ctx->bufsize;
+
+    return buflib_alloc_ex(ctx, *size, ops);
+}
+
+bool buflib_shrink(struct buflib_context *ctx, int handle,
+                   void *newstart, size_t new_size)
+{
+    struct buflib_malloc_handle *h = get_handle(ctx, handle);
+    if (newstart < h->user || new_size > h->size - (newstart - h->user))
+        return false;
+
+    /* XXX: this might be allowed, but what would be the point... */
+    if (new_size == 0)
+    {
+        panicf("weird shrink");
+        return false;
+    }
+
+    /* due to buflib semantics we must not realloc */
+    h->user = newstart;
+    h->size = new_size;
+    return true;
+}
+
+void buflib_pin(struct buflib_context *ctx, int handle)
+{
+    struct buflib_malloc_handle *h = get_handle(ctx, handle);
+
+    h->pin_count++;
+}
+
+void buflib_unpin(struct buflib_context *ctx, int handle)
+{
+    struct buflib_malloc_handle *h = get_handle(ctx, handle);
+
+    h->pin_count--;
+}
+
+unsigned buflib_pin_count(struct buflib_context *ctx, int handle)
+{
+    struct buflib_malloc_handle *h = get_handle(ctx, handle);
+
+    return h->pin_count;
+}
+
+int buflib_free(struct buflib_context *ctx, int handle)
+{
+    if (handle <= 0)
+        return 0;
+
+    struct buflib_malloc_handle *h = get_handle(ctx, handle);
+
+    free(h->data);
+    h->size = 0;
+
+    return 0;
+}
+
+#ifdef BUFLIB_DEBUG_GET_DATA
+void *buflib_get_data(struct buflib_context *ctx, int handle)
+{
+    /* kind of silly since it's better for ASAN to catch this but... */
+    if (handle <= 0 || handle > ctx->num_allocs)
+        panicf("buflib %p: invalid handle %d", ctx, handle);
+
+    struct buflib_malloc_handle *h = get_handle(ctx, handle);
+    if (h->user == NULL)
+        panicf("buflib %p: handle %d use after free", ctx, handle);
+
+    return h->user;
+}
+#endif
+
+void *buflib_buffer_out(struct buflib_context *ctx, size_t *size)
+{
+    if (*size == 0)
+        *size = ctx->bufsize;
+
+    void *ret = ctx->buf;
+
+    ctx->buf += *size;
+    return ret;
+}
+
+void buflib_buffer_in(struct buflib_context *ctx, int size)
+{
+    ctx->buf -= size;
+}
+
+#ifdef BUFLIB_DEBUG_PRINT
+int buflib_get_num_blocks(struct buflib_context *ctx)
+{
+    return ctx->num_allocs;
+}
+
+bool buflib_print_block_at(struct buflib_context *ctx, int block_num,
+                           char *buf, size_t bufsize)
+{
+    if (block_num >= ctx->num_allocs)
+    {
+        if (bufsize > 0)
+            *buf = '\0';
+        return false;
+    }
+
+    struct buflib_malloc_handle *handle = &ctx->allocs[block_num];
+    if (handle->data)
+    {
+        snprintf(buf, bufsize, "%03d addr:%8p length:%zu",
+                 block_num, handle->data, handle->size);
+    }
+    else
+    {
+        snprintf(buf, bufsize, "%03d (unallocated)", block_num);
+    }
+
+    return true;
+}
+#endif
+
+#ifdef BUFLIB_DEBUG_CHECK_VALID
+void buflib_check_valid(struct buflib_context *ctx)
+{
+    (void)ctx;
+}
+#endif