memory_manager.hpp

#if !defined(__MEMORY_MANAGER_HPP__)
#define __MEMORY_MANAGER_HPP__

//
// local includes
//
#include "core/machine/generic/resource_manager.hpp"
#include "core/machine/machine_config.hpp"
#include "memory_space.hpp"

struct memory_manager : public resource_manager, private noncopyable
{
    typedef memory_space<l4_gpa_t, mmio_handler> gpa_space;
    typedef gpa_space::region_type mmio_region;
    typedef memory_space<l4_hpa_t, mmio_handler> hpa_space;

    static const bool VERBOSE_ALLOCATION = false;

  protected:
    const machine_config &config;

    lock gpa_lock, hpa_lock;

    gpa_space gpa_map;

    hpa_space hpa_map;

    semaphore frame2page_lock;

    map<l4_gpa_t, l4_hva_t> frame2page_cache;

  public:
    //
    // constructors & destructors
    //
    memory_manager(const machine_config &config);
    virtual ~memory_manager(void);

    virtual int check_mmio_request(const mmio_handler *handler, l4_gpa_t base,
                                   l4_gpa_t size=1, bool verbose=VERBOSE_ALLOCATION) const;

    //
    // virtual (guest) physical I/O memory management functions
    //
    virtual inline const mmio_region *search_mmio_region(const l4_gpa_t base, const l4_gpa_t size=1)
    {
        return gpa_map.search_region(base, size);
    }

    virtual int register_mmio_handler(mmio_handler *handler, l4_gpa_t base,
                                      l4_gpa_t size=1, bool verbose=VERBOSE_ALLOCATION);
    virtual int unregister_mmio_handler(const mmio_handler *handler, l4_gpa_t base,
                                        l4_gpa_t size=1, bool verbose=VERBOSE_ALLOCATION);

    //
    // physical (host) physical I/O memory management functions
    //
    virtual l4_hva_t request_mmio_region(mmio_handler *handler, int l4io_flags,
                                         l4_hpa_t base, l4_hpa_t size=1, bool verbose=VERBOSE_ALLOCATION);
    virtual int release_mmio_region(const mmio_handler *handler, l4_hpa_t base,
                                    l4_hpa_t size=1, bool verbose=VERBOSE_ALLOCATION);
    virtual int release_mmio_regions(const mmio_handler *handler=nullptr, bool verbose=VERBOSE_ALLOCATION);

    //
    // translates (guest) physical addresses (not neccessarily frames) into
    //     (host) virtual addresses, using the cache if enabled.
    //
    inline l4_hva_t phys2virt(const l4_gpa_t phys)
    {
        return config.is(L4VMM_CACHE_PHYS_TO_VIRT) ?
                   phys2virt_cached(phys) : (*config.phys_to_virt_func)(phys);
    }

    //
    // translates (guest) physical addresses (not neccessarily frames) into
    //     (host) virtual addresses, always using the cache.
    //
    inline l4_hva_t phys2virt_cached(const l4_gpa_t phys)
    {
        auto_lock<semaphore> lock_guard(frame2page_lock);
        const l4_gpa_t frame=phys & memory::PAGE_MASK;
        l4_hva_t &page=frame2page_cache[frame];
        if (!page) page=(*config.phys_to_virt_func)(frame);
        return page | (phys & ~memory::PAGE_MASK);
    }

    //
    // debug functions
    //
    virtual void print_gpa_state(const char *header=nullptr);
    virtual void print_hpa_state(const char *header=nullptr);

  protected:
    virtual int init_memory(void);

  private:
    template <typename SpaceT, typename LockT>
    void print_memory_state(const SpaceT &map, LockT &lock, const char *header=nullptr);
};

#endif

// ***** end of source ***** //