keystore.hpp

Go to the documentation of this file.

 
#ifndef MODES_HARDWARD_KEYSTORE_HPP
#define MODES_HARDWARD_KEYSTORE_HPP
 
#include "src/modes/include/compile.hpp"
#include "src/modes/include/tools.hpp"
 
#include "src/system/physical/fileSystem.h"
#include "src/system/utils/utils.h"
 
#include <cstring>
#include <array>
 
namespace lampda::modes::store {
 
static constexpr uint32_t storeUid = utils::hash("StoreRev:v01");
 
static constexpr uint32_t map32to31hash(uint32_t a)
{
  uint32_t lsb = a & 0b1; // mix the lost LSB info into the 13th bit
  uint32_t val = (a ^ storeUid ^ (lsb << 14));
  return val >> 1;
}
 
template<int16_t N> static constexpr uint32_t LMBD_INLINE hash(const char (&s)[N])
{
  static_assert(N - 1 <= 14, "Please use keys shorter than 14 bytes!");
  return map32to31hash(utils::hash(s, N));
}
 
template<int16_t N> static inline void LMBD_INLINE setValue(const char (&key)[N], uint32_t value)
{
  static_assert(N - 1 <= 14, "Please use keys shorter than 14 bytes!");
  physical::fileSystem::user::set_value(hash(key), value);
}
 
template<int16_t N> static inline bool LMBD_INLINE getValue(const char (&key)[N], uint32_t& out)
{
  static_assert(N - 1 <= 14, "Please use keys shorter than 14 bytes!");
  return physical::fileSystem::user::get_value(hash(key), out);
}
 
static inline void clear_stored() { physical::fileSystem::clear(); }
 
static inline void LMBD_INLINE migrateIfNeeded()
{
  if (not physical::fileSystem::user::doKeyExists(storeUid))
  {
    physical::fileSystem::user::set_value(storeUid, storeUid);
  }
 
  uint32_t out = storeUid ^ 0xff;
  if (not physical::fileSystem::user::get_value(storeUid, out))
  {
    physical::fileSystem::user::set_value(storeUid, storeUid);
    physical::fileSystem::user::get_value(storeUid, out);
  }
 
  if (out != storeUid)
  {
    physical::fileSystem::clear_internal_fs();
    physical::fileSystem::clear();
    physical::fileSystem::user::set_value(storeUid, storeUid);
    physical::fileSystem::user::write_to_file();
    physical::fileSystem::system::write_to_file();
 
    physical::fileSystem::system::load_from_file();
    physical::fileSystem::user::load_from_file();
  }
}
 
static constexpr uint32_t indexKeyFlag = (1 << 31);
 
enum class PrefixValues : uint32_t
{
  generalKeys = indexKeyFlag | (0x0 << 29), 
  managerKeys = indexKeyFlag | (0x1 << 29), 
  privateKeys = indexKeyFlag | (0x2 << 29), 
  invalidKeys = indexKeyFlag | (0x3 << 29), 
};
 
static constexpr uint32_t noGroupIndex = 15;
 
static constexpr uint32_t noModeIndex = 31;
 
static constexpr uint32_t LMBD_INLINE
indexKeyFor(PrefixValues prefix, uint32_t groupId, uint32_t modeId, uint32_t offset, uint32_t index)
{
  uint32_t rawPrefix = (uint32_t)prefix;
 
  assert((rawPrefix >> 31) == 0b1); // prefix on 2 of the MSBs +indexKeyFlag
  assert((groupId >> 4) == 0);      // groupId on 4 bits (0-14)
  assert((modeId >> 5) == 0);       // modeId on 5 bits (0-30)
  assert((offset >> 4) == 0);       // offset on 4 bits (0-15)
  assert((index >> 16) == 0);       // index on 16 bits (0-65535)
 
  return rawPrefix | (groupId << 25) | (modeId << 20) | (offset << 16) | index;
}
 
template<typename _EnumTy, int _groupId, int _modeId, PrefixValues _prefix = PrefixValues::generalKeys> struct KeyStore
{
  using EnumTy = _EnumTy;
  static constexpr uint32_t groupId = _groupId < 0 ? noGroupIndex : _groupId;
  static constexpr uint32_t modeId = _modeId < 0 ? noModeIndex : _modeId;
  static constexpr PrefixValues prefix = _prefix;
 
  // it's magic!
  static constexpr uint16_t storeIdKey = 0xafff;
 
  static_assert(sizeof(EnumTy) == sizeof(uint16_t), "uint16_t enum only");
  static_assert((groupId >> 4) == 0, "Group index must fit on 4 bits!");
  static_assert((modeId >> 5) == 0, "Mode index must fit on 5 bits!");
 
  // \private maps to ContextTy::KeyProxy::setValue()
  template<EnumTy key, typename T> static inline void LMBD_INLINE setValue(T value)
  {
    using valueTy = std::remove_cv_t<std::remove_reference_t<T>>;
    constexpr uint16_t rawKey = (uint16_t)key;
 
    static_assert(storeIdKey != rawKey, "error: key can not match storeIdKey (0xafff)");
 
    // simple case: value is uint32_t, store it as-is
    if constexpr (std::is_same_v<valueTy, uint32_t>)
    {
      constexpr auto idx = indexKeyFor(prefix, groupId, modeId, 0, rawKey);
      physical::fileSystem::user::set_value(idx, value);
 
      // small case: value is smaller than uint32_t, store it on a uint32_t
    }
    else if constexpr (sizeof(valueTy) <= sizeof(uint32_t))
    {
      uint32_t storage = 0;
      details::bit_cast<sizeof(value)>(storage, value);
      setValue<key>(storage);
 
      // large case: value is stored on up to 16 uint32_t
    }
    else if constexpr (sizeof(valueTy) <= 16 * sizeof(uint32_t))
    {
      constexpr uint8_t N = ((sizeof(valueTy) - 1) / sizeof(uint32_t)) + 1;
      std::array<uint32_t, N> storage {};
      details::bit_cast<sizeof(value)>(storage, value);
      for (uint8_t I = 0; I < N; ++I)
      {
        uint32_t off = indexKeyFor(prefix, groupId, modeId, I, rawKey);
        physical::fileSystem::user::set_value(off, storage[I]);
      }
    }
    else
    {
      static_assert(sizeof(valueTy) <= 64, "KeyStore values limited to 64 bytes!");
    }
  }
 
  // \private maps to ContextTy::KeyProxy::getValue()
  template<EnumTy key, typename T> static inline bool LMBD_INLINE getValue(T& output)
  {
    constexpr uint16_t rawKey = (uint16_t)key;
 
    static_assert(storeIdKey != rawKey, "error: key can not match storeIdKey (0xafff)");
 
    // simple case: value is uint32_t, get it as-is
    if constexpr (std::is_same_v<T, uint32_t>)
    {
      constexpr auto idx = indexKeyFor(prefix, groupId, modeId, 0, rawKey);
      return physical::fileSystem::user::get_value(idx, output);
 
      // small case: value is smaller than uint32_t, get it on a uint32_t
    }
    else if constexpr (sizeof(T) <= sizeof(uint32_t))
    {
      uint32_t storage = 0;
      if (not getValue<key, uint32_t>(storage))
      {
        return false;
      }
 
      details::bit_cast<sizeof(output)>(output, storage);
      return true;
 
      // large case: value is stored on up to 16 uint32_t
    }
    else if constexpr (sizeof(T) <= 16 * sizeof(uint32_t))
    {
      constexpr uint8_t N = ((sizeof(T) - 1) / sizeof(uint32_t)) + 1;
      std::array<uint32_t, N> storage {};
      for (uint8_t I = 0; I < N; ++I)
      {
        uint32_t off = indexKeyFor(prefix, groupId, modeId, I, rawKey);
        if (not physical::fileSystem::user::get_value(off, storage[I]))
        {
          return false;
        }
      }
 
      details::bit_cast<sizeof(output)>(output, storage);
      return true;
    }
    else
    {
      static_assert(sizeof(T) <= 64, "KeyStore values limited to 64 bytes!");
    }
    return false;
  }
 
  // \private maps to ContextTy::KeyProxy::getValue(defaultValue)
  template<EnumTy key, typename T> static inline void LMBD_INLINE getValue(T& output, T defValue)
  {
    if (not getValue<key, T>(output))
    {
      output = defValue;
    }
  }
 
  // \private maps to ContextTy::KeyProxy::hasValue
  template<EnumTy key, typename T = uint32_t> static inline bool LMBD_INLINE hasValue()
  {
    T output;
    return getValue<key, T>(output);
  }
 
  // \private empty store if \p storeId mismatch with value at \p storeIdKey
  template<uint32_t storeId> static void migrateStoreIfNeeded()
  {
    constexpr auto idx = indexKeyFor(prefix, groupId, modeId, 0, storeIdKey);
 
    // retrieve storeId from storage
    uint32_t otherId = 0;
    if (not physical::fileSystem::user::get_value(idx, otherId))
    {
      otherId = storeId;
      physical::fileSystem::user::set_value(idx, storeId);
    }
 
    // if it don't match our storeId, clean storage from our old keys
    if (otherId != storeId || otherId == 0)
    {
      constexpr uint32_t select = 0xfff00000; // all but offset
      constexpr uint32_t masked = idx & select;
      physical::fileSystem::user::dropMatchingKeys(masked, select);
      physical::fileSystem::user::set_value(idx, storeId);
    }
  }
};
 
template<uint32_t baseId, typename AllModes> static constexpr uint32_t derivateStoreIdImpl()
{
  constexpr uint32_t MixCstA = 0x8af8901d, MixCstB = 0x2f9c7c90;
  constexpr uint8_t NbModes = std::tuple_size_v<AllModes>;
 
  uint32_t storeId = baseId;
  details::unroll<NbModes>([&](auto Idx) {
    constexpr uint8_t I = decltype(Idx)::value;
    using ModeHere = std::tuple_element_t<I, AllModes>;
    using StoreHere = StoreEnumOf<ModeHere>;
    constexpr bool hasStore = not std::is_same_v<StoreHere, NoStoreHere>;
 
    uint32_t storeIdHere = 0;
    if constexpr (hasStore)
    {
      storeIdHere = ModeHere::storeId;
    }
 
    // straightforward mix function
    storeId += MixCstA;
    storeId = (storeId << 7) ^ (storeId >> (32 - 7));
    storeId ^= MixCstB;
 
    storeId += storeIdHere;
  });
 
  return storeId;
}
 
template<uint32_t baseId, typename AllModes> static constexpr uint32_t derivateStoreId =
        derivateStoreIdImpl<baseId, AllModes>();
 
} // namespace lampda::modes::store
 
#endif