fw_if_fs_posix_bind.c

Go to the documentation of this file.

 
#ifndef RA8_OFF_TARGET
#error "port/posix is host-only and must never be compiled or linked into target firmware."
#endif
 
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
 
#include <errno.h>
#include <fcntl.h>
#include <stdint.h> // ra8-keep-include: `uint8_t` used directly
#include <stdio.h>
#include <string.h>
#include <unistd.h> // ra8-keep-include: `syscall` used directly
 
#include "fw_if_fs_posix.h" // ra8-keep-include: `fw_fs_posix_state_t` and public interface
#include "ra8_attributes.h" // ra8-keep-include: `RA8_INTERNAL` used directly
 
#if defined(__linux__) || defined(__APPLE__)
#include <sys/syscall.h>
#endif
 
#include "fw_if_fs.h" // ra8-keep-include: `fw_fs_t` backend interface used directly
#include "fw_if_fs_posix_internal.h"
#include "ra8_err.h" // ra8-keep-include: `ra8_err_t` used directly
 
#ifndef O_CLOEXEC
#define O_CLOEXEC (0)
#endif
 
#ifndef O_NOFOLLOW
#define O_NOFOLLOW (0)
#endif
 
#ifndef RENAME_NOREPLACE
#define RENAME_NOREPLACE (1U << 0U)
#endif

RA8_INTERNAL static bool internal_atomic_noreplace_available(void)
{
#if defined(__linux__) && defined(SYS_renameat2)
  errno             = 0;
  const long result = syscall(SYS_renameat2, -1, "x", -1, "y", RENAME_NOREPLACE);
  if (result != -1L) {
    return false;
  }
  return errno == EBADF;
#elif defined(__APPLE__)
  errno            = 0;
  const int result = renameatx_np(-1, "x", -1, "y", RENAME_EXCL);
  if (result != -1) {
    return false;
  }
  return errno == EBADF;
#else
  return false;
#endif
}

RA8_INTERNAL static ra8_err_t
internal_root_base_open(const char* path, const char** out_cursor, int* out_fd)
{
  ra8_err_t status = k_ra8_err_invalid_arg;
  *out_cursor      = path;
  *out_fd          = -1;
  if (path[0] != '\0') {
    const char* anchor = (path[0] == '/') ? "/" : ".";
    const int   opened = open(anchor, O_RDONLY | O_DIRECTORY | O_CLOEXEC | O_NOFOLLOW);
    if (opened < 0) {
      status = priv_fs_posix_errno(errno);
    } else {
      *out_fd = opened;
      status  = k_ra8_ok;
    }
  }
  return status;
}

RA8_INTERNAL static ra8_err_t internal_root_skip_slashes(const char** cursor, uint16_t* consumed)
{
  ra8_err_t status = k_ra8_ok;
  RA8_LOOP_BOUND(k_fw_fs_path_cap);
  while (**cursor == '/') {
    if (*consumed >= (uint16_t)(k_fw_fs_path_cap - 1U)) {
      status = k_ra8_err_invalid_size;
      break;
    }
    *cursor = &(*cursor)[1];
    ++(*consumed);
  }
  return status;
}

RA8_INTERNAL static ra8_err_t
internal_root_name_copy(const char** cursor, uint16_t* consumed, char* out_component)
{
  uint16_t  length = 0U;
  ra8_err_t status = k_ra8_ok;
  RA8_LOOP_BOUND(k_posix_component_cap);
  for (uint16_t index = 0U; index < (uint16_t)k_posix_component_cap; ++index) {
    const char value = **cursor;
    bool       stop  = false;
    if (value == '/') {
      stop = true;
    }
    if (!stop) {
      if (value == '\0') {
        stop = true;
      }
    }
    if (!stop) {
      if (length >= (uint16_t)(k_posix_component_cap - 1U)) {
        status = k_ra8_err_invalid_size;
        stop   = true;
      }
    }
    if (!stop) {
      if (*consumed >= (uint16_t)(k_fw_fs_path_cap - 1U)) {
        status = k_ra8_err_invalid_size;
        stop   = true;
      }
    }
    if (stop) {
      break;
    }
    out_component[length] = value;
    ++length;
    *cursor = &(*cursor)[1];
    ++(*consumed);
  }
  out_component[length] = '\0';
  return status;
}

RA8_INTERNAL static ra8_err_t internal_root_component_scan(const char** cursor,
                                                           uint16_t*    consumed,
                                                           char*        out_component,
                                                           bool*        out_end)
{
  *out_end         = false;
  out_component[0] = '\0';
  ra8_err_t status = internal_root_skip_slashes(cursor, consumed);
  if (status == k_ra8_ok) {
    if (**cursor == '\0') {
      *out_end = true;
    } else {
      status = internal_root_name_copy(cursor, consumed, out_component);
    }
  }
  return status;
}

RA8_INTERNAL static ra8_err_t internal_root_open_step(int* current, const char* component)
{
  int       next   = -1;
  ra8_err_t status = priv_fs_posix_component_open(*current, component, &next);
  if (status == k_ra8_ok) {
    const ra8_err_t closed = priv_fs_posix_close_fd(current);
    if (closed != k_ra8_ok) {
      status = priv_fs_posix_close_fd_preserve(&next, closed);
    } else {
      *current = next;
      next     = -1;
    }
  }
  if (next >= 0) {
    status = priv_fs_posix_close_fd_preserve(&next, status);
  }
  return status;
}

RA8_INTERNAL static ra8_err_t internal_root_walk_step(int* current, const char* component)
{
  ra8_err_t status = k_ra8_ok;
  if (strcmp(component, ".") != 0) {
    status = internal_root_open_step(current, component);
  }
  return status;
}

RA8_INTERNAL static ra8_err_t
internal_root_walk(const char** cursor, uint16_t* consumed, int* current, bool* out_complete)
{
  ra8_err_t status = k_ra8_ok;
  *out_complete    = false;
  RA8_LOOP_BOUND(k_fw_fs_path_cap);
  for (uint16_t component = 0U; component < (uint16_t)k_fw_fs_path_cap; ++component) {
    char name[k_posix_component_cap];
    bool end  = false;
    bool stop = false;
    status    = internal_root_component_scan(cursor, consumed, name, &end);
    if (status != k_ra8_ok) {
      stop = true;
    }
    if (!stop) {
      if (end) {
        *out_complete = true;
        stop          = true;
      }
    }
    if (!stop) {
      status = internal_root_walk_step(current, name);
      if (status != k_ra8_ok) {
        stop = true;
      }
    }
    if (stop) {
      break;
    }
  }
  return status;
}

RA8_INTERNAL static ra8_err_t internal_root_open(const char* path, int* out_fd)
{
  const char* cursor   = path;
  uint16_t    consumed = 0U;
  int         current  = -1;
  bool        complete = false;
  ra8_err_t   status   = internal_root_base_open(path, &cursor, &current);
  *out_fd              = -1;
  if (status == k_ra8_ok) {
    status = internal_root_walk(&cursor, &consumed, &current, &complete);
  }
  if (status == k_ra8_ok) {
    if (!complete) {
      status = k_ra8_err_invalid_size;
    } else {
      *out_fd = current;
      current = -1;
    }
  }
  if (current >= 0) {
    const ra8_err_t closed = priv_fs_posix_close_fd(&current);
    if (status == k_ra8_ok) {
      status = closed;
    }
  }
  return status;
}

RA8_INTERNAL static void internal_state_reset(fw_fs_posix_state_t* state)
{
  state->root_fd          = -1;
  state->transaction_id   = 0U;
  state->removable_media  = false;
  state->atomic_noreplace = false;
  state->initialized      = false;
}

RA8_INTERNAL static void internal_caps(const fw_fs_posix_state_t* state, fw_fs_caps_t* out)
{
  *out = (fw_fs_caps_t){
    .max_file_bytes = (uint64_t)INT64_MAX,
    .flags = (uint32_t)k_fw_fs_cap_namespace | (uint32_t)k_fw_fs_cap_stream |
             (uint32_t)k_fw_fs_cap_space_query | (uint32_t)k_fw_fs_cap_same_volume_rename |
             (uint32_t)k_fw_fs_cap_atomic_replace | (uint32_t)k_fw_fs_cap_create_exclusive |
             (uint32_t)k_fw_fs_cap_file_sync | (uint32_t)k_fw_fs_cap_durable_file_sync |
             (uint32_t)k_fw_fs_cap_durable_directory_sync | (uint32_t)k_fw_fs_cap_transactions |
             (uint32_t)k_fw_fs_cap_symlinks | (uint32_t)k_fw_fs_cap_rejects_symlink_walk |
             (uint32_t)k_fw_fs_cap_modified_time | (uint32_t)k_fw_fs_cap_accessed_time,
    .file_workspace_bytes        = sizeof(posix_file_state_t),
    .directory_workspace_bytes   = sizeof(posix_directory_state_t),
    .transaction_workspace_bytes = sizeof(posix_transaction_state_t),
    .path_max_bytes              = (uint16_t)k_fw_fs_path_cap,
    .name_max_bytes              = (uint16_t)(k_posix_component_cap - 1U),
    .max_open_files              = (uint16_t)k_posix_max_open_files,
    .max_open_directories        = (uint16_t)k_posix_max_open_files,
    .file_workspace_align        = (uint8_t)_Alignof(posix_file_state_t),
    .directory_workspace_align   = (uint8_t)_Alignof(posix_directory_state_t),
    .transaction_workspace_align = (uint8_t)_Alignof(posix_transaction_state_t),
  };
#ifdef __APPLE__
  out->flags |= (uint32_t)k_fw_fs_cap_created_time;
#endif
  if (state->atomic_noreplace) {
    out->flags |= (uint32_t)k_fw_fs_cap_atomic_noreplace;
  }
  if (state->removable_media) {
    out->flags |= (uint32_t)k_fw_fs_cap_removable_media;
  }
}
 
ra8_err_t fw_fs_posix_init(fw_fs_t* out, fw_fs_posix_state_t* state, const fw_fs_posix_cfg_t* cfg)
{
  if (out == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (state == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (cfg == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (cfg->root_path == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (state->initialized) {
    return k_ra8_err_exists;
  }
  internal_state_reset(state);
  int             root        = -1;
  const ra8_err_t root_status = internal_root_open(cfg->root_path, &root);
  if (root_status != k_ra8_ok) {
    return root_status;
  }
  state->root_fd          = root;
  state->transaction_id   = 0U;
  state->removable_media  = cfg->removable_media;
  state->atomic_noreplace = internal_atomic_noreplace_available();
  state->initialized      = true;
  fw_fs_caps_t caps       = {};
  internal_caps(state, &caps);
  const ra8_err_t bound = priv_fs_posix_bind_interfaces(out, state, &caps);
  if (bound != k_ra8_ok) {
    (void)fw_fs_posix_deinit(state);
  }
  return bound;
}
 
ra8_err_t fw_fs_posix_deinit(fw_fs_posix_state_t* state)
{
  if (state == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (!state->initialized) {
    return k_ra8_err_not_initialized;
  }
  const ra8_err_t status = priv_fs_posix_close_fd(&state->root_fd);
  internal_state_reset(state);
  return status;
}