From 4be6761a18d59e2bf4aad737eae3b7a73d274433 Mon Sep 17 00:00:00 2001 From: Robert Baldyga Date: Fri, 4 Jan 2019 08:33:34 +0100 Subject: [PATCH] Core data object Signed-off-by: Robert Baldyga --- inc/ocf_core.h | 48 +- inc/ocf_data_obj.h | 221 ++++++--- src/engine/engine_inv.c | 2 +- src/eviction/lru.c | 2 +- src/metadata/metadata_hash.c | 6 +- src/metadata/metadata_io.c | 4 +- src/mngt/ocf_mngt_cache.c | 47 +- src/mngt/ocf_mngt_common.c | 4 +- src/mngt/ocf_mngt_core.c | 37 +- src/mngt/ocf_mngt_core_pool.c | 8 +- src/mngt/ocf_mngt_core_priv.h | 13 + src/mngt/ocf_mngt_flush.c | 2 +- src/ocf_cache.c | 4 +- src/ocf_core.c | 465 ++++++++++-------- src/ocf_core_priv.h | 19 +- src/ocf_ctx.c | 13 +- src/ocf_ctx_priv.h | 31 +- src/ocf_data_obj.c | 145 ++++-- src/ocf_data_obj_priv.h | 66 --- src/ocf_logger_priv.h | 2 + src/ocf_metadata.c | 2 +- src/ocf_stats.c | 2 +- .../_cache_mng_set_cache_mode_test.c | 169 ++++--- 23 files changed, 769 insertions(+), 543 deletions(-) create mode 100644 src/mngt/ocf_mngt_core_priv.h diff --git a/inc/ocf_core.h b/inc/ocf_core.h index 4c1f08e..3b82c92 100644 --- a/inc/ocf_core.h +++ b/inc/ocf_core.h @@ -34,6 +34,15 @@ ocf_cache_t ocf_core_get_cache(ocf_core_t core); */ ocf_data_obj_t ocf_core_get_data_object(ocf_core_t core); +/** + * @brief Obtain data object of the core + * + * @param[in] core Core object + * + * @retval Front data object + */ +ocf_data_obj_t ocf_core_get_front_data_object(ocf_core_t core); + /** * @brief Get UUID of data object associated with core * @@ -43,7 +52,7 @@ ocf_data_obj_t ocf_core_get_data_object(ocf_core_t core); */ static inline const struct ocf_data_obj_uuid *ocf_core_get_uuid(ocf_core_t core) { - return ocf_data_obj_get_uuid(ocf_core_get_data_object(core)); + return ocf_dobj_get_uuid(ocf_core_get_data_object(core)); } /** @@ -156,30 +165,29 @@ int ocf_core_get_user_metadata(ocf_core_t core, void *data, size_t size); * * @retval ocf_io object */ -struct ocf_io *ocf_new_io(ocf_core_t core); +static inline struct ocf_io *ocf_core_new_io(ocf_core_t core) +{ + ocf_data_obj_t obj = ocf_core_get_front_data_object(core); + + return ocf_dobj_new_io(obj); +} /** * @brief Submit ocf_io * * @param[in] io IO to be submitted * @param[in] mode Cache mode to be enforced - * - * @retval 0 Success - * @retval Non-zero Fail */ -int ocf_submit_io_mode(struct ocf_io *io, ocf_cache_mode_t cache_mode); +void ocf_core_submit_io_mode(struct ocf_io *io, ocf_cache_mode_t cache_mode); /** * @brief Submit ocf_io * * @param[in] io IO to be submitted - * - * @retval 0 Success - * @retval Non-zero Fail */ -static inline int ocf_submit_io(struct ocf_io *io) +static inline void ocf_core_submit_io(struct ocf_io *io) { - return ocf_submit_io_mode(io, ocf_cache_mode_none); + ocf_dobj_submit_io(io); } /** @@ -191,27 +199,27 @@ static inline int ocf_submit_io(struct ocf_io *io) * @retval 0 IO has been submitted successfully * @retval Non-zero Fast submit failed. Try to submit IO with ocf_submit_io() */ -int ocf_submit_io_fast(struct ocf_io *io); +int ocf_core_submit_io_fast(struct ocf_io *io); /** * @brief Submit ocf_io with flush command * * @param[in] io IO to be submitted - * - * @retval 0 Success - * @retval Non-zero Fail */ -int ocf_submit_flush(struct ocf_io *io); +static inline void ocf_core_submit_flush(struct ocf_io *io) +{ + ocf_dobj_submit_flush(io); +} /** * @brief Submit ocf_io with discard command * * @param[in] io IO to be submitted - * - * @retval 0 Success - * @retval Non-zero Fail */ -int ocf_submit_discard(struct ocf_io *io); +static inline void ocf_core_submit_discard(struct ocf_io *io) +{ + ocf_dobj_submit_discard(io); +} /** * @brief Core visitor function type which is called back when iterating over diff --git a/inc/ocf_data_obj.h b/inc/ocf_data_obj.h index d42397f..49cf72a 100644 --- a/inc/ocf_data_obj.h +++ b/inc/ocf_data_obj.h @@ -136,6 +136,9 @@ struct ocf_data_obj_properties { struct ocf_data_obj_ops ops; /*!< Data object operations */ + + struct ocf_io_ops io_ops; + /*!< IO operations */ }; static inline struct ocf_data_obj_uuid ocf_str_to_uuid(char *str) @@ -148,15 +151,6 @@ static inline struct ocf_data_obj_uuid ocf_str_to_uuid(char *str) return uuid; } -/** - * @brief Get data object type - * - * @param[in] obj Data object - * - * @return Data object type - */ -ocf_data_obj_type_t ocf_data_obj_get_type(ocf_data_obj_t obj); - /** * @brief Get private context of data object * @@ -174,76 +168,12 @@ void *ocf_data_obj_get_priv(ocf_data_obj_t obj); */ void ocf_data_obj_set_priv(ocf_data_obj_t obj, void *priv); -/** - * @brief Get data object UUID - * - * @param[in] obj Data object - * - * @return UUID of data object - */ -const struct ocf_data_obj_uuid *ocf_data_obj_get_uuid(ocf_data_obj_t obj); - -/** - * @brief Get data object length - * - * @param[in] obj Data object - * - * @return Length of data object in bytes - */ -uint64_t ocf_data_obj_get_length(ocf_data_obj_t obj); - -/** - * @brief Get cache handle for given data object - * - * @param obj data object handle - * - * @return Handle to cache for which data object belongs to - */ -ocf_cache_t ocf_data_obj_get_cache(ocf_data_obj_t obj); - -/** - * @brief Initialize data object - * - * @param[in] obj data object handle - * @param[in] type cache/core object type - * @param[in] uuid OCF data object UUID - * @param[in] uuid_copy crate copy of uuid data - * - * @return Zero when success, othewise en error - */ -int ocf_data_obj_init(ocf_data_obj_t obj, ocf_data_obj_type_t type, - struct ocf_data_obj_uuid *uuid, bool uuid_copy); - -/** - * @brief Deinitialize data object - * - * @param[in] obj data object handle - */ -void ocf_data_obj_deinit(ocf_data_obj_t obj); - -/** - * @brief Allocate and initialize data object - * - * @param[out] obj pointer to data object handle - * @param[in] type cache/core object type - * @param[in] uuid OCF data object UUID - * - * @return Zero when success, othewise en error - */ -int ocf_data_obj_create(ocf_data_obj_t *obj, ocf_data_obj_type_t type, - struct ocf_data_obj_uuid *uuid); - -/** - * @brief Deinitialize and free data object - * - * @param[in] obj data object handle - */ -void ocf_data_obj_destroy(ocf_data_obj_t obj); - /** * @brief Allocate new io from data object allocator * * @param[in] obj data object handle + * + * @return ocf_io object on success, otherwise NULL */ struct ocf_io *ocf_data_obj_new_io(ocf_data_obj_t obj); @@ -258,7 +188,148 @@ void ocf_data_obj_del_io(struct ocf_io* io); * @brief Return io context data * * @param[in] io ocf io handle + * + * @return ocf_io private context data */ void *ocf_data_obj_get_data_from_io(struct ocf_io* io); +/** + * @brief Initialize data object + * + * @param[in] obj data object handle + * @param[in] type cache/core object type + * @param[in] uuid OCF data object UUID + * @param[in] uuid_copy crate copy of uuid data + * + * @return Zero when success, othewise error + */ +int ocf_dobj_init(ocf_data_obj_t obj, ocf_data_obj_type_t type, + struct ocf_data_obj_uuid *uuid, bool uuid_copy); + +/** + * @brief Deinitialize data object + * + * @param[in] obj data object handle + */ +void ocf_dobj_deinit(ocf_data_obj_t obj); + +/** + * @brief Allocate and initialize data object + * + * @param[out] obj pointer to data object handle + * @param[in] type cache/core object type + * @param[in] uuid OCF data object UUID + * + * @return Zero when success, othewise en error + */ +int ocf_dobj_create(ocf_data_obj_t *obj, ocf_data_obj_type_t type, + struct ocf_data_obj_uuid *uuid); + +/** + * @brief Deinitialize and free data object + * + * @param[in] obj data object handle + */ +void ocf_data_obj_destroy(ocf_data_obj_t obj); + +/** + * @brief Get data object type + * + * @param[in] obj Data object + * + * @return Data object type + */ +ocf_data_obj_type_t ocf_dobj_get_type(ocf_data_obj_t obj); + +/** + * @brief Get data object UUID + * + * @param[in] obj Data object + * + * @return UUID of data object + */ +const struct ocf_data_obj_uuid *ocf_dobj_get_uuid(ocf_data_obj_t obj); + +/** + * @brief Get cache handle for given data object + * + * @param obj data object handle + * + * @return Handle to cache for which data object belongs to + */ +ocf_cache_t ocf_dobj_get_cache(ocf_data_obj_t obj); + +/** + * @brief Check if data object supports atomic mode + * + * @param[in] obj Data object + * + * @return Non-zero value if data object is atomic, otherwise zero + */ +int ocf_dobj_is_atomic(ocf_data_obj_t obj); + +/** + * @brief Allocate new io + * + * @param[in] io IO + * + * @return ocf_io on success atomic, otherwise NULL + */ +struct ocf_io *ocf_dobj_new_io(ocf_data_obj_t obj); + +/** + * @brief Submit io to data object + * + * @param[in] io IO + */ +void ocf_dobj_submit_io(struct ocf_io *io); + +/** + * @brief Submit flush to data object + * + * @param[in] io IO + */ +void ocf_dobj_submit_flush(struct ocf_io *io); + +/** + * @brief Submit discard to data object + * + * @param[in] io IO + */ +void ocf_dobj_submit_discard(struct ocf_io *io); + +/** + * @brief Open data object + * + * @param[in] obj Data object + * + * @return Zero when success, othewise en error + */ +int ocf_dobj_open(ocf_data_obj_t obj); + +/** + * @brief Get data object max io size + * + * @param[in] obj Data object + */ +void ocf_dobj_close(ocf_data_obj_t obj); + +/** + * @brief Get data object max io size + * + * @param[in] obj Data object + * + * @return Data object max io size in bytes + */ +unsigned int ocf_dobj_get_max_io_size(ocf_data_obj_t obj); + +/** + * @brief Get data object length + * + * @param[in] obj Data object + * + * @return Length of data object in bytes + */ +uint64_t ocf_dobj_get_length(ocf_data_obj_t obj); + #endif /* __OCF_DATA_OBJ_H__ */ diff --git a/src/engine/engine_inv.c b/src/engine/engine_inv.c index de1647e..26db3e6 100644 --- a/src/engine/engine_inv.c +++ b/src/engine/engine_inv.c @@ -50,7 +50,7 @@ static int _ocf_invalidate_do(struct ocf_request *req) env_atomic_inc(&req->req_remaining); - if (ocf_data_obj_is_atomic(&cache->device->obj) && + if (ocf_dobj_is_atomic(&cache->device->obj) && req->info.flush_metadata) { /* Metadata flush IO */ ocf_metadata_flush_do_asynch(cache, req, _ocf_invalidate_req); diff --git a/src/eviction/lru.c b/src/eviction/lru.c index 69b4dc8..441cbd4 100644 --- a/src/eviction/lru.c +++ b/src/eviction/lru.c @@ -410,7 +410,7 @@ uint32_t evp_lru_req_clines(struct ocf_cache *cache, uint32_t io_queue, ENV_BUG_ON(metadata_test_dirty(cache, curr_cline)); - if (ocf_data_obj_is_atomic(&cache->device->obj)) { + if (ocf_dobj_is_atomic(&cache->device->obj)) { /* atomic cache, we have to trim cache lines before * eviction */ diff --git a/src/metadata/metadata_hash.c b/src/metadata/metadata_hash.c index 5fcf51e..e1746e0 100644 --- a/src/metadata/metadata_hash.c +++ b/src/metadata/metadata_hash.c @@ -577,7 +577,7 @@ static int ocf_metadata_hash_init_variable_size(struct ocf_cache *cache, if (cache->device->init_mode == ocf_init_mode_metadata_volatile) { raw->raw_type = metadata_raw_type_volatile; } else if (i == metadata_segment_collision && - ocf_data_obj_is_atomic(&cache->device->obj)) { + ocf_dobj_is_atomic(&cache->device->obj)) { raw->raw_type = metadata_raw_type_atomic; } @@ -975,7 +975,7 @@ static int ocf_metadata_hash_load_superblock(struct ocf_cache *cache) uuid.size = muuid->size; /* Initialize core data object */ - ocf_data_obj_init(&cache->core[i].obj, + ocf_dobj_init(&cache->core[i].obj, ocf_ctx_get_data_obj_type(cache->owner, cache->core_conf_meta[i].type), &uuid, false); @@ -1544,7 +1544,7 @@ static int ocf_metadata_hash_load_recovery(struct ocf_cache *cache) OCF_DEBUG_TRACE(cache); - if (ocf_data_obj_is_atomic(&cache->device->obj)) { + if (ocf_dobj_is_atomic(&cache->device->obj)) { result = _ocf_metadata_hash_load_recovery_atomic(cache); rebuild_dirty_only = false; } else { diff --git a/src/metadata/metadata_io.c b/src/metadata/metadata_io.c index 228fec3..c8f8809 100644 --- a/src/metadata/metadata_io.c +++ b/src/metadata/metadata_io.c @@ -46,7 +46,7 @@ static struct ocf_io_if meta_restart_if = { */ static uint32_t metadata_io_max_page(struct ocf_cache *cache) { - return ocf_data_obj_get_max_io_size(&cache->device->obj) / + return ocf_dobj_get_max_io_size(&cache->device->obj) / BYTES_TO_SECTORS(PAGE_SIZE); } @@ -57,7 +57,7 @@ static void metadata_io_read_i_atomic_end(struct ocf_io *io, int error) { struct metadata_io_request_atomic *meta_atom_req = io->priv1; - OCF_DEBUG_TRACE(ocf_data_obj_get_cache(io->obj)); + OCF_DEBUG_TRACE(ocf_dobj_get_cache(io->obj)); meta_atom_req->error |= error; env_completion_complete(&meta_atom_req->complete); diff --git a/src/mngt/ocf_mngt_cache.c b/src/mngt/ocf_mngt_cache.c index ac231c1..cd902f0 100644 --- a/src/mngt/ocf_mngt_cache.c +++ b/src/mngt/ocf_mngt_cache.c @@ -5,6 +5,7 @@ #include "ocf/ocf.h" #include "ocf_mngt_common.h" +#include "ocf_mngt_core_priv.h" #include "../ocf_priv.h" #include "../ocf_core_priv.h" #include "../ocf_queue_priv.h" @@ -364,7 +365,7 @@ static void _ocf_mngt_close_all_uninitialized_cores( continue; obj = &(cache->core[i].obj); - ocf_data_obj_close(obj); + ocf_dobj_close(obj); --j; @@ -418,15 +419,15 @@ static int _ocf_mngt_init_instance_add_cores( continue; if (!cache->core[i].obj.type) - goto _cache_mng_init_instance_add_cores_ERROR; + goto err; ret = snprintf(core_name, sizeof(core_name), "core%d", i); if (ret < 0 || ret >= sizeof(core_name)) - goto _cache_mng_init_instance_add_cores_ERROR; + goto err; ret = ocf_core_set_name(core, core_name, sizeof(core_name)); if (ret) - goto _cache_mng_init_instance_add_cores_ERROR; + goto err; tobj = ocf_mngt_core_pool_lookup(ocf_cache_get_ctx(cache), &core->obj.uuid, core->obj.type); @@ -444,7 +445,7 @@ static int _ocf_mngt_init_instance_add_cores( ocf_cache_log(cache, log_info, "Attached core %u from pool\n", i); } else { - ret = ocf_data_obj_open(&core->obj); + ret = ocf_dobj_open(&core->obj); if (ret == -OCF_ERR_NOT_OPEN_EXC) { ocf_cache_log(cache, log_warn, "Cannot open core %u. " @@ -461,10 +462,13 @@ static int _ocf_mngt_init_instance_add_cores( cache->conf_meta->core_count++; core->obj.cache = cache; + if (ocf_mngt_core_init_front_dobj(core)) + goto err; + core->counters = env_zalloc(sizeof(*core->counters), ENV_MEM_NORMAL); if (!core->counters) - goto _cache_mng_init_instance_add_cores_ERROR; + goto err; if (!core->opened) { env_bit_set(ocf_cache_state_incomplete, @@ -477,7 +481,7 @@ static int _ocf_mngt_init_instance_add_cores( } hd_lines = ocf_bytes_2_lines(cache, - ocf_data_obj_get_length( + ocf_dobj_get_length( &cache->core[i].obj)); if (hd_lines) { @@ -489,7 +493,7 @@ static int _ocf_mngt_init_instance_add_cores( attach_params->flags.cores_opened = true; return 0; -_cache_mng_init_instance_add_cores_ERROR: +err: _ocf_mngt_close_all_uninitialized_cores(cache); return -OCF_ERR_START_CACHE_FAIL; @@ -633,12 +637,12 @@ static int _ocf_mngt_attach_cache_device(struct ocf_cache *cache, attach_params->device_type); if (!cache->device->obj.type) { ret = -OCF_ERR_INVAL_DATA_OBJ_TYPE; - goto _cache_mng_attach_cache_device_ERROR; + goto err; } if (ocf_uuid_cache_set(cache, &attach_params->uuid)) { ret = -OCF_ERR_INVAL; - goto _cache_mng_attach_cache_device_ERROR; + goto err; } attach_params->flags.uuid_alloc = true; @@ -646,21 +650,21 @@ static int _ocf_mngt_attach_cache_device(struct ocf_cache *cache, * Open cache device, It has to be done first because metadata service * need to know size of cache device. */ - ret = ocf_data_obj_open(&cache->device->obj); + ret = ocf_dobj_open(&cache->device->obj); if (ret) { ocf_cache_log(cache, log_err, "ERROR: Cache not available\n"); - goto _cache_mng_attach_cache_device_ERROR; + goto err; } attach_params->flags.device_opened = true; - attach_params->device_size = ocf_data_obj_get_length(&cache->device->obj); + attach_params->device_size = ocf_dobj_get_length(&cache->device->obj); /* Check minimum size of cache device */ if (attach_params->device_size < OCF_CACHE_SIZE_MIN) { ocf_cache_log(cache, log_err, "ERROR: Cache cache size must " "be at least %llu [MiB]\n", OCF_CACHE_SIZE_MIN / MiB); ret = -OCF_ERR_START_CACHE_FAIL; - goto _cache_mng_attach_cache_device_ERROR; + goto err; } if (cache->metadata.is_volatile) { @@ -672,7 +676,7 @@ static int _ocf_mngt_attach_cache_device(struct ocf_cache *cache, return 0; -_cache_mng_attach_cache_device_ERROR: +err: return ret; } @@ -829,7 +833,7 @@ static int _ocf_mngt_init_test_device(struct ocf_cache *cache) goto end; } - if (!ocf_data_obj_is_atomic(&cache->device->obj)) + if (!ocf_dobj_is_atomic(&cache->device->obj)) goto end; /* @@ -1089,7 +1093,7 @@ static void _ocf_mngt_attach_handle_error( ocf_metadata_deinit_variable_size(cache); if (attach_params->flags.device_opened) - ocf_data_obj_close(&cache->device->obj); + ocf_dobj_close(&cache->device->obj); if (attach_params->flags.concurrency_inited) ocf_concurrency_deinit(cache); @@ -1105,11 +1109,11 @@ static int _ocf_mngt_cache_discard_after_metadata(struct ocf_cache *cache) { int result; uint64_t addr = cache->device->metadata_offset; - uint64_t length = ocf_data_obj_get_length( + uint64_t length = ocf_dobj_get_length( &cache->device->obj) - addr; bool discard = cache->device->obj.features.discard_zeroes; - if (!discard && ocf_data_obj_is_atomic(&cache->device->obj)) { + if (!discard && ocf_dobj_is_atomic(&cache->device->obj)) { /* discard does not zero data - need to explicitly write zeroes */ result = ocf_submit_write_zeroes_wait( @@ -1129,7 +1133,7 @@ static int _ocf_mngt_cache_discard_after_metadata(struct ocf_cache *cache) discard ? "Discarding whole cache device" : "Overwriting cache with zeroes"); - if (ocf_data_obj_is_atomic(&cache->device->obj)) { + if (ocf_dobj_is_atomic(&cache->device->obj)) { ocf_cache_log(cache, log_err, "This step is required" " for atomic mode!\n"); } else { @@ -1351,7 +1355,6 @@ static int _ocf_mngt_cache_attach(ocf_cache_t cache, break; case ocf_init_mode_load: result = _ocf_mngt_init_instance_load(&attach_params); - break; default: result = OCF_ERR_INVAL; @@ -1564,7 +1567,7 @@ static int _ocf_mngt_cache_unplug(ocf_cache_t cache, bool stop) result = ocf_metadata_flush_all(cache); } - ocf_data_obj_close(&cache->device->obj); + ocf_dobj_close(&cache->device->obj); ocf_metadata_deinit_variable_size(cache); ocf_concurrency_deinit(cache); diff --git a/src/mngt/ocf_mngt_common.c b/src/mngt/ocf_mngt_common.c index 089c689..216f535 100644 --- a/src/mngt/ocf_mngt_common.c +++ b/src/mngt/ocf_mngt_common.c @@ -22,7 +22,7 @@ int cache_mng_core_close(ocf_cache_t cache, ocf_core_id_t core_id) if (!cache->core[core_id].opened) return -OCF_ERR_CORE_IN_INACTIVE_STATE; - ocf_data_obj_close(&cache->core[core_id].obj); + ocf_dobj_close(&cache->core[core_id].obj); cache->core[core_id].opened = false; return 0; @@ -57,7 +57,7 @@ void cache_mng_core_deinit_attached_meta(struct ocf_cache *cache, int core_id) core = &cache->core[core_id].obj; - core_size = ocf_data_obj_get_length(core); + core_size = ocf_dobj_get_length(core); if (!core_size) core_size = ~0ULL; diff --git a/src/mngt/ocf_mngt_core.c b/src/mngt/ocf_mngt_core.c index d2f0b1e..8174628 100644 --- a/src/mngt/ocf_mngt_core.c +++ b/src/mngt/ocf_mngt_core.c @@ -5,6 +5,7 @@ #include "ocf/ocf.h" #include "ocf_mngt_common.h" +#include "ocf_mngt_core_priv.h" #include "../ocf_priv.h" #include "../metadata/metadata.h" #include "../engine/cache_engine.h" @@ -36,11 +37,11 @@ static int _ocf_mngt_cache_try_add_core(ocf_cache_t cache, ocf_core_t *core, goto error_out; } - result = ocf_data_obj_open(obj); + result = ocf_dobj_open(obj); if (result) goto error_out; - if (!ocf_data_obj_get_length(obj)) { + if (!ocf_dobj_get_length(obj)) { result = -OCF_ERR_CORE_NOT_AVAIL; goto error_after_open; } @@ -54,7 +55,7 @@ static int _ocf_mngt_cache_try_add_core(ocf_cache_t cache, ocf_core_t *core, return 0; error_after_open: - ocf_data_obj_close(obj); + ocf_dobj_close(obj); error_out: *core = NULL; return result; @@ -92,11 +93,11 @@ static int _ocf_mngt_cache_add_core(ocf_cache_t cache, ocf_core_t *core, goto error_out; } - result = ocf_data_obj_open(obj); + result = ocf_dobj_open(obj); if (result) goto error_out; - length = ocf_data_obj_get_length(obj); + length = ocf_dobj_get_length(obj); if (!length) { result = -OCF_ERR_CORE_NOT_AVAIL; goto error_after_open; @@ -181,7 +182,7 @@ error_after_clean_pol: cleaning_policy_ops[clean_type].remove_core(cache, cfg->core_id); error_after_open: - ocf_data_obj_close(obj); + ocf_dobj_close(obj); error_out: ocf_uuid_core_clear(cache, tmp_core); *core = NULL; @@ -332,6 +333,22 @@ static int _ocf_mngt_find_core_id(ocf_cache_t cache, return result; } +int ocf_mngt_core_init_front_dobj(ocf_core_t core) +{ + ocf_cache_t cache = ocf_core_get_cache(core); + ocf_data_obj_t front_obj; + + front_obj = &core->front_obj; + front_obj->uuid.data = core; + front_obj->uuid.size = sizeof(core); + + front_obj->type = ocf_ctx_get_data_obj_type(cache->owner, 0); + if (!front_obj->type) + return -OCF_ERR_INVAL; + + return ocf_dobj_open(front_obj); +} + int ocf_mngt_cache_add_core_nolock(ocf_cache_t cache, ocf_core_t *core, struct ocf_mngt_core_config *cfg) { @@ -369,6 +386,12 @@ int ocf_mngt_cache_add_core_nolock(ocf_cache_t cache, ocf_core_t *core, else result = _ocf_mngt_cache_add_core(cache, core, cfg); + if (result) + goto out; + + result = ocf_mngt_core_init_front_dobj(*core); + +out: if (!result) { ocf_core_log(*core, log_info, "Successfully added\n"); } else { @@ -417,6 +440,8 @@ static int _ocf_mngt_cache_remove_core(ocf_core_t core, bool detach) return status; } + ocf_dobj_close(&core->front_obj); + /* Deinit everything*/ if (ocf_cache_is_device_attached(cache)) { cache_mng_core_deinit_attached_meta(cache, core_id); diff --git a/src/mngt/ocf_mngt_core_pool.c b/src/mngt/ocf_mngt_core_pool.c index 7ac4ca8..7671ee0 100644 --- a/src/mngt/ocf_mngt_core_pool.c +++ b/src/mngt/ocf_mngt_core_pool.c @@ -38,9 +38,9 @@ int ocf_mngt_core_pool_add(ocf_ctx_t ctx, ocf_uuid_t uuid, uint8_t type) if (result) return result; - result = ocf_data_obj_open(obj); + result = ocf_dobj_open(obj); if (result) { - ocf_data_obj_deinit(obj); + ocf_dobj_deinit(obj); return result; } @@ -99,14 +99,14 @@ void ocf_mngt_core_pool_remove(ocf_ctx_t ctx, ocf_data_obj_t obj) ctx->core_pool.core_pool_count--; list_del(&obj->core_pool_item); env_mutex_unlock(&ctx->lock); - ocf_data_obj_deinit(obj); + ocf_dobj_deinit(obj); } void ocf_mngt_core_pool_close_and_remove(ocf_ctx_t ctx, ocf_data_obj_t obj) { OCF_CHECK_NULL(ctx); OCF_CHECK_NULL(obj); - ocf_data_obj_close(obj); + ocf_dobj_close(obj); ocf_mngt_core_pool_remove(ctx, obj); } diff --git a/src/mngt/ocf_mngt_core_priv.h b/src/mngt/ocf_mngt_core_priv.h new file mode 100644 index 0000000..b228e82 --- /dev/null +++ b/src/mngt/ocf_mngt_core_priv.h @@ -0,0 +1,13 @@ +/* + * Copyright(c) 2012-2018 Intel Corporation + * SPDX-License-Identifier: BSD-3-Clause-Clear + */ + +#ifndef __OCF_CORE_MNGT_PRIV_H__ +#define __OCF_CORE_MNGT_PRIV_H__ + +#include "../ocf_core_priv.h" + +int ocf_mngt_core_init_front_dobj(ocf_core_t core); + +#endif /* __OCF_CORE_MNGT_PRIV_H__ */ diff --git a/src/mngt/ocf_mngt_flush.c b/src/mngt/ocf_mngt_flush.c index 5dd73f4..a6163c4 100644 --- a/src/mngt/ocf_mngt_flush.c +++ b/src/mngt/ocf_mngt_flush.c @@ -598,7 +598,7 @@ int ocf_mngt_core_purge(ocf_cache_t cache, ocf_core_id_t core_id, bool interrupt return -OCF_ERR_CORE_NOT_AVAIL; } - core_size = ocf_data_obj_get_length(&cache->core[core_id].obj); + core_size = ocf_dobj_get_length(&cache->core[core_id].obj); core_size = core_size ?: ~0ULL; _ocf_mngt_begin_flush(cache); diff --git a/src/ocf_cache.c b/src/ocf_cache.c index 92a46e8..a56cc3c 100644 --- a/src/ocf_cache.c +++ b/src/ocf_cache.c @@ -182,7 +182,7 @@ const struct ocf_data_obj_uuid *ocf_cache_get_uuid(ocf_cache_t cache) if (!ocf_cache_is_device_attached(cache)) return NULL; - return ocf_data_obj_get_uuid(ocf_cache_get_data_object(cache)); + return ocf_dobj_get_uuid(ocf_cache_get_data_object(cache)); } uint8_t ocf_cache_get_type_id(ocf_cache_t cache) @@ -191,7 +191,7 @@ uint8_t ocf_cache_get_type_id(ocf_cache_t cache) return 0xff; return ocf_ctx_get_data_obj_type_id(ocf_cache_get_ctx(cache), - ocf_data_obj_get_type(ocf_cache_get_data_object(cache))); + ocf_dobj_get_type(ocf_cache_get_data_object(cache))); } ocf_cache_line_size_t ocf_cache_get_line_size(ocf_cache_t cache) diff --git a/src/ocf_core.c b/src/ocf_core.c index b3d04da..eeadd2c 100644 --- a/src/ocf_core.c +++ b/src/ocf_core.c @@ -26,6 +26,12 @@ ocf_data_obj_t ocf_core_get_data_object(ocf_core_t core) return &core->obj; } +ocf_data_obj_t ocf_core_get_front_data_object(ocf_core_t core) +{ + OCF_CHECK_NULL(core); + return &core->front_obj; +} + ocf_core_id_t ocf_core_get_id(ocf_core_t core) { struct ocf_cache *cache; @@ -122,100 +128,6 @@ int ocf_core_set_uuid(ocf_core_t core, const struct ocf_data_obj_uuid *uuid) return result; } -static inline void inc_dirty_req_counter(struct ocf_core_io *core_io, - ocf_cache_t cache) -{ - core_io->dirty = 1; - env_atomic_inc(&cache->pending_dirty_requests); -} - -static inline void dec_counter_if_req_was_dirty(struct ocf_core_io *core_io, - ocf_cache_t cache) -{ - int pending_dirty_req_count; - - if (!core_io->dirty) - return; - - pending_dirty_req_count = - env_atomic_dec_return(&cache->pending_dirty_requests); - - ENV_BUG_ON(pending_dirty_req_count < 0); - - core_io->dirty = 0; - - if (!pending_dirty_req_count) - env_waitqueue_wake_up(&cache->pending_dirty_wq); -} - -/* *** CORE IO *** */ - -static inline struct ocf_core_io *ocf_io_to_core_io(struct ocf_io *io) -{ - return container_of(io, struct ocf_core_io, base); -} - -static void ocf_core_io_get(struct ocf_io *io) -{ - struct ocf_core_io *core_io; - int value; - - OCF_CHECK_NULL(io); - - core_io = ocf_io_to_core_io(io); - value = env_atomic_inc_return(&core_io->ref_counter); - - ENV_BUG_ON(value < 1); -} - -static void ocf_core_io_put(struct ocf_io *io) -{ - struct ocf_core_io *core_io; - ocf_cache_t cache; - int value; - - OCF_CHECK_NULL(io); - - core_io = ocf_io_to_core_io(io); - value = env_atomic_dec_return(&core_io->ref_counter); - - ENV_BUG_ON(value < 0); - - if (value) - return; - - cache = ocf_core_get_cache(core_io->core); - - core_io->data = NULL; - env_allocator_del(cache->owner->resources.core_io_allocator, core_io); -} - -static int ocf_core_io_set_data(struct ocf_io *io, - ctx_data_t *data, uint32_t offset) -{ - struct ocf_core_io *core_io; - - OCF_CHECK_NULL(io); - - if (!data || offset) - return -EINVAL; - - core_io = ocf_io_to_core_io(io); - core_io->data = data; - - return 0; -} - -static ctx_data_t *ocf_core_io_get_data(struct ocf_io *io) -{ - struct ocf_core_io *core_io; - - OCF_CHECK_NULL(io); - - core_io = ocf_io_to_core_io(io); - return core_io->data; -} - uint32_t ocf_core_get_seq_cutoff_threshold(ocf_core_t core) { uint32_t core_id = ocf_core_get_id(core); @@ -232,13 +144,6 @@ ocf_seq_cutoff_policy ocf_core_get_seq_cutoff_policy(ocf_core_t core) return cache->core_conf_meta[core_id].seq_cutoff_policy; } -const struct ocf_io_ops ocf_core_io_ops = { - .set_data = ocf_core_io_set_data, - .get_data = ocf_core_io_get_data, - .get = ocf_core_io_get, - .put = ocf_core_io_put, -}; - int ocf_core_set_user_metadata_raw(ocf_core_t core, void *data, size_t size) { ocf_cache_t cache = ocf_core_get_cache(core); @@ -293,12 +198,74 @@ int ocf_core_get_user_metadata(ocf_core_t core, void *data, size_t size) return 0; } -/* *** OCF API *** */ - -static inline int ocf_validate_io(struct ocf_core_io *core_io) +int ocf_core_visit(ocf_cache_t cache, ocf_core_visitor_t visitor, void *cntx, + bool only_opened) { - ocf_cache_t cache = ocf_core_get_cache(core_io->core); - struct ocf_io *io = &core_io->base; + ocf_core_id_t id; + int result = 0; + + OCF_CHECK_NULL(cache); + + if (!visitor) + return -OCF_ERR_INVAL; + + for (id = 0; id < OCF_CORE_MAX; id++) { + if (!env_bit_test(id, cache->conf_meta->valid_object_bitmap)) + continue; + + if (only_opened && !cache->core[id].opened) + continue; + + result = visitor(&cache->core[id], cntx); + if (result) + break; + } + + return result; +} + +/* *** HELPER FUNCTIONS *** */ + +static inline struct ocf_core_io *ocf_io_to_core_io(struct ocf_io *io) +{ + return ocf_data_obj_get_data_from_io(io); +} + +static inline ocf_core_t ocf_data_obj_to_core(ocf_data_obj_t obj) +{ + return ocf_data_obj_get_priv(obj); +} + +static inline void inc_dirty_req_counter(struct ocf_core_io *core_io, + ocf_cache_t cache) +{ + core_io->dirty = 1; + env_atomic_inc(&cache->pending_dirty_requests); +} + +static inline void dec_counter_if_req_was_dirty(struct ocf_core_io *core_io, + ocf_cache_t cache) +{ + int pending_dirty_req_count; + + if (!core_io->dirty) + return; + + pending_dirty_req_count = + env_atomic_dec_return(&cache->pending_dirty_requests); + + ENV_BUG_ON(pending_dirty_req_count < 0); + + core_io->dirty = 0; + + if (!pending_dirty_req_count) + env_waitqueue_wake_up(&cache->pending_dirty_wq); +} + +static inline int ocf_core_validate_io(struct ocf_io *io) +{ + ocf_core_t core = ocf_data_obj_to_core(io->obj); + ocf_cache_t cache = ocf_core_get_cache(core); if (!io->obj) return -EINVAL; @@ -306,10 +273,10 @@ static inline int ocf_validate_io(struct ocf_core_io *core_io) if (!io->ops) return -EINVAL; - if (io->addr >= ocf_data_obj_get_length(io->obj)) + if (io->addr >= ocf_dobj_get_length(io->obj)) return -EINVAL; - if (io->addr + io->bytes > ocf_data_obj_get_length(io->obj)) + if (io->addr + io->bytes > ocf_dobj_get_length(io->obj)) return -EINVAL; if (io->class >= OCF_IO_CLASS_MAX) @@ -335,36 +302,11 @@ static void ocf_req_complete(struct ocf_request *req, int error) dec_counter_if_req_was_dirty(ocf_io_to_core_io(req->io), req->cache); /* Invalidate OCF IO, it is not valid after completion */ - ocf_core_io_put(req->io); + ocf_io_put(req->io); req->io = NULL; } -struct ocf_io *ocf_new_io(ocf_core_t core) -{ - ocf_cache_t cache; - struct ocf_core_io *core_io; - - OCF_CHECK_NULL(core); - - cache = ocf_core_get_cache(core); - if (!cache) - return NULL; - - core_io = env_allocator_new( - cache->owner->resources.core_io_allocator); - if (!core_io) - return NULL; - - core_io->base.obj = ocf_core_get_data_object(core); - core_io->base.ops = &ocf_core_io_ops; - core_io->core = core; - - env_atomic_set(&core_io->ref_counter, 1); - - return &core_io->base; -} - -int ocf_submit_io_mode(struct ocf_io *io, ocf_cache_mode_t cache_mode) +void ocf_core_submit_io_mode(struct ocf_io *io, ocf_cache_mode_t cache_mode) { struct ocf_core_io *core_io; ocf_req_cache_mode_t req_cache_mode; @@ -372,22 +314,23 @@ int ocf_submit_io_mode(struct ocf_io *io, ocf_cache_mode_t cache_mode) ocf_cache_t cache; int ret; - if (!io) - return -EINVAL; + OCF_CHECK_NULL(io); + + ret = ocf_core_validate_io(io); + if (ret < 0) { + io->end(io, -EINVAL); + return; + } core_io = ocf_io_to_core_io(io); - ret = ocf_validate_io(core_io); - if (ret < 0) - return ret; - - core = core_io->core; + core = ocf_data_obj_to_core(io->obj); cache = ocf_core_get_cache(core); if (unlikely(!env_bit_test(ocf_cache_state_running, &cache->cache_state))) { ocf_io_end(io, -EIO); - return 0; + return; } /* TODO: instead of casting ocf_cache_mode_t to ocf_req_cache_mode_t @@ -415,7 +358,7 @@ int ocf_submit_io_mode(struct ocf_io *io, ocf_cache_mode_t cache_mode) if (!core_io->req) { dec_counter_if_req_was_dirty(core_io, cache); io->end(io, -ENOMEM); - return 0; + return; } if (core_io->req->d2c) @@ -431,18 +374,16 @@ int ocf_submit_io_mode(struct ocf_io *io, ocf_cache_mode_t cache_mode) ocf_core_update_stats(core, io); - ocf_core_io_get(io); + ocf_io_get(io); ret = ocf_engine_hndl_req(core_io->req, req_cache_mode); if (ret) { dec_counter_if_req_was_dirty(core_io, cache); ocf_req_put(core_io->req); io->end(io, ret); } - - return 0; } -int ocf_submit_io_fast(struct ocf_io *io) +int ocf_core_submit_io_fast(struct ocf_io *io) { struct ocf_core_io *core_io; ocf_req_cache_mode_t req_cache_mode; @@ -452,16 +393,15 @@ int ocf_submit_io_fast(struct ocf_io *io) int fast; int ret; - if (!io) - return -EINVAL; + OCF_CHECK_NULL(io); - core_io = ocf_io_to_core_io(io); - - ret = ocf_validate_io(core_io); + ret = ocf_core_validate_io(io); if (ret < 0) return ret; - core = core_io->core; + core_io = ocf_io_to_core_io(io); + + core = ocf_data_obj_to_core(io->obj); cache = ocf_core_get_cache(core); if (unlikely(!env_bit_test(ocf_cache_state_running, @@ -523,7 +463,7 @@ int ocf_submit_io_fast(struct ocf_io *io) req->io = io; ocf_core_update_stats(core, io); - ocf_core_io_get(io); + ocf_io_get(io); fast = ocf_engine_hndl_fast_req(req, req_cache_mode); if (fast != OCF_FAST_PATH_NO) { @@ -533,41 +473,47 @@ int ocf_submit_io_fast(struct ocf_io *io) dec_counter_if_req_was_dirty(core_io, cache); - ocf_core_io_put(io); + ocf_io_put(io); ocf_req_put(req); return -EIO; } -int ocf_submit_flush(struct ocf_io *io) +static void ocf_core_data_obj_submit_io(struct ocf_io *io) +{ + ocf_core_submit_io_mode(io, ocf_cache_mode_none); +} + +static void ocf_core_data_obj_submit_flush(struct ocf_io *io) { struct ocf_core_io *core_io; ocf_core_t core; ocf_cache_t cache; int ret; - if (!io) - return -EINVAL; + OCF_CHECK_NULL(io); + + ret = ocf_core_validate_io(io); + if (ret < 0) { + ocf_io_end(io, -EINVAL); + return; + } core_io = ocf_io_to_core_io(io); - ret = ocf_validate_io(core_io); - if (ret < 0) - return ret; - - core = core_io->core; + core = ocf_data_obj_to_core(io->obj); cache = ocf_core_get_cache(core); if (unlikely(!env_bit_test(ocf_cache_state_running, &cache->cache_state))) { ocf_io_end(io, -EIO); - return 0; + return; } core_io->req = ocf_req_new(cache, ocf_core_get_id(core), io->addr, io->bytes, io->dir); if (!core_io->req) { ocf_io_end(io, -ENOMEM); - return 0; + return; } core_io->req->io_queue = io->io_queue; @@ -575,42 +521,41 @@ int ocf_submit_flush(struct ocf_io *io) core_io->req->io = io; core_io->req->data = core_io->data; - ocf_core_io_get(io); + ocf_io_get(io); ocf_engine_hndl_ops_req(core_io->req); - - return 0; } -int ocf_submit_discard(struct ocf_io *io) +static void ocf_core_data_obj_submit_discard(struct ocf_io *io) { struct ocf_core_io *core_io; ocf_core_t core; ocf_cache_t cache; int ret; - if (!io) - return -EINVAL; + OCF_CHECK_NULL(io); + + ret = ocf_core_validate_io(io); + if (ret < 0) { + ocf_io_end(io, -EINVAL); + return; + } core_io = ocf_io_to_core_io(io); - ret = ocf_validate_io(core_io); - if (ret < 0) - return ret; - - core = core_io->core; + core = ocf_data_obj_to_core(io->obj); cache = ocf_core_get_cache(core); if (unlikely(!env_bit_test(ocf_cache_state_running, &cache->cache_state))) { ocf_io_end(io, -EIO); - return 0; + return; } core_io->req = ocf_req_new_discard(cache, ocf_core_get_id(core), io->addr, io->bytes, OCF_WRITE); if (!core_io->req) { ocf_io_end(io, -ENOMEM); - return 0; + return; } core_io->req->io_queue = io->io_queue; @@ -618,35 +563,149 @@ int ocf_submit_discard(struct ocf_io *io) core_io->req->io = io; core_io->req->data = core_io->data; - ocf_core_io_get(io); + ocf_io_get(io); ocf_engine_hndl_discard_req(core_io->req); +} + +/* *** DATA OBJECT OPS *** */ + +struct ocf_io *ocf_core_data_obj_new_io(ocf_data_obj_t obj) +{ + struct ocf_core_io *core_io; + struct ocf_io *io; + + io = ocf_data_obj_new_io(obj); + if (!io) + return NULL; + + core_io = ocf_data_obj_get_data_from_io(io); + + env_atomic_set(&core_io->ref_counter, 1); + + return io; +} + +static int ocf_core_data_obj_open(ocf_data_obj_t obj) +{ + const struct ocf_data_obj_uuid *uuid = ocf_dobj_get_uuid(obj); + ocf_core_t core = (ocf_core_t)uuid->data; + + ocf_data_obj_set_priv(obj, core); return 0; } -int ocf_core_visit(ocf_cache_t cache, ocf_core_visitor_t visitor, void *cntx, - bool only_opened) +static void ocf_core_data_obj_close(ocf_data_obj_t obj) { - ocf_core_id_t id; - int result = 0; - - OCF_CHECK_NULL(cache); - - if (!visitor) - return -OCF_ERR_INVAL; - - for (id = 0; id < OCF_CORE_MAX; id++) { - if (!env_bit_test(id, cache->conf_meta->valid_object_bitmap)) - continue; - - if (only_opened && !cache->core[id].opened) - continue; - - result = visitor(&cache->core[id], cntx); - if (result) - break; - } - - return result; + ocf_data_obj_set_priv(obj, NULL); } +static unsigned int ocf_core_data_obj_get_max_io_size(ocf_data_obj_t obj) +{ + ocf_core_t core = ocf_data_obj_to_core(obj); + + return ocf_dobj_get_max_io_size(&core->obj); +} + +static uint64_t ocf_core_data_obj_get_byte_length(ocf_data_obj_t obj) +{ + ocf_core_t core = ocf_data_obj_to_core(obj); + + return ocf_dobj_get_length(&core->obj); +} + + +/* *** IO OPS *** */ + +static int ocf_core_io_set_data(struct ocf_io *io, + ctx_data_t *data, uint32_t offset) +{ + struct ocf_core_io *core_io; + + OCF_CHECK_NULL(io); + + if (!data || offset) + return -EINVAL; + + core_io = ocf_io_to_core_io(io); + core_io->data = data; + + return 0; +} + +static ctx_data_t *ocf_core_io_get_data(struct ocf_io *io) +{ + struct ocf_core_io *core_io; + + OCF_CHECK_NULL(io); + + core_io = ocf_io_to_core_io(io); + return core_io->data; +} + +static void ocf_core_io_get(struct ocf_io *io) +{ + struct ocf_core_io *core_io; + + OCF_CHECK_NULL(io); + + core_io = ocf_io_to_core_io(io); + + ENV_BUG_ON(env_atomic_inc_return(&core_io->ref_counter) < 1); +} + +static void ocf_core_io_put(struct ocf_io *io) +{ + struct ocf_core_io *core_io; + int value; + + OCF_CHECK_NULL(io); + + core_io = ocf_io_to_core_io(io); + value = env_atomic_dec_return(&core_io->ref_counter); + + ENV_BUG_ON(value < 0); + + if (value) + return; + + ocf_data_obj_del_io(io); +} + +const struct ocf_data_obj_properties ocf_core_data_obj_properties = { + .name = "OCF Core", + .io_context_size = sizeof(struct ocf_core_io), + .caps = { + .atomic_writes = 0, + }, + .ops = { + .new_io = ocf_core_data_obj_new_io, + + .submit_io = ocf_core_data_obj_submit_io, + .submit_flush = ocf_core_data_obj_submit_flush, + .submit_discard = ocf_core_data_obj_submit_discard, + .submit_metadata = NULL, + + .open = ocf_core_data_obj_open, + .close = ocf_core_data_obj_close, + .get_max_io_size = ocf_core_data_obj_get_max_io_size, + .get_length = ocf_core_data_obj_get_byte_length, + }, + .io_ops = { + .set_data = ocf_core_io_set_data, + .get_data = ocf_core_io_get_data, + .get = ocf_core_io_get, + .put = ocf_core_io_put, + }, +}; + +int ocf_core_data_obj_type_init(ocf_ctx_t ctx) +{ + return ocf_ctx_register_data_obj_type(ctx, 0, + &ocf_core_data_obj_properties); +} + +void ocf_core_data_obj_type_deinit(ocf_ctx_t ctx) +{ + ocf_ctx_unregister_data_obj_type(ctx, 0); +} diff --git a/src/ocf_core_priv.h b/src/ocf_core_priv.h index 3fefad4..140060c 100644 --- a/src/ocf_core_priv.h +++ b/src/ocf_core_priv.h @@ -8,12 +8,17 @@ #include "ocf/ocf.h" #include "ocf_env.h" +#include "ocf_ctx_priv.h" #include "ocf_data_obj_priv.h" -struct ocf_core_io { - struct ocf_io base; - ocf_core_t core; +#define ocf_core_log_prefix(core, lvl, prefix, fmt, ...) \ + ocf_cache_log_prefix(ocf_core_get_cache(core), lvl, ".%s" prefix, \ + fmt, ocf_core_get_name(core), ##__VA_ARGS__) +#define ocf_core_log(core, lvl, fmt, ...) \ + ocf_core_log_prefix(core, lvl, ": ", fmt, ##__VA_ARGS__) + +struct ocf_core_io { env_atomic ref_counter; bool dirty; @@ -26,6 +31,7 @@ struct ocf_core_io { struct ocf_core { char name[OCF_CORE_NAME_SIZE]; + struct ocf_data_obj front_obj; struct ocf_data_obj obj; struct { @@ -46,11 +52,8 @@ bool ocf_core_is_valid(ocf_cache_t cache, ocf_core_id_t id); int ocf_core_set_user_metadata_raw(ocf_core_t core, void *data, size_t size); -#define ocf_core_log_prefix(core, lvl, prefix, fmt, ...) \ - ocf_cache_log_prefix(ocf_core_get_cache(core), lvl, ".%s" prefix, \ - fmt, ocf_core_get_name(core), ##__VA_ARGS__) +int ocf_core_data_obj_type_init(ocf_ctx_t ctx); -#define ocf_core_log(core, lvl, fmt, ...) \ - ocf_core_log_prefix(core, lvl, ": ", fmt, ##__VA_ARGS__) +void ocf_core_data_obj_type_deinit(ocf_ctx_t ctx); #endif /* __OCF_CORE_PRIV_H__ */ diff --git a/src/ocf_ctx.c b/src/ocf_ctx.c index 2a4e324..ae9cdae 100644 --- a/src/ocf_ctx.c +++ b/src/ocf_ctx.c @@ -9,6 +9,7 @@ #include "ocf_data_obj_priv.h" #include "ocf_utils.h" #include "ocf_logger_priv.h" +#include "ocf_core_priv.h" /* * @@ -106,7 +107,7 @@ int ocf_ctx_data_obj_create(ocf_ctx_t ctx, ocf_data_obj_t *obj, if (type_id >= OCF_DATA_OBJ_TYPE_MAX) return -EINVAL; - return ocf_data_obj_create(obj, ctx->data_obj_type[type_id], uuid); + return ocf_dobj_create(obj, ctx->data_obj_type[type_id], uuid); } /* @@ -144,7 +145,7 @@ out: */ int ocf_ctx_init(ocf_ctx_t *ctx, const struct ocf_ctx_ops *ops) { - struct ocf_ctx *ocf_ctx; + ocf_ctx_t ocf_ctx; OCF_CHECK_NULL(ctx); OCF_CHECK_NULL(ops); @@ -165,6 +166,12 @@ int ocf_ctx_init(ocf_ctx_t *ctx, const struct ocf_ctx_ops *ops) return -ENOMEM; } + if (ocf_core_data_obj_type_init(ocf_ctx)) { + ocf_utils_deinit(ocf_ctx); + env_free(ocf_ctx); + return -EINVAL; + } + *ctx = ocf_ctx; return 0; @@ -187,6 +194,8 @@ int ocf_ctx_exit(ocf_ctx_t ctx) if (result) return result; + ocf_core_data_obj_type_deinit(ctx); + ocf_utils_deinit(ctx); if (ctx->logger && ctx->logger->close) ctx->logger->close(ctx->logger); diff --git a/src/ocf_ctx_priv.h b/src/ocf_ctx_priv.h index f7f9a42..3703857 100644 --- a/src/ocf_ctx_priv.h +++ b/src/ocf_ctx_priv.h @@ -7,7 +7,7 @@ #define __OCF_CTX_PRIV_H__ #include "ocf_env.h" -#include "ocf/ocf_logger.h" +#include "ocf/ocf_ctx.h" #include "ocf_logger_priv.h" #define OCF_DATA_OBJ_TYPE_MAX 8 @@ -32,17 +32,34 @@ struct ocf_ctx { } resources; }; -#define ocf_log_prefix(ctx, lvl, prefix, fmt, ...) \ - ocf_log_raw(ctx->logger, lvl, prefix fmt, ##__VA_ARGS__) +#define ocf_log_prefix(ctx, lvl, prefix, fmt, ...) ({ \ + int __ocf_log_return_value = 0; \ + if (ctx->logger) { \ + __ocf_log_return_value = ocf_log_raw(ctx->logger, \ + lvl, prefix fmt, ##__VA_ARGS__); \ + } \ + __ocf_log_return_value; \ +}) #define ocf_log(ctx, lvl, fmt, ...) \ ocf_log_prefix(ctx, lvl, "", fmt, ##__VA_ARGS__) -#define ocf_log_rl(ctx) \ - ocf_log_raw_rl(ctx->logger, __func__) +#define ocf_log_rl(ctx) ({ \ + int __ocf_log_return_value = 0; \ + if (ctx->logger) { \ + __ocf_log_return_value = ocf_log_raw_rl(ctx->logger, \ + __func__); \ + } \ + __ocf_log_return_value; \ +}) -#define ocf_log_stack_trace(ctx) \ - ocf_log_stack_trace_raw(ctx->logger) +#define ocf_log_stack_trace(ctx) ({ \ + int __ocf_log_return_value = 0; \ + if (ctx->logger) { \ + __ocf_log_return_value = ocf_log_stack_trace_raw(ctx->logger); \ + } \ + __ocf_log_return_value; \ +}) /** * @name Environment data buffer operations wrappers diff --git a/src/ocf_data_obj.c b/src/ocf_data_obj.c index 92058ef..780cc9e 100644 --- a/src/ocf_data_obj.c +++ b/src/ocf_data_obj.c @@ -9,6 +9,8 @@ #include "ocf_io_priv.h" #include "ocf_env.h" +/* *** Bottom interface *** */ + /* * This is io allocator dedicated for bottom devices. * Out IO structure looks like this: @@ -104,16 +106,9 @@ void ocf_data_obj_type_deinit(struct ocf_data_obj_type *type) } /* - * Data object + * Data object backend API */ -ocf_data_obj_type_t ocf_data_obj_get_type(ocf_data_obj_t obj) -{ - OCF_CHECK_NULL(obj); - - return obj->type; -} - void *ocf_data_obj_get_priv(ocf_data_obj_t obj) { OCF_CHECK_NULL(obj); @@ -128,30 +123,39 @@ void ocf_data_obj_set_priv(ocf_data_obj_t obj, void *priv) obj->priv = priv; } -const struct ocf_data_obj_uuid *ocf_data_obj_get_uuid( - ocf_data_obj_t obj) +struct ocf_io *ocf_data_obj_new_io(ocf_data_obj_t obj) { + struct ocf_io *io; + OCF_CHECK_NULL(obj); - return &obj->uuid; + io = ocf_io_allocator_new(obj->type->allocator); + if (!io) + return NULL; + + io->obj = obj; + io->ops = &obj->type->properties->io_ops; + + return io; } -uint64_t ocf_data_obj_get_length(ocf_data_obj_t obj) +void ocf_data_obj_del_io(struct ocf_io* io) { - OCF_CHECK_NULL(obj); + OCF_CHECK_NULL(io); - return obj->type->properties->ops.get_length(obj); + ocf_io_allocator_del(io->obj->type->allocator, io); } - -ocf_cache_t ocf_data_obj_get_cache(ocf_data_obj_t obj) +void *ocf_data_obj_get_data_from_io(struct ocf_io* io) { - OCF_CHECK_NULL(obj); - - return obj->cache; + return (void *)io + sizeof(struct ocf_io); } -int ocf_data_obj_init(ocf_data_obj_t obj, ocf_data_obj_type_t type, +/* + * Data object frontend API + */ + +int ocf_dobj_init(ocf_data_obj_t obj, ocf_data_obj_type_t type, struct ocf_data_obj_uuid *uuid, bool uuid_copy) { if (!obj || !type) @@ -179,7 +183,7 @@ int ocf_data_obj_init(ocf_data_obj_t obj, ocf_data_obj_type_t type, return 0; } -void ocf_data_obj_deinit(ocf_data_obj_t obj) +void ocf_dobj_deinit(ocf_data_obj_t obj) { OCF_CHECK_NULL(obj); @@ -187,7 +191,7 @@ void ocf_data_obj_deinit(ocf_data_obj_t obj) env_free(obj->uuid.data); } -int ocf_data_obj_create(ocf_data_obj_t *obj, ocf_data_obj_type_t type, +int ocf_dobj_create(ocf_data_obj_t *obj, ocf_data_obj_type_t type, struct ocf_data_obj_uuid *uuid) { ocf_data_obj_t tmp_obj; @@ -199,7 +203,7 @@ int ocf_data_obj_create(ocf_data_obj_t *obj, ocf_data_obj_type_t type, if (!tmp_obj) return -OCF_ERR_NO_MEM; - ret = ocf_data_obj_init(tmp_obj, type, uuid, true); + ret = ocf_dobj_init(tmp_obj, type, uuid, true); if (ret) { env_free(tmp_obj); return ret; @@ -214,34 +218,97 @@ void ocf_data_obj_destroy(ocf_data_obj_t obj) { OCF_CHECK_NULL(obj); - ocf_data_obj_deinit(obj); + ocf_dobj_deinit(obj); env_free(obj); } -struct ocf_io *ocf_data_obj_new_io(ocf_data_obj_t obj) +ocf_data_obj_type_t ocf_dobj_get_type(ocf_data_obj_t obj) { - struct ocf_io *io; - OCF_CHECK_NULL(obj); - io = ocf_io_allocator_new(obj->type->allocator); - if (!io) - return NULL; - - io->obj = obj; - - return io; + return obj->type; } -void ocf_data_obj_del_io(struct ocf_io* io) +const struct ocf_data_obj_uuid *ocf_dobj_get_uuid( + ocf_data_obj_t obj) { - OCF_CHECK_NULL(io); + OCF_CHECK_NULL(obj); - ocf_io_allocator_del(io->obj->type->allocator, io); + return &obj->uuid; } -void *ocf_data_obj_get_data_from_io(struct ocf_io* io) +ocf_cache_t ocf_dobj_get_cache(ocf_data_obj_t obj) { - return (void *)io + sizeof(struct ocf_io); + OCF_CHECK_NULL(obj); + + return obj->cache; } +int ocf_dobj_is_atomic(ocf_data_obj_t obj) +{ + return obj->type->properties->caps.atomic_writes; +} + +struct ocf_io *ocf_dobj_new_io(ocf_data_obj_t obj) +{ + ENV_BUG_ON(!obj->type->properties->ops.new_io); + + return obj->type->properties->ops.new_io(obj); +} + +void ocf_dobj_submit_io(struct ocf_io *io) +{ + ENV_BUG_ON(!io->obj->type->properties->ops.submit_io); + + io->obj->type->properties->ops.submit_io(io); +} + +void ocf_dobj_submit_flush(struct ocf_io *io) +{ + ENV_BUG_ON(!io->obj->type->properties->ops.submit_flush); + + if (!io->obj->type->properties->ops.submit_flush) { + ocf_io_end(io, 0); + return; + } + + io->obj->type->properties->ops.submit_flush(io); +} + +void ocf_dobj_submit_discard(struct ocf_io *io) +{ + if (!io->obj->type->properties->ops.submit_discard) { + ocf_io_end(io, 0); + return; + } + + io->obj->type->properties->ops.submit_discard(io); +} + +int ocf_dobj_open(ocf_data_obj_t obj) +{ + ENV_BUG_ON(!obj->type->properties->ops.open); + + return obj->type->properties->ops.open(obj); +} + +void ocf_dobj_close(ocf_data_obj_t obj) +{ + ENV_BUG_ON(!obj->type->properties->ops.close); + + obj->type->properties->ops.close(obj); +} + +unsigned int ocf_dobj_get_max_io_size(ocf_data_obj_t obj) +{ + ENV_BUG_ON(!obj->type->properties->ops.get_max_io_size); + + return obj->type->properties->ops.get_max_io_size(obj); +} + +uint64_t ocf_dobj_get_length(ocf_data_obj_t obj) +{ + ENV_BUG_ON(!obj->type->properties->ops.get_length); + + return obj->type->properties->ops.get_length(obj); +} diff --git a/src/ocf_data_obj_priv.h b/src/ocf_data_obj_priv.h index bee0464..22f374e 100644 --- a/src/ocf_data_obj_priv.h +++ b/src/ocf_data_obj_priv.h @@ -32,46 +32,6 @@ int ocf_data_obj_type_init(struct ocf_data_obj_type **type, void ocf_data_obj_type_deinit(struct ocf_data_obj_type *type); -static inline struct ocf_io *ocf_dobj_new_io(ocf_data_obj_t obj) -{ - ENV_BUG_ON(!obj->type->properties->ops.new_io); - - return obj->type->properties->ops.new_io(obj); -} - -static inline void ocf_dobj_submit_io(struct ocf_io *io) -{ - ENV_BUG_ON(!io->obj->type->properties->ops.submit_io); - - io->obj->type->properties->ops.submit_io(io); -} - -static inline void ocf_dobj_submit_flush(struct ocf_io *io) -{ - ENV_BUG_ON(!io->obj->type->properties->ops.submit_flush); - /* - * TODO(rbaldyga): Maybe we should supply function for checking - * submit_flush availability and return -ENOTSUPP here? - */ - if (!io->obj->type->properties->ops.submit_flush) - ocf_io_end(io, 0); - else - io->obj->type->properties->ops.submit_flush(io); -} - -static inline void ocf_dobj_submit_discard(struct ocf_io *io) -{ - ENV_BUG_ON(!io->obj->type->properties->ops.submit_discard); - /* - * TODO(rbaldyga): Maybe we should supply function for checking - * submit_discard availability and return -ENOTSUPP here? - */ - if (!io->obj->type->properties->ops.submit_discard) - ocf_io_end(io, 0); - else - io->obj->type->properties->ops.submit_discard(io); -} - static inline void ocf_dobj_submit_metadata(struct ocf_io *io) { ENV_BUG_ON(!io->obj->type->properties->ops.submit_metadata); @@ -86,30 +46,4 @@ static inline void ocf_dobj_submit_write_zeroes(struct ocf_io *io) io->obj->type->properties->ops.submit_write_zeroes(io); } -static inline int ocf_data_obj_open(ocf_data_obj_t obj) -{ - ENV_BUG_ON(!obj->type->properties->ops.open); - - return obj->type->properties->ops.open(obj); -} - -static inline void ocf_data_obj_close(ocf_data_obj_t obj) -{ - ENV_BUG_ON(!obj->type->properties->ops.close); - - obj->type->properties->ops.close(obj); -} - -static inline unsigned int ocf_data_obj_get_max_io_size(ocf_data_obj_t obj) -{ - ENV_BUG_ON(!obj->type->properties->ops.get_max_io_size); - - return obj->type->properties->ops.get_max_io_size(obj); -} - -static inline int ocf_data_obj_is_atomic(ocf_data_obj_t obj) -{ - return obj->type->properties->caps.atomic_writes; -} - #endif /*__OCF_DATA_OBJ_PRIV_H__ */ diff --git a/src/ocf_logger_priv.h b/src/ocf_logger_priv.h index 5ce9c0c..2fec971 100644 --- a/src/ocf_logger_priv.h +++ b/src/ocf_logger_priv.h @@ -6,6 +6,8 @@ #ifndef __OCF_LOGGER_PRIV_H__ #define __OCF_LOGGER_PRIV_H__ +#include "ocf/ocf_logger.h" + __attribute__((format(printf, 3, 4))) int ocf_log_raw(const struct ocf_logger *logger, ocf_logger_lvl_t lvl, const char *fmt, ...); diff --git a/src/ocf_metadata.c b/src/ocf_metadata.c index a3bf7f4..b528954 100644 --- a/src/ocf_metadata.c +++ b/src/ocf_metadata.c @@ -30,7 +30,7 @@ int ocf_metadata_get_atomic_entry(ocf_cache_t cache, OCF_CHECK_NULL(cache); OCF_CHECK_NULL(entry); - if (addr > ocf_data_obj_get_length(&cache->device->obj)) + if (addr > ocf_dobj_get_length(&cache->device->obj)) return -EFAULT; if (addr < cache->device->metadata_offset) { diff --git a/src/ocf_stats.c b/src/ocf_stats.c index c300ad9..8d489ef 100644 --- a/src/ocf_stats.c +++ b/src/ocf_stats.c @@ -275,7 +275,7 @@ int ocf_core_get_stats(ocf_core_t core, struct ocf_stats_core *stats) ENV_BUG_ON(env_memset(stats, sizeof(*stats), 0)); - stats->core_size_bytes = ocf_data_obj_get_length( + stats->core_size_bytes = ocf_dobj_get_length( &cache->core[core_id].obj); stats->core_size = ocf_bytes_2_lines_round_up(cache, stats->core_size_bytes); diff --git a/tests/ut/mngt/ocf_mngt_cache.c/_cache_mng_set_cache_mode_test.c b/tests/ut/mngt/ocf_mngt_cache.c/_cache_mng_set_cache_mode_test.c index b1888cd..ee2d422 100644 --- a/tests/ut/mngt/ocf_mngt_cache.c/_cache_mng_set_cache_mode_test.c +++ b/tests/ut/mngt/ocf_mngt_cache.c/_cache_mng_set_cache_mode_test.c @@ -55,6 +55,7 @@ const char *__wrap_ocf_get_io_iface_name(ocf_cache_mode_t cache_mode) ocf_ctx_t __wrap_ocf_cache_get_ctx(ocf_cache_t cache) { + return cache->owner; } int __wrap_ocf_log_raw(const struct ocf_logger *logger, ocf_logger_lvl_t lvl, @@ -105,19 +106,23 @@ char *__wrap_ocf_cache_get_name(ocf_cache_t cache) static void _cache_mng_set_cache_mode_test01(void **state) { + ocf_cache_mode_t mode_old = -20; + ocf_cache_mode_t mode_new = ocf_cache_mode_none; + struct ocf_ctx ctx = { + .logger = 0x1, /* Just not NULL, we don't care. */ + }; + struct ocf_superblock_config sb_config = { + .cache_mode = mode_old, + }; + struct ocf_cache cache = { + .owner = &ctx, + .conf_meta = &sb_config, + }; + uint8_t flush = 0; int result; - struct ocf_cache cache; - ocf_cache_mode_t mode_old, mode_new; - uint8_t flush; print_test_description("Invalid new mode produces appropirate error code"); - cache.conf_meta = test_malloc(sizeof(struct ocf_superblock_config)); - mode_old = -20; - cache.conf_meta->cache_mode = mode_old; - mode_new = ocf_cache_mode_none; - flush = 0; - expect_function_call(__wrap_ocf_cache_mode_is_valid); will_return(__wrap_ocf_cache_mode_is_valid, 0); @@ -125,25 +130,27 @@ static void _cache_mng_set_cache_mode_test01(void **state) assert_int_equal(result, -OCF_ERR_INVAL); assert_int_equal(cache.conf_meta->cache_mode, mode_old); - - test_free(cache.conf_meta); } static void _cache_mng_set_cache_mode_test02(void **state) { + ocf_cache_mode_t mode_old = ocf_cache_mode_wt; + ocf_cache_mode_t mode_new = ocf_cache_mode_wt; + struct ocf_ctx ctx = { + .logger = 0x1, /* Just not NULL, we don't care. */ + }; + struct ocf_superblock_config sb_config = { + .cache_mode = mode_old, + }; + struct ocf_cache cache = { + .owner = &ctx, + .conf_meta = &sb_config, + }; + uint8_t flush = 0; int result; - struct ocf_cache cache; - ocf_cache_mode_t mode_old, mode_new; - uint8_t flush; print_test_description("Attempt to set mode the same as previous"); - mode_old = mode_new = ocf_cache_mode_wt; - flush = 0; - - cache.conf_meta = test_malloc(sizeof(struct ocf_superblock_config)); - cache.conf_meta->cache_mode = mode_old; - expect_function_call(__wrap_ocf_cache_mode_is_valid); will_return(__wrap_ocf_cache_mode_is_valid, 1); @@ -154,25 +161,28 @@ static void _cache_mng_set_cache_mode_test02(void **state) assert_int_equal(result, 0); assert_int_equal(cache.conf_meta->cache_mode, mode_old); - - test_free(cache.conf_meta); } static void _cache_mng_set_cache_mode_test03(void **state) { + ocf_cache_mode_t mode_old = ocf_cache_mode_wt; + ocf_cache_mode_t mode_new = ocf_cache_mode_pt; + struct ocf_ctx ctx = { + .logger = 0x1, /* Just not NULL, we don't care. */ + }; + struct ocf_superblock_config sb_config = { + .cache_mode = mode_old, + }; + struct ocf_cache cache = { + .owner = &ctx, + .conf_meta = &sb_config, + }; + uint8_t flush = 1; int result; - struct ocf_cache cache; - ocf_cache_mode_t mode_old, mode_new; - uint8_t flush; print_test_description("Flush flag is set, but operation failed -" " check if error code is correct"); - mode_old = ocf_cache_mode_wt; - mode_new = ocf_cache_mode_pt; - cache.conf_meta->cache_mode = mode_old; - flush = 1; - expect_function_call(__wrap_ocf_cache_mode_is_valid); will_return(__wrap_ocf_cache_mode_is_valid, 1); @@ -187,23 +197,26 @@ static void _cache_mng_set_cache_mode_test03(void **state) static void _cache_mng_set_cache_mode_test04(void **state) { + ocf_cache_mode_t mode_old = ocf_cache_mode_wb; + ocf_cache_mode_t mode_new = ocf_cache_mode_wa; + struct ocf_ctx ctx = { + .logger = 0x1, /* Just not NULL, we don't care. */ + }; + struct ocf_superblock_config sb_config = { + .cache_mode = mode_old, + }; + struct ocf_cache cache = { + .owner = &ctx, + .conf_meta = &sb_config, + }; + uint8_t flush = 0; int result; - struct ocf_cache cache; - ocf_cache_mode_t mode_old, mode_new; - uint8_t flush; int i; print_test_description("Flush flag is not set, " "old cache mode is write back. " "Setting new cache mode is succesfull"); - mode_old = ocf_cache_mode_wb; - mode_new = ocf_cache_mode_wa; - flush = 0; - - cache.conf_meta = test_malloc(sizeof(struct ocf_superblock_config)); - cache.conf_meta->cache_mode = mode_old; - expect_function_call(__wrap_ocf_cache_mode_is_valid); will_return(__wrap_ocf_cache_mode_is_valid, 1); @@ -226,28 +239,29 @@ static void _cache_mng_set_cache_mode_test04(void **state) assert_int_equal(result, 0); assert_int_equal(cache.conf_meta->cache_mode, mode_new); - - test_free(cache.conf_meta); } static void _cache_mng_set_cache_mode_test05(void **state) { + ocf_cache_mode_t mode_old = ocf_cache_mode_wt; + ocf_cache_mode_t mode_new = ocf_cache_mode_wa; + struct ocf_ctx ctx = { + .logger = 0x1, /* Just not NULL, we don't care. */ + }; + struct ocf_superblock_config sb_config = { + .cache_mode = mode_old, + }; + struct ocf_cache cache = { + .owner = &ctx, + .conf_meta = &sb_config, + }; + uint8_t flush = 0; int result; - struct ocf_cache cache; - ocf_cache_mode_t mode_old, mode_new; - uint8_t flush; int i; print_test_description("Flush flag is not set, " "flushing metadata superblock fails"); - mode_old = ocf_cache_mode_wt; - mode_new = ocf_cache_mode_wa; - flush = 0; - - cache.conf_meta = test_malloc(sizeof(struct ocf_superblock_config)); - cache.conf_meta->cache_mode = mode_old; - expect_function_call(__wrap_ocf_cache_mode_is_valid); will_return(__wrap_ocf_cache_mode_is_valid, 1); @@ -261,25 +275,27 @@ static void _cache_mng_set_cache_mode_test05(void **state) assert_int_equal(result, -OCF_ERR_WRITE_CACHE); assert_int_equal(cache.conf_meta->cache_mode, mode_old); - - test_free(cache.conf_meta); } static void _cache_mng_set_cache_mode_test06(void **state) { + ocf_cache_mode_t mode_old = ocf_cache_mode_wt; + ocf_cache_mode_t mode_new = ocf_cache_mode_wa; + struct ocf_ctx ctx = { + .logger = 0x1, /* Just not NULL, we don't care. */ + }; + struct ocf_superblock_config sb_config = { + .cache_mode = mode_old, + }; + struct ocf_cache cache = { + .owner = &ctx, + .conf_meta = &sb_config, + }; + uint8_t flush = 0; int result; - struct ocf_cache cache; - ocf_cache_mode_t mode_old, mode_new; - uint8_t flush; int i; print_test_description("No flush, mode changed successfully"); - mode_old = ocf_cache_mode_wt; - mode_new = ocf_cache_mode_wa; - flush = 0; - - cache.conf_meta = test_malloc(sizeof(struct ocf_superblock_config)); - cache.conf_meta->cache_mode = mode_old; expect_function_call(__wrap_ocf_cache_mode_is_valid); will_return(__wrap_ocf_cache_mode_is_valid, 1); @@ -294,25 +310,26 @@ static void _cache_mng_set_cache_mode_test06(void **state) assert_int_equal(result, 0); assert_int_equal(cache.conf_meta->cache_mode, mode_new); - - test_free(cache.conf_meta); } static void _cache_mng_set_cache_mode_test07(void **state) { + ocf_cache_mode_t mode_old = ocf_cache_mode_wt; + ocf_cache_mode_t mode_new = ocf_cache_mode_wa; + struct ocf_ctx ctx = { + .logger = 0x1, /* Just not NULL, we don't care. */ + }; + struct ocf_superblock_config sb_config = { + .cache_mode = mode_old, + }; + struct ocf_cache cache = { + .owner = &ctx, + .conf_meta = &sb_config, + }; + uint8_t flush = 1; int result; - struct ocf_cache cache; - ocf_cache_mode_t mode_old, mode_new; - uint8_t flush; - int i; print_test_description("Flush performed, mode changed successfully"); - mode_old = ocf_cache_mode_wt; - mode_new = ocf_cache_mode_wa; - flush = 1; - - cache.conf_meta = test_malloc(sizeof(struct ocf_superblock_config)); - cache.conf_meta->cache_mode = mode_old; expect_function_call(__wrap_ocf_cache_mode_is_valid); will_return(__wrap_ocf_cache_mode_is_valid, 1); @@ -330,8 +347,6 @@ static void _cache_mng_set_cache_mode_test07(void **state) assert_int_equal(result, 0); assert_int_equal(cache.conf_meta->cache_mode, mode_new); - - test_free(cache.conf_meta); } /*