ra8_fs_fat_utime.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_utime_fat(const ra8_fs_mount_t*    m,
                                    const char*              path,
                                    const ra8_fs_datetime_t* create,
                                    const ra8_fs_datetime_t* modify,
                                    const ra8_fs_datetime_t* access)
{
  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_set_times(&sec[off], create, modify, access);
  return priv_write_sector(m, lba, sec);
}

RA8_INTERNAL
static ra8_err_t internal_utime_exfat(const ra8_fs_mount_t*    m,
                                      const char*              path,
                                      const ra8_fs_datetime_t* create,
                                      const ra8_fs_datetime_t* modify,
                                      const ra8_fs_datetime_t* access)
{
  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 set[(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, &set[(size_t)k * (size_t)k_exfat_entry_bytes]);
    if (err != k_ra8_ok) {
      return err;
    }
  }
  priv_exfat_file_set_times(&set[0], create, modify, access);
  priv_wr16(&set[k_exfat_off_file_csum],
            priv_exfat_set_checksum(set, count * (uint32_t)k_exfat_entry_bytes));
  return priv_exfat_write_dir_set(m,
                                  pos[0].cluster,
                                  pos[0].index,
                                  &set[0],
                                  (uint32_t)k_exfat_entry_bytes);
}

RA8_INTERNAL
RA8_EXPECTS_LOCK("ra8_fs_lock")
static ra8_err_t internal_utime_locked(const ra8_fs_mount_t*    handle,
                                       const char*              path,
                                       const ra8_fs_datetime_t* create,
                                       const ra8_fs_datetime_t* modify,
                                       const ra8_fs_datetime_t* access)
{
  if (handle == nullptr || path == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (handle->in_use == 0U) {
    return k_ra8_err_invalid_state;
  }
  const char* p = path;
  while (*p == '/') {
    p++;
  }
  if (*p == '\0') {
    return k_ra8_err_invalid_arg; /* the volume root has no entry to stamp */
  }
  if (handle->type == k_ra8_fs_type_exfat) {
    return internal_utime_exfat(handle, path, create, modify, access);
  }
  return internal_utime_fat(handle, path, create, modify, access);
}
 
/* =============================================================================
 * Public entry point -- the lock bracket
 * =============================================================================
 */
 
RA8_OWNS_RESOURCE("ra8_fs_lock")
ra8_err_t ra8_fs_utime(const ra8_fs_mount_t*    handle,
                       const char*              path,
                       const ra8_fs_datetime_t* create,
                       const ra8_fs_datetime_t* modify,
                       const ra8_fs_datetime_t* access)
{
  priv_lock_acquire();
  const ra8_err_t err = internal_utime_locked(handle, path, create, modify, access);
  priv_lock_release();
  return err;
}