ra8_fs_fat_lfn_write.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 : uint32_t {
  k_lfnw_grow_max = 3U, 
} ra8_fs_lfnw_local_t;
 
/* =============================================================================
 * Alias generation
 * =============================================================================
 */

RA8_INTERNAL
static ra8_err_t internal_alias_unique(const ra8_fs_mount_t* m,
                                       const dir_loc_t*      loc,
                                       const uint16_t*       leaf,
                                       uint32_t              n,
                                       uint8_t*              out11)
{
  uint64_t lba                             = 0U;
  uint32_t off                             = 0U;
  uint8_t  entry[k_ra8_fs_dir_entry_bytes] = {};
  for (uint32_t tail = 1U; tail <= (uint32_t)k_lfn_alias_tail_max; tail++) {
    priv_lfn_alias_basis(leaf, n, tail, out11);
    const ra8_err_t err = priv_dir_find(m, loc, out11, &lba, &off, entry);
    if (err == k_ra8_err_not_found) {
      return k_ra8_ok;
    }
    if (err != k_ra8_ok) {
      return err;
    }
  }
  /* Unreachable in practice: exhausting this needs 999999 entries sharing one
   * basis name, and the largest directory this driver can mount holds far
   * fewer. It is the Rule 2 bound's honest failure answer, not dead code. */
  return k_ra8_err_no_mem; /* GCOVR_EXCL_LINE -- million-alias exhaustion, bounded-loop fallback */
}
 
/* =============================================================================
 * Free-slot runs and directory growth
 * =============================================================================
 */

RA8_INTERNAL
static uint8_t internal_slot_is_free(const uint8_t* ent)
{
  if ((ent[k_dir_off_name] == (uint8_t)k_dir_marker_free_perm) ||
      (ent[k_dir_off_name] == (uint8_t)k_dir_marker_free_used)) {
    return 1U;
  }
  return 0U;
}
 
/* `priv_dir_find_free_run()`: see header for the documented contract. */
ra8_err_t priv_dir_find_free_run(const ra8_fs_mount_t* m,
                                 const dir_loc_t*      loc,
                                 uint32_t              need,
                                 dir_slot_t*           out)
{
  dir_walk_t w = {};
  priv_dir_walk_init_loc(m, loc, &w);
  dir_slot_t     start = {};
  uint32_t       run   = 0U;
  uint8_t        eod   = 0U;
  uint8_t* const buf   = priv_sec_walk();
  while (eod == 0U) {
    ra8_err_t err = priv_read_sector(m, w.cur_lba, buf);
    if (err != k_ra8_ok) {
      return err;
    }
    for (uint32_t e = 0U; e < priv_dir_eps(m); e++) {
      if (internal_slot_is_free(&buf[(size_t)e * (size_t)k_ra8_fs_dir_entry_bytes]) == 0U) {
        run = 0U;
        continue;
      }
      if (run == 0U) {
        start.w   = w;
        start.ent = e;
      }
      run++;
      if (run >= need) {
        *out = start;
        return k_ra8_ok;
      }
    }
    err = priv_dir_walk_next_sector(m, &w, &eod);
    if (err != k_ra8_ok) {
      return err;
    }
  }
  return k_ra8_err_no_mem;
}

RA8_INTERNAL
static ra8_err_t internal_dir_grow(const ra8_fs_mount_t* m, const dir_loc_t* loc)
{
  if ((loc->is_root != 0U) && (m->type != k_ra8_fs_type_fat32)) {
    return k_ra8_err_no_mem; /* the FAT12/16 root is a fixed sector region */
  }
  /* Walk to the chain's last cluster with the shared directory iterator rather
   * than a second FAT walk of this file's own: the iterator already carries
   * the cycle guard, and two walks that could disagree about where a directory
   * ends is exactly the kind of duplication that goes wrong quietly. */
  dir_walk_t w = {};
  priv_dir_walk_init_loc(m, loc, &w);
  uint32_t last = w.cluster;
  uint8_t  eod  = 0U;
  while (eod == 0U) {
    last                 = w.cluster;
    const ra8_err_t werr = priv_dir_walk_next_sector(m, &w, &eod);
    if (werr != k_ra8_ok) {
      return werr;
    }
  }
  uint32_t  fresh = 0U;
  ra8_err_t err   = priv_alloc_eoc_cluster(m, &fresh);
  if (err != k_ra8_ok) {
    return err;
  }
  const uint64_t base = priv_cluster_to_lba(m, fresh);
  for (uint32_t s = 0U; s < m->sectors_per_cluster; s++) {
    err = priv_write_sector(m, base + s, k_zero_sector);
    if (err != k_ra8_ok) {
      (void)priv_free_chain(m, fresh);
      return err;
    }
  }
  err = priv_fat_set(m, last, fresh);
  if (err != k_ra8_ok) {
    (void)priv_free_chain(m, fresh);
    return err;
  }
  return k_ra8_ok;
}
 
/* =============================================================================
 * Reserve / commit
 * =============================================================================
 */
 
/* `priv_dir_reserve()`: see header for the documented contract. */
ra8_err_t
priv_dir_reserve(const ra8_fs_mount_t* m, const dir_loc_t* loc, const char* leaf, dir_insert_t* out)
{
  out->lfn_entries = 0U;
  out->nunits      = 0U;
  const ra8_fs_name_kind_t kind =
    priv_name_classify(leaf, out->units, &out->nunits, out->name83, &out->ntres);
  if (kind == k_name_kind_invalid) {
    return k_ra8_err_invalid_arg;
  }
  uint32_t need = 1U;
  if (kind == k_name_kind_long) {
    const ra8_err_t aerr = internal_alias_unique(m, loc, out->units, out->nunits, out->name83);
    if (aerr != k_ra8_ok) {
      return aerr;
    }
    out->ntres = 0U; /* the chain carries the case; the alias is upper-case */
    /* Groups of THIRTEEN CODE UNITS -- the slot's capacity. Deriving this from
     * a byte count put a 2-byte character's worth of slots on a 1-unit
     * character, and the chain then disagreed with its own contents (#606). */
    out->lfn_entries = (uint8_t)(((out->nunits + (uint32_t)k_lfn_chars_per_ent) - 1U) /
                                 (uint32_t)k_lfn_chars_per_ent);
    need             = (uint32_t)out->lfn_entries + 1U;
  }
  for (uint32_t attempt = 0U; attempt <= (uint32_t)k_lfnw_grow_max; attempt++) {
    const ra8_err_t ferr = priv_dir_find_free_run(m, loc, need, &out->start);
    if (ferr != k_ra8_err_no_mem) {
      return ferr;
    }
    if (attempt == (uint32_t)k_lfnw_grow_max) {
      break; /* growing again would only link a cluster nothing then uses */
    }
    const ra8_err_t gerr = internal_dir_grow(m, loc);
    if (gerr != k_ra8_ok) {
      return gerr;
    }
  }
  return k_ra8_err_no_mem;
}

RA8_INTERNAL
static ra8_err_t
internal_slot_advance(const ra8_fs_mount_t* m, dir_slot_t* cur, uint8_t* buf, uint64_t* lba_io)
{
  cur->ent++;
  if (cur->ent < priv_dir_eps(m)) {
    return k_ra8_ok;
  }
  ra8_err_t err = priv_write_sector(m, *lba_io, buf);
  if (err != k_ra8_ok) {
    return err;
  }
  uint8_t eod = 0U;
  err         = priv_dir_walk_next_sector(m, &cur->w, &eod);
  if (err != k_ra8_ok) {
    return err;
  }
  if (eod != 0U) {
    return k_ra8_err_no_mem; /* the reserved run ran off the directory's end */
  }
  cur->ent = 0U;
  *lba_io  = cur->w.cur_lba;
  return priv_read_sector(m, *lba_io, buf);
}
 
/* `priv_dir_commit()`: see header for the documented contract. */
ra8_err_t priv_dir_commit(const ra8_fs_mount_t* m,
                          const dir_insert_t*   plan,
                          const uint8_t*        tmpl,
                          uint64_t*             out_lba,
                          uint32_t*             out_off)
{
  const uint32_t nlen  = (plan->lfn_entries != 0U) ? plan->nunits : 0U;
  const uint8_t  csum  = priv_sfn_checksum(plan->name83);
  const uint32_t total = (uint32_t)plan->lfn_entries + 1U;
  dir_slot_t     cur   = plan->start;
  uint64_t       lba   = cur.w.cur_lba;
  uint8_t* const buf   = priv_sec_walk();
  ra8_err_t      err   = priv_read_sector(m, lba, buf);
  if (err != k_ra8_ok) {
    return err;
  }
  for (uint32_t i = 0U; i < total; i++) {
    uint8_t* slot = &buf[(size_t)cur.ent * (size_t)k_ra8_fs_dir_entry_bytes];
    if (i < (uint32_t)plan->lfn_entries) {
      priv_lfn_fill_slot(slot,
                         plan->units,
                         nlen,
                         (uint32_t)plan->lfn_entries - i,
                         (uint8_t)((i == 0U) ? 1U : 0U),
                         csum);
    } else {
      priv_byte_copy(slot, tmpl, (uint32_t)k_ra8_fs_dir_entry_bytes);
      priv_byte_copy(&slot[k_dir_off_name], plan->name83, (uint32_t)k_dir_name_field_len);
      slot[k_dir_off_ntres] = plan->ntres;
      *out_lba              = lba;
      *out_off              = cur.ent * (uint32_t)k_ra8_fs_dir_entry_bytes;
    }
    if ((i + 1U) < total) {
      err = internal_slot_advance(m, &cur, buf, &lba);
      if (err != k_ra8_ok) {
        return err;
      }
    }
  }
  return priv_write_sector(m, lba, buf);
}
 
/* =============================================================================
 * Deletion -- the 8.3 entry AND the chain in front of it
 * =============================================================================
 */

RA8_INTERNAL
static void internal_run_push(dir_pos_t* run, uint32_t* len_io, uint64_t lba, uint32_t off)
{
  uint32_t len = *len_io;
  if (len == (uint32_t)k_lfn_erase_max) {
    for (uint32_t i = 1U; i < (uint32_t)k_lfn_erase_max; i++) {
      run[i - 1U] = run[i];
    }
    len--;
  }
  run[len].lba = lba;
  run[len].off = off;
  *len_io      = len + 1U;
}

RA8_INTERNAL
static ra8_err_t internal_dir_collect_chain(const ra8_fs_mount_t* m,
                                            const dir_loc_t*      loc,
                                            uint64_t              tlba,
                                            uint32_t              toff,
                                            uint8_t               csum,
                                            dir_pos_t*            run,
                                            uint32_t*             out_len)
{
  dir_walk_t w = {};
  priv_dir_walk_init_loc(m, loc, &w);
  uint32_t       len = 0U;
  uint8_t        eod = 0U;
  uint8_t* const buf = priv_sec_walk();
  while (eod == 0U) {
    ra8_err_t err = priv_read_sector(m, w.cur_lba, buf);
    if (err != k_ra8_ok) {
      return err;
    }
    for (uint32_t e = 0U; e < priv_dir_eps(m); e++) {
      const uint32_t off = e * (uint32_t)k_ra8_fs_dir_entry_bytes;
      if ((w.cur_lba == tlba) && (off == toff)) {
        *out_len = len;
        return k_ra8_ok;
      }
      const uint8_t* ent = &buf[off];
      if ((ent[k_dir_off_attr] == (uint8_t)k_ra8_fs_attr_lfn) &&
          (ent[k_dir_off_name] != (uint8_t)k_dir_marker_free_used) &&
          (ent[k_lfn_off_checksum] == csum)) {
        internal_run_push(run, &len, w.cur_lba, off);
      } else {
        len = 0U;
      }
    }
    err = priv_dir_walk_next_sector(m, &w, &eod);
    if (err != k_ra8_ok) {
      return err;
    }
  }
  return k_ra8_err_not_found;
}

RA8_INTERNAL
static ra8_err_t
internal_dir_erase_positions(const ra8_fs_mount_t* m, const dir_pos_t* pos, uint32_t count)
{
  uint8_t* const buf = priv_sec_walk();
  uint64_t       cur = pos[0].lba;
  ra8_err_t      err = priv_read_sector(m, cur, buf);
  if (err != k_ra8_ok) {
    return err;
  }
  for (uint32_t i = 0U; i < count; i++) {
    if (pos[i].lba != cur) {
      err = priv_write_sector(m, cur, buf);
      if (err != k_ra8_ok) {
        return err;
      }
      cur = pos[i].lba;
      err = priv_read_sector(m, cur, buf);
      if (err != k_ra8_ok) {
        return err;
      }
    }
    buf[pos[i].off + (uint32_t)k_dir_off_name] = (uint8_t)k_dir_marker_free_used;
  }
  return priv_write_sector(m, cur, buf);
}
 
/* `priv_dir_erase_chain()`: see header for the documented contract. */
ra8_err_t priv_dir_erase_chain(const ra8_fs_mount_t* m,
                               const dir_loc_t*      loc,
                               uint64_t              lba,
                               uint32_t              off,
                               const uint8_t*        name83)
{
  dir_pos_t       all[(uint32_t)k_lfn_erase_max + 1U] = {};
  uint32_t        len                                 = 0U;
  const ra8_err_t cerr =
    internal_dir_collect_chain(m, loc, lba, off, priv_sfn_checksum(name83), all, &len);
  if (cerr != k_ra8_ok) {
    return cerr;
  }
  all[len].lba = lba;
  all[len].off = off;
  return internal_dir_erase_positions(m, all, len + 1U);
}
 
/* `priv_dir_lookup_any()`: see header for the documented contract. */
ra8_err_t priv_dir_lookup_any(const ra8_fs_mount_t* m,
                              const dir_loc_t*      loc,
                              const char*           leaf,
                              uint64_t*             out_lba,
                              uint32_t*             out_off,
                              uint8_t               out_entry[k_ra8_fs_dir_entry_bytes])
{
  uint8_t   name83[k_max_8_3_name] = {};
  ra8_err_t err                    = k_ra8_err_not_found;
  if (priv_path_to_83(leaf, name83) != 0U) {
    err = priv_dir_find(m, loc, name83, out_lba, out_off, out_entry);
  }
  if (err == k_ra8_err_not_found) {
    /* A name that is not 8.3-representable, or one whose 8.3 lookup missed
     * because the file is filed under a generated `~N` alias, can still match
     * the reassembled long name. */
    err = priv_dir_find_long(m, loc, leaf, out_lba, out_off, out_entry);
  }
  return err;
}