ra8_fs_fat_truncate.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"
 
/* =============================================================================
 * Shared helpers
 * =============================================================================
 */

RA8_INTERNAL
static uint64_t internal_trunc_clusters(uint64_t bytes, uint32_t cbytes)
{
  return (bytes + cbytes - 1U) / cbytes;
}

RA8_INTERNAL
static ra8_err_t
internal_trunc_walk(const ra8_fs_mount_t* m, uint32_t start, uint32_t idx, uint32_t* out)
{
  uint32_t cur = start;
  for (uint32_t i = 0U; i < idx; i++) {
    uint32_t        next = 0U;
    const ra8_err_t e    = priv_fat_get(m, cur, &next);
    if (e != k_ra8_ok) {
      return e;
    }
    if (priv_is_eoc(m, next) != 0U) {
      return k_ra8_err_protocol_error;
    }
    cur = next;
  }
  *out = cur;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t
internal_trunc_zero_span(const ra8_fs_mount_t* m, uint32_t cluster, uint32_t lo, uint32_t hi)
{
  if (lo >= hi) {
    return k_ra8_ok;
  }
  const uint64_t base_lba = priv_cluster_to_lba(m, cluster);
  uint32_t       off      = lo;
  while (off < hi) {
    const uint32_t sec_idx   = off / priv_bps(m);
    const uint32_t sec_start = sec_idx * priv_bps(m);
    const uint32_t in_sector = off - sec_start;
    uint32_t       n         = priv_bps(m) - in_sector;
    if (n > (hi - off)) {
      n = hi - off;
    }
    uint8_t* const  sec = priv_sec_io();
    const ra8_err_t re  = priv_read_sector(m, base_lba + sec_idx, sec);
    if (re != k_ra8_ok) {
      return re;
    }
    for (uint32_t i = 0U; i < n; i++) {
      sec[in_sector + i] = 0U;
    }
    const ra8_err_t we = priv_write_sector(m, base_lba + sec_idx, sec);
    if (we != k_ra8_ok) {
      return we;
    }
    off += n;
  }
  return k_ra8_ok;
}
 
/* =============================================================================
 * FAT12/16/32 truncate
 * =============================================================================
 */

RA8_INTERNAL
static ra8_err_t internal_fat_trunc_shrink(ra8_fs_file_t* file, uint32_t new_size, uint32_t cbytes)
{
  const ra8_fs_mount_t* m         = file->mount;
  const uint32_t        new_nclus = (uint32_t)internal_trunc_clusters(new_size, cbytes);
  if (new_nclus == 0U) {
    if (file->first_cluster >= (uint32_t)k_cluster_first_data) {
      const ra8_err_t e = priv_free_chain(m, file->first_cluster);
      if (e != k_ra8_ok) {
        return e;
      }
    }
    file->first_cluster = 0U;
    file->size_bytes    = new_size;
    return k_ra8_ok;
  }
  uint32_t        new_tail = 0U;
  const ra8_err_t we       = internal_trunc_walk(m, file->first_cluster, new_nclus - 1U, &new_tail);
  if (we != k_ra8_ok) {
    return we;
  }
  uint32_t        succ = 0U;
  const ra8_err_t ge   = priv_fat_get(m, new_tail, &succ);
  if (ge != k_ra8_ok) {
    return ge;
  }
  if (priv_is_eoc(m, succ) == 0U) {
    ra8_err_t e = priv_fat_set(m, new_tail, priv_eoc_write(m));
    if (e != k_ra8_ok) {
      return e;
    }
    e = priv_free_chain(m, succ);
    if (e != k_ra8_ok) {
      return e;
    }
  }
  file->size_bytes = new_size;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_fat_trunc_extend(ra8_fs_file_t* file,
                                           uint32_t       tail,
                                           uint32_t       have,
                                           uint32_t       new_nclus,
                                           uint32_t       cbytes)
{
  const ra8_fs_mount_t* m   = file->mount;
  uint32_t              cur = tail;
  if (have == 0U) {
    ra8_err_t e = priv_alloc_eoc_cluster(m, &cur);
    if (e != k_ra8_ok) {
      return e;
    }
    file->first_cluster = cur;
    e                   = internal_trunc_zero_span(m, cur, 0U, cbytes);
    if (e != k_ra8_ok) {
      return e;
    }
    have = 1U;
  }
  while (have < new_nclus) {
    uint32_t  c = 0U;
    ra8_err_t e = priv_alloc_eoc_cluster(m, &c);
    if (e != k_ra8_ok) {
      return e;
    }
    e = priv_fat_set(m, cur, c);
    if (e != k_ra8_ok) {
      return e;
    }
    e = internal_trunc_zero_span(m, c, 0U, cbytes);
    if (e != k_ra8_ok) {
      return e;
    }
    cur = c;
    have++;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_fat_trunc_grow(ra8_fs_file_t* file, uint32_t new_size, uint32_t cbytes)
{
  const ra8_fs_mount_t* m         = file->mount;
  const uint32_t        old_size  = (uint32_t)file->size_bytes;
  const uint32_t        old_nclus = (uint32_t)internal_trunc_clusters(old_size, cbytes);
  const uint32_t        new_nclus = (uint32_t)internal_trunc_clusters(new_size, cbytes);
  uint32_t              tail      = 0U;
  if (old_nclus > 0U) {
    const ra8_err_t we = internal_trunc_walk(m, file->first_cluster, old_nclus - 1U, &tail);
    if (we != k_ra8_ok) {
      return we;
    }
    const uint32_t  base    = (old_nclus - 1U) * cbytes;
    const uint32_t  cap     = old_nclus * cbytes;
    const uint32_t  span_hi = (new_size < cap) ? new_size : cap;
    const ra8_err_t ze      = internal_trunc_zero_span(m, tail, old_size - base, span_hi - base);
    if (ze != k_ra8_ok) {
      return ze;
    }
  }
  const ra8_err_t ee = internal_fat_trunc_extend(file, tail, old_nclus, new_nclus, cbytes);
  if (ee != k_ra8_ok) {
    return ee;
  }
  file->size_bytes = new_size;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_fat_trunc_commit(ra8_fs_file_t* file)
{
  const ra8_fs_mount_t* m   = file->mount;
  uint8_t* const        sec = priv_sec_walk();
  const ra8_err_t       re  = priv_read_sector(m, file->dir_entry_lba, sec);
  if (re != k_ra8_ok) {
    return re;
  }
  priv_entry_set_cluster_size(&sec[file->dir_entry_idx],
                              file->first_cluster,
                              (uint32_t)file->size_bytes);
  priv_fat_entry_stamp_write(&sec[file->dir_entry_idx]);
  const ra8_err_t we = priv_write_sector(m, file->dir_entry_lba, sec);
  if (we != k_ra8_ok) {
    return we;
  }
  file->dirty = 1U;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_fat_trunc(ra8_fs_file_t* file, uint32_t new_size)
{
  const uint32_t cbytes = priv_cluster_bytes(file->mount);
  ra8_err_t      e      = k_ra8_ok;
  if (new_size < file->size_bytes) {
    e = internal_fat_trunc_shrink(file, new_size, cbytes);
  } else if (new_size > file->size_bytes) {
    e = internal_fat_trunc_grow(file, new_size, cbytes);
  }
  if (e != k_ra8_ok) {
    return e;
  }
  file->cur_cluster        = file->first_cluster;
  file->walk_cache_idx     = 0U;
  file->walk_cache_cluster = file->first_cluster;
  return internal_fat_trunc_commit(file);
}
 
/* =============================================================================
 * exFAT truncate
 * =============================================================================
 */

RA8_INTERNAL
static ra8_err_t
internal_exfat_free_run(const ra8_fs_mount_t* m, uint32_t first, uint64_t nbytes, uint8_t nofat)
{
  uint8_t strm[k_exfat_entry_bytes] = {};
  priv_wr32(&strm[k_exfat_strm_off_clus], first);
  priv_wr64(&strm[k_exfat_strm_off_dlen], nbytes);
  strm[k_exfat_strm_off_flags] =
    (nofat != 0U) ? (uint8_t)k_exfat_secflag_alloc : (uint8_t)k_exfat_secflag_poss;
  return priv_exfat_free_clusters(m, strm);
}

RA8_INTERNAL
static ra8_err_t
internal_exfat_shrink_chain_tail(ra8_fs_file_t* file, uint32_t new_nclus, uint32_t cbytes)
{
  const ra8_fs_mount_t* m        = file->mount;
  uint32_t              new_tail = 0U;
  const ra8_err_t       we = internal_trunc_walk(m, file->first_cluster, new_nclus - 1U, &new_tail);
  if (we != k_ra8_ok) {
    return we;
  }
  uint32_t        succ = 0U;
  const ra8_err_t ge   = priv_fat_get(m, new_tail, &succ);
  if (ge != k_ra8_ok) {
    return ge;
  }
  ra8_err_t e = priv_fat_set(m, new_tail, priv_eoc_write(m));
  if (e != k_ra8_ok) {
    return e;
  }
  e = internal_exfat_free_run(m, succ, cbytes, 0U);
  if (e != k_ra8_ok) {
    return e;
  }
  file->tail_cluster = new_tail;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t
internal_exfat_trunc_shrink(ra8_fs_file_t* file, uint64_t new_size, uint32_t cbytes)
{
  const ra8_fs_mount_t* m         = file->mount;
  const uint32_t        new_nclus = (uint32_t)internal_trunc_clusters(new_size, cbytes);
  if (new_nclus < file->alloc_clusters) {
    if (new_nclus == 0U) {
      const ra8_err_t e =
        internal_exfat_free_run(m, file->first_cluster, file->size_bytes, file->no_fat_chain);
      if (e != k_ra8_ok) {
        return e;
      }
      file->first_cluster = 0U;
      file->no_fat_chain  = 1U;
      file->tail_cluster  = 0U;
    } else if (file->no_fat_chain != 0U) {
      const uint32_t  first = file->first_cluster + new_nclus;
      const ra8_err_t e =
        internal_exfat_free_run(m,
                                first,
                                (uint64_t)(file->alloc_clusters - new_nclus) * cbytes,
                                1U);
      if (e != k_ra8_ok) {
        return e;
      }
      file->tail_cluster = file->first_cluster + new_nclus - 1U;
    } else {
      const ra8_err_t e = internal_exfat_shrink_chain_tail(file, new_nclus, cbytes);
      if (e != k_ra8_ok) {
        return e;
      }
    }
    file->alloc_clusters = new_nclus;
  }
  file->size_bytes = new_size;
  if (file->valid_bytes > new_size) {
    file->valid_bytes = new_size;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_exfat_trunc(ra8_fs_file_t* file, uint64_t new_size)
{
  const uint32_t cbytes = priv_cluster_bytes(file->mount);
  if (new_size < file->size_bytes) {
    const ra8_err_t e = internal_exfat_trunc_shrink(file, new_size, cbytes);
    if (e != k_ra8_ok) {
      return e;
    }
  } else if (new_size > file->size_bytes) {
    /* Sized before a single cluster moves: a grow past the volume's whole
     * cluster count can never succeed, and discovering that AFTER the bitmap
     * ran dry would leave the volume full for no gain. */
    const uint64_t want = internal_trunc_clusters(new_size, cbytes);
    if (want > (uint64_t)file->mount->count_of_clusters) {
      return k_ra8_err_no_mem;
    }
    const ra8_err_t e = priv_exfat_ensure_clusters(file, (uint32_t)want);
    if (e != k_ra8_ok) {
      return e;
    }
    file->size_bytes = new_size;
  } else {
    return k_ra8_ok;
  }
  return priv_exfat_flush_set(file);
}
 
/* =============================================================================
 * Dispatch and the public entry point
 * =============================================================================
 */

RA8_INTERNAL
RA8_EXPECTS_LOCK("ra8_fs_lock")
static ra8_err_t internal_truncate_locked(ra8_fs_file_t* file, uint64_t new_size)
{
  if (file == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (file->in_use == 0U || file->mode == k_ra8_fs_mode_read) {
    return k_ra8_err_invalid_state;
  }
  ra8_err_t e = k_ra8_ok;
  if (file->mount->type == k_ra8_fs_type_exfat) {
    e = internal_exfat_trunc(file, new_size);
  } else if (new_size > (uint64_t)k_ra8_fs_fat_max_file_bytes) {
    /* The FAT boundary of #676: `DIR_FileSize` cannot record 4 GiB or more,
     * so the request is refused rather than wrapped (see ra8_fs_meta.h). */
    e = k_ra8_err_invalid_size;
  } else {
    e = internal_fat_trunc(file, (uint32_t)new_size);
  }
  if (e != k_ra8_ok) {
    return e;
  }
  if (file->offset > file->size_bytes) {
    file->offset = file->size_bytes;
  }
  return k_ra8_ok;
}
 
RA8_OWNS_RESOURCE("ra8_fs_lock")
ra8_err_t ra8_fs_truncate(ra8_fs_file_t* file, uint64_t new_size)
{
  priv_lock_acquire();
  const ra8_err_t err = internal_truncate_locked(file, new_size);
  priv_lock_release();
  return err;
}