From f969309f11dfbe24d3e7f863bc3b463536b869ad Mon Sep 17 00:00:00 2001 From: Sukchan Lee Date: Sun, 28 May 2023 22:47:10 +0900 Subject: [PATCH] [CORE] Rollback ogs_pool_init/final (#2339) ogs_pool_init() shall be used in the initialization routine. Otherwise, memory will be fragment since this function uses system malloc() Compared with ogs_pool_init() ogs_pool_create() could be called while the process is running, so this function should use ogs_malloc() instead of system malloc() --- lib/core/ogs-pool.h | 66 ++++++++++++++++++++++++++++++++++--------- lib/pfcp/context.c | 20 ++++++------- src/mme/mme-context.c | 4 +-- src/smf/context.c | 12 ++++---- 4 files changed, 70 insertions(+), 32 deletions(-) diff --git a/lib/core/ogs-pool.h b/lib/core/ogs-pool.h index e5f3c8c4f..b6398192a 100644 --- a/lib/core/ogs-pool.h +++ b/lib/core/ogs-pool.h @@ -28,14 +28,6 @@ extern "C" { #endif -#if OGS_USE_TALLOC == 1 -#define ogs_pool_create ogs_malloc -#define ogs_pool_destroy ogs_free -#else -#define ogs_pool_create malloc -#define ogs_pool_destroy free -#endif - typedef uint32_t ogs_pool_id_t; #define OGS_POOL(pool, type) \ @@ -46,14 +38,18 @@ typedef uint32_t ogs_pool_id_t; type **free, *array, **index; \ } pool +/* + * ogs_pool_init() shall be used in the initialization routine. + * Otherwise, memory will be fragment since this function uses system malloc() + */ #define ogs_pool_init(pool, _size) do { \ int i; \ (pool)->name = #pool; \ - (pool)->free = ogs_pool_create(sizeof(*(pool)->free) * _size); \ + (pool)->free = malloc(sizeof(*(pool)->free) * _size); \ ogs_assert((pool)->free); \ - (pool)->array = ogs_pool_create(sizeof(*(pool)->array) * _size); \ + (pool)->array = malloc(sizeof(*(pool)->array) * _size); \ ogs_assert((pool)->array); \ - (pool)->index = ogs_pool_create(sizeof(*(pool)->index) * _size); \ + (pool)->index = malloc(sizeof(*(pool)->index) * _size); \ ogs_assert((pool)->index); \ (pool)->size = (pool)->avail = _size; \ (pool)->head = (pool)->tail = 0; \ @@ -63,13 +59,55 @@ typedef uint32_t ogs_pool_id_t; } \ } while (0) +/* + * ogs_pool_final() shall be used in the finalization routine. + * Otherwise, memory will be fragment since this function uses system free() + */ #define ogs_pool_final(pool) do { \ if (((pool)->size != (pool)->avail)) \ ogs_error("%d in '%s[%d]' were not released.", \ (pool)->size - (pool)->avail, (pool)->name, (pool)->size); \ - ogs_pool_destroy((pool)->free); \ - ogs_pool_destroy((pool)->array); \ - ogs_pool_destroy((pool)->index); \ + free((pool)->free); \ + free((pool)->array); \ + free((pool)->index); \ +} while (0) + +/* + * COMPARED WITH ogs_pool_init() + * + * ogs_pool_create() could be called while the process is running, + * so this function should use ogs_malloc() instead of system malloc() + */ +#define ogs_pool_create(pool, _size) do { \ + int i; \ + (pool)->name = #pool; \ + (pool)->free = ogs_malloc(sizeof(*(pool)->free) * _size); \ + ogs_assert((pool)->free); \ + (pool)->array = ogs_malloc(sizeof(*(pool)->array) * _size); \ + ogs_assert((pool)->array); \ + (pool)->index = ogs_malloc(sizeof(*(pool)->index) * _size); \ + ogs_assert((pool)->index); \ + (pool)->size = (pool)->avail = _size; \ + (pool)->head = (pool)->tail = 0; \ + for (i = 0; i < _size; i++) { \ + (pool)->free[i] = &((pool)->array[i]); \ + (pool)->index[i] = NULL; \ + } \ +} while (0) + +/* + * COMPARED WITH ogs_pool_final() + * + * ogs_pool_destroy() could be called while the process is running, + * so this function should use ogs_free() instead of system free() + */ +#define ogs_pool_destroy(pool) do { \ + if (((pool)->size != (pool)->avail)) \ + ogs_error("%d in '%s[%d]' were not released.", \ + (pool)->size - (pool)->avail, (pool)->name, (pool)->size); \ + ogs_free((pool)->free); \ + ogs_free((pool)->array); \ + ogs_free((pool)->index); \ } while (0) #define ogs_pool_index(pool, node) (((node) - (pool)->array)+1) diff --git a/lib/pfcp/context.c b/lib/pfcp/context.c index 9e15075b1..5f085c687 100644 --- a/lib/pfcp/context.c +++ b/lib/pfcp/context.c @@ -2084,11 +2084,11 @@ void ogs_pfcp_pool_init(ogs_pfcp_sess_t *sess) sess->obj.type = OGS_PFCP_OBJ_SESS_TYPE; - ogs_pool_init(&sess->pdr_id_pool, OGS_MAX_NUM_OF_PDR); - ogs_pool_init(&sess->far_id_pool, OGS_MAX_NUM_OF_FAR); - ogs_pool_init(&sess->urr_id_pool, OGS_MAX_NUM_OF_URR); - ogs_pool_init(&sess->qer_id_pool, OGS_MAX_NUM_OF_QER); - ogs_pool_init(&sess->bar_id_pool, OGS_MAX_NUM_OF_BAR); + ogs_pool_create(&sess->pdr_id_pool, OGS_MAX_NUM_OF_PDR); + ogs_pool_create(&sess->far_id_pool, OGS_MAX_NUM_OF_FAR); + ogs_pool_create(&sess->urr_id_pool, OGS_MAX_NUM_OF_URR); + ogs_pool_create(&sess->qer_id_pool, OGS_MAX_NUM_OF_QER); + ogs_pool_create(&sess->bar_id_pool, OGS_MAX_NUM_OF_BAR); ogs_pool_sequence_id_generate(&sess->pdr_id_pool); ogs_pool_sequence_id_generate(&sess->far_id_pool); @@ -2100,9 +2100,9 @@ void ogs_pfcp_pool_final(ogs_pfcp_sess_t *sess) { ogs_assert(sess); - ogs_pool_final(&sess->pdr_id_pool); - ogs_pool_final(&sess->far_id_pool); - ogs_pool_final(&sess->urr_id_pool); - ogs_pool_final(&sess->qer_id_pool); - ogs_pool_final(&sess->bar_id_pool); + ogs_pool_destroy(&sess->pdr_id_pool); + ogs_pool_destroy(&sess->far_id_pool); + ogs_pool_destroy(&sess->urr_id_pool); + ogs_pool_destroy(&sess->qer_id_pool); + ogs_pool_destroy(&sess->bar_id_pool); } diff --git a/src/mme/mme-context.c b/src/mme/mme-context.c index 9986ac401..4035500ac 100644 --- a/src/mme/mme-context.c +++ b/src/mme/mme-context.c @@ -3970,7 +3970,7 @@ void mme_ebi_pool_init(mme_ue_t *mme_ue) ogs_assert(mme_ue); - ogs_pool_init(&mme_ue->ebi_pool, MAX_EPS_BEARER_ID-MIN_EPS_BEARER_ID+1); + ogs_pool_create(&mme_ue->ebi_pool, MAX_EPS_BEARER_ID-MIN_EPS_BEARER_ID+1); for (i = MIN_EPS_BEARER_ID, index = 0; i <= MAX_EPS_BEARER_ID; i++, index++) { @@ -3982,7 +3982,7 @@ void mme_ebi_pool_final(mme_ue_t *mme_ue) { ogs_assert(mme_ue); - ogs_pool_final(&mme_ue->ebi_pool); + ogs_pool_destroy(&mme_ue->ebi_pool); } void mme_ebi_pool_clear(mme_ue_t *mme_ue) diff --git a/src/smf/context.c b/src/smf/context.c index 6e7a73588..b63274570 100644 --- a/src/smf/context.c +++ b/src/smf/context.c @@ -3003,7 +3003,7 @@ void smf_qfi_pool_init(smf_sess_t *sess) { ogs_assert(sess); - ogs_pool_init(&sess->qfi_pool, OGS_MAX_QOS_FLOW_ID); + ogs_pool_create(&sess->qfi_pool, OGS_MAX_QOS_FLOW_ID); ogs_pool_sequence_id_generate(&sess->qfi_pool); } @@ -3011,14 +3011,14 @@ void smf_qfi_pool_final(smf_sess_t *sess) { ogs_assert(sess); - ogs_pool_final(&sess->qfi_pool); + ogs_pool_destroy(&sess->qfi_pool); } void smf_pf_identifier_pool_init(smf_bearer_t *bearer) { ogs_assert(bearer); - ogs_pool_init(&bearer->pf_identifier_pool, OGS_MAX_NUM_OF_FLOW_IN_BEARER); + ogs_pool_create(&bearer->pf_identifier_pool, OGS_MAX_NUM_OF_FLOW_IN_BEARER); ogs_pool_sequence_id_generate(&bearer->pf_identifier_pool); } @@ -3026,14 +3026,14 @@ void smf_pf_identifier_pool_final(smf_bearer_t *bearer) { ogs_assert(bearer); - ogs_pool_final(&bearer->pf_identifier_pool); + ogs_pool_destroy(&bearer->pf_identifier_pool); } void smf_pf_precedence_pool_init(smf_sess_t *sess) { ogs_assert(sess); - ogs_pool_init(&sess->pf_precedence_pool, + ogs_pool_create(&sess->pf_precedence_pool, OGS_MAX_NUM_OF_BEARER * OGS_MAX_NUM_OF_FLOW_IN_BEARER); ogs_pool_sequence_id_generate(&sess->pf_precedence_pool); } @@ -3042,7 +3042,7 @@ void smf_pf_precedence_pool_final(smf_sess_t *sess) { ogs_assert(sess); - ogs_pool_final(&sess->pf_precedence_pool); + ogs_pool_destroy(&sess->pf_precedence_pool); } static void stats_add_smf_session(void)