Merge pull request #27565 from yuwata/static-destruct

static-destruct: support clearing array on exit

2 files changed, 71 insertions, 29 deletions

diff --git a/src/basic/memory-util.h b/src/basic/memory-util.h
index d03d52cd43..d26a0918e1 100644
--- a/src/basic/memory-util.h
+++ b/src/basic/memory-util.h
@@ -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) ({                         \
diff --git a/src/basic/static-destruct.h b/src/basic/static-destruct.h
index 97baac7abb..2ffc6516f8 100644
--- a/src/basic/static-destruct.h
+++ b/src/basic/static-destruct.h
@@ -4,15 +4,46 @@
 
 #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 {
+#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. */ \
+        _section_("SYSTEMD_STATIC_DESTRUCT")                            \
+        /* Use pointer alignment, since that is apparently what gcc does for static variables. */ \
+        _alignptr_                                                      \
+        /* Make sure this is not dropped from the image despite not being explicitly referenced. */ \
+        _used_                                                          \
+        /* 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_
+
+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) \
@@ -24,40 +55,51 @@ typedef struct StaticDestructor {
                 typeof(variable) *q = p;                                \
                 func(q);                                                \
         }                                                               \
-        /* 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. */ \
-        _section_("SYSTEMD_STATIC_DESTRUCT")                            \
-        /* Use pointer alignment, since that is apparently what gcc does for static variables. */ \
-        _alignptr_                                                      \
-        /* Make sure this is not dropped from the image despite not being explicitly referenced. */ \
-        _used_                                                          \
-        /* 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_                                  \
+        _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();
+                }
 }