morgan/systemd
1
0
Fork 0
mirror of https://github.com/morgan9e/systemd synced 2026-04-14 00:14:32 +09:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #27565 from yuwata/static-destruct

Browse Source 
static-destruct: support clearing array on exit
This commit is contained in:
Daan De Meyer
2023-05-12 08:36:43 +02:00
committed by GitHub
parent 2bc161dddb 9695b0c01b
commit 32b0be0eb8
3 changed files with 112 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/basic/memory-util.h
View File

@@ -113,13 +113,13 @@ static inline void erase_char(char *p) {
}
/* An automatic _cleanup_-like logic for destroy arrays (i.e. pointers + size) when leaving scope */
struct ArrayCleanup {
typedef struct ArrayCleanup {
void **parray;
size_t *pn;
free_array_func_t pfunc;
};
} ArrayCleanup;
static inline void array_cleanup(struct ArrayCleanup *c) {
static inline void array_cleanup(const ArrayCleanup *c) {
assert(c);
assert(!c->parray == !c->pn);
@@ -137,7 +137,7 @@ static inline void array_cleanup(struct ArrayCleanup *c) {
}
#define CLEANUP_ARRAY(array, n, func) \
_cleanup_(array_cleanup) _unused_ struct ArrayCleanup CONCATENATE(_cleanup_array_, UNIQ) = { \
_cleanup_(array_cleanup) _unused_ const ArrayCleanup CONCATENATE(_cleanup_array_, UNIQ) = { \
.parray = (void**) &(array), \
.pn = &(n), \
.pfunc = (free_array_func_t) ({ \

96
src/basic/static-destruct.h
View File

@@ -4,26 +4,14 @@
#include "alloc-util.h"
#include "macro.h"
#include "memory-util.h"
/* A framework for registering static variables that shall be freed on shutdown of a process. It's a bit like gcc's
* destructor attribute, but allows us to precisely schedule when we want to free the variables. This is supposed to
* feel a bit like the gcc cleanup attribute, but for static variables. Note that this does not work for static
* variables declared in .so's, as the list is private to the same linking unit. But maybe that's a good thing. */
typedef struct StaticDestructor {
void *data;
free_func_t destroy;
} StaticDestructor;
#define STATIC_DESTRUCTOR_REGISTER(variable, func) \
_STATIC_DESTRUCTOR_REGISTER(UNIQ, variable, func)
#define _STATIC_DESTRUCTOR_REGISTER(uq, variable, func) \
/* Type-safe destructor */ \
static void UNIQ_T(static_destructor_wrapper, uq)(void *p) { \
typeof(variable) *q = p; \
func(q); \
} \
#define _common_static_destruct_attrs_ \
/* Older compilers don't know "retain" attribute. */ \
_Pragma("GCC diagnostic ignored \"-Wattributes\"") \
/* The actual destructor structure we place in a special section to find it. */ \
@@ -35,29 +23,83 @@ typedef struct StaticDestructor {
/* Prevent garbage collection by the linker. */ \
_retain_ \
/* Make sure that AddressSanitizer doesn't pad this variable: we want everything in this section
* packed next to each other so that we can enumerate it. */ \
_variable_no_sanitize_address_ \
* packed next to each other so that we can enumerate it. */ \
_variable_no_sanitize_address_
typedef enum StaticDestructorType {
STATIC_DESTRUCTOR_SIMPLE,
STATIC_DESTRUCTOR_ARRAY,
_STATIC_DESTRUCTOR_TYPE_MAX,
_STATIC_DESTRUCTOR_INVALID = -EINVAL,
} StaticDestructorType;
typedef struct SimpleCleanup {
void *data;
free_func_t destroy;
} SimpleCleanup;
typedef struct StaticDestructor {
StaticDestructorType type;
union {
SimpleCleanup simple;
ArrayCleanup array;
};
} StaticDestructor;
#define STATIC_DESTRUCTOR_REGISTER(variable, func) \
_STATIC_DESTRUCTOR_REGISTER(UNIQ, variable, func)
#define _STATIC_DESTRUCTOR_REGISTER(uq, variable, func) \
/* Type-safe destructor */ \
static void UNIQ_T(static_destructor_wrapper, uq)(void *p) { \
typeof(variable) *q = p; \
func(q); \
} \
_common_static_destruct_attrs_ \
static const StaticDestructor UNIQ_T(static_destructor_entry, uq) = { \
.data = &(variable), \
.destroy = UNIQ_T(static_destructor_wrapper, uq), \
.type = STATIC_DESTRUCTOR_SIMPLE, \
.simple.data = &(variable), \
.simple.destroy = UNIQ_T(static_destructor_wrapper, uq), \
}
#define STATIC_ARRAY_DESTRUCTOR_REGISTER(a, n, func) \
_STATIC_ARRAY_DESTRUCTOR_REGISTER(UNIQ, a, n, func)
#define _STATIC_ARRAY_DESTRUCTOR_REGISTER(uq, a, n, func) \
/* Type-safety check */ \
_unused_ static void (* UNIQ_T(static_destructor_wrapper, uq))(typeof(a[0]) *x, size_t y) = (func); \
_common_static_destruct_attrs_ \
static const StaticDestructor UNIQ_T(static_destructor_entry, uq) = { \
.type = STATIC_DESTRUCTOR_ARRAY, \
.array.parray = (void**) &(a), \
.array.pn = &(n), \
.array.pfunc = (free_array_func_t) (func), \
};
/* Beginning and end of our section listing the destructors. We define these as weak as we want this to work
* even if no destructors are defined and the section is missing. */
extern const struct StaticDestructor _weak_ __start_SYSTEMD_STATIC_DESTRUCT[];
extern const struct StaticDestructor _weak_ __stop_SYSTEMD_STATIC_DESTRUCT[];
extern const StaticDestructor _weak_ __start_SYSTEMD_STATIC_DESTRUCT[];
extern const StaticDestructor _weak_ __stop_SYSTEMD_STATIC_DESTRUCT[];
/* The function to destroy everything. (Note that this must be static inline, as it's key that it remains in
* the same linking unit as the variables we want to destroy.) */
static inline void static_destruct(void) {
const StaticDestructor *d;
if (!__start_SYSTEMD_STATIC_DESTRUCT)
return;
d = ALIGN_PTR(__start_SYSTEMD_STATIC_DESTRUCT);
while (d < __stop_SYSTEMD_STATIC_DESTRUCT) {
d->destroy(d->data);
d = ALIGN_PTR(d + 1);
}
for (const StaticDestructor *d = ALIGN_PTR(__start_SYSTEMD_STATIC_DESTRUCT);
d < __stop_SYSTEMD_STATIC_DESTRUCT;
d = ALIGN_PTR(d + 1))
switch (d->type) {
case STATIC_DESTRUCTOR_SIMPLE:
d->simple.destroy(d->simple.data);
break;
case STATIC_DESTRUCTOR_ARRAY:
array_cleanup(&d->array);
break;
default:
assert_not_reached();
}
}

45
src/test/test-static-destruct.c
View File

@@ -2,17 +2,38 @@
#include "alloc-util.h"
#include "static-destruct.h"
#include "strv.h"
#include "tests.h"
static int foo = 0;
static int bar = 0;
static int baz = 0;
static char* memory = NULL;
static char *memory = NULL;
static char **strings = NULL;
static size_t n_strings = 0;
static int *integers = NULL;
static size_t n_integers = 0;
static void test_destroy(int *b) {
(*b)++;
}
static void test_strings_destroy(char **array, size_t n) {
assert_se(n == 3);
assert_se(strv_equal(array, STRV_MAKE("a", "bbb", "ccc")));
strv_free(array);
}
static void test_integers_destroy(int *array, size_t n) {
assert_se(n == 10);
for (size_t i = 0; i < n; i++)
assert_se(array[i] == (int)(i * i));
free(array);
}
STATIC_DESTRUCTOR_REGISTER(foo, test_destroy);
STATIC_DESTRUCTOR_REGISTER(bar, test_destroy);
STATIC_DESTRUCTOR_REGISTER(bar, test_destroy);
@@ -20,15 +41,27 @@ STATIC_DESTRUCTOR_REGISTER(baz, test_destroy);
STATIC_DESTRUCTOR_REGISTER(baz, test_destroy);
STATIC_DESTRUCTOR_REGISTER(baz, test_destroy);
STATIC_DESTRUCTOR_REGISTER(memory, freep);
STATIC_ARRAY_DESTRUCTOR_REGISTER(strings, n_strings, test_strings_destroy);
STATIC_ARRAY_DESTRUCTOR_REGISTER(integers, n_integers, test_integers_destroy);
TEST(static_destruct) {
assert_se(memory = strdup("hallo"));
assert_se(foo == 0 && bar == 0 && baz == 0);
static_destruct();
assert_se(foo == 1 && bar == 2 && baz == 3);
assert_se(memory = strdup("hallo"));
assert_se(strings = strv_new("a", "bbb", "ccc"));
n_strings = strv_length(strings);
n_integers = 10;
assert_se(integers = new(int, n_integers));
for (size_t i = 0; i < n_integers; i++)
integers[i] = i * i;
assert_se(memory == NULL);
static_destruct();
assert_se(foo == 1 && bar == 2 && baz == 3);
assert_se(!memory);
assert_se(!strings);
assert_se(n_strings == 0);
assert_se(!integers);
assert_se(n_integers == 0);
}
DEFINE_TEST_MAIN(LOG_INFO);