ra8_fs_fat_alloc.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"
 
/* =============================================================================
 * Module state
 * =============================================================================
 */

typedef struct {
  const ra8_fs_mount_t* owner;      
  uint32_t              next_free;  
  uint32_t              free_count; 
  uint32_t              fsinfo_lba; 
  uint64_t              bitmap_lba; 
  uint8_t               dirty;      
} fat_alloc_state_t;

static fat_alloc_state_t s_alloc[k_fs_alloc_slots] = {};
 
static_assert((uint32_t)k_fs_alloc_slots == (uint32_t)k_ra8_fs_max_mounts,
              "one allocator state slot per mount slot, or a bind can fail");

static uint8_t s_fat_cache[k_ra8_fs_sector_max] = {};

static uint64_t s_fat_cache_lba = k_fs_cache_empty;

static const ra8_fs_mount_t* s_fat_cache_owner = nullptr;
 
/* =============================================================================
 * Slot lookup
 * =============================================================================
 */

RA8_INTERNAL
static fat_alloc_state_t* internal_state_for(const ra8_fs_mount_t* m)
{
  for (uint32_t i = 0U; i < (uint32_t)k_fs_alloc_slots; i++) {
    if (s_alloc[i].owner == m) {
      return &s_alloc[i];
    }
  }
  return nullptr;
}
 
/* `priv_alloc_state_bind()`: see header for the documented contract. */
void priv_alloc_state_bind(const ra8_fs_mount_t* m)
{
  fat_alloc_state_t* st = internal_state_for(m);
  if (st == nullptr) {
    st = internal_state_for(nullptr);
  }
  if (st == nullptr) {
    return;
  }
  st->owner      = m;
  st->next_free  = (uint32_t)k_cluster_first_data;
  st->free_count = (uint32_t)k_fs_free_unknown;
  st->fsinfo_lba = (uint32_t)k_fs_fsinfo_absent;
  st->bitmap_lba = (uint64_t)k_fs_bitmap_unknown;
  st->dirty      = 0U;
}
 
/* `priv_exfat_bitmap_lba()`: see header for the documented contract. */
ra8_err_t priv_exfat_bitmap_lba(const ra8_fs_mount_t* m, uint64_t* out_lba)
{
  /* Nested rather than joined: a mount with no bound slot is not a mount with
   * a cold cache, and there is no input that can produce the first -- every
   * accessor in this file is total by construction, because there is one slot
   * per mount slot. Spelling the pair as one compound decision would add a
   * condition nothing can vary, which is a permanent MC/DC hole. */
  fat_alloc_state_t* st = internal_state_for(m);
  if (st != nullptr) {
    if (st->bitmap_lba != (uint64_t)k_fs_bitmap_unknown) {
      *out_lba = st->bitmap_lba;
      return k_ra8_ok;
    }
  }
  uint32_t        clus = 0U;
  uint32_t        len  = 0U;
  const ra8_err_t e    = priv_exfat_find_bitmap(m, &clus, &len);
  if (e != k_ra8_ok) {
    return e;
  }
  const uint64_t lba = priv_cluster_to_lba(m, clus);
  if (st != nullptr) {
    st->bitmap_lba = lba;
  }
  *out_lba = lba;
  return k_ra8_ok;
}
 
/* `priv_alloc_state_release()`: see header for the documented contract. */
void priv_alloc_state_release(const ra8_fs_mount_t* m)
{
  fat_alloc_state_t* st = internal_state_for(m);
  if (st != nullptr) {
    *st = (fat_alloc_state_t){};
  }
  if (s_fat_cache_owner == m) {
    s_fat_cache_lba   = (uint64_t)k_fs_cache_empty;
    s_fat_cache_owner = nullptr;
  }
}
 
/* =============================================================================
 * FAT sector cache
 * =============================================================================
 */

RA8_INTERNAL
static bool internal_lba_is_cacheable(const ra8_fs_mount_t* m, uint64_t lba)
{
  return (lba - m->first_fat_lba) < m->fat_size_sectors;
}
 
/* `priv_fat_sector_read()`: see header for the documented contract. */
ra8_err_t priv_fat_sector_read(const ra8_fs_mount_t* m, uint64_t lba, uint8_t* buf)
{
  if (!internal_lba_is_cacheable(m, lba)) {
    return priv_read_sector(m, lba, buf);
  }
  if ((s_fat_cache_owner == m) && (s_fat_cache_lba == lba)) {
    priv_byte_copy(buf, s_fat_cache, priv_bps(m));
    return k_ra8_ok;
  }
  const ra8_err_t err = priv_read_sector(m, lba, buf);
  if (err != k_ra8_ok) {
    return err;
  }
  priv_byte_copy(s_fat_cache, buf, priv_bps(m));
  s_fat_cache_lba   = lba;
  s_fat_cache_owner = m;
  return k_ra8_ok;
}
 
/* `priv_fat_sector_wrote()`: see header for the documented contract. */
void priv_fat_sector_wrote(const ra8_fs_mount_t* m, const uint8_t* buf, uint64_t lba)
{
  if (!internal_lba_is_cacheable(m, lba)) {
    return;
  }
  priv_byte_copy(s_fat_cache, buf, priv_bps(m));
  s_fat_cache_lba   = lba;
  s_fat_cache_owner = m;
}
 
/* =============================================================================
 * Next-free hint and free-cluster count
 * =============================================================================
 */
 
/* `priv_alloc_hint_get()`: see header for the documented contract. */
uint32_t priv_alloc_hint_get(const ra8_fs_mount_t* m)
{
  const fat_alloc_state_t* st = internal_state_for(m);
  if (st == nullptr) {
    return (uint32_t)k_cluster_first_data;
  }
  return st->next_free;
}
 
/* `priv_alloc_hint_set()`: see header for the documented contract. */
void priv_alloc_hint_set(const ra8_fs_mount_t* m, uint32_t cluster)
{
  fat_alloc_state_t* st = internal_state_for(m);
  if (st == nullptr) {
    return;
  }
  st->next_free = cluster;
}
 
/* `priv_alloc_hint_lower()`: see header for the documented contract. */
void priv_alloc_hint_lower(const ra8_fs_mount_t* m, uint32_t cluster)
{
  fat_alloc_state_t* st = internal_state_for(m);
  if (st == nullptr) {
    return;
  }
  if (cluster < st->next_free) {
    st->next_free = cluster;
  }
}
 
/* `priv_free_count_took()`: see header for the documented contract. */
void priv_free_count_took(const ra8_fs_mount_t* m, uint32_t n)
{
  fat_alloc_state_t* st = internal_state_for(m);
  if (st == nullptr) {
    return;
  }
  st->dirty = 1U;
  if (st->free_count == (uint32_t)k_fs_free_unknown) {
    return;
  }
  st->free_count = (st->free_count >= n) ? (st->free_count - n) : 0U;
}
 
/* `priv_free_count_gave()`: see header for the documented contract. */
void priv_free_count_gave(const ra8_fs_mount_t* m, uint32_t n)
{
  fat_alloc_state_t* st = internal_state_for(m);
  if (st == nullptr) {
    return;
  }
  st->dirty = 1U;
  if (st->free_count == (uint32_t)k_fs_free_unknown) {
    return;
  }
  const uint32_t raised = st->free_count + n;
  st->free_count        = (raised > m->count_of_clusters) ? m->count_of_clusters : raised;
}
 
/* `priv_free_count_peek()`: see header for the documented contract. */
uint32_t priv_free_count_peek(const ra8_fs_mount_t* m)
{
  const fat_alloc_state_t* st = internal_state_for(m);
  if (st == nullptr) {
    return (uint32_t)k_fs_free_unknown;
  }
  return st->free_count;
}
 
/* `priv_free_count_cache()`: see header for the documented contract. */
void priv_free_count_cache(const ra8_fs_mount_t* m, uint32_t n)
{
  fat_alloc_state_t* st = internal_state_for(m);
  if (st == nullptr) {
    return;
  }
  st->free_count = (n > m->count_of_clusters) ? m->count_of_clusters : n;
}
 
/* =============================================================================
 * FAT32 FSInfo (MS FAT spec sec 5)
 * =============================================================================
 */

RA8_INTERNAL
static ra8_err_t internal_fsinfo_locate(const ra8_fs_mount_t* m, uint32_t* out_lba)
{
  uint8_t* const  boot = priv_sec_walk();
  const ra8_err_t err  = priv_read_sector(m, 0U, boot);
  if (err != k_ra8_ok) {
    return err;
  }
  const uint32_t lba = (uint32_t)priv_rd16(&boot[k_fmt_off_f32_fsinfo]);
  *out_lba           = (uint32_t)k_fs_fsinfo_absent;
  if (lba == (uint32_t)k_fs_fsinfo_absent) {
    return k_ra8_ok;
  }
  if (lba >= m->reserved_sectors) {
    return k_ra8_ok;
  }
  *out_lba = lba;
  return k_ra8_ok;
}

RA8_INTERNAL
static bool internal_fsinfo_signatures_ok(const uint8_t* sec)
{
  if (priv_rd32(&sec[k_fmt_fsi_off_lead]) != (uint32_t)k_fmt_fsi_lead_sig) {
    return false;
  }
  if (priv_rd32(&sec[k_fmt_fsi_off_struct]) != (uint32_t)k_fmt_fsi_struct_sig) {
    return false;
  }
  return priv_rd32(&sec[k_fmt_fsi_off_trail]) == (uint32_t)k_fmt_fsi_trail_sig;
}
 
/* `priv_fsinfo_seed()`: see header for the documented contract. */
ra8_err_t priv_fsinfo_seed(const ra8_fs_mount_t* m)
{
  fat_alloc_state_t* st = internal_state_for(m);
  if (st == nullptr) {
    return k_ra8_ok;
  }
  if (m->type != k_ra8_fs_type_fat32) {
    return k_ra8_ok;
  }
  uint32_t  lba = (uint32_t)k_fs_fsinfo_absent;
  ra8_err_t err = internal_fsinfo_locate(m, &lba);
  if (err != k_ra8_ok) {
    return err;
  }
  if (lba == (uint32_t)k_fs_fsinfo_absent) {
    return k_ra8_ok;
  }
  uint8_t* const sec = priv_sec_walk();
  err                = priv_read_sector(m, lba, sec);
  if (err != k_ra8_ok) {
    return err;
  }
  if (!internal_fsinfo_signatures_ok(sec)) {
    return k_ra8_ok;
  }
  st->fsinfo_lba      = lba;
  const uint32_t nxt  = priv_rd32(&sec[k_fmt_fsi_off_nxtfree]);
  const uint32_t free = priv_rd32(&sec[k_fmt_fsi_off_free]);
  if (nxt >= (uint32_t)k_cluster_first_data) {
    if ((nxt - (uint32_t)k_cluster_first_data) < m->count_of_clusters) {
      st->next_free = nxt;
    }
  }
  if (free <= m->count_of_clusters) {
    st->free_count = free;
  }
  return k_ra8_ok;
}
 
/* `priv_fsinfo_flush()`: see header for the documented contract. */
ra8_err_t priv_fsinfo_flush(const ra8_fs_mount_t* m)
{
  fat_alloc_state_t* st = internal_state_for(m);
  if (st == nullptr) {
    return k_ra8_ok;
  }
  if (st->fsinfo_lba == (uint32_t)k_fs_fsinfo_absent) {
    return k_ra8_ok;
  }
  if (st->dirty == 0U) {
    return k_ra8_ok;
  }
  uint8_t* const sec = priv_sec_walk();
  ra8_err_t      err = priv_read_sector(m, st->fsinfo_lba, sec);
  if (err != k_ra8_ok) {
    return err;
  }
  priv_wr32(&sec[k_fmt_fsi_off_free], st->free_count);
  priv_wr32(&sec[k_fmt_fsi_off_nxtfree], st->next_free);
  err = priv_write_sector(m, st->fsinfo_lba, sec);
  if (err != k_ra8_ok) {
    return err;
  }
  st->dirty = 0U;
  return k_ra8_ok;
}