ra8_fs_fat_stat.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_fs.h"
#include "ra8_fs_fat_internal.h"

typedef enum : uint16_t {
  k_stat_fat_year_shift     = 9U,      
  k_stat_fat_month_shift    = 5U,      
  k_stat_fat_month_mask     = 0x0FU,   
  k_stat_fat_day_mask       = 0x1FU,   
  k_stat_fat_hour_shift     = 11U,     
  k_stat_fat_hour_mask      = 0x1FU,   
  k_stat_fat_minute_shift   = 5U,      
  k_stat_fat_minute_mask    = 0x3FU,   
  k_stat_fat_second_mask    = 0x1FU,   
  k_stat_tenths_per_second  = 100U,    
  k_stat_month_max          = 12U,     
  k_stat_hour_max           = 23U,     
  k_stat_minute_max         = 59U,     
  k_stat_second_max         = 59U,     
  k_stat_creation_tenth_max = 199U,    
  k_stat_packed_time_mask   = 0xFFFFU, 
  k_stat_utc_sign_bit       = 0x40U,   
  k_stat_utc_field_modulus  = 128U,    
} fs_stat_field_t;

RA8_INTERNAL
static bool internal_path_is_root(const char* path)
{
  const char* p = path;
  while (*p == '/') {
    p++;
  }
  return *p == '\0';
}

RA8_INTERNAL
static bool internal_stat_fat_time_valid(const ra8_fs_datetime_t* v, uint8_t tenth, bool have_tenth)
{
  if (v->month == 0U) {
    return false;
  }
  if (v->month > (uint8_t)k_stat_month_max) {
    return false;
  }
  if (v->day == 0U) {
    return false;
  }
  if (v->hour > (uint8_t)k_stat_hour_max) {
    return false;
  }
  if (v->minute > (uint8_t)k_stat_minute_max) {
    return false;
  }
  if (v->second > (uint8_t)k_stat_second_max) {
    return false;
  }
  if (have_tenth) {
    if (tenth > (uint8_t)k_stat_creation_tenth_max) {
      return false;
    }
  }
  return true;
}

RA8_INTERNAL
static void internal_stat_decode_fat(uint16_t            date,
                                     uint16_t            time,
                                     uint8_t             tenth,
                                     bool                have_tenth,
                                     ra8_fs_timestamp_t* out)
{
  ra8_fs_datetime_t v = {};
  v.year   = (uint16_t)((uint32_t)k_fs_time_epoch_year + (date >> k_stat_fat_year_shift));
  v.month  = (uint8_t)((date >> k_stat_fat_month_shift) & (uint16_t)k_stat_fat_month_mask);
  v.day    = (uint8_t)(date & (uint16_t)k_stat_fat_day_mask);
  v.hour   = (uint8_t)((time >> k_stat_fat_hour_shift) & (uint16_t)k_stat_fat_hour_mask);
  v.minute = (uint8_t)((time >> k_stat_fat_minute_shift) & (uint16_t)k_stat_fat_minute_mask);
  v.second = (uint8_t)((time & (uint16_t)k_stat_fat_second_mask) * 2U);
  if (have_tenth) {
    v.second      = (uint8_t)(v.second + ((tenth >= (uint8_t)k_stat_tenths_per_second) ? 1U : 0U));
    v.centisecond = (uint8_t)(tenth % (uint8_t)k_stat_tenths_per_second);
  }
  if (!internal_stat_fat_time_valid(&v, tenth, have_tenth)) {
    *out = (ra8_fs_timestamp_t){};
    return;
  }
  out->value            = v;
  out->valid            = true;
  out->utc_offset_valid = false;
}

RA8_INTERNAL
static void internal_stat_decode_exfat(uint32_t            packed,
                                       uint8_t             tenth,
                                       bool                have_tenth,
                                       uint8_t             utc,
                                       ra8_fs_timestamp_t* out)
{
  const uint16_t date = (uint16_t)(packed >> 16U);
  const uint16_t time = (uint16_t)(packed & (uint32_t)k_stat_packed_time_mask);
  internal_stat_decode_fat(date, time, tenth, have_tenth, out);
  if (!out->valid) {
    return;
  }
  if ((utc & (uint8_t)k_fs_utc_valid_bit) == 0U) {
    return;
  }
  int32_t steps = (int32_t)(utc & (uint8_t)k_fs_utc_field_mask);
  if ((steps & (int32_t)k_stat_utc_sign_bit) != 0) {
    steps -= (int32_t)k_stat_utc_field_modulus;
  }
  const int32_t minutes = steps * (int32_t)k_fs_utc_step_min;
  if (minutes < (int32_t)k_fs_utc_span_min) {
    return;
  }
  if (minutes > (int32_t)k_fs_utc_span_max) {
    return;
  }
  out->value.utc_offset_min = (int16_t)minutes;
  out->utc_offset_valid     = true;
}

RA8_INTERNAL
static void internal_stat_fat_times(const uint8_t* entry, ra8_fs_stat_t* out)
{
  internal_stat_decode_fat(priv_rd16(&entry[k_dir_off_crt_date]),
                           priv_rd16(&entry[k_dir_off_crt_time]),
                           entry[k_dir_off_crt_time_tenth],
                           true,
                           &out->created);
  internal_stat_decode_fat(priv_rd16(&entry[k_dir_off_wrt_date]),
                           priv_rd16(&entry[k_dir_off_wrt_time]),
                           0U,
                           false,
                           &out->modified);
  internal_stat_decode_fat(priv_rd16(&entry[k_dir_off_lst_acc_date]),
                           0U,
                           0U,
                           false,
                           &out->accessed);
}

RA8_INTERNAL
static void internal_stat_exfat_times(const uint8_t* entry, ra8_fs_stat_t* out)
{
  internal_stat_decode_exfat(priv_rd32(&entry[k_exfat_off_file_ctime]),
                             entry[k_exfat_off_file_c10ms],
                             true,
                             entry[k_exfat_off_file_cutc],
                             &out->created);
  internal_stat_decode_exfat(priv_rd32(&entry[k_exfat_off_file_mtime]),
                             entry[k_exfat_off_file_m10ms],
                             true,
                             entry[k_exfat_off_file_mutc],
                             &out->modified);
  internal_stat_decode_exfat(priv_rd32(&entry[k_exfat_off_file_atime]),
                             0U,
                             false,
                             entry[k_exfat_off_file_autc],
                             &out->accessed);
}

RA8_INTERNAL
static void internal_stat_root(const ra8_fs_mount_t* m, ra8_fs_stat_t* out)
{
  out->size_bytes    = 0U;
  out->first_cluster = m->root_cluster;
  out->attr          = (uint8_t)k_ra8_fs_attr_directory;
  out->is_directory  = true;
}

RA8_INTERNAL
static void internal_entry_to_stat(const uint8_t* entry, ra8_fs_stat_t* out)
{
  const uint8_t attr = entry[k_dir_off_attr];
  out->attr          = attr;
  out->is_directory  = (attr & (uint8_t)k_ra8_fs_attr_directory) != 0U;
  out->first_cluster = priv_entry_first_cluster(entry);
  out->size_bytes    = priv_rd32(&entry[k_dir_off_file_size]);
  internal_stat_fat_times(entry, out);
  if (out->is_directory) {
    out->size_bytes = 0U;
  }
}

RA8_INTERNAL
static ra8_err_t internal_stat_exfat(const ra8_fs_mount_t* m, const char* path, ra8_fs_stat_t* out)
{
  exfat_dir_t     parent = {};
  const char*     leaf   = nullptr;
  const ra8_err_t pe     = priv_exfat_resolve_parent(m, path, &parent, &leaf);
  if (pe != k_ra8_ok) {
    return pe;
  }
  exfat_setpos_t  pos[k_exfat_set_max_entries] = {};
  uint32_t        count                        = 0U;
  uint8_t         file_e[k_exfat_entry_bytes]  = {};
  uint8_t         strm[k_exfat_entry_bytes]    = {};
  const ra8_err_t err = priv_exfat_find_set(m,
                                            &parent,
                                            leaf,
                                            pos,
                                            (uint32_t)k_exfat_set_max_entries,
                                            &count,
                                            file_e,
                                            strm);
  if (err != k_ra8_ok) {
    return err;
  }
  out->attr          = file_e[k_exfat_off_file_attr];
  out->is_directory  = (out->attr & (uint8_t)k_ra8_fs_attr_directory) != 0U;
  out->first_cluster = priv_rd32(&strm[k_exfat_strm_off_clus]);
  out->size_bytes    = priv_rd64(&strm[k_exfat_strm_off_dlen]);
  internal_stat_exfat_times(file_e, out);
  if (out->is_directory) {
    out->size_bytes = 0U;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_EXPECTS_LOCK("ra8_fs_lock")
static ra8_err_t
internal_stat_fat(const ra8_fs_mount_t* handle, const char* path, ra8_fs_stat_t* out)
{
  dir_loc_t       parent = {};
  const char*     leaf   = nullptr;
  const ra8_err_t rerr   = priv_resolve_parent(handle, path, &parent, &leaf);
  if (rerr != k_ra8_ok) {
    return rerr;
  }
  uint8_t       name83[k_max_8_3_name]          = {};
  const uint8_t have83                          = priv_path_to_83(leaf, name83);
  uint64_t      lba                             = 0U;
  uint32_t      off                             = 0U;
  uint8_t       entry[k_ra8_fs_dir_entry_bytes] = {};
  ra8_err_t     err                             = k_ra8_err_not_found;
  if (have83 != 0U) {
    err = priv_dir_find(handle, &parent, name83, &lba, &off, entry);
  }
  if (err == k_ra8_err_not_found) {
    /* Same long-name fallback as priv_open_locked: a leaf that is not
     * 8.3-representable still resolves through its VFAT chain. */
    err = priv_dir_find_long(handle, &parent, leaf, &lba, &off, entry);
  }
  if (err != k_ra8_ok) {
    return err;
  }
  internal_entry_to_stat(entry, out);
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_EXPECTS_LOCK("ra8_fs_lock")
static ra8_err_t
internal_stat_locked(const ra8_fs_mount_t* handle, const char* path, ra8_fs_stat_t* out)
{
  if (handle == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (path == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (out == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (handle->in_use == 0U) {
    return k_ra8_err_invalid_state;
  }
  *out = (ra8_fs_stat_t){};
  if (internal_path_is_root(path)) {
    internal_stat_root(handle, out);
    return k_ra8_ok;
  }
  if (handle->type == k_ra8_fs_type_exfat) {
    return internal_stat_exfat(handle, path, out);
  }
  return internal_stat_fat(handle, path, out);
}
 
/* =============================================================================
 * Public entry points -- the lock brackets
 * =============================================================================
 */
 
RA8_OWNS_RESOURCE("ra8_fs_lock")
ra8_err_t ra8_fs_stat(const ra8_fs_mount_t* handle, const char* path, ra8_fs_stat_t* out)
{
  priv_lock_acquire();
  const ra8_err_t err = internal_stat_locked(handle, path, out);
  priv_lock_release();
  return err;
}