fw_if_fs_posix_stream.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
 
#include <errno.h>
#include <fcntl.h>
#include <stdint.h> // ra8-keep-include: `uint8_t` used directly
#include <sys/stat.h>
#include <unistd.h>
 
#include "fw_if_fs.h" // ra8-keep-include: `fw_fs_stream_iface_t` backend interface used directly
#include "fw_if_fs_backend.h"
#include "fw_if_fs_posix_stream_contracts_internal.h"
#include "ra8_attributes.h" // ra8-keep-include: `RA8_INTERNAL` and `RA8_PRIV` used directly
#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
 
/* see header for full description */
RA8_INTERNAL static ra8_err_t internal_open_flags(fw_fs_open_mode_t mode, int* out_flags)
{
  if (mode == k_fw_fs_open_read) {
    *out_flags = O_RDONLY | O_CLOEXEC | O_NOFOLLOW;
    return k_ra8_ok;
  }
  if (mode == k_fw_fs_open_write_truncate) {
    *out_flags = O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_NOFOLLOW;
    return k_ra8_ok;
  }
  if (mode == k_fw_fs_open_append) {
    *out_flags = O_WRONLY | O_CREAT | O_APPEND | O_CLOEXEC | O_NOFOLLOW;
    return k_ra8_ok;
  }
  if (mode == k_fw_fs_open_create_new) {
    *out_flags = O_WRONLY | O_CREAT | O_EXCL | O_CLOEXEC | O_NOFOLLOW;
    return k_ra8_ok;
  }
  return k_ra8_err_invalid_arg;
}
 
/* see header for full description */
RA8_PRIV ra8_err_t priv_fs_posix_open(void*             ctx,
                                      const char*       path,
                                      fw_fs_open_mode_t mode,
                                      void*             file_state,
                                      uint32_t          state_bytes)
{
  if (state_bytes < sizeof(posix_file_state_t)) {
    return k_ra8_err_no_mem;
  }
  int             flags  = 0;
  const ra8_err_t mapped = internal_open_flags(mode, &flags);
  if (mapped != k_ra8_ok) {
    return mapped;
  }
  fw_fs_posix_state_t* state     = (fw_fs_posix_state_t*)ctx;
  int                  parent_fd = -1;
  char                 leaf[k_posix_component_cap];
  const ra8_err_t      parent = priv_fs_posix_parent_open(state, path, &parent_fd, leaf);
  if (parent != k_ra8_ok) {
    return parent;
  }
  const int       opened      = openat(parent_fd, leaf, flags, (mode_t)k_posix_file_mode);
  const int       saved_errno = errno;
  const ra8_err_t closed      = priv_fs_posix_close_fd(&parent_fd);
  if (opened < 0) {
    return priv_fs_posix_errno(saved_errno);
  }
  if (closed != k_ra8_ok) {
    int owned = opened;
    return priv_fs_posix_close_fd_preserve(&owned, closed);
  }
  struct stat meta = {};
  if (fstat(opened, &meta) != 0) {
    int owned = opened;
    return priv_fs_posix_close_fd_preserve(&owned, k_ra8_err_invalid_arg);
  }
  if (!S_ISREG(meta.st_mode)) {
    int owned = opened;
    return priv_fs_posix_close_fd_preserve(&owned, k_ra8_err_invalid_arg);
  }
  ((posix_file_state_t*)file_state)->fd = opened;
  return k_ra8_ok;
}
 
/* see header for full description */
RA8_INTERNAL static ra8_err_t
internal_read(void* ctx, void* file_state, uint8_t* dst, uint32_t cap, uint32_t* out_read)
{
  (void)ctx;
  const int fd    = ((posix_file_state_t*)file_state)->fd;
  ssize_t   got   = -1;
  int       saved = 0;
  do {
    got = read(fd, dst, (size_t)cap);
    /* Capture errno in the statement after the call that set it: nothing may
     * run in between, and the retry test then reads a plain int. */
    saved = (got < 0) ? errno : 0;
  } while (saved == EINTR);
  if (got < 0) {
    return priv_fs_posix_errno(saved);
  }
  *out_read = (uint32_t)got;
  return k_ra8_ok;
}
 
/* see header for full description */
RA8_PRIV ra8_err_t priv_fs_posix_write(void*          ctx,
                                       void*          file_state,
                                       const uint8_t* src,
                                       uint32_t       len,
                                       uint32_t*      out_written)
{
  (void)ctx;
  const int fd = ((posix_file_state_t*)file_state)->fd;
  while (*out_written < len) {
    const uint32_t remaining = len - *out_written;
    const ssize_t  wrote     = write(fd, &src[*out_written], (size_t)remaining);
    /* Capture errno in the statement after the call that set it (see the read
     * loop above); the two tests below then read a plain int. */
    const int saved = (wrote < 0) ? errno : 0;
    if (wrote < 0) {
      if (saved == EINTR) {
        continue;
      }
      return priv_fs_posix_errno(saved);
    }
    if (wrote == 0) {
      return k_ra8_fail;
    }
    *out_written += (uint32_t)wrote;
  }
  return k_ra8_ok;
}
 
/* see header for full description */
RA8_PRIV ra8_err_t priv_fs_posix_seek(void* ctx, void* file_state, uint64_t offset)
{
  (void)ctx;
  if (offset > (uint64_t)INT64_MAX) {
    return k_ra8_err_invalid_size;
  }
  const int fd = ((posix_file_state_t*)file_state)->fd;
  if (lseek(fd, (off_t)offset, SEEK_SET) < 0) {
    return priv_fs_posix_errno(errno);
  }
  return k_ra8_ok;
}
 
/* see header for full description */
RA8_INTERNAL static ra8_err_t internal_tell(void* ctx, void* file_state, uint64_t* out_offset)
{
  (void)ctx;
  const int   fd     = ((posix_file_state_t*)file_state)->fd;
  const off_t offset = lseek(fd, 0, SEEK_CUR);
  if (offset < 0) {
    return priv_fs_posix_errno(errno);
  }
  *out_offset = (uint64_t)offset;
  return k_ra8_ok;
}
 
/* see header for full description */
RA8_PRIV ra8_err_t priv_fs_posix_size(void* ctx, void* file_state, uint64_t* out_size)
{
  (void)ctx;
  const int   fd   = ((posix_file_state_t*)file_state)->fd;
  struct stat meta = {};
  if (fstat(fd, &meta) != 0) {
    return priv_fs_posix_errno(errno);
  }
  *out_size = (uint64_t)meta.st_size;
  return k_ra8_ok;
}
 
/* see header for full description */
RA8_PRIV ra8_err_t priv_fs_posix_sync(void* ctx, void* file_state)
{
  (void)ctx;
  const int fd = ((posix_file_state_t*)file_state)->fd;
  if (fsync(fd) != 0) {
    return priv_fs_posix_errno(errno);
  }
  return k_ra8_ok;
}
 
/* see header for full description */
RA8_PRIV ra8_err_t priv_fs_posix_close(void* ctx, void* file_state)
{
  (void)ctx;
  return priv_fs_posix_close_fd(&((posix_file_state_t*)file_state)->fd);
}
 
/* see header for full description */
RA8_PRIV const fw_fs_stream_iface_t* priv_fs_posix_stream_iface(void)
{
  static const fw_fs_stream_iface_t k_stream_iface = {
    .open  = priv_fs_posix_open,
    .read  = internal_read,
    .write = priv_fs_posix_write,
    .seek  = priv_fs_posix_seek,
    .tell  = internal_tell,
    .size  = priv_fs_posix_size,
    .sync  = priv_fs_posix_sync,
    .close = priv_fs_posix_close,
  };
  return &k_stream_iface;
}