Coverage report for src/xen_internal.c.gcov
-: 0:Source:xen_internal.c
-: 0:Graph:./libvirt_la-xen_internal.gcno
-: 0:Data:./libvirt_la-xen_internal.gcda
-: 0:Runs:1
-: 0:Programs:1
-: 1:/*
-: 2: * xen_internal.c: direct access to Xen hypervisor level
-: 3: *
-: 4: * Copyright (C) 2005 Red Hat, Inc.
-: 5: *
-: 6: * See COPYING.LIB for the License of this software
-: 7: *
-: 8: * Daniel Veillard <veillard@redhat.com>
-: 9: */
-: 10:
-: 11:#include <stdio.h>
-: 12:#include <string.h>
-: 13:/* required for uint8_t, uint32_t, etc ... */
-: 14:#include <stdint.h>
-: 15:#include <sys/types.h>
-: 16:#include <sys/stat.h>
-: 17:#include <unistd.h>
-: 18:#include <fcntl.h>
-: 19:#include <sys/mman.h>
-: 20:#include <sys/ioctl.h>
-: 21:#include <limits.h>
-: 22:#include <stdint.h>
-: 23:
-: 24:/* required for dom0_getdomaininfo_t */
-: 25:#include <xen/dom0_ops.h>
-: 26:#include <xen/version.h>
-: 27:#include <xen/xen.h>
-: 28:#include <xen/linux/privcmd.h>
-: 29:
-: 30:/* #ifndef __LINUX_PUBLIC_PRIVCMD_H__ */
-: 31:typedef struct old_hypercall_struct {
-: 32: unsigned long op;
-: 33: unsigned long arg[5];
-: 34:} old_hypercall_t;
-: 35:#define XEN_OLD_IOCTL_HYPERCALL_CMD \
-: 36: _IOC(_IOC_NONE, 'P', 0, sizeof(old_hypercall_t))
-: 37:
-: 38:typedef struct privcmd_hypercall hypercall_t;
-: 39:#define XEN_IOCTL_HYPERCALL_CMD IOCTL_PRIVCMD_HYPERCALL
-: 40:
-: 41:static int xen_ioctl_hypercall_cmd = 0;
-: 42:static int old_hypervisor = 0;
-: 43:static int initialized = 0;
-: 44:static int hv_version = 0;
-: 45:
-: 46:#include "internal.h"
-: 47:#include "driver.h"
-: 48:#include "xen_internal.h"
-: 49:
-: 50:#define XEN_HYPERVISOR_SOCKET "/proc/xen/privcmd"
-: 51:
-: 52:#ifndef PROXY
-: 53:static const char * xenHypervisorGetType(virConnectPtr conn);
-: 54:static unsigned long xenHypervisorGetMaxMemory(virDomainPtr domain);
-: 55:#endif
-: 56:static int xenHypervisorInit(void);
-: 57:
-: 58:#ifndef PROXY
-: 59:static virDriver xenHypervisorDriver = {
-: 60: VIR_DRV_XEN_HYPERVISOR,
-: 61: "Xen",
-: 62: (DOM0_INTERFACE_VERSION >> 24) * 1000000 +
-: 63: ((DOM0_INTERFACE_VERSION >> 16) & 0xFF) * 1000 +
-: 64: (DOM0_INTERFACE_VERSION & 0xFFFF),
-: 65: xenHypervisorInit, /* init */
-: 66: xenHypervisorOpen, /* open */
-: 67: xenHypervisorClose, /* close */
-: 68: xenHypervisorGetType, /* type */
-: 69: xenHypervisorGetVersion, /* version */
-: 70: NULL, /* nodeGetInfo */
-: 71: xenHypervisorListDomains, /* listDomains */
-: 72: xenHypervisorNumOfDomains, /* numOfDomains */
-: 73: NULL, /* domainCreateLinux */
-: 74: NULL, /* domainLookupByID */
-: 75: NULL, /* domainLookupByUUID */
-: 76: NULL, /* domainLookupByName */
-: 77: xenHypervisorPauseDomain, /* domainSuspend */
-: 78: xenHypervisorResumeDomain, /* domainResume */
-: 79: NULL, /* domainShutdown */
-: 80: NULL, /* domainReboot */
-: 81: xenHypervisorDestroyDomain, /* domainDestroy */
-: 82: NULL, /* domainFree */
-: 83: NULL, /* domainGetName */
-: 84: NULL, /* domainGetID */
-: 85: NULL, /* domainGetUUID */
-: 86: NULL, /* domainGetOSType */
-: 87: xenHypervisorGetMaxMemory, /* domainGetMaxMemory */
-: 88: xenHypervisorSetMaxMemory, /* domainSetMaxMemory */
-: 89: NULL, /* domainSetMemory */
-: 90: xenHypervisorGetDomainInfo, /* domainGetInfo */
-: 91: NULL, /* domainSave */
-: 92: NULL, /* domainRestore */
-: 93: xenHypervisorSetVcpus, /* domainSetVcpus */
-: 94: xenHypervisorPinVcpu, /* domainPinVcpu */
-: 95: xenHypervisorGetVcpus, /* domainGetVcpus */
-: 96: NULL, /* domainDumpXML */
-: 97:};
-: 98:#endif /* !PROXY */
-: 99:
-: 100:/**
-: 101: * virXenError:
-: 102: * @conn: the connection if available
-: 103: * @error: the error number
-: 104: * @info: extra information string
-: 105: *
-: 106: * Handle an error at the xend daemon interface
-: 107: */
-: 108:static void
-: 109:virXenError(virErrorNumber error, const char *info, int value)
function virXenError called 0 returned 0% blocks executed 0%
#####: 110:{
-: 111: const char *errmsg;
-: 112:
#####: 113: if (error == VIR_ERR_OK)
branch 0 never executed
branch 1 never executed
#####: 114: return;
-: 115:
#####: 116: errmsg = __virErrorMsg(error, info);
call 0 never executed
#####: 117: __virRaiseError(NULL, NULL, VIR_FROM_XEN, error, VIR_ERR_ERROR,
call 0 never executed
-: 118: errmsg, info, NULL, value, 0, errmsg, info, value);
-: 119:}
-: 120:
-: 121:/**
-: 122: * xenHypervisorInit:
-: 123: *
-: 124: * Initialize the hypervisor layer. Try to detect the kind of interface
-: 125: * used i.e. pre or post changeset 10277
-: 126: */
-: 127:int xenHypervisorInit(void)
function xenHypervisorInit called 0 returned 0% blocks executed 0%
#####: 128:{
-: 129: int fd, ret, cmd;
-: 130: hypercall_t hc;
-: 131: old_hypercall_t old_hc;
-: 132:
#####: 133: if (initialized) {
branch 0 never executed
branch 1 never executed
#####: 134: if (old_hypervisor == -1)
branch 0 never executed
branch 1 never executed
#####: 135: return(-1);
#####: 136: return(0);
-: 137: }
#####: 138: initialized = 1;
-: 139:
#####: 140: ret = open(XEN_HYPERVISOR_SOCKET, O_RDWR);
call 0 never executed
#####: 141: if (ret < 0) {
branch 0 never executed
branch 1 never executed
#####: 142: old_hypervisor = -1;
#####: 143: return (-1);
-: 144: }
#####: 145: fd = ret;
-: 146:
#####: 147: hc.op = __HYPERVISOR_xen_version;
#####: 148: hc.arg[0] = (unsigned long) XENVER_version;
#####: 149: hc.arg[1] = 0;
-: 150:
#####: 151: cmd = IOCTL_PRIVCMD_HYPERCALL;
#####: 152: ret = ioctl(fd, cmd, (unsigned long) &hc);
call 0 never executed
-: 153:
#####: 154: if ((ret != -1) && (ret != 0)) {
branch 0 never executed
branch 1 never executed
-: 155: /* fprintf(stderr, "Using new hypervisor call: %X\n", ret); */
#####: 156: hv_version = ret;
#####: 157: xen_ioctl_hypercall_cmd = cmd;
#####: 158: old_hypervisor = 0;
#####: 159: goto done;
-: 160: }
-: 161:
#####: 162: old_hc.op = __HYPERVISOR_xen_version;
#####: 163: old_hc.arg[0] = (unsigned long) XENVER_version;
#####: 164: old_hc.arg[1] = 0;
#####: 165: cmd = _IOC(_IOC_NONE, 'P', 0, sizeof(old_hypercall_t));
#####: 166: ret = ioctl(fd, cmd, (unsigned long) &old_hc);
call 0 never executed
#####: 167: if ((ret != -1) && (ret != 0)) {
branch 0 never executed
branch 1 never executed
-: 168: /* fprintf(stderr, "Using old hypervisor call: %X\n", ret); */
#####: 169: hv_version = ret;
#####: 170: xen_ioctl_hypercall_cmd = cmd;
#####: 171: old_hypervisor = 1;
#####: 172: goto done;
-: 173: }
-: 174:
#####: 175: old_hypervisor = -1;
#####: 176: virXenError(VIR_ERR_XEN_CALL, " ioctl ", IOCTL_PRIVCMD_HYPERCALL);
call 0 never executed
#####: 177: close(fd);
call 0 never executed
#####: 178: return(-1);
-: 179:
#####: 180:done:
#####: 181: close(fd);
call 0 never executed
#####: 182: return(0);
-: 183:
-: 184:}
-: 185:
-: 186:#ifndef PROXY
-: 187:/**
-: 188: * xenHypervisorRegister:
-: 189: *
-: 190: * Registers the xenHypervisor driver
-: 191: */
-: 192:void xenHypervisorRegister(void)
function xenHypervisorRegister called 0 returned 0% blocks executed 0%
#####: 193:{
#####: 194: if (initialized == 0)
branch 0 never executed
branch 1 never executed
#####: 195: xenHypervisorInit();
call 0 never executed
-: 196:
#####: 197: virRegisterDriver(&xenHypervisorDriver);
call 0 never executed
#####: 198:}
-: 199:#endif /* !PROXY */
-: 200:
-: 201:/**
-: 202: * xenHypervisorOpen:
-: 203: * @conn: pointer to the connection block
-: 204: * @name: URL for the target, NULL for local
-: 205: * @flags: combination of virDrvOpenFlag(s)
-: 206: *
-: 207: * Connects to the Xen hypervisor.
-: 208: *
-: 209: * Returns 0 or -1 in case of error.
-: 210: */
-: 211:int
-: 212:xenHypervisorOpen(virConnectPtr conn, const char *name, int flags)
function xenHypervisorOpen called 0 returned 0% blocks executed 0%
#####: 213:{
-: 214: int ret;
-: 215:
#####: 216: if (initialized == 0)
branch 0 never executed
branch 1 never executed
#####: 217: xenHypervisorInit();
call 0 never executed
-: 218:
#####: 219: if ((name != NULL) && (strcasecmp(name, "xen")))
branch 0 never executed
branch 1 never executed
call 2 never executed
branch 3 never executed
branch 4 never executed
#####: 220: return(-1);
-: 221:
#####: 222: conn->handle = -1;
-: 223:
#####: 224: ret = open(XEN_HYPERVISOR_SOCKET, O_RDWR);
call 0 never executed
#####: 225: if (ret < 0) {
branch 0 never executed
branch 1 never executed
#####: 226: if (!(flags & VIR_DRV_OPEN_QUIET))
branch 0 never executed
branch 1 never executed
#####: 227: virXenError(VIR_ERR_NO_XEN, XEN_HYPERVISOR_SOCKET, 0);
call 0 never executed
#####: 228: return (-1);
-: 229: }
#####: 230: conn->handle = ret;
-: 231:
#####: 232: return(0);
-: 233:}
-: 234:
-: 235:/**
-: 236: * xenHypervisorClose:
-: 237: * @conn: pointer to the connection block
-: 238: *
-: 239: * Close the connection to the Xen hypervisor.
-: 240: *
-: 241: * Returns 0 in case of success or -1 in case of error.
-: 242: */
-: 243:int
-: 244:xenHypervisorClose(virConnectPtr conn)
function xenHypervisorClose called 0 returned 0% blocks executed 0%
#####: 245:{
-: 246: int ret;
-: 247:
#####: 248: if ((conn == NULL) || (conn->handle < 0))
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 249: return (-1);
-: 250:
#####: 251: ret = close(conn->handle);
call 0 never executed
#####: 252: if (ret < 0)
branch 0 never executed
branch 1 never executed
#####: 253: return (-1);
#####: 254: return (0);
-: 255:}
-: 256:
-: 257:/**
-: 258: * xenHypervisorDoOldOp:
-: 259: * @handle: the handle to the Xen hypervisor
-: 260: * @op: pointer to the hyperviros operation structure
-: 261: *
-: 262: * Do an hypervisor operation though the old interface,
-: 263: * this leads to an hypervisor call through ioctl.
-: 264: *
-: 265: * Returns 0 in case of success and -1 in case of error.
-: 266: */
-: 267:static int
-: 268:xenHypervisorDoOldOp(int handle, dom0_op_t * op)
function xenHypervisorDoOldOp called 0 returned 0% blocks executed 0%
#####: 269:{
-: 270: int ret;
-: 271: old_hypercall_t hc;
-: 272:
#####: 273: memset(&hc, 0, sizeof(hc));
call 0 never executed
#####: 274: op->interface_version = hv_version << 8;
#####: 275: hc.op = __HYPERVISOR_dom0_op;
#####: 276: hc.arg[0] = (unsigned long) op;
-: 277:
#####: 278: if (mlock(op, sizeof(dom0_op_t)) < 0) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 279: virXenError(VIR_ERR_XEN_CALL, " locking", sizeof(dom0_op_t));
call 0 never executed
#####: 280: return (-1);
-: 281: }
-: 282:
#####: 283: ret = ioctl(handle, xen_ioctl_hypercall_cmd, (unsigned long) &hc);
call 0 never executed
#####: 284: if (ret < 0) {
branch 0 never executed
branch 1 never executed
#####: 285: virXenError(VIR_ERR_XEN_CALL, " ioctl ", xen_ioctl_hypercall_cmd);
call 0 never executed
-: 286: }
-: 287:
#####: 288: if (munlock(op, sizeof(dom0_op_t)) < 0) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 289: virXenError(VIR_ERR_XEN_CALL, " releasing", sizeof(dom0_op_t));
call 0 never executed
#####: 290: ret = -1;
-: 291: }
-: 292:
#####: 293: if (ret < 0)
branch 0 never executed
branch 1 never executed
#####: 294: return (-1);
-: 295:
#####: 296: return (0);
-: 297:}
-: 298:/**
-: 299: * xenHypervisorDoOp:
-: 300: * @handle: the handle to the Xen hypervisor
-: 301: * @op: pointer to the hyperviros operation structure
-: 302: *
-: 303: * Do an hypervisor operation, this leads to an hypervisor call through ioctl.
-: 304: *
-: 305: * Returns 0 in case of success and -1 in case of error.
-: 306: */
-: 307:static int
-: 308:xenHypervisorDoOp(int handle, dom0_op_t * op)
function xenHypervisorDoOp called 0 returned 0% blocks executed 0%
#####: 309:{
-: 310: int ret;
-: 311: hypercall_t hc;
-: 312:
#####: 313: if (old_hypervisor)
branch 0 never executed
branch 1 never executed
#####: 314: return(xenHypervisorDoOldOp(handle, op));
call 0 never executed
-: 315:
#####: 316: memset(&hc, 0, sizeof(hc));
call 0 never executed
#####: 317: op->interface_version = DOM0_INTERFACE_VERSION;
#####: 318: hc.op = __HYPERVISOR_dom0_op;
#####: 319: hc.arg[0] = (unsigned long) op;
-: 320:
#####: 321: if (mlock(op, sizeof(dom0_op_t)) < 0) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 322: virXenError(VIR_ERR_XEN_CALL, " locking", sizeof(dom0_op_t));
call 0 never executed
#####: 323: return (-1);
-: 324: }
-: 325:
#####: 326: ret = ioctl(handle, xen_ioctl_hypercall_cmd, (unsigned long) &hc);
call 0 never executed
#####: 327: if (ret < 0) {
branch 0 never executed
branch 1 never executed
#####: 328: virXenError(VIR_ERR_XEN_CALL, " ioctl ", xen_ioctl_hypercall_cmd);
call 0 never executed
-: 329: }
-: 330:
#####: 331: if (munlock(op, sizeof(dom0_op_t)) < 0) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 332: virXenError(VIR_ERR_XEN_CALL, " releasing", sizeof(dom0_op_t));
call 0 never executed
#####: 333: ret = -1;
-: 334: }
-: 335:
#####: 336: if (ret < 0)
branch 0 never executed
branch 1 never executed
#####: 337: return (-1);
-: 338:
#####: 339: return (0);
-: 340:}
-: 341:
-: 342:#ifndef PROXY
-: 343:/**
-: 344: * xenHypervisorGetType:
-: 345: * @conn: pointer to the Xen Hypervisor block
-: 346: *
-: 347: * Get the version level of the Hypervisor running.
-: 348: *
-: 349: * Returns -1 in case of error, 0 otherwise. if the version can't be
-: 350: * extracted by lack of capacities returns 0 and @hvVer is 0, otherwise
-: 351: * @hvVer value is major * 1,000,000 + minor * 1,000 + release
-: 352: */
-: 353:static const char *
-: 354:xenHypervisorGetType(virConnectPtr conn)
function xenHypervisorGetType called 0 returned 0% blocks executed 0%
#####: 355:{
#####: 356: if (!VIR_IS_CONNECT(conn)) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 357: virXenError(VIR_ERR_INVALID_CONN, __FUNCTION__, 0);
call 0 never executed
#####: 358: return (NULL);
-: 359: }
#####: 360: return("Xen");
-: 361:}
-: 362:#endif
-: 363:
-: 364:/**
-: 365: * xenHypervisorGetVersion:
-: 366: * @conn: pointer to the connection block
-: 367: * @hvVer: where to store the version
-: 368: *
-: 369: * Call the hypervisor to extracts his own internal API version
-: 370: *
-: 371: * Returns 0 in case of success, -1 in case of error
-: 372: */
-: 373:int
-: 374:xenHypervisorGetVersion(virConnectPtr conn, unsigned long *hvVer)
function xenHypervisorGetVersion called 0 returned 0% blocks executed 0%
#####: 375:{
#####: 376: if ((conn == NULL) || (conn->handle < 0) || (hvVer == NULL))
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 377: return (-1);
#####: 378: *hvVer = (hv_version >> 16) * 1000000 + (hv_version & 0xFFFF) * 1000;
#####: 379: return(0);
-: 380:}
-: 381:
-: 382:/**
-: 383: * xenHypervisorNumOfDomains:
-: 384: * @conn: pointer to the connection block
-: 385: *
-: 386: * Provides the number of active domains.
-: 387: *
-: 388: * Returns the number of domain found or -1 in case of error
-: 389: */
-: 390:int
-: 391:xenHypervisorNumOfDomains(virConnectPtr conn)
function xenHypervisorNumOfDomains called 0 returned 0% blocks executed 0%
#####: 392:{
-: 393: dom0_op_t op;
-: 394: dom0_getdomaininfo_t *dominfos;
-: 395: int ret, nbids;
-: 396: static int last_maxids = 2;
#####: 397: int maxids = last_maxids;
-: 398:
#####: 399: if ((conn == NULL) || (conn->handle < 0))
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 400: return (-1);
-: 401:
#####: 402:retry:
#####: 403: dominfos = malloc(maxids * sizeof(dom0_getdomaininfo_t));
call 0 never executed
#####: 404: if (dominfos == NULL) {
branch 0 never executed
branch 1 never executed
#####: 405: virXenError(VIR_ERR_NO_MEMORY, "failed to allocate %d domain info",
call 0 never executed
-: 406: maxids);
#####: 407: return(-1);
-: 408: }
-: 409:
#####: 410: memset(dominfos, 0, sizeof(dom0_getdomaininfo_t) * maxids);
call 0 never executed
-: 411:
#####: 412: if (mlock(dominfos, sizeof(dom0_getdomaininfo_t) * maxids) < 0) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 413: virXenError(VIR_ERR_XEN_CALL, " locking",
call 0 never executed
-: 414: sizeof(dom0_getdomaininfo_t) * maxids);
#####: 415: free(dominfos);
call 0 never executed
#####: 416: return (-1);
-: 417: }
-: 418:
#####: 419: op.cmd = DOM0_GETDOMAININFOLIST;
#####: 420: op.u.getdomaininfolist.first_domain = (domid_t) 0;
#####: 421: op.u.getdomaininfolist.max_domains = maxids;
#####: 422: op.u.getdomaininfolist.buffer = dominfos;
#####: 423: op.u.getdomaininfolist.num_domains = maxids;
-: 424:
#####: 425: ret = xenHypervisorDoOp(conn->handle, &op);
call 0 never executed
-: 426:
#####: 427: if (munlock(dominfos, sizeof(dom0_getdomaininfo_t) * maxids) < 0) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 428: virXenError(VIR_ERR_XEN_CALL, " release",
call 0 never executed
-: 429: sizeof(dom0_getdomaininfo_t) * maxids);
#####: 430: ret = -1;
-: 431: }
-: 432:
#####: 433: free(dominfos);
call 0 never executed
-: 434:
#####: 435: if (ret < 0)
branch 0 never executed
branch 1 never executed
#####: 436: return (-1);
-: 437:
#####: 438: nbids = op.u.getdomaininfolist.num_domains;
#####: 439: if (nbids == maxids) {
branch 0 never executed
branch 1 never executed
#####: 440: last_maxids *= 2;
#####: 441: maxids *= 2;
#####: 442: goto retry;
-: 443: }
#####: 444: if ((nbids < 0) || (nbids > maxids))
branch 0 never executed
branch 1 never executed
#####: 445: return(-1);
#####: 446: return(nbids);
-: 447:}
-: 448:
-: 449:/**
-: 450: * xenHypervisorListDomains:
-: 451: * @conn: pointer to the connection block
-: 452: * @ids: array to collect the list of IDs of active domains
-: 453: * @maxids: size of @ids
-: 454: *
-: 455: * Collect the list of active domains, and store their ID in @maxids
-: 456: *
-: 457: * Returns the number of domain found or -1 in case of error
-: 458: */
-: 459:int
-: 460:xenHypervisorListDomains(virConnectPtr conn, int *ids, int maxids)
function xenHypervisorListDomains called 0 returned 0% blocks executed 0%
#####: 461:{
-: 462: dom0_op_t op;
-: 463: dom0_getdomaininfo_t *dominfos;
-: 464: int ret, nbids, i;
-: 465:
#####: 466: if ((conn == NULL) || (conn->handle < 0) ||
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
branch 4 never executed
branch 5 never executed
-: 467: (ids == NULL) || (maxids < 1))
#####: 468: return (-1);
-: 469:
#####: 470: dominfos = malloc(maxids * sizeof(dom0_getdomaininfo_t));
call 0 never executed
#####: 471: if (dominfos == NULL) {
branch 0 never executed
branch 1 never executed
#####: 472: virXenError(VIR_ERR_NO_MEMORY, "failed to allocate %d domain info",
call 0 never executed
-: 473: maxids);
#####: 474: return(-1);
-: 475: }
-: 476:
#####: 477: memset(dominfos, 0, sizeof(dom0_getdomaininfo_t) * maxids);
call 0 never executed
#####: 478: memset(ids, 0, maxids * sizeof(int));
call 0 never executed
-: 479:
#####: 480: if (mlock(dominfos, sizeof(dom0_getdomaininfo_t) * maxids) < 0) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 481: virXenError(VIR_ERR_XEN_CALL, " locking",
call 0 never executed
-: 482: sizeof(dom0_getdomaininfo_t) * maxids);
#####: 483: free(dominfos);
call 0 never executed
#####: 484: return (-1);
-: 485: }
-: 486:
#####: 487: op.cmd = DOM0_GETDOMAININFOLIST;
#####: 488: op.u.getdomaininfolist.first_domain = (domid_t) 0;
#####: 489: op.u.getdomaininfolist.max_domains = maxids;
#####: 490: op.u.getdomaininfolist.buffer = dominfos;
#####: 491: op.u.getdomaininfolist.num_domains = maxids;
-: 492:
#####: 493: ret = xenHypervisorDoOp(conn->handle, &op);
call 0 never executed
-: 494:
#####: 495: if (munlock(dominfos, sizeof(dom0_getdomaininfo_t) * maxids) < 0) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 496: virXenError(VIR_ERR_XEN_CALL, " release",
call 0 never executed
-: 497: sizeof(dom0_getdomaininfo_t) * maxids);
#####: 498: ret = -1;
-: 499: }
-: 500:
#####: 501: if (ret < 0) {
branch 0 never executed
branch 1 never executed
#####: 502: free(dominfos);
call 0 never executed
#####: 503: return (-1);
-: 504: }
-: 505:
#####: 506: nbids = op.u.getdomaininfolist.num_domains;
#####: 507: if ((nbids < 0) || (nbids > maxids)) {
branch 0 never executed
branch 1 never executed
#####: 508: free(dominfos);
call 0 never executed
#####: 509: return(-1);
-: 510: }
-: 511:
#####: 512: for (i = 0;i < nbids;i++) {
branch 0 never executed
branch 1 never executed
#####: 513: ids[i] = dominfos[i].domain;
-: 514: }
-: 515:
#####: 516: free(dominfos);
call 0 never executed
#####: 517: return (nbids);
-: 518:}
-: 519:
-: 520:/**
-: 521: * xenHypervisorGetDomMaxMemory:
-: 522: * @conn: connection data
-: 523: * @id: domain id
-: 524: *
-: 525: * Retrieve the maximum amount of physical memory allocated to a
-: 526: * domain.
-: 527: *
-: 528: * Returns the memory size in kilobytes or 0 in case of error.
-: 529: */
-: 530:unsigned long
-: 531:xenHypervisorGetDomMaxMemory(virConnectPtr conn, int id)
function xenHypervisorGetDomMaxMemory called 0 returned 0% blocks executed 0%
#####: 532:{
-: 533: dom0_op_t op;
-: 534: dom0_getdomaininfo_t dominfo;
-: 535: int ret;
-: 536:
#####: 537: if ((conn == NULL) || (conn->handle < 0))
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 538: return (0);
-: 539:
#####: 540: memset(&dominfo, 0, sizeof(dom0_getdomaininfo_t));
call 0 never executed
-: 541:
#####: 542: if (mlock(&dominfo, sizeof(dom0_getdomaininfo_t)) < 0) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 543: virXenError(VIR_ERR_XEN_CALL, " locking",
call 0 never executed
-: 544: sizeof(dom0_getdomaininfo_t));
#####: 545: return (0);
-: 546: }
-: 547:
#####: 548: op.cmd = DOM0_GETDOMAININFOLIST;
#####: 549: op.u.getdomaininfolist.first_domain = (domid_t) id;
#####: 550: op.u.getdomaininfolist.max_domains = 1;
#####: 551: op.u.getdomaininfolist.buffer = &dominfo;
#####: 552: op.u.getdomaininfolist.num_domains = 1;
#####: 553: dominfo.domain = id;
-: 554:
#####: 555: ret = xenHypervisorDoOp(conn->handle, &op);
call 0 never executed
-: 556:
#####: 557: if (munlock(&dominfo, sizeof(dom0_getdomaininfo_t)) < 0) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 558: virXenError(VIR_ERR_XEN_CALL, " release",
call 0 never executed
-: 559: sizeof(dom0_getdomaininfo_t));
#####: 560: ret = -1;
-: 561: }
-: 562:
#####: 563: if (ret < 0)
branch 0 never executed
branch 1 never executed
#####: 564: return (0);
-: 565:
#####: 566: return((unsigned long) dominfo.max_pages * 4);
-: 567:}
-: 568:
-: 569:#ifndef PROXY
-: 570:/**
-: 571: * xenHypervisorGetMaxMemory:
-: 572: * @domain: a domain object or NULL
-: 573: *
-: 574: * Retrieve the maximum amount of physical memory allocated to a
-: 575: * domain. If domain is NULL, then this get the amount of memory reserved
-: 576: * to Domain0 i.e. the domain where the application runs.
-: 577: *
-: 578: * Returns the memory size in kilobytes or 0 in case of error.
-: 579: */
-: 580:static unsigned long
-: 581:xenHypervisorGetMaxMemory(virDomainPtr domain)
function xenHypervisorGetMaxMemory called 0 returned 0% blocks executed 0%
#####: 582:{
#####: 583: if ((domain == NULL) || (domain->conn == NULL) ||
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
branch 4 never executed
branch 5 never executed
-: 584: (domain->conn->handle < 0))
#####: 585: return (0);
-: 586:
#####: 587: return(xenHypervisorGetDomMaxMemory(domain->conn, domain->handle));
call 0 never executed
-: 588:}
-: 589:#endif
-: 590:
-: 591:/**
-: 592: * xenHypervisorGetDomInfo:
-: 593: * @conn: connection data
-: 594: * @id: the domain ID
-: 595: * @info: the place where information should be stored
-: 596: *
-: 597: * Do an hypervisor call to get the related set of domain information.
-: 598: *
-: 599: * Returns 0 in case of success, -1 in case of error.
-: 600: */
-: 601:int
-: 602:xenHypervisorGetDomInfo(virConnectPtr conn, int id, virDomainInfoPtr info)
function xenHypervisorGetDomInfo called 0 returned 0% blocks executed 0%
#####: 603:{
-: 604: dom0_op_t op;
-: 605: dom0_getdomaininfo_t dominfo;
-: 606: int ret;
-: 607:
#####: 608: if ((conn == NULL) || (conn->handle < 0) || (info == NULL))
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 609: return (-1);
-: 610:
#####: 611: memset(info, 0, sizeof(virDomainInfo));
call 0 never executed
#####: 612: memset(&dominfo, 0, sizeof(dom0_getdomaininfo_t));
call 0 never executed
-: 613:
#####: 614: if (mlock(&dominfo, sizeof(dom0_getdomaininfo_t)) < 0) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 615: virXenError(VIR_ERR_XEN_CALL, " locking",
call 0 never executed
-: 616: sizeof(dom0_getdomaininfo_t));
#####: 617: return (-1);
-: 618: }
-: 619:
#####: 620: op.cmd = DOM0_GETDOMAININFOLIST;
#####: 621: op.u.getdomaininfolist.first_domain = (domid_t) id;
#####: 622: op.u.getdomaininfolist.max_domains = 1;
#####: 623: op.u.getdomaininfolist.buffer = &dominfo;
#####: 624: op.u.getdomaininfolist.num_domains = 1;
#####: 625: dominfo.domain = id;
-: 626:
#####: 627: ret = xenHypervisorDoOp(conn->handle, &op);
call 0 never executed
-: 628:
#####: 629: if (munlock(&dominfo, sizeof(dom0_getdomaininfo_t)) < 0) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 630: virXenError(VIR_ERR_XEN_CALL, " release",
call 0 never executed
-: 631: sizeof(dom0_getdomaininfo_t));
#####: 632: ret = -1;
-: 633: }
-: 634:
#####: 635: if (ret < 0)
branch 0 never executed
branch 1 never executed
#####: 636: return (-1);
-: 637:
#####: 638: switch (dominfo.flags & 0xFF) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
branch 4 never executed
branch 5 never executed
-: 639: case DOMFLAGS_DYING:
#####: 640: info->state = VIR_DOMAIN_SHUTDOWN;
#####: 641: break;
-: 642: case DOMFLAGS_SHUTDOWN:
#####: 643: info->state = VIR_DOMAIN_SHUTOFF;
#####: 644: break;
-: 645: case DOMFLAGS_PAUSED:
#####: 646: info->state = VIR_DOMAIN_PAUSED;
#####: 647: break;
-: 648: case DOMFLAGS_BLOCKED:
#####: 649: info->state = VIR_DOMAIN_BLOCKED;
#####: 650: break;
-: 651: case DOMFLAGS_RUNNING:
#####: 652: info->state = VIR_DOMAIN_RUNNING;
#####: 653: break;
-: 654: default:
#####: 655: info->state = VIR_DOMAIN_NONE;
-: 656: }
-: 657:
-: 658: /*
-: 659: * the API brings back the cpu time in nanoseconds,
-: 660: * convert to microseconds, same thing convert to
-: 661: * kilobytes from page counts
-: 662: */
#####: 663: info->cpuTime = dominfo.cpu_time;
#####: 664: info->memory = dominfo.tot_pages * 4;
#####: 665: info->maxMem = dominfo.max_pages * 4;
#####: 666: info->nrVirtCpu = dominfo.nr_online_vcpus;
#####: 667: return (0);
-: 668:}
-: 669:
-: 670:/**
-: 671: * xenHypervisorGetDomainInfo:
-: 672: * @domain: pointer to the domain block
-: 673: * @info: the place where information should be stored
-: 674: *
-: 675: * Do an hypervisor call to get the related set of domain information.
-: 676: *
-: 677: * Returns 0 in case of success, -1 in case of error.
-: 678: */
-: 679:int
-: 680:xenHypervisorGetDomainInfo(virDomainPtr domain, virDomainInfoPtr info)
function xenHypervisorGetDomainInfo called 0 returned 0% blocks executed 0%
#####: 681:{
#####: 682: if ((domain == NULL) || (domain->conn == NULL) ||
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
branch 4 never executed
branch 5 never executed
branch 6 never executed
branch 7 never executed
-: 683: (domain->conn->handle < 0) || (info == NULL) ||
-: 684: (domain->handle < 0))
#####: 685: return (-1);
#####: 686: return(xenHypervisorGetDomInfo(domain->conn, domain->handle, info));
call 0 never executed
-: 687:
-: 688:}
-: 689:
-: 690:#ifndef PROXY
-: 691:/**
-: 692: * xenHypervisorPauseDomain:
-: 693: * @domain: pointer to the domain block
-: 694: *
-: 695: * Do an hypervisor call to pause the given domain
-: 696: *
-: 697: * Returns 0 in case of success, -1 in case of error.
-: 698: */
-: 699:int
-: 700:xenHypervisorPauseDomain(virDomainPtr domain)
function xenHypervisorPauseDomain called 0 returned 0% blocks executed 0%
#####: 701:{
-: 702: dom0_op_t op;
-: 703: int ret;
-: 704:
#####: 705: if ((domain == NULL) || (domain->conn == NULL) ||
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
branch 4 never executed
branch 5 never executed
-: 706: (domain->conn->handle < 0))
#####: 707: return (-1);
-: 708:
#####: 709: op.cmd = DOM0_PAUSEDOMAIN;
#####: 710: op.u.pausedomain.domain = (domid_t) domain->handle;
-: 711:
#####: 712: ret = xenHypervisorDoOp(domain->conn->handle, &op);
call 0 never executed
-: 713:
#####: 714: if (ret < 0)
branch 0 never executed
branch 1 never executed
#####: 715: return (-1);
#####: 716: return (0);
-: 717:}
-: 718:
-: 719:/**
-: 720: * xenHypervisorResumeDomain:
-: 721: * @domain: pointer to the domain block
-: 722: *
-: 723: * Do an hypervisor call to resume the given domain
-: 724: *
-: 725: * Returns 0 in case of success, -1 in case of error.
-: 726: */
-: 727:int
-: 728:xenHypervisorResumeDomain(virDomainPtr domain)
function xenHypervisorResumeDomain called 0 returned 0% blocks executed 0%
#####: 729:{
-: 730: dom0_op_t op;
-: 731: int ret;
-: 732:
#####: 733: if ((domain == NULL) || (domain->conn == NULL) ||
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
branch 4 never executed
branch 5 never executed
-: 734: (domain->conn->handle < 0))
#####: 735: return (-1);
-: 736:
#####: 737: op.cmd = DOM0_UNPAUSEDOMAIN;
#####: 738: op.u.unpausedomain.domain = (domid_t) domain->handle;
-: 739:
#####: 740: ret = xenHypervisorDoOp(domain->conn->handle, &op);
call 0 never executed
-: 741:
#####: 742: if (ret < 0)
branch 0 never executed
branch 1 never executed
#####: 743: return (-1);
#####: 744: return (0);
-: 745:}
-: 746:
-: 747:/**
-: 748: * xenHypervisorDestroyDomain:
-: 749: * @domain: pointer to the domain block
-: 750: *
-: 751: * Do an hypervisor call to destroy the given domain
-: 752: *
-: 753: * Returns 0 in case of success, -1 in case of error.
-: 754: */
-: 755:int
-: 756:xenHypervisorDestroyDomain(virDomainPtr domain)
function xenHypervisorDestroyDomain called 0 returned 0% blocks executed 0%
#####: 757:{
-: 758: dom0_op_t op;
-: 759: int ret;
-: 760:
#####: 761: if ((domain == NULL) || (domain->conn == NULL) ||
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
branch 4 never executed
branch 5 never executed
-: 762: (domain->conn->handle < 0))
#####: 763: return (-1);
-: 764:
#####: 765: op.cmd = DOM0_DESTROYDOMAIN;
#####: 766: op.u.destroydomain.domain = (domid_t) domain->handle;
-: 767:
#####: 768: ret = xenHypervisorDoOp(domain->conn->handle, &op);
call 0 never executed
-: 769:
#####: 770: if (ret < 0)
branch 0 never executed
branch 1 never executed
#####: 771: return (-1);
#####: 772: return (0);
-: 773:}
-: 774:
-: 775:/**
-: 776: * xenHypervisorSetMaxMemory:
-: 777: * @domain: pointer to the domain block
-: 778: * @memory: the max memory size in kilobytes.
-: 779: *
-: 780: * Do an hypervisor call to change the maximum amount of memory used
-: 781: *
-: 782: * Returns 0 in case of success, -1 in case of error.
-: 783: */
-: 784:int
-: 785:xenHypervisorSetMaxMemory(virDomainPtr domain, unsigned long memory)
function xenHypervisorSetMaxMemory called 0 returned 0% blocks executed 0%
#####: 786:{
-: 787: dom0_op_t op;
-: 788: int ret;
-: 789:
#####: 790: if ((domain == NULL) || (domain->conn == NULL) ||
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
branch 4 never executed
branch 5 never executed
-: 791: (domain->conn->handle < 0))
#####: 792: return (-1);
-: 793:
#####: 794: op.cmd = DOM0_SETDOMAINMAXMEM;
#####: 795: op.u.setdomainmaxmem.domain = (domid_t) domain->handle;
#####: 796: op.u.setdomainmaxmem.max_memkb = memory;
-: 797:
#####: 798: ret = xenHypervisorDoOp(domain->conn->handle, &op);
call 0 never executed
-: 799:
#####: 800: if (ret < 0)
branch 0 never executed
branch 1 never executed
#####: 801: return (-1);
#####: 802: return (0);
-: 803:}
-: 804:#endif /* PROXY */
-: 805:
-: 806:/**
-: 807: * xenHypervisorCheckID:
-: 808: * @domain: pointer to the domain block
-: 809: * @info: the place where information should be stored
-: 810: *
-: 811: * Do an hypervisor call to verify the domain ID is valid
-: 812: *
-: 813: * Returns 0 in case of success, -1 in case of error.
-: 814: */
-: 815:int
-: 816:xenHypervisorCheckID(virConnectPtr conn, int id)
function xenHypervisorCheckID called 0 returned 0% blocks executed 0%
#####: 817:{
-: 818: dom0_op_t op;
-: 819: dom0_getdomaininfo_t dominfo;
-: 820: int ret;
-: 821:
#####: 822: if ((conn->handle < 0) || (id < 0))
branch 0 never executed
branch 1 never executed
#####: 823: return (-1);
-: 824:
#####: 825: memset(&dominfo, 0, sizeof(dom0_getdomaininfo_t));
call 0 never executed
-: 826:
#####: 827: if (mlock(&dominfo, sizeof(dom0_getdomaininfo_t)) < 0) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 828: virXenError(VIR_ERR_XEN_CALL, " locking",
call 0 never executed
-: 829: sizeof(dom0_getdomaininfo_t));
#####: 830: return (-1);
-: 831: }
-: 832:
#####: 833: op.cmd = DOM0_GETDOMAININFOLIST;
#####: 834: op.u.getdomaininfolist.first_domain = (domid_t) id;
#####: 835: op.u.getdomaininfolist.max_domains = 1;
#####: 836: op.u.getdomaininfolist.buffer = &dominfo;
#####: 837: op.u.getdomaininfolist.num_domains = 1;
#####: 838: dominfo.domain = id;
-: 839:
#####: 840: ret = xenHypervisorDoOp(conn->handle, &op);
call 0 never executed
-: 841:
#####: 842: if (munlock(&dominfo, sizeof(dom0_getdomaininfo_t)) < 0) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 843: virXenError(VIR_ERR_XEN_CALL, " release",
call 0 never executed
-: 844: sizeof(dom0_getdomaininfo_t));
#####: 845: ret = -1;
-: 846: }
-: 847:
#####: 848: if (ret < 0)
branch 0 never executed
branch 1 never executed
#####: 849: return (-1);
-: 850:
#####: 851: return (0);
-: 852:}
-: 853:
-: 854:#ifndef PROXY
-: 855:/**
-: 856: * xenHypervisorSetVcpus:
-: 857: * @domain: pointer to domain object
-: 858: * @nvcpus: the new number of virtual CPUs for this domain
-: 859: *
-: 860: * Dynamically change the number of virtual CPUs used by the domain.
-: 861: *
-: 862: * Returns 0 in case of success, -1 in case of failure.
-: 863: */
-: 864:
-: 865:int
-: 866:xenHypervisorSetVcpus(virDomainPtr domain, unsigned int nvcpus)
function xenHypervisorSetVcpus called 0 returned 0% blocks executed 0%
#####: 867:{
-: 868: dom0_op_t op;
-: 869:
#####: 870: if ((domain == NULL) || (domain->conn == NULL) || (domain->conn->handle < 0)
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
branch 4 never executed
branch 5 never executed
-: 871: || (nvcpus < 1))
#####: 872: return (-1);
#####: 873: op.cmd = DOM0_MAX_VCPUS;
#####: 874: op.u.max_vcpus.domain = (domid_t) domain->handle;
#####: 875: op.u.max_vcpus.max = nvcpus;
#####: 876: if (xenHypervisorDoOp(domain->conn->handle, &op) < 0)
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 877: return (-1);
#####: 878: return 0;
-: 879:}
-: 880:
-: 881:/**
-: 882: * xenHypervisorPinVcpu:
-: 883: * @domain: pointer to domain object
-: 884: * @vcpu: virtual CPU number
-: 885: * @cpumap: pointer to a bit map of real CPUs (in 8-bit bytes)
-: 886: * @maplen: length of cpumap in bytes
-: 887: *
-: 888: * Dynamically change the real CPUs which can be allocated to a virtual CPU.
-: 889: *
-: 890: * Returns 0 in case of success, -1 in case of failure.
-: 891: */
-: 892:
-: 893:int
-: 894:xenHypervisorPinVcpu(virDomainPtr domain, unsigned int vcpu,
-: 895: unsigned char *cpumap, int maplen)
function xenHypervisorPinVcpu called 0 returned 0% blocks executed 0%
#####: 896:{
-: 897: dom0_op_t op;
#####: 898: uint64_t *pm = (uint64_t *)&op.u.setvcpuaffinity.cpumap;
-: 899: int j;
-: 900:
#####: 901: if ((domain == NULL) || (domain->conn == NULL) || (domain->conn->handle < 0)
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
branch 4 never executed
branch 5 never executed
branch 6 never executed
branch 7 never executed
-: 902: || (cpumap == NULL) || (maplen < 1) || (maplen > (int)sizeof(cpumap_t))
-: 903: || (sizeof(cpumap_t) & 7))
#####: 904: return (-1);
#####: 905: op.cmd = DOM0_SETVCPUAFFINITY;
#####: 906: op.u.setvcpuaffinity.domain = (domid_t) domain->handle;
#####: 907: op.u.setvcpuaffinity.vcpu = vcpu;
#####: 908: memset(pm, 0, sizeof(cpumap_t));
call 0 never executed
#####: 909: for (j = 0; j < maplen; j++)
branch 0 never executed
branch 1 never executed
#####: 910: *(pm + (j / 8)) |= cpumap[j] << (8 * (j & 7));
#####: 911: if (xenHypervisorDoOp(domain->conn->handle, &op) < 0)
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 912: return (-1);
#####: 913: return 0;
-: 914:}
-: 915:#endif
-: 916:
-: 917:/**
-: 918: * virDomainGetVcpus:
-: 919: * @domain: pointer to domain object, or NULL for Domain0
-: 920: * @info: pointer to an array of virVcpuInfo structures (OUT)
-: 921: * @maxinfo: number of structures in info array
-: 922: * @cpumaps: pointer to an bit map of real CPUs for all vcpus of this domain (in 8-bit bytes) (OUT)
-: 923: * If cpumaps is NULL, then no cupmap information is returned by the API.
-: 924: * It's assumed there is <maxinfo> cpumap in cpumaps array.
-: 925: * The memory allocated to cpumaps must be (maxinfo * maplen) bytes
-: 926: * (ie: calloc(maxinfo, maplen)).
-: 927: * One cpumap inside cpumaps has the format described in virDomainPinVcpu() API.
-: 928: * @maplen: number of bytes in one cpumap, from 1 up to size of CPU map in
-: 929: * underlying virtualization system (Xen...).
-: 930: *
-: 931: * Extract information about virtual CPUs of domain, store it in info array
-: 932: * and also in cpumaps if this pointer is'nt NULL.
-: 933: *
-: 934: * Returns the number of info filled in case of success, -1 in case of failure.
-: 935: */
-: 936:int
-: 937:xenHypervisorGetVcpus(virDomainPtr domain, virVcpuInfoPtr info, int maxinfo,
-: 938: unsigned char *cpumaps, int maplen)
function xenHypervisorGetVcpus called 0 returned 0% blocks executed 0%
#####: 939:{
-: 940: dom0_op_t op;
#####: 941: uint64_t *pm = (uint64_t *)&op.u.getvcpuinfo.cpumap;
-: 942: virVcpuInfoPtr ipt;
-: 943: int nbinfo, mapl, i;
-: 944: unsigned char *cpumap;
-: 945: int vcpu, cpu;
-: 946:
#####: 947: if ((domain == NULL) || (domain->conn == NULL) || (domain->conn->handle < 0)
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
branch 4 never executed
branch 5 never executed
branch 6 never executed
branch 7 never executed
-: 948: || (info == NULL) || (maxinfo < 1)
-: 949: || (sizeof(cpumap_t) & 7))
#####: 950: return (-1);
#####: 951: if (cpumaps != NULL && maplen < 1)
branch 0 never executed
branch 1 never executed
#####: 952: return -1;
-: 953:
-: 954: /* first get the number of virtual CPUs in this domain */
#####: 955: op.cmd = DOM0_GETDOMAININFO;
#####: 956: op.u.getdomaininfo.domain = (domid_t) domain->handle;
#####: 957: if (xenHypervisorDoOp(domain->conn->handle, &op) < 0)
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 958: return (-1);
#####: 959: nbinfo = (int)op.u.getdomaininfo.max_vcpu_id + 1;
#####: 960: if (nbinfo > maxinfo) nbinfo = maxinfo;
branch 0 never executed
branch 1 never executed
-: 961:
#####: 962: if (cpumaps != NULL)
branch 0 never executed
branch 1 never executed
#####: 963: memset(cpumaps, 0, maxinfo * maplen);
call 0 never executed
-: 964:
#####: 965: op.cmd = DOM0_GETVCPUINFO;
#####: 966: for (i=0, ipt=info; i < nbinfo; i++, ipt++) {
branch 0 never executed
branch 1 never executed
#####: 967: vcpu = op.u.getvcpuinfo.vcpu = i;
#####: 968: if (xenHypervisorDoOp(domain->conn->handle, &op) < 0)
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 969: return (-1);
#####: 970: ipt->number = i;
#####: 971: if (op.u.getvcpuinfo.online) {
branch 0 never executed
branch 1 never executed
#####: 972: if (op.u.getvcpuinfo.running) ipt->state = VIR_VCPU_RUNNING;
branch 0 never executed
branch 1 never executed
#####: 973: if (op.u.getvcpuinfo.blocked) ipt->state = VIR_VCPU_BLOCKED;
branch 0 never executed
branch 1 never executed
-: 974: }
#####: 975: else ipt->state = VIR_VCPU_OFFLINE;
#####: 976: ipt->cpuTime = op.u.getvcpuinfo.cpu_time;
#####: 977: ipt->cpu = op.u.getvcpuinfo.online ? (int)op.u.getvcpuinfo.cpu : -1;
branch 0 never executed
branch 1 never executed
#####: 978: if (cpumaps != NULL && vcpu >= 0 && vcpu < maxinfo) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 979: cpumap = (unsigned char *)VIR_GET_CPUMAP(cpumaps, maplen, vcpu);
#####: 980: mapl = (maplen > (int)sizeof(cpumap_t)) ? (int)sizeof(cpumap_t) : maplen;
#####: 981: for (cpu = 0; cpu < (mapl * CHAR_BIT); cpu++) {
branch 0 never executed
branch 1 never executed
#####: 982: if (*pm & ((uint64_t)1<<cpu))
branch 0 never executed
branch 1 never executed
#####: 983: VIR_USE_CPU(cpumap, cpu);
-: 984: }
-: 985: }
-: 986: }
#####: 987: return nbinfo;
-: 988:}