slab: Remove implicit fr_ prefix

Yes, the framework for creating slabs is in the util library, but the functions and types it produces may not be so should not have an implicit fr_ prefix.

diff --git a/src/lib/util/slab.h b/src/lib/util/slab.h
index 0da8627f1a5ac323a6f3620d87922d55972461db..3c2e07c62e7b64dc62dce6fb9c15143966d785e2 100644 (file)
--- a/src/lib/util/slab.h
+++ b/src/lib/util/slab.h
@@ -70,44 +70,44 @@ typedef struct { \
  * @param[in] _type    of structure which will be held in the slab elements.
  */
 #define FR_SLAB_TYPES(_name, _type) \
-       FR_DLIST_TYPES(fr_ ## _name ## _slab) \
-       FR_DLIST_TYPES(fr_ ## _name ## _slab_element) \
+       FR_DLIST_TYPES(_name ## _slab) \
+       FR_DLIST_TYPES(_name ## _slab_element) \
 \
-       typedef int (*fr_ ## _type ## _slab_free_t)(_type *elem, void *uctx); \
-       typedef int (*fr_ ## _type ## _slab_alloc_t)(_type *elem, void *uctx); \
-       typedef int (*fr_ ## _type ## _slab_reserve_t)(_type *elem, void *uctx); \
+       typedef int (*_type ## _slab_free_t)(_type *elem, void *uctx); \
+       typedef int (*_type ## _slab_alloc_t)(_type *elem, void *uctx); \
+       typedef int (*_type ## _slab_reserve_t)(_type *elem, void *uctx); \
 \
        typedef struct { \
-               FR_DLIST_HEAD(fr_ ## _name ## _slab)    reserved; \
-               FR_DLIST_HEAD(fr_ ## _name ## _slab)    avail; \
+               FR_DLIST_HEAD(_name ## _slab)   reserved; \
+               FR_DLIST_HEAD(_name ## _slab)   avail; \
                fr_event_list_t                         *el; \
                fr_event_timer_t const                  *ev; \
                fr_slab_config_t                        config; \
                unsigned int                            in_use; \
                unsigned int                            high_water_mark; \
-               fr_ ## _type ## _slab_alloc_t           alloc; \
-               fr_ ## _type ## _slab_reserve_t         reserve; \
+               _type ## _slab_alloc_t          alloc; \
+               _type ## _slab_reserve_t                reserve; \
                void                                    *uctx; \
                bool                                    release_reset; \
                bool                                    reserve_mru; \
-       } fr_ ## _name ## _slab_list_t; \
+       } _name ## _slab_list_t; \
 \
        typedef struct { \
-               FR_DLIST_ENTRY(fr_ ## _name ## _slab)           entry; \
-               fr_ ## _name ## _slab_list_t                    *list; \
+               FR_DLIST_ENTRY(_name ## _slab)          entry; \
+               _name ## _slab_list_t                   *list; \
                TALLOC_CTX                                      *pool; \
-               FR_DLIST_HEAD(fr_ ## _name ## _slab_element)    reserved; \
-               FR_DLIST_HEAD(fr_ ## _name ## _slab_element)    avail; \
-       } fr_ ## _name ## _slab_t; \
+               FR_DLIST_HEAD(_name ## _slab_element)   reserved; \
+               FR_DLIST_HEAD(_name ## _slab_element)   avail; \
+       } _name ## _slab_t; \
 \
        typedef struct { \
                _type                                           elem; \
-               FR_DLIST_ENTRY(fr_ ## _name ## _slab_element)   entry; \
+               FR_DLIST_ENTRY(_name ## _slab_element)  entry; \
                bool                                            in_use; \
-               fr_ ## _name ## _slab_t                         *slab; \
-               fr_ ## _type ## _slab_free_t                    free; \
+               _name ## _slab_t                        *slab; \
+               _type ## _slab_free_t                   free; \
                void                                            *uctx; \
-       } fr_ ## _name ## _slab_element_t;
+       } _name ## _slab_element_t;
 
 /** Define type specific wrapper functions for slabs and slab elements
  *
@@ -118,8 +118,8 @@ typedef struct { \
  * @param[in] _type    of structure returned by the reserve function.
  */
 #define FR_SLAB_FUNCS(_name, _type) \
-       FR_DLIST_FUNCS(fr_ ## _name ## _slab, fr_ ## _name ## _slab_t, entry) \
-       FR_DLIST_FUNCS(fr_ ## _name ## _slab_element, fr_ ## _name ## _slab_element_t, entry) \
+       FR_DLIST_FUNCS(_name ## _slab, _name ## _slab_t, entry) \
+       FR_DLIST_FUNCS(_name ## _slab_element, _name ## _slab_element_t, entry) \
 \
 DIAG_OFF(unused-function) \
        /** Timer event for freeing unused slabs \
@@ -131,21 +131,21 @@ DIAG_OFF(unused-function) \
         */ \
         static void _ ## _name ## _slab_cleanup(fr_event_list_t *el, UNUSED fr_time_t now, void *uctx) \
         { \
-               fr_ ## _name ## _slab_list_t    *slab_list = talloc_get_type_abort(uctx, fr_ ## _name ## _slab_list_t); \
-               fr_ ## _name ## _slab_t         *slab = NULL, *next_slab = NULL; \
+               _name ## _slab_list_t   *slab_list = talloc_get_type_abort(uctx, _name ## _slab_list_t); \
+               _name ## _slab_t                *slab = NULL, *next_slab = NULL; \
                unsigned int                    to_clear, cleared = 0; \
                to_clear = (slab_list->high_water_mark - slab_list->in_use) / 2; \
                if ((slab_list->in_use + to_clear) < slab_list->config.min_elements) \
                        to_clear = slab_list->high_water_mark - slab_list->config.min_elements; \
                if (to_clear < slab_list->config.elements_per_slab) goto finish; \
-               slab = fr_ ## _name ## _slab_head(&slab_list->avail); \
+               slab = _name ## _slab_head(&slab_list->avail); \
                while (slab) { \
-                       next_slab = fr_ ## _name ## _slab_next(&slab_list->avail, slab); \
-                       if (fr_ ## _name ## _slab_element_num_elements(&slab->reserved) > 0) goto next; \
-                       fr_ ## _name ## _slab_remove(&slab_list->avail, slab); \
-                       cleared += fr_ ## _name ## _slab_element_num_elements(&slab->avail); \
-                       to_clear -= fr_ ## _name ## _slab_element_num_elements(&slab->avail); \
-                       fr_ ## _name ## _slab_element_talloc_free(&slab->avail); \
+                       next_slab = _name ## _slab_next(&slab_list->avail, slab); \
+                       if (_name ## _slab_element_num_elements(&slab->reserved) > 0) goto next; \
+                       _name ## _slab_remove(&slab_list->avail, slab); \
+                       cleared += _name ## _slab_element_num_elements(&slab->avail); \
+                       to_clear -= _name ## _slab_element_num_elements(&slab->avail); \
+                       _name ## _slab_element_talloc_free(&slab->avail); \
                        talloc_free(slab); \
                        if (to_clear < slab_list->config.elements_per_slab) break; \
                next: \
@@ -169,17 +169,17 @@ DIAG_OFF(unused-function) \
         * @param[in] release_reset     Should elements be reset and children freed when the element is released.\
         * @param[in] reserve_mru       If true, the most recently used element will be returned when an element is reserved. \
         */ \
-       static inline CC_HINT(nonnull(2)) int fr_ ## _name ## _slab_list_alloc(TALLOC_CTX *ctx, \
-                                                                              fr_ ## _name ## _slab_list_t **out, \
+       static inline CC_HINT(nonnull(2)) int _name ## _slab_list_alloc(TALLOC_CTX *ctx, \
+                                                                              _name ## _slab_list_t **out, \
                                                                               fr_event_list_t *el, \
                                                                               fr_slab_config_t const *config, \
-                                                                              fr_ ## _type ## _slab_alloc_t alloc, \
-                                                                              fr_ ## _type ## _slab_reserve_t reserve, \
+                                                                              _type ## _slab_alloc_t alloc, \
+                                                                              _type ## _slab_reserve_t reserve, \
                                                                               void *uctx, \
                                                                               bool release_reset, \
                                                                               bool reserve_mru) \
        { \
-               MEM(*out = talloc_zero(ctx, fr_ ## _name ## _slab_list_t)); \
+               MEM(*out = talloc_zero(ctx, _name ## _slab_list_t)); \
                (*out)->el = el; \
                (*out)->config = *config; \
                if ((*out)->config.elements_per_slab == 0) \
@@ -189,8 +189,8 @@ DIAG_OFF(unused-function) \
                (*out)->uctx = uctx; \
                (*out)->release_reset = release_reset; \
                (*out)->reserve_mru = reserve_mru; \
-               fr_ ## _name ## _slab_init(&(*out)->reserved); \
-               fr_ ## _name ## _slab_init(&(*out)->avail); \
+               _name ## _slab_init(&(*out)->reserved); \
+               _name ## _slab_init(&(*out)->avail); \
                if (el) (void) fr_event_timer_in(*out, el, &(*out)->ev, config->interval, _ ## _name ## _slab_cleanup, *out); \
                return 0; \
        } \
@@ -201,16 +201,16 @@ DIAG_OFF(unused-function) \
         * the element is not released before being freed. \
         * Also ensure the element is removed from the relevant list. \
         */ \
-       static int _ ## _type ## _element_free(fr_ ## _name ## _slab_element_t *element) \
+       static int _ ## _type ## _element_free(_name ## _slab_element_t *element) \
        { \
-               fr_ ## _name ## _slab_t *slab; \
+               _name ## _slab_t        *slab; \
                if (element->in_use && element->free) element->free(( _type *)element, element->uctx); \
                if (!element->slab) return 0; \
                slab = element->slab; \
                if (element->in_use) { \
-                       fr_ ## _name ## _slab_element_remove(&slab->reserved, element); \
+                       _name ## _slab_element_remove(&slab->reserved, element); \
                } else { \
-                       fr_ ## _name ## _slab_element_remove(&slab->avail, element); \
+                       _name ## _slab_element_remove(&slab->avail, element); \
                } \
                return 0; \
        } \
@@ -224,37 +224,37 @@ DIAG_OFF(unused-function) \
         * @param[in] slab_list         to reserve an element from. \
         * @return a slab element. \
         */ \
-       static inline CC_HINT(nonnull) _type *fr_ ## _name ## _slab_reserve(fr_ ## _name ## _slab_list_t *slab_list) \
+       static inline CC_HINT(nonnull) _type *_name ## _slab_reserve(_name ## _slab_list_t *slab_list) \
        { \
-               fr_ ## _name ## _slab_t         *slab; \
-               fr_ ## _name ## _slab_element_t *element = NULL; \
+               _name ## _slab_t                *slab; \
+               _name ## _slab_element_t        *element = NULL; \
 \
-               slab = slab_list->reserve_mru ? fr_ ## _name ## _slab_tail(&slab_list->avail) : \
-                                               fr_ ## _name ## _slab_head(&slab_list->avail); \
-               if (!slab && ((fr_ ## _name ## _slab_num_elements(&slab_list->reserved) * \
+               slab = slab_list->reserve_mru ? _name ## _slab_tail(&slab_list->avail) : \
+                                               _name ## _slab_head(&slab_list->avail); \
+               if (!slab && ((_name ## _slab_num_elements(&slab_list->reserved) * \
                               slab_list->config.elements_per_slab) < slab_list->config.max_elements)) { \
-                       fr_ ## _name ## _slab_element_t *new_element; \
+                       _name ## _slab_element_t *new_element; \
                        unsigned int count, elems; \
                        size_t elem_size; \
                        elems = slab_list->config.elements_per_slab * (1 + slab_list->config.num_children); \
-                       elem_size = slab_list->config.elements_per_slab * (sizeof(fr_ ## _name ## _slab_element_t) + \
+                       elem_size = slab_list->config.elements_per_slab * (sizeof(_name ## _slab_element_t) + \
                                                                           slab_list->config.child_pool_size); \
-                       MEM(slab = talloc_zero_pooled_object(slab_list, fr_ ## _name ## _slab_t, elems, elem_size)); \
-                       fr_ ## _name ## _slab_element_init(&slab->avail); \
-                       fr_ ## _name ## _slab_element_init(&slab->reserved); \
-                       fr_ ## _name ## _slab_insert_head(&slab_list->avail, slab); \
+                       MEM(slab = talloc_zero_pooled_object(slab_list, _name ## _slab_t, elems, elem_size)); \
+                       _name ## _slab_element_init(&slab->avail); \
+                       _name ## _slab_element_init(&slab->reserved); \
+                       _name ## _slab_insert_head(&slab_list->avail, slab); \
                        slab->list = slab_list; \
                        for (count = 0; count < slab_list->config.elements_per_slab; count++) { \
                                if (slab_list->config.num_children > 0) { \
-                                       MEM(new_element = talloc_zero_pooled_object(slab, fr_ ## _name ## _slab_element_t, \
+                                       MEM(new_element = talloc_zero_pooled_object(slab, _name ## _slab_element_t, \
                                                                                    slab_list->config.num_children, \
                                                                                    slab_list->config.child_pool_size)); \
                                } else { \
-                                       MEM(new_element = talloc_zero(slab, fr_ ## _name ## _slab_element_t)); \
+                                       MEM(new_element = talloc_zero(slab, _name ## _slab_element_t)); \
                                } \
                                talloc_set_type(new_element, _type); \
                                talloc_set_destructor(new_element, _ ## _type ## _element_free); \
-                               fr_ ## _name ## _slab_element_insert_tail(&slab->avail, new_element); \
+                               _name ## _slab_element_insert_tail(&slab->avail, new_element); \
                                new_element->slab = slab; \
                        } \
                        /* Initialisation of new elements done after allocation to ensure \
@@ -262,32 +262,32 @@ DIAG_OFF(unused-function) \
                         * by the callback may take memory from the pool. \
                         * Any elements which fail to initialise are freed immediately. */ \
                        if (slab_list->alloc) { \
-                               fr_ ## _name ## _slab_element_t *prev = NULL; \
+                               _name ## _slab_element_t *prev = NULL; \
                                new_element = NULL; \
-                               while ((new_element = fr_ ## _name ## _slab_element_next(&slab->avail, new_element))) { \
+                               while ((new_element = _name ## _slab_element_next(&slab->avail, new_element))) { \
                                        if (slab_list->alloc((_type *)new_element, slab_list->uctx) < 0) { \
-                                               prev = fr_ ## _name ## _slab_element_remove(&slab->avail, new_element); \
+                                               prev = _name ## _slab_element_remove(&slab->avail, new_element); \
                                                talloc_free(new_element); \
                                                new_element = prev; \
                                                continue; \
                                        } \
                                } \
                        } \
-                       slab_list->high_water_mark += fr_ ## _name ## _slab_element_num_elements(&slab->avail); \
+                       slab_list->high_water_mark += _name ## _slab_element_num_elements(&slab->avail); \
                } \
                if (!slab && slab_list->config.at_max_fail) return NULL; \
-               if (slab) element = slab_list->reserve_mru ? fr_ ## _name ## _slab_element_pop_tail(&slab->avail) : \
-                                                            fr_ ## _name ## _slab_element_pop_head(&slab->avail); \
+               if (slab) element = slab_list->reserve_mru ? _name ## _slab_element_pop_tail(&slab->avail) : \
+                                                            _name ## _slab_element_pop_head(&slab->avail); \
                if (element) { \
-                       fr_ ## _name ## _slab_element_insert_tail(&slab->reserved, element); \
-                       if (fr_ ## _name ## _slab_element_num_elements(&slab->avail) == 0) { \
-                               fr_ ## _name ## _slab_remove(&slab_list->avail, slab); \
-                               fr_ ## _name ## _slab_insert_tail(&slab_list->reserved, slab); \
+                       _name ## _slab_element_insert_tail(&slab->reserved, element); \
+                       if (_name ## _slab_element_num_elements(&slab->avail) == 0) { \
+                               _name ## _slab_remove(&slab_list->avail, slab); \
+                               _name ## _slab_insert_tail(&slab_list->reserved, slab); \
                        } \
                        element->in_use = true; \
                        slab_list->in_use++; \
                } else { \
-                       MEM(element = talloc_zero(slab_list, fr_ ## _name ## _slab_element_t)); \
+                       MEM(element = talloc_zero(slab_list, _name ## _slab_element_t)); \
                        talloc_set_type(element, _type); \
                        talloc_set_destructor(element, _ ## _type ## _element_free); \
                        if (slab_list->alloc) slab_list->alloc((_type *)element, slab_list->uctx); \
@@ -302,9 +302,9 @@ DIAG_OFF(unused-function) \
         * @param[in] func      Function to attach. \
         * @param[in] uctx      to be passed to func. \
         */ \
-       static inline CC_HINT(nonnull(1,2)) void fr_ ## _name ## _slab_element_set_destructor(_type *elem, fr_ ## _type ## _slab_free_t func, void *uctx) \
+       static inline CC_HINT(nonnull(1,2)) void _name ## _slab_element_set_destructor(_type *elem, _type ## _slab_free_t func, void *uctx) \
        { \
-               fr_ ## _name ## _slab_element_t *element = (fr_ ## _name ## _slab_element_t *)elem; \
+               _name ## _slab_element_t        *element = (_name ## _slab_element_t *)elem; \
                element->free = func; \
                element->uctx = uctx; \
        } \
@@ -316,25 +316,25 @@ DIAG_OFF(unused-function) \
         * \
         * @param[in] elem      to release. \
         */ \
-       static inline CC_HINT(nonnull) void fr_ ## _name ## _slab_release(_type *elem) \
+       static inline CC_HINT(nonnull) void _name ## _slab_release(_type *elem) \
        { \
-               fr_ ## _name ## _slab_element_t *element = (fr_ ## _name ## _slab_element_t *)elem; \
-               fr_ ## _name ## _slab_t *slab = element->slab; \
+               _name ## _slab_element_t *element = (_name ## _slab_element_t *)elem; \
+               _name ## _slab_t *slab = element->slab; \
                if (element->free) element->free(elem, element->uctx); \
                if (slab) { \
-                       fr_ ## _name ## _slab_list_t    *slab_list; \
+                       _name ## _slab_list_t   *slab_list; \
                        slab_list = slab->list; \
-                       fr_ ## _name ## _slab_element_remove(&slab->reserved, element); \
+                       _name ## _slab_element_remove(&slab->reserved, element); \
                        if (slab_list->release_reset){ \
                                talloc_free_children(element); \
                                memset(&element->elem, 0, sizeof(_type)); \
                                element->free = NULL; \
                                element->uctx = NULL; \
                        } \
-                       fr_ ## _name ## _slab_element_insert_tail(&slab->avail, element); \
-                       if (fr_ ## _name ## _slab_element_num_elements(&slab->avail) == 1) { \
-                               fr_ ## _name ## _slab_remove(&slab_list->reserved, slab); \
-                               fr_ ## _name ## _slab_insert_tail(&slab_list->avail, slab); \
+                       _name ## _slab_element_insert_tail(&slab->avail, element); \
+                       if (_name ## _slab_element_num_elements(&slab->avail) == 1) { \
+                               _name ## _slab_remove(&slab_list->reserved, slab); \
+                               _name ## _slab_insert_tail(&slab_list->avail, slab); \
                        } \
                        slab_list->in_use--; \
                        element->in_use = false; \
@@ -343,15 +343,15 @@ DIAG_OFF(unused-function) \
                talloc_free(element); \
        } \
 \
-       static inline CC_HINT(nonnull) unsigned int fr_ ## _name ## _slab_num_elements_used(fr_ ## _name ## _slab_list_t *slab_list) \
+       static inline CC_HINT(nonnull) unsigned int _name ## _slab_num_elements_used(_name ## _slab_list_t *slab_list) \
        { \
                return slab_list->in_use; \
        } \
 \
-       static inline CC_HINT(nonnull) unsigned int fr_ ## _name ## _slab_num_allocated(fr_ ## _name ## _slab_list_t *slab_list) \
+       static inline CC_HINT(nonnull) unsigned int _name ## _slab_num_allocated(_name ## _slab_list_t *slab_list) \
        { \
-               return fr_ ## _name ## _slab_num_elements(&slab_list->reserved) + \
-                      fr_ ## _name ## _slab_num_elements(&slab_list->avail); \
+               return _name ## _slab_num_elements(&slab_list->reserved) + \
+                      _name ## _slab_num_elements(&slab_list->avail); \
        } \
 DIAG_ON(unused-function)
 

diff --git a/src/lib/util/slab_tests.c b/src/lib/util/slab_tests.c
index e8ac62257d3e47a854805cce37ac78cc9013bf7b..e6fc877e6715829540e445c62370e1c68b52e642 100644 (file)
--- a/src/lib/util/slab_tests.c
+++ b/src/lib/util/slab_tests.c
@@ -54,7 +54,7 @@ FR_SLAB_FUNCS(test, test_element_t)
  */
 static void test_alloc(void)
 {
-       fr_test_slab_list_t     *test_slab_list;
+       test_slab_list_t        *test_slab_list;
        test_element_t          *test_elements[5];
        test_uctx_t             test_uctx, test_uctx2;
        int                     ret = -1;
@@ -62,62 +62,62 @@ static void test_alloc(void)
        /*
         *      Each slab will contain 2 elements, maximum of 4 elements allocated from slabs.
         */
-       ret = fr_test_slab_list_alloc(NULL, &test_slab_list, NULL, &def_slab_config, NULL, NULL, NULL, true, false);
+       ret = test_slab_list_alloc(NULL, &test_slab_list, NULL, &def_slab_config, NULL, NULL, NULL, true, false);
        TEST_CHECK(ret == 0);
        TEST_CHECK(test_slab_list != NULL);
        if (!test_slab_list) return;
 
-       test_elements[0] = fr_test_slab_reserve(test_slab_list);
+       test_elements[0] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[0] != NULL);
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 1);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 1);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 1);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 1);
 
        test_uctx.count = 0;
        test_uctx2.count = 0;
 
        /* "if" to keep clang scan happy */
        if (test_elements[0]) test_elements[0]->name = talloc_strdup(test_elements[0], "Hello there");
-       if (test_elements[0]) fr_test_slab_element_set_destructor(test_elements[0], test_element_free, &test_uctx);
+       if (test_elements[0]) test_slab_element_set_destructor(test_elements[0], test_element_free, &test_uctx);
 
-       test_elements[1] = fr_test_slab_reserve(test_slab_list);
+       test_elements[1] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[1] != NULL);
        TEST_CHECK(test_elements[1] != test_elements[0]);
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 1);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 2);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 1);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 2);
 
        /* This will cause a second slab to be allocated */
-       test_elements[2] = fr_test_slab_reserve(test_slab_list);
+       test_elements[2] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[2] != NULL);
        if (test_elements[2]) test_elements[2]->name = talloc_strdup(test_elements[2], "Hello there testing");
-       if (test_elements[2]) fr_test_slab_element_set_destructor(test_elements[2], test_element_free, &test_uctx2);
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 2);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 3);
+       if (test_elements[2]) test_slab_element_set_destructor(test_elements[2], test_element_free, &test_uctx2);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 2);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 3);
 
-       test_elements[3] = fr_test_slab_reserve(test_slab_list);
+       test_elements[3] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[3] != NULL);
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 2);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 4);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 2);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 4);
 
        /* This is more elements than max_elements */
-       test_elements[4] = fr_test_slab_reserve(test_slab_list);
+       test_elements[4] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[4] != NULL);
        /* Allocations beyond the maximum do not amend the slab stats */
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 2);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 4);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 2);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 4);
 
-       if (test_elements[0]) fr_test_slab_release(test_elements[0]);
+       if (test_elements[0]) test_slab_release(test_elements[0]);
        TEST_CHECK(test_uctx.count == 11);
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 2);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 3);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 2);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 3);
 
-       if (test_elements[1]) fr_test_slab_release(test_elements[1]);
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 2);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 2);
+       if (test_elements[1]) test_slab_release(test_elements[1]);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 2);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 2);
 
-       if (test_elements[2]) fr_test_slab_release(test_elements[2]);
+       if (test_elements[2]) test_slab_release(test_elements[2]);
        TEST_CHECK(test_uctx2.count == 19);
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 2);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 1);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 2);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 1);
 
        talloc_free(test_slab_list);
 }
@@ -127,7 +127,7 @@ static void test_alloc(void)
  */
 static void test_alloc_fail(void)
 {
-       fr_test_slab_list_t     *test_slab_list;
+       test_slab_list_t        *test_slab_list;
        test_element_t          *test_elements[5];
        int                     ret = -1;
        fr_slab_config_t        slab_config = def_slab_config;
@@ -136,28 +136,28 @@ static void test_alloc_fail(void)
         *      Each slab will contain 2 elements, maximum of 4 elements allocated from slabs.
         */
        slab_config.at_max_fail = true;
-       ret = fr_test_slab_list_alloc(NULL, &test_slab_list, NULL, &slab_config, NULL, NULL, NULL, true, false);
+       ret = test_slab_list_alloc(NULL, &test_slab_list, NULL, &slab_config, NULL, NULL, NULL, true, false);
        TEST_CHECK(ret == 0);
        TEST_CHECK(test_slab_list != NULL);
        if (!test_slab_list) return;
 
-       test_elements[0] = fr_test_slab_reserve(test_slab_list);
+       test_elements[0] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[0] != NULL);
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 1);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 1);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 1);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 1);
 
-       test_elements[1] = fr_test_slab_reserve(test_slab_list);
-       test_elements[2] = fr_test_slab_reserve(test_slab_list);
-       test_elements[3] = fr_test_slab_reserve(test_slab_list);
+       test_elements[1] = test_slab_reserve(test_slab_list);
+       test_elements[2] = test_slab_reserve(test_slab_list);
+       test_elements[3] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[3] != NULL);
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 2);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 4);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 2);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 4);
 
        /* This is more elements than max_elements */
-       test_elements[4] = fr_test_slab_reserve(test_slab_list);
+       test_elements[4] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[4] == NULL);
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 2);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 4);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 2);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 4);
 
        talloc_free(test_slab_list);
 }
@@ -167,37 +167,37 @@ static void test_alloc_fail(void)
  */
 static void test_reuse_reset(void)
 {
-       fr_test_slab_list_t     *test_slab_list;
+       test_slab_list_t        *test_slab_list;
        test_element_t          *test_elements[5];
        test_uctx_t             test_uctx;
        int                     ret = -1;
 
-       ret = fr_test_slab_list_alloc(NULL, &test_slab_list, NULL, &def_slab_config, NULL, NULL, NULL, true, false);
+       ret = test_slab_list_alloc(NULL, &test_slab_list, NULL, &def_slab_config, NULL, NULL, NULL, true, false);
        TEST_CHECK(ret == 0);
        TEST_CHECK(test_slab_list != NULL);
        if (!test_slab_list) return;
 
-       test_elements[0] = fr_test_slab_reserve(test_slab_list);
+       test_elements[0] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[0] != NULL);
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 1);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 1);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 1);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 1);
 
        test_uctx.count = 0;
 
        if (test_elements[0]) test_elements[0]->name = talloc_strdup(test_elements[0], "Hello there");
-       if (test_elements[0]) fr_test_slab_element_set_destructor(test_elements[0], test_element_free, &test_uctx);
+       if (test_elements[0]) test_slab_element_set_destructor(test_elements[0], test_element_free, &test_uctx);
 
-       test_elements[1] = fr_test_slab_reserve(test_slab_list);
+       test_elements[1] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[1] != NULL);
        TEST_CHECK(test_elements[1] != test_elements[0]);
 
-       test_elements[2] = fr_test_slab_reserve(test_slab_list);
+       test_elements[2] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[2] != NULL);
 
-       test_elements[3] = fr_test_slab_reserve(test_slab_list);
+       test_elements[3] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[3] != NULL);
 
-       if (test_elements[0]) fr_test_slab_release(test_elements[0]);
+       if (test_elements[0]) test_slab_release(test_elements[0]);
        TEST_CHECK(test_uctx.count == 11);
 
        /*
@@ -205,12 +205,12 @@ static void test_reuse_reset(void)
         *      reserving another should grab that first one again, but
         *      with the entry memset to zero.
         */
-       test_elements[4] = fr_test_slab_reserve(test_slab_list);
+       test_elements[4] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[4] != NULL);
        TEST_CHECK(test_elements[4] == test_elements[0]);
        if (test_elements[4]) TEST_CHECK(test_elements[4]->name == NULL);
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 2);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 4);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 2);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 4);
 
        /*
         *      Releasing the first element should reset the destructor
@@ -218,7 +218,7 @@ static void test_reuse_reset(void)
         *      of the initial release.
         */
        if (test_elements[4]) test_elements[4]->name = talloc_strdup(test_elements[4], "Different length string");
-       if (test_elements[4]) fr_test_slab_release(test_elements[4]);
+       if (test_elements[4]) test_slab_release(test_elements[4]);
        TEST_CHECK(test_uctx.count == 11);
 
        talloc_free(test_slab_list);
@@ -229,31 +229,31 @@ static void test_reuse_reset(void)
  */
 static void test_reuse_noreset(void)
 {
-       fr_test_slab_list_t     *test_slab_list;
+       test_slab_list_t        *test_slab_list;
        test_element_t          *test_elements[3];
        test_uctx_t             test_uctx;
        int                     ret = -1;
 
-       ret = fr_test_slab_list_alloc(NULL, &test_slab_list, NULL, &def_slab_config, NULL, NULL, NULL, false, false);
+       ret = test_slab_list_alloc(NULL, &test_slab_list, NULL, &def_slab_config, NULL, NULL, NULL, false, false);
        TEST_CHECK(ret == 0);
        TEST_CHECK(test_slab_list != NULL);
        if (!test_slab_list) return;
 
-       test_elements[0] = fr_test_slab_reserve(test_slab_list);
+       test_elements[0] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[0] != NULL);
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 1);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 1);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 1);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 1);
 
        test_uctx.count = 0;
 
        if (test_elements[0]) test_elements[0]->name = talloc_strdup(test_elements[0], "Hello there");
-       if (test_elements[0]) fr_test_slab_element_set_destructor(test_elements[0], test_element_free, &test_uctx);
+       if (test_elements[0]) test_slab_element_set_destructor(test_elements[0], test_element_free, &test_uctx);
 
-       test_elements[1] = fr_test_slab_reserve(test_slab_list);
+       test_elements[1] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[1] != NULL);
        TEST_CHECK(test_elements[1] != test_elements[0]);
 
-       if (test_elements[0]) fr_test_slab_release(test_elements[0]);
+       if (test_elements[0]) test_slab_release(test_elements[0]);
        TEST_CHECK(test_uctx.count == 11);
 
        /*
@@ -261,7 +261,7 @@ static void test_reuse_noreset(void)
         *      reserving another should grab that first one again.
         *      Since no reset was done, the element should be as it was before.
         */
-       test_elements[2] = fr_test_slab_reserve(test_slab_list);
+       test_elements[2] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[2] != NULL);
        TEST_CHECK(test_elements[2] == test_elements[0]);
        if (test_elements[0] && test_elements[2]) TEST_CHECK(test_elements[2]->name == test_elements[0]->name);
@@ -272,7 +272,7 @@ static void test_reuse_noreset(void)
         */
        if (test_elements[2]) talloc_free(test_elements[2]->name);
        if (test_elements[2]) test_elements[2]->name = talloc_strdup(test_elements[2], "Different length string");
-       if (test_elements[2]) fr_test_slab_release(test_elements[2]);
+       if (test_elements[2]) test_slab_release(test_elements[2]);
        TEST_CHECK(test_uctx.count == 23);
 
        talloc_free(test_slab_list);
@@ -284,7 +284,7 @@ static void test_reuse_noreset(void)
  */
 static void test_reserve_mru(void)
 {
-       fr_test_slab_list_t     *test_slab_list;
+       test_slab_list_t        *test_slab_list;
        test_element_t          *test_elements[2];
        int                     ret = -1;
 
@@ -292,17 +292,17 @@ static void test_reserve_mru(void)
         *      First use a slab list with reserve_mru = false to verify that the two reservations
         *      result in different elements being returned
         */
-       ret = fr_test_slab_list_alloc(NULL, &test_slab_list, NULL, &def_slab_config, NULL, NULL, NULL, true, false);
+       ret = test_slab_list_alloc(NULL, &test_slab_list, NULL, &def_slab_config, NULL, NULL, NULL, true, false);
        TEST_CHECK(ret == 0);
        TEST_CHECK(test_slab_list != NULL);
        if (!test_slab_list) return;
 
-       test_elements[0] = fr_test_slab_reserve(test_slab_list);
+       test_elements[0] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[0] != NULL);
 
-       if (test_elements[0]) fr_test_slab_release(test_elements[0]);
+       if (test_elements[0]) test_slab_release(test_elements[0]);
 
-       test_elements[1] = fr_test_slab_reserve(test_slab_list);
+       test_elements[1] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[1] != NULL);
        TEST_CHECK(test_elements[0] != test_elements[1]);
 
@@ -311,17 +311,17 @@ static void test_reserve_mru(void)
        /*
         *      Now use a slab list with reserve_mru = true
         */
-       ret = fr_test_slab_list_alloc(NULL, &test_slab_list, NULL, &def_slab_config, NULL, NULL, NULL, true, true);
+       ret = test_slab_list_alloc(NULL, &test_slab_list, NULL, &def_slab_config, NULL, NULL, NULL, true, true);
        TEST_CHECK(ret == 0);
        TEST_CHECK(test_slab_list != NULL);
        if (!test_slab_list) return;
 
-       test_elements[0] = fr_test_slab_reserve(test_slab_list);
+       test_elements[0] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[0] != NULL);
 
-       if (test_elements[0]) fr_test_slab_release(test_elements[0]);
+       if (test_elements[0]) test_slab_release(test_elements[0]);
 
-       test_elements[1] = fr_test_slab_reserve(test_slab_list);
+       test_elements[1] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[1] != NULL);
        TEST_CHECK(test_elements[0] == test_elements[1]);
 
@@ -333,23 +333,23 @@ static void test_reserve_mru(void)
  */
 static void test_free(void)
 {
-       fr_test_slab_list_t     *test_slab_list;
+       test_slab_list_t        *test_slab_list;
        test_element_t          *test_element;
        test_uctx_t             test_uctx;
        int                     ret = -1;
 
-       ret = fr_test_slab_list_alloc(NULL, &test_slab_list, NULL, &def_slab_config, NULL, NULL, NULL, true, false);
+       ret = test_slab_list_alloc(NULL, &test_slab_list, NULL, &def_slab_config, NULL, NULL, NULL, true, false);
        TEST_CHECK(ret == 0);
        TEST_CHECK(test_slab_list != NULL);
        if (!test_slab_list) return;
 
-       test_element = fr_test_slab_reserve(test_slab_list);
+       test_element = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_element != NULL);
 
        test_uctx.count = 0;
 
        if (test_element) test_element->name = talloc_strdup(test_element, "Hello there");
-       if (test_element) fr_test_slab_element_set_destructor(test_element, test_element_free, &test_uctx);
+       if (test_element) test_slab_element_set_destructor(test_element, test_element_free, &test_uctx);
 
        if (test_element) talloc_free(test_element);
        TEST_CHECK(test_uctx.count == 11);
@@ -369,19 +369,19 @@ static int test_element_alloc(test_element_t *elem, void *uctx)
  */
 static void test_init(void)
 {
-       fr_test_slab_list_t     *test_slab_list;
+       test_slab_list_t        *test_slab_list;
        test_element_t          *test_elements[2];
        test_conf_t             test_conf = { .initial = 10 };
        int                     ret = -1;
        fr_slab_config_t        slab_config = def_slab_config;
 
        slab_config.elements_per_slab = 1;
-       ret = fr_test_slab_list_alloc(NULL, &test_slab_list, NULL, &slab_config, test_element_alloc, NULL, &test_conf, false, false);
+       ret = test_slab_list_alloc(NULL, &test_slab_list, NULL, &slab_config, test_element_alloc, NULL, &test_conf, false, false);
        TEST_CHECK(ret == 0);
        TEST_CHECK(test_slab_list != NULL);
        if (!test_slab_list) return;
 
-       test_elements[0] = fr_test_slab_reserve(test_slab_list);
+       test_elements[0] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[0] != NULL);
        TEST_CHECK(test_elements[0] && (test_elements[0]->num == 10));
 
@@ -390,13 +390,13 @@ static void test_init(void)
         */
        if (test_elements[0]) {
                test_elements[0]->num = 5;
-               fr_test_slab_release(test_elements[0]);
+               test_slab_release(test_elements[0]);
        }
 
        /*
         *      Re-reserve and check element is unchanged.
         */
-       test_elements[1] = fr_test_slab_reserve(test_slab_list);
+       test_elements[1] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[1] != NULL);
        TEST_CHECK(test_elements[1] == test_elements[0]);
        if (test_elements[1]) TEST_CHECK(test_elements[1]->num == 5);
@@ -409,19 +409,19 @@ static void test_init(void)
  */
 static void test_reserve(void)
 {
-       fr_test_slab_list_t     *test_slab_list;
+       test_slab_list_t        *test_slab_list;
        test_element_t          *test_elements[2];
        test_conf_t             test_conf = { .initial = 10 };
        int                     ret = -1;
        fr_slab_config_t        slab_config = def_slab_config;
 
        slab_config.elements_per_slab = 1;
-       ret = fr_test_slab_list_alloc(NULL, &test_slab_list, NULL, &slab_config, NULL, test_element_alloc, &test_conf, false, false);
+       ret = test_slab_list_alloc(NULL, &test_slab_list, NULL, &slab_config, NULL, test_element_alloc, &test_conf, false, false);
        TEST_CHECK(ret == 0);
        TEST_CHECK(test_slab_list != NULL);
        if (!test_slab_list) return;
 
-       test_elements[0] = fr_test_slab_reserve(test_slab_list);
+       test_elements[0] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[0] != NULL);
        TEST_CHECK(test_elements[0] && (test_elements[0]->num == 10));
 
@@ -430,13 +430,13 @@ static void test_reserve(void)
         */
        if (test_elements[0]) {
                test_elements[0]->num = 5;
-               fr_test_slab_release(test_elements[0]);
+               test_slab_release(test_elements[0]);
        }
 
        /*
         *      Re-reserve and check element is re-initialised.
         */
-       test_elements[1] = fr_test_slab_reserve(test_slab_list);
+       test_elements[1] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[1] != NULL);
        TEST_CHECK(test_elements[1] == test_elements[0]);
        if (test_elements[1]) TEST_CHECK(test_elements[1]->num == 10);
@@ -456,19 +456,19 @@ static int test_element_reserve(test_element_t *elem, void *uctx)
  */
 static void test_init_reserve(void)
 {
-       fr_test_slab_list_t     *test_slab_list;
+       test_slab_list_t        *test_slab_list;
        test_element_t          *test_elements[2];
        test_conf_t             test_conf = { .initial = 10 };
        int                     ret = -1;
        fr_slab_config_t        slab_config = def_slab_config;
 
        slab_config.elements_per_slab = 1;
-       ret = fr_test_slab_list_alloc(NULL, &test_slab_list, NULL, &slab_config, test_element_alloc, test_element_reserve, &test_conf, false, false);
+       ret = test_slab_list_alloc(NULL, &test_slab_list, NULL, &slab_config, test_element_alloc, test_element_reserve, &test_conf, false, false);
        TEST_CHECK(ret == 0);
        TEST_CHECK(test_slab_list != NULL);
        if (!test_slab_list) return;
 
-       test_elements[0] = fr_test_slab_reserve(test_slab_list);
+       test_elements[0] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[0] != NULL);
        TEST_CHECK(test_elements[0] && (test_elements[0]->num == 20));
 
@@ -477,13 +477,13 @@ static void test_init_reserve(void)
         */
        if (test_elements[0]) {
                test_elements[0]->num = 5;
-               fr_test_slab_release(test_elements[0]);
+               test_slab_release(test_elements[0]);
        }
 
        /*
         *      Re-reserve and check reset callback is run.
         */
-       test_elements[1] = fr_test_slab_reserve(test_slab_list);
+       test_elements[1] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[1] != NULL);
        TEST_CHECK(test_elements[1] == test_elements[0]);
        if (test_elements[1]) TEST_CHECK(test_elements[1]->num == 20);
@@ -498,7 +498,7 @@ static void test_clearup_1(void)
 {
        TALLOC_CTX              *ctx = talloc_init_const("test");
        fr_event_list_t         *el;
-       fr_test_slab_list_t     *test_slab_list;
+       test_slab_list_t        *test_slab_list;
        test_element_t          *test_elements[6];
        int                     i, events, ret = -1;
        fr_slab_config_t        slab_config = def_slab_config;
@@ -507,7 +507,7 @@ static void test_clearup_1(void)
        fr_event_list_set_time_func(el, test_time);
 
        slab_config.max_elements = 6;
-       ret = fr_test_slab_list_alloc(NULL, &test_slab_list, el, &slab_config, NULL, NULL, NULL, true, false);
+       ret = test_slab_list_alloc(NULL, &test_slab_list, el, &slab_config, NULL, NULL, NULL, true, false);
        TEST_CHECK(ret == 0);
        TEST_CHECK(test_slab_list != NULL);
        if (!test_slab_list) return;
@@ -516,20 +516,20 @@ static void test_clearup_1(void)
         *      Allocate all the slab elements
         */
        for (i = 0; i < 6; i++) {
-               test_elements[i] = fr_test_slab_reserve(test_slab_list);
+               test_elements[i] = test_slab_reserve(test_slab_list);
                TEST_CHECK(test_elements[i] != NULL);
        }
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 3);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 6);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 3);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 6);
 
        /*
         *      Release four of the six elements
         */
        for (i = 0; i < 4; i++) {
-               fr_test_slab_release(test_elements[i]);
+               test_slab_release(test_elements[i]);
        }
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 3);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 2);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 3);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 2);
 
        /*
         *      Running clearup should free one slab - half of the
@@ -539,8 +539,8 @@ static void test_clearup_1(void)
        events = fr_event_corral(el, test_time_base, true);
        TEST_CHECK(events == 1);
        fr_event_service(el);
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 2);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 2);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 2);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 2);
 
        talloc_free(test_slab_list);
        talloc_free(ctx);
@@ -553,7 +553,7 @@ static void test_clearup_2(void)
 {
        TALLOC_CTX              *ctx = talloc_init_const("test");
        fr_event_list_t         *el;
-       fr_test_slab_list_t     *test_slab_list;
+       test_slab_list_t        *test_slab_list;
        test_element_t          *test_elements[20];
        int                     i, events, ret = -1;
        fr_slab_config_t        slab_config = def_slab_config;
@@ -563,7 +563,7 @@ static void test_clearup_2(void)
 
        slab_config.min_elements = 16;
        slab_config.max_elements = 20;
-       ret = fr_test_slab_list_alloc(NULL, &test_slab_list, el, &slab_config, NULL, NULL, NULL, true, false);
+       ret = test_slab_list_alloc(NULL, &test_slab_list, el, &slab_config, NULL, NULL, NULL, true, false);
        TEST_CHECK(ret == 0);
        TEST_CHECK(test_slab_list != NULL);
        if (!test_slab_list) return;
@@ -572,20 +572,20 @@ static void test_clearup_2(void)
         *      Allocate all the slab elements
         */
        for (i = 0; i < 20; i++) {
-               test_elements[i] = fr_test_slab_reserve(test_slab_list);
+               test_elements[i] = test_slab_reserve(test_slab_list);
                TEST_CHECK(test_elements[i] != NULL);
        }
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 10);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 20);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 10);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 20);
 
        /*
         *      Release all of the elements
         */
        for (i = 0; i < 20; i++) {
-               fr_test_slab_release(test_elements[i]);
+               test_slab_release(test_elements[i]);
        }
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 10);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 0);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 10);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 0);
 
        /*
         *      Running clearup should free two slabs - the minimum element
@@ -595,8 +595,8 @@ static void test_clearup_2(void)
        events = fr_event_corral(el, test_time_base, true);
        TEST_CHECK(events == 1);
        fr_event_service(el);
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 8);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 0);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 8);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 0);
 
        /*
         *      Re-run the event - no more slabs should be cleared
@@ -605,8 +605,8 @@ static void test_clearup_2(void)
        events = fr_event_corral(el, test_time_base, true);
        TEST_CHECK(events == 1);
        fr_event_service(el);
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 8);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 0);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 8);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 0);
 
        talloc_free(test_slab_list);
        talloc_free(ctx);
@@ -619,7 +619,7 @@ static void test_clearup_3(void)
 {
        TALLOC_CTX              *ctx = talloc_init_const("test");
        fr_event_list_t         *el;
-       fr_test_slab_list_t     *test_slab_list;
+       test_slab_list_t        *test_slab_list;
        test_element_t          *test_elements[20];
        int                     i, events, ret = -1;
        fr_slab_config_t        slab_config = def_slab_config;
@@ -629,7 +629,7 @@ static void test_clearup_3(void)
 
        slab_config.min_elements = 0;
        slab_config.max_elements = 20;
-       ret = fr_test_slab_list_alloc(NULL, &test_slab_list, el, &slab_config, NULL, NULL, NULL, true, false);
+       ret = test_slab_list_alloc(NULL, &test_slab_list, el, &slab_config, NULL, NULL, NULL, true, false);
        TEST_CHECK(ret == 0);
        TEST_CHECK(test_slab_list != NULL);
        if (!test_slab_list) return;
@@ -638,20 +638,20 @@ static void test_clearup_3(void)
         *      Allocate all the slab elements
         */
        for (i = 0; i < 20; i++) {
-               test_elements[i] = fr_test_slab_reserve(test_slab_list);
+               test_elements[i] = test_slab_reserve(test_slab_list);
                TEST_CHECK(test_elements[i] != NULL);
        }
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 10);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 20);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 10);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 20);
 
        /*
         *      Release all of the elements
         */
        for (i = 0; i < 20; i++) {
-               fr_test_slab_release(test_elements[i]);
+               test_slab_release(test_elements[i]);
        }
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 10);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 0);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 10);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 0);
 
        /*
         *      Running clearup should free five slabs (20 - 0) / 2 / 2 = 5
@@ -660,8 +660,8 @@ static void test_clearup_3(void)
        events = fr_event_corral(el, test_time_base, true);
        TEST_CHECK(events == 1);
        fr_event_service(el);
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 5);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 0);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 5);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 0);
 
        /*
         *      Re-run the event - two more slabs should be freed (10 - 0) / 2 / 2 = 2.5
@@ -670,8 +670,8 @@ static void test_clearup_3(void)
        events = fr_event_corral(el, test_time_base, true);
        TEST_CHECK(events == 1);
        fr_event_service(el);
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 3);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 0);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 3);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 0);
 
        /*
         *      Re-run the event - one more slab should be freed (6 - 0) / 2 / 2 = 1.5
@@ -680,8 +680,8 @@ static void test_clearup_3(void)
        events = fr_event_corral(el, test_time_base, true);
        TEST_CHECK(events == 1);
        fr_event_service(el);
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 2);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 0);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 2);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 0);
 
        /*
         *      Re-run the event - one more slab should be freed (4 - 0) / 2 / 2 = 1
@@ -690,8 +690,8 @@ static void test_clearup_3(void)
        events = fr_event_corral(el, test_time_base, true);
        TEST_CHECK(events == 1);
        fr_event_service(el);
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 1);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 0);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 1);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 0);
 
        /*
         *      Re-run the event - no more will be freed as (2 - 0) / 2 / 2 = 0.5
@@ -700,8 +700,8 @@ static void test_clearup_3(void)
        events = fr_event_corral(el, test_time_base, true);
        TEST_CHECK(events == 1);
        fr_event_service(el);
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 1);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 0);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 1);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 0);
 
        talloc_free(test_slab_list);
        talloc_free(ctx);
@@ -714,7 +714,7 @@ static void test_realloc(void)
 {
        TALLOC_CTX              *ctx = talloc_init_const("test");
        fr_event_list_t         *el;
-       fr_test_slab_list_t     *test_slab_list;
+       test_slab_list_t        *test_slab_list;
        test_element_t          *test_elements[20];
        int                     i, events, ret = -1;
        fr_slab_config_t        slab_config = def_slab_config;
@@ -724,7 +724,7 @@ static void test_realloc(void)
 
        slab_config.min_elements = 0;
        slab_config.max_elements = 20;
-       ret = fr_test_slab_list_alloc(NULL, &test_slab_list, el, &slab_config, NULL, NULL, NULL, true, false);
+       ret = test_slab_list_alloc(NULL, &test_slab_list, el, &slab_config, NULL, NULL, NULL, true, false);
        TEST_CHECK(ret == 0);
        TEST_CHECK(test_slab_list != NULL);
        if (!test_slab_list) return;
@@ -733,20 +733,20 @@ static void test_realloc(void)
         *      Allocate all the slab elements
         */
        for (i = 0; i < 20; i++) {
-               test_elements[i] = fr_test_slab_reserve(test_slab_list);
+               test_elements[i] = test_slab_reserve(test_slab_list);
                TEST_CHECK(test_elements[i] != NULL);
        }
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 10);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 20);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 10);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 20);
 
        /*
         *      Release all of the elements
         */
        for (i = 0; i < 20; i++) {
-               fr_test_slab_release(test_elements[i]);
+               test_slab_release(test_elements[i]);
        }
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 10);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 0);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 10);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 0);
 
        /*
         *      Running clearup should free five slabs
@@ -755,19 +755,19 @@ static void test_realloc(void)
        events = fr_event_corral(el, test_time_base, true);
        TEST_CHECK(events == 1);
        fr_event_service(el);
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 5);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 0);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 5);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 0);
 
        /*
         *      Allocate all the slab elements
         *      With new slabs allocated, the slab stats will change
         */
        for (i = 0; i < 20; i++) {
-               test_elements[i] = fr_test_slab_reserve(test_slab_list);
+               test_elements[i] = test_slab_reserve(test_slab_list);
                TEST_CHECK(test_elements[i] != NULL);
        }
-       TEST_CHECK_RET(fr_test_slab_num_allocated(test_slab_list), 10);
-       TEST_CHECK_RET(fr_test_slab_num_elements_used(test_slab_list), 20);
+       TEST_CHECK_RET(test_slab_num_allocated(test_slab_list), 10);
+       TEST_CHECK_RET(test_slab_num_elements_used(test_slab_list), 20);
 
        talloc_free(test_slab_list);
        talloc_free(ctx);
@@ -775,7 +775,7 @@ static void test_realloc(void)
 
 static void test_child_alloc(void)
 {
-       fr_test_slab_list_t     *test_slab_list;
+       test_slab_list_t        *test_slab_list;
        test_element_t          *test_elements[2];
        int                     ret = -1;
        fr_slab_config_t        slab_config = def_slab_config;
@@ -783,14 +783,14 @@ static void test_child_alloc(void)
        slab_config.max_elements = 2;
        slab_config.num_children = 1;
        slab_config.child_pool_size = 128;
-       ret = fr_test_slab_list_alloc(NULL, &test_slab_list, NULL, &slab_config, NULL, NULL, NULL, false, false);
+       ret = test_slab_list_alloc(NULL, &test_slab_list, NULL, &slab_config, NULL, NULL, NULL, false, false);
        TEST_CHECK(ret == 0);
        TEST_CHECK(test_slab_list != NULL);
        if (!test_slab_list) return;
 
-       test_elements[0] = fr_test_slab_reserve(test_slab_list);
+       test_elements[0] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[0] != NULL);
-       test_elements[1] = fr_test_slab_reserve(test_slab_list);
+       test_elements[1] = test_slab_reserve(test_slab_list);
        TEST_CHECK(test_elements[1] != NULL);
 
        /*

diff --git a/src/modules/rlm_imap/rlm_imap.c b/src/modules/rlm_imap/rlm_imap.c
index 10f7fb5662a16bcaa8255f80fb1d0430b5771513..4534e527f2b54e1c505bda20ca71ee21d9ef9d5c 100644 (file)
--- a/src/modules/rlm_imap/rlm_imap.c
+++ b/src/modules/rlm_imap/rlm_imap.c
@@ -65,7 +65,7 @@ FR_SLAB_TYPES(imap, fr_curl_io_request_t)
 FR_SLAB_FUNCS(imap, fr_curl_io_request_t)
 
 typedef struct {
-       fr_imap_slab_list_t             *slab;          //!< Slab list for connection handles.
+       imap_slab_list_t                *slab;          //!< Slab list for connection handles.
        fr_curl_handle_t                *mhandle;       //!< Thread specific multi handle.  Serves as the dispatch and coralling structure for imap requests.
 } rlm_imap_thread_t;
 
@@ -94,7 +94,7 @@ static void imap_io_module_signal(module_ctx_t const *mctx, request_t *request,
                /* Not much we can do */
        }
        t->mhandle->transfers--;
-       fr_imap_slab_release(randle);
+       imap_slab_release(randle);
 }
 
 /*
@@ -122,7 +122,7 @@ static unlang_action_t CC_HINT(nonnull) mod_authenticate_resume(rlm_rcode_t *p_r
 
        if (randle->result != CURLE_OK) {
                CURLcode result = randle->result;
-               fr_imap_slab_release(randle);
+               imap_slab_release(randle);
                switch(result) {
                case CURLE_PEER_FAILED_VERIFICATION:
                case CURLE_LOGIN_DENIED:
@@ -134,7 +134,7 @@ static unlang_action_t CC_HINT(nonnull) mod_authenticate_resume(rlm_rcode_t *p_r
 
        if (tls->extract_cert_attrs) fr_curl_response_certinfo(request, randle);
 
-       fr_imap_slab_release(randle);
+       imap_slab_release(randle);
        RETURN_MODULE_OK;
 }
 
@@ -175,9 +175,9 @@ static unlang_action_t CC_HINT(nonnull(1,2)) mod_authenticate(rlm_rcode_t *p_res
                RETURN_MODULE_INVALID;
        }
 
-       randle = fr_imap_slab_reserve(t->slab);
+       randle = imap_slab_reserve(t->slab);
        if (!randle){
-               if (randle) fr_imap_slab_release(randle);
+               if (randle) imap_slab_release(randle);
                RETURN_MODULE_FAIL;
        }
 
@@ -186,7 +186,7 @@ static unlang_action_t CC_HINT(nonnull(1,2)) mod_authenticate(rlm_rcode_t *p_res
 
        if (fr_curl_io_request_enqueue(t->mhandle, request, randle)) {
        error:
-               fr_imap_slab_release(randle);
+               imap_slab_release(randle);
                RETURN_MODULE_FAIL;
        }
 
@@ -247,7 +247,7 @@ static int mod_thread_instantiate(module_thread_inst_ctx_t const *mctx)
        rlm_imap_thread_t       *t = talloc_get_type_abort(mctx->thread, rlm_imap_thread_t);
        fr_curl_handle_t        *mhandle;
 
-       if (fr_imap_slab_list_alloc(t, &t->slab, mctx->el, &inst->conn_config.reuse,
+       if (imap_slab_list_alloc(t, &t->slab, mctx->el, &inst->conn_config.reuse,
                                    imap_conn_alloc, NULL, inst, false, false) < 0) {
                ERROR("Connection handle pool instantiation failed");
                return -1;

diff --git a/src/modules/rlm_rest/io.c b/src/modules/rlm_rest/io.c
index ee781ca56d85b560c47cda52ef76426ad21382e8..050cff9c257b6b51b1ce6fb65a4fe38868b2896d 100644 (file)
--- a/src/modules/rlm_rest/io.c
+++ b/src/modules/rlm_rest/io.c
@@ -45,7 +45,7 @@ void rest_io_module_signal(module_ctx_t const *mctx, request_t *request, UNUSED
        }
        t->mhandle->transfers--;
 
-       fr_rest_slab_release(randle);
+       rest_slab_release(randle);
 }
 
 /** Handle asynchronous cancellation of a request

diff --git a/src/modules/rlm_rest/rest.h b/src/modules/rlm_rest/rest.h
index 75777376e3c469f68d5ef0a7b41530bd2365ca5f..080cad4e25464765c324a82b8ac9a3b526ea3378 100644 (file)
--- a/src/modules/rlm_rest/rest.h
+++ b/src/modules/rlm_rest/rest.h
@@ -177,7 +177,7 @@ FR_SLAB_FUNCS(rest, fr_curl_io_request_t)
  */
 typedef struct {
        rlm_rest_t const        *inst;          //!< Instance of rlm_rest.
-       fr_rest_slab_list_t     *slab;          //!< Slab list for connection handles.
+       rest_slab_list_t        *slab;          //!< Slab list for connection handles.
        fr_curl_handle_t        *mhandle;       //!< Thread specific multi handle.  Serves as the dispatch
                                                //!< and coralling structure for REST requests.
 } rlm_rest_thread_t;

diff --git a/src/modules/rlm_rest/rlm_rest.c b/src/modules/rlm_rest/rlm_rest.c
index 2e4ec13610e3cd5150ce07a3068df02c618d440c..b3bea1a213351cab7a3b6826c67b5c25dbce59ae 100644 (file)
--- a/src/modules/rlm_rest/rlm_rest.c
+++ b/src/modules/rlm_rest/rlm_rest.c
@@ -329,7 +329,7 @@ finish:
                fr_dcursor_insert(out, vb);
        }
 
-       fr_rest_slab_release(handle);
+       rest_slab_release(handle);
 
        talloc_free(rctx);
 
@@ -461,7 +461,7 @@ static xlat_action_t rest_xlat(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
         *      We get a connection from the pool here as the CURL object
         *      is needed to use curl_easy_escape() for escaping
         */
-       randle = rctx->handle = fr_rest_slab_reserve(t->slab);
+       randle = rctx->handle = rest_slab_reserve(t->slab);
        if (!randle) return XLAT_ACTION_FAIL;
 
        /*
@@ -478,7 +478,7 @@ static xlat_action_t rest_xlat(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
                RPEDEBUG("Failed escaping URI");
 
        error:
-               fr_rest_slab_release(randle);
+               rest_slab_release(randle);
                talloc_free(section);
 
                return XLAT_ACTION_FAIL;
@@ -611,7 +611,7 @@ static unlang_action_t mod_authorize_result(rlm_rcode_t *p_result, module_ctx_t
        }
 
 finish:
-       fr_rest_slab_release(handle);
+       rest_slab_release(handle);
 
        RETURN_MODULE_RCODE(rcode);
 }
@@ -633,12 +633,12 @@ static unlang_action_t CC_HINT(nonnull) mod_authorize(rlm_rcode_t *p_result, mod
 
        if (!section->name) RETURN_MODULE_NOOP;
 
-       handle = fr_rest_slab_reserve(t->slab);
+       handle = rest_slab_reserve(t->slab);
        if (!handle) RETURN_MODULE_FAIL;
 
        ret = rlm_rest_perform(mctx, section, handle, request, NULL, NULL);
        if (ret < 0) {
-               fr_rest_slab_release(handle);
+               rest_slab_release(handle);
 
                RETURN_MODULE_FAIL;
        }
@@ -722,7 +722,7 @@ static unlang_action_t mod_authenticate_result(rlm_rcode_t *p_result,
        }
 
 finish:
-       fr_rest_slab_release(handle);
+       rest_slab_release(handle);
 
        RETURN_MODULE_RCODE(rcode);
 }
@@ -778,13 +778,13 @@ static unlang_action_t CC_HINT(nonnull) mod_authenticate(rlm_rcode_t *p_result,
                RDEBUG2("Login attempt with password");
        }
 
-       handle = fr_rest_slab_reserve(t->slab);
+       handle = rest_slab_reserve(t->slab);
        if (!handle) RETURN_MODULE_FAIL;
 
        ret = rlm_rest_perform(mctx, section,
                               handle, request, username->vp_strvalue, password->vp_strvalue);
        if (ret < 0) {
-               fr_rest_slab_release(handle);
+               rest_slab_release(handle);
 
                RETURN_MODULE_FAIL;
        }
@@ -835,7 +835,7 @@ static unlang_action_t mod_accounting_result(rlm_rcode_t *p_result, module_ctx_t
        }
 
 finish:
-       fr_rest_slab_release(handle);
+       rest_slab_release(handle);
 
        RETURN_MODULE_RCODE(rcode);
 }
@@ -854,12 +854,12 @@ static unlang_action_t CC_HINT(nonnull) mod_accounting(rlm_rcode_t *p_result, mo
 
        if (!section->name) RETURN_MODULE_NOOP;
 
-       handle = fr_rest_slab_reserve(t->slab);
+       handle = rest_slab_reserve(t->slab);
        if (!handle) RETURN_MODULE_FAIL;
 
        ret = rlm_rest_perform(mctx, section, handle, request, NULL, NULL);
        if (ret < 0) {
-               fr_rest_slab_release(handle);
+               rest_slab_release(handle);
 
                RETURN_MODULE_FAIL;
        }
@@ -910,7 +910,7 @@ static unlang_action_t mod_post_auth_result(rlm_rcode_t *p_result, module_ctx_t
        }
 
 finish:
-       fr_rest_slab_release(handle);
+       rest_slab_release(handle);
 
        RETURN_MODULE_RCODE(rcode);
 }
@@ -929,12 +929,12 @@ static unlang_action_t CC_HINT(nonnull) mod_post_auth(rlm_rcode_t *p_result, mod
 
        if (!section->name) RETURN_MODULE_NOOP;
 
-       handle = fr_rest_slab_reserve(t->slab);
+       handle = rest_slab_reserve(t->slab);
        if (!handle) RETURN_MODULE_FAIL;
 
        ret = rlm_rest_perform(mctx, section, handle, request, NULL, NULL);
        if (ret < 0) {
-               fr_rest_slab_release(handle);
+               rest_slab_release(handle);
 
                RETURN_MODULE_FAIL;
        }
@@ -1142,7 +1142,7 @@ static int rest_conn_alloc(fr_curl_io_request_t *randle, void *uctx)
        randle->uctx = curl_ctx;
        talloc_set_destructor(randle, _mod_conn_free);
 
-       fr_rest_slab_element_set_destructor(randle, rest_request_cleanup, NULL);
+       rest_slab_element_set_destructor(randle, rest_request_cleanup, NULL);
 
        return 0;
 }
@@ -1165,8 +1165,8 @@ static int mod_thread_instantiate(module_thread_inst_ctx_t const *mctx)
 
        t->inst = inst;
 
-       if (fr_rest_slab_list_alloc(t, &t->slab, mctx->el, &inst->conn_config.reuse,
-                                   rest_conn_alloc, NULL, inst, false, false) < 0) {
+       if (rest_slab_list_alloc(t, &t->slab, mctx->el, &inst->conn_config.reuse,
+                                rest_conn_alloc, NULL, inst, false, false) < 0) {
                ERROR("Connection handle pool instantiation failed");
                return -1;
        }

diff --git a/src/modules/rlm_smtp/rlm_smtp.c b/src/modules/rlm_smtp/rlm_smtp.c
index 621eaf7e9e106751ad9167ea64adaf2fc70e1928..f7369ce5e6f48159ac8fd98b94a730954c5237b9 100644 (file)
--- a/src/modules/rlm_smtp/rlm_smtp.c
+++ b/src/modules/rlm_smtp/rlm_smtp.c
@@ -119,8 +119,8 @@ FR_SLAB_FUNCS(smtp, fr_curl_io_request_t)
 typedef struct {
        fr_curl_handle_t        *mhandle;       //!< Thread specific multi handle.  Serves as the dispatch and
                                                ///< coralling structure for smtp requests
-       fr_smtp_slab_list_t     *slab_persist;  //!< Slab list for persistent connections.
-       fr_smtp_slab_list_t     *slab_onetime;  //!< Slab list for onetime use connections.
+       smtp_slab_list_t        *slab_persist;  //!< Slab list for persistent connections.
+       smtp_slab_list_t        *slab_onetime;  //!< Slab list for onetime use connections.
 } rlm_smtp_thread_t;
 
 /*
@@ -774,7 +774,7 @@ static void smtp_io_module_signal(module_ctx_t const *mctx, request_t *request,
                /* Not much we can do */
        }
        t->mhandle->transfers--;
-       fr_smtp_slab_release(randle);
+       smtp_slab_release(randle);
 }
 
 /**    Callback to process response of SMTP server
@@ -804,7 +804,7 @@ static unlang_action_t smtp_io_module_resume(rlm_rcode_t *p_result, module_ctx_t
 
        if (randle->result != CURLE_OK) {
                CURLcode result = randle->result;
-               fr_smtp_slab_release(randle);
+               smtp_slab_release(randle);
                switch (result) {
                case CURLE_PEER_FAILED_VERIFICATION:
                case CURLE_LOGIN_DENIED:
@@ -815,7 +815,7 @@ static unlang_action_t smtp_io_module_resume(rlm_rcode_t *p_result, module_ctx_t
        }
 
        if (tls->extract_cert_attrs) fr_curl_response_certinfo(request, randle);
-       fr_smtp_slab_release(randle);
+       smtp_slab_release(randle);
 
        RETURN_MODULE_OK;
 }
@@ -857,7 +857,7 @@ static unlang_action_t CC_HINT(nonnull) mod_mail(rlm_rcode_t *p_result, module_c
        if (!inst->sender_address && !inst->envelope_address) {
                RDEBUG2("At least one of \"sender_address\" or \"envelope_address\" in the config, or \"SMTP-Sender-Address\" in the request is needed");
        error:
-               if (randle) fr_smtp_slab_release(randle);
+               if (randle) smtp_slab_release(randle);
                RETURN_MODULE_INVALID;
        }
 
@@ -867,8 +867,8 @@ static unlang_action_t CC_HINT(nonnull) mod_mail(rlm_rcode_t *p_result, module_c
         *      can be used.
         */
        randle = (mod_env->username_tmpl &&
-                 !tmpl_is_data(mod_env->username_tmpl)) ? fr_smtp_slab_reserve(t->slab_onetime) :
-                                                          fr_smtp_slab_reserve(t->slab_persist);
+                 !tmpl_is_data(mod_env->username_tmpl)) ? smtp_slab_reserve(t->slab_onetime) :
+                                                          smtp_slab_reserve(t->slab_persist);
        if (!randle) {
                RDEBUG2("A handle could not be allocated for the request");
                RETURN_MODULE_FAIL;
@@ -962,7 +962,7 @@ static unlang_action_t CC_HINT(nonnull(1,2)) mod_authenticate(rlm_rcode_t *p_res
        fr_pair_t const         *username, *password;
        fr_curl_io_request_t    *randle;
 
-       randle = fr_smtp_slab_reserve(t->slab_onetime);
+       randle = smtp_slab_reserve(t->slab_onetime);
        if (!randle) RETURN_MODULE_FAIL;
 
        username = fr_pair_find_by_da(&request->request_pairs, NULL, attr_user_name);
@@ -972,7 +972,7 @@ static unlang_action_t CC_HINT(nonnull(1,2)) mod_authenticate(rlm_rcode_t *p_res
        if (!username) {
                REDEBUG("Attribute \"User-Name\" is required for authentication");
        error:
-               fr_smtp_slab_release(randle);
+               smtp_slab_release(randle);
                RETURN_MODULE_INVALID;
        }
        if (username->vp_length == 0) {
@@ -1115,7 +1115,7 @@ static int smtp_onetime_conn_alloc(fr_curl_io_request_t *randle, UNUSED void *uc
        MEM(mail_ctx = talloc_zero(randle, fr_mail_ctx_t));
        randle->uctx = mail_ctx;
 
-       fr_smtp_slab_element_set_destructor(randle, smtp_onetime_request_cleanup, NULL);
+       smtp_slab_element_set_destructor(randle, smtp_onetime_request_cleanup, NULL);
 
        return 0;
 }
@@ -1141,7 +1141,7 @@ static int smtp_persist_conn_alloc(fr_curl_io_request_t *randle, UNUSED void *uc
        }
        talloc_set_destructor(mail_ctx, smtp_mail_ctx_free);
 
-       fr_smtp_slab_element_set_destructor(randle, smtp_persist_request_cleanup, NULL);
+       smtp_slab_element_set_destructor(randle, smtp_persist_request_cleanup, NULL);
 
        return 0;
 }
@@ -1205,12 +1205,12 @@ static int mod_thread_instantiate(module_thread_inst_ctx_t const *mctx)
        rlm_smtp_thread_t       *t = talloc_get_type_abort(mctx->thread, rlm_smtp_thread_t);
        fr_curl_handle_t        *mhandle;
 
-       if (fr_smtp_slab_list_alloc(t, &t->slab_onetime, mctx->el, &inst->conn_config.reuse,
+       if (smtp_slab_list_alloc(t, &t->slab_onetime, mctx->el, &inst->conn_config.reuse,
                                    smtp_onetime_conn_alloc, smtp_onetime_conn_init, inst, false, false) < 0) {
                ERROR("Connection handle pool instantiation failed");
                return -1;
        }
-       if (fr_smtp_slab_list_alloc(t, &t->slab_persist, mctx->el, &inst->conn_config.reuse,
+       if (smtp_slab_list_alloc(t, &t->slab_persist, mctx->el, &inst->conn_config.reuse,
                                    smtp_persist_conn_alloc, smtp_persist_conn_init, inst, false, true) < 0) {
                ERROR("Connection handle pool instantiation failed");
                return -1;