From 8dd03b01f6b94f26afc9ed5a042ef3e6bd57cd79 Mon Sep 17 00:00:00 2001 From: Robert Baldyga Date: Tue, 27 Jan 2026 23:12:06 +0100 Subject: [PATCH] cleaning: Populate cleaning policy on the load path properly ACP requires dirty counter reconstruction regardless to shutdown status, while ALRU reconstructs only on dirty shutdown. Call the populate on load unconditionally and let the cleaining policy deciside on what to populate in each of those cases. Signed-off-by: Robert Baldyga --- src/cleaning/acp.c | 8 +++----- src/cleaning/acp.h | 5 +++-- src/cleaning/alru.c | 13 ++++++++----- src/cleaning/alru.h | 5 +++-- src/cleaning/cleaning_ops.h | 13 +++++++------ src/mngt/ocf_mngt_cache.c | 25 ++++++++++--------------- src/mngt/ocf_mngt_flush.c | 3 ++- 7 files changed, 36 insertions(+), 36 deletions(-) diff --git a/src/cleaning/acp.c b/src/cleaning/acp.c index 3364c8de..b558a98d 100644 --- a/src/cleaning/acp.c +++ b/src/cleaning/acp.c @@ -1,6 +1,7 @@ /* * Copyright(c) 2012-2022 Intel Corporation * Copyright(c) 2024-2025 Huawei Technologies + * Copyright(c) 2026 Unvertical * SPDX-License-Identifier: BSD-3-Clause */ @@ -246,7 +247,7 @@ void cleaning_policy_acp_setup(struct ocf_cache *cache) config->flush_max_buffers = OCF_ACP_DEFAULT_FLUSH_MAX_BUFFERS; } -int cleaning_policy_acp_initialize(ocf_cache_t cache, int kick_cleaner) +int cleaning_policy_acp_initialize(ocf_cache_t cache) { struct acp_context *acp; int err, i; @@ -292,9 +293,6 @@ int cleaning_policy_acp_initialize(ocf_cache_t cache, int kick_cleaner) } } - if (kick_cleaner) - ocf_kick_cleaner(cache); - return 0; } @@ -419,7 +417,7 @@ static void ocf_acp_populate_finish(ocf_parallelize_t parallelize, ocf_parallelize_destroy(parallelize); } -void cleaning_policy_acp_populate(ocf_cache_t cache, +void cleaning_policy_acp_populate(ocf_cache_t cache, bool reconstruct, ocf_cleaning_op_end_t cmpl, void *priv) { struct ocf_acp_populate_context *context; diff --git a/src/cleaning/acp.h b/src/cleaning/acp.h index c1beba51..3d5a4b7f 100644 --- a/src/cleaning/acp.h +++ b/src/cleaning/acp.h @@ -1,6 +1,7 @@ /* * Copyright(c) 2012-2022 Intel Corporation * Copyright(c) 2025 Huawei Technologies + * Copyright(c) 2026 Unvertical * SPDX-License-Identifier: BSD-3-Clause */ #ifndef __LAYER_CLEANING_POLICY_AGGRESSIVE_H__ @@ -11,9 +12,9 @@ void cleaning_policy_acp_setup(ocf_cache_t cache); -int cleaning_policy_acp_initialize(ocf_cache_t cache, int kick_cleaner); +int cleaning_policy_acp_initialize(ocf_cache_t cache); -void cleaning_policy_acp_populate(ocf_cache_t cache, +void cleaning_policy_acp_populate(ocf_cache_t cache, bool reconstruct, ocf_cleaning_op_end_t cmpl, void *priv); void cleaning_policy_acp_prepopulate(ocf_cache_t cache, diff --git a/src/cleaning/alru.c b/src/cleaning/alru.c index c4bf543d..219b493f 100644 --- a/src/cleaning/alru.c +++ b/src/cleaning/alru.c @@ -2,6 +2,7 @@ * Copyright(c) 2012-2022 Intel Corporation * Copyright(c) 2022 David Lee * Copyright(c) 2024-2025 Huawei Technologies + * Copyright(c) 2026 Unvertical * SPDX-License-Identifier: BSD-3-Clause */ @@ -361,7 +362,7 @@ void cleaning_policy_alru_setup(struct ocf_cache *cache) config->dirty_ratio_inertia = OCF_ALRU_DEFAULT_DIRTY_RATIO_INERTIA; } -int cleaning_policy_alru_initialize(ocf_cache_t cache, int kick_cleaner) +int cleaning_policy_alru_initialize(ocf_cache_t cache) { struct alru_context *ctx; int error = 0; @@ -390,9 +391,6 @@ int cleaning_policy_alru_initialize(ocf_cache_t cache, int kick_cleaner) cache->cleaner.cleaning_policy_context = ctx; - if (kick_cleaner) - ocf_kick_cleaner(cache); - return 0; } @@ -607,9 +605,14 @@ static void cleaning_policy_alru_fill(ocf_cache_t cache, ocf_parallelize_run(parallelize); } -void cleaning_policy_alru_populate(ocf_cache_t cache, +void cleaning_policy_alru_populate(ocf_cache_t cache, bool reconstruct, ocf_cleaning_op_end_t cmpl, void *priv) { + if (!reconstruct) { + ocf_kick_cleaner(cache); + OCF_CMPL_RET(priv, 0); + } + cleaning_policy_alru_fill(cache, cmpl, priv, ocf_alru_populate_handle); } diff --git a/src/cleaning/alru.h b/src/cleaning/alru.h index b65c2c22..6b06c1f1 100644 --- a/src/cleaning/alru.h +++ b/src/cleaning/alru.h @@ -1,6 +1,7 @@ /* * Copyright(c) 2012-2022 Intel Corporation * Copyright(c) 2025 Huawei Technologies + * Copyright(c) 2026 Unvertical * SPDX-License-Identifier: BSD-3-Clause */ #ifndef __LAYER_CLEANING_POLICY_ALRU_H__ @@ -11,8 +12,8 @@ #include "alru_structs.h" void cleaning_policy_alru_setup(ocf_cache_t cache); -int cleaning_policy_alru_initialize(ocf_cache_t cache, int kick_cleaner); -void cleaning_policy_alru_populate(ocf_cache_t cache, +int cleaning_policy_alru_initialize(ocf_cache_t cache); +void cleaning_policy_alru_populate(ocf_cache_t cache, bool reconstruct, ocf_cleaning_op_end_t cmpl, void *priv); void cleaning_policy_alru_prepopulate(ocf_cache_t cache, ocf_cleaning_op_end_t cmpl, void *priv); diff --git a/src/cleaning/cleaning_ops.h b/src/cleaning/cleaning_ops.h index 73f4c35f..6e98da5f 100644 --- a/src/cleaning/cleaning_ops.h +++ b/src/cleaning/cleaning_ops.h @@ -1,6 +1,7 @@ /* * Copyright(c) 2012-2022 Intel Corporation * Copyright(c) 2023-2025 Huawei Technologies Co., Ltd. + * Copyright(c) 2026 Unvertical * SPDX-License-Identifier: BSD-3-Clause */ @@ -14,8 +15,8 @@ struct cleaning_policy_ops { void (*setup)(ocf_cache_t cache); - int (*initialize)(ocf_cache_t cache, int kick_cleaner); - void (*populate)(ocf_cache_t cache, + int (*initialize)(ocf_cache_t cache); + void (*populate)(ocf_cache_t cache, bool reconstruct, ocf_cleaning_op_end_t cmpl, void *priv); void (*prepopulate)(ocf_cache_t cache, ocf_cleaning_op_end_t cmpl, void *priv); @@ -90,18 +91,18 @@ static inline void ocf_cleaning_setup(ocf_cache_t cache, ocf_cleaning_t policy) } static inline int ocf_cleaning_initialize(ocf_cache_t cache, - ocf_cleaning_t policy, int kick_cleaner) + ocf_cleaning_t policy) { ENV_BUG_ON(policy >= ocf_cleaning_max); if (unlikely(!cleaning_policy_ops[policy].initialize)) return 0; - return cleaning_policy_ops[policy].initialize(cache, kick_cleaner); + return cleaning_policy_ops[policy].initialize(cache); } static inline void ocf_cleaning_populate(ocf_cache_t cache, - ocf_cleaning_t policy, + ocf_cleaning_t policy, bool reconstruct, ocf_cleaning_op_end_t cmpl, void *priv) { ENV_BUG_ON(policy >= ocf_cleaning_max); @@ -111,7 +112,7 @@ static inline void ocf_cleaning_populate(ocf_cache_t cache, return; } - cleaning_policy_ops[policy].populate(cache, cmpl, priv); + cleaning_policy_ops[policy].populate(cache, reconstruct, cmpl, priv); } static inline void ocf_cleaning_prepopulate(ocf_cache_t cache, diff --git a/src/mngt/ocf_mngt_cache.c b/src/mngt/ocf_mngt_cache.c index 27e63f35..4ab7e0e2 100644 --- a/src/mngt/ocf_mngt_cache.c +++ b/src/mngt/ocf_mngt_cache.c @@ -1,6 +1,7 @@ /* * Copyright(c) 2012-2022 Intel Corporation * Copyright(c) 2023-2025 Huawei Technologies + * Copyright(c) 2026 Unvertical * SPDX-License-Identifier: BSD-3-Clause */ @@ -232,7 +233,7 @@ static ocf_error_t __init_cleaning_policy(ocf_cache_t cache) for (i = 0; i < ocf_cleaning_max; i++) ocf_cleaning_setup(cache, i); - result = ocf_cleaning_initialize(cache, cache->cleaner.policy, false); + result = ocf_cleaning_initialize(cache, cache->cleaner.policy); if (result) env_refcnt_deinit(&cache->cleaner.refcnt); @@ -736,6 +737,8 @@ static void _ocf_mngt_load_init_cleaning(ocf_pipeline_t pipeline, { struct ocf_cache_attach_context *context = priv; ocf_cache_t cache = context->cache; + bool reconstruct = context->metadata.shutdown_status == + ocf_metadata_dirty_shutdown; ocf_error_t result; result = env_refcnt_init(&cache->cleaner.refcnt, "cleaner", sizeof("cleaner")); @@ -744,20 +747,12 @@ static void _ocf_mngt_load_init_cleaning(ocf_pipeline_t pipeline, OCF_PL_FINISH_RET(pipeline, result); } - if (context->metadata.shutdown_status == ocf_metadata_clean_shutdown) { - /* Cleaning policy structures have been loaded so no need to populate - them for the second time */ - result = ocf_cleaning_initialize(cache, cache->cleaner.policy, true); - OCF_PL_NEXT_ON_SUCCESS_RET(pipeline, result); - - } else { - result = ocf_cleaning_initialize(cache, cache->cleaner.policy, false); - if (result) - OCF_PL_FINISH_RET(pipeline, result); + result = ocf_cleaning_initialize(cache, cache->cleaner.policy); + if (result) + OCF_PL_FINISH_RET(pipeline, result); - ocf_cleaning_populate(cache, cache->cleaner.policy, - _ocf_mngt_cleaning_populate_complete, context); - } + ocf_cleaning_populate(cache, cache->cleaner.policy, reconstruct, + _ocf_mngt_cleaning_populate_complete, context); } static void _ocf_mngt_init_metadata_complete(void *priv, int error) @@ -1469,7 +1464,7 @@ static void _ocf_mngt_attach_init_services(ocf_pipeline_t pipeline, OCF_PL_FINISH_RET(pipeline, result); } - ocf_cleaning_populate(cache, cache->cleaner.policy, + ocf_cleaning_populate(cache, cache->cleaner.policy, true, _ocf_mngt_cleaning_populate_init_complete, context); } diff --git a/src/mngt/ocf_mngt_flush.c b/src/mngt/ocf_mngt_flush.c index 84158d2b..dc9184c8 100644 --- a/src/mngt/ocf_mngt_flush.c +++ b/src/mngt/ocf_mngt_flush.c @@ -1,6 +1,7 @@ /* * Copyright(c) 2012-2022 Intel Corporation * Copyright(c) 2023-2025 Huawei Technologies Co., Ltd. + * Copyright(c) 2026 Unvertical * SPDX-License-Identifier: BSD-3-Clause */ @@ -1006,7 +1007,7 @@ static void _ocf_mngt_cache_cleaning_set_policy_initialize( ocf_cleaning_t new_policy = context->new_policy; int result; - result = ocf_cleaning_initialize(cache, new_policy, false); + result = ocf_cleaning_initialize(cache, new_policy); OCF_PL_NEXT_ON_SUCCESS_RET(context->pipeline, result); }