|
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] Re: [Xen-devel] [PATCH 1/2] xen: Implement ioctl to restrict privcmd to a specific domain
On Tue, Aug 05, 2014 at 10:10:19AM +0100, Frediano Ziglio wrote:
> On Mon, 2014-08-04 at 16:26 -0400, Konrad Rzeszutek Wilk wrote:
> > On Thu, Jul 31, 2014 at 02:16:44PM +0100, Frediano Ziglio wrote:
> > > Add a RESTRICT ioctl to /dev/xen/privcmd, which allows privileged commands
> > > file descriptor to be restricted to only working with a particular domain.
> >
> > I feel I am missing an justification or use case here.
> >
>
> Running Qemu in domain0 but not allowing it to mess up with other
> domains.
Ok, so multiple levels of security. That is good.
Comments:
- Once the restriction is in place, there is only a subset of
hypercalls you can make. There is no mechanism to dynamically
adjust it (so say you upgrade Xen to a new version with a new
toolstack - and - you leave the kernel at its original version).
One way to solve this is to allow the ioctl to define which
hypercalls to tie down - but that might be too complex.
Perhaps there ought to be a version field with the ioctl so that
if you have a newer toolstack and it supplies a version that
is mismatched with the kernel - the kernel will fail the operation.
The toolstack is free to supply the ioctl again, but with an
older version?
- Some of these hypercalls don't have an ABI so we can't depend
on them being stable. How do you want to handle that?
- Please run the patch through scripts/checkpatch.pl
>
> Basically our Qemu version is quite restricted (normal user, chroot,
> single domain and others) but still can fully support a virtual machine.
Any ETA on when the patch for using this ioctl will be posted?
>
> The reason for not using stub domains is mainly for scalability reasons.
> Allocating fixed memory for every Qemu running (not taking into account
> the missing memory sharing) is quite memory consuming. 4gb dom0 can
> support 500 VMs.
>
> Frediano
>
>
> > >
> > > Signed-off-by: Frediano Ziglio <frediano.ziglio@xxxxxxxxxx>
> > > ---
> > > drivers/xen/privcmd.c | 209 ++++++-
> > > include/uapi/xen/privcmd.h | 6 +
> > > include/xen/interface/domctl.h | 1090
> > > ++++++++++++++++++++++++++++++++++++
> > > include/xen/interface/hvm/hvm_op.h | 66 +++
> > > include/xen/interface/memory.h | 8 +
> > > include/xen/interface/xen.h | 1 +
> > > 6 files changed, 1373 insertions(+), 7 deletions(-)
> > > create mode 100644 include/xen/interface/domctl.h
> > >
> > > diff --git a/drivers/xen/privcmd.c b/drivers/xen/privcmd.c
> > > index 569a13b..c177850 100644
> > > --- a/drivers/xen/privcmd.c
> > > +++ b/drivers/xen/privcmd.c
> > > @@ -32,6 +32,10 @@
> > > #include <xen/xen.h>
> > > #include <xen/privcmd.h>
> > > #include <xen/interface/xen.h>
> > > +#include <xen/interface/sched.h>
> > > +#include <xen/interface/memory.h>
> > > +#include <xen/interface/domctl.h>
> > > +#include <xen/interface/hvm/hvm_op.h>
> > > #include <xen/features.h>
> > > #include <xen/page.h>
> > > #include <xen/xen-ops.h>
> > > @@ -43,24 +47,173 @@ MODULE_LICENSE("GPL");
> > >
> > > #define PRIV_VMA_LOCKED ((void *)1)
> > >
> > > +#define UNRESTRICTED_DOMID ((domid_t)-1)
> > > +
> > > static int privcmd_vma_range_is_mapped(
> > > struct vm_area_struct *vma,
> > > unsigned long addr,
> > > unsigned long nr_pages);
> > >
> > > -static long privcmd_ioctl_hypercall(void __user *udata)
> > > +struct privcmd_check_buf {
> > > + unsigned copy_back;
> > > + void __user *copy_ptr;
> > > + union {
> > > + struct sched_remote_shutdown remote_shutdown;
> > > + struct xen_memory_exchange mem_exchange;
> > > + struct xen_domctl domctl;
> > > + unsigned char buf[1];
> > > + } u;
> > > +};
> > > +
> > > +static long privcmd_check_hypercall(struct privcmd_hypercall *hypercall,
> > > + struct privcmd_check *check,
> > > + domid_t restrict_domid)
> > > +{
> > > +#define DOMID_AT(type, field) do { \
> > > + BUILD_BUG_ON(sizeof(type) > sizeof(check->u)); \
> > > + BUILD_BUG_ON(sizeof(((type *) 0)->field) != sizeof(domid_t)); \
> > > + check->copy_back = sizeof(type); \
> > > + domid_offset = offsetof(type, field); \
> > > + } while (0)
> > > +
> > > +/* we copy from userspace and replace arguments to avoid unsafe data */
> > > +#define FETCH_ARG(dest, arg_num, size) do { \
> > > + check->copy_ptr = (void *) (long) hypercall->arg[arg_num]; \
> > > + if (copy_from_user(dest, check->copy_ptr, size)) \
> > > + return -EFAULT; \
> > > + hypercall->arg[arg_num] = (long) dest; \
> > > + } while (0)
> > > +
> > > + unsigned domid_offset;
> > > +
> > > + /* default to invalid so on cases not handled we fail */
> > > + domid_t domid = UNRESTRICTED_DOMID;
> > > +
> > > + switch (hypercall->op) {
> > > + case __HYPERVISOR_sched_op:
> > > + if (hypercall->arg[0] == SCHEDOP_remote_shutdown) {
> > > + FETCH_ARG(&check->u.remote_shutdown, 1,
> > > + sizeof(check->u.remote_shutdown));
> > > + domid = check->u.remote_shutdown.domain_id;
> > > + }
> > > + break;
> > > +
> > > + case __HYPERVISOR_domctl:
> > > + FETCH_ARG(&check->u.domctl, 0, sizeof(check->u.domctl));
> > > + check->copy_back = sizeof(check->u.domctl);
> > > + /* avoid to create a domain */
> > > + if (check->u.domctl.cmd == XEN_DOMCTL_createdomain)
> > > + return -EACCES;
> > > + /* limit versions to avoid possible future bigger buffer */
> > > + if (check->u.domctl.interface_version >
> > > XEN_DOMCTL_INTERFACE_VERSION)
> > > + return -EACCES;
> > > + domid = check->u.domctl.domain;
> > > + break;
> > > +
> > > + case __HYPERVISOR_memory_op:
> > > + switch (hypercall->arg[0]) {
> > > + case XENMEM_increase_reservation:
> > > + case XENMEM_decrease_reservation:
> > > + case XENMEM_populate_physmap:
> > > + DOMID_AT(struct xen_memory_reservation, domid);
> > > + break;
> > > + case XENMEM_exchange:
> > > + DOMID_AT(struct xen_memory_exchange, in.domid);
> > > + break;
> > > + case XENMEM_current_reservation:
> > > + case XENMEM_maximum_reservation:
> > > + case XENMEM_maximum_gpfn:
> > > + check->copy_back = sizeof(domid);
> > > + domid_offset = 0;
> > > + break;
> > > + case XENMEM_add_to_physmap:
> > > + DOMID_AT(struct xen_add_to_physmap, domid);
> > > + break;
> > > + case XENMEM_set_memory_map:
> > > + DOMID_AT(struct xen_foreign_memory_map, domid);
> > > + break;
> > > + default:
> > > + return -EACCES;
> > > + }
> > > + FETCH_ARG(&check->u, 1, check->copy_back);
> > > + domid = *((domid_t *) &check->u.buf[domid_offset]);
> > > +
> > > + /* extra check for XENMEM_exchange, exchange in the same
> > > + * domain */
> > > + if (hypercall->arg[0] == XENMEM_exchange &&
> > > + check->u.mem_exchange.in.domid !=
> > > check->u.mem_exchange.out.domid)
> > > + return -EACCES;
> > > + break;
> > > +
> > > + case __HYPERVISOR_hvm_op:
> > > + switch (hypercall->arg[0]) {
> > > + case HVMOP_set_param:
> > > + case HVMOP_get_param:
> > > + DOMID_AT(struct xen_hvm_param, domid);
> > > + break;
> > > + case HVMOP_set_pci_intx_level:
> > > + DOMID_AT(struct xen_hvm_set_pci_intx_level, domid);
> > > + break;
> > > + case HVMOP_set_isa_irq_level:
> > > + DOMID_AT(struct xen_hvm_set_isa_irq_level, domid);
> > > + break;
> > > + case HVMOP_set_pci_link_route:
> > > + DOMID_AT(struct xen_hvm_set_pci_link_route, domid);
> > > + break;
> > > + case HVMOP_modified_memory:
> > > + DOMID_AT(struct xen_hvm_modified_memory, domid);
> > > + break;
> > > + case HVMOP_set_mem_type:
> > > + DOMID_AT(struct xen_hvm_set_mem_type, domid);
> > > + break;
> > > + case HVMOP_track_dirty_vram:
> > > + DOMID_AT(struct xen_hvm_track_dirty_vram, domid);
> > > + break;
> > > + default:
> > > + return -EACCES;
> > > + }
> > > + FETCH_ARG(&check->u, 1, check->copy_back);
> > > + domid = *((domid_t *) &check->u.buf[domid_offset]);
> > > + break;
> > > + }
> > > +
> > > + if (domid != restrict_domid)
> > > + return -EACCES;
> > > +
> > > + return 0;
> > > +}
> > > +
> > > +static long privcmd_ioctl_hypercall(void __user *udata,
> > > + domid_t restrict_domid)
> > > {
> > > struct privcmd_hypercall hypercall;
> > > + struct privcmd_check_buf check_buf;
> > > long ret;
> > >
> > > + check_buf.copy_back = 0;
> > > + check_buf.copy_ptr = NULL;
> > > +
> > > if (copy_from_user(&hypercall, udata, sizeof(hypercall)))
> > > return -EFAULT;
> > >
> > > + /* we must check domain we are using */
> > > + if (restrict_domid != UNRESTRICTED_DOMID) {
> > > + ret = privcmd_check_hypercall(&hypercall, &check_buf,
> > > + restrict_domid);
> > > + if (ret)
> > > + return ret;
> > > + }
> > > +
> > > ret = privcmd_call(hypercall.op,
> > > hypercall.arg[0], hypercall.arg[1],
> > > hypercall.arg[2], hypercall.arg[3],
> > > hypercall.arg[4]);
> > >
> > > + if (check_buf.copy_back && check_buf.copy_ptr && ret >= 0)
> > > + if (copy_to_user(check_buf.copy_ptr, &check_buf.u,
> > > + check_buf.copy_back))
> > > + ret = -EFAULT;
> > > +
> > > return ret;
> > > }
> > >
> > > @@ -193,7 +346,7 @@ static int mmap_mfn_range(void *data, void *state)
> > > return 0;
> > > }
> > >
> > > -static long privcmd_ioctl_mmap(void __user *udata)
> > > +static long privcmd_ioctl_mmap(void __user *udata, domid_t
> > > restrict_domid)
> > > {
> > > struct privcmd_mmap mmapcmd;
> > > struct mm_struct *mm = current->mm;
> > > @@ -209,6 +362,10 @@ static long privcmd_ioctl_mmap(void __user *udata)
> > > if (copy_from_user(&mmapcmd, udata, sizeof(mmapcmd)))
> > > return -EFAULT;
> > >
> > > + if (restrict_domid != UNRESTRICTED_DOMID &&
> > > + restrict_domid != mmapcmd.dom)
> > > + return -EACCES;
> > > +
> > > rc = gather_array(&pagelist,
> > > mmapcmd.num, sizeof(struct privcmd_mmap_entry),
> > > mmapcmd.entry);
> > > @@ -367,7 +524,8 @@ static int alloc_empty_pages(struct vm_area_struct
> > > *vma, int numpgs)
> > >
> > > static struct vm_operations_struct privcmd_vm_ops;
> > >
> > > -static long privcmd_ioctl_mmap_batch(void __user *udata, int version)
> > > +static long privcmd_ioctl_mmap_batch(void __user *udata, int version,
> > > + domid_t restrict_domid)
> > > {
> > > int ret;
> > > struct privcmd_mmapbatch_v2 m;
> > > @@ -397,6 +555,10 @@ static long privcmd_ioctl_mmap_batch(void __user
> > > *udata, int version)
> > > return -EINVAL;
> > > }
> > >
> > > + if (restrict_domid != UNRESTRICTED_DOMID &&
> > > + restrict_domid != m.dom)
> > > + return -EACCES;
> > > +
> > > nr_pages = m.num;
> > > if ((m.num <= 0) || (nr_pages > (LONG_MAX >> PAGE_SHIFT)))
> > > return -EINVAL;
> > > @@ -498,27 +660,53 @@ out_unlock:
> > > goto out;
> > > }
> > >
> > > +static inline domid_t privcmd_get_restrict_domid(const struct file *file)
> > > +{
> > > + return (domid_t) (long) file->private_data;
> > > +}
> > > +
> > > +static inline void privcmd_set_restrict_domid(struct file *file,
> > > + domid_t domid)
> > > +{
> > > + file->private_data = (void *) (long) domid;
> > > +}
> > > +
> > > static long privcmd_ioctl(struct file *file,
> > > unsigned int cmd, unsigned long data)
> > > {
> > > int ret = -ENOSYS;
> > > void __user *udata = (void __user *) data;
> > > + domid_t restrict_domid = privcmd_get_restrict_domid(file);
> > >
> > > switch (cmd) {
> > > case IOCTL_PRIVCMD_HYPERCALL:
> > > - ret = privcmd_ioctl_hypercall(udata);
> > > + ret = privcmd_ioctl_hypercall(udata, restrict_domid);
> > > break;
> > >
> > > case IOCTL_PRIVCMD_MMAP:
> > > - ret = privcmd_ioctl_mmap(udata);
> > > + ret = privcmd_ioctl_mmap(udata, restrict_domid);
> > > break;
> > >
> > > case IOCTL_PRIVCMD_MMAPBATCH:
> > > - ret = privcmd_ioctl_mmap_batch(udata, 1);
> > > + ret = privcmd_ioctl_mmap_batch(udata, 1, restrict_domid);
> > > break;
> > >
> > > case IOCTL_PRIVCMD_MMAPBATCH_V2:
> > > - ret = privcmd_ioctl_mmap_batch(udata, 2);
> > > + ret = privcmd_ioctl_mmap_batch(udata, 2, restrict_domid);
> > > + break;
> > > +
> > > + case IOCTL_PRIVCMD_RESTRICT_DOMID: {
> > > + struct privcmd_restrict_domid prd;
> > > +
> > > + if (restrict_domid != UNRESTRICTED_DOMID)
> > > + return -EACCES;
> > > + if (copy_from_user(&prd, udata, sizeof(prd)))
> > > + return -EFAULT;
> > > + if (prd.domid >= DOMID_FIRST_RESERVED)
> > > + return -EINVAL;
> > > + privcmd_set_restrict_domid(file, prd.domid);
> > > + ret = 0;
> > > + }
> > > break;
> > >
> > > default:
> > > @@ -593,10 +781,17 @@ static int privcmd_vma_range_is_mapped(
> > > is_mapped_fn, NULL) != 0;
> > > }
> > >
> > > +static int privcmd_open(struct inode *ino, struct file *filp)
> > > +{
> > > + privcmd_set_restrict_domid(filp, UNRESTRICTED_DOMID);
> > > + return 0;
> > > +}
> > > +
> > > const struct file_operations xen_privcmd_fops = {
> > > .owner = THIS_MODULE,
> > > .unlocked_ioctl = privcmd_ioctl,
> > > .mmap = privcmd_mmap,
> > > + .open = privcmd_open,
> > > };
> > > EXPORT_SYMBOL_GPL(xen_privcmd_fops);
> > >
> > > diff --git a/include/uapi/xen/privcmd.h b/include/uapi/xen/privcmd.h
> > > index a853168..461a999 100644
> > > --- a/include/uapi/xen/privcmd.h
> > > +++ b/include/uapi/xen/privcmd.h
> > > @@ -73,6 +73,10 @@ struct privcmd_mmapbatch_v2 {
> > > int __user *err; /* array of error codes */
> > > };
> > >
> > > +struct privcmd_restrict_domid {
> > > + domid_t domid;
> > > +};
> > > +
> > > /*
> > > * @cmd: IOCTL_PRIVCMD_HYPERCALL
> > > * @arg: &privcmd_hypercall_t
> > > @@ -94,5 +98,7 @@ struct privcmd_mmapbatch_v2 {
> > > _IOC(_IOC_NONE, 'P', 3, sizeof(struct privcmd_mmapbatch))
> > > #define IOCTL_PRIVCMD_MMAPBATCH_V2 \
> > > _IOC(_IOC_NONE, 'P', 4, sizeof(struct privcmd_mmapbatch_v2))
> > > +#define IOCTL_PRIVCMD_RESTRICT_DOMID \
> > > + _IOC(_IOC_NONE, 'P', 5, sizeof(struct privcmd_restrict_domid))
> > >
> > > #endif /* __LINUX_PUBLIC_PRIVCMD_H__ */
> > > diff --git a/include/xen/interface/domctl.h
> > > b/include/xen/interface/domctl.h
> > > new file mode 100644
> > > index 0000000..0668fed
> > > --- /dev/null
> > > +++ b/include/xen/interface/domctl.h
> > > @@ -0,0 +1,1090 @@
> > > +/******************************************************************************
> > > + * domctl.h
> > > + *
> > > + * Domain management operations. For use by node control stack.
> > > + *
> > > + * Permission is hereby granted, free of charge, to any person obtaining
> > > a copy
> > > + * of this software and associated documentation files (the "Software"),
> > > to
> > > + * deal in the Software without restriction, including without
> > > limitation the
> > > + * rights to use, copy, modify, merge, publish, distribute, sublicense,
> > > and/or
> > > + * sell copies of the Software, and to permit persons to whom the
> > > Software is
> > > + * furnished to do so, subject to the following conditions:
> > > + *
> > > + * The above copyright notice and this permission notice shall be
> > > included in
> > > + * all copies or substantial portions of the Software.
> > > + *
> > > + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
> > > EXPRESS OR
> > > + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
> > > MERCHANTABILITY,
> > > + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
> > > SHALL THE
> > > + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
> > > + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
> > > ARISING
> > > + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
> > > + * DEALINGS IN THE SOFTWARE.
> > > + *
> > > + * Copyright (c) 2002-2003, B Dragovic
> > > + * Copyright (c) 2002-2006, K Fraser
> > > + */
> > > +
> > > +#ifndef __XEN_PUBLIC_DOMCTL_H__
> > > +#define __XEN_PUBLIC_DOMCTL_H__
> > > +
> > > +#include "xen.h"
> > > +#include "grant_table.h"
> > > +
> > > +#define XEN_DOMCTL_INTERFACE_VERSION 0x0000000a
> > > +
> > > +#if 1
> > > +/*
> > > + * NB. xen_domctl.domain is an IN/OUT parameter for this operation.
> > > + * If it is specified as zero, an id is auto-allocated and returned.
> > > + */
> > > +/* XEN_DOMCTL_createdomain */
> > > +struct xen_domctl_createdomain {
> > > + /* IN parameters */
> > > + uint32_t ssidref;
> > > + xen_domain_handle_t handle;
> > > + /* Is this an HVM guest (as opposed to a PVH or PV guest)? */
> > > +#define _XEN_DOMCTL_CDF_hvm_guest 0
> > > +#define XEN_DOMCTL_CDF_hvm_guest (1U<<_XEN_DOMCTL_CDF_hvm_guest)
> > > + /* Use hardware-assisted paging if available? */
> > > +#define _XEN_DOMCTL_CDF_hap 1
> > > +#define XEN_DOMCTL_CDF_hap (1U<<_XEN_DOMCTL_CDF_hap)
> > > + /* Should domain memory integrity be verifed by tboot during Sx? */
> > > +#define _XEN_DOMCTL_CDF_s3_integrity 2
> > > +#define XEN_DOMCTL_CDF_s3_integrity (1U<<_XEN_DOMCTL_CDF_s3_integrity)
> > > + /* Disable out-of-sync shadow page tables? */
> > > +#define _XEN_DOMCTL_CDF_oos_off 3
> > > +#define XEN_DOMCTL_CDF_oos_off (1U<<_XEN_DOMCTL_CDF_oos_off)
> > > + /* Is this a PVH guest (as opposed to an HVM or PV guest)? */
> > > +#define _XEN_DOMCTL_CDF_pvh_guest 4
> > > +#define XEN_DOMCTL_CDF_pvh_guest (1U<<_XEN_DOMCTL_CDF_pvh_guest)
> > > + uint32_t flags;
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_createdomain);
> > > +
> > > +/* XEN_DOMCTL_getdomaininfo */
> > > +struct xen_domctl_getdomaininfo {
> > > + /* OUT variables. */
> > > + domid_t domain; /* Also echoed in domctl.domain */
> > > + /* Domain is scheduled to die. */
> > > +#define _XEN_DOMINF_dying 0
> > > +#define XEN_DOMINF_dying (1U<<_XEN_DOMINF_dying)
> > > + /* Domain is an HVM guest (as opposed to a PV guest). */
> > > +#define _XEN_DOMINF_hvm_guest 1
> > > +#define XEN_DOMINF_hvm_guest (1U<<_XEN_DOMINF_hvm_guest)
> > > + /* The guest OS has shut down. */
> > > +#define _XEN_DOMINF_shutdown 2
> > > +#define XEN_DOMINF_shutdown (1U<<_XEN_DOMINF_shutdown)
> > > + /* Currently paused by control software. */
> > > +#define _XEN_DOMINF_paused 3
> > > +#define XEN_DOMINF_paused (1U<<_XEN_DOMINF_paused)
> > > + /* Currently blocked pending an event. */
> > > +#define _XEN_DOMINF_blocked 4
> > > +#define XEN_DOMINF_blocked (1U<<_XEN_DOMINF_blocked)
> > > + /* Domain is currently running. */
> > > +#define _XEN_DOMINF_running 5
> > > +#define XEN_DOMINF_running (1U<<_XEN_DOMINF_running)
> > > + /* Being debugged. */
> > > +#define _XEN_DOMINF_debugged 6
> > > +#define XEN_DOMINF_debugged (1U<<_XEN_DOMINF_debugged)
> > > +/* domain is PVH */
> > > +#define _XEN_DOMINF_pvh_guest 7
> > > +#define XEN_DOMINF_pvh_guest (1U<<_XEN_DOMINF_pvh_guest)
> > > + /* XEN_DOMINF_shutdown guest-supplied code. */
> > > +#define XEN_DOMINF_shutdownmask 255
> > > +#define XEN_DOMINF_shutdownshift 16
> > > + uint32_t flags; /* XEN_DOMINF_* */
> > > + aligned_u64 tot_pages;
> > > + aligned_u64 max_pages;
> > > + aligned_u64 outstanding_pages;
> > > + aligned_u64 shr_pages;
> > > + aligned_u64 paged_pages;
> > > + aligned_u64 shared_info_frame; /* GMFN of shared_info struct */
> > > + aligned_u64 cpu_time;
> > > + uint32_t nr_online_vcpus; /* Number of VCPUs currently online. */
> > > + uint32_t max_vcpu_id; /* Maximum VCPUID in use by this domain. */
> > > + uint32_t ssidref;
> > > + xen_domain_handle_t handle;
> > > + uint32_t cpupool;
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_getdomaininfo);
> > > +
> > > +
> > > +/* XEN_DOMCTL_getmemlist */
> > > +struct xen_domctl_getmemlist {
> > > + /* IN variables. */
> > > + /* Max entries to write to output buffer. */
> > > + aligned_u64 max_pfns;
> > > + /* Start index in guest's page list. */
> > > + aligned_u64 start_pfn;
> > > + GUEST_HANDLE(uint64_t) buffer;
> > > + /* OUT variables. */
> > > + aligned_u64 num_pfns;
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_getmemlist);
> > > +
> > > +
> > > +/* XEN_DOMCTL_getpageframeinfo */
> > > +
> > > +#define XEN_DOMCTL_PFINFO_LTAB_SHIFT 28
> > > +#define XEN_DOMCTL_PFINFO_NOTAB (0x0U<<28)
> > > +#define XEN_DOMCTL_PFINFO_L1TAB (0x1U<<28)
> > > +#define XEN_DOMCTL_PFINFO_L2TAB (0x2U<<28)
> > > +#define XEN_DOMCTL_PFINFO_L3TAB (0x3U<<28)
> > > +#define XEN_DOMCTL_PFINFO_L4TAB (0x4U<<28)
> > > +#define XEN_DOMCTL_PFINFO_LTABTYPE_MASK (0x7U<<28)
> > > +#define XEN_DOMCTL_PFINFO_LPINTAB (0x1U<<31)
> > > +#define XEN_DOMCTL_PFINFO_XTAB (0xfU<<28) /* invalid page */
> > > +#define XEN_DOMCTL_PFINFO_XALLOC (0xeU<<28) /* allocate-only page */
> > > +#define XEN_DOMCTL_PFINFO_BROKEN (0xdU<<28) /* broken page */
> > > +#define XEN_DOMCTL_PFINFO_LTAB_MASK (0xfU<<28)
> > > +
> > > +struct xen_domctl_getpageframeinfo {
> > > + /* IN variables. */
> > > + aligned_u64 gmfn; /* GMFN to query */
> > > + /* OUT variables. */
> > > + /* Is the page PINNED to a type? */
> > > + uint32_t type; /* see above type defs */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_getpageframeinfo);
> > > +
> > > +
> > > +/* XEN_DOMCTL_getpageframeinfo2 */
> > > +struct xen_domctl_getpageframeinfo2 {
> > > + /* IN variables. */
> > > + aligned_u64 num;
> > > + /* IN/OUT variables. */
> > > + GUEST_HANDLE(uint32_t) array;
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_getpageframeinfo2);
> > > +
> > > +/* XEN_DOMCTL_getpageframeinfo3 */
> > > +struct xen_domctl_getpageframeinfo3 {
> > > + /* IN variables. */
> > > + aligned_u64 num;
> > > + /* IN/OUT variables. */
> > > + GUEST_HANDLE(xen_pfn_t) array;
> > > +};
> > > +
> > > +
> > > +/*
> > > + * Control shadow pagetables operation
> > > + */
> > > +/* XEN_DOMCTL_shadow_op */
> > > +
> > > +/* Disable shadow mode. */
> > > +#define XEN_DOMCTL_SHADOW_OP_OFF 0
> > > +
> > > +/* Enable shadow mode (mode contains ORed XEN_DOMCTL_SHADOW_ENABLE_*
> > > flags). */
> > > +#define XEN_DOMCTL_SHADOW_OP_ENABLE 32
> > > +
> > > +/* Log-dirty bitmap operations. */
> > > + /* Return the bitmap and clean internal copy for next round. */
> > > +#define XEN_DOMCTL_SHADOW_OP_CLEAN 11
> > > + /* Return the bitmap but do not modify internal copy. */
> > > +#define XEN_DOMCTL_SHADOW_OP_PEEK 12
> > > +
> > > +/* Memory allocation accessors. */
> > > +#define XEN_DOMCTL_SHADOW_OP_GET_ALLOCATION 30
> > > +#define XEN_DOMCTL_SHADOW_OP_SET_ALLOCATION 31
> > > +
> > > +/* Legacy enable operations. */
> > > + /* Equiv. to ENABLE with no mode flags. */
> > > +#define XEN_DOMCTL_SHADOW_OP_ENABLE_TEST 1
> > > + /* Equiv. to ENABLE with mode flag ENABLE_LOG_DIRTY. */
> > > +#define XEN_DOMCTL_SHADOW_OP_ENABLE_LOGDIRTY 2
> > > + /* Equiv. to ENABLE with mode flags ENABLE_REFCOUNT and
> > > ENABLE_TRANSLATE. */
> > > +#define XEN_DOMCTL_SHADOW_OP_ENABLE_TRANSLATE 3
> > > +
> > > +/* Mode flags for XEN_DOMCTL_SHADOW_OP_ENABLE. */
> > > + /*
> > > + * Shadow pagetables are refcounted: guest does not use explicit mmu
> > > + * operations nor write-protect its pagetables.
> > > + */
> > > +#define XEN_DOMCTL_SHADOW_ENABLE_REFCOUNT (1 << 1)
> > > + /*
> > > + * Log pages in a bitmap as they are dirtied.
> > > + * Used for live relocation to determine which pages must be re-sent.
> > > + */
> > > +#define XEN_DOMCTL_SHADOW_ENABLE_LOG_DIRTY (1 << 2)
> > > + /*
> > > + * Automatically translate GPFNs into MFNs.
> > > + */
> > > +#define XEN_DOMCTL_SHADOW_ENABLE_TRANSLATE (1 << 3)
> > > + /*
> > > + * Xen does not steal virtual address space from the guest.
> > > + * Requires HVM support.
> > > + */
> > > +#define XEN_DOMCTL_SHADOW_ENABLE_EXTERNAL (1 << 4)
> > > +
> > > +struct xen_domctl_shadow_op_stats {
> > > + uint32_t fault_count;
> > > + uint32_t dirty_count;
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_shadow_op_stats);
> > > +
> > > +struct xen_domctl_shadow_op {
> > > + /* IN variables. */
> > > + uint32_t op; /* XEN_DOMCTL_SHADOW_OP_* */
> > > +
> > > + /* OP_ENABLE */
> > > + uint32_t mode; /* XEN_DOMCTL_SHADOW_ENABLE_* */
> > > +
> > > + /* OP_GET_ALLOCATION / OP_SET_ALLOCATION */
> > > + uint32_t mb; /* Shadow memory allocation in MB */
> > > +
> > > + /* OP_PEEK / OP_CLEAN */
> > > + GUEST_HANDLE(uchar) dirty_bitmap;
> > > + aligned_u64 pages; /* Size of buffer. Updated with actual size. */
> > > + struct xen_domctl_shadow_op_stats stats;
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_shadow_op);
> > > +
> > > +
> > > +/* XEN_DOMCTL_max_mem */
> > > +struct xen_domctl_max_mem {
> > > + /* IN variables. */
> > > + aligned_u64 max_memkb;
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_max_mem);
> > > +
> > > +
> > > +/* XEN_DOMCTL_setvcpucontext */
> > > +/* XEN_DOMCTL_getvcpucontext */
> > > +struct xen_domctl_vcpucontext {
> > > + uint32_t vcpu; /* IN */
> > > + GUEST_HANDLE(vcpu_guest_context) ctxt; /* IN/OUT */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_vcpucontext);
> > > +
> > > +
> > > +/* XEN_DOMCTL_getvcpuinfo */
> > > +struct xen_domctl_getvcpuinfo {
> > > + /* IN variables. */
> > > + uint32_t vcpu;
> > > + /* OUT variables. */
> > > + uint8_t online; /* currently online (not hotplugged)? */
> > > + uint8_t blocked; /* blocked waiting for an event? */
> > > + uint8_t running; /* currently scheduled on its CPU? */
> > > + aligned_u64 cpu_time; /* total cpu time consumed (ns) */
> > > + uint32_t cpu; /* current mapping */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_getvcpuinfo);
> > > +
> > > +#if 0
> > > +/* Get/set the NUMA node(s) with which the guest has affinity with. */
> > > +/* XEN_DOMCTL_setnodeaffinity */
> > > +/* XEN_DOMCTL_getnodeaffinity */
> > > +struct xen_domctl_nodeaffinity {
> > > + struct xenctl_bitmap nodemap;/* IN */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_nodeaffinity);
> > > +
> > > +
> > > +/* Get/set which physical cpus a vcpu can execute on. */
> > > +/* XEN_DOMCTL_setvcpuaffinity */
> > > +/* XEN_DOMCTL_getvcpuaffinity */
> > > +struct xen_domctl_vcpuaffinity {
> > > + uint32_t vcpu; /* IN */
> > > + struct xenctl_bitmap cpumap; /* IN/OUT */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_vcpuaffinity);
> > > +#endif
> > > +
> > > +
> > > +/* XEN_DOMCTL_max_vcpus */
> > > +struct xen_domctl_max_vcpus {
> > > + uint32_t max; /* maximum number of vcpus */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_max_vcpus);
> > > +
> > > +
> > > +/* XEN_DOMCTL_scheduler_op */
> > > +/* Scheduler types. */
> > > +#define XEN_SCHEDULER_SEDF 4
> > > +#define XEN_SCHEDULER_CREDIT 5
> > > +#define XEN_SCHEDULER_CREDIT2 6
> > > +#define XEN_SCHEDULER_ARINC653 7
> > > +/* Set or get info? */
> > > +#define XEN_DOMCTL_SCHEDOP_putinfo 0
> > > +#define XEN_DOMCTL_SCHEDOP_getinfo 1
> > > +struct xen_domctl_scheduler_op {
> > > + uint32_t sched_id; /* XEN_SCHEDULER_* */
> > > + uint32_t cmd; /* XEN_DOMCTL_SCHEDOP_* */
> > > + union {
> > > + struct xen_domctl_sched_sedf {
> > > + aligned_u64 period;
> > > + aligned_u64 slice;
> > > + aligned_u64 latency;
> > > + uint32_t extratime;
> > > + uint32_t weight;
> > > + } sedf;
> > > + struct xen_domctl_sched_credit {
> > > + uint16_t weight;
> > > + uint16_t cap;
> > > + } credit;
> > > + struct xen_domctl_sched_credit2 {
> > > + uint16_t weight;
> > > + } credit2;
> > > + } u;
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_scheduler_op);
> > > +
> > > +
> > > +/* XEN_DOMCTL_setdomainhandle */
> > > +struct xen_domctl_setdomainhandle {
> > > + xen_domain_handle_t handle;
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_setdomainhandle);
> > > +
> > > +
> > > +/* XEN_DOMCTL_setdebugging */
> > > +struct xen_domctl_setdebugging {
> > > + uint8_t enable;
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_setdebugging);
> > > +
> > > +
> > > +/* XEN_DOMCTL_irq_permission */
> > > +struct xen_domctl_irq_permission {
> > > + uint8_t pirq;
> > > + uint8_t allow_access; /* flag to specify enable/disable of IRQ access */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_irq_permission);
> > > +
> > > +
> > > +/* XEN_DOMCTL_iomem_permission */
> > > +struct xen_domctl_iomem_permission {
> > > + aligned_u64 first_mfn;/* first page (physical page number) in range */
> > > + aligned_u64 nr_mfns; /* number of pages in range (>0) */
> > > + uint8_t allow_access; /* allow (!0) or deny (0) access to range? */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_iomem_permission);
> > > +
> > > +
> > > +/* XEN_DOMCTL_ioport_permission */
> > > +struct xen_domctl_ioport_permission {
> > > + uint32_t first_port; /* first port int range */
> > > + uint32_t nr_ports; /* size of port range */
> > > + uint8_t allow_access; /* allow or deny access to range? */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_ioport_permission);
> > > +
> > > +
> > > +/* XEN_DOMCTL_hypercall_init */
> > > +struct xen_domctl_hypercall_init {
> > > + aligned_u64 gmfn; /* GMFN to be initialised */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_hypercall_init);
> > > +
> > > +
> > > +/* XEN_DOMCTL_arch_setup */
> > > +#define _XEN_DOMAINSETUP_hvm_guest 0
> > > +#define XEN_DOMAINSETUP_hvm_guest (1UL<<_XEN_DOMAINSETUP_hvm_guest)
> > > +#define _XEN_DOMAINSETUP_query 1 /* Get parameters (for save) */
> > > +#define XEN_DOMAINSETUP_query (1UL<<_XEN_DOMAINSETUP_query)
> > > +#define _XEN_DOMAINSETUP_sioemu_guest 2
> > > +#define XEN_DOMAINSETUP_sioemu_guest
> > > (1UL<<_XEN_DOMAINSETUP_sioemu_guest)
> > > +struct xen_domctl_arch_setup {
> > > + aligned_u64 flags; /* XEN_DOMAINSETUP_* */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_arch_setup);
> > > +
> > > +
> > > +/* XEN_DOMCTL_settimeoffset */
> > > +struct xen_domctl_settimeoffset {
> > > + int32_t time_offset_seconds; /* applied to domain wallclock time */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_settimeoffset);
> > > +
> > > +/* XEN_DOMCTL_gethvmcontext */
> > > +/* XEN_DOMCTL_sethvmcontext */
> > > +struct xen_domctl_hvmcontext {
> > > + uint32_t size; /* IN/OUT: size of buffer / bytes filled */
> > > + GUEST_HANDLE(uchar) buffer; /* IN/OUT: data, or call
> > > + * gethvmcontext with NULL
> > > + * buffer to get size req'd */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_hvmcontext);
> > > +
> > > +
> > > +/* XEN_DOMCTL_set_address_size */
> > > +/* XEN_DOMCTL_get_address_size */
> > > +struct xen_domctl_address_size {
> > > + uint32_t size;
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_address_size);
> > > +
> > > +
> > > +/* XEN_DOMCTL_real_mode_area */
> > > +struct xen_domctl_real_mode_area {
> > > + uint32_t log; /* log2 of Real Mode Area size */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_real_mode_area);
> > > +
> > > +
> > > +/* XEN_DOMCTL_sendtrigger */
> > > +#define XEN_DOMCTL_SENDTRIGGER_NMI 0
> > > +#define XEN_DOMCTL_SENDTRIGGER_RESET 1
> > > +#define XEN_DOMCTL_SENDTRIGGER_INIT 2
> > > +#define XEN_DOMCTL_SENDTRIGGER_POWER 3
> > > +#define XEN_DOMCTL_SENDTRIGGER_SLEEP 4
> > > +struct xen_domctl_sendtrigger {
> > > + uint32_t trigger; /* IN */
> > > + uint32_t vcpu; /* IN */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_sendtrigger);
> > > +
> > > +
> > > +/* Assign PCI device to HVM guest. Sets up IOMMU structures. */
> > > +/* XEN_DOMCTL_assign_device */
> > > +/* XEN_DOMCTL_test_assign_device */
> > > +/* XEN_DOMCTL_deassign_device */
> > > +struct xen_domctl_assign_device {
> > > + uint32_t machine_sbdf; /* machine PCI ID of assigned device */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_assign_device);
> > > +
> > > +/* Retrieve sibling devices infomation of machine_sbdf */
> > > +/* XEN_DOMCTL_get_device_group */
> > > +struct xen_domctl_get_device_group {
> > > + uint32_t machine_sbdf; /* IN */
> > > + uint32_t max_sdevs; /* IN */
> > > + uint32_t num_sdevs; /* OUT */
> > > + GUEST_HANDLE(uint32_t) sdev_array; /* OUT */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_get_device_group);
> > > +
> > > +/* Pass-through interrupts: bind real irq -> hvm devfn. */
> > > +/* XEN_DOMCTL_bind_pt_irq */
> > > +/* XEN_DOMCTL_unbind_pt_irq */
> > > +enum pt_irq_type_e {
> > > + PT_IRQ_TYPE_PCI,
> > > + PT_IRQ_TYPE_ISA,
> > > + PT_IRQ_TYPE_MSI,
> > > + PT_IRQ_TYPE_MSI_TRANSLATE,
> > > +};
> > > +struct xen_domctl_bind_pt_irq {
> > > + uint32_t machine_irq;
> > > + enum pt_irq_type_e irq_type;
> > > + uint32_t hvm_domid;
> > > +
> > > + union {
> > > + struct {
> > > + uint8_t isa_irq;
> > > + } isa;
> > > + struct {
> > > + uint8_t bus;
> > > + uint8_t device;
> > > + uint8_t intx;
> > > + } pci;
> > > + struct {
> > > + uint8_t gvec;
> > > + uint32_t gflags;
> > > + aligned_u64 gtable;
> > > + } msi;
> > > + } u;
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_bind_pt_irq);
> > > +
> > > +
> > > +/* Bind machine I/O address range -> HVM address range. */
> > > +/* XEN_DOMCTL_memory_mapping */
> > > +#define DPCI_ADD_MAPPING 1
> > > +#define DPCI_REMOVE_MAPPING 0
> > > +struct xen_domctl_memory_mapping {
> > > + aligned_u64 first_gfn; /* first page (hvm guest phys page) in range */
> > > + aligned_u64 first_mfn; /* first page (machine page) in range */
> > > + aligned_u64 nr_mfns; /* number of pages in range (>0) */
> > > + uint32_t add_mapping; /* add or remove mapping */
> > > + uint32_t padding; /* padding for 64-bit aligned structure */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_memory_mapping);
> > > +
> > > +
> > > +/* Bind machine I/O port range -> HVM I/O port range. */
> > > +/* XEN_DOMCTL_ioport_mapping */
> > > +struct xen_domctl_ioport_mapping {
> > > + uint32_t first_gport; /* first guest IO port*/
> > > + uint32_t first_mport; /* first machine IO port */
> > > + uint32_t nr_ports; /* size of port range */
> > > + uint32_t add_mapping; /* add or remove mapping */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_ioport_mapping);
> > > +
> > > +
> > > +/*
> > > + * Pin caching type of RAM space for x86 HVM domU.
> > > + */
> > > +/* XEN_DOMCTL_pin_mem_cacheattr */
> > > +/* Caching types: these happen to be the same as x86 MTRR/PAT type
> > > codes. */
> > > +#define XEN_DOMCTL_MEM_CACHEATTR_UC 0
> > > +#define XEN_DOMCTL_MEM_CACHEATTR_WC 1
> > > +#define XEN_DOMCTL_MEM_CACHEATTR_WT 4
> > > +#define XEN_DOMCTL_MEM_CACHEATTR_WP 5
> > > +#define XEN_DOMCTL_MEM_CACHEATTR_WB 6
> > > +#define XEN_DOMCTL_MEM_CACHEATTR_UCM 7
> > > +struct xen_domctl_pin_mem_cacheattr {
> > > + aligned_u64 start, end;
> > > + uint32_t type; /* XEN_DOMCTL_MEM_CACHEATTR_* */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_pin_mem_cacheattr);
> > > +
> > > +
> > > +#if 0
> > > +/* XEN_DOMCTL_set_ext_vcpucontext */
> > > +/* XEN_DOMCTL_get_ext_vcpucontext */
> > > +struct xen_domctl_ext_vcpucontext {
> > > + /* IN: VCPU that this call applies to. */
> > > + uint32_t vcpu;
> > > + /*
> > > + * SET: Size of struct (IN)
> > > + * GET: Size of struct (OUT, up to 128 bytes)
> > > + */
> > > + uint32_t size;
> > > +#if defined(__i386__) || defined(__x86_64__)
> > > + /* SYSCALL from 32-bit mode and SYSENTER callback information. */
> > > + /* NB. SYSCALL from 64-bit mode is contained in vcpu_guest_context_t */
> > > + aligned_u64 syscall32_callback_eip;
> > > + aligned_u64 sysenter_callback_eip;
> > > + uint16_t syscall32_callback_cs;
> > > + uint16_t sysenter_callback_cs;
> > > + uint8_t syscall32_disables_events;
> > > + uint8_t sysenter_disables_events;
> > > +#if defined(__GNUC__)
> > > + union {
> > > + aligned_u64 mcg_cap;
> > > + struct hvm_vmce_vcpu vmce;
> > > + };
> > > +#else
> > > + struct hvm_vmce_vcpu vmce;
> > > +#endif
> > > +#endif
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_ext_vcpucontext);
> > > +#endif
> > > +
> > > +/*
> > > + * Set the target domain for a domain
> > > + */
> > > +/* XEN_DOMCTL_set_target */
> > > +struct xen_domctl_set_target {
> > > + domid_t target;
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_set_target);
> > > +
> > > +#if defined(__i386__) || defined(__x86_64__)
> > > +# define XEN_CPUID_INPUT_UNUSED 0xFFFFFFFF
> > > +/* XEN_DOMCTL_set_cpuid */
> > > +struct xen_domctl_cpuid {
> > > + uint32_t input[2];
> > > + uint32_t eax;
> > > + uint32_t ebx;
> > > + uint32_t ecx;
> > > + uint32_t edx;
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_cpuid);
> > > +#endif
> > > +
> > > +/*
> > > + * Arranges that if the domain suspends (specifically, if it shuts
> > > + * down with code SHUTDOWN_suspend), this event channel will be
> > > + * notified.
> > > + *
> > > + * This is _instead of_ the usual notification to the global
> > > + * VIRQ_DOM_EXC. (In most systems that pirq is owned by xenstored.)
> > > + *
> > > + * Only one subscription per domain is possible. Last subscriber
> > > + * wins; others are silently displaced.
> > > + *
> > > + * NB that contrary to the rather general name, it only applies to
> > > + * domain shutdown with code suspend. Shutdown for other reasons
> > > + * (including crash), and domain death, are notified to VIRQ_DOM_EXC
> > > + * regardless.
> > > + */
> > > +/* XEN_DOMCTL_subscribe */
> > > +struct xen_domctl_subscribe {
> > > + uint32_t port; /* IN */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_subscribe);
> > > +
> > > +/*
> > > + * Define the maximum machine address size which should be allocated
> > > + * to a guest.
> > > + */
> > > +/* XEN_DOMCTL_set_machine_address_size */
> > > +/* XEN_DOMCTL_get_machine_address_size */
> > > +
> > > +/*
> > > + * Do not inject spurious page faults into this domain.
> > > + */
> > > +/* XEN_DOMCTL_suppress_spurious_page_faults */
> > > +
> > > +/* XEN_DOMCTL_debug_op */
> > > +#define XEN_DOMCTL_DEBUG_OP_SINGLE_STEP_OFF 0
> > > +#define XEN_DOMCTL_DEBUG_OP_SINGLE_STEP_ON 1
> > > +struct xen_domctl_debug_op {
> > > + uint32_t op; /* IN */
> > > + uint32_t vcpu; /* IN */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_debug_op);
> > > +
> > > +/*
> > > + * Request a particular record from the HVM context
> > > + */
> > > +/* XEN_DOMCTL_gethvmcontext_partial */
> > > +struct xen_domctl_hvmcontext_partial {
> > > + uint32_t type; /* IN: Type of record required */
> > > + uint32_t instance; /* IN: Instance of that type */
> > > + GUEST_HANDLE(uchar) buffer; /* OUT: buffer to write record into */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_hvmcontext_partial);
> > > +
> > > +/* XEN_DOMCTL_disable_migrate */
> > > +struct xen_domctl_disable_migrate {
> > > + uint32_t disable; /* IN: 1: disable migration and restore */
> > > +};
> > > +
> > > +
> > > +/* XEN_DOMCTL_gettscinfo */
> > > +/* XEN_DOMCTL_settscinfo */
> > > +struct xen_guest_tsc_info {
> > > + uint32_t tsc_mode;
> > > + uint32_t gtsc_khz;
> > > + uint32_t incarnation;
> > > + uint32_t pad;
> > > + aligned_u64 elapsed_nsec;
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_guest_tsc_info);
> > > +
> > > +struct xen_domctl_tsc_info {
> > > + GUEST_HANDLE(xen_guest_tsc_info) out_info; /* OUT */
> > > + struct xen_guest_tsc_info info; /* IN */
> > > +};
> > > +
> > > +/* XEN_DOMCTL_gdbsx_guestmemio guest mem io */
> > > +struct xen_domctl_gdbsx_memio {
> > > + /* IN */
> > > + aligned_u64 pgd3val;/* optional: init_mm.pgd[3] value */
> > > + aligned_u64 gva; /* guest virtual address */
> > > + aligned_u64 uva; /* user buffer virtual address */
> > > + uint32_t len; /* number of bytes to read/write */
> > > + uint8_t gwr; /* 0 = read from guest. 1 = write to guest */
> > > + /* OUT */
> > > + uint32_t remain; /* bytes remaining to be copied */
> > > +};
> > > +
> > > +/* XEN_DOMCTL_gdbsx_pausevcpu */
> > > +/* XEN_DOMCTL_gdbsx_unpausevcpu */
> > > +struct xen_domctl_gdbsx_pauseunp_vcpu { /* pause/unpause a vcpu */
> > > + uint32_t vcpu; /* which vcpu */
> > > +};
> > > +
> > > +/* XEN_DOMCTL_gdbsx_domstatus */
> > > +struct xen_domctl_gdbsx_domstatus {
> > > + /* OUT */
> > > + uint8_t paused; /* is the domain paused */
> > > + uint32_t vcpu_id; /* any vcpu in an event? */
> > > + uint32_t vcpu_ev; /* if yes, what event? */
> > > +};
> > > +
> > > +/*
> > > + * Memory event operations
> > > + */
> > > +
> > > +/* XEN_DOMCTL_mem_event_op */
> > > +
> > > +/*
> > > + * Domain memory paging
> > > + * Page memory in and out.
> > > + * Domctl interface to set up and tear down the
> > > + * pager<->hypervisor interface. Use XENMEM_paging_op*
> > > + * to perform per-page operations.
> > > + *
> > > + * The XEN_DOMCTL_MEM_EVENT_OP_PAGING_ENABLE domctl returns several
> > > + * non-standard error codes to indicate why paging could not be enabled:
> > > + * ENODEV - host lacks HAP support (EPT/NPT) or HAP is disabled in guest
> > > + * EMLINK - guest has iommu passthrough enabled
> > > + * EXDEV - guest has PoD enabled
> > > + * EBUSY - guest has or had paging enabled, ring buffer still active
> > > + */
> > > +#define XEN_DOMCTL_MEM_EVENT_OP_PAGING 1
> > > +
> > > +#define XEN_DOMCTL_MEM_EVENT_OP_PAGING_ENABLE 0
> > > +#define XEN_DOMCTL_MEM_EVENT_OP_PAGING_DISABLE 1
> > > +
> > > +/*
> > > + * Access permissions.
> > > + *
> > > + * As with paging, use the domctl for teardown/setup of the
> > > + * helper<->hypervisor interface.
> > > + *
> > > + * There are HVM hypercalls to set the per-page access permissions of
> > > every
> > > + * page in a domain. When one of these permissions--independent, read,
> > > + * write, and execute--is violated, the VCPU is paused and a memory event
> > > + * is sent with what happened. (See public/mem_event.h) .
> > > + *
> > > + * The memory event handler can then resume the VCPU and redo the access
> > > + * with a XENMEM_access_op_resume hypercall.
> > > + *
> > > + * The XEN_DOMCTL_MEM_EVENT_OP_ACCESS_ENABLE domctl returns several
> > > + * non-standard error codes to indicate why access could not be enabled:
> > > + * ENODEV - host lacks HAP support (EPT/NPT) or HAP is disabled in guest
> > > + * EBUSY - guest has or had access enabled, ring buffer still active
> > > + */
> > > +#define XEN_DOMCTL_MEM_EVENT_OP_ACCESS 2
> > > +
> > > +#define XEN_DOMCTL_MEM_EVENT_OP_ACCESS_ENABLE 0
> > > +#define XEN_DOMCTL_MEM_EVENT_OP_ACCESS_DISABLE 1
> > > +
> > > +/*
> > > + * Sharing ENOMEM helper.
> > > + *
> > > + * As with paging, use the domctl for teardown/setup of the
> > > + * helper<->hypervisor interface.
> > > + *
> > > + * If setup, this ring is used to communicate failed allocations
> > > + * in the unshare path. XENMEM_sharing_op_resume is used to wake up
> > > + * vcpus that could not unshare.
> > > + *
> > > + * Note that shring can be turned on (as per the domctl below)
> > > + * *without* this ring being setup.
> > > + */
> > > +#define XEN_DOMCTL_MEM_EVENT_OP_SHARING 3
> > > +
> > > +#define XEN_DOMCTL_MEM_EVENT_OP_SHARING_ENABLE 0
> > > +#define XEN_DOMCTL_MEM_EVENT_OP_SHARING_DISABLE 1
> > > +
> > > +/* Use for teardown/setup of helper<->hypervisor interface for paging,
> > > + * access and sharing.*/
> > > +struct xen_domctl_mem_event_op {
> > > + uint32_t op; /* XEN_DOMCTL_MEM_EVENT_OP_*_* */
> > > + uint32_t mode; /* XEN_DOMCTL_MEM_EVENT_OP_* */
> > > +
> > > + uint32_t port; /* OUT: event channel for ring */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_mem_event_op);
> > > +
> > > +/*
> > > + * Memory sharing operations
> > > + */
> > > +/* XEN_DOMCTL_mem_sharing_op.
> > > + * The CONTROL sub-domctl is used for bringup/teardown. */
> > > +#define XEN_DOMCTL_MEM_SHARING_CONTROL 0
> > > +
> > > +struct xen_domctl_mem_sharing_op {
> > > + uint8_t op; /* XEN_DOMCTL_MEM_SHARING_* */
> > > +
> > > + union {
> > > + uint8_t enable; /* CONTROL */
> > > + } u;
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_mem_sharing_op);
> > > +
> > > +struct xen_domctl_audit_p2m {
> > > + /* OUT error counts */
> > > + uint64_t orphans;
> > > + uint64_t m2p_bad;
> > > + uint64_t p2m_bad;
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_audit_p2m);
> > > +
> > > +struct xen_domctl_set_virq_handler {
> > > + uint32_t virq; /* IN */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_set_virq_handler);
> > > +
> > > +#if defined(__i386__) || defined(__x86_64__)
> > > +/* XEN_DOMCTL_setvcpuextstate */
> > > +/* XEN_DOMCTL_getvcpuextstate */
> > > +struct xen_domctl_vcpuextstate {
> > > + /* IN: VCPU that this call applies to. */
> > > + uint32_t vcpu;
> > > + /*
> > > + * SET: Ignored.
> > > + * GET: xfeature support mask of struct (IN/OUT)
> > > + * xfeature mask is served as identifications of the saving format
> > > + * so that compatible CPUs can have a check on format to decide
> > > + * whether it can restore.
> > > + */
> > > + aligned_u64 xfeature_mask;
> > > + /*
> > > + * SET: Size of struct (IN)
> > > + * GET: Size of struct (IN/OUT)
> > > + */
> > > + aligned_u64 size;
> > > + GUEST_HANDLE(uint64_t) buffer;
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_vcpuextstate);
> > > +#endif
> > > +
> > > +/* XEN_DOMCTL_set_access_required: sets whether a memory event listener
> > > + * must be present to handle page access events: if false, the page
> > > + * access will revert to full permissions if no one is listening;
> > > + * */
> > > +struct xen_domctl_set_access_required {
> > > + uint8_t access_required;
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_set_access_required);
> > > +
> > > +struct xen_domctl_set_broken_page_p2m {
> > > + aligned_u64 pfn;
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_set_broken_page_p2m);
> > > +
> > > +/*
> > > + * XEN_DOMCTL_set_max_evtchn: sets the maximum event channel port
> > > + * number the guest may use. Use this limit the amount of resources
> > > + * (global mapping space, xenheap) a guest may use for event channels.
> > > + */
> > > +struct xen_domctl_set_max_evtchn {
> > > + uint32_t max_port;
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_set_max_evtchn);
> > > +
> > > +/*
> > > + * ARM: Clean and invalidate caches associated with given region of
> > > + * guest memory.
> > > + */
> > > +struct xen_domctl_cacheflush {
> > > + /* IN: page range to flush. */
> > > + xen_pfn_t start_pfn, nr_pfns;
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_cacheflush);
> > > +
> > > +#if defined(__i386__) || defined(__x86_64__)
> > > +struct xen_domctl_vcpu_msr {
> > > + uint32_t index;
> > > + uint32_t reserved;
> > > + aligned_u64 value;
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_vcpu_msr);
> > > +
> > > +/*
> > > + * XEN_DOMCTL_set_vcpu_msrs / XEN_DOMCTL_get_vcpu_msrs.
> > > + *
> > > + * Input:
> > > + * - A NULL 'msrs' guest handle is a request for the maximum 'msr_count'.
> > > + * - Otherwise, 'msr_count' is the number of entries in 'msrs'.
> > > + *
> > > + * Output for get:
> > > + * - If 'msr_count' is less than the number Xen needs to write, -ENOBUFS
> > > shall
> > > + * be returned and 'msr_count' updated to reflect the intended number.
> > > + * - On success, 'msr_count' shall indicate the number of MSRs written,
> > > which
> > > + * may be less than the maximum if some are not currently used by the
> > > vcpu.
> > > + *
> > > + * Output for set:
> > > + * - If Xen encounters an error with a specific MSR, -EINVAL shall be
> > > returned
> > > + * and 'msr_count' shall be set to the offending index, to aid
> > > debugging.
> > > + */
> > > +struct xen_domctl_vcpu_msrs {
> > > + uint32_t vcpu; /* IN */
> > > + uint32_t msr_count; /* IN/OUT */
> > > + GUEST_HANDLE(xen_domctl_vcpu_msr) msrs; /* IN/OUT */
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_vcpu_msrs);
> > > +#endif
> > > +
> > > +/*
> > > + * Return information about the state and running time of a domain.
> > > + * The "domain runstate" is based on the runstates of all the vcpus of
> > > the
> > > + * domain (see below).
> > > + * @extra_arg == pointer to domain_runstate_info structure.
> > > + */
> > > +struct xen_domctl_runstate_info {
> > > + /* VCPU's current state (RUNSTATE_*). */
> > > + uint32_t state;
> > > + uint32_t missed_changes;
> > > + /* Number of times we missed an update due to contention */
> > > + /* When was current state entered (system time, ns)? */
> > > + uint64_t state_entry_time;
> > > + /*
> > > + * Time spent in each RUNSTATE_* (ns). The sum of these times is
> > > + * NOT guaranteed not to drift from system time.
> > > + */
> > > + uint64_t time[6];
> > > +};
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_runstate_info);
> > > +
> > > +/* All vcpus are running */
> > > +#define DOMAIN_RUNSTATE_full_run 0
> > > +
> > > +/* All vcpus are runnable (i.e., waiting for cpu) */
> > > +#define DOMAIN_RUNSTATE_full_contention 1
> > > +
> > > +/* Some vcpus are running, some are runnable */
> > > +#define DOMAIN_RUNSTATE_concurrency_hazard 2
> > > +
> > > +/* All vcpus are blocked / offline */
> > > +#define DOMAIN_RUNSTATE_blocked 3
> > > +
> > > +/* Some vpcus are running, some are blocked */
> > > +#define DOMAIN_RUNSTATE_partial_run 4
> > > +
> > > +/* Some vcpus are runnable, some are blocked */
> > > +#define DOMAIN_RUNSTATE_partial_contention 5
> > > +
> > > +struct xen_domctl_corespersocket {
> > > + uint32_t cores_per_socket;
> > > +};
> > > +
> > > +DEFINE_GUEST_HANDLE_STRUCT(xen_domctl_corespersocket);
> > > +#endif
> > > +
> > > +struct xen_domctl {
> > > + uint32_t cmd;
> > > +#define XEN_DOMCTL_createdomain 1
> > > +#define XEN_DOMCTL_destroydomain 2
> > > +#define XEN_DOMCTL_pausedomain 3
> > > +#define XEN_DOMCTL_unpausedomain 4
> > > +#define XEN_DOMCTL_getdomaininfo 5
> > > +#define XEN_DOMCTL_getmemlist 6
> > > +#define XEN_DOMCTL_getpageframeinfo 7
> > > +#define XEN_DOMCTL_getpageframeinfo2 8
> > > +#define XEN_DOMCTL_setvcpuaffinity 9
> > > +#define XEN_DOMCTL_shadow_op 10
> > > +#define XEN_DOMCTL_max_mem 11
> > > +#define XEN_DOMCTL_setvcpucontext 12
> > > +#define XEN_DOMCTL_getvcpucontext 13
> > > +#define XEN_DOMCTL_getvcpuinfo 14
> > > +#define XEN_DOMCTL_max_vcpus 15
> > > +#define XEN_DOMCTL_scheduler_op 16
> > > +#define XEN_DOMCTL_setdomainhandle 17
> > > +#define XEN_DOMCTL_setdebugging 18
> > > +#define XEN_DOMCTL_irq_permission 19
> > > +#define XEN_DOMCTL_iomem_permission 20
> > > +#define XEN_DOMCTL_ioport_permission 21
> > > +#define XEN_DOMCTL_hypercall_init 22
> > > +#define XEN_DOMCTL_arch_setup 23
> > > +#define XEN_DOMCTL_settimeoffset 24
> > > +#define XEN_DOMCTL_getvcpuaffinity 25
> > > +#define XEN_DOMCTL_real_mode_area 26
> > > +#define XEN_DOMCTL_resumedomain 27
> > > +#define XEN_DOMCTL_sendtrigger 28
> > > +#define XEN_DOMCTL_subscribe 29
> > > +#define XEN_DOMCTL_gethvmcontext 33
> > > +#define XEN_DOMCTL_sethvmcontext 34
> > > +#define XEN_DOMCTL_set_address_size 35
> > > +#define XEN_DOMCTL_get_address_size 36
> > > +#define XEN_DOMCTL_assign_device 37
> > > +#define XEN_DOMCTL_bind_pt_irq 38
> > > +#define XEN_DOMCTL_memory_mapping 39
> > > +#define XEN_DOMCTL_ioport_mapping 40
> > > +#define XEN_DOMCTL_pin_mem_cacheattr 41
> > > +#define XEN_DOMCTL_set_ext_vcpucontext 42
> > > +#define XEN_DOMCTL_get_ext_vcpucontext 43
> > > +#define XEN_DOMCTL_set_opt_feature 44 /* Obsolete IA64
> > > only */
> > > +#define XEN_DOMCTL_test_assign_device 45
> > > +#define XEN_DOMCTL_set_target 46
> > > +#define XEN_DOMCTL_deassign_device 47
> > > +#define XEN_DOMCTL_unbind_pt_irq 48
> > > +#define XEN_DOMCTL_set_cpuid 49
> > > +#define XEN_DOMCTL_get_device_group 50
> > > +#define XEN_DOMCTL_set_machine_address_size 51
> > > +#define XEN_DOMCTL_get_machine_address_size 52
> > > +#define XEN_DOMCTL_suppress_spurious_page_faults 53
> > > +#define XEN_DOMCTL_debug_op 54
> > > +#define XEN_DOMCTL_gethvmcontext_partial 55
> > > +#define XEN_DOMCTL_mem_event_op 56
> > > +#define XEN_DOMCTL_mem_sharing_op 57
> > > +#define XEN_DOMCTL_disable_migrate 58
> > > +#define XEN_DOMCTL_gettscinfo 59
> > > +#define XEN_DOMCTL_settscinfo 60
> > > +#define XEN_DOMCTL_getpageframeinfo3 61
> > > +#define XEN_DOMCTL_setvcpuextstate 62
> > > +#define XEN_DOMCTL_getvcpuextstate 63
> > > +#define XEN_DOMCTL_set_access_required 64
> > > +#define XEN_DOMCTL_audit_p2m 65
> > > +#define XEN_DOMCTL_set_virq_handler 66
> > > +#define XEN_DOMCTL_set_broken_page_p2m 67
> > > +#define XEN_DOMCTL_setnodeaffinity 68
> > > +#define XEN_DOMCTL_getnodeaffinity 69
> > > +#define XEN_DOMCTL_set_max_evtchn 70
> > > +#define XEN_DOMCTL_cacheflush 71
> > > +#define XEN_DOMCTL_get_vcpu_msrs 72
> > > +#define XEN_DOMCTL_set_vcpu_msrs 73
> > > +#define XEN_DOMCTL_get_runstate_info 98
> > > +#define XEN_DOMCTL_gdbsx_guestmemio 1000
> > > +#define XEN_DOMCTL_gdbsx_pausevcpu 1001
> > > +#define XEN_DOMCTL_gdbsx_unpausevcpu 1002
> > > +#define XEN_DOMCTL_gdbsx_domstatus 1003
> > > +#define XEN_DOMCTL_setcorespersocket 4001
> > > + uint32_t interface_version; /* XEN_DOMCTL_INTERFACE_VERSION */
> > > + domid_t domain;
> > > + union {
> > > + struct xen_domctl_createdomain createdomain;
> > > + struct xen_domctl_getdomaininfo getdomaininfo;
> > > + struct xen_domctl_getmemlist getmemlist;
> > > + struct xen_domctl_getpageframeinfo getpageframeinfo;
> > > + struct xen_domctl_getpageframeinfo2 getpageframeinfo2;
> > > + struct xen_domctl_getpageframeinfo3 getpageframeinfo3;
> > > +#if 0
> > > + struct xen_domctl_nodeaffinity nodeaffinity;
> > > + struct xen_domctl_vcpuaffinity vcpuaffinity;
> > > +#endif
> > > + struct xen_domctl_shadow_op shadow_op;
> > > + struct xen_domctl_max_mem max_mem;
> > > + struct xen_domctl_vcpucontext vcpucontext;
> > > + struct xen_domctl_getvcpuinfo getvcpuinfo;
> > > + struct xen_domctl_max_vcpus max_vcpus;
> > > + struct xen_domctl_scheduler_op scheduler_op;
> > > + struct xen_domctl_setdomainhandle setdomainhandle;
> > > + struct xen_domctl_setdebugging setdebugging;
> > > + struct xen_domctl_irq_permission irq_permission;
> > > + struct xen_domctl_iomem_permission iomem_permission;
> > > + struct xen_domctl_ioport_permission ioport_permission;
> > > + struct xen_domctl_hypercall_init hypercall_init;
> > > + struct xen_domctl_arch_setup arch_setup;
> > > + struct xen_domctl_settimeoffset settimeoffset;
> > > + struct xen_domctl_disable_migrate disable_migrate;
> > > + struct xen_domctl_tsc_info tsc_info;
> > > + struct xen_domctl_real_mode_area real_mode_area;
> > > + struct xen_domctl_hvmcontext hvmcontext;
> > > + struct xen_domctl_hvmcontext_partial hvmcontext_partial;
> > > + struct xen_domctl_address_size address_size;
> > > + struct xen_domctl_sendtrigger sendtrigger;
> > > + struct xen_domctl_get_device_group get_device_group;
> > > + struct xen_domctl_assign_device assign_device;
> > > + struct xen_domctl_bind_pt_irq bind_pt_irq;
> > > + struct xen_domctl_memory_mapping memory_mapping;
> > > + struct xen_domctl_ioport_mapping ioport_mapping;
> > > + struct xen_domctl_pin_mem_cacheattr pin_mem_cacheattr;
> > > +#if 0
> > > + struct xen_domctl_ext_vcpucontext ext_vcpucontext;
> > > +#endif
> > > + struct xen_domctl_set_target set_target;
> > > + struct xen_domctl_subscribe subscribe;
> > > + struct xen_domctl_debug_op debug_op;
> > > + struct xen_domctl_mem_event_op mem_event_op;
> > > + struct xen_domctl_mem_sharing_op mem_sharing_op;
> > > +#if defined(__i386__) || defined(__x86_64__)
> > > + struct xen_domctl_cpuid cpuid;
> > > + struct xen_domctl_vcpuextstate vcpuextstate;
> > > + struct xen_domctl_vcpu_msrs vcpu_msrs;
> > > +#endif
> > > + struct xen_domctl_set_access_required access_required;
> > > + struct xen_domctl_audit_p2m audit_p2m;
> > > + struct xen_domctl_set_virq_handler set_virq_handler;
> > > + struct xen_domctl_set_max_evtchn set_max_evtchn;
> > > + struct xen_domctl_runstate_info domain_runstate;
> > > + struct xen_domctl_corespersocket corespersocket;
> > > + struct xen_domctl_gdbsx_memio gdbsx_guest_memio;
> > > + struct xen_domctl_set_broken_page_p2m set_broken_page_p2m;
> > > + struct xen_domctl_cacheflush cacheflush;
> > > + struct xen_domctl_gdbsx_pauseunp_vcpu gdbsx_pauseunp_vcpu;
> > > + struct xen_domctl_gdbsx_domstatus gdbsx_domstatus;
> > > + uint8_t pad[128];
> > > + } u __aligned(8);
> > > +};
> > > +
> > > +#endif /* __XEN_PUBLIC_DOMCTL_H__ */
> > > +
> > > +/*
> > > + * Local variables:
> > > + * mode: C
> > > + * c-file-style: "BSD"
> > > + * c-basic-offset: 4
> > > + * tab-width: 4
> > > + * indent-tabs-mode: nil
> > > + * End:
> > > + */
> > > diff --git a/include/xen/interface/hvm/hvm_op.h
> > > b/include/xen/interface/hvm/hvm_op.h
> > > index 956a046..5fb5260 100644
> > > --- a/include/xen/interface/hvm/hvm_op.h
> > > +++ b/include/xen/interface/hvm/hvm_op.h
> > > @@ -32,6 +32,72 @@ struct xen_hvm_param {
> > > };
> > > DEFINE_GUEST_HANDLE_STRUCT(xen_hvm_param);
> > >
> > > +#define HVMOP_set_pci_intx_level 2
> > > +struct xen_hvm_set_pci_intx_level {
> > > + /* Domain to be updated. */
> > > + domid_t domid;
> > > + /* PCI INTx identification in PCI topology (domain:bus:device:intx). */
> > > + uint8_t domain, bus, device, intx;
> > > + /* Assertion level (0 = unasserted, 1 = asserted). */
> > > + uint8_t level;
> > > +};
> > > +
> > > +#define HVMOP_set_isa_irq_level 3
> > > +struct xen_hvm_set_isa_irq_level {
> > > + /* Domain to be updated. */
> > > + domid_t domid;
> > > + /* ISA device identification, by ISA IRQ (0-15). */
> > > + uint8_t isa_irq;
> > > + /* Assertion level (0 = unasserted, 1 = asserted). */
> > > + uint8_t level;
> > > +};
> > > +
> > > +#define HVMOP_set_pci_link_route 4
> > > +struct xen_hvm_set_pci_link_route {
> > > + /* Domain to be updated. */
> > > + domid_t domid;
> > > + /* PCI link identifier (0-3). */
> > > + uint8_t link;
> > > + /* ISA IRQ (1-15), or 0 (disable link). */
> > > + uint8_t isa_irq;
> > > +};
> > > +
> > > +#define HVMOP_track_dirty_vram 6
> > > +struct xen_hvm_track_dirty_vram {
> > > + /* Domain to be tracked. */
> > > + domid_t domid;
> > > + /* First pfn to track. */
> > > + aligned_u64 first_pfn;
> > > + /* Number of pages to track. */
> > > + aligned_u64 nr;
> > > + /* OUT variable. */
> > > + /* Dirty bitmap buffer. */
> > > + aligned_u64 dirty_bitmap;
> > > +};
> > > +
> > > +#define HVMOP_modified_memory 7
> > > +struct xen_hvm_modified_memory {
> > > + /* Domain to be updated. */
> > > + domid_t domid;
> > > + /* First pfn. */
> > > + aligned_u64 first_pfn;
> > > + /* Number of pages. */
> > > + aligned_u64 nr;
> > > +};
> > > +
> > > +#define HVMOP_set_mem_type 8
> > > +/* Notify that a region of memory is to be treated in a specific way. */
> > > +struct xen_hvm_set_mem_type {
> > > + /* Domain to be updated. */
> > > + domid_t domid;
> > > + /* Memory type */
> > > + uint16_t hvmmem_type;
> > > + /* Number of pages. */
> > > + uint32_t nr;
> > > + /* First pfn. */
> > > + aligned_u64 first_pfn;
> > > +};
> > > +
> > > /* Hint from PV drivers for pagetable destruction. */
> > > #define HVMOP_pagetable_dying 9
> > > struct xen_hvm_pagetable_dying {
> > > diff --git a/include/xen/interface/memory.h
> > > b/include/xen/interface/memory.h
> > > index 2ecfe4f..a5fd2e6 100644
> > > --- a/include/xen/interface/memory.h
> > > +++ b/include/xen/interface/memory.h
> > > @@ -248,6 +248,14 @@ DEFINE_GUEST_HANDLE_STRUCT(xen_memory_map);
> > > */
> > > extern spinlock_t xen_reservation_lock;
> > >
> > > +#define XENMEM_set_memory_map 13
> > > +struct xen_foreign_memory_map {
> > > + domid_t domid;
> > > + struct xen_memory_map map;
> > > +};
> > > +
> > > +#define XENMEM_maximum_gpfn 14
> > > +
> > > /*
> > > * Unmaps the page appearing at a particular GPFN from the specified
> > > guest's
> > > * pseudophysical address space.
> > > diff --git a/include/xen/interface/xen.h b/include/xen/interface/xen.h
> > > index de08213..075cb6f 100644
> > > --- a/include/xen/interface/xen.h
> > > +++ b/include/xen/interface/xen.h
> > > @@ -57,6 +57,7 @@
> > > #define __HYPERVISOR_event_channel_op 32
> > > #define __HYPERVISOR_physdev_op 33
> > > #define __HYPERVISOR_hvm_op 34
> > > +#define __HYPERVISOR_domctl 36
> > > #define __HYPERVISOR_tmem_op 38
> > >
> > > /* Architecture-specific hypercall definitions. */
> > > --
> > > 1.9.1
> > >
> > >
>
>
_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxx
http://lists.xen.org/xen-devel
|
 |
Lists.xenproject.org is hosted with RackSpace, monitoring our |