sh_paged.c

Go to the documentation of this file.

#include <string.h>
 
#include "book_chunked.h"
#include "ra8_check.h"
#include "ra8_vmem.h"
#include "ra8_vsource.h"
#include "sh_app.h"

typedef enum : uint32_t {
  k_shp_frame_bytes   = 64U * 1024U, 
  k_shp_frame_count   = 384U,        
  k_shp_bucket_count  = 512U,        
  k_shp_table_entries = 1025U,       
  k_shp_staging_bytes = 72U * 1024U, 
} sh_paged_dim_t;

[[gnu::section(".sdram_data"),
  gnu::aligned(8)]] static uint8_t s_shp_frames[k_shp_frame_count * k_shp_frame_bytes];

[[gnu::section(".sdram_data"), gnu::aligned(8)]] static uint8_t s_shp_staging[k_shp_staging_bytes];

static uint64_t s_shp_table[k_shp_table_entries];

static ra8_vmem_frame_t s_shp_meta[k_shp_frame_count];

static ra8_vmem_key_t s_shp_keys[k_shp_frame_count];

static int32_t s_shp_buckets[k_shp_bucket_count];

static book_chunked_t s_shp_rd;

static ra8_vsource_obj_t s_shp_obj;

static ra8_vsource_t s_shp_vs;

static ra8_vmem_t s_shp_vm;

typedef struct {
  const uint8_t* data; 
  uint64_t       len;  
} sh_paged_mram_t;

static sh_paged_mram_t s_shp_mram;

static const char* const s_shp_tag = "sh_paged";

/* cppcheck-suppress constParameterCallback -- ra8_vsource_read_fn fixes this callback's context type as void*. */
static ra8_err_t sh_paged_mram_read(void* ctx, uint64_t offset, uint8_t* buf, uint32_t len)
{
  RA8_CHECK_NULL_PTR(ctx, s_shp_tag, "mram: null ctx");
  RA8_CHECK_NULL_PTR(buf, s_shp_tag, "mram: null buf");
  const sh_paged_mram_t* m = (const sh_paged_mram_t*)ctx;
  if ((offset + (uint64_t)len) > m->len) {
    return k_ra8_err_out_of_range;
  }
  (void)memcpy(buf, &m->data[offset], (size_t)len);
  return k_ra8_ok;
}

static bool sh_paged_extent_ok(uint32_t off, uint32_t count, uint32_t elem, uint32_t total)
{
  const uint64_t end = (uint64_t)off + ((uint64_t)count * (uint64_t)elem);
  if (off > total) {
    return false;
  }
  return end <= (uint64_t)total;
}

static bool sh_paged_hdr_ok(const book_header_t* hdr, uint64_t inflated_total)
{
  const char k_magic[8] = {'R', 'A', 'B', 'O', 'O', 'K', '1', '\0'};
  if (memcmp(hdr->magic, k_magic, sizeof k_magic) != 0) {
    return false;
  }
  if (hdr->format_version != (uint32_t)k_book_format_version) {
    return false;
  }
  if ((uint64_t)hdr->total_size != inflated_total) {
    return false;
  }
  if (hdr->total_size < (uint32_t)sizeof(book_header_t)) {
    return false;
  }
  const struct {
    uint32_t off;   
    uint32_t count; 
    uint32_t elem;  
  } k_ext[] = {
    {hdr->chapter_off, hdr->chapter_count, (uint32_t)sizeof(book_chapter_t)},
    {hdr->node_off, hdr->node_count, (uint32_t)sizeof(book_node_t)},
    {hdr->attr_off, hdr->attr_count, (uint32_t)sizeof(book_attr_t)},
    {hdr->stylesheet_off, hdr->stylesheet_count, (uint32_t)sizeof(book_stylesheet_t)},
    {hdr->image_off, hdr->image_count, (uint32_t)sizeof(book_image_t)},
    {hdr->string_off, hdr->string_size, 1U},
    {hdr->image_pool_off, hdr->image_pool_size, 1U},
  };
  for (size_t i = 0U; i < (sizeof(k_ext) / sizeof(k_ext[0])); ++i) {
    if (!sh_paged_extent_ok(k_ext[i].off, k_ext[i].count, k_ext[i].elem, hdr->total_size)) {
      return false;
    }
  }
  return true;
}

static bool sh_paged_bind(void)
{
  if (ra8_vsource_init(&s_shp_vs, &s_shp_obj, 1U) != k_ra8_ok) {
    return false;
  }
  uint32_t oid = 0U;
  if (ra8_vsource_add_paged(&s_shp_vs,
                            book_chunked_read,
                            &s_shp_rd,
                            0U,
                            s_shp_rd.inflated_total,
                            &oid) != k_ra8_ok) {
    return false;
  }
  const ra8_vmem_cfg_t cfg = {
    .frame_mem    = s_shp_frames,
    .frame_bytes  = (uint32_t)k_shp_frame_bytes,
    .frame_count  = (uint32_t)k_shp_frame_count,
    .meta         = s_shp_meta,
    .keys         = s_shp_keys,
    .buckets      = s_shp_buckets,
    .bucket_count = (uint32_t)k_shp_bucket_count,
    .loader       = ra8_vsource_loader,
    .loader_ctx   = &s_shp_vs,
  };
  s_shp_vm = (ra8_vmem_t){};
  if (ra8_vmem_init(&s_shp_vm, &cfg) != k_ra8_ok) {
    return false;
  }
  /* Binding reads the 100-byte header through the cache (faults chunk 0 in). */
  if (book_src_paged(&g_sh.book_src,
                     &s_shp_vm,
                     oid,
                     (uint32_t)k_shp_frame_bytes,
                     (uint32_t)s_shp_rd.inflated_total) != k_ra8_ok) {
    return false;
  }
  return sh_paged_hdr_ok(&g_sh.book_src.hdr, s_shp_rd.inflated_total);
}
 
bool sh_paged_open(ra8_vsource_read_fn file_read, void* file_ctx, uint64_t file_len)
{
  /* Unbind any previous source, but do NOT sh_paged_close() here: the caller
   * has already torn the old book down (sh_book_open), and a full close would
   * wipe the MRAM context / close the SD file that @p file_read is about to
   * read from. The failure paths below do close, releasing the SD backing. */
  g_sh.book_src = (book_src_t){};
  s_shp_rd      = (book_chunked_t){};
  if ((file_read == nullptr) || (file_len == 0U)) {
    sh_paged_close();
    return false;
  }
  if (book_chunked_open(&s_shp_rd,
                        file_read,
                        file_ctx,
                        file_len,
                        sh_inflate,
                        s_shp_table,
                        (uint32_t)k_shp_table_entries,
                        s_shp_staging,
                        (uint32_t)k_shp_staging_bytes) != k_ra8_ok) {
    sh_paged_close();
    return false;
  }
  /* One chunk == one cache frame: the read callback's contract. A container
   * compiled with a different --chunk-bytes cannot be paged through this
   * cache, so reject it here instead of failing obscurely per read. */
  if (s_shp_rd.chunk_bytes != (uint32_t)k_shp_frame_bytes) {
    sh_paged_close();
    return false;
  }
  /* book_src_t carries a uint32 size; the table budget already caps books
   * at 64 MiB, so this guard is belt-and-braces against a lying header. */
  if (s_shp_rd.inflated_total > (uint64_t)UINT32_MAX) {
    sh_paged_close();
    return false;
  }
  if (!sh_paged_bind()) {
    sh_paged_close();
    return false;
  }
  return true;
}
 
bool sh_paged_open_mram(const uint8_t* blob, uint32_t blob_len)
{
  if (blob == nullptr) {
    return false;
  }
  if (blob_len == 0U) {
    return false;
  }
  s_shp_mram = (sh_paged_mram_t){.data = blob, .len = (uint64_t)blob_len};
  return sh_paged_open(sh_paged_mram_read, &s_shp_mram, (uint64_t)blob_len);
}
 
void sh_paged_close(void)
{
  g_sh.book_src = (book_src_t){};
  s_shp_rd      = (book_chunked_t){};
  s_shp_mram    = (sh_paged_mram_t){};
  sh_sd_book_close(); /* release the held SD file handle, if any */
}