VirtualStruct.h

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-3-Clause
//
// This file is part of ETISS. It is licensed under the BSD 3-Clause License; you may not use this file except in
// compliance with the License. You should have received a copy of the license along with this project. If not, see the
// LICENSE file.
#ifndef ETISS_PLUGIN_VIRTUALSTRUCT_H_
#define ETISS_PLUGIN_VIRTUALSTRUCT_H_
#include "etiss/CVirtualStruct.h"
#include "etiss/Misc.h"
#include "etiss/fault/Injector.h"
 
#include <cstddef>
 
#include <memory>
 
namespace etiss
{
 
class VSSync;
 
class VirtualStruct : public std::enable_shared_from_this<VirtualStruct>, public etiss::fault::Injector
{
    friend class VSSync;
 
  public:
    class Field
    {
      public:
        class Listener
        {
          public:
            virtual ~Listener();
            virtual void write(etiss::VirtualStruct::Field &field, uint64_t val) = 0;
        };
 
      private:
        struct listener_pair_compare
        {
            bool operator()(const std::pair<Listener *, std::shared_ptr<Listener>> &lhs,
                            const std::pair<Listener *, std::shared_ptr<Listener>> &rhs) const
            {
                return lhs.first < rhs.first;
            }
        };
 
      public:
        enum AccessMode
        {
            VIRTUAL,
            LAMBDA,
            PREFER_LAMBDA,
        };
 
      public:                        // flags
        static const int R = 1;      
        static const int W = 2;      
        static const int RW = R | W; 
        static const int L = 4;      
        static const int F = 8;      
        static const int A = 16;     
        static const int P = 32; 
 
      public: // constructor
        Field(VirtualStruct &parent, const std::string &name, const std::string &prettyname, int flags, size_t width,
              size_t bitwidth = 0);
        Field(VirtualStruct &parent, const std::string &name, const std::string &prettyname, int flags, size_t width,
              bool virtual_enabled, std::function<uint64_t()> lread, std::function<void(uint64_t)> lwrite,
              size_t bitwidth = 0);
        virtual ~Field();
 
      public:                    // fields
        VirtualStruct &parent_;  
        const std::string name_; 
        const std::string prettyname_; 
        int flags_;             
        const size_t width_;    
        const size_t bitwidth_; 
        const AccessMode accessMode_;
 
      public: // read write
        uint64_t read()
            const; 
        void write(uint64_t); 
        bool applyBitflip(unsigned position, uint64_t fault_id); 
        bool applyAction(const etiss::fault::Fault &f, const etiss::fault::Action &a,
                         std::string &errormsg); 
        void signalWrite(); 
      protected:            // read write implementation
        virtual uint64_t _read() const;
        virtual void _write(uint64_t);
        virtual bool _applyBitflip(unsigned position, uint64_t fault_id);
        virtual bool _applyAction(const etiss::fault::Fault &f, const etiss::fault::Action &a, std::string &errormsg);
        std::function<uint64_t()> lread;
        std::function<void(uint64_t)> lwrite;
 
      public:
        std::function<bool(unsigned position, uint64_t fault_id)> lapplyBitflip;
 
      public:
        std::function<void(Field *)> delete_;
        inline Field *setDeleteP(std::function<void(Field *)> del)
        {
            delete_ = del;
            return this;
        }
        inline Field &setDelete(std::function<void(Field *)> del)
        {
            delete_ = del;
            return *this;
        }
 
      public:
        bool addListener(Listener *listener, std::shared_ptr<Listener> ref = nullptr);
        void removeListener(Listener *listener, std::shared_ptr<Listener> ref = nullptr);
 
      private:
        std::set<std::pair<Listener *, std::shared_ptr<Listener>>, listener_pair_compare> listeners;
    };
 
  private:
    template <typename structT, typename retT, retT structT::*field>
    class FieldT : public VirtualStruct::Field
    {
        static_assert(sizeof(retT) <= sizeof(uint64_t),
                      "Cannot use etiss::VirtualStruct::FieldT for a field larger than uint64_t");
 
      protected:
        FieldT(VirtualStruct &parent, const std::string &name, const std::string &prettyname)
            : Field(parent, name, prettyname, 0, sizeof(retT))
        {
        }
        virtual uint64_t _read() const { return (uint64_t)((const structT *)parent_.structure_)->*field; }
        virtual void _write(uint64_t val) { ((structT *)parent_.structure_)->*field = (retT)val; }
    };
 
  protected:
    VirtualStruct(void *structure, std::function<void(Field *)> dtor = [](Field *f) { delete f; });
 
  public:
    virtual ~VirtualStruct();
 
    bool addField(Field *f, bool noerrorprint = false);
 
    template <typename structT, typename retT, retT structT::*field>
    bool addField(const std::string &name, const std::string &prettyname = "", bool noerrorprint = false)
    {
 
        Field *ret = new FieldT<structT, retT, field>(*this, name, prettyname);
 
        if (!addField(ret, noerrorprint))
        {
            delete ret;
            return false;
        }
 
        return true;
    }
 
    template <typename T>
    bool addField(const std::string &name, const std::string &prettyname, std::function<T()> read,
                  std::function<void(T)> write, bool supportsListener = false, bool noerrorprint = false)
    {
        int flags = 0;
        if (read)
            flags |= Field::R;
        if (write)
            flags |= Field::W;
        if (supportsListener)
            flags |= Field::L;
        Field *f = new Field(
            *this, name, prettyname, flags, sizeof(T), false, [read]() { return (uint64_t)read(); },
            [write](uint64_t v) { write((T)v); });
        if (addField(f, noerrorprint))
            return true;
        delete f;
        return false;
    }
 
    std::shared_ptr<Field> findName(const std::string &name) const;
    std::shared_ptr<Field> findPrettyName(const std::string &name) const;
    void foreachField(const std::function<void(std::shared_ptr<Field>)> &func);
 
    bool mountStruct(const std::string &name, const std::shared_ptr<VirtualStruct> vs);
    std::shared_ptr<VirtualStruct> findStruct(const std::string &name);
    void foreachStruct(const std::function<void(const std::string &name, VirtualStruct &vs)> &func);
 
    void close();
    bool isClosed();
 
  public: // inherited from etiss::fault::Injector
    virtual std::list<std::string> listFields();
    virtual std::list<std::string> listSubInjectors();
 
    virtual std::shared_ptr<etiss::fault::Injector> getSubInjector(const std::string &name);
    virtual std::shared_ptr<etiss::fault::Injector> getParentInjector();
 
    virtual bool acceleratedTrigger(const etiss::fault::Trigger &, int32_t fault_id);
 
  protected: // inherited from etiss::fault::Injector
    virtual void *fastFieldAccessPtr(const std::string &name, std::string &errormsg);
    virtual bool readField(void *fastfieldaccessptr, uint64_t &val, std::string &errormsg);
    virtual bool applyAction(const etiss::fault::Fault &fault, const etiss::fault::Action &action,
                             std::string &errormsg);
    virtual bool update_field_access_rights(const etiss::fault::Action &action, std::string &errormsg);
 
  public:
    std::function<bool(const etiss::fault::Fault &, const etiss::fault::Action &, std::string & /*errormsg*/)>
        applyCustomAction;
 
  public:
    void *const structure_;
    std::function<bool(const etiss::fault::Trigger &, int32_t)> acceleratedTrigger_;
 
  private:
    std::list<Field *> fields_;
    std::map<std::string, Field *> fieldNames_;
    std::map<std::string, Field *> fieldPrettyNames_;
    std::map<std::string, std::weak_ptr<VirtualStruct>> subStructs_;
    std::function<void(Field *)> dtor_;
    bool closed;
 
  private:
    std::shared_ptr<VirtualStruct> parent_;
 
  public:
    static std::shared_ptr<VirtualStruct> allocate(void *structure, std::function<void(Field *)> delete_);
 
  public: // name resolving an root VirtualStruct
    static std::shared_ptr<VirtualStruct> root();
 
    std::shared_ptr<VirtualStruct> getVirtualStruct(const std::string &path);
 
    std::shared_ptr<VirtualStruct::Field> getResolvedField(const std::string &path);
 
  public: // C interface
    static std::shared_ptr<VirtualStruct> allocateFromC(void *handle, VirtualStruct_names names,
                                                        VirtualStruct_prettyNames prettyNames_optional,
                                                        VirtualStruct_read read_recommended,
                                                        VirtualStruct_write write_optional,
                                                        VirtualStruct_setListenerCallback setListenerCallback_optional,
                                                        std::function<void(void *handle)> cleanup);
};
 
class VSSync
{
  public:
    VSSync();
    ~VSSync();
 
  private:
    static std::recursive_mutex &mutex();
};
 
void copy(VirtualStruct &dst, VirtualStruct &src, std::list<std::shared_ptr<VirtualStruct::Field>> &dst_notPresent,
          std::list<std::shared_ptr<VirtualStruct::Field>> &dst_notWriteable,
          std::list<std::shared_ptr<VirtualStruct::Field>> dst_unknown, bool pretend = false,
          std::list<std::shared_ptr<VirtualStruct::Field>> *src_private = 0,
          std::list<std::shared_ptr<VirtualStruct::Field>> *dst_private = 0);
 
class VirtualStructSupport
{
  public:
    virtual inline ~VirtualStructSupport() {}
    virtual std::shared_ptr<VirtualStruct> getStruct() = 0;
    virtual const std::string &getName() = 0;
};
 
#define ETISS_VIRTUALSTRUCT_ADDFIELD(VIRTUALSTRUCT, STRUCT, FIELD, NAME, PRETTYNAME) \
    (VIRTUALSTRUCT).addField<STRUCT, decltype(((STRUCT *)0)->FIELD), &STRUCT::FIELD>(NAME, PRETTYNAME);
 
} // namespace etiss
 
#endif