machine_base.hpp

#if !defined(__MACHINE_BASE_HPP__)
#define __MACHINE_BASE_HPP__

//
// local includes
//
#include "core/machine/generic/device_container.hpp"
#include "core/machine/devices/device.hpp"
#include "core/machine/iospace/iospace_manager.hpp"
#include "core/machine/memory/memory_manager.hpp"
#include "core/machine/irqs/irq_manager.hpp"
#include "core/machine/pci/pci_bridge_base.hpp"
#include "host_resource_owner.hpp"

//
// forward declarations
//
struct config_node;

struct machine_base : public iospace_manager, public memory_manager, public irq_manager
{
    static const bool VERBOSE_HOST_RESOURCES = true;
    static const int  NO_DEVICE_FOUND        = 0xffff;

  protected:
    machine_config config;

    device_container<device> legacy_devices;

    host_resource_owner host_owner;

  public:
    machine_base(const l4_threadid_t client=l4_myself())
        : iospace_manager(config), memory_manager(config), irq_manager(config), config(client)
    {
        log::info("initializing virtual machine for task 0x%02x ...\n", config.client.id.task);
    }

    virtual ~machine_base(void)
    {
      #if L4VMM_BUILD_DEBUG
        // see whether all destructors were called
        print_machine_state(true);
      #endif
    }

    //
    // functions for this class's users:
    //     machine init functions
    //
    virtual int init_machine(const machine_config &config, config_node *config_tree=nullptr);
    virtual int reset(void);

    //
    // functions for this class's users:
    //     set emulation mode & get PCI device functions
    //
    virtual inline int set_emulation_mode(l4vmm_emulation_modes mode)
    {
        config.mode=mode;
        return 0;
    }

    virtual inline pci_device *get_pci_device(pci_devfn devfn)
    {
        return get_host_bridge().get_device(devfn);
    }

    //
    // functions for devices referencing their machine object:
    //     obtain machine configuration & machine init functions
    //
    inline const machine_config &get_config(void) const
    {
        return config;
    }

    virtual int request_host_resources(const resource_descriptor &resource,
                                       bool verbose=VERBOSE_HOST_RESOURCES);
    virtual int request_host_resources(config_node &host_node,
                                       bool verbose=VERBOSE_HOST_RESOURCES);

    //
    // debug stuff
    //
    virtual void print_legacy_devices(const char *header=nullptr);
    virtual void print_pci_devices(const char *header=nullptr);
    virtual void print_machine_state(bool in_destruction=false);

  protected:
    //
    // functions for this class's users:
    //     abstract interface to be implemented in derived classes
    //
    virtual const char *name(void) const = 0;
    virtual pci_bridge &get_host_bridge(void) = 0;

    //
    // internal machine init node name to request function mapping
    //
    static const struct host_option
    {
        typedef int (machine_base::*request_func_ptr)(config_node &, bool);
        const char *name;
        request_func_ptr request_func;
    } host_options[];

    //
    // internal machine init functions
    //
    virtual int set_option(config_node &option_node);
    virtual int create_device(config_node &device_node);
    virtual int parse_machine_section(config_node &machine_node);

    virtual int request_host_ports(config_node &port_node, bool verbose=VERBOSE_HOST_RESOURCES);
    virtual int request_host_memory(config_node &memory_node, bool verbose=VERBOSE_HOST_RESOURCES);
    virtual int request_host_irqs(config_node &irq_node, bool verbose=VERBOSE_HOST_RESOURCES);
    virtual int request_host_groups(config_node &group_node, bool verbose=VERBOSE_HOST_RESOURCES);
    virtual int request_host_list(config_node &list_node, host_option::request_func_ptr request_func,
                                  bool verbose=VERBOSE_HOST_RESOURCES);

  private:
    //
    // internal create device implementation
    //
    template <typename DeviceT, typename ContainerT>
    int create_device(ContainerT &container, config_node &device_node);
};

#endif

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