ra8_fs_fat_exfat_openw.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_exfat_seed_handle(ra8_fs_file_t*        file,
                                       ra8_fs_mount_t*       m,
                                       const exfat_setpos_t* head,
                                       uint32_t              count,
                                       ra8_fs_mode_t         mode)
{
  file->mount              = m;
  file->first_cluster      = 0U;
  file->cur_cluster        = 0U;
  file->walk_cache_idx     = 0U;
  file->walk_cache_cluster = 0U;
  file->size_bytes         = 0U;
  file->offset             = 0U;
  file->dir_entry_lba      = 0U;
  file->dir_entry_idx      = 0U;
  file->valid_bytes        = 0U;
  file->entry_set_cluster  = head->cluster;
  file->entry_set_index    = head->index;
  file->entry_set_count    = count;
  file->alloc_clusters     = 0U;
  file->tail_cluster       = 0U;
  file->mode               = mode;
  file->in_use             = 1U;
  file->no_fat_chain       = 1U;
  file->dirty              = 0U;
}

RA8_INTERNAL
static ra8_err_t internal_exfat_survey_alloc(ra8_fs_file_t* file)
{
  const ra8_fs_mount_t* m      = file->mount;
  const uint32_t        cbytes = priv_cluster_bytes(m);
  if ((file->first_cluster < (uint32_t)k_cluster_first_data) || (file->size_bytes == 0U)) {
    file->first_cluster  = 0U;
    file->alloc_clusters = 0U;
    file->tail_cluster   = 0U;
    file->no_fat_chain   = 1U;
    return k_ra8_ok;
  }
  if (file->no_fat_chain != 0U) {
    file->alloc_clusters = (uint32_t)((file->size_bytes + cbytes - 1U) / cbytes);
    file->tail_cluster   = file->first_cluster + file->alloc_clusters - 1U;
    return k_ra8_ok;
  }
  uint32_t clus  = file->first_cluster;
  uint32_t owned = 1U;
  for (uint32_t guard = 0U; guard < m->count_of_clusters; guard++) {
    uint32_t        next = 0U;
    const ra8_err_t e    = priv_fat_get(m, clus, &next);
    if (e != k_ra8_ok) {
      return e;
    }
    if (priv_is_eoc(m, next) != 0U) {
      break;
    }
    if (next < (uint32_t)k_cluster_first_data) {
      return k_ra8_err_protocol_error;
    }
    clus = next;
    owned++;
  }
  file->alloc_clusters = owned;
  file->tail_cluster   = clus;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_exfat_truncate(ra8_fs_file_t* file, const uint8_t* strm)
{
  const ra8_err_t e = priv_exfat_free_clusters(file->mount, strm);
  if (e != k_ra8_ok) {
    return e;
  }
  file->first_cluster      = 0U;
  file->cur_cluster        = 0U;
  file->walk_cache_idx     = 0U;
  file->walk_cache_cluster = 0U;
  file->size_bytes         = 0U;
  file->valid_bytes        = 0U;
  file->offset             = 0U;
  file->alloc_clusters     = 0U;
  file->tail_cluster       = 0U;
  file->no_fat_chain       = 1U;
  return priv_exfat_flush_set(file);
}

RA8_INTERNAL
static ra8_err_t internal_exfat_writable_set(uint32_t count)
{
  if (count < (uint32_t)k_exfat_set_min_entries) {
    return k_ra8_err_protocol_error;
  }
  if (count > (uint32_t)k_exfat_set_writable) {
    return k_ra8_err_not_supported;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_exfat_open_found(ra8_fs_mount_t*       handle,
                                           ra8_fs_mode_t         mode,
                                           const exfat_setpos_t* head,
                                           uint32_t              count,
                                           const uint8_t*        file_e,
                                           const uint8_t*        strm,
                                           ra8_fs_file_t**       out_file)
{
  if ((file_e[k_exfat_off_file_attr] & (uint8_t)k_exfat_attr_directory) != 0U) {
    return k_ra8_err_invalid_arg;
  }
  /* Honor the read-only attribute (#681): both writing modes mutate the file, so
   * a host-marked read-only file is refused before a slot is claimed or a cluster
   * freed. A read open never reaches here (priv_exfat_open dispatches it away). */
  if ((file_e[k_exfat_off_file_attr] & (uint8_t)k_exfat_attr_read_only) != 0U) {
    return k_ra8_err_access_denied;
  }
  ra8_err_t e = internal_exfat_writable_set(count);
  if (e != k_ra8_ok) {
    return e;
  }
  ra8_fs_file_t* f = priv_alloc_file_slot();
  if (f == nullptr) {
    return k_ra8_err_no_mem;
  }
  internal_exfat_seed_handle(f, handle, head, count, mode);
  f->first_cluster = priv_rd32(&strm[k_exfat_strm_off_clus]);
  f->size_bytes    = priv_rd64(&strm[k_exfat_strm_off_dlen]);
  f->valid_bytes   = priv_rd64(&strm[k_exfat_off_strm_valid]);
  f->no_fat_chain =
    ((strm[k_exfat_strm_off_flags] & (uint8_t)k_exfat_secflag_no_fat) != 0U) ? 1U : 0U;
  /* exFAT spec sec 7.4.5 makes ValidDataLength a PREFIX of DataLength, and the
   * handle's invariant says so too. Another implementation can still leave the
   * pair inverted, and taking it at face value would have the flush write the
   * inversion back -- so it is clamped on the way in, where it costs one
   * comparison, rather than believed. */
  if (f->valid_bytes > f->size_bytes) {
    f->valid_bytes = f->size_bytes;
  }
  if (mode == k_ra8_fs_mode_write) {
    e = internal_exfat_truncate(f, strm);
  } else {
    e                     = internal_exfat_survey_alloc(f);
    f->cur_cluster        = f->first_cluster;
    f->walk_cache_cluster = f->first_cluster;
    f->offset             = f->size_bytes;
  }
  if (e != k_ra8_ok) {
    f->in_use = 0U;
    f->mount  = nullptr;
    return e;
  }
  *out_file = f;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_exfat_open_created(ra8_fs_mount_t*    handle,
                                             const exfat_dir_t* dir,
                                             const uint16_t*    name,
                                             uint32_t           nlen,
                                             ra8_fs_mode_t      mode,
                                             ra8_fs_file_t**    out_file)
{
  ra8_fs_file_t* f = priv_alloc_file_slot();
  if (f == nullptr) {
    return k_ra8_err_no_mem;
  }
  exfat_setpos_t  head  = {};
  uint32_t        count = 0U;
  const ra8_err_t e     = priv_exfat_link(handle, dir, name, nlen, &head, &count);
  if (e != k_ra8_ok) {
    f->in_use = 0U;
    f->mount  = nullptr;
    return e;
  }
  internal_exfat_seed_handle(f, handle, &head, count, mode);
  *out_file = f;
  return k_ra8_ok;
}
 
/* `priv_exfat_open_write()`: see header for the documented contract. */
ra8_err_t priv_exfat_open_write(ra8_fs_mount_t* handle,
                                const char*     path,
                                ra8_fs_mode_t   mode,
                                ra8_fs_file_t** out_file)
{
  /* Resolve the directory the name lives in, rather than treating the whole
   * path as one root-level name (#605). Leading slashes fall out of the walk,
   * which is what used to make "/name" resolve (#93); "/logs/name" now lands in
   * "/logs" instead of creating a file literally called "logs/name" that no
   * matcher could ever find again. */
  exfat_dir_t     parent = {};
  const char*     leaf   = nullptr;
  const ra8_err_t pe     = priv_exfat_resolve_parent(handle, path, &parent, &leaf);
  if (pe != k_ra8_ok) {
    return pe;
  }
  /* The name becomes code units once, here, and every on-disk length below
   * counts those rather than the caller's bytes. The cap is a UNIT cap, so a
   * UTF-8 argument three times as long is still perfectly legal (#606). */
  uint16_t        name[k_exfat_name_cap] = {};
  uint32_t        nlen                   = 0U;
  const ra8_err_t ne                     = priv_exfat_name_to_units(handle, leaf, name, &nlen);
  if (ne == k_ra8_err_no_mem) {
    return k_ra8_err_invalid_arg; /* over the name cap: an argument, not a full disk */
  }
  if (ne != k_ra8_ok) {
    return ne;
  }
  if (nlen == 0U) {
    return k_ra8_err_invalid_arg;
  }
  exfat_setpos_t  pos[k_exfat_set_max_entries] = {};
  uint32_t        count                        = 0U;
  uint8_t         file_e[k_exfat_entry_bytes]  = {};
  uint8_t         strm[k_exfat_entry_bytes]    = {};
  const ra8_err_t e = priv_exfat_find_set(handle,
                                          &parent,
                                          leaf,
                                          pos,
                                          (uint32_t)k_exfat_set_max_entries,
                                          &count,
                                          file_e,
                                          strm);
  if (e == k_ra8_ok) {
    return internal_exfat_open_found(handle, mode, &pos[0], count, file_e, strm, out_file);
  }
  if (e != k_ra8_err_not_found) {
    return e;
  }
  return internal_exfat_open_created(handle, &parent, name, nlen, mode, out_file);
}