> Allow users to provide custom
> memory allocation hooks for runtime memory in rte_acl_ctx, via
> struct rte_acl_mem_hook.
>
> Key changes:
> - Added struct rte_acl_mem_hook with zalloc, free, and udata.
> - Added rte_acl_set_mem_hook / rte_acl_get_mem_hook to set/get callbacks.
> - Default allocation uses existing rte_zmalloc_socket/rte_free.
> - Modified ACL code to call callbacks for runtime allocations instead
> of rte_zmalloc_socket/rte_free directly.
>
> v5:
> - Remove temporary memory allocation callback for build stage.
> - Introduce new API (rte_acl_set_mem_hook / rte_acl_get_mem_hook)
> instead of modifying existing rte_acl_config to preserve
> ABI compatibility.
>
> v6:
> - Reworked API to meet consistency and naming conventions.
> - Adjusted parameter order for better readability and alignment.
> - Renamed internal variables for clarity and code consistency.
>
> v7:
> - Switch the UT to use malloc/free.
> - Update the documentation to clarify that rte_acl_set_mem_hook
> must be called before rte_acl_build.
>
> Signed-off-by: YongFeng Wang <[email protected]>
> ---
> app/test/test_acl.c | 117 ++++++++++++++++++
> .../prog_guide/packet_classif_access_ctrl.rst | 31 +++++
> lib/acl/acl.h | 1 +
> lib/acl/acl_bld.c | 2 +-
> lib/acl/acl_gen.c | 4 +-
> lib/acl/rte_acl.c | 45 ++++++-
> lib/acl/rte_acl.h | 53 ++++++++
> 7 files changed, 249 insertions(+), 4 deletions(-)
>
> diff --git a/app/test/test_acl.c b/app/test/test_acl.c
> index 43d13b5b0f..5472943580 100644
> --- a/app/test/test_acl.c
> +++ b/app/test/test_acl.c
> @@ -1721,6 +1721,121 @@ test_u32_range(void)
> return rc;
> }
>
> +struct acl_ctx_wrapper {
> + struct rte_acl_ctx *ctx;
> + void *running_buf;
> + bool running_buf_using;
> +};
> +
> +#define ACL_RUNNING_BUF_SIZE (10 * 1024 * 1024)
> +
> +static void *running_alloc(char *name, size_t size,
> + size_t align, int32_t socket_id, void *udata)
> +{
> + RTE_SET_USED(align);
> + RTE_SET_USED(name);
> + RTE_SET_USED(socket_id);
> + if (size > ACL_RUNNING_BUF_SIZE)
> + return NULL;
> + struct acl_ctx_wrapper *acl_ctx = (struct acl_ctx_wrapper *)udata;
> + if (acl_ctx->running_buf_using)
> + return NULL;
> + printf("running memory alloc for acl context, size=%zu, pointer=%p\n",
> + size,
> + acl_ctx->running_buf);
> + memset(acl_ctx->running_buf, 0, size);
> + acl_ctx->running_buf_using = true;
> + return acl_ctx->running_buf;
> +}
Sorry, I didn't express myself clear enough.
My thought was to use malloc/aligned_alloc() directly in running_alloc()
function.
To be more specific here:
static void *running_alloc(char *name, size_t size, size_t align, int32_t
socket_id, void *udata)
{
...
/* just for the API correctness check */
If (udata != <expected_value>) {
/* report error */
return NULL;
}
addr = aligned_alloc(align, size);
if (addr == NULL) {
/* report error*/
}
return addr;
}
> +static void running_free(void *ptr, void *udata)
> +{
> + if (!ptr)
> + return;
> + struct acl_ctx_wrapper *acl_ctx = (struct acl_ctx_wrapper *)udata;
> + printf("running memory free, pointer=%p\n", ptr);
> + acl_ctx->running_buf_using = false;
> +}
> +
> +static int
> +test_mem_hook(void)
> +{
> + int i, ret;
> + struct acl_ctx_wrapper acl_ctx_wrapper = {0};
> + acl_ctx_wrapper.ctx = rte_acl_create(&acl_param);
> + if (acl_ctx_wrapper.ctx == NULL) {
> + printf("Line %i: Error creating ACL context!\n", __LINE__);
> + return -1;
> + }
> + acl_ctx_wrapper.running_buf = malloc(ACL_RUNNING_BUF_SIZE);
> + if (!acl_ctx_wrapper.running_buf) {
> + rte_acl_free(acl_ctx_wrapper.ctx);
> + printf("Line %i: Error allocing running buf for acl context!\n",
> __LINE__);
> + return 1;
> + }
> + acl_ctx_wrapper.running_buf_using = false;
> +
> + struct rte_acl_mem_hook mhook = {
> + .zalloc = running_alloc,
> + .free = running_free,
> + .udata = &acl_ctx_wrapper
> + };
> + ret = rte_acl_set_mem_hook(acl_ctx_wrapper.ctx, &mhook);
> + if (ret != 0) {
> + printf("Line %i: Error set mem hook for acl context!\n",
> __LINE__);
> + rte_acl_free(acl_ctx_wrapper.ctx);
> + free(acl_ctx_wrapper.running_buf);
> + return 1;
> + }
> + struct rte_acl_mem_hook new_hook;
> + memset(&new_hook, 0, sizeof(struct rte_acl_mem_hook));
> + if (rte_acl_get_mem_hook(acl_ctx_wrapper.ctx, &new_hook) != 0
> + || memcmp(&mhook, &new_hook, sizeof(struct
> rte_acl_mem_hook)) != 0) {
> + printf("Line %i: Error get mem hook for acl context!\n",
> __LINE__);
> + rte_acl_free(acl_ctx_wrapper.ctx);
> + free(acl_ctx_wrapper.running_buf);
> + return 1;
> + }
> + ret = 0;
> + for (i = 0; i < TEST_CLASSIFY_ITER; i++) {
> +
> + if ((i & 1) == 0)
> + rte_acl_reset(acl_ctx_wrapper.ctx);
> + else
> + rte_acl_reset_rules(acl_ctx_wrapper.ctx);
> +
> + ret = test_classify_buid(acl_ctx_wrapper.ctx, acl_test_rules,
> + RTE_DIM(acl_test_rules));
> + if (ret != 0) {
> + printf("Line %i, iter: %d: Adding rules to ACL context
> failed!\n",
> + __LINE__, i);
> + break;
> + }
> +
> + ret = test_classify_run(acl_ctx_wrapper.ctx, acl_test_data,
> + RTE_DIM(acl_test_data));
> + if (ret != 0) {
> + printf("Line %i, iter: %d: %s failed!\n",
> + __LINE__, i, __func__);
> + break;
> + }
> +
> + /* reset rules and make sure that classify still works ok. */
> + rte_acl_reset_rules(acl_ctx_wrapper.ctx);
> + ret = test_classify_run(acl_ctx_wrapper.ctx, acl_test_data,
> + RTE_DIM(acl_test_data));
> + if (ret != 0) {
> + printf("Line %i, iter: %d: %s failed!\n",
> + __LINE__, i, __func__);
> + break;
> + }
> + }
> +
> + rte_acl_free(acl_ctx_wrapper.ctx);
> + free(acl_ctx_wrapper.running_buf);
> + return ret;
> +}
> +
> static int
> test_acl(void)
> {
> @@ -1742,6 +1857,8 @@ test_acl(void)
> return -1;
> if (test_u32_range() < 0)
> return -1;
> + if (test_mem_hook() < 0)
> + return -1;
>
> return 0;
> }
> diff --git a/doc/guides/prog_guide/packet_classif_access_ctrl.rst
> b/doc/guides/prog_guide/packet_classif_access_ctrl.rst
> index 172f443f6e..55b2018db9 100644
> --- a/doc/guides/prog_guide/packet_classif_access_ctrl.rst
> +++ b/doc/guides/prog_guide/packet_classif_access_ctrl.rst
> @@ -359,7 +359,38 @@ For example:
> ret = rte_acl_build(acx, &cfg);
> }
>
> +Custom Memory Hooks
> +~~~~~~~~~~~~~~~~~~~~
> +
> +The ACL library supports custom memory allocation for runtime structures.
> +Applications can supply their own memory hooks through:
> +
> +.. code-block:: c
> +
> + int rte_acl_set_mem_hook(struct rte_acl_ctx *ctx,
> + const struct rte_acl_mem_hook *mhook);
> +
> + int rte_acl_get_mem_hook(const struct rte_acl_ctx *ctx,
> + struct rte_acl_mem_hook *mhook);
> +
> +The ``rte_acl_mem_hook`` structure defines memory hooks:
> +
> +.. code-block:: c
> +
> + struct rte_acl_mem_hook {
> + /** Allocate zero-initialized memory used during runtime. */
> + void *(*zalloc)(char *name, size_t size, size_t align, int32_t
> socket_id, void
> *udata);
> +
> + /** Free memory previously allocated by zalloc(). */
> + void (*free)(void *ptr, void *udata);
> +
> + /** User-provided context passed to allocation/free hooks. */
> + void *udata;
> + };
> +
> +Applications may use these hooks to allocate memory from custom pools or pre-
> allocated buffers.
>
> +If no memory hook is provided, the ACL library uses rte_zmalloc_socket()
> internally.
>
> Classification methods
> ~~~~~~~~~~~~~~~~~~~~~~
> diff --git a/lib/acl/acl.h b/lib/acl/acl.h
> index c8e4e72fab..9c85a3d58a 100644
> --- a/lib/acl/acl.h
> +++ b/lib/acl/acl.h
> @@ -174,6 +174,7 @@ struct rte_acl_ctx {
> uint32_t max_rules;
> uint32_t rule_sz;
> uint32_t num_rules;
> + struct rte_acl_mem_hook mem_hook;
> uint32_t num_categories;
> uint32_t num_tries;
> uint32_t match_index;
> diff --git a/lib/acl/acl_bld.c b/lib/acl/acl_bld.c
> index 7056b1c117..99d1dbc467 100644
> --- a/lib/acl/acl_bld.c
> +++ b/lib/acl/acl_bld.c
> @@ -779,7 +779,7 @@ acl_merge_trie(struct acl_build_context *context,
> static void
> acl_build_reset(struct rte_acl_ctx *ctx)
> {
> - rte_free(ctx->mem);
> + ctx->mem_hook.free(ctx->mem, ctx->mem_hook.udata);
> memset(&ctx->num_categories, 0,
> sizeof(*ctx) - offsetof(struct rte_acl_ctx, num_categories));
> }
> diff --git a/lib/acl/acl_gen.c b/lib/acl/acl_gen.c
> index 3c53d24056..77f19dd13a 100644
> --- a/lib/acl/acl_gen.c
> +++ b/lib/acl/acl_gen.c
> @@ -478,8 +478,8 @@ rte_acl_gen(struct rte_acl_ctx *ctx, struct rte_acl_trie
> *trie,
> return -ERANGE;
> }
>
> - mem = rte_zmalloc_socket(ctx->name, total_size, RTE_CACHE_LINE_SIZE,
> - ctx->socket_id);
> + mem = ctx->mem_hook.zalloc(ctx->name, total_size,
> + RTE_CACHE_LINE_SIZE, ctx->socket_id, ctx-
> >mem_hook.udata);
> if (mem == NULL) {
> ACL_LOG(ERR,
> "allocation of %zu bytes on socket %d for %s failed",
> diff --git a/lib/acl/rte_acl.c b/lib/acl/rte_acl.c
> index 8c0ca29618..3f2b194206 100644
> --- a/lib/acl/rte_acl.c
> +++ b/lib/acl/rte_acl.c
> @@ -264,6 +264,20 @@ acl_get_best_alg(void)
> return alg[i];
> }
>
> +static void *
> +acl_mem_default_zalloc(char *name, size_t size, size_t align, int32_t
> socket_id,
> void *udata)
> +{
> + RTE_SET_USED(udata);
> + return rte_zmalloc_socket(name, size, align, socket_id);
> +}
> +
> +static void
> +acl_mem_default_free(void *ptr, void *udata)
> +{
> + RTE_SET_USED(udata);
> + rte_free(ptr);
> +}
> +
> RTE_EXPORT_SYMBOL(rte_acl_set_ctx_classify)
> extern int
> rte_acl_set_ctx_classify(struct rte_acl_ctx *ctx, enum rte_acl_classify_alg
> alg)
> @@ -362,7 +376,7 @@ rte_acl_free(struct rte_acl_ctx *ctx)
>
> rte_mcfg_tailq_write_unlock();
>
> - rte_free(ctx->mem);
> + ctx->mem_hook.free(ctx->mem, ctx->mem_hook.udata);
> rte_free(ctx);
> rte_free(te);
> }
> @@ -425,6 +439,9 @@ rte_acl_create(const struct rte_acl_param *param)
> ctx->rule_sz = param->rule_size;
> ctx->socket_id = param->socket_id;
> ctx->alg = acl_get_best_alg();
> + ctx->mem_hook.zalloc = acl_mem_default_zalloc;
> + ctx->mem_hook.free = acl_mem_default_free;
> + ctx->mem_hook.udata = NULL;
> strlcpy(ctx->name, param->name, sizeof(ctx->name));
>
> te->data = (void *) ctx;
> @@ -555,3 +572,29 @@ rte_acl_list_dump(void)
> }
> rte_mcfg_tailq_read_unlock();
> }
> +
> +/*
> + * Set memory allocation hooks for a given ACL context.
> + */
> +RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_acl_set_mem_hook, 26.03)
> +int
> +rte_acl_set_mem_hook(struct rte_acl_ctx *acl, const struct rte_acl_mem_hook
> *mhook)
> +{
> + if (acl == NULL || mhook == NULL || mhook->zalloc == NULL || mhook-
> >free == NULL)
> + return -EINVAL;
> + memcpy(&acl->mem_hook, mhook, sizeof(struct rte_acl_mem_hook));
> + return 0;
> +}
> +
> +/*
> + * Retrieve the memory allocation hooks assigned to the ACL context.
> + */
> +RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_acl_get_mem_hook, 26.03)
> +int
> +rte_acl_get_mem_hook(const struct rte_acl_ctx *acl, struct rte_acl_mem_hook
> *mhook)
> +{
> + if (acl == NULL || mhook == NULL)
> + return -EINVAL;
> + memcpy(mhook, &acl->mem_hook, sizeof(struct rte_acl_mem_hook));
> + return 0;
> +}
> diff --git a/lib/acl/rte_acl.h b/lib/acl/rte_acl.h
> index 95354cabb8..18ac30889b 100644
> --- a/lib/acl/rte_acl.h
> +++ b/lib/acl/rte_acl.h
> @@ -136,6 +136,59 @@ struct rte_acl_param {
> /** @internal opaque ACL handle */
> struct rte_acl_ctx;
>
> +/**
> + * Memory allocation hooks for ACL runtime.
> + */
> +struct rte_acl_mem_hook {
> + /** Allocate zero-initialized memory used during runtime. */
> + void *(*zalloc)(char *name, size_t size, size_t align, int32_t
> socket_id, void
> *udata);
> +
> + /** Free memory previously allocated by zalloc(). */
> + void (*free)(void *ptr, void *udata);
> +
> + /** User-provided context passed to allocation/free hooks. */
> + void *udata;
> +};
> +
> +/**
> + * Set memory allocation hooks for a given ACL context.
> + *
> + * Applications may use these hooks to allocate memory from custom pools or
> + * pre-allocated buffers. If no memory hook is provided, the ACL library uses
> + * rte_zmalloc_socket() internally.
> + *
> + * This function must be called **before** rte_acl_build().
> + * If the hook needs to be changed after a build, the ACL context must be
> reset
> + * first by invoking rte_acl_reset(), and only then can the memory hook be
> + * updated followed by another call to rte_acl_build().
> + *
> + * @param acl
> + * The ACL context.
> + * @param mhook
> + * Pointer to the memory hook structure
> + *
> + * @return
> + * 0 on success.
> + * -EINVAL if parameters are invalid.
> + */
> +__rte_experimental
> +int rte_acl_set_mem_hook(struct rte_acl_ctx *acl, const struct
> rte_acl_mem_hook
> *mhook);
> +
> +/**
> + * Retrieve the memory allocation hooks assigned to the ACL context.
> + *
> + * @param acl
> + * The ACL context.
> + * @param mhook
> + * Output location for the current memory hook structure
> + *
> + * @return
> + * 0 on success.
> + * -EINVAL if parameters are invalid.
> + */
> +__rte_experimental
> +int rte_acl_get_mem_hook(const struct rte_acl_ctx *acl, struct
> rte_acl_mem_hook
> *mhook);
> +
> /**
> * De-allocate all memory used by ACL context.
> *
> --
> 2.43.0
>
