ocf_mngt.h

Go to the documentation of this file.

/*
 * Copyright(c) 2012-2020 Intel Corporation
 * SPDX-License-Identifier: BSD-3-Clause-Clear
 */

#ifndef __OCF_MNGT_H__
#define __OCF_MNGT_H__

#include "ocf_cache.h"
#include "ocf_core.h"

struct ocf_mngt_core_config {
        char name[OCF_CORE_NAME_SIZE];

        struct ocf_volume_uuid uuid;

        uint8_t volume_type;

        bool try_add;

        uint32_t seq_cutoff_threshold;
        struct {
                void *data;
                size_t size;
        } user_metadata;
};

static inline void ocf_mngt_core_config_set_default(
                struct ocf_mngt_core_config *cfg)
{
        cfg->try_add = false;
        cfg->seq_cutoff_threshold = 1024;
        cfg->user_metadata.data = NULL;
        cfg->user_metadata.size = 0;
}

uint32_t ocf_mngt_cache_get_count(ocf_ctx_t ctx);

/* Cache instances getters */

int ocf_mngt_cache_get_by_name(ocf_ctx_t ctx, const char* name, size_t name_len,
                ocf_cache_t *cache);

int ocf_mngt_cache_get(ocf_cache_t cache);

void ocf_mngt_cache_put(ocf_cache_t cache);

typedef void (*ocf_mngt_cache_lock_end_t)(ocf_cache_t cache,
                void *priv, int error);

void ocf_mngt_cache_lock(ocf_cache_t cache,
                ocf_mngt_cache_lock_end_t cmpl, void *priv);

void ocf_mngt_cache_read_lock(ocf_cache_t cache,
                ocf_mngt_cache_lock_end_t cmpl, void *priv);

int ocf_mngt_cache_trylock(ocf_cache_t cache);

int ocf_mngt_cache_read_trylock(ocf_cache_t cache);

void ocf_mngt_cache_unlock(ocf_cache_t cache);

void ocf_mngt_cache_read_unlock(ocf_cache_t cache);

typedef int (*ocf_mngt_cache_visitor_t)(ocf_cache_t cache, void *cntx);

int ocf_mngt_cache_visit(ocf_ctx_t ctx, ocf_mngt_cache_visitor_t visitor,
                void *cntx);

int ocf_mngt_cache_visit_reverse(ocf_ctx_t ctx, ocf_mngt_cache_visitor_t visitor,
                void *cntx);

struct ocf_mngt_cache_config {
        char name[OCF_CACHE_NAME_SIZE];

        ocf_cache_mode_t cache_mode;

        ocf_eviction_t eviction_policy;

        ocf_promotion_t promotion_policy;

        ocf_cache_line_size_t cache_line_size;

        ocf_metadata_layout_t metadata_layout;

        bool metadata_volatile;

        struct {
                 uint32_t max_queue_size;
                 uint32_t queue_unblock_size;
        } backfill;

        bool locked;

        bool pt_unaligned_io;

        bool use_submit_io_fast;
};

static inline void ocf_mngt_cache_config_set_default(
                struct ocf_mngt_cache_config *cfg)
{
        cfg->cache_mode = ocf_cache_mode_default;
        cfg->eviction_policy = ocf_eviction_default;
        cfg->promotion_policy = ocf_promotion_default;
        cfg->cache_line_size = ocf_cache_line_size_4;
        cfg->metadata_layout = ocf_metadata_layout_default;
        cfg->metadata_volatile = false;
        cfg->backfill.max_queue_size = 65536;
        cfg->backfill.queue_unblock_size = 60000;
        cfg->locked = false;
        cfg->pt_unaligned_io = false;
        cfg->use_submit_io_fast = false;
}

int ocf_mngt_cache_start(ocf_ctx_t ctx, ocf_cache_t *cache,
                struct ocf_mngt_cache_config *cfg);

int ocf_mngt_cache_set_mngt_queue(ocf_cache_t cache, ocf_queue_t queue);

typedef void (*ocf_mngt_cache_stop_end_t)(ocf_cache_t cache,
                void *priv, int error);

void ocf_mngt_cache_stop(ocf_cache_t cache,
                ocf_mngt_cache_stop_end_t cmpl, void *priv);

struct ocf_mngt_cache_device_config {
        struct ocf_volume_uuid uuid;

        uint8_t volume_type;

        ocf_cache_line_size_t cache_line_size;

        bool open_cores;

        bool force;

        bool perform_test;

        bool discard_on_start;

        void *volume_params;
};

static inline void ocf_mngt_cache_device_config_set_default(
                struct ocf_mngt_cache_device_config *cfg)
{
        cfg->cache_line_size = ocf_cache_line_size_none;
        cfg->open_cores = true;
        cfg->force = false;
        cfg->perform_test = true;
        cfg->discard_on_start = true;
        cfg->volume_params = NULL;
}

int ocf_mngt_get_ram_needed(ocf_cache_t cache,
                struct ocf_mngt_cache_device_config *cfg, uint64_t *ram_needed);

typedef void (*ocf_mngt_cache_attach_end_t)(ocf_cache_t cache,
                void *priv, int error);

void ocf_mngt_cache_attach(ocf_cache_t cache,
                struct ocf_mngt_cache_device_config *cfg,
                ocf_mngt_cache_attach_end_t cmpl, void *priv);

typedef void (*ocf_mngt_cache_detach_end_t)(ocf_cache_t cache,
                void *priv, int error);

void ocf_mngt_cache_detach(ocf_cache_t cache,
                ocf_mngt_cache_detach_end_t cmpl, void *priv);

typedef void (*ocf_mngt_cache_load_end_t)(ocf_cache_t cache,
                void *priv, int error);

void ocf_mngt_cache_load(ocf_cache_t cache,
                struct ocf_mngt_cache_device_config *cfg,
                ocf_mngt_cache_load_end_t cmpl, void *priv);

/* Adding and removing cores */

typedef void (*ocf_mngt_cache_add_core_end_t)(ocf_cache_t cache,
                ocf_core_t core, void *priv, int error);

void ocf_mngt_cache_add_core(ocf_cache_t cache,
                struct ocf_mngt_core_config *cfg,
                ocf_mngt_cache_add_core_end_t cmpl, void *priv);

typedef void (*ocf_mngt_cache_remove_core_end_t)(void *priv, int error);

void ocf_mngt_cache_remove_core(ocf_core_t core,
                ocf_mngt_cache_remove_core_end_t cmpl, void *priv);

typedef void (*ocf_mngt_cache_detach_core_end_t)(void *priv, int error);

void ocf_mngt_cache_detach_core(ocf_core_t core,
                ocf_mngt_cache_detach_core_end_t cmpl, void *priv);

/* Flush operations */

typedef void (*ocf_mngt_cache_flush_end_t)(ocf_cache_t cache,
                void *priv, int error);

void ocf_mngt_cache_flush(ocf_cache_t cache,
                ocf_mngt_cache_flush_end_t cmpl, void *priv);

bool ocf_mngt_core_is_dirty(ocf_core_t core);

bool ocf_mngt_cache_is_dirty(ocf_cache_t cache);

typedef void (*ocf_mngt_core_flush_end_t)(ocf_core_t core,
                void *priv, int error);

void ocf_mngt_core_flush(ocf_core_t core,
                ocf_mngt_core_flush_end_t cmpl, void *priv);

typedef void (*ocf_mngt_cache_purge_end_t)(ocf_cache_t cache,
                void *priv, int error);

void ocf_mngt_cache_purge(ocf_cache_t cache,
                ocf_mngt_cache_purge_end_t cmpl, void *priv);

typedef void (*ocf_mngt_core_purge_end_t)(ocf_core_t core,
                void *priv, int error);

void ocf_mngt_core_purge(ocf_core_t core,
                ocf_mngt_core_purge_end_t cmpl, void *priv);

void ocf_mngt_cache_flush_interrupt(ocf_cache_t cache);

typedef void (*ocf_mngt_cache_save_end_t)(ocf_cache_t cache,
                void *priv, int error);

void ocf_mngt_cache_save(ocf_cache_t cache,
                ocf_mngt_cache_save_end_t cmpl, void *priv);

static inline bool ocf_mngt_cache_mode_has_lazy_write(ocf_cache_mode_t mode)
{
        return mode == ocf_cache_mode_wb || mode == ocf_cache_mode_wo;
}

int ocf_mngt_cache_set_mode(ocf_cache_t cache, ocf_cache_mode_t mode);

int ocf_mngt_cache_cleaning_set_policy(ocf_cache_t cache, ocf_cleaning_t type);

int ocf_mngt_cache_cleaning_get_policy(ocf_cache_t cache, ocf_cleaning_t *type);

int ocf_mngt_cache_cleaning_set_param(ocf_cache_t cache, ocf_cleaning_t type,
                uint32_t param_id, uint32_t param_value);

int ocf_mngt_cache_cleaning_get_param(ocf_cache_t cache,ocf_cleaning_t type,
                uint32_t param_id, uint32_t *param_value);

int ocf_mngt_cache_promotion_set_policy(ocf_cache_t cache, ocf_promotion_t type);

ocf_promotion_t ocf_mngt_cache_promotion_get_policy(ocf_cache_t cache);

int ocf_mngt_cache_promotion_set_param(ocf_cache_t cache, ocf_promotion_t type,
                uint8_t param_id, uint32_t param_value);

int ocf_mngt_cache_promotion_get_param(ocf_cache_t cache, ocf_promotion_t type,
                uint8_t param_id, uint32_t *param_value);

struct ocf_mngt_io_class_config {
        uint32_t class_id;

        const char *name;

        int16_t prio;

        ocf_cache_mode_t cache_mode;

        uint32_t min_size;

        uint32_t max_size;
};

struct ocf_mngt_io_classes_config {
        struct ocf_mngt_io_class_config config[OCF_IO_CLASS_MAX];
};

int ocf_mngt_cache_io_classes_configure(ocf_cache_t cache,
                const struct ocf_mngt_io_classes_config *cfg);

int ocf_mngt_core_set_uuid(ocf_core_t core, const struct ocf_volume_uuid *uuid);

int ocf_mngt_core_set_user_metadata(ocf_core_t core, void *data, size_t size);

int ocf_mngt_core_get_user_metadata(ocf_core_t core, void *data, size_t size);

int ocf_mngt_core_set_seq_cutoff_threshold(ocf_core_t core, uint32_t thresh);

int ocf_mngt_core_set_seq_cutoff_threshold_all(ocf_cache_t cache,
                uint32_t thresh);

int ocf_mngt_core_get_seq_cutoff_threshold(ocf_core_t core, uint32_t *thresh);

int ocf_mngt_core_set_seq_cutoff_policy(ocf_core_t core,
                ocf_seq_cutoff_policy policy);

int ocf_mngt_core_set_seq_cutoff_policy_all(ocf_cache_t cache,
                ocf_seq_cutoff_policy policy);

int ocf_mngt_core_get_seq_cutoff_policy(ocf_core_t core,
                ocf_seq_cutoff_policy *policy);

int ocf_mngt_cache_set_fallback_pt_error_threshold(ocf_cache_t cache,
                uint32_t threshold);

int ocf_mngt_cache_get_fallback_pt_error_threshold(ocf_cache_t cache,
                uint32_t *threshold);

int ocf_mngt_cache_reset_fallback_pt_error_counter(ocf_cache_t cache);

int ocf_mngt_core_pool_get_count(ocf_ctx_t ctx);

int ocf_mngt_core_pool_add(ocf_ctx_t ctx, ocf_uuid_t uuid, uint8_t type);

ocf_volume_t ocf_mngt_core_pool_lookup(ocf_ctx_t ctx, ocf_uuid_t uuid,
                ocf_volume_type_t type);
int ocf_mngt_core_pool_visit(ocf_ctx_t ctx,
                int (*visitor)(ocf_uuid_t, void *), void *visitor_ctx);

void ocf_mngt_core_pool_remove(ocf_ctx_t ctx, ocf_volume_t volume);

#endif /* __OCF_CACHE_H__ */