open5gs/lib/core/ogs-memory.c

/*
 * Copyright (C) 2019 by Sukchan Lee <acetcom@gmail.com>
 *
 * This file is part of Open5GS.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

#include "ogs-core.h"

#undef OGS_LOG_DOMAIN
#define OGS_LOG_DOMAIN __ogs_mem_domain

/*****************************************
 * Memory Pool - Use talloc library
 *****************************************/

void *__ogs_talloc_core;

static ogs_thread_mutex_t mutex;

void ogs_mem_init(void)
{
    ogs_thread_mutex_init(&mutex);

    talloc_enable_null_tracking();

#define TALLOC_MEMSIZE 1
    __ogs_talloc_core = talloc_named_const(NULL, TALLOC_MEMSIZE, "core");
}

void ogs_mem_final(void)
{
    if (talloc_total_size(__ogs_talloc_core) != TALLOC_MEMSIZE)
        talloc_report_full(__ogs_talloc_core, stderr);

    talloc_free(__ogs_talloc_core);

    ogs_thread_mutex_destroy(&mutex);
}

void *ogs_mem_get_mutex(void)
{
    return &mutex;
}

void *ogs_talloc_size(const void *ctx, size_t size, const char *name)
{
    void *ptr = NULL;

    ogs_thread_mutex_lock(&mutex);

    ptr = talloc_named_const(ctx, size, name);
    ogs_expect(ptr);

    ogs_thread_mutex_unlock(&mutex);

    return ptr;
}

void *ogs_talloc_zero_size(const void *ctx, size_t size, const char *name)
{
    void *ptr = NULL;

    ogs_thread_mutex_lock(&mutex);

    ptr = _talloc_zero(ctx, size, name);
    ogs_expect(ptr);

    ogs_thread_mutex_unlock(&mutex);

    return ptr;
}

void *ogs_talloc_realloc_size(
        const void *context, void *oldptr, size_t size, const char *name)
{
    void *ptr = NULL;

    ogs_thread_mutex_lock(&mutex);

    ptr = _talloc_realloc(context, oldptr, size, name);
    ogs_expect(ptr);

    ogs_thread_mutex_unlock(&mutex);

    return ptr;
}

int ogs_talloc_free(void *ptr, const char *location)
{
    int ret;

    ogs_thread_mutex_lock(&mutex);

    ret = _talloc_free(ptr, location);

    ogs_thread_mutex_unlock(&mutex);

    return ret;
}

/*****************************************
 * Memory Pool - Use pkbuf library
 *****************************************/

void *ogs_malloc_debug(size_t size, const char *file_line)
{
    size_t headroom = 0;
    ogs_pkbuf_t *pkbuf = NULL;

    ogs_assert(size);

    headroom = sizeof(ogs_pkbuf_t *);
    pkbuf = ogs_pkbuf_alloc_debug(NULL, headroom + size, file_line);
    if (!pkbuf) {
        ogs_error("ogs_pkbuf_alloc_debug[headroom:%d, size:%d] failed",
                (int)headroom, (int)size);
        return NULL;
    }

    ogs_pkbuf_reserve(pkbuf, headroom);
    memcpy(pkbuf->head, &pkbuf, headroom);
    ogs_pkbuf_put(pkbuf, size);

    return pkbuf->data;
}

int ogs_free_debug(void *ptr)
{
    size_t headroom;
    ogs_pkbuf_t *pkbuf = NULL;

    if (!ptr)
        return OGS_ERROR;

    headroom = sizeof(ogs_pkbuf_t *);
    memcpy(&pkbuf, (unsigned char*)ptr - headroom, headroom);
    ogs_assert(pkbuf);

    ogs_pkbuf_free(pkbuf);

    return OGS_OK;
}

void *ogs_calloc_debug(size_t nmemb, size_t size, const char *file_line)
{
    void *ptr = NULL;

    ptr = ogs_malloc_debug(nmemb * size, file_line);
    if (!ptr) {
        ogs_error("ogs_malloc_debug[nmemb:%d, size:%d] failed",
                (int)nmemb, (int)size);
        return NULL;
    }

    memset(ptr, 0, nmemb * size);
    return ptr;
}

void *ogs_realloc_debug(void *ptr, size_t size, const char *file_line)
{
    size_t headroom = 0;
    ogs_pkbuf_t *pkbuf = NULL;
    ogs_cluster_t *cluster = NULL;

    if (!ptr)
        return ogs_malloc(size);

    headroom = sizeof(ogs_pkbuf_t *);

    memcpy(&pkbuf, (unsigned char*)ptr - headroom, headroom);

    if (!pkbuf) {
        ogs_error("Cannot get pkbuf from ptr[%p], headroom[%d]",
                ptr, (int)headroom);
        return NULL;
    }

    cluster = pkbuf->cluster;
    if (!cluster) {
        ogs_error("No cluster");
        return NULL;
    }

    if (!size) {
        ogs_pkbuf_free(pkbuf);
        return NULL;
    }

    if (size > (cluster->size - headroom)) {
        void *new = NULL;

        new = ogs_malloc_debug(size, file_line);
        if (!new) {
            ogs_error("ogs_malloc_debug[%d] failed", (int)size);
            return NULL;
        }

        memcpy(new, ptr, pkbuf->len);

        ogs_pkbuf_free(pkbuf);
        return new;
    } else {
        pkbuf->tail = pkbuf->data + size;
        pkbuf->len = size;
        return ptr;
    }
}