4ab22ee2dc
To allow the fastest switching from the passive-standby to active mode, the runtime metadata must be kept 100% synced with the metadata on the drive and in the RAM thus recovery is required after each collision section update. To avoid long-lasting recovering of all the cachelines each time the collision section is being updated, the passive update procedure recovers only those which have its MD entries on the updated pages. Signed-off-by: Michal Mielewczyk <michal.mielewczyk@intel.com>
526 lines
12 KiB
C
526 lines
12 KiB
C
/*
|
|
* Copyright(c) 2012-2021 Intel Corporation
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
*/
|
|
|
|
#include "ocf/ocf.h"
|
|
#include "metadata/metadata.h"
|
|
#include "metadata/metadata.h"
|
|
#include "engine/cache_engine.h"
|
|
#include "utils/utils_cache_line.h"
|
|
#include "ocf_request.h"
|
|
#include "utils/utils_user_part.h"
|
|
#include "ocf_priv.h"
|
|
#include "ocf_cache_priv.h"
|
|
#include "ocf_queue_priv.h"
|
|
#include "utils/utils_stats.h"
|
|
|
|
ocf_volume_t ocf_cache_get_volume(ocf_cache_t cache)
|
|
{
|
|
return cache->device ? &cache->device->volume : NULL;
|
|
}
|
|
|
|
ocf_volume_t ocf_cache_get_front_volume(ocf_cache_t cache)
|
|
{
|
|
return cache->device ? &cache->device->front_volume : NULL;
|
|
}
|
|
|
|
int ocf_cache_set_name(ocf_cache_t cache, const char *src, size_t src_size)
|
|
{
|
|
int result;
|
|
|
|
OCF_CHECK_NULL(cache);
|
|
|
|
result = env_strncpy(cache->name, OCF_CACHE_NAME_SIZE, src, src_size);
|
|
if (result)
|
|
return result;
|
|
|
|
return env_strncpy(cache->conf_meta->name, OCF_CACHE_NAME_SIZE,
|
|
src, src_size);
|
|
}
|
|
|
|
const char *ocf_cache_get_name(ocf_cache_t cache)
|
|
{
|
|
OCF_CHECK_NULL(cache);
|
|
return cache->name;
|
|
}
|
|
|
|
bool ocf_cache_is_incomplete(ocf_cache_t cache)
|
|
{
|
|
OCF_CHECK_NULL(cache);
|
|
return env_bit_test(ocf_cache_state_incomplete, &cache->cache_state);
|
|
}
|
|
|
|
bool ocf_cache_is_running(ocf_cache_t cache)
|
|
{
|
|
OCF_CHECK_NULL(cache);
|
|
return env_bit_test(ocf_cache_state_running, &cache->cache_state);
|
|
}
|
|
|
|
bool ocf_cache_is_standby(ocf_cache_t cache)
|
|
{
|
|
OCF_CHECK_NULL(cache);
|
|
return env_bit_test(ocf_cache_state_standby, &cache->cache_state);
|
|
}
|
|
|
|
bool ocf_cache_is_device_attached(ocf_cache_t cache)
|
|
{
|
|
OCF_CHECK_NULL(cache);
|
|
return !!cache->device;
|
|
}
|
|
|
|
ocf_cache_mode_t ocf_cache_get_mode(ocf_cache_t cache)
|
|
{
|
|
OCF_CHECK_NULL(cache);
|
|
|
|
return cache->conf_meta->cache_mode;
|
|
}
|
|
|
|
static uint64_t _calc_dirty_for(uint64_t dirty_since)
|
|
{
|
|
uint64_t current_time = env_ticks_to_secs(env_get_tick_count());
|
|
|
|
return dirty_since ? (current_time - dirty_since) : 0;
|
|
}
|
|
|
|
int ocf_cache_get_info(ocf_cache_t cache, struct ocf_cache_info *info)
|
|
{
|
|
uint32_t cache_occupancy_total = 0;
|
|
uint32_t dirty_blocks_total = 0;
|
|
uint32_t initial_dirty_blocks_total = 0;
|
|
uint32_t flushed_total = 0;
|
|
uint32_t curr_dirty_cnt;
|
|
uint64_t dirty_since = 0;
|
|
uint32_t init_dirty_cnt;
|
|
uint64_t core_dirty_since;
|
|
uint32_t dirty_blocks_inactive = 0;
|
|
uint32_t cache_occupancy_inactive = 0;
|
|
ocf_core_t core;
|
|
ocf_core_id_t core_id;
|
|
|
|
OCF_CHECK_NULL(cache);
|
|
|
|
if (!info)
|
|
return -OCF_ERR_INVAL;
|
|
|
|
ENV_BUG_ON(env_memset(info, sizeof(*info), 0));
|
|
|
|
_ocf_stats_zero(&info->inactive);
|
|
|
|
info->attached = ocf_cache_is_device_attached(cache);
|
|
info->failover_detached = ocf_cache_is_standby(cache) &&
|
|
ocf_refcnt_frozen(&cache->refcnt.metadata);
|
|
if (info->attached && !info->failover_detached) {
|
|
info->volume_type = ocf_ctx_get_volume_type_id(cache->owner,
|
|
cache->device->volume.type);
|
|
info->size = cache->conf_meta->cachelines;
|
|
}
|
|
info->state = cache->cache_state;
|
|
info->cache_line_size = ocf_line_size(cache);
|
|
info->metadata_end_offset = ocf_cache_is_device_attached(cache) ?
|
|
cache->device->metadata_offset / PAGE_SIZE : 0;
|
|
info->metadata_footprint = ocf_cache_is_device_attached(cache) ?
|
|
ocf_metadata_size_of(cache) : 0;
|
|
|
|
if (ocf_cache_is_standby(cache))
|
|
return 0;
|
|
|
|
info->core_count = cache->conf_meta->core_count;
|
|
|
|
info->cache_mode = ocf_cache_get_mode(cache);
|
|
|
|
/* iterate through all possibly valid core objcts, as list of
|
|
* valid objects may be not continuous
|
|
*/
|
|
for_each_core(cache, core, core_id) {
|
|
/* If current dirty blocks exceeds saved initial dirty
|
|
* blocks then update the latter
|
|
*/
|
|
curr_dirty_cnt = env_atomic_read(
|
|
&core->runtime_meta->dirty_clines);
|
|
init_dirty_cnt = env_atomic_read(
|
|
&core->runtime_meta->initial_dirty_clines);
|
|
if (init_dirty_cnt && (curr_dirty_cnt > init_dirty_cnt)) {
|
|
env_atomic_set(
|
|
&core->runtime_meta->initial_dirty_clines,
|
|
env_atomic_read(
|
|
&core->runtime_meta->dirty_clines));
|
|
}
|
|
cache_occupancy_total += env_atomic_read(
|
|
&core->runtime_meta->cached_clines);
|
|
|
|
dirty_blocks_total += env_atomic_read(
|
|
&core->runtime_meta->dirty_clines);
|
|
initial_dirty_blocks_total += env_atomic_read(
|
|
&core->runtime_meta->initial_dirty_clines);
|
|
|
|
if (!core->opened) {
|
|
cache_occupancy_inactive += env_atomic_read(
|
|
&core->runtime_meta->cached_clines);
|
|
|
|
dirty_blocks_inactive += env_atomic_read(
|
|
&core->runtime_meta->dirty_clines);
|
|
}
|
|
core_dirty_since = env_atomic64_read(
|
|
&core->runtime_meta->dirty_since);
|
|
if (core_dirty_since) {
|
|
dirty_since = (dirty_since ?
|
|
OCF_MIN(dirty_since, core_dirty_since) :
|
|
core_dirty_since);
|
|
}
|
|
|
|
flushed_total += env_atomic_read(&core->flushed);
|
|
}
|
|
|
|
info->dirty = dirty_blocks_total;
|
|
info->dirty_initial = initial_dirty_blocks_total;
|
|
info->occupancy = cache_occupancy_total;
|
|
info->dirty_for = _calc_dirty_for(dirty_since);
|
|
|
|
if (info->attached) {
|
|
_set(&info->inactive.occupancy,
|
|
_lines4k(cache_occupancy_inactive, ocf_line_size(cache)),
|
|
_lines4k(info->size, ocf_line_size(cache)));
|
|
_set(&info->inactive.clean,
|
|
_lines4k(cache_occupancy_inactive - dirty_blocks_inactive,
|
|
ocf_line_size(cache)),
|
|
_lines4k(cache_occupancy_total, ocf_line_size(cache)));
|
|
_set(&info->inactive.dirty,
|
|
_lines4k(dirty_blocks_inactive, ocf_line_size(cache)),
|
|
_lines4k(cache_occupancy_total, ocf_line_size(cache)));
|
|
}
|
|
|
|
info->flushed = (env_atomic_read(&cache->flush_in_progress)) ?
|
|
flushed_total : 0;
|
|
|
|
info->fallback_pt.status = ocf_fallback_pt_is_on(cache);
|
|
info->fallback_pt.error_counter =
|
|
env_atomic_read(&cache->fallback_pt_error_counter);
|
|
|
|
info->cleaning_policy = cache->cleaner.policy;
|
|
info->promotion_policy = cache->conf_meta->promotion_policy_type;
|
|
info->cache_line_size = ocf_line_size(cache);
|
|
|
|
return 0;
|
|
}
|
|
|
|
const struct ocf_volume_uuid *ocf_cache_get_uuid(ocf_cache_t cache)
|
|
{
|
|
if (!ocf_cache_is_device_attached(cache))
|
|
return NULL;
|
|
|
|
return ocf_volume_get_uuid(ocf_cache_get_volume(cache));
|
|
}
|
|
|
|
uint8_t ocf_cache_get_type_id(ocf_cache_t cache)
|
|
{
|
|
if (!ocf_cache_is_device_attached(cache))
|
|
return 0xff;
|
|
|
|
return ocf_ctx_get_volume_type_id(ocf_cache_get_ctx(cache),
|
|
ocf_volume_get_type(ocf_cache_get_volume(cache)));
|
|
}
|
|
|
|
ocf_cache_line_size_t ocf_cache_get_line_size(ocf_cache_t cache)
|
|
{
|
|
OCF_CHECK_NULL(cache);
|
|
return ocf_line_size(cache);
|
|
}
|
|
|
|
uint64_t ocf_cache_bytes_2_lines(ocf_cache_t cache, uint64_t bytes)
|
|
{
|
|
OCF_CHECK_NULL(cache);
|
|
return ocf_bytes_2_lines(cache, bytes);
|
|
}
|
|
|
|
uint32_t ocf_cache_get_core_count(ocf_cache_t cache)
|
|
{
|
|
OCF_CHECK_NULL(cache);
|
|
return cache->conf_meta->core_count;
|
|
}
|
|
|
|
ocf_ctx_t ocf_cache_get_ctx(ocf_cache_t cache)
|
|
{
|
|
OCF_CHECK_NULL(cache);
|
|
return cache->owner;
|
|
}
|
|
|
|
void ocf_cache_set_priv(ocf_cache_t cache, void *priv)
|
|
{
|
|
OCF_CHECK_NULL(cache);
|
|
cache->priv = priv;
|
|
}
|
|
|
|
void *ocf_cache_get_priv(ocf_cache_t cache)
|
|
{
|
|
OCF_CHECK_NULL(cache);
|
|
return cache->priv;
|
|
}
|
|
|
|
struct ocf_cache_volume_io_priv {
|
|
struct ocf_io *io;
|
|
struct ctx_data_t *data;
|
|
env_atomic remaining;
|
|
env_atomic error;
|
|
};
|
|
|
|
struct ocf_cache_volume {
|
|
ocf_cache_t cache;
|
|
};
|
|
|
|
static inline ocf_cache_t ocf_volume_to_cache(ocf_volume_t volume)
|
|
{
|
|
struct ocf_cache_volume *cache_volume = ocf_volume_get_priv(volume);
|
|
|
|
return cache_volume->cache;
|
|
}
|
|
|
|
static void ocf_cache_volume_io_complete_generic(struct ocf_io *vol_io,
|
|
int error)
|
|
{
|
|
struct ocf_cache_volume_io_priv *priv;
|
|
struct ocf_io *io = vol_io->priv1;
|
|
ocf_cache_t cache = ocf_volume_to_cache(ocf_io_get_volume(io));
|
|
|
|
priv = ocf_io_get_priv(io);
|
|
|
|
if (env_atomic_dec_return(&priv->remaining))
|
|
return;
|
|
|
|
ocf_io_put(vol_io);
|
|
ocf_io_end(io, error);
|
|
ocf_refcnt_dec(&cache->refcnt.metadata);
|
|
}
|
|
|
|
static void ocf_cache_io_complete(struct ocf_io *io, int error)
|
|
{
|
|
struct ocf_cache_volume_io_priv *priv;
|
|
ocf_cache_t cache;
|
|
|
|
cache = ocf_volume_to_cache(ocf_io_get_volume(io));
|
|
|
|
priv = ocf_io_get_priv(io);
|
|
|
|
env_atomic_cmpxchg(&priv->error, 0, error);
|
|
|
|
if (env_atomic_dec_return(&priv->remaining))
|
|
return;
|
|
|
|
ocf_refcnt_dec(&cache->refcnt.metadata);
|
|
ocf_io_end(io, env_atomic_read(&priv->error));
|
|
}
|
|
|
|
static void ocf_cache_volume_io_complete(struct ocf_io *vol_io, int error)
|
|
{
|
|
struct ocf_io *io = vol_io->priv1;
|
|
|
|
ocf_io_put(vol_io);
|
|
|
|
ocf_cache_io_complete(io, error);
|
|
}
|
|
|
|
static int ocf_cache_volume_prepare_vol_io(struct ocf_io *io,
|
|
struct ocf_io **vol_io)
|
|
{
|
|
struct ocf_cache_volume_io_priv *priv;
|
|
ocf_cache_t cache;
|
|
struct ocf_io *tmp_io;
|
|
int result;
|
|
|
|
OCF_CHECK_NULL(io);
|
|
|
|
priv = ocf_io_get_priv(io);
|
|
cache = ocf_volume_to_cache(ocf_io_get_volume(io));
|
|
|
|
tmp_io = ocf_volume_new_io(ocf_cache_get_volume(cache), io->io_queue,
|
|
io->addr, io->bytes, io->dir, io->io_class, io->flags);
|
|
if (!tmp_io)
|
|
return -OCF_ERR_NO_MEM;
|
|
|
|
result = ocf_io_set_data(tmp_io, priv->data, 0);
|
|
if (result) {
|
|
ocf_io_put(tmp_io);
|
|
return result;
|
|
}
|
|
|
|
*vol_io = tmp_io;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void ocf_cache_volume_submit_io(struct ocf_io *io)
|
|
{
|
|
struct ocf_cache_volume_io_priv *priv;
|
|
struct ocf_io *vol_io;
|
|
ocf_cache_t cache;
|
|
int result;
|
|
|
|
cache = ocf_volume_to_cache(ocf_io_get_volume(io));
|
|
priv = ocf_io_get_priv(io);
|
|
|
|
if (!ocf_refcnt_inc(&cache->refcnt.metadata)) {
|
|
ocf_io_end(io, -OCF_ERR_IO);
|
|
return;
|
|
}
|
|
|
|
env_atomic_set(&priv->remaining, 3);
|
|
env_atomic_set(&priv->error, 0);
|
|
|
|
result = ocf_cache_volume_prepare_vol_io(io, &vol_io);
|
|
if (result) {
|
|
ocf_io_end(io, result);
|
|
return;
|
|
}
|
|
|
|
ocf_io_set_cmpl(vol_io, io, NULL, ocf_cache_volume_io_complete);
|
|
ocf_volume_submit_io(vol_io);
|
|
|
|
result = ocf_metadata_passive_update(cache, io, ocf_cache_io_complete);
|
|
if (result) {
|
|
ocf_cache_log(cache, log_crit,
|
|
"Metadata update error (error=%d)!\n", result);
|
|
}
|
|
|
|
ocf_cache_io_complete(io, 0);
|
|
}
|
|
|
|
|
|
static void ocf_cache_volume_submit_flush(struct ocf_io *io)
|
|
{
|
|
struct ocf_cache_volume_io_priv *priv;
|
|
struct ocf_io *vol_io;
|
|
ocf_cache_t cache;
|
|
int result;
|
|
|
|
cache = ocf_volume_to_cache(ocf_io_get_volume(io));
|
|
priv = ocf_io_get_priv(io);
|
|
|
|
if (!ocf_refcnt_inc(&cache->refcnt.metadata)) {
|
|
ocf_io_end(io, -OCF_ERR_IO);
|
|
return;
|
|
}
|
|
|
|
env_atomic_set(&priv->remaining, 1);
|
|
|
|
result = ocf_cache_volume_prepare_vol_io(io, &vol_io);
|
|
if (result) {
|
|
ocf_io_end(io, result);
|
|
return;
|
|
}
|
|
ocf_io_set_cmpl(vol_io, io, NULL, ocf_cache_volume_io_complete_generic);
|
|
|
|
ocf_volume_submit_flush(vol_io);
|
|
}
|
|
|
|
|
|
static void ocf_cache_volume_submit_discard(struct ocf_io *io)
|
|
{
|
|
struct ocf_cache_volume_io_priv *priv;
|
|
struct ocf_io *vol_io;
|
|
ocf_cache_t cache;
|
|
int result;
|
|
|
|
cache = ocf_volume_to_cache(ocf_io_get_volume(io));
|
|
priv = ocf_io_get_priv(io);
|
|
|
|
if (!ocf_refcnt_inc(&cache->refcnt.metadata)) {
|
|
ocf_io_end(io, -OCF_ERR_IO);
|
|
return;
|
|
}
|
|
|
|
env_atomic_set(&priv->remaining, 1);
|
|
|
|
result = ocf_cache_volume_prepare_vol_io(io, &vol_io);
|
|
if (result) {
|
|
ocf_io_end(io, result);
|
|
return;
|
|
}
|
|
ocf_io_set_cmpl(vol_io, io, NULL, ocf_cache_volume_io_complete_generic);
|
|
|
|
ocf_volume_submit_discard(vol_io);
|
|
}
|
|
|
|
/* *** VOLUME OPS *** */
|
|
|
|
static int ocf_cache_volume_open(ocf_volume_t volume, void *volume_params)
|
|
{
|
|
struct ocf_cache_volume *cache_volume = ocf_volume_get_priv(volume);
|
|
const struct ocf_volume_uuid *uuid = ocf_volume_get_uuid(volume);
|
|
ocf_cache_t cache = (ocf_cache_t)uuid->data;
|
|
|
|
cache_volume->cache = cache;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void ocf_cache_volume_close(ocf_volume_t volume)
|
|
{
|
|
}
|
|
|
|
static unsigned int ocf_cache_volume_get_max_io_size(ocf_volume_t volume)
|
|
{
|
|
ocf_cache_t cache = ocf_volume_to_cache(volume);
|
|
|
|
return ocf_volume_get_max_io_size(ocf_cache_get_volume(cache));
|
|
}
|
|
|
|
static uint64_t ocf_cache_volume_get_byte_length(ocf_volume_t volume)
|
|
{
|
|
ocf_cache_t cache = ocf_volume_to_cache(volume);
|
|
|
|
return ocf_volume_get_length(ocf_cache_get_volume(cache));
|
|
}
|
|
|
|
/* *** IO OPS *** */
|
|
|
|
static int ocf_cache_io_set_data(struct ocf_io *io,
|
|
ctx_data_t *data, uint32_t offset)
|
|
{
|
|
struct ocf_cache_volume_io_priv *priv = ocf_io_get_priv(io);
|
|
|
|
if (!data || offset)
|
|
return -OCF_ERR_INVAL;
|
|
|
|
priv->data = data;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static ctx_data_t *ocf_cache_io_get_data(struct ocf_io *io)
|
|
{
|
|
struct ocf_cache_volume_io_priv *priv = ocf_io_get_priv(io);
|
|
|
|
return priv->data;
|
|
}
|
|
|
|
const struct ocf_volume_properties ocf_cache_volume_properties = {
|
|
.name = "OCF Cache",
|
|
.io_priv_size = sizeof(struct ocf_cache_volume_io_priv),
|
|
.volume_priv_size = sizeof(struct ocf_cache_volume),
|
|
.caps = {
|
|
.atomic_writes = 0,
|
|
},
|
|
.ops = {
|
|
.submit_io = ocf_cache_volume_submit_io,
|
|
.submit_flush = ocf_cache_volume_submit_flush,
|
|
.submit_discard = ocf_cache_volume_submit_discard,
|
|
.submit_metadata = NULL,
|
|
|
|
.open = ocf_cache_volume_open,
|
|
.close = ocf_cache_volume_close,
|
|
.get_max_io_size = ocf_cache_volume_get_max_io_size,
|
|
.get_length = ocf_cache_volume_get_byte_length,
|
|
},
|
|
.io_ops = {
|
|
.set_data = ocf_cache_io_set_data,
|
|
.get_data = ocf_cache_io_get_data,
|
|
},
|
|
.deinit = NULL,
|
|
};
|
|
|
|
int ocf_cache_volume_type_init(ocf_ctx_t ctx)
|
|
{
|
|
return ocf_ctx_register_volume_type_internal(ctx, OCF_VOLUME_TYPE_CACHE,
|
|
&ocf_cache_volume_properties, NULL);
|
|
}
|