CTL: Add a CTL sources to the UMF

This commit introduces sources and compilation of the CTL.
The CTL sources are copied from: https://github.com/pmem/pmdk/tree/master/src/common

Signed-off-by: Krzysztof Filipek <[email protected]>

Author: KFilipek

cmake/helpers.cmake

@@ -232,9 +232,8 @@ function(add_umf_target_compile_options name)
             PRIVATE -fPIC
                     -Wall
                     -Wextra
-                    -Wpedantic
                     -Wformat-security
-                    -Wcast-qual
+                    -Wno-cast-qual
                     $<$<CXX_COMPILER_ID:GNU>:-fdiagnostics-color=auto>)
         if(CMAKE_BUILD_TYPE STREQUAL "Release")
             target_compile_definitions(${name} PRIVATE -D_FORTIFY_SOURCE=2)

src/CMakeLists.txt

@@ -26,6 +26,13 @@ add_subdirectory(coarse)
 
 set(UMF_LIBS $<BUILD_INTERFACE:umf_utils> $<BUILD_INTERFACE:coarse>)
 
+if(LINUX OR MACOSX)
+    set(CTL_SOURCES
+        ${CMAKE_CURRENT_SOURCE_DIR}/ctl/alloc.c
+        ${CMAKE_CURRENT_SOURCE_DIR}/ctl/ctl.c
+        ${CMAKE_CURRENT_SOURCE_DIR}/ctl/ctl_debug.c)
+endif()
+
 if(LINUX)
     set(BA_SOURCES ${BA_SOURCES}
                    ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc_linux.c)
@@ -45,6 +52,7 @@ set(HWLOC_DEPENDENT_SOURCES topology.c)
 
 set(UMF_SOURCES
     ${BA_SOURCES}
+    ${CTL_SOURCES}
     libumf.c
     ipc.c
     ipc_cache.c

src/ctl/alloc.c

@@ -0,0 +1,106 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/* Copyright 2019-2024, Intel Corporation */
+
+#include <errno.h>
+
+#include "alloc.h"
+#include <string.h>
+
+// #include "fault_injection.h"
+
+Malloc_func fn_malloc = malloc;
+Realloc_func fn_realloc = realloc;
+
+#if FAULT_INJECTION
+#include "log_internal.h"
+
+static __thread int malloc_num;
+static __thread int fail_malloc_num;
+static __thread const char *fail_malloc_from;
+
+void *_flt_Malloc(size_t size, const char *func) {
+    if (fail_malloc_from && strcmp(func, fail_malloc_from) == 0) {
+        if (++malloc_num == fail_malloc_num) {
+            errno = ENOMEM;
+            return NULL;
+        }
+    }
+    return fn_malloc(size);
+}
+
+static __thread int realloc_num;
+static __thread int fail_realloc_num;
+static __thread const char *fail_realloc_from;
+
+void *_flt_Realloc(void *ptr, size_t size, const char *func) {
+    if (fail_realloc_from && strcmp(func, fail_realloc_from) == 0) {
+        if (++realloc_num == fail_realloc_num) {
+            errno = ENOMEM;
+            return NULL;
+        }
+    }
+    return fn_realloc(ptr, size);
+}
+
+void core_inject_fault_at(enum pmem_allocation_type type, int nth,
+                          const char *at) {
+    switch (type) {
+    case PMEM_MALLOC:
+        malloc_num = 0;
+        fail_malloc_num = nth;
+        fail_malloc_from = at;
+        break;
+    case PMEM_REALLOC:
+        realloc_num = 0;
+        fail_realloc_num = nth;
+        fail_realloc_from = at;
+        break;
+    default:
+        CORE_LOG_FATAL("unknown allocation type");
+    }
+}
+
+int core_fault_injection_enabled(void) { return 1; }
+#else
+void *_Malloc(size_t size) { return fn_malloc(size); }
+
+void *_Realloc(void *ptr, size_t size) { return fn_realloc(ptr, size); }
+#endif
+
+void set_func_malloc(void *(*malloc_func)(size_t size)) {
+    fn_malloc = (malloc_func == NULL) ? malloc : malloc_func;
+}
+
+void set_func_realloc(void *(*realloc_func)(void *ptr, size_t size)) {
+    fn_realloc = (realloc_func == NULL) ? realloc : realloc_func;
+}
+
+/*
+ * our versions of malloc & friends start off pointing to the libc versions
+ */
+Free_func Free = free;
+Strdup_func Strdup = strdup;
+
+/*
+ * Zalloc -- allocate zeroed memory
+ */
+void *Zalloc(size_t sz) {
+    void *ret = Malloc(sz);
+    if (!ret) {
+        return NULL;
+    }
+    return memset(ret, 0, sz);
+}
+
+/*
+ * util_set_alloc_funcs -- allow one to override malloc, etc.
+ */
+void util_set_alloc_funcs(void *(*malloc_func)(size_t size),
+                          void (*free_func)(void *ptr),
+                          void *(*realloc_func)(void *ptr, size_t size),
+                          char *(*strdup_func)(const char *s)) {
+    set_func_malloc(malloc_func);
+    Free = (free_func == NULL) ? free : free_func;
+    set_func_realloc(realloc_func);
+    Strdup = (strdup_func == NULL) ? strdup : strdup_func;
+}

src/ctl/alloc.h

@@ -0,0 +1,49 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+/* Copyright 2019-2024, Intel Corporation */
+
+#ifndef COMMON_ALLOC_H
+#define COMMON_ALLOC_H
+
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*Malloc_func)(size_t size);
+typedef void *(*Realloc_func)(void *ptr, size_t size);
+
+extern Malloc_func fn_malloc;
+extern Realloc_func fn_realloc;
+
+#if FAULT_INJECTION
+void *_flt_Malloc(size_t, const char *);
+void *_flt_Realloc(void *, size_t, const char *);
+
+#define Malloc(size) _flt_Malloc(size, __func__)
+#define Realloc(ptr, size) _flt_Realloc(ptr, size, __func__)
+#else
+void *_Malloc(size_t);
+void *_Realloc(void *, size_t);
+
+#define Malloc(size) _Malloc(size)
+#define Realloc(ptr, size) _Realloc(ptr, size)
+#endif
+
+void set_func_malloc(void *(*malloc_func)(size_t size));
+void set_func_realloc(void *(*realloc_func)(void *ptr, size_t size));
+
+/*
+ * overridable names for malloc & friends used by this library
+ */
+typedef void (*Free_func)(void *ptr);
+typedef char *(*Strdup_func)(const char *s);
+
+extern Free_func Free;
+extern Strdup_func Strdup;
+extern void *Zalloc(size_t sz);
+
+#ifdef __cplusplus
+}
+#endif
+#endif