app_mem_utils.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
#include "os_helpers.h"
#include "os_print.h"
#include "mem_alloc.h"
#include "app_mem_utils.h"
 
static mem_ctx_t mem_utils_ctx = NULL;
 
#ifdef HAVE_MEMORY_PROFILING
#define MP_LOG_PREFIX "==MP "
#endif
 
bool mem_utils_init(void *heap_start, size_t heap_size)
{
    mem_utils_ctx = mem_init(heap_start, heap_size);
#ifdef HAVE_MEMORY_PROFILING
    PRINTF(MP_LOG_PREFIX "init;0x%p;%u\n", heap_start, heap_size);
#endif
    return mem_utils_ctx != NULL;
}
 
void *mem_utils_alloc(size_t size, bool permanent, const char *file, int line)
{
    UNUSED(permanent);
    UNUSED(file);
    UNUSED(line);
    void *ptr = NULL;
 
    ptr = mem_alloc(mem_utils_ctx, size);
#ifdef HAVE_MEMORY_PROFILING
    // Only log successful allocations. A failed allocation (ptr == NULL, e.g. out of memory) must
    // not be recorded, otherwise the profiler tracks a phantom live allocation at address 0x0 that
    // is never freed (there is nothing to free) and reports it as a spurious memory leak.
    if (ptr != NULL) {
        if (permanent) {
            PRINTF(MP_LOG_PREFIX "persist;%u;0x%p;%s:%u\n", size, ptr, file, line);
        }
        else {
            PRINTF(MP_LOG_PREFIX "alloc;%u;0x%p;%s:%u\n", size, ptr, file, line);
        }
    }
#endif
    return ptr;
}
 
void *mem_utils_realloc(void *ptr, size_t size, const char *file, int line)
{
    UNUSED(file);
    UNUSED(line);
    void *new_ptr;
    new_ptr = mem_realloc(mem_utils_ctx, ptr, size);
 
#ifdef HAVE_MEMORY_PROFILING
    if (ptr != NULL && size == 0) {
        PRINTF(MP_LOG_PREFIX "free;0x%p;%s:%u\n", ptr, file, line);
    }
    else if (new_ptr != NULL) {
        if (ptr == NULL) {
            PRINTF(MP_LOG_PREFIX "alloc;%u;0x%p;%s:%u\n", size, new_ptr, file, line);
        }
        else if (ptr != new_ptr) {
            PRINTF(MP_LOG_PREFIX "free;0x%p;%s:%u\n", ptr, file, line);
            PRINTF(MP_LOG_PREFIX "alloc;%u;0x%p;%s:%u\n", size, new_ptr, file, line);
        }
    }
#endif
    return new_ptr;
}
 
void mem_utils_free(void *ptr, const char *file, int line)
{
    UNUSED(file);
    UNUSED(line);
    if (ptr == NULL) {
        return;
    }
#ifdef HAVE_MEMORY_PROFILING
    PRINTF(MP_LOG_PREFIX "free;0x%p;%s:%u\n", ptr, file, line);
#endif
    mem_free(mem_utils_ctx, ptr);
}
 
bool mem_utils_calloc(void **buffer, uint16_t size, bool permanent, const char *file, int line)
{
    if (size == 0) {
        // Nothing to allocate, but cleanup was done if needed
        PRINTF("Requested buffer size is zero\n");
        return true;
    }
    // Allocate the message buffer
    if ((*buffer = mem_utils_alloc(size, permanent, file, line)) == NULL) {
        PRINTF("Memory allocation failed for buffer of size %u\n", size);
        return false;
    }
    explicit_bzero(*buffer, size);
    return true;
}
 
void mem_utils_free_and_null(void **buffer, const char *file, int line)
{
    if (*buffer != NULL) {
        mem_utils_free(*buffer, file, line);
        *buffer = NULL;
    }
}
 
char *mem_utils_strdup(const char *src, const char *file, int line)
{
    char  *dst    = NULL;
    size_t length = strlen(src) + 1;
 
    if ((dst = mem_utils_alloc(length, false, file, line)) != NULL) {
        memcpy(dst, src, length);
    }
    return dst;
}