From: Arran Cudbard-Bell Date: Mon, 3 Apr 2023 22:40:09 +0000 (-0600) Subject: slab: Remove implicit fr_ prefix X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=f46848e1a8d495b882847df8239aea4f2bbcf707;p=thirdparty%2Ffreeradius-server.git 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 0da8627f1a..3c2e07c62e 100644 --- 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 e8ac62257d..e6fc877e67 100644 --- 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 10f7fb5662..4534e527f2 100644 --- 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 ee781ca56d..050cff9c25 100644 --- 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 75777376e3..080cad4e25 100644 --- 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 2e4ec13610..b3bea1a213 100644 --- 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 621eaf7e9e..f7369ce5e6 100644 --- 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;