ra8_fs_fat_attr.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 ra8_err_t internal_setattr_fat(const ra8_fs_mount_t* m,
                                      const char*           path,
                                      uint8_t               set_mask,
                                      uint8_t               clear_mask)
{
  dir_loc_t       parent = {};
  const char*     leaf   = nullptr;
  const ra8_err_t rerr   = priv_resolve_parent(m, path, &parent, &leaf);
  if (rerr != k_ra8_ok) {
    return rerr;
  }
  uint8_t       name83[k_max_8_3_name]          = {};
  const uint8_t have83                          = priv_path_to_83(leaf, name83);
  uint64_t      lba                             = 0U;
  uint32_t      off                             = 0U;
  uint8_t       entry[k_ra8_fs_dir_entry_bytes] = {};
  ra8_err_t     err                             = k_ra8_err_not_found;
  if (have83 != 0U) {
    err = priv_dir_find(m, &parent, name83, &lba, &off, entry);
  }
  if (err == k_ra8_err_not_found) {
    err = priv_dir_find_long(m, &parent, leaf, &lba, &off, entry);
  }
  if (err != k_ra8_ok) {
    return err;
  }
  uint8_t* const sec = priv_sec_walk();
  err                = priv_read_sector(m, lba, sec);
  if (err != k_ra8_ok) {
    return err;
  }
  priv_fat_entry_apply_attr(&sec[off], set_mask, clear_mask);
  return priv_write_sector(m, lba, sec);
}

RA8_INTERNAL
static ra8_err_t internal_setattr_exfat(const ra8_fs_mount_t* m,
                                        const char*           path,
                                        uint8_t               set_mask,
                                        uint8_t               clear_mask)
{
  exfat_dir_t root = {};
  priv_exfat_dir_root(m, &root);
  exfat_setpos_t pos[k_exfat_set_max_entries] = {};
  uint32_t       count                        = 0U;
  uint8_t        file_e[k_exfat_entry_bytes]  = {};
  uint8_t        strm_e[k_exfat_entry_bytes]  = {};
  ra8_err_t      err = priv_exfat_find_set(m,
                                           &root,
                                           path,
                                           pos,
                                           (uint32_t)k_exfat_set_max_entries,
                                           &count,
                                           file_e,
                                           strm_e);
  if (err != k_ra8_ok) {
    return err;
  }
  uint8_t eset[(uint32_t)k_exfat_set_max_entries * (uint32_t)k_exfat_entry_bytes] = {};
  for (uint32_t k = 0U; k < count; k++) {
    exfat_cursor_t one = {.cluster          = pos[k].cluster,
                          .entry_in_cluster = pos[k].index,
                          .scanned          = 0U,
                          .contig_end       = 0U};
    err = priv_exfat_next_entry(m, &one, &eset[(size_t)k * (size_t)k_exfat_entry_bytes]);
    if (err != k_ra8_ok) {
      return err;
    }
  }
  const uint8_t attr = eset[k_exfat_off_file_attr];
  eset[k_exfat_off_file_attr] =
    (uint8_t)((uint8_t)(attr & (uint8_t)~clear_mask) | (uint8_t)set_mask);
  priv_wr16(&eset[k_exfat_off_file_csum],
            priv_exfat_set_checksum(eset, count * (uint32_t)k_exfat_entry_bytes));
  return priv_exfat_write_dir_set(m,
                                  pos[0].cluster,
                                  pos[0].index,
                                  &eset[0],
                                  (uint32_t)k_exfat_entry_bytes);
}

RA8_INTERNAL
RA8_EXPECTS_LOCK("ra8_fs_lock")
static ra8_err_t internal_setattr_locked(const ra8_fs_mount_t* handle,
                                         const char*           path,
                                         uint8_t               set_mask,
                                         uint8_t               clear_mask)
{
  if (handle == nullptr || path == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (handle->in_use == 0U) {
    return k_ra8_err_invalid_state;
  }
  /* Confine the change to the four host-controlled bits, and reject a bit told
   * to be both set and cleared. Any of the three catches makes the whole request
   * invalid_arg, so the DIRECTORY / VOLUME_ID / long-name bits can never be
   * flipped and a caller cannot give contradictory instructions. */
  const uint8_t settable = (uint8_t)k_ra8_fs_attr_settable;
  if (((set_mask & (uint8_t)~settable) != 0U) || ((clear_mask & (uint8_t)~settable) != 0U) ||
      ((set_mask & clear_mask) != 0U)) {
    return k_ra8_err_invalid_arg;
  }
  const char* p = path;
  while (*p == '/') {
    p++;
  }
  if (*p == '\0') {
    return k_ra8_err_invalid_arg; /* the volume root has no entry to patch */
  }
  if (handle->type == k_ra8_fs_type_exfat) {
    return internal_setattr_exfat(handle, path, set_mask, clear_mask);
  }
  return internal_setattr_fat(handle, path, set_mask, clear_mask);
}
 
/* =============================================================================
 * Public entry point -- the lock bracket
 * =============================================================================
 */
 
RA8_OWNS_RESOURCE("ra8_fs_lock")
ra8_err_t ra8_fs_set_attr(const ra8_fs_mount_t* handle,
                          const char*           path,
                          uint8_t               set_mask,
                          uint8_t               clear_mask)
{
  priv_lock_acquire();
  const ra8_err_t err = internal_setattr_locked(handle, path, set_mask, clear_mask);
  priv_lock_release();
  return err;
}