ra8_fs_fat_dirmk.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"

RA8_INTERNAL
static void internal_pack_dot_entry(uint8_t* ent, uint32_t dots, uint32_t cluster)
{
  for (uint32_t i = 0; i < (uint32_t)k_ra8_fs_dir_entry_bytes; i++) {
    ent[i] = 0;
  }
  for (uint32_t i = 0; i < (uint32_t)k_dir_name_field_len; i++) {
    ent[i] = ' ';
  }
  for (uint32_t i = 0; i < dots; i++) {
    ent[i] = '.';
  }
  ent[k_dir_off_attr] = k_ra8_fs_attr_directory;
  priv_entry_set_cluster_size(ent, cluster, 0U);
  /* "." and ".." are ordinary directory entries to every host, and every mkfs
   * stamps them. Leaving them at zero would put an illegal date inside a
   * directory this firmware had just created (#601). */
  priv_fat_entry_stamp_create(ent);
}

RA8_INTERNAL
static ra8_err_t
internal_dir_cluster_init(const ra8_fs_mount_t* m, uint32_t new_cluster, uint32_t parent_cluster)
{
  uint8_t* const buf = priv_sec_walk();
  priv_byte_fill(buf, 0U, priv_bps(m));
  internal_pack_dot_entry(&buf[0], 1U, new_cluster);
  internal_pack_dot_entry(&buf[k_ra8_fs_dir_entry_bytes], 2U, parent_cluster);
  const uint64_t base = priv_cluster_to_lba(m, new_cluster);
  ra8_err_t      err  = priv_write_sector(m, base, buf);
  if (err != k_ra8_ok) {
    return err;
  }
  for (uint32_t s = 1; s < m->sectors_per_cluster; s++) {
    err = priv_write_sector(m, base + s, k_zero_sector);
    if (err != k_ra8_ok) {
      return err;
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_fat_mkdir(const ra8_fs_mount_t* handle, const char* path)
{
  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;
  }
  uint64_t lba                             = 0;
  uint32_t off                             = 0;
  uint8_t  entry[k_ra8_fs_dir_entry_bytes] = {};
  /* By long name as well as by 8.3: a second `mkdir("/Reading List")` has to
   * be refused, and the alias probe behind `priv_dir_reserve()` would happily
   * file a second copy as `READIN~2` if it were not. */
  if (priv_dir_lookup_any(handle, &parent, leaf, &lba, &off, entry) == k_ra8_ok) {
    return k_ra8_err_exists;
  }
  dir_insert_t plan = {};
  ra8_err_t    err  = priv_dir_reserve(handle, &parent, leaf, &plan);
  if (err != k_ra8_ok) {
    return err;
  }
  uint32_t new_cluster = 0;
  err                  = priv_alloc_eoc_cluster(handle, &new_cluster);
  if (err != k_ra8_ok) {
    return err;
  }
  const uint32_t parent_cluster = (parent.is_root != 0U) ? 0U : parent.cluster;
  err                           = internal_dir_cluster_init(handle, new_cluster, parent_cluster);
  if (err != k_ra8_ok) {
    (void)priv_free_chain(handle, new_cluster);
    return err;
  }
  uint8_t tmpl[k_ra8_fs_dir_entry_bytes] = {};
  tmpl[k_dir_off_attr]                   = (uint8_t)k_ra8_fs_attr_directory;
  priv_entry_set_cluster_size(tmpl, new_cluster, 0U);
  /* Same reasoning as the file case: a zero FAT date is illegal, and the
   * directory's own "." and ".." were stamped when the cluster was built, so
   * the entry in the parent must agree with them (#601). */
  priv_fat_entry_stamp_create(tmpl);
  err = priv_dir_commit(handle, &plan, tmpl, &lba, &off);
  if (err != k_ra8_ok) {
    (void)priv_free_chain(handle, new_cluster);
    return err;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_EXPECTS_LOCK("ra8_fs_lock")
static ra8_err_t internal_mkdir_locked(const ra8_fs_mount_t* handle, const char* path)
{
  if (handle == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (path == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (handle->in_use == 0U) {
    return k_ra8_err_invalid_state;
  }
  if (handle->type == k_ra8_fs_type_exfat) {
    return priv_exfat_mkdir(handle, path);
  }
  return internal_fat_mkdir(handle, path);
}

typedef enum : uint8_t {
  k_dir_scan_more  = 0U, 
  k_dir_scan_empty = 1U, 
  k_dir_scan_used  = 2U, 
} dir_scan_t;

RA8_INTERNAL
static dir_scan_t internal_rmdir_scan_sector(const ra8_fs_mount_t* m, const uint8_t* buf)
{
  for (uint32_t e = 0; e < priv_dir_eps(m); e++) {
    const uint8_t* ent = &buf[(size_t)e * (size_t)k_ra8_fs_dir_entry_bytes];
    if (ent[k_dir_off_name] == k_dir_marker_free_perm) {
      return k_dir_scan_empty;
    }
    if (ent[k_dir_off_name] == k_dir_marker_free_used) {
      continue;
    }
    if (ent[k_dir_off_attr] == k_ra8_fs_attr_lfn) {
      continue;
    }
    if (ent[k_dir_off_name] == k_dir_marker_dot) {
      continue;
    }
    return k_dir_scan_used;
  }
  return k_dir_scan_more;
}

RA8_INTERNAL
static ra8_err_t
internal_dir_is_empty(const ra8_fs_mount_t* m, uint32_t cluster, uint8_t* out_empty)
{
  const dir_loc_t loc = {.is_root = 0U, .cluster = cluster};
  dir_walk_t      w   = {};
  priv_dir_walk_init_loc(m, &loc, &w);
  uint8_t        eod = 0;
  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;
    }
    const dir_scan_t verdict = internal_rmdir_scan_sector(m, buf);
    if (verdict == k_dir_scan_used) {
      *out_empty = 0U;
      return k_ra8_ok;
    }
    if (verdict == k_dir_scan_empty) {
      *out_empty = 1U;
      return k_ra8_ok;
    }
    err = priv_dir_walk_next_sector(m, &w, &eod);
    if (err != k_ra8_ok) {
      return err;
    }
  }
  *out_empty = 1U; /* chain exhausted with no occupant and no 0x00 marker */
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_rmdir_locate(const ra8_fs_mount_t* handle,
                                       const char*           path,
                                       dir_target_t*         out,
                                       uint32_t*             out_cluster)
{
  const char*     leaf = nullptr;
  const ra8_err_t rerr = priv_resolve_parent(handle, path, &out->parent, &leaf);
  if (rerr != k_ra8_ok) {
    return rerr;
  }
  if (leaf[0] == '\0') {
    return k_ra8_err_invalid_arg; /* "/" or a trailing slash: the root itself */
  }
  const ra8_err_t err =
    priv_dir_lookup_any(handle, &out->parent, leaf, &out->lba, &out->off, out->entry);
  if (err != k_ra8_ok) {
    return err;
  }
  if ((out->entry[k_dir_off_attr] & (uint8_t)k_ra8_fs_attr_directory) == 0U) {
    return k_ra8_err_invalid_arg; /* a file: ra8_fs_unlink() is the verb for it */
  }
  *out_cluster = priv_entry_first_cluster(out->entry);
  if (*out_cluster < (uint32_t)k_cluster_first_data) {
    return k_ra8_err_protocol_error; /* a directory always owns a cluster */
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_fat_rmdir(const ra8_fs_mount_t* handle, const char* path)
{
  dir_target_t t       = {};
  uint32_t     cluster = 0;
  ra8_err_t    err     = internal_rmdir_locate(handle, path, &t, &cluster);
  if (err != k_ra8_ok) {
    return err;
  }
  uint8_t empty = 0;
  err           = internal_dir_is_empty(handle, cluster, &empty);
  if (err != k_ra8_ok) {
    return err;
  }
  if (empty == 0U) {
    return k_ra8_err_not_empty;
  }
  err = priv_free_chain(handle, cluster);
  if (err != k_ra8_ok) {
    return err;
  }
  return priv_dir_erase_chain(handle, &t.parent, t.lba, t.off, &t.entry[k_dir_off_name]);
}

RA8_INTERNAL
RA8_EXPECTS_LOCK("ra8_fs_lock")
static ra8_err_t internal_rmdir_locked(const ra8_fs_mount_t* handle, const char* path)
{
  if (handle == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (path == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (handle->in_use == 0U) {
    return k_ra8_err_invalid_state;
  }
  if (handle->type == k_ra8_fs_type_exfat) {
    return priv_exfat_rmdir(handle, path);
  }
  return internal_fat_rmdir(handle, path);
}
 
/* =============================================================================
 * Public entry points -- the lock brackets
 * =============================================================================
 */
 
RA8_OWNS_RESOURCE("ra8_fs_lock")
ra8_err_t ra8_fs_mkdir(const ra8_fs_mount_t* handle, const char* path)
{
  priv_lock_acquire();
  const ra8_err_t err = internal_mkdir_locked(handle, path);
  priv_lock_release();
  return err;
}
 
RA8_OWNS_RESOURCE("ra8_fs_lock")
ra8_err_t ra8_fs_rmdir(const ra8_fs_mount_t* handle, const char* path)
{
  priv_lock_acquire();
  const ra8_err_t err = internal_rmdir_locked(handle, path);
  priv_lock_release();
  return err;
}