ra8_io_roundtrip.c

Go to the documentation of this file.

 
#include "ra8_io_roundtrip.h"
 
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"

typedef enum : uint32_t {
  k_ra8_io_roundtrip_max_payload = 512U, 
  k_ra8_io_roundtrip_seed_mul    = 7U,   
  k_ra8_io_roundtrip_seed_add    = 1U,   
  k_ra8_io_roundtrip_note_base   = 65U,  
  k_ra8_io_roundtrip_note_mod    = 26U,  
} ra8_io_roundtrip_const_t;

static uint8_t s_payload[k_ra8_io_roundtrip_max_payload];
static uint8_t s_readback[k_ra8_io_roundtrip_max_payload];

RA8_INTERNAL static void internal_ra8_io_roundtrip_fill_linear(uint32_t len)
{
  for (uint32_t i = 0U; i < len; ++i) {
    s_payload[i] = (uint8_t)((i * (uint32_t)k_ra8_io_roundtrip_seed_mul) +
                             (uint32_t)k_ra8_io_roundtrip_seed_add);
  }
}

RA8_INTERNAL static void internal_ra8_io_roundtrip_fill_alpha(uint32_t len)
{
  for (uint32_t i = 0U; i < len; ++i) {
    s_payload[i] = (uint8_t)((uint32_t)k_ra8_io_roundtrip_note_base +
                             (i % (uint32_t)k_ra8_io_roundtrip_note_mod));
  }
}

RA8_INTERNAL static ra8_err_t
internal_ra8_io_roundtrip_read_verify(const char* path, uint32_t len, const char* tag)
{
  ra8_fs_file_t* rf = nullptr;
  RA8_RETURN_ON_ERROR(ra8_io_vfs_open(path, k_ra8_fs_mode_read, &rf), tag, "open r");
  memset(s_readback, 0, sizeof(s_readback));
  uint32_t  got = 0U;
  ra8_err_t err = ra8_fs_read(rf, s_readback, len, &got);
  (void)ra8_fs_close(rf);
  if (err != k_ra8_ok) {
    return err;
  }
  if (got != len) {
    return k_ra8_err_invalid_size;
  }
  if (memcmp(s_payload, s_readback, (size_t)len) != 0) {
    return k_ra8_err_checksum_mismatch;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t
internal_ra8_io_roundtrip_mount_check(const ra8_io_blockdev_t*         bd,
                                      const ra8_io_roundtrip_params_t* p,
                                      const ra8_fs_backend_t*          be,
                                      ra8_fs_mount_t**                 out_mount)
{
  RA8_CHECK_NULL_PTR(bd, "ra8_io_roundtrip", "bd");
  RA8_CHECK_NULL_PTR(p, "ra8_io_roundtrip", "params");
  RA8_CHECK_NULL_PTR(be, "ra8_io_roundtrip", "backend");
  RA8_CHECK_NULL_PTR(out_mount, "ra8_io_roundtrip", "out_mount");
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t
internal_ra8_io_roundtrip_format_mount(ra8_fs_backend_t*                be,
                                       const ra8_io_roundtrip_params_t* p,
                                       ra8_fs_mount_t**                 out_mount)
{
  ra8_fs_format_opts_t opts = {};
  opts.type                 = p->fat_type;
  opts.label                = p->volume_label;
  RA8_RETURN_ON_ERROR(ra8_fs_format(be, &opts), p->log_tag, "format");
  ra8_fs_mount_t* mnt = nullptr;
  RA8_RETURN_ON_ERROR(ra8_fs_mount(be, &mnt), p->log_tag, "mount");
  RA8_RETURN_ON_ERROR(ra8_io_vfs_mount(p->vfs_prefix, mnt), p->log_tag, "vfs mount");
  *out_mount = mnt;
  return k_ra8_ok;
}
 
ra8_err_t ra8_io_roundtrip_mount(ra8_io_blockdev_t*               bd,
                                 const ra8_io_roundtrip_params_t* p,
                                 ra8_fs_backend_t*                be,
                                 ra8_fs_mount_t**                 out_mount)
{
  RA8_RETURN_ON_ERROR(internal_ra8_io_roundtrip_mount_check(bd, p, be, out_mount),
                      "ra8_io_roundtrip",
                      "args");
  *out_mount = nullptr;
 
  RA8_RETURN_ON_ERROR(ra8_io_blockdev_as_fs_backend(bd, be), p->log_tag, "fs bridge");
  return internal_ra8_io_roundtrip_format_mount(be, p, out_mount);
}
 
ra8_err_t ra8_io_roundtrip_root_file(ra8_fs_mount_t* mnt, const ra8_io_roundtrip_params_t* p)
{
  RA8_CHECK_NULL_PTR(mnt, "ra8_io_roundtrip", "mnt");
  RA8_CHECK_NULL_PTR(p, "ra8_io_roundtrip", "params");
  if (p->root_bytes > (uint32_t)k_ra8_io_roundtrip_max_payload) {
    return k_ra8_err_invalid_size;
  }
 
  internal_ra8_io_roundtrip_fill_linear(p->root_bytes);
  RA8_RETURN_ON_ERROR(ra8_fs_write_file(mnt, p->root_file, s_payload, p->root_bytes),
                      p->log_tag,
                      "write");
  return internal_ra8_io_roundtrip_read_verify(p->root_path, p->root_bytes, p->log_tag);
}

RA8_INTERNAL static ra8_err_t
internal_ra8_io_roundtrip_write_subdir(const ra8_io_roundtrip_params_t* p)
{
  ra8_fs_file_t* wf = nullptr;
  RA8_RETURN_ON_ERROR(ra8_io_vfs_open(p->subdir_file, k_ra8_fs_mode_write, &wf),
                      p->log_tag,
                      "open w");
  ra8_err_t werr = ra8_fs_write(wf, s_payload, p->subdir_bytes);
  RA8_RETURN_ON_ERROR(ra8_fs_close(wf), p->log_tag, "close w");
  RA8_RETURN_ON_ERROR(werr, p->log_tag, "write");
  return k_ra8_ok;
}
 
ra8_err_t ra8_io_roundtrip_subdir_file(const ra8_io_roundtrip_params_t* p)
{
  RA8_CHECK_NULL_PTR(p, "ra8_io_roundtrip", "params");
  if (p->subdir_bytes > (uint32_t)k_ra8_io_roundtrip_max_payload) {
    return k_ra8_err_invalid_size;
  }
 
  RA8_RETURN_ON_ERROR(ra8_io_vfs_mkdir(p->subdir_path), p->log_tag, "mkdir");
  internal_ra8_io_roundtrip_fill_alpha(p->subdir_bytes);
  RA8_RETURN_ON_ERROR(internal_ra8_io_roundtrip_write_subdir(p), p->log_tag, "subdir write");
 
  return internal_ra8_io_roundtrip_read_verify(p->subdir_file, p->subdir_bytes, p->log_tag);
}