[mirror_qemu.git] / include / hw / xen / xen_common.h

#ifndef QEMU_HW_XEN_COMMON_H
#define QEMU_HW_XEN_COMMON_H

/*
 * If we have new enough libxenctrl then we do not want/need these compat
 * interfaces, despite what the user supplied cflags might say. They
 * must be undefined before including xenctrl.h
 */
#undef XC_WANT_COMPAT_EVTCHN_API
#undef XC_WANT_COMPAT_GNTTAB_API
#undef XC_WANT_COMPAT_MAP_FOREIGN_API

#include <xenctrl.h>
#include <xenstore.h>
#include <xen/io/xenbus.h>

#include "hw/hw.h"
#include "hw/xen/xen.h"
#include "hw/pci/pci.h"
#include "qemu/queue.h"
#include "hw/xen/trace.h"

extern xc_interface *xen_xc;

/*
 * We don't support Xen prior to 4.2.0.
 */

static inline int xen_set_mem_type(domid_t domid, hvmmem_type_t type,
                                   uint64_t first_pfn, uint32_t nr)
{
    return xc_hvm_set_mem_type(xen_xc, domid, type, first_pfn, nr);
}

static inline int xen_set_pci_intx_level(domid_t domid, uint16_t segment,
                                         uint8_t bus, uint8_t device,
                                         uint8_t intx, unsigned int level)
{
    return xc_hvm_set_pci_intx_level(xen_xc, domid, segment, bus, device,
                                     intx, level);
}

static inline int xen_set_pci_link_route(domid_t domid, uint8_t link,
                                         uint8_t irq)
{
    return xc_hvm_set_pci_link_route(xen_xc, domid, link, irq);
}

static inline int xen_inject_msi(domid_t domid, uint64_t msi_addr,
                                 uint32_t msi_data)
{
    return xc_hvm_inject_msi(xen_xc, domid, msi_addr, msi_data);
}

static inline int xen_set_isa_irq_level(domid_t domid, uint8_t irq,
                                        unsigned int level)
{
    return xc_hvm_set_isa_irq_level(xen_xc, domid, irq, level);
}

static inline int xen_track_dirty_vram(domid_t domid, uint64_t first_pfn,
                                       uint32_t nr, unsigned long *bitmap)
{
    return xc_hvm_track_dirty_vram(xen_xc, domid, first_pfn, nr, bitmap);
}

static inline int xen_modified_memory(domid_t domid, uint64_t first_pfn,
                                      uint32_t nr)
{
    return xc_hvm_modified_memory(xen_xc, domid, first_pfn, nr);
}

/* Xen 4.2 through 4.6 */
#if CONFIG_XEN_CTRL_INTERFACE_VERSION < 471

typedef xc_interface xenforeignmemory_handle;
typedef xc_evtchn xenevtchn_handle;
typedef xc_gnttab xengnttab_handle;

#define xenevtchn_open(l, f) xc_evtchn_open(l, f);
#define xenevtchn_close(h) xc_evtchn_close(h)
#define xenevtchn_fd(h) xc_evtchn_fd(h)
#define xenevtchn_pending(h) xc_evtchn_pending(h)
#define xenevtchn_notify(h, p) xc_evtchn_notify(h, p)
#define xenevtchn_bind_interdomain(h, d, p) xc_evtchn_bind_interdomain(h, d, p)
#define xenevtchn_unmask(h, p) xc_evtchn_unmask(h, p)
#define xenevtchn_unbind(h, p) xc_evtchn_unbind(h, p)

#define xengnttab_open(l, f) xc_gnttab_open(l, f)
#define xengnttab_close(h) xc_gnttab_close(h)
#define xengnttab_set_max_grants(h, n) xc_gnttab_set_max_grants(h, n)
#define xengnttab_map_grant_ref(h, d, r, p) xc_gnttab_map_grant_ref(h, d, r, p)
#define xengnttab_unmap(h, a, n) xc_gnttab_munmap(h, a, n)
#define xengnttab_map_grant_refs(h, c, d, r, p) \
    xc_gnttab_map_grant_refs(h, c, d, r, p)
#define xengnttab_map_domain_grant_refs(h, c, d, r, p) \
    xc_gnttab_map_domain_grant_refs(h, c, d, r, p)

#define xenforeignmemory_open(l, f) xen_xc

static inline void *xenforeignmemory_map(xc_interface *h, uint32_t dom,
                                         int prot, size_t pages,
                                         const xen_pfn_t arr[/*pages*/],
                                         int err[/*pages*/])
{
    if (err)
        return xc_map_foreign_bulk(h, dom, prot, arr, err, pages);
    else
        return xc_map_foreign_pages(h, dom, prot, arr, pages);
}

#define xenforeignmemory_unmap(h, p, s) munmap(p, s * XC_PAGE_SIZE)

#else /* CONFIG_XEN_CTRL_INTERFACE_VERSION >= 471 */

#include <xenevtchn.h>
#include <xengnttab.h>
#include <xenforeignmemory.h>

#endif

extern xenforeignmemory_handle *xen_fmem;

void destroy_hvm_domain(bool reboot);

/* shutdown/destroy current domain because of an error */
void xen_shutdown_fatal_error(const char *fmt, ...) GCC_FMT_ATTR(1, 2);

#ifdef HVM_PARAM_VMPORT_REGS_PFN
static inline int xen_get_vmport_regs_pfn(xc_interface *xc, domid_t dom,
                                          xen_pfn_t *vmport_regs_pfn)
{
    int rc;
    uint64_t value;
    rc = xc_hvm_param_get(xc, dom, HVM_PARAM_VMPORT_REGS_PFN, &value);
    if (rc >= 0) {
        *vmport_regs_pfn = (xen_pfn_t) value;
    }
    return rc;
}
#else
static inline int xen_get_vmport_regs_pfn(xc_interface *xc, domid_t dom,
                                          xen_pfn_t *vmport_regs_pfn)
{
    return -ENOSYS;
}
#endif

/* Xen before 4.6 */
#if CONFIG_XEN_CTRL_INTERFACE_VERSION < 460

#ifndef HVM_IOREQSRV_BUFIOREQ_ATOMIC
#define HVM_IOREQSRV_BUFIOREQ_ATOMIC 2
#endif

#endif

static inline int xen_get_default_ioreq_server_info(domid_t dom,
                                                    xen_pfn_t *ioreq_pfn,
                                                    xen_pfn_t *bufioreq_pfn,
                                                    evtchn_port_t
                                                        *bufioreq_evtchn)
{
    unsigned long param;
    int rc;

    rc = xc_get_hvm_param(xen_xc, dom, HVM_PARAM_IOREQ_PFN, &param);
    if (rc < 0) {
        fprintf(stderr, "failed to get HVM_PARAM_IOREQ_PFN\n");
        return -1;
    }

    *ioreq_pfn = param;

    rc = xc_get_hvm_param(xen_xc, dom, HVM_PARAM_BUFIOREQ_PFN, &param);
    if (rc < 0) {
        fprintf(stderr, "failed to get HVM_PARAM_BUFIOREQ_PFN\n");
        return -1;
    }

    *bufioreq_pfn = param;

    rc = xc_get_hvm_param(xen_xc, dom, HVM_PARAM_BUFIOREQ_EVTCHN,
                          &param);
    if (rc < 0) {
        fprintf(stderr, "failed to get HVM_PARAM_BUFIOREQ_EVTCHN\n");
        return -1;
    }

    *bufioreq_evtchn = param;

    return 0;
}

/* Xen before 4.5 */
#if CONFIG_XEN_CTRL_INTERFACE_VERSION < 450

#ifndef HVM_PARAM_BUFIOREQ_EVTCHN
#define HVM_PARAM_BUFIOREQ_EVTCHN 26
#endif

#define IOREQ_TYPE_PCI_CONFIG 2

typedef uint16_t ioservid_t;

static inline void xen_map_memory_section(domid_t dom,
                                          ioservid_t ioservid,
                                          MemoryRegionSection *section)
{
}

static inline void xen_unmap_memory_section(domid_t dom,
                                            ioservid_t ioservid,
                                            MemoryRegionSection *section)
{
}

static inline void xen_map_io_section(domid_t dom,
                                      ioservid_t ioservid,
                                      MemoryRegionSection *section)
{
}

static inline void xen_unmap_io_section(domid_t dom,
                                        ioservid_t ioservid,
                                        MemoryRegionSection *section)
{
}

static inline void xen_map_pcidev(domid_t dom,
                                  ioservid_t ioservid,
                                  PCIDevice *pci_dev)
{
}

static inline void xen_unmap_pcidev(domid_t dom,
                                    ioservid_t ioservid,
                                    PCIDevice *pci_dev)
{
}

static inline void xen_create_ioreq_server(domid_t dom,
                                           ioservid_t *ioservid)
{
}

static inline void xen_destroy_ioreq_server(domid_t dom,
                                            ioservid_t ioservid)
{
}

static inline int xen_get_ioreq_server_info(domid_t dom,
                                            ioservid_t ioservid,
                                            xen_pfn_t *ioreq_pfn,
                                            xen_pfn_t *bufioreq_pfn,
                                            evtchn_port_t *bufioreq_evtchn)
{
    return xen_get_default_ioreq_server_info(dom, ioreq_pfn,
                                             bufioreq_pfn,
                                             bufioreq_evtchn);
}

static inline int xen_set_ioreq_server_state(domid_t dom,
                                             ioservid_t ioservid,
                                             bool enable)
{
    return 0;
}

/* Xen 4.5 */
#else

static bool use_default_ioreq_server;

static inline void xen_map_memory_section(domid_t dom,
                                          ioservid_t ioservid,
                                          MemoryRegionSection *section)
{
    hwaddr start_addr = section->offset_within_address_space;
    ram_addr_t size = int128_get64(section->size);
    hwaddr end_addr = start_addr + size - 1;

    if (use_default_ioreq_server) {
        return;
    }

    trace_xen_map_mmio_range(ioservid, start_addr, end_addr);
    xc_hvm_map_io_range_to_ioreq_server(xen_xc, dom, ioservid, 1,
                                        start_addr, end_addr);
}

static inline void xen_unmap_memory_section(domid_t dom,
                                            ioservid_t ioservid,
                                            MemoryRegionSection *section)
{
    hwaddr start_addr = section->offset_within_address_space;
    ram_addr_t size = int128_get64(section->size);
    hwaddr end_addr = start_addr + size - 1;

    if (use_default_ioreq_server) {
        return;
    }

    trace_xen_unmap_mmio_range(ioservid, start_addr, end_addr);
    xc_hvm_unmap_io_range_from_ioreq_server(xen_xc, dom, ioservid,
                                            1, start_addr, end_addr);
}

static inline void xen_map_io_section(domid_t dom,
                                      ioservid_t ioservid,
                                      MemoryRegionSection *section)
{
    hwaddr start_addr = section->offset_within_address_space;
    ram_addr_t size = int128_get64(section->size);
    hwaddr end_addr = start_addr + size - 1;

    if (use_default_ioreq_server) {
        return;
    }

    trace_xen_map_portio_range(ioservid, start_addr, end_addr);
    xc_hvm_map_io_range_to_ioreq_server(xen_xc, dom, ioservid, 0,
                                        start_addr, end_addr);
}

static inline void xen_unmap_io_section(domid_t dom,
                                        ioservid_t ioservid,
                                        MemoryRegionSection *section)
{
    hwaddr start_addr = section->offset_within_address_space;
    ram_addr_t size = int128_get64(section->size);
    hwaddr end_addr = start_addr + size - 1;

    if (use_default_ioreq_server) {
        return;
    }

    trace_xen_unmap_portio_range(ioservid, start_addr, end_addr);
    xc_hvm_unmap_io_range_from_ioreq_server(xen_xc, dom, ioservid,
                                            0, start_addr, end_addr);
}

static inline void xen_map_pcidev(domid_t dom,
                                  ioservid_t ioservid,
                                  PCIDevice *pci_dev)
{
    if (use_default_ioreq_server) {
        return;
    }

    trace_xen_map_pcidev(ioservid, pci_bus_num(pci_dev->bus),
                         PCI_SLOT(pci_dev->devfn), PCI_FUNC(pci_dev->devfn));
    xc_hvm_map_pcidev_to_ioreq_server(xen_xc, dom, ioservid, 0,
                                      pci_bus_num(pci_dev->bus),
                                      PCI_SLOT(pci_dev->devfn),
                                      PCI_FUNC(pci_dev->devfn));
}

static inline void xen_unmap_pcidev(domid_t dom,
                                    ioservid_t ioservid,
                                    PCIDevice *pci_dev)
{
    if (use_default_ioreq_server) {
        return;
    }

    trace_xen_unmap_pcidev(ioservid, pci_bus_num(pci_dev->bus),
                           PCI_SLOT(pci_dev->devfn), PCI_FUNC(pci_dev->devfn));
    xc_hvm_unmap_pcidev_from_ioreq_server(xen_xc, dom, ioservid, 0,
                                          pci_bus_num(pci_dev->bus),
                                          PCI_SLOT(pci_dev->devfn),
                                          PCI_FUNC(pci_dev->devfn));
}

static inline void xen_create_ioreq_server(domid_t dom,
                                           ioservid_t *ioservid)
{
    int rc = xc_hvm_create_ioreq_server(xen_xc, dom,
                                        HVM_IOREQSRV_BUFIOREQ_ATOMIC,
                                        ioservid);

    if (rc == 0) {
        trace_xen_ioreq_server_create(*ioservid);
        return;
    }

    *ioservid = 0;
    use_default_ioreq_server = true;
    trace_xen_default_ioreq_server();
}

static inline void xen_destroy_ioreq_server(domid_t dom,
                                            ioservid_t ioservid)
{
    if (use_default_ioreq_server) {
        return;
    }

    trace_xen_ioreq_server_destroy(ioservid);
    xc_hvm_destroy_ioreq_server(xen_xc, dom, ioservid);
}

static inline int xen_get_ioreq_server_info(domid_t dom,
                                            ioservid_t ioservid,
                                            xen_pfn_t *ioreq_pfn,
                                            xen_pfn_t *bufioreq_pfn,
                                            evtchn_port_t *bufioreq_evtchn)
{
    if (use_default_ioreq_server) {
        return xen_get_default_ioreq_server_info(dom, ioreq_pfn,
                                                 bufioreq_pfn,
                                                 bufioreq_evtchn);
    }

    return xc_hvm_get_ioreq_server_info(xen_xc, dom, ioservid,
                                        ioreq_pfn, bufioreq_pfn,
                                        bufioreq_evtchn);
}

static inline int xen_set_ioreq_server_state(domid_t dom,
                                             ioservid_t ioservid,
                                             bool enable)
{
    if (use_default_ioreq_server) {
        return 0;
    }

    trace_xen_ioreq_server_state(ioservid, enable);
    return xc_hvm_set_ioreq_server_state(xen_xc, dom, ioservid,
                                         enable);
}

#endif

#if CONFIG_XEN_CTRL_INTERFACE_VERSION < 460
static inline int xen_xc_domain_add_to_physmap(xc_interface *xch, uint32_t domid,
                                               unsigned int space,
                                               unsigned long idx,
                                               xen_pfn_t gpfn)
{
    return xc_domain_add_to_physmap(xch, domid, space, idx, gpfn);
}
#else
static inline int xen_xc_domain_add_to_physmap(xc_interface *xch, uint32_t domid,
                                               unsigned int space,
                                               unsigned long idx,
                                               xen_pfn_t gpfn)
{
    /* In Xen 4.6 rc is -1 and errno contains the error value. */
    int rc = xc_domain_add_to_physmap(xch, domid, space, idx, gpfn);
    if (rc == -1)
        return errno;
    return rc;
}
#endif

#ifdef CONFIG_XEN_PV_DOMAIN_BUILD
#if CONFIG_XEN_CTRL_INTERFACE_VERSION < 470
static inline int xen_domain_create(xc_interface *xc, uint32_t ssidref,
                                    xen_domain_handle_t handle, uint32_t flags,
                                    uint32_t *pdomid)
{
    return xc_domain_create(xc, ssidref, handle, flags, pdomid);
}
#else
static inline int xen_domain_create(xc_interface *xc, uint32_t ssidref,
                                    xen_domain_handle_t handle, uint32_t flags,
                                    uint32_t *pdomid)
{
    return xc_domain_create(xc, ssidref, handle, flags, pdomid, NULL);
}
#endif
#endif

/* Xen before 4.8 */

#if CONFIG_XEN_CTRL_INTERFACE_VERSION < 480


typedef void *xengnttab_grant_copy_segment_t;

static inline int xengnttab_grant_copy(xengnttab_handle *xgt, uint32_t count,
                                       xengnttab_grant_copy_segment_t *segs)
{
    return -ENOSYS;
}
#endif

#endif /* QEMU_HW_XEN_COMMON_H */
Commit	Line	Data
d94f9486	1	#ifndef QEMU_HW_XEN_COMMON_H
175de524	2	#define QEMU_HW_XEN_COMMON_H
d94f9486	3
5eeb39c2 IC	4	/*
	5	* If we have new enough libxenctrl then we do not want/need these compat
	6	* interfaces, despite what the user supplied cflags might say. They
	7	* must be undefined before including xenctrl.h
	8	*/
	9	#undef XC_WANT_COMPAT_EVTCHN_API
	10	#undef XC_WANT_COMPAT_GNTTAB_API
	11	#undef XC_WANT_COMPAT_MAP_FOREIGN_API
	12
d94f9486	13	#include <xenctrl.h>
edfb07ed	14	#include <xenstore.h>
d94f9486 AL	15	#include <xen/io/xenbus.h>
d94f9486 AL	16
83c9f4ca	17	#include "hw/hw.h"
0d09e41a	18	#include "hw/xen/xen.h"
3996e85c	19	#include "hw/pci/pci.h"
1de7afc9	20	#include "qemu/queue.h"
0ab8ed18	21	#include "hw/xen/trace.h"
d94f9486	22
260cabed PD	23	extern xc_interface *xen_xc;
260cabed PD	24
d94f9486	25	/*
edfb07ed	26	* We don't support Xen prior to 4.2.0.
d94f9486	27	*/
d5b93ddf	28
8f25e754 PD	29	static inline int xen_set_mem_type(domid_t domid, hvmmem_type_t type,
	30	uint64_t first_pfn, uint32_t nr)
	31	{
	32	return xc_hvm_set_mem_type(xen_xc, domid, type, first_pfn, nr);
	33	}
	34
	35	static inline int xen_set_pci_intx_level(domid_t domid, uint16_t segment,
	36	uint8_t bus, uint8_t device,
	37	uint8_t intx, unsigned int level)
	38	{
	39	return xc_hvm_set_pci_intx_level(xen_xc, domid, segment, bus, device,
	40	intx, level);
	41	}
	42
	43	static inline int xen_set_pci_link_route(domid_t domid, uint8_t link,
	44	uint8_t irq)
	45	{
	46	return xc_hvm_set_pci_link_route(xen_xc, domid, link, irq);
	47	}
	48
	49	static inline int xen_inject_msi(domid_t domid, uint64_t msi_addr,
	50	uint32_t msi_data)
	51	{
	52	return xc_hvm_inject_msi(xen_xc, domid, msi_addr, msi_data);
	53	}
	54
	55	static inline int xen_set_isa_irq_level(domid_t domid, uint8_t irq,
	56	unsigned int level)
	57	{
	58	return xc_hvm_set_isa_irq_level(xen_xc, domid, irq, level);
	59	}
	60
	61	static inline int xen_track_dirty_vram(domid_t domid, uint64_t first_pfn,
	62	uint32_t nr, unsigned long *bitmap)
	63	{
	64	return xc_hvm_track_dirty_vram(xen_xc, domid, first_pfn, nr, bitmap);
	65	}
	66
	67	static inline int xen_modified_memory(domid_t domid, uint64_t first_pfn,
	68	uint32_t nr)
	69	{
	70	return xc_hvm_modified_memory(xen_xc, domid, first_pfn, nr);
	71	}
	72
cb8d4c8f	73	/* Xen 4.2 through 4.6 */
edfb07ed	74	#if CONFIG_XEN_CTRL_INTERFACE_VERSION < 471
d5b93ddf	75
81daba58	76	typedef xc_interface xenforeignmemory_handle;
a2db2a1e	77	typedef xc_evtchn xenevtchn_handle;
c1345a88	78	typedef xc_gnttab xengnttab_handle;
d5b93ddf	79
a2db2a1e IC	80	#define xenevtchn_open(l, f) xc_evtchn_open(l, f);
	81	#define xenevtchn_close(h) xc_evtchn_close(h)
	82	#define xenevtchn_fd(h) xc_evtchn_fd(h)
	83	#define xenevtchn_pending(h) xc_evtchn_pending(h)
	84	#define xenevtchn_notify(h, p) xc_evtchn_notify(h, p)
	85	#define xenevtchn_bind_interdomain(h, d, p) xc_evtchn_bind_interdomain(h, d, p)
	86	#define xenevtchn_unmask(h, p) xc_evtchn_unmask(h, p)
	87	#define xenevtchn_unbind(h, p) xc_evtchn_unbind(h, p)
d5b93ddf	88
c1345a88 IC	89	#define xengnttab_open(l, f) xc_gnttab_open(l, f)
	90	#define xengnttab_close(h) xc_gnttab_close(h)
	91	#define xengnttab_set_max_grants(h, n) xc_gnttab_set_max_grants(h, n)
	92	#define xengnttab_map_grant_ref(h, d, r, p) xc_gnttab_map_grant_ref(h, d, r, p)
	93	#define xengnttab_unmap(h, a, n) xc_gnttab_munmap(h, a, n)
	94	#define xengnttab_map_grant_refs(h, c, d, r, p) \
	95	xc_gnttab_map_grant_refs(h, c, d, r, p)
816ac92e JG	96	#define xengnttab_map_domain_grant_refs(h, c, d, r, p) \
816ac92e JG	97	xc_gnttab_map_domain_grant_refs(h, c, d, r, p)
d5b93ddf	98
6aa0205e IC	99	#define xenforeignmemory_open(l, f) xen_xc
	100
	101	static inline void xenforeignmemory_map(xc_interface h, uint32_t dom,
	102	int prot, size_t pages,
	103	const xen_pfn_t arr[/pages/],
	104	int err[/pages/])
	105	{
	106	if (err)
	107	return xc_map_foreign_bulk(h, dom, prot, arr, err, pages);
	108	else
	109	return xc_map_foreign_pages(h, dom, prot, arr, pages);
	110	}
	111
	112	#define xenforeignmemory_unmap(h, p, s) munmap(p, s * XC_PAGE_SIZE)
e0cb42ae	113
5eeb39c2 IC	114	#else /* CONFIG_XEN_CTRL_INTERFACE_VERSION >= 471 */
5eeb39c2 IC	115
5eeb39c2 IC	116	#include <xenevtchn.h>
	117	#include <xengnttab.h>
	118	#include <xenforeignmemory.h>
	119
d94f9486 AL	120	#endif
d94f9486 AL	121
260cabed PD	122	extern xenforeignmemory_handle *xen_fmem;
260cabed PD	123
180640ea	124	void destroy_hvm_domain(bool reboot);
9ce94e7c	125
eaab4d60 AK	126	/* shutdown/destroy current domain because of an error */
	127	void xen_shutdown_fatal_error(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
	128
37f9e258	129	#ifdef HVM_PARAM_VMPORT_REGS_PFN
81daba58	130	static inline int xen_get_vmport_regs_pfn(xc_interface *xc, domid_t dom,
d01a5a3f	131	xen_pfn_t *vmport_regs_pfn)
37f9e258	132	{
d01a5a3f SS	133	int rc;
	134	uint64_t value;
	135	rc = xc_hvm_param_get(xc, dom, HVM_PARAM_VMPORT_REGS_PFN, &value);
	136	if (rc >= 0) {
	137	*vmport_regs_pfn = (xen_pfn_t) value;
	138	}
	139	return rc;
37f9e258 DS	140	}
37f9e258 DS	141	#else
81daba58	142	static inline int xen_get_vmport_regs_pfn(xc_interface *xc, domid_t dom,
d01a5a3f	143	xen_pfn_t *vmport_regs_pfn)
37f9e258 DS	144	{
	145	return -ENOSYS;
	146	}
	147	#endif
	148
d8b441a3 JB	149	/* Xen before 4.6 */
	150	#if CONFIG_XEN_CTRL_INTERFACE_VERSION < 460
	151
	152	#ifndef HVM_IOREQSRV_BUFIOREQ_ATOMIC
	153	#define HVM_IOREQSRV_BUFIOREQ_ATOMIC 2
	154	#endif
	155
	156	#endif
	157
260cabed	158	static inline int xen_get_default_ioreq_server_info(domid_t dom,
b7665c60 PD	159	xen_pfn_t *ioreq_pfn,
	160	xen_pfn_t *bufioreq_pfn,
	161	evtchn_port_t
	162	*bufioreq_evtchn)
	163	{
	164	unsigned long param;
	165	int rc;
	166
260cabed	167	rc = xc_get_hvm_param(xen_xc, dom, HVM_PARAM_IOREQ_PFN, &param);
b7665c60 PD	168	if (rc < 0) {
	169	fprintf(stderr, "failed to get HVM_PARAM_IOREQ_PFN\n");
	170	return -1;
	171	}
	172
	173	*ioreq_pfn = param;
	174
260cabed	175	rc = xc_get_hvm_param(xen_xc, dom, HVM_PARAM_BUFIOREQ_PFN, &param);
b7665c60 PD	176	if (rc < 0) {
	177	fprintf(stderr, "failed to get HVM_PARAM_BUFIOREQ_PFN\n");
	178	return -1;
	179	}
	180
	181	*bufioreq_pfn = param;
	182
260cabed	183	rc = xc_get_hvm_param(xen_xc, dom, HVM_PARAM_BUFIOREQ_EVTCHN,
b7665c60 PD	184	&param);
	185	if (rc < 0) {
	186	fprintf(stderr, "failed to get HVM_PARAM_BUFIOREQ_EVTCHN\n");
	187	return -1;
	188	}
	189
	190	*bufioreq_evtchn = param;
	191
	192	return 0;
	193	}
	194
3996e85c PD	195	/* Xen before 4.5 */
	196	#if CONFIG_XEN_CTRL_INTERFACE_VERSION < 450
	197
	198	#ifndef HVM_PARAM_BUFIOREQ_EVTCHN
	199	#define HVM_PARAM_BUFIOREQ_EVTCHN 26
	200	#endif
	201
	202	#define IOREQ_TYPE_PCI_CONFIG 2
	203
d09952ee	204	typedef uint16_t ioservid_t;
3996e85c	205
260cabed	206	static inline void xen_map_memory_section(domid_t dom,
3996e85c PD	207	ioservid_t ioservid,
	208	MemoryRegionSection *section)
	209	{
	210	}
	211
260cabed	212	static inline void xen_unmap_memory_section(domid_t dom,
3996e85c PD	213	ioservid_t ioservid,
	214	MemoryRegionSection *section)
	215	{
	216	}
	217
260cabed	218	static inline void xen_map_io_section(domid_t dom,
3996e85c PD	219	ioservid_t ioservid,
	220	MemoryRegionSection *section)
	221	{
	222	}
	223
260cabed	224	static inline void xen_unmap_io_section(domid_t dom,
3996e85c PD	225	ioservid_t ioservid,
	226	MemoryRegionSection *section)
	227	{
	228	}
	229
260cabed	230	static inline void xen_map_pcidev(domid_t dom,
3996e85c PD	231	ioservid_t ioservid,
	232	PCIDevice *pci_dev)
	233	{
	234	}
	235
260cabed	236	static inline void xen_unmap_pcidev(domid_t dom,
3996e85c PD	237	ioservid_t ioservid,
	238	PCIDevice *pci_dev)
	239	{
	240	}
	241
260cabed	242	static inline void xen_create_ioreq_server(domid_t dom,
b7665c60	243	ioservid_t *ioservid)
3996e85c	244	{
3996e85c PD	245	}
3996e85c PD	246
260cabed	247	static inline void xen_destroy_ioreq_server(domid_t dom,
3996e85c PD	248	ioservid_t ioservid)
	249	{
	250	}
	251
260cabed	252	static inline int xen_get_ioreq_server_info(domid_t dom,
3996e85c PD	253	ioservid_t ioservid,
	254	xen_pfn_t *ioreq_pfn,
	255	xen_pfn_t *bufioreq_pfn,
	256	evtchn_port_t *bufioreq_evtchn)
	257	{
260cabed PD	258	return xen_get_default_ioreq_server_info(dom, ioreq_pfn,
260cabed PD	259	bufioreq_pfn,
b7665c60	260	bufioreq_evtchn);
3996e85c PD	261	}
3996e85c PD	262
260cabed	263	static inline int xen_set_ioreq_server_state(domid_t dom,
3996e85c PD	264	ioservid_t ioservid,
	265	bool enable)
	266	{
	267	return 0;
	268	}
	269
	270	/* Xen 4.5 */
	271	#else
	272
b7665c60 PD	273	static bool use_default_ioreq_server;
b7665c60 PD	274
260cabed	275	static inline void xen_map_memory_section(domid_t dom,
3996e85c PD	276	ioservid_t ioservid,
	277	MemoryRegionSection *section)
	278	{
	279	hwaddr start_addr = section->offset_within_address_space;
	280	ram_addr_t size = int128_get64(section->size);
	281	hwaddr end_addr = start_addr + size - 1;
	282
b7665c60 PD	283	if (use_default_ioreq_server) {
	284	return;
	285	}
	286
3996e85c	287	trace_xen_map_mmio_range(ioservid, start_addr, end_addr);
260cabed	288	xc_hvm_map_io_range_to_ioreq_server(xen_xc, dom, ioservid, 1,
3996e85c PD	289	start_addr, end_addr);
	290	}
	291
260cabed	292	static inline void xen_unmap_memory_section(domid_t dom,
3996e85c PD	293	ioservid_t ioservid,
	294	MemoryRegionSection *section)
	295	{
	296	hwaddr start_addr = section->offset_within_address_space;
	297	ram_addr_t size = int128_get64(section->size);
	298	hwaddr end_addr = start_addr + size - 1;
	299
b7665c60 PD	300	if (use_default_ioreq_server) {
	301	return;
	302	}
	303
3996e85c	304	trace_xen_unmap_mmio_range(ioservid, start_addr, end_addr);
260cabed PD	305	xc_hvm_unmap_io_range_from_ioreq_server(xen_xc, dom, ioservid,
260cabed PD	306	1, start_addr, end_addr);
3996e85c PD	307	}
3996e85c PD	308
260cabed	309	static inline void xen_map_io_section(domid_t dom,
3996e85c PD	310	ioservid_t ioservid,
	311	MemoryRegionSection *section)
	312	{
	313	hwaddr start_addr = section->offset_within_address_space;
	314	ram_addr_t size = int128_get64(section->size);
	315	hwaddr end_addr = start_addr + size - 1;
	316
b7665c60 PD	317	if (use_default_ioreq_server) {
	318	return;
	319	}
	320
3996e85c	321	trace_xen_map_portio_range(ioservid, start_addr, end_addr);
260cabed	322	xc_hvm_map_io_range_to_ioreq_server(xen_xc, dom, ioservid, 0,
3996e85c PD	323	start_addr, end_addr);
	324	}
	325
260cabed	326	static inline void xen_unmap_io_section(domid_t dom,
3996e85c PD	327	ioservid_t ioservid,
	328	MemoryRegionSection *section)
	329	{
	330	hwaddr start_addr = section->offset_within_address_space;
	331	ram_addr_t size = int128_get64(section->size);
	332	hwaddr end_addr = start_addr + size - 1;
	333
b7665c60 PD	334	if (use_default_ioreq_server) {
	335	return;
	336	}
	337
3996e85c	338	trace_xen_unmap_portio_range(ioservid, start_addr, end_addr);
260cabed PD	339	xc_hvm_unmap_io_range_from_ioreq_server(xen_xc, dom, ioservid,
260cabed PD	340	0, start_addr, end_addr);
3996e85c PD	341	}
3996e85c PD	342
260cabed	343	static inline void xen_map_pcidev(domid_t dom,
3996e85c PD	344	ioservid_t ioservid,
	345	PCIDevice *pci_dev)
	346	{
b7665c60 PD	347	if (use_default_ioreq_server) {
	348	return;
	349	}
	350
3996e85c PD	351	trace_xen_map_pcidev(ioservid, pci_bus_num(pci_dev->bus),
3996e85c PD	352	PCI_SLOT(pci_dev->devfn), PCI_FUNC(pci_dev->devfn));
260cabed PD	353	xc_hvm_map_pcidev_to_ioreq_server(xen_xc, dom, ioservid, 0,
260cabed PD	354	pci_bus_num(pci_dev->bus),
3996e85c PD	355	PCI_SLOT(pci_dev->devfn),
	356	PCI_FUNC(pci_dev->devfn));
	357	}
	358
260cabed	359	static inline void xen_unmap_pcidev(domid_t dom,
3996e85c PD	360	ioservid_t ioservid,
	361	PCIDevice *pci_dev)
	362	{
b7665c60 PD	363	if (use_default_ioreq_server) {
	364	return;
	365	}
	366
3996e85c PD	367	trace_xen_unmap_pcidev(ioservid, pci_bus_num(pci_dev->bus),
3996e85c PD	368	PCI_SLOT(pci_dev->devfn), PCI_FUNC(pci_dev->devfn));
260cabed PD	369	xc_hvm_unmap_pcidev_from_ioreq_server(xen_xc, dom, ioservid, 0,
260cabed PD	370	pci_bus_num(pci_dev->bus),
3996e85c PD	371	PCI_SLOT(pci_dev->devfn),
	372	PCI_FUNC(pci_dev->devfn));
	373	}
	374
260cabed	375	static inline void xen_create_ioreq_server(domid_t dom,
b7665c60	376	ioservid_t *ioservid)
3996e85c	377	{
260cabed PD	378	int rc = xc_hvm_create_ioreq_server(xen_xc, dom,
260cabed PD	379	HVM_IOREQSRV_BUFIOREQ_ATOMIC,
d8b441a3	380	ioservid);
3996e85c PD	381
	382	if (rc == 0) {
	383	trace_xen_ioreq_server_create(*ioservid);
b7665c60	384	return;
3996e85c PD	385	}
3996e85c PD	386
b7665c60 PD	387	*ioservid = 0;
	388	use_default_ioreq_server = true;
	389	trace_xen_default_ioreq_server();
3996e85c PD	390	}
3996e85c PD	391
260cabed	392	static inline void xen_destroy_ioreq_server(domid_t dom,
3996e85c PD	393	ioservid_t ioservid)
3996e85c PD	394	{
b7665c60 PD	395	if (use_default_ioreq_server) {
	396	return;
	397	}
	398
3996e85c	399	trace_xen_ioreq_server_destroy(ioservid);
260cabed	400	xc_hvm_destroy_ioreq_server(xen_xc, dom, ioservid);
3996e85c PD	401	}
3996e85c PD	402
260cabed	403	static inline int xen_get_ioreq_server_info(domid_t dom,
3996e85c PD	404	ioservid_t ioservid,
	405	xen_pfn_t *ioreq_pfn,
	406	xen_pfn_t *bufioreq_pfn,
	407	evtchn_port_t *bufioreq_evtchn)
	408	{
b7665c60	409	if (use_default_ioreq_server) {
260cabed	410	return xen_get_default_ioreq_server_info(dom, ioreq_pfn,
b7665c60 PD	411	bufioreq_pfn,
	412	bufioreq_evtchn);
	413	}
	414
260cabed	415	return xc_hvm_get_ioreq_server_info(xen_xc, dom, ioservid,
3996e85c PD	416	ioreq_pfn, bufioreq_pfn,
	417	bufioreq_evtchn);
	418	}
	419
260cabed	420	static inline int xen_set_ioreq_server_state(domid_t dom,
3996e85c PD	421	ioservid_t ioservid,
	422	bool enable)
	423	{
b7665c60 PD	424	if (use_default_ioreq_server) {
	425	return 0;
	426	}
	427
3996e85c	428	trace_xen_ioreq_server_state(ioservid, enable);
260cabed PD	429	return xc_hvm_set_ioreq_server_state(xen_xc, dom, ioservid,
260cabed PD	430	enable);
3996e85c PD	431	}
	432
	433	#endif
	434
20a544c7	435	#if CONFIG_XEN_CTRL_INTERFACE_VERSION < 460
81daba58	436	static inline int xen_xc_domain_add_to_physmap(xc_interface *xch, uint32_t domid,
20a544c7 KRW	437	unsigned int space,
	438	unsigned long idx,
	439	xen_pfn_t gpfn)
	440	{
	441	return xc_domain_add_to_physmap(xch, domid, space, idx, gpfn);
	442	}
	443	#else
81daba58	444	static inline int xen_xc_domain_add_to_physmap(xc_interface *xch, uint32_t domid,
20a544c7 KRW	445	unsigned int space,
	446	unsigned long idx,
	447	xen_pfn_t gpfn)
	448	{
	449	/* In Xen 4.6 rc is -1 and errno contains the error value. */
	450	int rc = xc_domain_add_to_physmap(xch, domid, space, idx, gpfn);
	451	if (rc == -1)
	452	return errno;
	453	return rc;
	454	}
	455	#endif
	456
64a7ad6f	457	#ifdef CONFIG_XEN_PV_DOMAIN_BUILD
cdadde39	458	#if CONFIG_XEN_CTRL_INTERFACE_VERSION < 470
81daba58	459	static inline int xen_domain_create(xc_interface *xc, uint32_t ssidref,
cdadde39 RPM	460	xen_domain_handle_t handle, uint32_t flags,
	461	uint32_t *pdomid)
	462	{
	463	return xc_domain_create(xc, ssidref, handle, flags, pdomid);
	464	}
	465	#else
81daba58	466	static inline int xen_domain_create(xc_interface *xc, uint32_t ssidref,
cdadde39 RPM	467	xen_domain_handle_t handle, uint32_t flags,
	468	uint32_t *pdomid)
	469	{
	470	return xc_domain_create(xc, ssidref, handle, flags, pdomid, NULL);
	471	}
	472	#endif
64a7ad6f	473	#endif
cdadde39	474
b6eb9b45 PS	475	/* Xen before 4.8 */
	476
	477	#if CONFIG_XEN_CTRL_INTERFACE_VERSION < 480
	478
	479
	480	typedef void *xengnttab_grant_copy_segment_t;
	481
	482	static inline int xengnttab_grant_copy(xengnttab_handle *xgt, uint32_t count,
	483	xengnttab_grant_copy_segment_t *segs)
	484	{
	485	return -ENOSYS;
	486	}
	487	#endif
	488
d94f9486	489	#endif /* QEMU_HW_XEN_COMMON_H */