fw_if_fs_posix_internal.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef RA8_OFF_TARGET
#error "port/posix is host-only and must never be compiled or linked into target firmware."
#endif
 
#include <stddef.h>
#include <stdint.h>
#include <time.h>
 
#include "fw_if_fs.h"
#include "fw_if_fs_posix.h"
#include "ra8_attributes.h"
#include "ra8_err.h"

typedef enum : uint16_t {
  k_posix_stage_leaf_span = 13U,  
  k_posix_max_open_files  = 64U,  
  k_posix_component_cap   = 256U, 
  k_posix_file_mode       = 0600, 
  k_posix_directory_mode  = 0700, 
  k_posix_stage_attempts  = 64U,  
} posix_limits_t;

typedef enum : uint8_t {
  k_posix_root_alias_none = 0U, 
  k_posix_root_alias_tmp  = 1U, 
  k_posix_root_alias_var  = 2U, 
} posix_root_alias_t;

typedef enum : uint8_t {
  k_posix_hex_nibble_bits  = 4U, 
  k_posix_stage_hex_digits = 6U, 
  k_posix_hex_last_digit  = k_posix_stage_hex_digits - 1U,
  k_posix_hex_nibble_mask = 0x0FU, 
} posix_hex_limits_t;

typedef enum : uint32_t {
  k_posix_epoch_year_offset   = 1900U,       
  k_posix_nanosecond_max      = 999999999U,  
  k_posix_transaction_id_mask = 0x00FFFFFFU, 
} posix_numeric_limits_t;

typedef enum : uint16_t {
  k_posix_directory_buffer_bytes = 4096U, 
  k_posix_directory_read_retries = 16U,   
} posix_directory_limits_t;

typedef enum : uint8_t {
  k_posix_linux_reclen_offset = 16U, 
  k_posix_linux_name_offset   = 19U, 
  k_posix_linux_record_align  = 8U,  
} posix_linux_dirent_layout_t;

typedef enum : uint8_t {
  k_posix_darwin_reclen_offset = 16U, 
  k_posix_darwin_namlen_offset = 18U, 
  k_posix_darwin_name_offset   = 21U, 
  k_posix_darwin_record_align  = 4U,  
} posix_darwin_dirent_layout_t;

typedef struct {
  const char* name;         
  uint16_t    name_bytes;   
  uint16_t    record_bytes; 
} posix_directory_record_t;

typedef struct {
  uint8_t  buffer[k_posix_directory_buffer_bytes]; 
  uint32_t valid_bytes;                            
  uint32_t cursor;                                 
} posix_directory_reader_t;

typedef struct {
  posix_directory_reader_t reader; 
  int                      fd;     
} posix_directory_state_t;

typedef struct {
  int fd;
} posix_file_state_t;

typedef struct {
  char destination[k_fw_fs_path_cap];
  char stage[k_fw_fs_path_cap];
  posix_file_state_t file_state;
  fw_fs_transaction_policy_t policy;
  bool writer_open;
  bool stage_exists;
} posix_transaction_state_t;
 
#ifdef RA8_POSIX_TEST
typedef int64_t (*fw_fs_posix_test_dir_read_fn_t)(void*    ctx,
                                                  int      fd,
                                                  uint8_t* buffer,
                                                  uint32_t capacity,
                                                  int*     out_errno);

RA8_TEST_HELPER RA8_NODISCARD ra8_err_t
ra8_fs_posix_test_set_directory_reader(fw_fs_posix_test_dir_read_fn_t reader, void* ctx);
#endif

RA8_PRIV RA8_NODISCARD ra8_err_t priv_fs_posix_errno(int value);

RA8_PRIV RA8_NODISCARD ra8_err_t priv_fs_posix_close_fd(int* fd);

RA8_PRIV RA8_NODISCARD ra8_err_t priv_fs_posix_close_fd_preserve(int* fd, ra8_err_t primary);

RA8_PRIV RA8_NODISCARD ra8_err_t priv_fs_posix_root_alias_classify(const char*         component,
                                                                   const char*         target,
                                                                   size_t              target_bytes,
                                                                   posix_root_alias_t* out_alias);
 
#ifdef __APPLE__
RA8_PRIV RA8_NODISCARD ra8_err_t priv_fs_posix_root_alias_verify(int                 parent_fd,
                                                                 const char*         component,
                                                                 posix_root_alias_t* out_alias);
#endif

RA8_PRIV RA8_NODISCARD ra8_err_t priv_fs_posix_root_alias_open(int                root_fd,
                                                               posix_root_alias_t alias,
                                                               int*               out_fd);

RA8_PRIV RA8_NODISCARD ra8_err_t priv_fs_posix_component_open(int         parent_fd,
                                                              const char* component,
                                                              int*        out_fd);

RA8_PRIV RA8_NODISCARD ra8_err_t priv_fs_posix_directory_next(int                       fd,
                                                              posix_directory_reader_t* reader,
                                                              posix_directory_record_t* out,
                                                              bool*                     out_end);

RA8_PRIV RA8_NODISCARD fw_fs_timestamp_t priv_fs_posix_timestamp(time_t seconds, long nanoseconds);

RA8_PRIV RA8_NODISCARD ra8_err_t priv_fs_posix_copy_path(char* out, const char* path);

RA8_PRIV RA8_NODISCARD ra8_err_t priv_fs_posix_stage_path(const char* destination,
                                                          uint32_t    id,
                                                          char*       out);

RA8_PRIV RA8_NODISCARD ra8_err_t priv_fs_posix_dir_open(void*       ctx,
                                                        const char* path,
                                                        void*       directory_state,
                                                        uint32_t    state_bytes);

RA8_PRIV RA8_NODISCARD ra8_err_t priv_fs_posix_dir_next(void*                 ctx,
                                                        void*                 directory_state,
                                                        fw_fs_dirent_value_t* out,
                                                        bool*                 out_entry);

RA8_PRIV RA8_NODISCARD ra8_err_t priv_fs_posix_dir_close(void* ctx, void* directory_state);

RA8_PRIV RA8_NODISCARD ra8_err_t priv_fs_posix_listdir(void*           ctx,
                                                       const char*     path,
                                                       uint32_t        max_entries,
                                                       fw_fs_list_fn_t callback,
                                                       void*           callback_ctx,
                                                       uint32_t*       out_count,
                                                       bool*           out_complete);

RA8_PRIV RA8_NODISCARD ra8_err_t priv_fs_posix_bind_interfaces(fw_fs_t*             out,
                                                               fw_fs_posix_state_t* state,
                                                               const fw_fs_caps_t*  caps);

RA8_PRIV RA8_NODISCARD ra8_err_t priv_fs_posix_parent_open(fw_fs_posix_state_t* state,
                                                           const char*          path,
                                                           int*                 out_parent_fd,
                                                           char*                out_leaf);

RA8_PRIV RA8_NODISCARD 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);

RA8_PRIV RA8_NODISCARD ra8_err_t priv_fs_posix_write(void*          ctx,
                                                     void*          file_state,
                                                     const uint8_t* src,
                                                     uint32_t       len,
                                                     uint32_t*      out_written);

RA8_PRIV RA8_NODISCARD ra8_err_t priv_fs_posix_seek(void* ctx, void* file_state, uint64_t offset);

RA8_PRIV RA8_NODISCARD ra8_err_t priv_fs_posix_size(void*     ctx,
                                                    void*     file_state,
                                                    uint64_t* out_size);

RA8_PRIV RA8_NODISCARD ra8_err_t priv_fs_posix_sync(void* ctx, void* file_state);

RA8_PRIV RA8_NODISCARD ra8_err_t priv_fs_posix_close(void* ctx, void* file_state);

RA8_PRIV RA8_NODISCARD const fw_fs_stream_iface_t* priv_fs_posix_stream_iface(void);