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

static const uint8_t s_gpt_signature[k_gpt_sig_len] = {
  0x45U,
  0x46U,
  0x49U,
  0x20U,
  0x50U,
  0x41U,
  0x52U,
  0x54U,
};

static const uint8_t s_gpt_guid_basic_data[k_gpt_guid_len] = {
  0xA2U,
  0xA0U,
  0xD0U,
  0xEBU,
  0xE5U,
  0xB9U,
  0x33U,
  0x44U,
  0x87U,
  0xC0U,
  0x68U,
  0xB6U,
  0xB7U,
  0x26U,
  0x99U,
  0xC7U,
};

RA8_INTERNAL
static uint64_t internal_gpt_entry_first_lba(const uint8_t* entry)
{
  uint32_t nonzero = 0U;
  for (uint32_t i = 0U; i < (uint32_t)k_gpt_guid_len; i++) {
    if (entry[i] != 0U) {
      nonzero = 1U;
    }
  }
  if (nonzero == 0U) {
    return 0U;
  }
  return priv_rd64(&entry[k_gpt_entry_off_first_lba]);
}

RA8_INTERNAL
static uint32_t internal_gpt_entry_is_basic_data(const uint8_t* entry)
{
  for (uint32_t i = 0U; i < (uint32_t)k_gpt_guid_len; i++) {
    if (entry[i] != s_gpt_guid_basic_data[i]) {
      return 0U;
    }
  }
  return 1U;
}

RA8_INTERNAL
static void internal_gpt_note_entry(const uint8_t* entry, uint64_t* basic_lba, uint64_t* any_lba)
{
  const uint64_t first = internal_gpt_entry_first_lba(entry);
  if (first == 0U) {
    return;
  }
  if (*any_lba == 0U) {
    *any_lba = first;
  }
  if (*basic_lba == 0U) {
    if (internal_gpt_entry_is_basic_data(entry) != 0U) {
      *basic_lba = first;
    }
  }
}

RA8_INTERNAL
static ra8_err_t internal_gpt_scan_entries(const ra8_fs_mount_t* m,
                                           uint64_t              entry_lba,
                                           uint32_t              count,
                                           uint64_t*             out_base)
{
  const uint32_t eps       = priv_bps(m) / (uint32_t)k_gpt_entry_bytes;
  uint64_t       basic_lba = 0U;
  uint64_t       any_lba   = 0U;
  for (uint32_t i = 0U; i < count; i++) {
    const uint32_t sector = i / eps;
    const uint32_t offset = (i % eps) * (uint32_t)k_gpt_entry_bytes;
    if (offset == 0U) {
      const ra8_err_t err = priv_read_sector(m, entry_lba + sector, g_fs_scratch);
      if (err != k_ra8_ok) {
        return err;
      }
    }
    internal_gpt_note_entry(&g_fs_scratch[offset], &basic_lba, &any_lba);
  }
  if (basic_lba != 0U) {
    *out_base = basic_lba;
    return k_ra8_ok;
  }
  if (any_lba != 0U) {
    *out_base = any_lba;
    return k_ra8_ok;
  }
  return k_ra8_err_not_found;
}

RA8_INTERNAL
static ra8_err_t
internal_gpt_read_geom(const ra8_fs_mount_t* m, uint64_t* out_entry_lba, uint32_t* out_count)
{
  const ra8_err_t err = priv_read_sector(m, (uint64_t)k_gpt_header_lba, g_fs_scratch);
  if (err != k_ra8_ok) {
    return err;
  }
  for (uint32_t i = 0U; i < (uint32_t)k_gpt_sig_len; i++) {
    if (g_fs_scratch[i] != s_gpt_signature[i]) {
      return k_ra8_err_validation_failed;
    }
  }
  const uint64_t entry_lba  = priv_rd64(&g_fs_scratch[k_gpt_off_entry_lba]);
  const uint32_t entry_size = priv_rd32(&g_fs_scratch[k_gpt_off_entry_size]);
  uint32_t       count      = priv_rd32(&g_fs_scratch[k_gpt_off_entry_count]);
  if (entry_lba == 0U) {
    return k_ra8_err_validation_failed;
  }
  if (entry_size != (uint32_t)k_gpt_entry_bytes) {
    return k_ra8_err_not_supported;
  }
  if (count > (uint32_t)k_gpt_entry_scan_max) {
    count = (uint32_t)k_gpt_entry_scan_max;
  }
  *out_entry_lba = entry_lba;
  *out_count     = count;
  return k_ra8_ok;
}
 
/* `priv_gpt_locate_volume()`: see header for the documented contract. */
ra8_err_t priv_gpt_locate_volume(const ra8_fs_mount_t* m, uint64_t* out_base)
{
  uint64_t        entry_lba = 0U;
  uint32_t        count     = 0U;
  const ra8_err_t err       = internal_gpt_read_geom(m, &entry_lba, &count);
  if (err != k_ra8_ok) {
    return err;
  }
  return internal_gpt_scan_entries(m, entry_lba, count, out_base);
}

RA8_INTERNAL
static ra8_err_t internal_gpt_entry_select(const uint8_t* entry, uint64_t* out_base)
{
  uint32_t nonzero = 0U;
  for (uint32_t i = 0U; i < (uint32_t)k_gpt_guid_len; i++) {
    if (entry[i] != 0U) {
      nonzero = 1U;
    }
  }
  if (nonzero == 0U) {
    return k_ra8_err_not_found;
  }
  const uint64_t base = priv_rd64(&entry[k_gpt_entry_off_first_lba]);
  if (base == 0U) {
    return k_ra8_err_validation_failed;
  }
  *out_base = base;
  return k_ra8_ok;
}
 
/* `priv_gpt_locate_partition()`: see header for the documented contract. */
ra8_err_t priv_gpt_locate_partition(const ra8_fs_mount_t* m, uint8_t index, uint64_t* out_base)
{
  uint64_t        entry_lba = 0U;
  uint32_t        count     = 0U;
  const ra8_err_t err       = internal_gpt_read_geom(m, &entry_lba, &count);
  if (err != k_ra8_ok) {
    return err;
  }
  if ((uint32_t)index >= count) {
    return k_ra8_err_out_of_range;
  }
  const uint32_t  eps    = priv_bps(m) / (uint32_t)k_gpt_entry_bytes;
  const uint32_t  sector = (uint32_t)index / eps;
  const uint32_t  offset = ((uint32_t)index % eps) * (uint32_t)k_gpt_entry_bytes;
  const ra8_err_t rerr   = priv_read_sector(m, entry_lba + sector, g_fs_scratch);
  if (rerr != k_ra8_ok) {
    return rerr;
  }
  return internal_gpt_entry_select(&g_fs_scratch[offset], out_base);
}