ra8_fs_fat_space.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"
#include "ra8_fs_meta.h"

typedef enum : uint32_t {
  k_space_bits_per_byte = 8U, 
  k_space_bit_mask      = 7U, 
  k_space_byte_shift    = 3U, 
} ra8_fs_space_const_t;

RA8_INTERNAL
static uint32_t internal_popcount8(uint8_t b)
{
  uint32_t n = 0U;
  for (uint32_t i = 0U; i < (uint32_t)k_space_bits_per_byte; i++) {
    n += ((uint32_t)b >> i) & 1U;
  }
  return n;
}

RA8_INTERNAL
static ra8_err_t internal_space_fat_free(const ra8_fs_mount_t* m, uint32_t* out_free)
{
  uint32_t       free = 0U;
  const uint32_t last = (uint32_t)k_cluster_first_data + m->count_of_clusters;
  for (uint32_t c = (uint32_t)k_cluster_first_data; c < last; c++) {
    uint32_t        v   = 0U;
    const ra8_err_t err = priv_fat_get(m, c, &v);
    if (err != k_ra8_ok) {
      return err;
    }
    if (v == (uint32_t)k_cluster_free) {
      free++;
    }
  }
  *out_free = free;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_space_exfat_free(const ra8_fs_mount_t* m, uint32_t* out_free)
{
  uint32_t        bmp_clus = 0U;
  uint32_t        bmp_len  = 0U;
  const ra8_err_t ferr     = priv_exfat_find_bitmap(m, &bmp_clus, &bmp_len);
  if (ferr != k_ra8_ok) {
    return ferr;
  }
  const uint64_t bmp_lba    = priv_cluster_to_lba(m, bmp_clus);
  const uint32_t total      = m->count_of_clusters;
  const uint32_t full_bytes = total >> (uint32_t)k_space_byte_shift;
  const uint32_t rem_bits   = total & (uint32_t)k_space_bit_mask;
  /* One byte per full group of 8 clusters, plus one partial byte for the tail.
   * The tail byte is masked to the volume's last cluster so any bits the spec
   * leaves 0 past the heap cannot inflate the used count. */
  const uint32_t nbytes = full_bytes + ((rem_bits != 0U) ? 1U : 0U);
  uint32_t       used   = 0U;
  uint64_t       loaded = UINT64_MAX;
  uint8_t* const sec    = priv_sec_io();
  for (uint32_t bi = 0U; bi < nbytes; bi++) {
    const uint64_t lba = bmp_lba + (bi / priv_bps(m));
    if (lba != loaded) {
      const ra8_err_t err = priv_read_sector(m, lba, sec);
      if (err != k_ra8_ok) {
        return err;
      }
      loaded = lba;
    }
    uint8_t b = sec[bi % priv_bps(m)];
    /* The loop only reaches `bi == full_bytes` when `rem_bits != 0` (that is the
     * only case `nbytes` includes the partial byte), so masking it here needs no
     * second condition -- and adding one would be an MC/DC hole nothing can flip. */
    if (bi == full_bytes) {
      b = (uint8_t)(b & (uint8_t)((1U << rem_bits) - 1U));
    }
    used += internal_popcount8(b);
  }
  /* The bitmap holds exactly `total` cluster bits and the tail is masked, so
   * `used <= total` always -- no clamp needed. */
  *out_free = total - used;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_space_free_clusters(const ra8_fs_mount_t* m, uint32_t* out_free)
{
  if (m->type == k_ra8_fs_type_exfat) {
    return internal_space_exfat_free(m, out_free);
  }
  const uint32_t cached = priv_free_count_peek(m);
  if (cached != (uint32_t)k_fs_free_unknown) {
    *out_free = cached;
    return k_ra8_ok;
  }
  const ra8_err_t err = internal_space_fat_free(m, out_free);
  if (err != k_ra8_ok) {
    return err;
  }
  priv_free_count_cache(m, *out_free);
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_EXPECTS_LOCK("ra8_fs_lock")
static ra8_err_t internal_space_locked(const ra8_fs_mount_t* handle, ra8_fs_space_t* out)
{
  if (handle == nullptr || out == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (handle->in_use == 0U) {
    return k_ra8_err_invalid_state;
  }
  uint32_t        free_clusters = 0U;
  const ra8_err_t err           = internal_space_free_clusters(handle, &free_clusters);
  if (err != k_ra8_ok) {
    return err;
  }
  /* `free_clusters` is bounded by the volume size at its source: the FAT scan
   * counts among exactly `count_of_clusters` entries, the bitmap popcount masks
   * to the last cluster, and the cached count is clamped on the way in. So no
   * clamp is needed here. */
  const uint32_t total             = handle->count_of_clusters;
  const uint32_t bytes_per_cluster = priv_cluster_bytes(handle);
  const uint32_t used              = total - free_clusters;
  *out                             = (ra8_fs_space_t){};
  out->bytes_per_cluster           = bytes_per_cluster;
  out->total_clusters              = total;
  out->free_clusters               = free_clusters;
  out->used_clusters               = used;
  out->total_bytes                 = (uint64_t)total * (uint64_t)bytes_per_cluster;
  out->free_bytes                  = (uint64_t)free_clusters * (uint64_t)bytes_per_cluster;
  out->used_bytes                  = (uint64_t)used * (uint64_t)bytes_per_cluster;
  return k_ra8_ok;
}
 
/* =============================================================================
 * Public entry point -- the lock bracket
 * =============================================================================
 */
 
RA8_OWNS_RESOURCE("ra8_fs_lock")
ra8_err_t ra8_fs_free_space(const ra8_fs_mount_t* handle, ra8_fs_space_t* out)
{
  priv_lock_acquire();
  const ra8_err_t err = internal_space_locked(handle, out);
  priv_lock_release();
  return err;
}