ra8_io_vfs.c

Go to the documentation of this file.

 
#include "ra8_io_vfs.h"
 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_fs.h"
#include "ra8_io_fsfmt.h"
#include "ra8_io_vfs_internal.h"

static const char* const s_tag = "ra8_io_vfs";

struct ra8_io_vfs_file {
  const ra8_io_fsfmt_t* format;      
  void*                 file_ctx;    
  uint8_t               mount_index; 
  bool                  in_use;      
};

static vfs_slot_t s_table[(uint32_t)k_ra8_io_vfs_max_mounts];
static ra8_io_vfs_file_t s_files[(uint32_t)k_ra8_io_vfs_max_files];
 
RA8_PRIV bool priv_ra8_io_vfs_streq(const char* a, const char* b)
{
  for (uint32_t i = 0U; i < (uint32_t)k_ra8_io_vfs_name_max; ++i) {
    if (a[i] != b[i]) {
      return false;
    }
    if (a[i] == '\0') {
      return true;
    }
  }
  return true;
}

RA8_INTERNAL
static bool internal_name_ok(const char* name)
{
  uint32_t i = 0U;
  for (i = 0U; i < (uint32_t)k_ra8_io_vfs_name_max; ++i) {
    const char c = name[i];
    if (c == '\0') {
      break;
    }
    if (c == ':') {
      return false;
    }
    if (c == '/') {
      return false;
    }
  }
  if (i == 0U) {
    return false;
  }
  return i < (uint32_t)k_ra8_io_vfs_name_max;
}

RA8_INTERNAL
static void internal_copy_name(char* dst, const char* src)
{
  uint32_t i = 0U;
  for (i = 0U; i < (uint32_t)k_ra8_io_vfs_name_max - 1U; ++i) {
    dst[i] = src[i];
    if (src[i] == '\0') {
      return;
    }
  }
  dst[i] = '\0';
}
 
RA8_PRIV vfs_slot_t* priv_ra8_io_vfs_find(const char* name, uint8_t* out_index)
{
  for (uint32_t i = 0U; i < (uint32_t)k_ra8_io_vfs_max_mounts; ++i) {
    if (!s_table[i].in_use) {
      continue;
    }
    if (priv_ra8_io_vfs_streq(s_table[i].name, name)) {
      if (out_index != nullptr) {
        *out_index = (uint8_t)i;
      }
      return &s_table[i];
    }
  }
  return nullptr;
}

RA8_INTERNAL
static vfs_slot_t* internal_free_mount(void)
{
  for (uint32_t i = 0U; i < (uint32_t)k_ra8_io_vfs_max_mounts; ++i) {
    if (!s_table[i].in_use) {
      return &s_table[i];
    }
  }
  return nullptr;
}
 
RA8_PRIV ra8_err_t priv_ra8_io_vfs_split(const char* path, char* out_name, const char** out_sub)
{
  uint32_t i = 0U;
  for (i = 0U; i < (uint32_t)k_ra8_io_vfs_name_max; ++i) {
    const char c = path[i];
    if (c == '\0') {
      return k_ra8_err_invalid_arg;
    }
    if (c == ':') {
      break;
    }
    out_name[i] = c;
  }
  if (i >= (uint32_t)k_ra8_io_vfs_name_max) {
    return k_ra8_err_invalid_arg;
  }
  out_name[i] = '\0';
  *out_sub    = &path[i + 1U];
  return k_ra8_ok;
}
 
RA8_PRIV ra8_err_t priv_ra8_io_vfs_resolve(const char*  path,
                                           vfs_slot_t** out_slot,
                                           uint8_t*     out_index,
                                           const char** out_sub)
{
  char            name[(uint32_t)k_ra8_io_vfs_name_max];
  const ra8_err_t e = priv_ra8_io_vfs_split(path, name, out_sub);
  if (e != k_ra8_ok) {
    return e;
  }
  vfs_slot_t* slot = priv_ra8_io_vfs_find(name, out_index);
  if (slot == nullptr) {
    return k_ra8_err_not_found;
  }
  *out_slot = slot;
  return k_ra8_ok;
}

RA8_INTERNAL
static bool internal_is_native(const ra8_io_fsfmt_t* format)
{
  const ra8_io_fsfmt_t* native = nullptr;
  (void)ra8_io_fsfmt_get_builtin(k_ra8_fs_type_fat16, &native);
  if (format == native) {
    return true;
  }
  (void)ra8_io_fsfmt_get_builtin(k_ra8_fs_type_exfat, &native);
  return format == native;
}

RA8_INTERNAL
static void internal_store_mount(vfs_slot_t*           slot,
                                 const char*           name,
                                 const ra8_io_fsfmt_t* format,
                                 void*                 mount_ctx,
                                 bool                  owned)
{
  internal_copy_name(slot->name, name);
  slot->format    = format;
  slot->mount_ctx = mount_ctx;
  slot->owned     = owned;
  slot->native    = internal_is_native(format);
  slot->in_use    = true;
}

RA8_INTERNAL
static bool internal_mode_valid(ra8_fs_mode_t mode)
{
  if (mode == k_ra8_fs_mode_read) {
    return true;
  }
  if (mode == k_ra8_fs_mode_write) {
    return true;
  }
  return mode == k_ra8_fs_mode_append;
}

RA8_INTERNAL
static ra8_err_t internal_can_open(const ra8_io_fsfmt_t* format, ra8_fs_mode_t mode)
{
  if (!internal_mode_valid(mode)) {
    return k_ra8_err_invalid_arg;
  }
  if (mode == k_ra8_fs_mode_read) {
    return k_ra8_ok;
  }
  if (format->caps.read_only) {
    return k_ra8_err_not_supported;
  }
  if (!format->caps.supports_streaming_write) {
    return k_ra8_err_not_supported;
  }
  if (format->ops->write == nullptr) {
    return k_ra8_err_not_supported;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_io_vfs_file_t* internal_free_file(void)
{
  for (uint32_t i = 0U; i < (uint32_t)k_ra8_io_vfs_max_files; ++i) {
    if (!s_files[i].in_use) {
      return &s_files[i];
    }
  }
  return nullptr;
}

RA8_INTERNAL
static bool internal_file_valid(const ra8_io_vfs_file_t* file)
{
  if (file == nullptr) {
    return false;
  }
  for (uint32_t i = 0U; i < (uint32_t)k_ra8_io_vfs_max_files; ++i) {
    if (file == &s_files[i]) {
      return file->in_use;
    }
  }
  return false;
}

RA8_INTERNAL static ra8_err_t internal_vfs_init_slot(vfs_slot_t* slot)
{
  ra8_err_t e = k_ra8_ok;
  if (slot->in_use && slot->owned) {
    e = slot->format->ops->unmount(slot->mount_ctx);
  }
  *slot = (vfs_slot_t){};
  return e;
}

RA8_TEST_HELPER ra8_err_t ra8_io_vfs_init_slot_test(vfs_slot_t* slot)
{
  return internal_vfs_init_slot(slot);
}
 
ra8_err_t ra8_io_vfs_init(void)
{
  ra8_err_t first_error = k_ra8_ok;
  for (uint32_t i = 0U; i < (uint32_t)k_ra8_io_vfs_max_files; ++i) {
    s_files[i] = (ra8_io_vfs_file_t){};
  }
  for (uint32_t i = 0U; i < (uint32_t)k_ra8_io_vfs_max_mounts; ++i) {
    const ra8_err_t e = internal_vfs_init_slot(&s_table[i]);
    if (first_error == k_ra8_ok) {
      first_error = e;
    }
  }
  return first_error;
}
 
ra8_err_t ra8_io_vfs_mount(const char* name, ra8_fs_mount_t* mount)
{
  RA8_CHECK_NULL_PTR(name, s_tag, "name must not be nullptr");
  RA8_CHECK_NULL_PTR(mount, s_tag, "mount must not be nullptr");
  if (!internal_name_ok(name)) {
    return k_ra8_err_invalid_arg;
  }
  if (priv_ra8_io_vfs_find(name, nullptr) != nullptr) {
    return k_ra8_err_exists;
  }
  vfs_slot_t* slot = internal_free_mount();
  if (slot == nullptr) {
    return k_ra8_err_no_mem;
  }
  const ra8_io_fsfmt_t* format = nullptr;
  RA8_RETURN_ON_ERROR(ra8_io_fsfmt_get_builtin(mount->type, &format), s_tag, "native type");
  internal_store_mount(slot, name, format, mount, false);
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_vfs_probe_and_mount(const ra8_fs_backend_t* backend,
                                                           const ra8_io_fsfmt_t**  out_format,
                                                           void**                  out_mount_ctx)
{
  RA8_RETURN_ON_ERROR(ra8_io_fsfmt_probe(backend, out_format), s_tag, "probe format");
  RA8_RETURN_ON_ERROR((*out_format)->ops->mount(backend, out_mount_ctx), s_tag, "mount format");
  return k_ra8_ok;
}
 
ra8_err_t ra8_io_vfs_mount_auto(const char* name, const ra8_fs_backend_t* backend)
{
  RA8_CHECK_NULL_PTR(name, s_tag, "name must not be nullptr");
  RA8_CHECK_NULL_PTR(backend, s_tag, "backend must not be nullptr");
  if (!internal_name_ok(name)) {
    return k_ra8_err_invalid_arg;
  }
  if (priv_ra8_io_vfs_find(name, nullptr) != nullptr) {
    return k_ra8_err_exists;
  }
  vfs_slot_t* slot = internal_free_mount();
  if (slot == nullptr) {
    return k_ra8_err_no_mem;
  }
  const ra8_io_fsfmt_t* format    = nullptr;
  void*                 mount_ctx = nullptr;
  const ra8_err_t       probed    = internal_vfs_probe_and_mount(backend, &format, &mount_ctx);
  if (probed != k_ra8_ok) {
    return probed;
  }
  internal_store_mount(slot, name, format, mount_ctx, true);
  return k_ra8_ok;
}
 
ra8_err_t ra8_io_vfs_unmount(const char* name)
{
  RA8_CHECK_NULL_PTR(name, s_tag, "name must not be nullptr");
  uint8_t     index = 0U;
  vfs_slot_t* slot  = priv_ra8_io_vfs_find(name, &index);
  if (slot == nullptr) {
    return k_ra8_err_not_found;
  }
  for (uint32_t i = 0U; i < (uint32_t)k_ra8_io_vfs_max_files; ++i) {
    if (s_files[i].in_use) {
      if (s_files[i].mount_index == index) {
        return k_ra8_err_busy;
      }
    }
  }
  ra8_err_t e = k_ra8_ok;
  if (slot->owned) {
    e = slot->format->ops->unmount(slot->mount_ctx);
  }
  *slot = (vfs_slot_t){};
  return e;
}

RA8_INTERNAL static ra8_err_t internal_vfs_open_resolve(const char*   path,
                                                        ra8_fs_mode_t mode,
                                                        vfs_slot_t**  out_slot,
                                                        const char**  out_sub)
{
  RA8_RETURN_ON_ERROR(priv_ra8_io_vfs_resolve(path, out_slot, nullptr, out_sub), s_tag, "resolve");
  if (!(*out_slot)->native) {
    return k_ra8_err_not_supported;
  }
  RA8_RETURN_ON_ERROR(internal_can_open((*out_slot)->format, mode), s_tag, "open capability");
  return k_ra8_ok;
}
 
ra8_err_t ra8_io_vfs_open(const char* path, ra8_fs_mode_t mode, ra8_fs_file_t** out_file)
{
  RA8_CHECK_NULL_PTR(path, s_tag, "path must not be nullptr");
  RA8_CHECK_NULL_PTR(out_file, s_tag, "out_file must not be nullptr");
  vfs_slot_t*     slot     = nullptr;
  const char*     sub      = nullptr;
  const ra8_err_t resolved = internal_vfs_open_resolve(path, mode, &slot, &sub);
  if (resolved != k_ra8_ok) {
    return resolved;
  }
  void* file_ctx = nullptr;
  RA8_RETURN_ON_ERROR(slot->format->ops->open(slot->mount_ctx, sub, mode, &file_ctx),
                      s_tag,
                      "open");
  *out_file = (ra8_fs_file_t*)file_ctx;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_vfs_file_open_resolve(const char*   path,
                                                             ra8_fs_mode_t mode,
                                                             vfs_slot_t**  out_slot,
                                                             uint8_t*      out_index,
                                                             const char**  out_sub)
{
  RA8_RETURN_ON_ERROR(priv_ra8_io_vfs_resolve(path, out_slot, out_index, out_sub),
                      s_tag,
                      "resolve");
  RA8_RETURN_ON_ERROR(internal_can_open((*out_slot)->format, mode), s_tag, "open capability");
  return k_ra8_ok;
}
 
ra8_err_t ra8_io_vfs_file_open(const char* path, ra8_fs_mode_t mode, ra8_io_vfs_file_t** out_file)
{
  RA8_CHECK_NULL_PTR(path, s_tag, "path must not be nullptr");
  RA8_CHECK_NULL_PTR(out_file, s_tag, "out_file must not be nullptr");
  vfs_slot_t*     slot     = nullptr;
  uint8_t         index    = 0U;
  const char*     sub      = nullptr;
  const ra8_err_t resolved = internal_vfs_file_open_resolve(path, mode, &slot, &index, &sub);
  if (resolved != k_ra8_ok) {
    return resolved;
  }
  ra8_io_vfs_file_t* file = internal_free_file();
  if (file == nullptr) {
    return k_ra8_err_no_mem;
  }
  void* file_ctx = nullptr;
  RA8_RETURN_ON_ERROR(slot->format->ops->open(slot->mount_ctx, sub, mode, &file_ctx),
                      s_tag,
                      "open");
  file->format      = slot->format;
  file->file_ctx    = file_ctx;
  file->mount_index = index;
  file->in_use      = true;
  *out_file         = file;
  return k_ra8_ok;
}
 
ra8_err_t ra8_io_vfs_file_close(ra8_io_vfs_file_t* file)
{
  RA8_CHECK_NULL_PTR(file, s_tag, "file must not be nullptr");
  if (!internal_file_valid(file)) {
    return k_ra8_err_invalid_state;
  }
  const ra8_err_t e = file->format->ops->close(file->file_ctx);
  *file             = (ra8_io_vfs_file_t){};
  return e;
}
 
ra8_err_t
ra8_io_vfs_file_read(ra8_io_vfs_file_t* file, void* buf, uint32_t bytes, uint32_t* out_read)
{
  RA8_CHECK_NULL_PTR(file, s_tag, "file must not be nullptr");
  RA8_CHECK_NULL_PTR(buf, s_tag, "buf must not be nullptr");
  RA8_CHECK_NULL_PTR(out_read, s_tag, "out_read must not be nullptr");
  if (!internal_file_valid(file)) {
    return k_ra8_err_invalid_state;
  }
  return file->format->ops->read(file->file_ctx, buf, bytes, out_read);
}
 
ra8_err_t ra8_io_vfs_file_write(ra8_io_vfs_file_t* file, const void* buf, uint32_t bytes)
{
  RA8_CHECK_NULL_PTR(file, s_tag, "file must not be nullptr");
  RA8_CHECK_NULL_PTR(buf, s_tag, "buf must not be nullptr");
  if (!internal_file_valid(file)) {
    return k_ra8_err_invalid_state;
  }
  if (file->format->caps.read_only) {
    return k_ra8_err_not_supported;
  }
  if (!file->format->caps.supports_streaming_write) {
    return k_ra8_err_not_supported;
  }
  if (file->format->ops->write == nullptr) {
    return k_ra8_err_not_supported;
  }
  return file->format->ops->write(file->file_ctx, buf, bytes);
}
 
ra8_err_t ra8_io_vfs_file_seek(ra8_io_vfs_file_t* file, uint64_t offset_bytes)
{
  RA8_CHECK_NULL_PTR(file, s_tag, "file must not be nullptr");
  if (!internal_file_valid(file)) {
    return k_ra8_err_invalid_state;
  }
  return file->format->ops->seek(file->file_ctx, offset_bytes);
}
 
ra8_err_t ra8_io_vfs_file_tell(const ra8_io_vfs_file_t* file, uint64_t* out_offset)
{
  RA8_CHECK_NULL_PTR(file, s_tag, "file must not be nullptr");
  RA8_CHECK_NULL_PTR(out_offset, s_tag, "out_offset must not be nullptr");
  if (!internal_file_valid(file)) {
    return k_ra8_err_invalid_state;
  }
  return file->format->ops->tell(file->file_ctx, out_offset);
}
 
ra8_err_t ra8_io_vfs_file_size(const ra8_io_vfs_file_t* file, uint64_t* out_bytes)
{
  RA8_CHECK_NULL_PTR(file, s_tag, "file must not be nullptr");
  RA8_CHECK_NULL_PTR(out_bytes, s_tag, "out_bytes must not be nullptr");
  if (!internal_file_valid(file)) {
    return k_ra8_err_invalid_state;
  }
  return file->format->ops->size(file->file_ctx, out_bytes);
}
 
ra8_err_t ra8_io_vfs_file_sync(ra8_io_vfs_file_t* file)
{
  RA8_CHECK_NULL_PTR(file, s_tag, "file must not be nullptr");
  if (!internal_file_valid(file)) {
    return k_ra8_err_invalid_state;
  }
  if (!file->format->caps.supports_sync) {
    return k_ra8_err_not_supported;
  }
  if (file->format->ops->sync == nullptr) {
    return k_ra8_err_not_supported;
  }
  return file->format->ops->sync(file->file_ctx);
}
 
ra8_err_t ra8_io_vfs_get_caps(const char* name, ra8_io_fsfmt_caps_t* out)
{
  RA8_CHECK_NULL_PTR(name, s_tag, "name must not be nullptr");
  RA8_CHECK_NULL_PTR(out, s_tag, "out must not be nullptr");
  vfs_slot_t* slot = priv_ra8_io_vfs_find(name, nullptr);
  if (slot == nullptr) {
    return k_ra8_err_not_found;
  }
  *out = slot->format->caps;
  return k_ra8_ok;
}
 
ra8_err_t ra8_io_vfs_free_space(const char* name, ra8_fs_space_t* out)
{
  RA8_CHECK_NULL_PTR(name, s_tag, "name must not be nullptr");
  RA8_CHECK_NULL_PTR(out, s_tag, "out must not be nullptr");
  vfs_slot_t* slot = priv_ra8_io_vfs_find(name, nullptr);
  if (slot == nullptr) {
    return k_ra8_err_not_found;
  }
  if (!slot->format->caps.supports_free_space) {
    return k_ra8_err_not_supported;
  }
  if (slot->format->ops->free_space == nullptr) {
    return k_ra8_err_not_supported;
  }
  return slot->format->ops->free_space(slot->mount_ctx, out);
}