ra8_io_fsfmt.c

Go to the documentation of this file.

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

static const char* const s_tag = "ra8_io_fsfmt";

static const ra8_io_fsfmt_t* s_reg[(uint32_t)k_ra8_io_fsfmt_max];
static uint32_t s_count;

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_native_mount(const ra8_fs_backend_t* backend,
                                                    void**                  out_mount)
{
  ra8_fs_mount_t* mount = nullptr;
  const ra8_err_t e     = ra8_fs_mount(backend, &mount);
  if (e != k_ra8_ok) {
    return e;
  }
  *out_mount = mount;
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_native_unmount(void* mount_ctx)
{
  return ra8_fs_unmount((ra8_fs_mount_t*)mount_ctx);
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_native_open(void* mount_ctx, const char* path, ra8_fs_mode_t mode, void** out_file)
{
  ra8_fs_file_t*  file = nullptr;
  const ra8_err_t e    = ra8_fs_open((ra8_fs_mount_t*)mount_ctx, path, mode, &file);
  if (e != k_ra8_ok) {
    return e;
  }
  *out_file = file;
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_native_close(void* file_ctx)
{
  return ra8_fs_close((ra8_fs_file_t*)file_ctx);
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_native_read(void* file_ctx, void* buf, uint32_t bytes, uint32_t* out_read)
{
  return ra8_fs_read((ra8_fs_file_t*)file_ctx, (uint8_t*)buf, bytes, out_read);
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_native_write(void* file_ctx, const void* buf, uint32_t bytes)
{
  return ra8_fs_write((ra8_fs_file_t*)file_ctx, (const uint8_t*)buf, bytes);
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_native_seek(void* file_ctx, uint64_t offset_bytes)
{
  return ra8_fs_seek((ra8_fs_file_t*)file_ctx, offset_bytes);
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_native_tell(const void* file_ctx, uint64_t* out_offset)
{
  return ra8_fs_tell((const ra8_fs_file_t*)file_ctx, out_offset);
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_native_size(const void* file_ctx, uint64_t* out_bytes)
{
  return ra8_fs_size((const ra8_fs_file_t*)file_ctx, out_bytes);
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_native_stat(void* mount_ctx, const char* path, ra8_fs_stat_t* out)
{
  return ra8_fs_stat((ra8_fs_mount_t*)mount_ctx, path, out);
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_native_listdir(void* mount_ctx, const char* path, ra8_fs_listdir_cb_t cb, void* cb_ctx)
{
  ra8_fs_dir_t directory = {};
  ra8_err_t    err       = ra8_fs_dir_open((ra8_fs_mount_t*)mount_ctx, path, &directory);
  while (err == k_ra8_ok) {
    ra8_fs_dirent_t entry   = {};
    bool            present = false;
    err                     = ra8_fs_dir_next(&directory, &entry, &present);
    if (err != k_ra8_ok) {
      break;
    }
    if (!present) {
      break;
    }
    cb(entry.name, entry.attr, entry.size_bytes, cb_ctx);
  }
  if (directory.is_open) {
    const ra8_err_t closed = ra8_fs_dir_close(&directory);
    if (err == k_ra8_ok) {
      err = closed;
    }
  }
  return err;
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_native_dir_open(void*       mount_ctx,
                                                       const char* path,
                                                       void*       directory_state,
                                                       uint32_t    state_bytes)
{
  if (state_bytes < (uint32_t)sizeof(ra8_fs_dir_t)) {
    return k_ra8_err_no_mem;
  }
  ra8_fs_dir_t* directory = (ra8_fs_dir_t*)directory_state;
  *directory              = (ra8_fs_dir_t){};
  return ra8_fs_dir_open((ra8_fs_mount_t*)mount_ctx, path, directory);
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_native_dir_next(void* directory_state, ra8_fs_dirent_t* out, bool* out_entry)
{
  return ra8_fs_dir_next((ra8_fs_dir_t*)directory_state, out, out_entry);
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_native_dir_close(void* directory_state)
{
  return ra8_fs_dir_close((ra8_fs_dir_t*)directory_state);
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_native_unlink(void* mount_ctx, const char* path)
{
  return ra8_fs_unlink((ra8_fs_mount_t*)mount_ctx, path);
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_native_rename(void* mount_ctx, const char* old_path, const char* new_path)
{
  return ra8_fs_rename((ra8_fs_mount_t*)mount_ctx, old_path, new_path);
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_native_mkdir(void* mount_ctx, const char* path)
{
  return ra8_fs_mkdir((ra8_fs_mount_t*)mount_ctx, path);
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_native_rmdir(void* mount_ctx, const char* path)
{
  return ra8_fs_rmdir((ra8_fs_mount_t*)mount_ctx, path);
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_native_free_space(void* mount_ctx, ra8_fs_space_t* out)
{
  return ra8_fs_free_space((ra8_fs_mount_t*)mount_ctx, out);
}

RA8_INTERNAL
RA8_INTERNAL static bool internal_exfat_probe(const ra8_fs_backend_t* backend)
{
  ra8_fs_type_t type = k_ra8_fs_type_unknown;
  if (ra8_fs_probe(backend, &type) != k_ra8_ok) {
    return false;
  }
  return type == k_ra8_fs_type_exfat;
}

RA8_INTERNAL
RA8_INTERNAL static bool internal_fat_probe(const ra8_fs_backend_t* backend)
{
  ra8_fs_type_t type = k_ra8_fs_type_unknown;
  if (ra8_fs_probe(backend, &type) != k_ra8_ok) {
    return false;
  }
  if (type == k_ra8_fs_type_fat12) {
    return true;
  }
  if (type == k_ra8_fs_type_fat16) {
    return true;
  }
  return type == k_ra8_fs_type_fat32;
}

static const ra8_io_fsfmt_ops_t s_native_ops = {
  .probe      = internal_fat_probe,
  .mount      = internal_native_mount,
  .unmount    = internal_native_unmount,
  .open       = internal_native_open,
  .close      = internal_native_close,
  .read       = internal_native_read,
  .write      = internal_native_write,
  .seek       = internal_native_seek,
  .tell       = internal_native_tell,
  .size       = internal_native_size,
  .sync       = nullptr,
  .stat       = internal_native_stat,
  .listdir    = internal_native_listdir,
  .dir_open   = internal_native_dir_open,
  .dir_next   = internal_native_dir_next,
  .dir_close  = internal_native_dir_close,
  .unlink     = internal_native_unlink,
  .rename     = internal_native_rename,
  .mkdir      = internal_native_mkdir,
  .rmdir      = internal_native_rmdir,
  .free_space = internal_native_free_space,
};

static const ra8_io_fsfmt_t s_fmt_fat = {
  .name = "fat",
  .caps =
    {
      .directory_workspace_bytes = sizeof(ra8_fs_dir_t),
      .max_name_len              = (uint16_t)k_ra8_io_fsfmt_fat_max_name_utf8,
      .max_open_directories      = UINT16_MAX,
      .directory_workspace_align = (uint8_t)_Alignof(ra8_fs_dir_t),
      .read_only                 = false,
      .supports_mkdir            = true,
      .supports_rmdir            = true,
      .supports_streaming_write  = true,
      .supports_timestamps       = true,
      .supports_free_space       = true,
      .supports_dir_cursor       = true,
      .supports_sync             = false,
      .atomic_rename             = false,
      .durable_sync              = false,
      .unicode_names             = true,
      .case_sensitive            = false,
    },
  .ops = &s_native_ops,
};

static const ra8_io_fsfmt_ops_t s_exfat_ops = {
  .probe      = internal_exfat_probe,
  .mount      = internal_native_mount,
  .unmount    = internal_native_unmount,
  .open       = internal_native_open,
  .close      = internal_native_close,
  .read       = internal_native_read,
  .write      = internal_native_write,
  .seek       = internal_native_seek,
  .tell       = internal_native_tell,
  .size       = internal_native_size,
  .sync       = nullptr,
  .stat       = internal_native_stat,
  .listdir    = internal_native_listdir,
  .dir_open   = internal_native_dir_open,
  .dir_next   = internal_native_dir_next,
  .dir_close  = internal_native_dir_close,
  .unlink     = internal_native_unlink,
  .rename     = internal_native_rename,
  .mkdir      = internal_native_mkdir,
  .rmdir      = internal_native_rmdir,
  .free_space = internal_native_free_space,
};

static const ra8_io_fsfmt_t s_fmt_exfat = {
  .name = "exfat",
  .caps =
    {
      .directory_workspace_bytes = sizeof(ra8_fs_dir_t),
      .max_name_len              = (uint16_t)k_ra8_io_fsfmt_exfat_max_name_utf8,
      .max_open_directories      = UINT16_MAX,
      .directory_workspace_align = (uint8_t)_Alignof(ra8_fs_dir_t),
      .read_only                 = false,
      .supports_mkdir            = true,
      .supports_rmdir            = true,
      .supports_streaming_write  = true,
      .supports_timestamps       = true,
      .supports_free_space       = true,
      .supports_dir_cursor       = true,
      .supports_sync             = false,
      .atomic_rename             = false,
      .durable_sync              = false,
      .unicode_names             = true,
      .case_sensitive            = false,
    },
  .ops = &s_exfat_ops,
};

RA8_INTERNAL
static ra8_err_t internal_validate_dir_cursor_caps(const ra8_io_fsfmt_t* fmt)
{
  const uint8_t align = fmt->caps.directory_workspace_align;
  if ((fmt->ops->dir_open == nullptr) || (fmt->ops->dir_next == nullptr) ||
      (fmt->ops->dir_close == nullptr) || (fmt->caps.directory_workspace_bytes == 0U) ||
      (fmt->caps.max_open_directories == 0U) || (align == 0U) ||
      (((uint32_t)align & ((uint32_t)align - 1U)) != 0U)) {
    return k_ra8_err_invalid_arg;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_INTERNAL
static ra8_err_t internal_validate_single_op_caps(const ra8_io_fsfmt_t* fmt)
{
  if (fmt->caps.supports_streaming_write) {
    if (fmt->ops->write == nullptr) {
      return k_ra8_err_invalid_arg;
    }
  }
  if (fmt->caps.supports_mkdir) {
    if (fmt->ops->mkdir == nullptr) {
      return k_ra8_err_invalid_arg;
    }
  }
  if (fmt->caps.supports_rmdir) {
    if (fmt->ops->rmdir == nullptr) {
      return k_ra8_err_invalid_arg;
    }
  }
  if (fmt->caps.supports_free_space) {
    if (fmt->ops->free_space == nullptr) {
      return k_ra8_err_invalid_arg;
    }
  }
  if (fmt->caps.supports_sync) {
    if (fmt->ops->sync == nullptr) {
      return k_ra8_err_invalid_arg;
    }
  }
  if (fmt->caps.atomic_rename) {
    if (fmt->ops->rename == nullptr) {
      return k_ra8_err_invalid_arg;
    }
  }
  return k_ra8_ok;
}

static ra8_err_t internal_validate_caps(const ra8_io_fsfmt_t* fmt)
{
  if (fmt->caps.supports_dir_cursor) {
    RA8_RETURN_ON_ERROR(internal_validate_dir_cursor_caps(fmt),
                        s_tag,
                        "dir-cursor capability mismatch");
  }
  RA8_RETURN_ON_ERROR(internal_validate_single_op_caps(fmt), s_tag, "capability mismatch");
  if (fmt->caps.durable_sync) {
    if (!fmt->caps.supports_sync) {
      return k_ra8_err_invalid_arg;
    }
  }
  return k_ra8_ok;
}
 
ra8_err_t ra8_io_fsfmt_init(void)
{
  s_count = 0U;
  RA8_RETURN_ON_ERROR(ra8_io_fsfmt_register(&s_fmt_exfat), s_tag, "register exfat");
  RA8_RETURN_ON_ERROR(ra8_io_fsfmt_register(&s_fmt_fat), s_tag, "register fat");
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_validate_required_ops_group1(const ra8_io_fsfmt_t* fmt)
{
  RA8_CHECK_NULL_PTR(fmt->ops->probe, s_tag, "probe must not be nullptr");
  RA8_CHECK_NULL_PTR(fmt->ops->mount, s_tag, "mount must not be nullptr");
  RA8_CHECK_NULL_PTR(fmt->ops->unmount, s_tag, "unmount must not be nullptr");
  RA8_CHECK_NULL_PTR(fmt->ops->open, s_tag, "open must not be nullptr");
  RA8_CHECK_NULL_PTR(fmt->ops->close, s_tag, "close must not be nullptr");
  RA8_CHECK_NULL_PTR(fmt->ops->read, s_tag, "read must not be nullptr");
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_validate_required_ops_group2(const ra8_io_fsfmt_t* fmt)
{
  RA8_CHECK_NULL_PTR(fmt->ops->seek, s_tag, "seek must not be nullptr");
  RA8_CHECK_NULL_PTR(fmt->ops->tell, s_tag, "tell must not be nullptr");
  RA8_CHECK_NULL_PTR(fmt->ops->size, s_tag, "size must not be nullptr");
  RA8_CHECK_NULL_PTR(fmt->ops->stat, s_tag, "stat must not be nullptr");
  RA8_CHECK_NULL_PTR(fmt->ops->listdir, s_tag, "listdir must not be nullptr");
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_validate_required_ops(const ra8_io_fsfmt_t* fmt)
{
  RA8_RETURN_ON_ERROR(internal_validate_required_ops_group1(fmt),
                      s_tag,
                      "missing mandatory operation");
  return internal_validate_required_ops_group2(fmt);
}
 
ra8_err_t ra8_io_fsfmt_register(const ra8_io_fsfmt_t* fmt)
{
  RA8_CHECK_NULL_PTR(fmt, s_tag, "fmt must not be nullptr");
  RA8_CHECK_NULL_PTR(fmt->name, s_tag, "fmt->name must not be nullptr");
  RA8_CHECK_NULL_PTR(fmt->ops, s_tag, "fmt->ops must not be nullptr");
  RA8_RETURN_ON_ERROR(internal_validate_required_ops(fmt), s_tag, "missing mandatory operation");
  RA8_RETURN_ON_ERROR(internal_validate_caps(fmt), s_tag, "capability mismatch");
  if (s_count >= (uint32_t)k_ra8_io_fsfmt_max) {
    return k_ra8_err_no_mem;
  }
  s_reg[s_count] = fmt;
  s_count++;
  return k_ra8_ok;
}
 
ra8_err_t ra8_io_fsfmt_get_builtin(ra8_fs_type_t type, const ra8_io_fsfmt_t** out)
{
  RA8_CHECK_NULL_PTR(out, s_tag, "out must not be nullptr");
  if (type == k_ra8_fs_type_exfat) {
    *out = &s_fmt_exfat;
    return k_ra8_ok;
  }
  if (type == k_ra8_fs_type_fat12) {
    *out = &s_fmt_fat;
    return k_ra8_ok;
  }
  if (type == k_ra8_fs_type_fat16) {
    *out = &s_fmt_fat;
    return k_ra8_ok;
  }
  if (type == k_ra8_fs_type_fat32) {
    *out = &s_fmt_fat;
    return k_ra8_ok;
  }
  return k_ra8_err_invalid_arg;
}
 
ra8_err_t ra8_io_fsfmt_probe(const ra8_fs_backend_t* backend, const ra8_io_fsfmt_t** out)
{
  RA8_CHECK_NULL_PTR(backend, s_tag, "backend must not be nullptr");
  RA8_CHECK_NULL_PTR(out, s_tag, "out must not be nullptr");
  for (uint32_t i = 0U; i < s_count; ++i) {
    if (s_reg[i]->ops->probe(backend)) {
      *out = s_reg[i];
      return k_ra8_ok;
    }
  }
  return k_ra8_err_not_found;
}