From 13f374ae8e3152765c6fcbd95fc9b4b93da665b5 Mon Sep 17 00:00:00 2001 From: Robert Baldyga Date: Tue, 6 Oct 2026 08:36:52 +0200 Subject: [PATCH 1/3] metadata: Decouple collision hash function from cache object Signed-off-by: Robert Baldyga --- src/metadata/metadata_collision.h | 34 +++++++++++++++++++++++++++++++ src/metadata/metadata_misc.h | 19 +++++++---------- 2 files changed, 41 insertions(+), 12 deletions(-) diff --git a/src/metadata/metadata_collision.h b/src/metadata/metadata_collision.h index 53ac94c71..a8672b4c0 100644 --- a/src/metadata/metadata_collision.h +++ b/src/metadata/metadata_collision.h @@ -44,6 +44,40 @@ struct ocf_hash_entry { }; }; +/** + * @brief Hash bucket of core line + * + * Hash function intentionally returns consecutive (modulo @hash_entries) + * values for consecutive @core_line. This way it is trivial to sort all + * core lines within a single request in ascending hash value order. This kind + * of sorting is required to assure that (future) hash bucket metadata locks are + * always acquired in fixed order, eliminating the risk of dead locks. + * + * @param hash_entries - Number of entries in hash segment + * @param core_line - Core line number + * @param core_id - Core id + */ +static inline ocf_cache_line_t ocf_metadata_collision_hash( + ocf_cache_line_t hash_entries, uint64_t core_line, + ocf_core_id_t core_id) +{ + return (ocf_cache_line_t) ((core_line + (core_id * (hash_entries / 32))) + % hash_entries); +} + +/** + * @brief Hash bucket following given one + * + * @param hash_entries - Number of entries in hash segment + * @param hash - Hash bucket + */ +static inline ocf_cache_line_t ocf_metadata_collision_hash_next( + ocf_cache_line_t hash_entries, ocf_cache_line_t hash) +{ + hash++; + return likely(hash < hash_entries) ? hash : 0; +} + /** * @brief Metadata map structure */ diff --git a/src/metadata/metadata_misc.h b/src/metadata/metadata_misc.h index 383be9580..6e1636c1c 100644 --- a/src/metadata/metadata_misc.h +++ b/src/metadata/metadata_misc.h @@ -8,27 +8,22 @@ #ifndef __METADATA_MISC_H__ #define __METADATA_MISC_H__ -/* Hash function intentionally returns consecutive (modulo @hash_table_entries) - * values for consecutive @core_line_num. This way it is trivial to sort all - * core lines within a single request in ascending hash value order. This kind - * of sorting is required to assure that (future) hash bucket metadata locks are - * always acquired in fixed order, eliminating the risk of dead locks. - */ +#include "metadata_collision.h" + +/* See ocf_metadata_collision_hash() */ static inline ocf_cache_line_t ocf_metadata_hash_func(ocf_cache_t cache, uint64_t core_line_num, ocf_core_id_t core_id) { - const unsigned int entries = cache->device->hash_table_entries; - - return (ocf_cache_line_t) ((core_line_num + (core_id * (entries / 32))) - % entries); + return ocf_metadata_collision_hash(cache->device->hash_table_entries, + core_line_num, core_id); } /* Return the hash based on the hash of the prev core line */ static inline ocf_cache_line_t ocf_metadata_hash_next(ocf_cache_t cache, ocf_cache_line_t hash) { - hash++; - return likely(hash < cache->device->hash_table_entries) ? hash : 0; + return ocf_metadata_collision_hash_next( + cache->device->hash_table_entries, hash); } void ocf_metadata_remove_cache_line(struct ocf_cache *cache, From 56c1fd9179ab87797500642f69ba03219da93fce Mon Sep 17 00:00:00 2001 From: Robert Baldyga Date: Tue, 6 Oct 2026 12:49:41 +0200 Subject: [PATCH 2/3] metadata: Encapsulate raw_dynamic memory management Make all the pages accessible through API, providing clean copy-on-write behavior for write accesses. Signed-off-by: Robert Baldyga --- src/metadata/metadata_raw.c | 18 +++- src/metadata/metadata_raw.h | 9 +- src/metadata/metadata_raw_dynamic.c | 143 +++++++++++++++------------- src/metadata/metadata_raw_dynamic.h | 9 +- 4 files changed, 105 insertions(+), 74 deletions(-) diff --git a/src/metadata/metadata_raw.c b/src/metadata/metadata_raw.c index 9bfac1a77..ab8f627a9 100644 --- a/src/metadata/metadata_raw.c +++ b/src/metadata/metadata_raw.c @@ -193,6 +193,12 @@ static void *_raw_ram_access(ocf_cache_t cache, return _RAW_RAM_ADDR(raw, entry); } +static const void *_raw_ram_rd_access(ocf_cache_t cache, + struct ocf_metadata_raw *raw, uint32_t entry) +{ + return _raw_ram_access(cache, raw, entry); +} + static int _raw_ram_drain_page(ocf_cache_t cache, struct ocf_metadata_raw *raw, ctx_data_t *data, uint32_t page) { @@ -640,7 +646,8 @@ static const struct raw_iface IRAW[metadata_raw_type_max] = { .size_on_ssd = _raw_ram_size_on_ssd, .checksum = _raw_ram_checksum, .page = _raw_ram_page, - .access = _raw_ram_access, + .wr_access = _raw_ram_access, + .rd_access = _raw_ram_rd_access, .update = _raw_ram_update, .zero = raw_ram_zero, .load_all = _raw_ram_load_all, @@ -655,7 +662,8 @@ static const struct raw_iface IRAW[metadata_raw_type_max] = { .size_on_ssd = raw_dynamic_size_on_ssd, .checksum = raw_dynamic_checksum, .page = raw_dynamic_page, - .access = raw_dynamic_access, + .wr_access = raw_dynamic_wr_access, + .rd_access = raw_dynamic_rd_access, .update = raw_dynamic_update, .zero = raw_ram_zero, .load_all = raw_dynamic_load_all, @@ -670,7 +678,8 @@ static const struct raw_iface IRAW[metadata_raw_type_max] = { .size_on_ssd = raw_volatile_size_on_ssd, .checksum = raw_volatile_checksum, .page = _raw_ram_page, - .access = _raw_ram_access, + .wr_access = _raw_ram_access, + .rd_access = _raw_ram_rd_access, .update = raw_volatile_update, .zero = raw_volatile_zero, .load_all = raw_volatile_load_all, @@ -685,7 +694,8 @@ static const struct raw_iface IRAW[metadata_raw_type_max] = { .size_on_ssd = _raw_ram_size_on_ssd, .checksum = _raw_ram_checksum, .page = _raw_ram_page, - .access = _raw_ram_access, + .wr_access = _raw_ram_access, + .rd_access = _raw_ram_rd_access, .update = _raw_ram_update, .zero = raw_ram_zero, .load_all = _raw_ram_load_all, diff --git a/src/metadata/metadata_raw.h b/src/metadata/metadata_raw.h index cdaa5cf72..b4ac4e8c7 100644 --- a/src/metadata/metadata_raw.h +++ b/src/metadata/metadata_raw.h @@ -117,9 +117,12 @@ struct raw_iface { uint32_t (*page)(struct ocf_metadata_raw *raw, uint32_t entry); - void* (*access)(ocf_cache_t cache, struct ocf_metadata_raw *raw, + void* (*wr_access)(ocf_cache_t cache, struct ocf_metadata_raw *raw, uint32_t entry); + const void* (*rd_access)(ocf_cache_t cache, + struct ocf_metadata_raw *raw, uint32_t entry); + int (*update)(ocf_cache_t cache, struct ocf_metadata_raw *raw, ctx_data_t *data, uint64_t page, uint64_t count); @@ -228,7 +231,7 @@ static inline uint32_t ocf_metadata_raw_page(struct ocf_metadata_raw* raw, static inline void *ocf_metadata_raw_wr_access(ocf_cache_t cache, struct ocf_metadata_raw *raw, uint32_t entry) { - return raw->iface->access(cache, raw, entry); + return raw->iface->wr_access(cache, raw, entry); } /** @@ -242,7 +245,7 @@ static inline void *ocf_metadata_raw_wr_access(ocf_cache_t cache, static inline const void *ocf_metadata_raw_rd_access( ocf_cache_t cache, struct ocf_metadata_raw *raw, uint32_t entry) { - return raw->iface->access(cache, raw, entry); + return raw->iface->rd_access(cache, raw, entry); } /** diff --git a/src/metadata/metadata_raw_dynamic.c b/src/metadata/metadata_raw_dynamic.c index ecba0135d..95fabf098 100644 --- a/src/metadata/metadata_raw_dynamic.c +++ b/src/metadata/metadata_raw_dynamic.c @@ -71,53 +71,60 @@ struct _raw_ctrl { void *pages[]; }; -static void *_raw_dynamic_get_item(ocf_cache_t cache, - struct ocf_metadata_raw *raw, uint32_t entry) +static const uint8_t _raw_dynamic_zero_page[PAGE_SIZE]; + +/* + * Get page for reading - page not allocated reads as zeros + */ +static const void *_raw_dynamic_page_rd(struct ocf_metadata_raw *raw, + uint32_t page) { - void *new = NULL; struct _raw_ctrl *ctrl = (struct _raw_ctrl *)raw->priv; - uint32_t page = _RAW_DYNAMIC_PAGE(raw, entry); - ENV_BUG_ON(!_raw_is_valid(raw, entry)); + if (ctrl->pages[page]) + return ctrl->pages[page]; - OCF_DEBUG_PARAM(cache, "Accessing item %u on page %u", entry, page); + return _raw_dynamic_zero_page; +} - if (!ctrl->pages[page]) { - /* No page, allocate one, and set*/ +/* + * Get page for writing - page not allocated yet is created as a copy of + * zero page + */ +static void *_raw_dynamic_page_wr(ocf_cache_t cache, + struct ocf_metadata_raw *raw, uint32_t page) +{ + struct _raw_ctrl *ctrl = (struct _raw_ctrl *)raw->priv; + void *new; - /* This RAW container has some restrictions and need to check - * this limitation: - * 1. no atomic context when allocation - * 2. Only one allocator in time - */ + if (ctrl->pages[page]) + return ctrl->pages[page]; - ENV_BUG_ON(env_in_interrupt()); + /* This RAW container has some restrictions and need to check + * this limitation: + * 1. no atomic context when allocation + * 2. Only one allocator in time + */ - env_mutex_lock(&ctrl->lock); + ENV_BUG_ON(env_in_interrupt()); - if (ctrl->pages[page]) { - /* Page has been already allocated, skip allocation */ - goto _raw_dynamic_get_item_SKIP; - } + env_mutex_lock(&ctrl->lock); + if (!ctrl->pages[page]) { OCF_DEBUG_PARAM(cache, "New page allocation - %u", page); new = env_secure_alloc(PAGE_SIZE); if (new) { - ENV_BUG_ON(env_memset(new, PAGE_SIZE, 0)); + ENV_BUG_ON(env_memcpy(new, PAGE_SIZE, + _raw_dynamic_zero_page, PAGE_SIZE)); ctrl->pages[page] = new; env_atomic_inc(&ctrl->count); } - -_raw_dynamic_get_item_SKIP: - - env_mutex_unlock(&ctrl->lock); } - if (ctrl->pages[page]) - return ctrl->pages[page] + _RAW_DYNAMIC_PAGE_OFFSET(raw, entry); + env_mutex_unlock(&ctrl->lock); - return NULL; + return ctrl->pages[page]; } /* @@ -255,12 +262,38 @@ uint32_t raw_dynamic_page(struct ocf_metadata_raw *raw, uint32_t entry) } /* -* RAM DYNAMIC Implementation - access -*/ -void *raw_dynamic_access(ocf_cache_t cache, + * RAM DYNAMIC Implementation - write access + */ +void *raw_dynamic_wr_access(ocf_cache_t cache, struct ocf_metadata_raw *raw, uint32_t entry) { - return _raw_dynamic_get_item(cache, raw, entry); + uint8_t *page; + + ENV_BUG_ON(!_raw_is_valid(raw, entry)); + + OCF_DEBUG_PARAM(cache, "Accessing item %u on page %u", entry, + _RAW_DYNAMIC_PAGE(raw, entry)); + + page = _raw_dynamic_page_wr(cache, raw, _RAW_DYNAMIC_PAGE(raw, entry)); + if (!page) + return NULL; + + return page + _RAW_DYNAMIC_PAGE_OFFSET(raw, entry); +} + +/* + * RAM DYNAMIC Implementation - read access + */ +const void *raw_dynamic_rd_access(ocf_cache_t cache, + struct ocf_metadata_raw *raw, uint32_t entry) +{ + const uint8_t *page; + + ENV_BUG_ON(!_raw_is_valid(raw, entry)); + + page = _raw_dynamic_page_rd(raw, _RAW_DYNAMIC_PAGE(raw, entry)); + + return page + _RAW_DYNAMIC_PAGE_OFFSET(raw, entry); } /* @@ -268,7 +301,7 @@ void *raw_dynamic_access(ocf_cache_t cache, */ static int raw_dynamic_update_pages(ocf_cache_t cache, struct ocf_metadata_raw *raw, ctx_data_t *data, uint64_t page, - uint64_t count, uint8_t **buffer, uint8_t *zpage) + uint64_t count, uint8_t **buffer) { struct _raw_ctrl *ctrl = (struct _raw_ctrl *)raw->priv; int result = 0; @@ -284,7 +317,8 @@ static int raw_dynamic_update_pages(ocf_cache_t cache, ctx_data_rd_check(cache->owner, *buffer, data, PAGE_SIZE); - result = env_memcmp(zpage, PAGE_SIZE, *buffer, PAGE_SIZE, &cmp); + result = env_memcmp(_raw_dynamic_zero_page, PAGE_SIZE, + *buffer, PAGE_SIZE, &cmp); if (result < 0) return result; @@ -317,21 +351,15 @@ int raw_dynamic_update(ocf_cache_t cache, struct ocf_metadata_raw *raw, ctx_data_t *data, uint64_t page, uint64_t count) { - uint8_t *buffer = NULL, *zpage; + uint8_t *buffer = NULL; int result; - zpage = env_vzalloc(PAGE_SIZE); - if (!zpage) - return -OCF_ERR_NO_MEM; - result = raw_dynamic_update_pages(cache, raw, data, page, - count, &buffer, zpage); + count, &buffer); if (buffer) env_secure_free(buffer, PAGE_SIZE); - env_vfree(zpage); - return result; } @@ -347,7 +375,6 @@ struct raw_dynamic_load_all_context { unsigned flapping_idx; struct ocf_request *req; ocf_cache_t cache; - uint8_t *zpage; uint8_t *page; uint64_t i_page; int error; @@ -362,7 +389,6 @@ static void raw_dynamic_load_all_complete( context->cmpl(context->priv, error); env_secure_free(context->page, PAGE_SIZE); - env_free(context->zpage); ctx_data_free(context->cache->owner, context->req->data); ocf_req_put(context->req); env_vfree(context); @@ -418,7 +444,7 @@ static int raw_dynamic_load_all_update(struct ocf_request *req) ctx_data_seek_begin, 0); result = raw_dynamic_update_pages(cache, raw, req->data, - context->i_page, count, &context->page, context->zpage); + context->i_page, count, &context->page); context->i_page += count; @@ -455,12 +481,6 @@ void raw_dynamic_load_all(ocf_cache_t cache, struct ocf_metadata_raw *raw, context->cmpl = cmpl; context->priv = priv; - context->zpage = env_zalloc(PAGE_SIZE, ENV_MEM_NORMAL); - if (!context->zpage) { - result = -OCF_ERR_NO_MEM; - goto err_zpage; - } - req = ocf_req_new_mngt(cache, cache->mngt_queue); if (!req) { result = -OCF_ERR_NO_MEM; @@ -486,8 +506,6 @@ void raw_dynamic_load_all(ocf_cache_t cache, struct ocf_metadata_raw *raw, err_data: ocf_req_put(req); err_req: - env_free(context->zpage); -err_zpage: env_vfree(context); OCF_CMPL_RET(priv, result); } @@ -511,26 +529,19 @@ static int raw_dynamic_flush_all_fill(ocf_cache_t cache, { struct raw_dynamic_flush_all_context *context = priv; struct ocf_metadata_raw *raw = context->raw; - struct _raw_ctrl *ctrl = (struct _raw_ctrl *)raw->priv; uint32_t raw_page; ENV_BUG_ON(!_raw_ssd_page_is_valid(raw, page)); raw_page = page - context->ssd_pages_offset; - if (ctrl->pages[raw_page]) { - OCF_DEBUG_PARAM(cache, "Page = %u", raw_page); - if (raw->lock_page) - raw->lock_page(cache, raw, raw_page); - ctx_data_wr_check(cache->owner, data, ctrl->pages[raw_page], - PAGE_SIZE); - if (raw->unlock_page) - raw->unlock_page(cache, raw, raw_page); - } else { - OCF_DEBUG_PARAM(cache, "Zero fill, Page = %u", raw_page); - /* Page was not allocated before set only zeros */ - ctx_data_zero_check(cache->owner, data, PAGE_SIZE); - } + OCF_DEBUG_PARAM(cache, "Page = %u", raw_page); + if (raw->lock_page) + raw->lock_page(cache, raw, raw_page); + ctx_data_wr_check(cache->owner, data, + _raw_dynamic_page_rd(raw, raw_page), PAGE_SIZE); + if (raw->unlock_page) + raw->unlock_page(cache, raw, raw_page); return 0; } diff --git a/src/metadata/metadata_raw_dynamic.h b/src/metadata/metadata_raw_dynamic.h index f64d0f712..daf4f361c 100644 --- a/src/metadata/metadata_raw_dynamic.h +++ b/src/metadata/metadata_raw_dynamic.h @@ -1,5 +1,6 @@ /* * Copyright(c) 2012-2021 Intel Corporation + * Copyright(c) 2026 Unvertical * SPDX-License-Identifier: BSD-3-Clause */ @@ -50,7 +51,13 @@ uint32_t raw_dynamic_page(struct ocf_metadata_raw *raw, uint32_t entry); /* * RAW DYNAMIC - Write access for specified entry */ -void *raw_dynamic_access(ocf_cache_t cache, +void *raw_dynamic_wr_access(ocf_cache_t cache, + struct ocf_metadata_raw *raw, uint32_t entry); + +/* + * RAW DYNAMIC - Read access for specified entry + */ +const void *raw_dynamic_rd_access(ocf_cache_t cache, struct ocf_metadata_raw *raw, uint32_t entry); /* From 216ef42a2a8e1385690e92d0b6cc8453c0e57856 Mon Sep 17 00:00:00 2001 From: Robert Baldyga Date: Tue, 6 Oct 2026 13:24:33 +0200 Subject: [PATCH 3/3] metadata: Decouple crc calculation Signed-off-by: Robert Baldyga --- src/metadata/metadata_layout.c | 37 +++++++++++++++++++++++++++ src/metadata/metadata_layout.h | 39 +++++++++++++++++++++++++++++ src/metadata/metadata_raw.c | 19 +++++++------- src/metadata/metadata_raw_dynamic.c | 20 ++++++--------- src/metadata/metadata_superblock.c | 9 +++---- 5 files changed, 97 insertions(+), 27 deletions(-) diff --git a/src/metadata/metadata_layout.c b/src/metadata/metadata_layout.c index f0abc7417..2a20e30e1 100644 --- a/src/metadata/metadata_layout.c +++ b/src/metadata/metadata_layout.c @@ -164,6 +164,39 @@ bool ocf_metadata_segment_layout_is_flapped( } } +uint32_t ocf_metadata_segment_layout_checksum_superblock(const void *data) +{ + return env_crc32(0, data, + offsetof(struct ocf_superblock_config, checksum)); +} + +uint32_t ocf_metadata_segment_layout_checksum_page( + const struct ocf_metadata_segment_layout *segment, + uint32_t crc, const void *page) +{ + ENV_BUG_ON(segment->id == metadata_segment_sb_config); + + return env_crc32(crc, page, PAGE_SIZE); +} + +uint32_t ocf_metadata_segment_layout_checksum_segment( + const struct ocf_metadata_segment_layout *segment, + const void *(*get_page)(void *opaque, unsigned idx), + void *opaque) +{ + uint32_t step = 0; + uint32_t crc = 0; + unsigned i; + + for (i = 0; i < segment->pages; i++) { + crc = ocf_metadata_segment_layout_checksum_page(segment, + crc, get_page(opaque, i)); + OCF_COND_RESCHED(step, 10000); + } + + return crc; +} + /* * Set up segment with given number of entries at given offset * @@ -203,6 +236,9 @@ void ocf_metadata_layout_init_fixed_size( layout->on_disk = on_disk; + for (i = 0; i < metadata_segment_max; i++) + layout->segment[i].id = i; + for (i = 0; i < metadata_segment_fixed_size_max; i++) { page += ocf_metadata_layout_setup_segment(layout, i, 0, ocf_metadata_segment_layout_entries(i, 0), @@ -227,6 +263,7 @@ void ocf_metadata_layout_set_cachelines(struct ocf_metadata_layout *layout, if (i == metadata_segment_cleaning && cleaner_disabled) { ENV_BUG_ON(env_memset(&layout->segment[i], sizeof(layout->segment[i]), 0)); + layout->segment[i].id = i; layout->segment[i].disabled = true; continue; } diff --git a/src/metadata/metadata_layout.h b/src/metadata/metadata_layout.h index fc5e1cb0d..c1b35707a 100644 --- a/src/metadata/metadata_layout.h +++ b/src/metadata/metadata_layout.h @@ -29,6 +29,9 @@ #define OCF_METADATA_SEGMENT_ALIGNMENT (128 * KiB) struct ocf_metadata_segment_layout { + enum ocf_metadata_segment_id id; + /*!< Segment id */ + uint32_t entry_size; /*!< Size of single entry */ @@ -122,6 +125,42 @@ static inline uint64_t ocf_metadata_segment_layout_offset( flapping_idx; } +/** + * @brief Checksum of superblock config + * + * Checksum covers struct ocf_superblock_config up to the checksum array. + * + * @param data - Superblock config (struct ocf_superblock_config) + */ +uint32_t ocf_metadata_segment_layout_checksum_superblock(const void *data); + +/** + * @brief Update segment checksum with single page of segment data + * + * @param segment - Segment layout (other than superblock config) + * @param crc - Checksum of preceding pages (0 for first page) + * @param page - Page of segment data + */ +uint32_t ocf_metadata_segment_layout_checksum_page( + const struct ocf_metadata_segment_layout *segment, uint32_t crc, + const void *page); + +/** + * @brief Checksum of segment data + * + * Checksum covers all pages of segment data as kept in memory, i.e. entries + * packed densely one after another (without unused remainder of each page + * on disk), followed by zeros up to the number of pages of the segment. + * + * @param segment - Segment layout (other than superblock config) + * @param get_page - Callback returning page of segment data of given index + * @param opaque - Private data passed to @get_page + */ +uint32_t ocf_metadata_segment_layout_checksum_segment( + const struct ocf_metadata_segment_layout *segment, + const void *(*get_page)(void *opaque, unsigned idx), + void *opaque); + /** * @brief Initialize layout of fixed size segments * diff --git a/src/metadata/metadata_raw.c b/src/metadata/metadata_raw.c index ab8f627a9..db435dec5 100644 --- a/src/metadata/metadata_raw.c +++ b/src/metadata/metadata_raw.c @@ -157,19 +157,18 @@ static uint32_t _raw_ram_size_on_ssd(struct ocf_metadata_raw *raw) /* * RAM Implementation - Checksum */ -static uint32_t _raw_ram_checksum(ocf_cache_t cache, - struct ocf_metadata_raw *raw) +static const void *_raw_ram_checksum_get_page(void *opaque, unsigned idx) { - uint64_t i; - uint32_t step = 0; - uint32_t crc = 0; + struct ocf_metadata_raw *raw = opaque; - for (i = 0; i < raw->layout->pages; i++) { - crc = env_crc32(crc, raw->mem_pool + PAGE_SIZE * i, PAGE_SIZE); - OCF_COND_RESCHED(step, 10000); - } + return (uint8_t *)raw->mem_pool + (uint64_t)idx * PAGE_SIZE; +} - return crc; +static uint32_t _raw_ram_checksum(ocf_cache_t cache, + struct ocf_metadata_raw *raw) +{ + return ocf_metadata_segment_layout_checksum_segment(raw->layout, + _raw_ram_checksum_get_page, raw); } /* diff --git a/src/metadata/metadata_raw_dynamic.c b/src/metadata/metadata_raw_dynamic.c index 95fabf098..c3708ca2a 100644 --- a/src/metadata/metadata_raw_dynamic.c +++ b/src/metadata/metadata_raw_dynamic.c @@ -234,21 +234,17 @@ uint32_t raw_dynamic_size_on_ssd(struct ocf_metadata_raw *raw) /* * RAM DYNAMIC Implementation - Checksum */ +static const void *_raw_dynamic_checksum_get_page(void *opaque, + unsigned idx) +{ + return _raw_dynamic_page_rd(opaque, idx); +} + uint32_t raw_dynamic_checksum(ocf_cache_t cache, struct ocf_metadata_raw *raw) { - struct _raw_ctrl *ctrl = (struct _raw_ctrl *)raw->priv; - uint64_t i; - uint32_t step = 0; - uint32_t crc = 0; - - for (i = 0; i < raw->layout->pages; i++) { - if (ctrl->pages[i]) - crc = env_crc32(crc, ctrl->pages[i], PAGE_SIZE); - OCF_COND_RESCHED(step, 10000); - } - - return crc; + return ocf_metadata_segment_layout_checksum_segment(raw->layout, + _raw_dynamic_checksum_get_page, raw); } /* diff --git a/src/metadata/metadata_superblock.c b/src/metadata/metadata_superblock.c index 0c3eaad2c..58b4ddbfb 100644 --- a/src/metadata/metadata_superblock.c +++ b/src/metadata/metadata_superblock.c @@ -128,8 +128,7 @@ int ocf_metadata_validate_superblock(ocf_ctx_t ctx, return -OCF_ERR_METADATA_VER; } - crc = env_crc32(0, (void *)superblock, - offsetof(struct ocf_superblock_config, checksum)); + crc = ocf_metadata_segment_layout_checksum_superblock(superblock); if (crc != superblock->checksum[metadata_segment_sb_config]) { ocf_log_invalid_superblock("checksum"); @@ -504,9 +503,9 @@ static void ocf_metadata_calculate_crc_sb_config(ocf_pipeline_t pipeline, ctrl = context->ctrl; sb_config = METADATA_MEM_POOL(ctrl, metadata_segment_sb_config); - sb_config->checksum[metadata_segment_sb_config] = env_crc32(0, - (void *)sb_config, - offsetof(struct ocf_superblock_config, checksum)); + sb_config->checksum[metadata_segment_sb_config] = + ocf_metadata_segment_layout_checksum_superblock( + sb_config); ocf_pipeline_next(pipeline); }