zms.h

Go to the documentation of this file.

/* Copyright (c) 2018 Laczen
 * Copyright (c) 2024 BayLibre SAS
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * ZMS: Zephyr Memory Storage
 */
#ifndef ZEPHYR_INCLUDE_KVSS_ZMS_H_
#define ZEPHYR_INCLUDE_KVSS_ZMS_H_
 
#include <sys/types.h>
#include <zephyr/drivers/flash.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/toolchain.h>
 
#ifdef __cplusplus
extern "C" {
#endif



enum zms_mount_flags {
        ZMS_MOUNT_FLAG_NO_FORMAT = BIT(0),
};

#if CONFIG_ZMS_ID_64BIT
typedef uint64_t zms_id_t;
#else
typedef uint32_t zms_id_t;
#endif

#if CONFIG_ZMS_ID_64BIT
#define ZMS_DATA_IN_ATE_SIZE 4
#else
#define ZMS_DATA_IN_ATE_SIZE 8
#endif

#define ZMS_ITER_ID_MIN ((zms_id_t)0)

#define ZMS_ITER_ID_MAX ((zms_id_t)~(zms_id_t)0)

#define ZMS_ITER_MASK_ALL ZMS_ITER_ID_MAX

typedef bool (*zms_iter_predicate_t)(zms_id_t id);

struct zms_fs {
        off_t offset;
        uint64_t ate_wra;
        uint64_t data_wra;
        uint32_t sector_size;
        uint32_t sector_count;
        uint32_t mount_flags;
        uint8_t sector_cycle;
        bool ready;
        struct k_mutex zms_lock;
        const struct device *flash_device;
        const struct flash_parameters *flash_parameters;
        size_t ate_size;
#if CONFIG_ZMS_LOOKUP_CACHE
#if CONFIG_ZMS_LOOKUP_CACHE_MANUAL
        uint64_t *lookup_cache;
        size_t lookup_cache_size;
#else
        uint64_t lookup_cache[CONFIG_ZMS_LOOKUP_CACHE_SIZE];
#endif
#endif
};

struct zms_iter_config {
        zms_id_t mask_id;
        zms_id_t min_id;
        zms_id_t max_id;
        bool use_mask;
        bool use_range;
        bool use_predicate;
        zms_iter_predicate_t predicate_func;
};

#define ZMS_ITER_CONFIG_DEFAULT \
        { \
                .mask_id = ZMS_ITER_MASK_ALL, \
                .min_id = ZMS_ITER_ID_MIN, \
                .max_id = ZMS_ITER_ID_MAX, \
                .use_mask = false, \
                .use_range = false, \
                .use_predicate = false, \
                .predicate_func = NULL, \
        }

struct zms_iter {
        uint64_t walk_addr;
        uint64_t end_addr;
        zms_id_t mask_id;
        zms_id_t min_id;
        zms_id_t max_id;
        zms_iter_predicate_t predicate_func;
        bool exhausted;
        int previous_sector_num;
        uint8_t current_cycle;
};



int zms_mount(struct zms_fs *fs);

int zms_mount_force(struct zms_fs *fs);

int zms_clear(struct zms_fs *fs);

ssize_t zms_write(struct zms_fs *fs, zms_id_t id, const void *data, size_t len);

int zms_delete(struct zms_fs *fs, zms_id_t id);

ssize_t zms_read(struct zms_fs *fs, zms_id_t id, void *data, size_t len);

ssize_t zms_read_hist(struct zms_fs *fs, zms_id_t id, void *data, size_t len, uint32_t cnt);

ssize_t zms_get_data_length(struct zms_fs *fs, zms_id_t id);

ssize_t zms_calc_free_space(struct zms_fs *fs);

ssize_t zms_active_sector_free_space(struct zms_fs *fs);

int zms_sector_use_next(struct zms_fs *fs);
 
#if CONFIG_ZMS_LOOKUP_CACHE_MANUAL
int zms_set_lookup_cache(struct zms_fs *fs, uint64_t *buffer, size_t size);
#endif

int zms_get_num_cycles(struct zms_fs *fs, uint32_t *cycles);

int zms_get_sector_num_cycles(struct zms_fs *fs, uint32_t sector, uint32_t *cycles);

int zms_iter_init_with_config(const struct zms_fs *fs, struct zms_iter *iter,
                              const struct zms_iter_config *config);

int zms_iter_init(const struct zms_fs *fs, struct zms_iter *iter);

int zms_iter_next(struct zms_fs *fs, struct zms_iter *iter, zms_id_t *id, size_t *len, void *data,
                  size_t data_len);

int zms_iter_next_all(struct zms_fs *fs, struct zms_iter *iter, zms_id_t *id, size_t *len,
                      void *data, size_t data_len);

 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_KVSS_ZMS_H_ */