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

RA8_INTERNAL
static uint32_t internal_fat_boot_label_off(const ra8_fs_mount_t* m)
{
  return (m->type == k_ra8_fs_type_fat32) ? (uint32_t)k_fmt_off_f32_label
                                          : (uint32_t)k_fmt_off_f16_label;
}

RA8_INTERNAL
static void internal_label_from_raw(const uint8_t* raw11, char* out, uint32_t out_len)
{
  static const uint8_t k_no_name[k_fmt_label_len] =
    {'N', 'O', ' ', 'N', 'A', 'M', 'E', ' ', ' ', ' ', ' '};
  if (priv_byte_equal(raw11, k_no_name, (uint32_t)k_fmt_label_len) != 0U) {
    out[0] = '\0';
    return;
  }
  /* BS_VolLab and the ATTR_VOLUME_ID name are space-padded by the FAT spec (and
   * by ::priv_fmt_label_field), so trailing spaces are the only padding to trim. */
  uint32_t n = (uint32_t)k_fmt_label_len;
  while (n > 0U) {
    if (raw11[n - 1U] != (uint8_t)' ') {
      break;
    }
    n--;
  }
  uint32_t w = 0U;
  for (uint32_t i = 0U; i < n; i++) {
    if ((w + 1U) >= out_len) {
      break;
    }
    out[w] = (char)raw11[i];
    w++;
  }
  out[w] = '\0';
}

RA8_INTERNAL
static ra8_err_t internal_fat_find_vol_id(const ra8_fs_mount_t* m,
                                          uint64_t*             out_lba,
                                          uint32_t*             out_off,
                                          uint8_t*              out_entry)
{
  const dir_loc_t loc = {.is_root = 1U, .cluster = 0U};
  dir_walk_t      w   = {};
  priv_dir_walk_init_loc(m, &loc, &w);
  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;
      const uint8_t  name0 = buf[off + (uint32_t)k_dir_off_name];
      const uint8_t  attr  = buf[off + (uint32_t)k_dir_off_attr];
      if (name0 == (uint8_t)k_dir_marker_free_perm) {
        return k_ra8_err_not_found;
      }
      if (name0 == (uint8_t)k_dir_marker_free_used) {
        continue;
      }
      if (attr == (uint8_t)k_ra8_fs_attr_lfn) {
        continue;
      }
      if ((attr & (uint8_t)k_ra8_fs_attr_volume_id) != 0U) {
        *out_lba = w.cur_lba;
        *out_off = off;
        priv_byte_copy(out_entry, &buf[off], (uint32_t)k_ra8_fs_dir_entry_bytes);
        return k_ra8_ok;
      }
    }
    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_fat_find_free_root(const ra8_fs_mount_t* m, uint64_t* out_lba, uint32_t* out_off)
{
  const dir_loc_t loc = {.is_root = 1U, .cluster = 0U};
  dir_walk_t      w   = {};
  priv_dir_walk_init_loc(m, &loc, &w);
  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;
      const uint8_t  name0 = buf[off + (uint32_t)k_dir_off_name];
      if ((name0 == (uint8_t)k_dir_marker_free_perm) ||
          (name0 == (uint8_t)k_dir_marker_free_used)) {
        *out_lba = w.cur_lba;
        *out_off = off;
        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_fat_boot_set_label(const ra8_fs_mount_t* m, const char* label)
{
  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;
  }
  priv_fmt_label_field(&boot[internal_fat_boot_label_off(m)], label);
  return priv_write_sector(m, 0U, boot);
}

RA8_INTERNAL
static ra8_err_t internal_fat_del_entry(const ra8_fs_mount_t* m, uint64_t lba, uint32_t off)
{
  uint8_t* const  sec = priv_sec_walk();
  const ra8_err_t err = priv_read_sector(m, lba, sec);
  if (err != k_ra8_ok) {
    return err;
  }
  sec[off + (uint32_t)k_dir_off_name] = (uint8_t)k_dir_marker_free_used;
  return priv_write_sector(m, lba, sec);
}

RA8_INTERNAL
static ra8_err_t internal_fat_put_vol_id(const ra8_fs_mount_t* m,
                                         uint64_t              lba,
                                         uint32_t              off,
                                         const char*           label,
                                         bool                  fresh)
{
  uint8_t* const  sec = priv_sec_walk();
  const ra8_err_t err = priv_read_sector(m, lba, sec);
  if (err != k_ra8_ok) {
    return err;
  }
  uint8_t* e = &sec[off];
  if (fresh) {
    for (uint32_t i = 0U; i < (uint32_t)k_ra8_fs_dir_entry_bytes; i++) {
      e[i] = 0U;
    }
  }
  priv_fmt_label_field(&e[k_dir_off_name], label);
  e[k_dir_off_attr] = (uint8_t)k_ra8_fs_attr_volume_id;
  if (fresh) {
    priv_fat_entry_stamp_create(e);
  } else {
    priv_fat_entry_stamp_write(e);
  }
  return priv_write_sector(m, lba, sec);
}

RA8_INTERNAL
static ra8_err_t internal_get_label_fat(const ra8_fs_mount_t* m, char* out, uint32_t out_len)
{
  uint8_t         raw[k_fmt_label_len]            = {};
  uint64_t        lba                             = 0U;
  uint32_t        off                             = 0U;
  uint8_t         entry[k_ra8_fs_dir_entry_bytes] = {};
  const ra8_err_t ferr                            = internal_fat_find_vol_id(m, &lba, &off, entry);
  if (ferr == k_ra8_ok) {
    priv_byte_copy(raw, &entry[k_dir_off_name], (uint32_t)k_fmt_label_len);
  } else if (ferr == k_ra8_err_not_found) {
    uint8_t* const  boot = priv_sec_walk();
    const ra8_err_t berr = priv_read_sector(m, 0U, boot);
    if (berr != k_ra8_ok) {
      return berr;
    }
    priv_byte_copy(raw, &boot[internal_fat_boot_label_off(m)], (uint32_t)k_fmt_label_len);
  } else {
    return ferr;
  }
  internal_label_from_raw(raw, out, out_len);
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_set_label_fat(const ra8_fs_mount_t* m, const char* label)
{
  const bool      clearing = (label == nullptr) || (label[0] == '\0');
  const ra8_err_t berr     = internal_fat_boot_set_label(m, label);
  if (berr != k_ra8_ok) {
    return berr;
  }
  uint64_t        lba                             = 0U;
  uint32_t        off                             = 0U;
  uint8_t         entry[k_ra8_fs_dir_entry_bytes] = {};
  const ra8_err_t ferr                            = internal_fat_find_vol_id(m, &lba, &off, entry);
  if ((ferr != k_ra8_ok) && (ferr != k_ra8_err_not_found)) {
    return ferr;
  }
  if (clearing) {
    return (ferr == k_ra8_ok) ? internal_fat_del_entry(m, lba, off) : k_ra8_ok;
  }
  if (ferr == k_ra8_ok) {
    return internal_fat_put_vol_id(m, lba, off, label, false);
  }
  const ra8_err_t serr = internal_fat_find_free_root(m, &lba, &off);
  if (serr != k_ra8_ok) {
    return serr;
  }
  return internal_fat_put_vol_id(m, lba, off, label, true);
}

RA8_INTERNAL
RA8_EXPECTS_LOCK("ra8_fs_lock")
static ra8_err_t
internal_get_label_locked(const ra8_fs_mount_t* handle, char* out, uint32_t out_len)
{
  if (handle == nullptr || out == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (out_len == 0U) {
    return k_ra8_err_invalid_arg;
  }
  if (handle->in_use == 0U) {
    return k_ra8_err_invalid_state;
  }
  out[0] = '\0';
  if (handle->type == k_ra8_fs_type_exfat) {
    return priv_exfat_get_label(handle, out, out_len);
  }
  return internal_get_label_fat(handle, out, out_len);
}

RA8_INTERNAL
RA8_EXPECTS_LOCK("ra8_fs_lock")
static ra8_err_t internal_set_label_locked(const ra8_fs_mount_t* handle, const char* label)
{
  if (handle == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (handle->in_use == 0U) {
    return k_ra8_err_invalid_state;
  }
  if ((label != nullptr) && (priv_strlen(label) > (uint32_t)k_fmt_label_len)) {
    return k_ra8_err_invalid_arg;
  }
  if (handle->type == k_ra8_fs_type_exfat) {
    return priv_exfat_set_label(handle, label);
  }
  return internal_set_label_fat(handle, label);
}
 
/* =============================================================================
 * Public entry points -- the lock brackets
 * =============================================================================
 */
 
RA8_OWNS_RESOURCE("ra8_fs_lock")
ra8_err_t ra8_fs_get_label(const ra8_fs_mount_t* handle, char* out, uint32_t out_len)
{
  priv_lock_acquire();
  const ra8_err_t err = internal_get_label_locked(handle, out, out_len);
  priv_lock_release();
  return err;
}
 
RA8_OWNS_RESOURCE("ra8_fs_lock")
ra8_err_t ra8_fs_set_label(const ra8_fs_mount_t* handle, const char* label)
{
  priv_lock_acquire();
  const ra8_err_t err = internal_set_label_locked(handle, label);
  priv_lock_release();
  return err;
}