int xc_numainfo(xc_interface *xch, unsigned *max_nodes,
xc_meminfo_t *meminfo, uint32_t *distance)
{
int ret;
DECLARE_SYSCTL;
DECLARE_HYPERCALL_BOUNCE(meminfo, *max_nodes * sizeof(*meminfo),
XC_HYPERCALL_BUFFER_BOUNCE_OUT);
DECLARE_HYPERCALL_BOUNCE(distance,
*max_nodes * *max_nodes * sizeof(*distance),
XC_HYPERCALL_BUFFER_BOUNCE_OUT);
if ( (ret = xc_hypercall_bounce_pre(xch, meminfo)) )
goto out;
if ((ret = xc_hypercall_bounce_pre(xch, distance)) )
goto out;
sysctl.u.numainfo.num_nodes = *max_nodes;
set_xen_guest_handle(sysctl.u.numainfo.meminfo, meminfo);
set_xen_guest_handle(sysctl.u.numainfo.distance, distance);
sysctl.cmd = XEN_SYSCTL_numainfo;
if ( (ret = do_sysctl(xch, &sysctl)) != 0 )
goto out;
*max_nodes = sysctl.u.numainfo.num_nodes;
out:
xc_hypercall_bounce_post(xch, meminfo);
xc_hypercall_bounce_post(xch, distance);
return ret;
}
int xc_pm_get_cxstat(xc_interface *xch, int cpuid, struct xc_cx_stat *cxpt)
{
DECLARE_SYSCTL;
DECLARE_NAMED_HYPERCALL_BOUNCE(triggers, cxpt->triggers,
cxpt->nr * sizeof(*cxpt->triggers),
XC_HYPERCALL_BUFFER_BOUNCE_OUT);
DECLARE_NAMED_HYPERCALL_BOUNCE(residencies, cxpt->residencies,
cxpt->nr * sizeof(*cxpt->residencies),
XC_HYPERCALL_BUFFER_BOUNCE_OUT);
DECLARE_NAMED_HYPERCALL_BOUNCE(pc, cxpt->pc,
cxpt->nr_pc * sizeof(*cxpt->pc),
XC_HYPERCALL_BUFFER_BOUNCE_OUT);
DECLARE_NAMED_HYPERCALL_BOUNCE(cc, cxpt->cc,
cxpt->nr_cc * sizeof(*cxpt->cc),
XC_HYPERCALL_BUFFER_BOUNCE_OUT);
int ret = -1;
if ( xc_hypercall_bounce_pre(xch, triggers) )
goto unlock_0;
if ( xc_hypercall_bounce_pre(xch, residencies) )
goto unlock_1;
if ( xc_hypercall_bounce_pre(xch, pc) )
goto unlock_2;
if ( xc_hypercall_bounce_pre(xch, cc) )
goto unlock_3;
sysctl.cmd = XEN_SYSCTL_get_pmstat;
sysctl.u.get_pmstat.type = PMSTAT_get_cxstat;
sysctl.u.get_pmstat.cpuid = cpuid;
sysctl.u.get_pmstat.u.getcx.nr = cxpt->nr;
sysctl.u.get_pmstat.u.getcx.nr_pc = cxpt->nr_pc;
sysctl.u.get_pmstat.u.getcx.nr_cc = cxpt->nr_cc;
set_xen_guest_handle(sysctl.u.get_pmstat.u.getcx.triggers, triggers);
set_xen_guest_handle(sysctl.u.get_pmstat.u.getcx.residencies, residencies);
set_xen_guest_handle(sysctl.u.get_pmstat.u.getcx.pc, pc);
set_xen_guest_handle(sysctl.u.get_pmstat.u.getcx.cc, cc);
if ( (ret = xc_sysctl(xch, &sysctl)) )
goto unlock_4;
cxpt->nr = sysctl.u.get_pmstat.u.getcx.nr;
cxpt->last = sysctl.u.get_pmstat.u.getcx.last;
cxpt->idle_time = sysctl.u.get_pmstat.u.getcx.idle_time;
cxpt->nr_pc = sysctl.u.get_pmstat.u.getcx.nr_pc;
cxpt->nr_cc = sysctl.u.get_pmstat.u.getcx.nr_cc;
unlock_4:
xc_hypercall_bounce_post(xch, cc);
unlock_3:
xc_hypercall_bounce_post(xch, pc);
unlock_2:
xc_hypercall_bounce_post(xch, residencies);
unlock_1:
xc_hypercall_bounce_post(xch, triggers);
unlock_0:
return ret;
}
int xc_pm_get_pxstat(xc_interface *xch, int cpuid, struct xc_px_stat *pxpt)
{
DECLARE_SYSCTL;
/* Sizes unknown until xc_pm_get_max_px */
DECLARE_NAMED_HYPERCALL_BOUNCE(trans, pxpt->trans_pt, 0, XC_HYPERCALL_BUFFER_BOUNCE_BOTH);
DECLARE_NAMED_HYPERCALL_BOUNCE(pt, pxpt->pt, 0, XC_HYPERCALL_BUFFER_BOUNCE_BOTH);
int max_px, ret;
if ( !pxpt->trans_pt || !pxpt->pt )
{
errno = EINVAL;
return -1;
}
if ( (ret = xc_pm_get_max_px(xch, cpuid, &max_px)) != 0)
return ret;
HYPERCALL_BOUNCE_SET_SIZE(trans, max_px * max_px * sizeof(uint64_t));
HYPERCALL_BOUNCE_SET_SIZE(pt, max_px * sizeof(struct xc_px_val));
if ( xc_hypercall_bounce_pre(xch, trans) )
return ret;
if ( xc_hypercall_bounce_pre(xch, pt) )
{
xc_hypercall_bounce_post(xch, trans);
return ret;
}
sysctl.cmd = XEN_SYSCTL_get_pmstat;
sysctl.u.get_pmstat.type = PMSTAT_get_pxstat;
sysctl.u.get_pmstat.cpuid = cpuid;
sysctl.u.get_pmstat.u.getpx.total = max_px;
set_xen_guest_handle(sysctl.u.get_pmstat.u.getpx.trans_pt, trans);
set_xen_guest_handle(sysctl.u.get_pmstat.u.getpx.pt, pt);
ret = xc_sysctl(xch, &sysctl);
if ( ret )
{
xc_hypercall_bounce_post(xch, trans);
xc_hypercall_bounce_post(xch, pt);
return ret;
}
pxpt->total = sysctl.u.get_pmstat.u.getpx.total;
pxpt->usable = sysctl.u.get_pmstat.u.getpx.usable;
pxpt->last = sysctl.u.get_pmstat.u.getpx.last;
pxpt->cur = sysctl.u.get_pmstat.u.getpx.cur;
xc_hypercall_bounce_post(xch, trans);
xc_hypercall_bounce_post(xch, pt);
return ret;
}
int xc_livepatch_upload(xc_interface *xch,
char *name,
unsigned char *payload,
uint32_t size)
{
int rc;
DECLARE_SYSCTL;
DECLARE_HYPERCALL_BUFFER(char, local);
DECLARE_HYPERCALL_BOUNCE(name, 0 /* later */, XC_HYPERCALL_BUFFER_BOUNCE_IN);
xen_livepatch_name_t def_name = { .pad = { 0, 0, 0 } };
if ( !name || !payload )
{
errno = EINVAL;
return -1;
}
def_name.size = strlen(name) + 1;
if ( def_name.size > XEN_LIVEPATCH_NAME_SIZE )
{
errno = EINVAL;
return -1;
}
HYPERCALL_BOUNCE_SET_SIZE(name, def_name.size);
if ( xc_hypercall_bounce_pre(xch, name) )
return -1;
local = xc_hypercall_buffer_alloc(xch, local, size);
if ( !local )
{
xc_hypercall_bounce_post(xch, name);
return -1;
}
memcpy(local, payload, size);
sysctl.cmd = XEN_SYSCTL_livepatch_op;
sysctl.u.livepatch.cmd = XEN_SYSCTL_LIVEPATCH_UPLOAD;
sysctl.u.livepatch.pad = 0;
sysctl.u.livepatch.u.upload.size = size;
set_xen_guest_handle(sysctl.u.livepatch.u.upload.payload, local);
sysctl.u.livepatch.u.upload.name = def_name;
set_xen_guest_handle(sysctl.u.livepatch.u.upload.name.name, name);
rc = do_sysctl(xch, &sysctl);
xc_hypercall_buffer_free(xch, local);
xc_hypercall_bounce_post(xch, name);
return rc;
}
int xc_machphys_mfn_list(xc_interface *xch,
unsigned long max_extents,
xen_pfn_t *extent_start)
{
int rc;
DECLARE_HYPERCALL_BOUNCE(extent_start, max_extents * sizeof(xen_pfn_t), XC_HYPERCALL_BUFFER_BOUNCE_OUT);
struct xen_machphys_mfn_list xmml = {
.max_extents = max_extents,
};
if ( xc_hypercall_bounce_pre(xch, extent_start) )
{
PERROR("Could not bounce memory for XENMEM_machphys_mfn_list hypercall");
return -1;
}
set_xen_guest_handle(xmml.extent_start, extent_start);
rc = do_memory_op(xch, XENMEM_machphys_mfn_list, &xmml, sizeof(xmml));
if (rc || xmml.nr_extents != max_extents)
rc = -1;
else
rc = 0;
xc_hypercall_bounce_post(xch, extent_start);
return rc;
}
static int flush_mmu_updates(xc_interface *xch, struct xc_mmu *mmu)
{
int rc, err = 0;
DECLARE_NAMED_HYPERCALL_BOUNCE(updates, mmu->updates, mmu->idx*sizeof(*mmu->updates), XC_HYPERCALL_BUFFER_BOUNCE_BOTH);
if ( mmu->idx == 0 )
return 0;
if ( xc_hypercall_bounce_pre(xch, updates) )
{
PERROR("flush_mmu_updates: bounce buffer failed");
err = 1;
goto out;
}
rc = xencall4(xch->xcall, __HYPERVISOR_mmu_update,
HYPERCALL_BUFFER_AS_ARG(updates),
mmu->idx, 0, mmu->subject);
if ( rc < 0 )
{
ERROR("Failure when submitting mmu updates");
err = 1;
}
mmu->idx = 0;
xc_hypercall_bounce_post(xch, updates);
out:
return err;
}
int xc_sched_rtds_vcpu_get(xc_interface *xch,
uint32_t domid,
xen_domctl_schedparam_vcpu_t *vcpus,
uint32_t num_vcpus)
{
int rc;
DECLARE_DOMCTL;
DECLARE_HYPERCALL_BOUNCE(vcpus, sizeof(*vcpus) * num_vcpus,
XC_HYPERCALL_BUFFER_BOUNCE_BOTH);
if ( xc_hypercall_bounce_pre(xch, vcpus) )
return -1;
domctl.cmd = XEN_DOMCTL_scheduler_op;
domctl.domain = (domid_t) domid;
domctl.u.scheduler_op.sched_id = XEN_SCHEDULER_RTDS;
domctl.u.scheduler_op.cmd = XEN_DOMCTL_SCHEDOP_getvcpuinfo;
domctl.u.scheduler_op.u.v.nr_vcpus = num_vcpus;
set_xen_guest_handle(domctl.u.scheduler_op.u.v.vcpus, vcpus);
rc = do_domctl(xch, &domctl);
xc_hypercall_bounce_post(xch, vcpus);
return rc;
}
int xc_get_pfn_list(xc_interface *xch,
uint32_t domid,
uint64_t *pfn_buf,
unsigned long max_pfns)
{
DECLARE_DOMCTL;
DECLARE_HYPERCALL_BOUNCE(pfn_buf, max_pfns * sizeof(*pfn_buf), XC_HYPERCALL_BUFFER_BOUNCE_OUT);
int ret;
#ifdef VALGRIND
memset(pfn_buf, 0, max_pfns * sizeof(*pfn_buf));
#endif
if ( xc_hypercall_bounce_pre(xch, pfn_buf) )
{
PERROR("xc_get_pfn_list: pfn_buf bounce failed");
return -1;
}
domctl.cmd = XEN_DOMCTL_getmemlist;
domctl.domain = (domid_t)domid;
domctl.u.getmemlist.max_pfns = max_pfns;
set_xen_guest_handle(domctl.u.getmemlist.buffer, pfn_buf);
ret = do_domctl(xch, &domctl);
xc_hypercall_bounce_post(xch, pfn_buf);
return (ret < 0) ? -1 : domctl.u.getmemlist.num_pfns;
}
int xc_flask_op(xc_interface *xch, xen_flask_op_t *op)
{
int ret = -1;
DECLARE_HYPERCALL;
DECLARE_HYPERCALL_BOUNCE(op, sizeof(*op), XC_HYPERCALL_BUFFER_BOUNCE_BOTH);
op->interface_version = XEN_FLASK_INTERFACE_VERSION;
if ( xc_hypercall_bounce_pre(xch, op) )
{
PERROR("Could not bounce memory for flask op hypercall");
goto out;
}
hypercall.op = __HYPERVISOR_xsm_op;
hypercall.arg[0] = HYPERCALL_BUFFER_AS_ARG(op);
if ( (ret = do_xen_hypercall(xch, &hypercall)) < 0 )
{
if ( errno == EACCES )
fprintf(stderr, "XSM operation failed!\n");
}
xc_hypercall_bounce_post(xch, op);
out:
return ret;
}
int xc_domain_populate_physmap(xc_interface *xch,
uint32_t domid,
unsigned long nr_extents,
unsigned int extent_order,
unsigned int mem_flags,
xen_pfn_t *extent_start)
{
int err;
DECLARE_HYPERCALL_BOUNCE(extent_start, nr_extents * sizeof(*extent_start), XC_HYPERCALL_BUFFER_BOUNCE_BOTH);
struct xen_memory_reservation reservation = {
.nr_extents = nr_extents,
.extent_order = extent_order,
.mem_flags = mem_flags,
.domid = domid
};
if ( xc_hypercall_bounce_pre(xch, extent_start) )
{
PERROR("Could not bounce memory for XENMEM_populate_physmap hypercall");
return -1;
}
set_xen_guest_handle(reservation.extent_start, extent_start);
err = do_memory_op(xch, XENMEM_populate_physmap, &reservation, sizeof(reservation));
xc_hypercall_bounce_post(xch, extent_start);
return err;
}
int xc_domain_getinfolist(xc_interface *xch,
uint32_t first_domain,
unsigned int max_domains,
xc_domaininfo_t *info)
{
int ret = 0;
DECLARE_SYSCTL;
DECLARE_HYPERCALL_BOUNCE(info, max_domains*sizeof(*info), XC_HYPERCALL_BUFFER_BOUNCE_OUT);
if ( xc_hypercall_bounce_pre(xch, info) )
return -1;
sysctl.cmd = XEN_SYSCTL_getdomaininfolist;
sysctl.u.getdomaininfolist.first_domain = first_domain;
sysctl.u.getdomaininfolist.max_domains = max_domains;
set_xen_guest_handle(sysctl.u.getdomaininfolist.buffer, info);
if ( xc_sysctl(xch, &sysctl) < 0 )
ret = -1;
else
ret = sysctl.u.getdomaininfolist.num_domains;
xc_hypercall_bounce_post(xch, info);
return ret;
}
int xc_hvm_track_dirty_vram(
xc_interface *xch, domid_t dom,
uint64_t first_pfn, uint64_t nr,
unsigned long *dirty_bitmap)
{
DECLARE_HYPERCALL_BOUNCE(dirty_bitmap, (nr+7) / 8, XC_HYPERCALL_BUFFER_BOUNCE_OUT);
DECLARE_HYPERCALL_BUFFER(struct xen_hvm_track_dirty_vram, arg);
int rc;
arg = xc_hypercall_buffer_alloc(xch, arg, sizeof(*arg));
if ( arg == NULL || xc_hypercall_bounce_pre(xch, dirty_bitmap) )
{
PERROR("Could not bounce memory for xc_hvm_track_dirty_vram hypercall");
rc = -1;
goto out;
}
arg->domid = dom;
arg->first_pfn = first_pfn;
arg->nr = nr;
set_xen_guest_handle(arg->dirty_bitmap, dirty_bitmap);
rc = xencall2(xch->xcall, __HYPERVISOR_hvm_op,
HVMOP_track_dirty_vram,
HYPERCALL_BUFFER_AS_ARG(arg));
out:
xc_hypercall_buffer_free(xch, arg);
xc_hypercall_bounce_post(xch, dirty_bitmap);
return rc;
}
int xc_domain_decrease_reservation(xc_interface *xch,
uint32_t domid,
unsigned long nr_extents,
unsigned int extent_order,
xen_pfn_t *extent_start)
{
int err;
DECLARE_HYPERCALL_BOUNCE(extent_start, nr_extents * sizeof(*extent_start), XC_HYPERCALL_BUFFER_BOUNCE_BOTH);
struct xen_memory_reservation reservation = {
.nr_extents = nr_extents,
.extent_order = extent_order,
.mem_flags = 0,
.domid = domid
};
if ( extent_start == NULL )
{
DPRINTF("decrease_reservation extent_start is NULL!\n");
errno = EINVAL;
return -1;
}
if ( xc_hypercall_bounce_pre(xch, extent_start) )
{
PERROR("Could not bounce memory for XENMEM_decrease_reservation hypercall");
return -1;
}
set_xen_guest_handle(reservation.extent_start, extent_start);
err = do_memory_op(xch, XENMEM_decrease_reservation, &reservation, sizeof(reservation));
xc_hypercall_bounce_post(xch, extent_start);
return err;
}
int xc_domain_decrease_reservation_exact(xc_interface *xch,
uint32_t domid,
unsigned long nr_extents,
unsigned int extent_order,
xen_pfn_t *extent_start)
{
int err;
err = xc_domain_decrease_reservation(xch, domid, nr_extents,
extent_order, extent_start);
if ( err == nr_extents )
return 0;
if ( err >= 0 )
{
DPRINTF("Failed deallocation for dom %d: %ld extents of order %d\n",
domid, nr_extents, extent_order);
errno = EINVAL;
err = -1;
}
return err;
}
/* Get just one element of the HVM guest context.
* size must be >= HVM_SAVE_LENGTH(type) */
int xc_domain_hvm_getcontext_partial(xc_interface *xch,
uint32_t domid,
uint16_t typecode,
uint16_t instance,
void *ctxt_buf,
uint32_t size)
{
int ret;
DECLARE_DOMCTL;
DECLARE_HYPERCALL_BOUNCE(ctxt_buf, size, XC_HYPERCALL_BUFFER_BOUNCE_OUT);
if ( !ctxt_buf || xc_hypercall_bounce_pre(xch, ctxt_buf) )
return -1;
domctl.cmd = XEN_DOMCTL_gethvmcontext_partial;
domctl.domain = (domid_t) domid;
domctl.u.hvmcontext_partial.type = typecode;
domctl.u.hvmcontext_partial.instance = instance;
set_xen_guest_handle(domctl.u.hvmcontext_partial.buffer, ctxt_buf);
ret = do_domctl(xch, &domctl);
if ( ctxt_buf )
xc_hypercall_bounce_post(xch, ctxt_buf);
return ret ? -1 : 0;
}
int xc_readconsolering(xc_interface *xch,
char *buffer,
unsigned int *pnr_chars,
int clear, int incremental, uint32_t *pindex)
{
int ret;
unsigned int nr_chars = *pnr_chars;
DECLARE_SYSCTL;
DECLARE_HYPERCALL_BOUNCE(buffer, nr_chars, XC_HYPERCALL_BUFFER_BOUNCE_OUT);
if ( xc_hypercall_bounce_pre(xch, buffer) )
return -1;
sysctl.cmd = XEN_SYSCTL_readconsole;
set_xen_guest_handle(sysctl.u.readconsole.buffer, buffer);
sysctl.u.readconsole.count = nr_chars;
sysctl.u.readconsole.clear = clear;
sysctl.u.readconsole.incremental = 0;
if ( pindex )
{
sysctl.u.readconsole.index = *pindex;
sysctl.u.readconsole.incremental = incremental;
}
if ( (ret = do_sysctl(xch, &sysctl)) == 0 )
{
*pnr_chars = sysctl.u.readconsole.count;
if ( pindex )
*pindex = sysctl.u.readconsole.index;
}
xc_hypercall_bounce_post(xch, buffer);
return ret;
}
int xc_cputopoinfo(xc_interface *xch, unsigned *max_cpus,
xc_cputopo_t *cputopo)
{
int ret;
DECLARE_SYSCTL;
DECLARE_HYPERCALL_BOUNCE(cputopo, *max_cpus * sizeof(*cputopo),
XC_HYPERCALL_BUFFER_BOUNCE_OUT);
if ( (ret = xc_hypercall_bounce_pre(xch, cputopo)) )
goto out;
sysctl.u.cputopoinfo.num_cpus = *max_cpus;
set_xen_guest_handle(sysctl.u.cputopoinfo.cputopo, cputopo);
sysctl.cmd = XEN_SYSCTL_cputopoinfo;
if ( (ret = do_sysctl(xch, &sysctl)) != 0 )
goto out;
*max_cpus = sysctl.u.cputopoinfo.num_cpus;
out:
xc_hypercall_bounce_post(xch, cputopo);
return ret;
}
static int flush_mmu_updates(xc_interface *xch, struct xc_mmu *mmu)
{
int err = 0;
DECLARE_HYPERCALL;
DECLARE_NAMED_HYPERCALL_BOUNCE(updates, mmu->updates, mmu->idx*sizeof(*mmu->updates), XC_HYPERCALL_BUFFER_BOUNCE_BOTH);
if ( mmu->idx == 0 )
return 0;
if ( xc_hypercall_bounce_pre(xch, updates) )
{
PERROR("flush_mmu_updates: bounce buffer failed");
err = 1;
goto out;
}
hypercall.op = __HYPERVISOR_mmu_update;
hypercall.arg[0] = HYPERCALL_BUFFER_AS_ARG(updates);
hypercall.arg[1] = (unsigned long)mmu->idx;
hypercall.arg[2] = 0;
hypercall.arg[3] = mmu->subject;
if ( do_xen_hypercall(xch, &hypercall) < 0 )
{
ERROR("Failure when submitting mmu updates");
err = 1;
}
mmu->idx = 0;
xc_hypercall_bounce_post(xch, updates);
out:
return err;
}
int xc_flask_context_to_sid(xc_interface *xch, char *buf, uint32_t size, uint32_t *sid)
{
int err;
DECLARE_FLASK_OP;
DECLARE_HYPERCALL_BOUNCE(buf, size, XC_HYPERCALL_BUFFER_BOUNCE_IN);
if ( xc_hypercall_bounce_pre(xch, buf) )
{
PERROR("Could not bounce memory for flask op hypercall");
return -1;
}
op.cmd = FLASK_CONTEXT_TO_SID;
op.u.sid_context.size = size;
set_xen_guest_handle(op.u.sid_context.context, buf);
err = xc_flask_op(xch, &op);
if ( !err )
*sid = op.u.sid_context.sid;
xc_hypercall_bounce_post(xch, buf);
return err;
}
int xc_flask_setbool(xc_interface *xch, char *name, int value, int commit)
{
int rv;
DECLARE_FLASK_OP;
DECLARE_HYPERCALL_BOUNCE(name, strlen(name), XC_HYPERCALL_BUFFER_BOUNCE_IN);
if ( xc_hypercall_bounce_pre(xch, name) )
{
PERROR("Could not bounce memory for flask op hypercall");
return -1;
}
op.cmd = FLASK_SETBOOL;
op.u.boolean.bool_id = -1;
op.u.boolean.new_value = value;
op.u.boolean.commit = 1;
op.u.boolean.size = strlen(name);
set_xen_guest_handle(op.u.boolean.name, name);
rv = xc_flask_op(xch, &op);
xc_hypercall_bounce_post(xch, name);
return rv;
}
int xc_flask_getbool_byname(xc_interface *xch, char *name, int *curr, int *pend)
{
int rv;
DECLARE_FLASK_OP;
DECLARE_HYPERCALL_BOUNCE(name, strlen(name), XC_HYPERCALL_BUFFER_BOUNCE_IN);
if ( xc_hypercall_bounce_pre(xch, name) )
{
PERROR("Could not bounce memory for flask op hypercall");
return -1;
}
op.cmd = FLASK_GETBOOL;
op.u.boolean.bool_id = -1;
op.u.boolean.size = strlen(name);
set_xen_guest_handle(op.u.boolean.name, name);
rv = xc_flask_op(xch, &op);
xc_hypercall_bounce_post(xch, name);
if ( rv )
return rv;
if ( curr )
*curr = op.u.boolean.enforcing;
if ( pend )
*pend = op.u.boolean.pending;
return rv;
}
int xc_sched_rt_domain_get(xc_interface *xch,
uint32_t domid,
struct xen_domctl_sched_rt_params *sdom,
uint16_t num_vcpus)
{
int rc;
DECLARE_DOMCTL;
DECLARE_HYPERCALL_BOUNCE(sdom,
sizeof(*sdom) * num_vcpus,
XC_HYPERCALL_BUFFER_BOUNCE_OUT);
if ( xc_hypercall_bounce_pre(xch, sdom) )
return -1;
domctl.cmd = XEN_DOMCTL_scheduler_op;
domctl.domain = (domid_t) domid;
domctl.u.scheduler_op.sched_id = XEN_SCHEDULER_RT_DS;
domctl.u.scheduler_op.cmd = XEN_DOMCTL_SCHEDOP_getinfo;
set_xen_guest_handle(domctl.u.scheduler_op.u.rt.vcpu, sdom);
rc = do_domctl(xch, &domctl);
xc_hypercall_bounce_post(xch, sdom);
return rc;
}
int xc_get_cpu_featureset(xc_interface *xch, uint32_t index,
uint32_t *nr_features, uint32_t *featureset)
{
DECLARE_SYSCTL;
DECLARE_HYPERCALL_BOUNCE(featureset,
*nr_features * sizeof(*featureset),
XC_HYPERCALL_BUFFER_BOUNCE_OUT);
int ret;
if ( xc_hypercall_bounce_pre(xch, featureset) )
return -1;
sysctl.cmd = XEN_SYSCTL_get_cpu_featureset;
sysctl.u.cpu_featureset.index = index;
sysctl.u.cpu_featureset.nr_features = *nr_features;
set_xen_guest_handle(sysctl.u.cpu_featureset.features, featureset);
ret = do_sysctl(xch, &sysctl);
xc_hypercall_bounce_post(xch, featureset);
if ( !ret )
*nr_features = sysctl.u.cpu_featureset.nr_features;
return ret;
}
int xc_mmuext_op(
xc_interface *xch,
struct mmuext_op *op,
unsigned int nr_ops,
domid_t dom)
{
DECLARE_HYPERCALL;
DECLARE_HYPERCALL_BOUNCE(op, nr_ops*sizeof(*op), XC_HYPERCALL_BUFFER_BOUNCE_BOTH);
long ret = -EINVAL;
if ( xc_hypercall_bounce_pre(xch, op) )
{
PERROR("Could not bounce memory for mmuext op hypercall");
goto out1;
}
hypercall.op = __HYPERVISOR_mmuext_op;
hypercall.arg[0] = HYPERCALL_BUFFER_AS_ARG(op);
hypercall.arg[1] = (unsigned long)nr_ops;
hypercall.arg[2] = (unsigned long)0;
hypercall.arg[3] = (unsigned long)dom;
ret = do_xen_hypercall(xch, &hypercall);
xc_hypercall_bounce_post(xch, op);
out1:
return ret;
}
int xc_pcitopoinfo(xc_interface *xch, unsigned num_devs,
physdev_pci_device_t *devs,
uint32_t *nodes)
{
int ret = 0;
unsigned processed = 0;
DECLARE_SYSCTL;
DECLARE_HYPERCALL_BOUNCE(devs, num_devs * sizeof(*devs),
XC_HYPERCALL_BUFFER_BOUNCE_IN);
DECLARE_HYPERCALL_BOUNCE(nodes, num_devs* sizeof(*nodes),
XC_HYPERCALL_BUFFER_BOUNCE_BOTH);
if ( (ret = xc_hypercall_bounce_pre(xch, devs)) )
goto out;
if ( (ret = xc_hypercall_bounce_pre(xch, nodes)) )
goto out;
sysctl.cmd = XEN_SYSCTL_pcitopoinfo;
while ( processed < num_devs )
{
sysctl.u.pcitopoinfo.num_devs = num_devs - processed;
set_xen_guest_handle_offset(sysctl.u.pcitopoinfo.devs, devs,
processed);
set_xen_guest_handle_offset(sysctl.u.pcitopoinfo.nodes, nodes,
processed);
if ( (ret = do_sysctl(xch, &sysctl)) != 0 )
break;
processed += sysctl.u.pcitopoinfo.num_devs;
}
out:
xc_hypercall_bounce_post(xch, devs);
xc_hypercall_bounce_post(xch, nodes);
return ret;
}
int xc_tmem_control(xc_interface *xch,
int32_t pool_id,
uint32_t cmd,
uint32_t cli_id,
uint32_t len,
uint32_t arg,
void *buf)
{
DECLARE_SYSCTL;
DECLARE_HYPERCALL_BOUNCE(buf, len, XC_HYPERCALL_BUFFER_BOUNCE_OUT);
int rc;
sysctl.cmd = XEN_SYSCTL_tmem_op;
sysctl.u.tmem_op.pool_id = pool_id;
sysctl.u.tmem_op.cmd = cmd;
sysctl.u.tmem_op.cli_id = cli_id;
sysctl.u.tmem_op.len = len;
sysctl.u.tmem_op.arg = arg;
sysctl.u.tmem_op.pad = 0;
sysctl.u.tmem_op.oid.oid[0] = 0;
sysctl.u.tmem_op.oid.oid[1] = 0;
sysctl.u.tmem_op.oid.oid[2] = 0;
if ( cmd == XEN_SYSCTL_TMEM_OP_SET_CLIENT_INFO ||
cmd == XEN_SYSCTL_TMEM_OP_SET_AUTH )
HYPERCALL_BOUNCE_SET_DIR(buf, XC_HYPERCALL_BUFFER_BOUNCE_IN);
if ( len )
{
if ( buf == NULL )
{
errno = EINVAL;
return -1;
}
if ( xc_hypercall_bounce_pre(xch, buf) )
{
PERROR("Could not bounce buffer for tmem control hypercall");
return -1;
}
}
set_xen_guest_handle(sysctl.u.tmem_op.u.buf, buf);
rc = do_sysctl(xch, &sysctl);
if ( len )
xc_hypercall_bounce_post(xch, buf);
return rc;
}
int xc_get_pfn_type_batch(xc_interface *xch, uint32_t dom,
unsigned int num, xen_pfn_t *arr)
{
int rc;
DECLARE_DOMCTL;
DECLARE_HYPERCALL_BOUNCE(arr, sizeof(*arr) * num, XC_HYPERCALL_BUFFER_BOUNCE_BOTH);
if ( xc_hypercall_bounce_pre(xch, arr) )
return -1;
domctl.cmd = XEN_DOMCTL_getpageframeinfo3;
domctl.domain = dom;
domctl.u.getpageframeinfo3.num = num;
set_xen_guest_handle(domctl.u.getpageframeinfo3.array, arr);
rc = do_domctl_retry_efault(xch, &domctl);
xc_hypercall_bounce_post(xch, arr);
return rc;
}
int xc_tmem_control_oid(xc_interface *xch,
int32_t pool_id,
uint32_t cmd,
uint32_t cli_id,
uint32_t len,
uint32_t arg,
struct xen_tmem_oid oid,
void *buf)
{
DECLARE_SYSCTL;
DECLARE_HYPERCALL_BOUNCE(buf, len, XC_HYPERCALL_BUFFER_BOUNCE_OUT);
int rc;
sysctl.cmd = XEN_SYSCTL_tmem_op;
sysctl.u.tmem_op.pool_id = pool_id;
sysctl.u.tmem_op.cmd = cmd;
sysctl.u.tmem_op.cli_id = cli_id;
sysctl.u.tmem_op.len = len;
sysctl.u.tmem_op.arg = arg;
sysctl.u.tmem_op.pad = 0;
sysctl.u.tmem_op.oid = oid;
if ( len )
{
if ( buf == NULL )
{
errno = EINVAL;
return -1;
}
if ( xc_hypercall_bounce_pre(xch, buf) )
{
PERROR("Could not bounce buffer for tmem control (OID) hypercall");
return -1;
}
}
set_xen_guest_handle(sysctl.u.tmem_op.u.buf, buf);
rc = do_sysctl(xch, &sysctl);
if ( len )
xc_hypercall_bounce_post(xch, buf);
return rc;
}
int xc_livepatch_get(xc_interface *xch,
char *name,
xen_livepatch_status_t *status)
{
int rc;
DECLARE_SYSCTL;
DECLARE_HYPERCALL_BOUNCE(name, 0 /*adjust later */, XC_HYPERCALL_BUFFER_BOUNCE_IN);
xen_livepatch_name_t def_name = { .pad = { 0, 0, 0 } };
if ( !name )
{
errno = EINVAL;
return -1;
}
def_name.size = strlen(name) + 1;
if ( def_name.size > XEN_LIVEPATCH_NAME_SIZE )
{
errno = EINVAL;
return -1;
}
HYPERCALL_BOUNCE_SET_SIZE(name, def_name.size);
if ( xc_hypercall_bounce_pre(xch, name) )
return -1;
sysctl.cmd = XEN_SYSCTL_livepatch_op;
sysctl.u.livepatch.cmd = XEN_SYSCTL_LIVEPATCH_GET;
sysctl.u.livepatch.pad = 0;
sysctl.u.livepatch.u.get.status.state = 0;
sysctl.u.livepatch.u.get.status.rc = 0;
sysctl.u.livepatch.u.get.name = def_name;
set_xen_guest_handle(sysctl.u.livepatch.u.get.name.name, name);
rc = do_sysctl(xch, &sysctl);
xc_hypercall_bounce_post(xch, name);
memcpy(status, &sysctl.u.livepatch.u.get.status, sizeof(*status));
return rc;
}
long do_memory_op(xc_interface *xch, int cmd, void *arg, size_t len)
{
DECLARE_HYPERCALL_BOUNCE(arg, len, XC_HYPERCALL_BUFFER_BOUNCE_BOTH);
long ret = -1;
if ( xc_hypercall_bounce_pre(xch, arg) )
{
PERROR("Could not bounce memory for XENMEM hypercall");
goto out1;
}
ret = xencall2(xch->xcall, __HYPERVISOR_memory_op,
cmd, HYPERCALL_BUFFER_AS_ARG(arg));
xc_hypercall_bounce_post(xch, arg);
out1:
return ret;
}
int xc_mca_op(xc_interface *xch, struct xen_mc *mc)
{
int ret = 0;
DECLARE_HYPERCALL_BOUNCE(mc, sizeof(*mc), XC_HYPERCALL_BUFFER_BOUNCE_BOTH);
if ( xc_hypercall_bounce_pre(xch, mc) )
{
PERROR("Could not bounce xen_mc memory buffer");
return -1;
}
mc->interface_version = XEN_MCA_INTERFACE_VERSION;
ret = xencall1(xch->xcall, __HYPERVISOR_mca,
HYPERCALL_BUFFER_AS_ARG(mc));
xc_hypercall_bounce_post(xch, mc);
return ret;
}
