mdl_storage.c

Go to the documentation of this file.

#include "mdl_storage.h"
 
#include <stdint.h>
#include <string.h>
 
#include "mdl_hash.h"
#include "ra8_attributes.h"

typedef enum : uint32_t {
  k_storage_io_calls   = 2000001U, 
  k_storage_span_count = 4U,       
} mdl_storage_limits_t;

typedef struct internal_storage_span_t {
  uintptr_t begin; 
  uintptr_t end;   
} internal_storage_span_t;

typedef struct {
  uint64_t size_bytes;   
  uint64_t hash;         
  uint8_t* buffer;       
  uint32_t buffer_bytes; 
} staged_identity_t;

RA8_INTERNAL static ra8_err_t
internal_make_span(const void* pointer, uint32_t bytes, internal_storage_span_t* out)
{
  if ((pointer == nullptr) || (bytes == 0U)) {
    return k_ra8_err_invalid_arg;
  }
  const uintptr_t begin = (uintptr_t)pointer;
  if ((uintptr_t)bytes > (UINTPTR_MAX - begin)) {
    return k_ra8_err_invalid_size;
  }
  *out = (internal_storage_span_t){.begin = begin, .end = begin + (uintptr_t)bytes};
  return k_ra8_ok;
}

RA8_INTERNAL static bool internal_overlap(const internal_storage_span_t* left,
                                          const internal_storage_span_t* right)
{
  return (left->begin < right->end) && (right->begin < left->end);
}

RA8_INTERNAL static ra8_err_t internal_validate_spans(mdl_storage_t* storage,
                                                      void*          file_workspace,
                                                      uint32_t       file_workspace_bytes,
                                                      void*          transaction_workspace,
                                                      uint32_t       transaction_workspace_bytes,
                                                      uint8_t*       io_buffer,
                                                      uint32_t       io_buffer_bytes)
{
  internal_storage_span_t spans[k_storage_span_count] = {};
  ra8_err_t               err = internal_make_span(storage, (uint32_t)sizeof(*storage), &spans[0]);
  if (err == k_ra8_ok) {
    err = internal_make_span(file_workspace, file_workspace_bytes, &spans[1]);
  }
  if (err == k_ra8_ok) {
    err = internal_make_span(transaction_workspace, transaction_workspace_bytes, &spans[2]);
  }
  if (err == k_ra8_ok) {
    err = internal_make_span(io_buffer, io_buffer_bytes, &spans[3]);
  }
  if (err != k_ra8_ok) {
    return err;
  }
  for (uint32_t left = 0U; left < (uint32_t)k_storage_span_count; ++left) {
    for (uint32_t right = left + 1U; right < (uint32_t)k_storage_span_count; ++right) {
      if (internal_overlap(&spans[left], &spans[right])) {
        return k_ra8_err_invalid_arg;
      }
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL static bool internal_aligned(const void* pointer, uint8_t alignment)
{
  if ((pointer == nullptr) || (alignment == 0U)) {
    return false;
  }
  return ((uintptr_t)pointer & ((uintptr_t)alignment - 1U)) == 0U;
}
 
ra8_err_t mdl_storage_init(mdl_storage_t* storage,
                           const fw_fs_t* fs,
                           void*          file_workspace,
                           uint32_t       file_workspace_bytes,
                           void*          transaction_workspace,
                           uint32_t       transaction_workspace_bytes,
                           uint8_t*       io_buffer,
                           uint32_t       io_buffer_bytes)
{
  if (storage == nullptr) {
    return k_ra8_err_invalid_arg;
  }
  if ((fs == nullptr) || (file_workspace == nullptr) || (transaction_workspace == nullptr) ||
      (io_buffer == nullptr) || (io_buffer_bytes == 0U)) {
    return k_ra8_err_invalid_arg;
  }
  ra8_err_t err = internal_validate_spans(storage,
                                          file_workspace,
                                          file_workspace_bytes,
                                          transaction_workspace,
                                          transaction_workspace_bytes,
                                          io_buffer,
                                          io_buffer_bytes);
  if (err != k_ra8_ok) {
    return err;
  }
  fw_fs_caps_t caps = {};
  err               = fw_fs_get_caps(fs, &caps);
  if (err != k_ra8_ok) {
    return err;
  }
  const uint32_t required = (uint32_t)k_fw_fs_cap_namespace | (uint32_t)k_fw_fs_cap_stream |
                            (uint32_t)k_fw_fs_cap_transactions;
  if ((caps.flags & required) != required) {
    return k_ra8_err_not_supported;
  }
  if ((file_workspace_bytes < caps.file_workspace_bytes) ||
      (transaction_workspace_bytes < caps.transaction_workspace_bytes)) {
    return k_ra8_err_no_mem;
  }
  if (!internal_aligned(file_workspace, caps.file_workspace_align) ||
      !internal_aligned(transaction_workspace, caps.transaction_workspace_align)) {
    return k_ra8_err_invalid_arg;
  }
  const mdl_storage_t candidate = {.fs                          = fs,
                                   .file_workspace              = file_workspace,
                                   .transaction_workspace       = transaction_workspace,
                                   .io_buffer                   = io_buffer,
                                   .file_workspace_bytes        = file_workspace_bytes,
                                   .transaction_workspace_bytes = transaction_workspace_bytes,
                                   .io_buffer_bytes             = io_buffer_bytes};
  *storage                      = candidate;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_abort(fw_fs_transaction_t* transaction, ra8_err_t primary)
{
  if (transaction->active) {
    const ra8_err_t aborted = fw_fs_transaction_abort(transaction);
    if (aborted != k_ra8_ok) {
      return aborted;
    }
  }
  return primary;
}

RA8_INTERNAL static ra8_err_t internal_write_all(fw_fs_transaction_t* transaction,
                                                 const uint8_t*       source,
                                                 uint32_t             length,
                                                 uint32_t*            calls)
{
  uint32_t offset = 0U;
  while (offset < length) {
    if (*calls >= (uint32_t)k_storage_io_calls) {
      return k_ra8_err_invalid_size;
    }
    uint32_t        written = 0U;
    const ra8_err_t err =
      fw_fs_transaction_write(transaction, source + offset, length - offset, &written);
    ++(*calls);
    if (err != k_ra8_ok) {
      return err;
    }
    if (written == 0U) {
      return k_ra8_err_invalid_state;
    }
    offset += written;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_validate_stage(void* ctx, fw_fs_file_t* staged)
{
  if ((ctx == nullptr) || (staged == nullptr)) {
    return k_ra8_err_invalid_arg;
  }
  const staged_identity_t* const expected = (const staged_identity_t*)ctx;
  uint64_t                       size     = 0U;
  ra8_err_t                      err      = fw_fs_file_size(staged, &size);
  if (err != k_ra8_ok) {
    return err;
  }
  if (size != expected->size_bytes) {
    return k_ra8_err_invalid_size;
  }
  uint64_t hash = 0U;
  err =
    mdl_hash_stream(staged, expected->size_bytes, expected->buffer, expected->buffer_bytes, &hash);
  if (err != k_ra8_ok) {
    return err;
  }
  return (hash == expected->hash) ? k_ra8_ok : k_ra8_err_protocol_error;
}

RA8_INTERNAL static ra8_err_t internal_policy(const mdl_storage_t*        storage,
                                              const char*                 destination,
                                              fw_fs_transaction_policy_t* out)
{
  fw_fs_stat_t    stat = {};
  const ra8_err_t err  = fw_fs_stat(&storage->fs->names, destination, &stat);
  if (err != k_ra8_ok) {
    return err;
  }
  if (!stat.exists) {
    *out = k_fw_fs_txn_create_new;
    return k_ra8_ok;
  }
  if (stat.type != k_fw_fs_node_file) {
    return k_ra8_err_invalid_arg;
  }
  *out = k_fw_fs_txn_replace_atomic;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t
internal_source_size(const mdl_storage_t* storage, const char* source, uint64_t* size)
{
  fw_fs_stat_t    stat = {};
  const ra8_err_t err  = fw_fs_stat(&storage->fs->names, source, &stat);
  if (err != k_ra8_ok) {
    return err;
  }
  if (!stat.exists) {
    return k_ra8_err_not_found;
  }
  if (stat.type != k_fw_fs_node_file) {
    return k_ra8_err_invalid_arg;
  }
  if (stat.size_bytes > (uint64_t)k_mdl_hash_max_file_bytes) {
    return k_ra8_err_invalid_size;
  }
  *size = stat.size_bytes;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_begin_copy(mdl_storage_t*       storage,
                                                  const char*          source,
                                                  const char*          destination,
                                                  fw_fs_file_t*        source_file,
                                                  fw_fs_transaction_t* transaction,
                                                  uint64_t*            size)
{
  ra8_err_t                  err    = internal_source_size(storage, source, size);
  fw_fs_transaction_policy_t policy = k_fw_fs_txn_create_new;
  if (err == k_ra8_ok) {
    err = internal_policy(storage, destination, &policy);
  }
  if (err == k_ra8_ok) {
    err = fw_fs_open(&storage->fs->streams,
                     source,
                     k_fw_fs_open_read,
                     source_file,
                     storage->file_workspace,
                     storage->file_workspace_bytes);
  }
  if (err != k_ra8_ok) {
    return err;
  }
  err = fw_fs_transaction_begin(&storage->fs->transactions,
                                destination,
                                policy,
                                transaction,
                                storage->transaction_workspace,
                                storage->transaction_workspace_bytes);
  if (err != k_ra8_ok) {
    (void)fw_fs_close(source_file);
  }
  return err;
}

RA8_INTERNAL static ra8_err_t internal_copy_payload(mdl_storage_t*       storage,
                                                    fw_fs_file_t*        source,
                                                    fw_fs_transaction_t* transaction,
                                                    uint64_t             size,
                                                    uint64_t*            hash)
{
  uint64_t  remaining   = size;
  uint64_t  digest      = (uint64_t)k_mdl_fnv_offset;
  uint32_t  read_calls  = 0U;
  uint32_t  write_calls = 0U;
  ra8_err_t err         = k_ra8_ok;
  while ((remaining > 0U) && (read_calls < (uint32_t)k_storage_io_calls)) {
    const uint32_t wanted = (remaining < (uint64_t)storage->io_buffer_bytes)
                              ? (uint32_t)remaining
                              : storage->io_buffer_bytes;
    uint32_t       read   = 0U;
    err                   = fw_fs_read(source, storage->io_buffer, wanted, &read);
    ++read_calls;
    if ((err != k_ra8_ok) || (read == 0U) || ((uint64_t)read > remaining)) {
      err = (err == k_ra8_ok) ? k_ra8_fail : err;
      break;
    }
    digest = mdl_hash_bytes_seed(storage->io_buffer, read, digest);
    err    = internal_write_all(transaction, storage->io_buffer, read, &write_calls);
    if (err != k_ra8_ok) {
      break;
    }
    remaining -= read;
  }
  if ((err == k_ra8_ok) && (remaining != 0U)) {
    err = k_ra8_err_invalid_size;
  }
  uint32_t trailing = 0U;
  if (err == k_ra8_ok) {
    err = fw_fs_read(source, storage->io_buffer, 1U, &trailing);
  }
  if ((err == k_ra8_ok) && (trailing != 0U)) {
    err = k_ra8_fail;
  }
  *hash = digest;
  return err;
}
 
ra8_err_t
mdl_storage_copy_atomic(mdl_storage_t* storage, const char* source, const char* destination)
{
  if ((storage == nullptr) || (storage->fs == nullptr) || (source == nullptr) ||
      (destination == nullptr)) {
    return k_ra8_err_invalid_arg;
  }
  if (strcmp(source, destination) == 0) {
    return k_ra8_err_invalid_arg;
  }
  fw_fs_file_t        source_file = {};
  fw_fs_transaction_t transaction = {};
  uint64_t            size        = 0U;
  ra8_err_t           err =
    internal_begin_copy(storage, source, destination, &source_file, &transaction, &size);
  if (err != k_ra8_ok) {
    return err;
  }
  uint64_t hash          = 0U;
  err                    = internal_copy_payload(storage, &source_file, &transaction, size, &hash);
  const ra8_err_t closed = fw_fs_close(&source_file);
  if (err == k_ra8_ok) {
    err = closed;
  }
  if (err != k_ra8_ok) {
    return internal_abort(&transaction, err);
  }
 
  const staged_identity_t identity = {.size_bytes   = size,
                                      .hash         = hash,
                                      .buffer       = storage->io_buffer,
                                      .buffer_bytes = storage->io_buffer_bytes};
  err = fw_fs_transaction_validate(&transaction, internal_validate_stage, (void*)&identity);
  if (err != k_ra8_ok) {
    return internal_abort(&transaction, err);
  }
  bool published = false;
  err            = fw_fs_transaction_commit(&transaction, &published);
  if ((err == k_ra8_ok) && !published) {
    err = k_ra8_err_invalid_state;
  }
  return internal_abort(&transaction, err);
}

RA8_INTERNAL static ra8_err_t internal_txn_begin(mdl_storage_txn_t*         writer,
                                                 mdl_storage_t*             storage,
                                                 const char*                destination,
                                                 fw_fs_transaction_policy_t policy)
{
  if ((writer == nullptr) || (storage == nullptr) || (storage->fs == nullptr) ||
      (destination == nullptr) || writer->transaction.active ||
      ((policy != k_fw_fs_txn_create_new) && (policy != k_fw_fs_txn_replace_atomic))) {
    return k_ra8_err_invalid_arg;
  }
  fw_fs_transaction_t transaction = {};
  const ra8_err_t     err         = fw_fs_transaction_begin(&storage->fs->transactions,
                                                            destination,
                                                            policy,
                                                            &transaction,
                                                            storage->transaction_workspace,
                                                            storage->transaction_workspace_bytes);
  if (err != k_ra8_ok) {
    return err;
  }
  *writer = (mdl_storage_txn_t){.storage     = storage,
                                .transaction = transaction,
                                .size_bytes  = 0U,
                                .hash        = (uint64_t)k_mdl_fnv_offset,
                                .write_calls = 0U};
  return k_ra8_ok;
}
 
ra8_err_t
mdl_storage_txn_begin(mdl_storage_txn_t* writer, mdl_storage_t* storage, const char* destination)
{
  if ((writer == nullptr) || (storage == nullptr) || (storage->fs == nullptr) ||
      (destination == nullptr) || writer->transaction.active) {
    return k_ra8_err_invalid_arg;
  }
  fw_fs_transaction_policy_t policy = k_fw_fs_txn_create_new;
  const ra8_err_t            err    = internal_policy(storage, destination, &policy);
  return (err == k_ra8_ok) ? internal_txn_begin(writer, storage, destination, policy) : err;
}
 
ra8_err_t mdl_storage_txn_begin_new(mdl_storage_txn_t* writer,
                                    mdl_storage_t*     storage,
                                    const char*        destination)
{
  return internal_txn_begin(writer, storage, destination, k_fw_fs_txn_create_new);
}
 
ra8_err_t mdl_storage_txn_write(mdl_storage_txn_t* writer, const uint8_t* bytes, uint32_t length)
{
  if ((writer == nullptr) || (writer->storage == nullptr) || !writer->transaction.active ||
      ((bytes == nullptr) && (length != 0U))) {
    return k_ra8_err_invalid_arg;
  }
  if ((uint64_t)length > ((uint64_t)k_mdl_hash_max_file_bytes - writer->size_bytes)) {
    return k_ra8_err_invalid_size;
  }
  uint32_t offset = 0U;
  while (offset < length) {
    if (writer->write_calls >= (uint32_t)k_storage_io_calls) {
      return k_ra8_err_invalid_size;
    }
    uint32_t        written = 0U;
    const ra8_err_t err =
      fw_fs_transaction_write(&writer->transaction, bytes + offset, length - offset, &written);
    ++writer->write_calls;
    if (err != k_ra8_ok) {
      return err;
    }
    if (written == 0U) {
      return k_ra8_err_invalid_state;
    }
    writer->hash = mdl_hash_bytes_seed(bytes + offset, (size_t)written, writer->hash);
    writer->size_bytes += (uint64_t)written;
    offset += written;
  }
  return k_ra8_ok;
}
 
ra8_err_t mdl_storage_txn_abort(mdl_storage_txn_t* writer)
{
  if (writer == nullptr) {
    return k_ra8_err_invalid_arg;
  }
  if (writer->transaction.active) {
    const ra8_err_t err = fw_fs_transaction_abort(&writer->transaction);
    if (err != k_ra8_ok) {
      return err;
    }
  }
  *writer = (mdl_storage_txn_t){};
  return k_ra8_ok;
}
 
ra8_err_t mdl_storage_txn_commit(mdl_storage_txn_t* writer)
{
  if ((writer == nullptr) || (writer->storage == nullptr) || !writer->transaction.active) {
    return k_ra8_err_invalid_arg;
  }
  const staged_identity_t identity = {.size_bytes   = writer->size_bytes,
                                      .hash         = writer->hash,
                                      .buffer       = writer->storage->io_buffer,
                                      .buffer_bytes = writer->storage->io_buffer_bytes};
  ra8_err_t               err =
    fw_fs_transaction_validate(&writer->transaction, internal_validate_stage, (void*)&identity);
  if (err == k_ra8_ok) {
    bool published = false;
    err            = fw_fs_transaction_commit(&writer->transaction, &published);
    if ((err == k_ra8_ok) && !published) {
      err = k_ra8_err_invalid_state;
    }
  }
  if (err != k_ra8_ok) {
    const ra8_err_t aborted = mdl_storage_txn_abort(writer);
    return (aborted == k_ra8_ok) ? err : aborted;
  }
  *writer = (mdl_storage_txn_t){};
  return k_ra8_ok;
}