bacnet_stack/zephyr/subsys/bacnet_settings/bacnet_storage.c

/**
 * @file
 * @brief The BACnet storage tasks for handling the device specific object data
 * @author Steve Karg <skarg@users.sourceforge.net>
 * @date April 2024
 * @copyright SPDX-License-Identifier: MIT
 */
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <zephyr/settings/settings.h>
#if defined(CONFIG_SETTINGS_FILE) && defined(CONFIG_FILE_SYSTEM_LITTLEFS)
#include <zephyr/fs/fs.h>
#include <zephyr/fs/littlefs.h>
#elif defined(CONFIG_SETTINGS_FILE) && defined(CONFIG_FILE_SYSTEM_EXT2)
#include <zephyr/fs/fs.h>
#include <zephyr/fs/ext2.h>
#endif
/* me! */
#include "bacnet_settings/bacnet_storage.h"

#ifdef CONFIG_BACNET_SETTINGS_BASE_NAME
#define BACNET_STORAGE_BASE_NAME CONFIG_BACNET_SETTINGS_BASE_NAME
#else
#define BACNET_STORAGE_BASE_NAME ".bacnet"
#endif

/* Logging module registration is already done in bacnet/ports/zephyr/main.c */
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(bacnet, CONFIG_BACNETSTACK_LOG_LEVEL);
#define FAIL_MSG "fail (err %d)"

#define STORAGE_PARTITION storage_partition
#define STORAGE_PARTITION_ID FIXED_PARTITION_ID(STORAGE_PARTITION)

/**
 * @brief Initialize the non-volatile data
*/
void bacnet_storage_init(void)
{
    int rc;

#if defined(CONFIG_SETTINGS_FILE) && defined(CONFIG_FILE_SYSTEM_LITTLEFS)
    FS_LITTLEFS_DECLARE_DEFAULT_CONFIG(cstorage);

    /* mounting info */
    static struct fs_mount_t littlefs_mnt = {
        .type = FS_LITTLEFS,
        .fs_data = &cstorage,
        .storage_dev = (void *)STORAGE_PARTITION_ID,
        .mnt_point = "/ff"
    };

    rc = fs_mount(&littlefs_mnt);
    if (rc != 0) {
        LOG_INF("mounting littlefs error: [%d]", rc);
    } else {
        rc = fs_unlink(CONFIG_SETTINGS_FILE_PATH);
        if ((rc != 0) && (rc != -ENOENT)) {
            H("can't delete config file%d", rc);
        } else {
            LOG_INF("FS initialized: OK");
        }
    }
#endif
    rc = settings_subsys_init();
    if (rc) {
        LOG_INF("settings subsys initialization: fail (err %d)", rc);
        return;
    }

    LOG_INF("settings subsys initialization: OK.");
}

/**
 * @brief Initialize a BACnet key object with optional array
 * @param key BACnet key (type, instance, property, array index)
 * @param object_type BACnet object type
 * @param object_instance BACnet object instance
 * @param property_id BACnet property id
 * @param array_index BACnet array index
 */
void bacnet_storage_key_init(BACNET_STORAGE_KEY *key, uint16_t object_type,
                 uint32_t object_instance, uint32_t property_id,
                 uint32_t array_index)
{
    if (key) {
        key->object_type = object_type;
        key->object_instance = object_instance;
        key->property_id = property_id;
        key->array_index = array_index;
    }
}

/**
 * @brief Create a storage key string for a BACnet object property
 * @param buffer buffer to store key string
 * @param buffer_size size of key buffer
 * @param key BACnet key (type, instance, property, array index)
 * @return length of the string
 */
int bacnet_storage_key_encode(char *buffer, size_t buffer_size,
                  BACNET_STORAGE_KEY *key)
{
    int rc = 0;
    const char base_name[] = CONFIG_BACNET_STORAGE_BASE_NAME;

    if (buffer) {
        memset(buffer, 0, buffer_size);
    }
    if (key->array_index == BACNET_STORAGE_ARRAY_INDEX_NONE) {
        rc = snprintf(buffer, buffer_size, "%s%c%u%c%lu%c%lu",
                  base_name, SETTINGS_NAME_SEPARATOR,
                  (unsigned short)key->object_type,
                  SETTINGS_NAME_SEPARATOR,
                  (unsigned long)key->object_instance,
                  SETTINGS_NAME_SEPARATOR,
                  (unsigned long)key->property_id);
    } else {
        rc = snprintf(buffer, buffer_size, "%s%c%u%c%lu%c%lu%c%lu",
                  base_name, SETTINGS_NAME_SEPARATOR,
                  (unsigned short)key->object_type,
                  SETTINGS_NAME_SEPARATOR,
                  (unsigned long)key->object_instance,
                  SETTINGS_NAME_SEPARATOR,
                  (unsigned long)key->property_id,
                  SETTINGS_NAME_SEPARATOR,
                  (unsigned long)key->array_index);
    }

    return rc;
}

/**
 * @brief Set a value with a specific key to non-volatile storage
 * @param key [in] Key in string format.
 * @param data [in] one or more bytes of data
 * @param data_len [in] Value length in bytes.
 * @return 0 on success, non-zero on failure.
 */
int bacnet_storage_set(BACNET_STORAGE_KEY *key, const void *data,
               size_t data_len)
{
    char name[SETTINGS_MAX_NAME_LEN + 1] = { 0 };
    int rc;

    rc = bacnet_storage_key_encode(name, sizeof(name), key);
    LOG_INF("Set a key-value pair. Key=%s", name);
    rc = settings_save_one(name, data, data_len);
    if (rc) {
        LOG_INF(FAIL_MSG, rc);
    } else {
        LOG_HEXDUMP_INF(data, data_len, "value");
    }

    return rc;
}

/**
 * @brief Structure to hold immediate values
 */
struct direct_immediate_value {
    size_t value_size;
    size_t value_len;
    void *value;
    bool fetched;
};

/**
 * @brief Direct loader for immediate values
 * @param name [in] Key in string format.
 * @param len [in] Length of the key
 * @param read_cb [in] Callback to read the value
 * @param cb_arg [in] Callback argument
 * @param param [in] Callback parameter
 * @return 0 on success, non-zero on failure.
 */
static int direct_loader_immediate_value(const char *name, size_t len,
                     settings_read_cb read_cb, void *cb_arg,
                     void *param)
{
    const char *next;
    size_t name_len;
    int rc;
    struct direct_immediate_value *context =
        (struct direct_immediate_value *)param;

    /* only the exact match and ignore descendants of the searched name */
    name_len = settings_name_next(name, &next);
    if (name_len == 0) {
        rc = read_cb(cb_arg, context->value, len);
        if ((rc >= 0) && (rc <= context->value_size)) {
            context->fetched = true;
            context->value_len = rc;
            LOG_INF("immediate load: OK.");
            return 0;
        }
        return -EINVAL;
    }

    /* other keys aren't served by the callback
     * Return success in order to skip them
     * and keep storage processing.
     */
    return 0;
}

/**
 * @brief Load an immediate value from non-volatile storage
 * @param name [in] Key in string format.
 * @param value [out] Buffer to store the value
 * @param value_size [in] size of the buffer
 * @return value length in bytes on success 0..N, negative on failure.
 */
static int load_immediate_value(const char *name, void *value,
                size_t value_size)
{
    int rc;
    struct direct_immediate_value context;

    context.fetched = false;
    context.value_size = value_size;
    context.value_len = 0;
    context.value = value;

    rc = settings_load_subtree_direct(name, direct_loader_immediate_value,
                      (void *)&context);
    if (rc == 0) {
        if (!context.fetched) {
            rc = -ENOENT;
        }
    }

    return context.value_len;
}

/**
 * @brief Get a value with a specific key to non-volatile storage
 * @param key [in] Key in string format.
 * @param data [out] Binary value.
 * @param data_size [in] requested value length in bytes
 * @return data length on success 0..N, negative on failure.
 */
int bacnet_storage_get(BACNET_STORAGE_KEY *key, void *data, size_t data_size)
{
    char name[SETTINGS_MAX_NAME_LEN + 1] = { 0 };
    int rc;

    rc = bacnet_storage_key_encode(name, sizeof(name), key);
    LOG_INF("Get a key-value pair. Key=<%s>", name);
    rc = load_immediate_value(name, data, data_size);
    if (rc == 0) {
        LOG_INF("empty entry");
    } else if (rc > 0) {
        LOG_HEXDUMP_INF(data, rc, "value");
    } else if (rc == -ENOENT) {
        LOG_INF("no entry");
    } else {
        LOG_INF("unexpected" FAIL_MSG, rc);
    }

    return rc;
}