ra8_cache_store.c

Go to the documentation of this file.

 
#include "ra8_cache_store.h"
 
#include <stdint.h>
#include <string.h>
 
#include "lx_api.h"
#include "ra8_cache_store_internal.h"
#include "ra8_check.h"
#include "ra8_err.h"

static const char* const s_tag = "ra8_cache_store";

typedef enum : uint32_t {
  k_ra8_cs_max_run = 0xFFFFU, 
} ra8_cs_rt_const_t;
 
/* ------------------------------------------------------------------------- */
/* Allocation + append helpers */
/* ------------------------------------------------------------------------- */

RA8_INTERNAL static uint16_t internal_index_used(const ra8_cache_store_t* store)
{
  if (store == nullptr) {
    return 0U;
  }
  if (store->index == nullptr) {
    return 0U;
  }
  uint16_t used = 0U;
  for (uint16_t i = 0U; i < store->index_cap; i++) {
    if ((store->index[i].flags & (uint8_t)k_ra8_cache_store_flag_in_use) != 0U) {
      used++;
    }
  }
  return used;
}

RA8_INTERNAL static bool
internal_run_free(const ra8_cache_store_t* store, uint32_t start, uint32_t count)
{
  if (store == nullptr) {
    return false;
  }
  if (store->index == nullptr) {
    return false;
  }
  uint32_t end = start + count;
  for (uint16_t i = 0U; i < store->index_cap; i++) {
    const ra8_cache_store_entry_t* e = &store->index[i];
    if ((e->flags & (uint8_t)k_ra8_cache_store_flag_in_use) == 0U) {
      continue;
    }
    uint32_t es = e->start_sector;
    uint32_t ee = es + e->sector_count;
    if (start < ee) {
      if (es < end) {
        return false;
      }
    }
  }
  return true;
}

RA8_INTERNAL static ra8_err_t
internal_alloc_run(const ra8_cache_store_t* store, uint32_t count, uint32_t* out_start)
{
  RA8_CHECK_NULL_PTR(store, s_tag, "store");
  RA8_CHECK_NULL_PTR(out_start, s_tag, "out_start");
  if (count == 0U) {
    return k_ra8_err_invalid_size;
  }
  for (uint32_t start = store->log_start; (start + count) <= store->logical_sectors; start++) {
    if (internal_run_free(store, start, count)) {
      *out_start = start;
      return k_ra8_ok;
    }
  }
  return k_ra8_err_no_mem;
}

RA8_INTERNAL static ra8_err_t internal_write_entry(ra8_cache_store_t* store,
                                                   uint32_t           start,
                                                   uint32_t           seq,
                                                   uint32_t           key,
                                                   const uint8_t*     data,
                                                   uint32_t           len,
                                                   uint16_t           count)
{
  RA8_CHECK_NULL_PTR(store, s_tag, "store");
  RA8_CHECK_NULL_PTR(data, s_tag, "data");
  uint16_t       data_sectors = (uint16_t)(count - 1U);
  uint32_t       off          = 0U;
  const uint32_t sec_sz       = (uint32_t)k_ra8_cache_store_sector_bytes;
  for (uint16_t i = 0U; i < data_sectors; i++) {
    uint32_t remain = len - off;
    uint32_t chunk  = (remain < sec_sz) ? remain : sec_sz;
    (void)memset(store->staging, 0, (size_t)sec_sz);
    (void)memcpy(store->staging, &data[off], (size_t)chunk);
    RA8_RETURN_ON_ERROR(
      priv_cache_store_sector_write(store, start + 1U + (uint32_t)i, store->staging),
      s_tag,
      "payload");
    off += chunk;
  }
  ra8_cs_entry_hdr_t h = {.magic        = (uint32_t)k_ra8_cs_entry_magic,
                          .seq          = seq,
                          .key          = key,
                          .byte_len     = len,
                          .start_sector = start,
                          .sector_count = count,
                          .flags        = 0U,
                          .hdr_crc      = 0U};
  h.hdr_crc = priv_cache_store_crc32((const uint8_t*)&h, (uint32_t)(sizeof(h) - sizeof(h.hdr_crc)));
  (void)memset(store->staging, 0, (size_t)sec_sz);
  (void)memcpy(store->staging, &h, sizeof(h));
  return priv_cache_store_sector_write(store, start, store->staging);
}

RA8_INTERNAL static ra8_err_t internal_mark_dirty(ra8_cache_store_t* store)
{
  RA8_CHECK_NULL_PTR(store, s_tag, "store");
  RA8_VALIDATE_INIT(store->inited, s_tag, "store");
  if (store->flash_state == (uint8_t)k_ra8_cs_dirty) {
    return k_ra8_ok;
  }
  RA8_RETURN_ON_ERROR(priv_cache_store_super_write(store, (uint32_t)k_ra8_cs_dirty),
                      s_tag,
                      "mark dirty");
  store->flash_state = (uint8_t)k_ra8_cs_dirty;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_checkpoint(ra8_cache_store_t* store)
{
  RA8_CHECK_NULL_PTR(store, s_tag, "store");
  RA8_VALIDATE_INIT(store->inited, s_tag, "store");
  RA8_RETURN_ON_ERROR(internal_mark_dirty(store), s_tag, "pre-dirty");
  uint32_t count = 0U;
  RA8_RETURN_ON_ERROR(priv_cache_store_dir_save(store, &count), s_tag, "dir save");
  RA8_RETURN_ON_ERROR(priv_cache_store_super_write(store, (uint32_t)k_ra8_cs_clean),
                      s_tag,
                      "clean super");
  store->flash_state = (uint8_t)k_ra8_cs_clean;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_put_check(const ra8_cache_store_t* store,
                                                 uint32_t                 key,
                                                 const uint8_t*           data,
                                                 uint32_t                 len,
                                                 uint32_t*                out_count)
{
  RA8_CHECK_NULL_PTR(store, s_tag, "store");
  RA8_CHECK_NULL_PTR(data, s_tag, "data");
  RA8_VALIDATE_INIT(store->inited, s_tag, "store");
  if (len == 0U) {
    return k_ra8_err_invalid_size;
  }
  if (priv_cache_store_index_find(store, key) >= 0) {
    return k_ra8_err_exists;
  }
  if (internal_index_used(store) >= store->index_cap) {
    return k_ra8_err_no_mem;
  }
  const uint32_t sec_sz = (uint32_t)k_ra8_cache_store_sector_bytes;
  uint32_t       count  = 1U + ((len + (sec_sz - 1U)) / sec_sz);
  if (count > (uint32_t)k_ra8_cs_max_run) {
    return k_ra8_err_invalid_size;
  }
  if ((store->live_sectors + count) > store->data_capacity) {
    return k_ra8_err_no_mem;
  }
  *out_count = count;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_read_at(const ra8_cache_store_t* store,
                                               uint32_t                 data_start,
                                               uint64_t                 byte_pos,
                                               uint8_t*                 dst,
                                               uint32_t                 max,
                                               uint32_t*                out_copied)
{
  RA8_CHECK_NULL_PTR(store, s_tag, "store");
  RA8_CHECK_NULL_PTR(dst, s_tag, "dst");
  const uint32_t sec_sz = (uint32_t)k_ra8_cache_store_sector_bytes;
  uint32_t       sector = data_start + (uint32_t)(byte_pos / sec_sz);
  uint32_t       soff   = (uint32_t)(byte_pos % sec_sz);
  uint32_t       space  = sec_sz - soff;
  uint32_t       chunk  = (max < space) ? max : space;
  RA8_RETURN_ON_ERROR(priv_cache_store_sector_read(store, sector, store->staging), s_tag, "read");
  (void)memcpy(dst, &store->staging[soff], (size_t)chunk);
  *out_copied = chunk;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t
internal_release_run(ra8_cache_store_t* store, uint32_t start, uint16_t count)
{
  RA8_CHECK_NULL_PTR(store, s_tag, "store");
  RA8_VALIDATE_INIT(store->inited, s_tag, "store");
  for (uint16_t i = 0U; i < count; i++) {
    RA8_RETURN_ON_ERROR(priv_cache_store_sector_release(store, start + (uint32_t)i),
                        s_tag,
                        "release");
  }
  return k_ra8_ok;
}
 
/* ------------------------------------------------------------------------- */
/* Public API */
/* ------------------------------------------------------------------------- */
 
ra8_err_t
ra8_cache_store_put(ra8_cache_store_t* store, uint32_t key, const uint8_t* data, uint32_t len)
{
  uint32_t count = 0U;
  RA8_RETURN_ON_ERROR(internal_put_check(store, key, data, len, &count), s_tag, "check");
  RA8_RETURN_ON_ERROR(internal_mark_dirty(store), s_tag, "dirty");
  uint32_t start = 0U;
  RA8_RETURN_ON_ERROR(internal_alloc_run(store, count, &start), s_tag, "alloc");
  RA8_RETURN_ON_ERROR(
    internal_write_entry(store, start, store->next_seq, key, data, len, (uint16_t)count),
    s_tag,
    "write");
  (void)priv_cache_store_index_add(store, key, start, (uint16_t)count, len, false);
  store->live_sectors += count;
  store->next_seq += 1U;
  return k_ra8_ok;
}
 
ra8_err_t ra8_cache_store_get(const ra8_cache_store_t*  store,
                              uint32_t                  key,
                              ra8_cache_store_reader_t* out_reader)
{
  RA8_CHECK_NULL_PTR(store, s_tag, "store");
  RA8_CHECK_NULL_PTR(out_reader, s_tag, "out_reader");
  RA8_VALIDATE_INIT(store->inited, s_tag, "store");
  int32_t slot = priv_cache_store_index_find(store, key);
  if (slot < 0) {
    return k_ra8_err_not_found;
  }
  const ra8_cache_store_entry_t* e = &store->index[slot];
  *out_reader = (ra8_cache_store_reader_t){.store        = store,
                                           .data_start   = e->start_sector + 1U,
                                           .data_sectors = (uint32_t)e->sector_count - 1U,
                                           .byte_len     = e->byte_len};
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_read_stream(const ra8_cache_store_t* store,
                                                   uint32_t                 data_start,
                                                   uint32_t                 data_sectors,
                                                   uint64_t                 offset,
                                                   uint8_t*                 buf,
                                                   uint32_t                 len)
{
  RA8_CHECK_NULL_PTR(store, s_tag, "store");
  RA8_CHECK_NULL_PTR(buf, s_tag, "buf");
  uint32_t done     = 0U;
  uint32_t max_iter = data_sectors + 1U;
  for (uint32_t g = 0U; g <= max_iter; g++) {
    if (done >= len) {
      break;
    }
    uint32_t copied = 0U;
    RA8_RETURN_ON_ERROR(
      internal_read_at(store, data_start, offset + (uint64_t)done, &buf[done], len - done, &copied),
      s_tag,
      "at");
    done += copied;
  }
  return k_ra8_ok;
}
 
ra8_err_t ra8_cache_store_read(void* ctx, uint64_t offset, uint8_t* buf, uint32_t len)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx");
  RA8_CHECK_NULL_PTR(buf, s_tag, "buf");
  const ra8_cache_store_reader_t* r     = (const ra8_cache_store_reader_t*)ctx;
  const ra8_cache_store_t*        store = r->store;
  RA8_CHECK_NULL_PTR(store, s_tag, "reader store");
  if ((offset + (uint64_t)len) > (uint64_t)r->byte_len) {
    return k_ra8_err_out_of_range;
  }
  return internal_read_stream(store, r->data_start, r->data_sectors, offset, buf, len);
}
 
ra8_err_t ra8_cache_store_evict(ra8_cache_store_t* store, uint32_t key)
{
  RA8_CHECK_NULL_PTR(store, s_tag, "store");
  RA8_VALIDATE_INIT(store->inited, s_tag, "store");
  int32_t slot = priv_cache_store_index_find(store, key);
  if (slot < 0) {
    return k_ra8_err_not_found;
  }
  ra8_cache_store_entry_t* e = &store->index[slot];
  if ((e->flags & (uint8_t)k_ra8_cache_store_flag_pinned) != 0U) {
    return k_ra8_err_busy;
  }
  RA8_RETURN_ON_ERROR(internal_mark_dirty(store), s_tag, "dirty");
  RA8_RETURN_ON_ERROR(internal_release_run(store, e->start_sector, e->sector_count),
                      s_tag,
                      "release");
  store->live_sectors -= e->sector_count;
  *e = (ra8_cache_store_entry_t){};
  return k_ra8_ok;
}
 
ra8_err_t ra8_cache_store_pin(ra8_cache_store_t* store, uint32_t key, bool pin)
{
  RA8_CHECK_NULL_PTR(store, s_tag, "store");
  RA8_VALIDATE_INIT(store->inited, s_tag, "store");
  int32_t slot = priv_cache_store_index_find(store, key);
  if (slot < 0) {
    return k_ra8_err_not_found;
  }
  RA8_RETURN_ON_ERROR(internal_mark_dirty(store), s_tag, "dirty");
  ra8_cache_store_entry_t* e = &store->index[slot];
  if (pin) {
    e->flags |= (uint8_t)k_ra8_cache_store_flag_pinned;
  } else {
    e->flags &= (uint8_t)~(uint8_t)k_ra8_cache_store_flag_pinned;
  }
  return k_ra8_ok;
}
 
ra8_err_t ra8_cache_store_sync(ra8_cache_store_t* store)
{
  RA8_CHECK_NULL_PTR(store, s_tag, "store");
  RA8_VALIDATE_INIT(store->inited, s_tag, "store");
  return internal_checkpoint(store);
}
 
ra8_err_t ra8_cache_store_close(ra8_cache_store_t* store)
{
  RA8_CHECK_NULL_PTR(store, s_tag, "store");
  RA8_VALIDATE_INIT(store->inited, s_tag, "store");
  RA8_RETURN_ON_ERROR(internal_checkpoint(store), s_tag, "checkpoint");
  (void)lx_nor_flash_close(store->flash);
  store->inited = false;
  return k_ra8_ok;
}