Coverage report for src/xend_internal.c.gcov
-: 0:Source:xend_internal.c
-: 0:Graph:./libvirt_la-xend_internal.gcno
-: 0:Data:./libvirt_la-xend_internal.gcda
-: 0:Runs:1
-: 0:Programs:1
-: 1:/*
-: 2: * xend_internal.c: access to Xen though the Xen Daemon interface
-: 3: *
-: 4: * Copyright (C) 2005
-: 5: *
-: 6: * Anthony Liguori <aliguori@us.ibm.com>
-: 7: *
-: 8: * This file is subject to the terms and conditions of the GNU Lesser General
-: 9: * Public License. See the file COPYING.LIB in the main directory of this
-: 10: * archive for more details.
-: 11: */
-: 12:
-: 13:#include <stdio.h>
-: 14:#include <sys/types.h>
-: 15:#include <sys/socket.h>
-: 16:#include <sys/un.h>
-: 17:#include <sys/errno.h>
-: 18:#include <unistd.h>
-: 19:#include <string.h>
-: 20:#include <stdlib.h>
-: 21:#include <stdbool.h>
-: 22:#include <math.h>
-: 23:#include <stdarg.h>
-: 24:#include <malloc.h>
-: 25:#include <netinet/in.h>
-: 26:#include <netinet/tcp.h>
-: 27:#include <arpa/inet.h>
-: 28:#include <netdb.h>
-: 29:#include <libxml/uri.h>
-: 30:
-: 31:#include "libvirt/libvirt.h"
-: 32:#include "driver.h"
-: 33:#include "internal.h"
-: 34:#include "sexpr.h"
-: 35:#include "xml.h"
-: 36:#include "xend_internal.h"
-: 37:#include "xen_internal.h" /* for DOM0_INTERFACE_VERSION */
-: 38:#include "xs_internal.h" /* To extract VNC port & Serial console TTY */
-: 39:
-: 40:#ifndef PROXY
-: 41:static const char * xenDaemonGetType(virConnectPtr conn);
-: 42:static int xenDaemonListDomains(virConnectPtr conn, int *ids, int maxids);
-: 43:static int xenDaemonNumOfDomains(virConnectPtr conn);
-: 44:static virDomainPtr xenDaemonLookupByID(virConnectPtr conn, int id);
-: 45:static virDomainPtr xenDaemonLookupByUUID(virConnectPtr conn,
-: 46: const unsigned char *uuid);
-: 47:static virDomainPtr xenDaemonCreateLinux(virConnectPtr conn,
-: 48: const char *xmlDesc,
-: 49: unsigned int flags);
-: 50:#endif /* PROXY */
-: 51:
-: 52:#ifndef PROXY
-: 53:static virDriver xenDaemonDriver = {
-: 54: VIR_DRV_XEN_DAEMON,
-: 55: "XenDaemon",
-: 56: (DOM0_INTERFACE_VERSION >> 24) * 1000000 +
-: 57: ((DOM0_INTERFACE_VERSION >> 16) & 0xFF) * 1000 +
-: 58: (DOM0_INTERFACE_VERSION & 0xFFFF),
-: 59: NULL, /* init */
-: 60: xenDaemonOpen, /* open */
-: 61: xenDaemonClose, /* close */
-: 62: xenDaemonGetType, /* type */
-: 63: xenDaemonGetVersion, /* version */
-: 64: xenDaemonNodeGetInfo, /* nodeGetInfo */
-: 65: xenDaemonListDomains, /* listDomains */
-: 66: xenDaemonNumOfDomains, /* numOfDomains */
-: 67: xenDaemonCreateLinux, /* domainCreateLinux */
-: 68: xenDaemonLookupByID, /* domainLookupByID */
-: 69: xenDaemonLookupByUUID, /* domainLookupByUUID */
-: 70: xenDaemonDomainLookupByName, /* domainLookupByName */
-: 71: xenDaemonDomainSuspend, /* domainSuspend */
-: 72: xenDaemonDomainResume, /* domainResume */
-: 73: xenDaemonDomainShutdown, /* domainShutdown */
-: 74: xenDaemonDomainReboot, /* domainReboot */
-: 75: xenDaemonDomainDestroy, /* domainDestroy */
-: 76: NULL, /* domainFree */
-: 77: NULL, /* domainGetName */
-: 78: NULL, /* domainGetID */
-: 79: NULL, /* domainGetUUID */
-: 80: NULL, /* domainGetOSType */
-: 81: xenDaemonDomainGetMaxMemory, /* domainGetMaxMemory */
-: 82: xenDaemonDomainSetMaxMemory, /* domainSetMaxMemory */
-: 83: xenDaemonDomainSetMemory, /* domainMaxMemory */
-: 84: xenDaemonDomainGetInfo, /* domainGetInfo */
-: 85: xenDaemonDomainSave, /* domainSave */
-: 86: xenDaemonDomainRestore, /* domainRestore */
-: 87: xenDaemonDomainSetVcpus, /* domainSetVcpus */
-: 88: xenDaemonDomainPinVcpu, /* domainPinVcpu */
-: 89: xenDaemonDomainGetVcpus, /* domainGetVcpus */
-: 90: xenDaemonDomainDumpXML, /* domainDumpXML */
-: 91:};
-: 92:
-: 93:/**
-: 94: * xenDaemonRegister:
-: 95: *
-: 96: * Registers the xenDaemon driver
-: 97: */
-: 98:void xenDaemonRegister(void)
function xenDaemonRegister called 0 returned 0% blocks executed 0%
#####: 99:{
#####: 100: virRegisterDriver(&xenDaemonDriver);
call 0 never executed
#####: 101:}
-: 102:#endif /* !PROXY */
-: 103:
-: 104:/**
-: 105: * xend_connection_type:
-: 106: *
-: 107: * The connection to the Xen Daemon can be done either though a normal TCP
-: 108: * socket or a local domain direct connection.
-: 109: */
-: 110:enum xend_connection_type {
-: 111: XEND_DOMAIN,
-: 112: XEND_TCP,
-: 113:};
-: 114:
-: 115:/**
-: 116: * xend:
-: 117: *
-: 118: * Structure associated to a connection to a Xen daemon
-: 119: */
-: 120:struct xend {
-: 121: int len;
-: 122: int type;
-: 123: struct sockaddr *addr;
-: 124: struct sockaddr_un addr_un;
-: 125: struct sockaddr_in addr_in;
-: 126:};
-: 127:
-: 128:
-: 129:/**
-: 130: * virXendError:
-: 131: * @conn: the connection if available
-: 132: * @error: the error noumber
-: 133: * @info: extra information string
-: 134: *
-: 135: * Handle an error at the xend daemon interface
-: 136: */
-: 137:static void
-: 138:virXendError(virConnectPtr conn, virErrorNumber error, const char *info)
function virXendError called 0 returned 0% blocks executed 0%
#####: 139:{
-: 140: const char *errmsg;
-: 141:
#####: 142: if (error == VIR_ERR_OK)
branch 0 never executed
branch 1 never executed
#####: 143: return;
-: 144:
#####: 145: errmsg = __virErrorMsg(error, info);
call 0 never executed
#####: 146: __virRaiseError(conn, NULL, VIR_FROM_XEND, error, VIR_ERR_ERROR,
call 0 never executed
-: 147: errmsg, info, NULL, 0, 0, errmsg, info);
-: 148:}
-: 149:
-: 150:/**
-: 151: * virXendErrorInt:
-: 152: * @conn: the connection if available
-: 153: * @error: the error noumber
-: 154: * @val: extra integer information
-: 155: *
-: 156: * Handle an error at the xend daemon interface
-: 157: */
-: 158:static void
-: 159:virXendErrorInt(virConnectPtr conn, virErrorNumber error, int val)
function virXendErrorInt called 0 returned 0% blocks executed 0%
#####: 160:{
-: 161: const char *errmsg;
-: 162:
#####: 163: if (error == VIR_ERR_OK)
branch 0 never executed
branch 1 never executed
#####: 164: return;
-: 165:
#####: 166: errmsg = __virErrorMsg(error, NULL);
call 0 never executed
#####: 167: __virRaiseError(conn, NULL, VIR_FROM_XEND, error, VIR_ERR_ERROR,
call 0 never executed
-: 168: errmsg, NULL, NULL, val, 0, errmsg, val);
-: 169:}
-: 170:
-: 171:
-: 172:#define foreach(iterator, start) \
-: 173: for (_for_i = (start), *iterator = (start)->car; \
-: 174: _for_i->kind == SEXPR_CONS; \
-: 175: _for_i = _for_i->cdr, iterator = _for_i->car)
-: 176:
-: 177:#define foreach_node(iterator, start, path) \
-: 178: foreach(iterator, start) \
-: 179: if (sexpr_lookup(iterator, path))
-: 180:
-: 181:/**
-: 182: * do_connect:
-: 183: * @xend: pointer to the Xen Daemon structure
-: 184: *
-: 185: * Internal routine to (re)connect to the daemon
-: 186: *
-: 187: * Returns the socket file descriptor or -1 in case of error
-: 188: */
-: 189:static int
-: 190:do_connect(virConnectPtr xend)
function do_connect called 0 returned 0% blocks executed 0%
#####: 191:{
-: 192: int s;
-: 193: int serrno;
#####: 194: int no_slow_start = 1;
-: 195:
#####: 196: s = socket(xend->type, SOCK_STREAM, 0);
call 0 never executed
#####: 197: if (s == -1) {
branch 0 never executed
branch 1 never executed
#####: 198: virXendError(xend, VIR_ERR_INTERNAL_ERROR,
call 0 never executed
-: 199: "failed to create a socket");
#####: 200: return -1;
-: 201: }
-: 202:
-: 203: /*
-: 204: * try to desactivate slow-start
-: 205: */
#####: 206: setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (void *)&no_slow_start,
call 0 never executed
-: 207: sizeof(no_slow_start));
-: 208:
-: 209:
#####: 210: if (connect(s, xend->addr, xend->len) == -1) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 211: serrno = errno;
call 0 never executed
#####: 212: close(s);
call 0 never executed
#####: 213: errno = serrno;
call 0 never executed
#####: 214: s = -1;
-: 215: }
-: 216:
#####: 217: return s;
-: 218:}
-: 219:
-: 220:/**
-: 221: * wr_sync:
-: 222: * @fd: the file descriptor
-: 223: * @buffer: the I/O buffer
-: 224: * @size: the size of the I/O
-: 225: * @do_read: write operation if 0, read operation otherwise
-: 226: *
-: 227: * Do a synchronous read or write on the file descriptor
-: 228: *
-: 229: * Returns the number of bytes exchanged, or -1 in case of error
-: 230: */
-: 231:static size_t
-: 232:wr_sync(int fd, void *buffer, size_t size, int do_read)
function wr_sync called 0 returned 0% blocks executed 0%
#####: 233:{
#####: 234: size_t offset = 0;
-: 235:
#####: 236: while (offset < size) {
branch 0 never executed
branch 1 never executed
-: 237: ssize_t len;
-: 238:
#####: 239: if (do_read) {
branch 0 never executed
branch 1 never executed
#####: 240: len = read(fd, ((char *) buffer) + offset, size - offset);
call 0 never executed
-: 241: } else {
#####: 242: len = write(fd, ((char *) buffer) + offset, size - offset);
call 0 never executed
-: 243: }
-: 244:
-: 245: /* recoverable error, retry */
#####: 246: if ((len == -1) && ((errno == EAGAIN) || (errno == EINTR))) {
branch 0 never executed
branch 1 never executed
call 2 never executed
branch 3 never executed
branch 4 never executed
#####: 247: continue;
-: 248: }
-: 249:
-: 250: /* eof */
#####: 251: if (len == 0) {
branch 0 never executed
branch 1 never executed
#####: 252: break;
-: 253: }
-: 254:
-: 255: /* unrecoverable error */
#####: 256: if (len == -1) {
branch 0 never executed
branch 1 never executed
#####: 257: if (do_read)
branch 0 never executed
branch 1 never executed
#####: 258: virXendError(NULL, VIR_ERR_INTERNAL_ERROR,
call 0 never executed
-: 259: "faid to read from Xen Daemon");
-: 260: else
#####: 261: virXendError(NULL, VIR_ERR_INTERNAL_ERROR,
call 0 never executed
-: 262: "faid to read from Xen Daemon");
-: 263:
#####: 264: return (-1);
-: 265: }
-: 266:
#####: 267: offset += len;
-: 268: }
-: 269:
#####: 270: return offset;
-: 271:}
-: 272:
-: 273:/**
-: 274: * sread:
-: 275: * @fd: the file descriptor
-: 276: * @buffer: the I/O buffer
-: 277: * @size: the size of the I/O
-: 278: *
-: 279: * Internal routine to do a synchronous read
-: 280: *
-: 281: * Returns the number of bytes read, or -1 in case of error
-: 282: */
-: 283:static ssize_t
-: 284:sread(int fd, void *buffer, size_t size)
function sread called 0 returned 0% blocks executed 0%
#####: 285:{
#####: 286: return wr_sync(fd, buffer, size, 1);
call 0 never executed
-: 287:}
-: 288:
-: 289:/**
-: 290: * swrite:
-: 291: * @fd: the file descriptor
-: 292: * @buffer: the I/O buffer
-: 293: * @size: the size of the I/O
-: 294: *
-: 295: * Internal routine to do a synchronous write
-: 296: *
-: 297: * Returns the number of bytes written, or -1 in case of error
-: 298: */
-: 299:static ssize_t
-: 300:swrite(int fd, const void *buffer, size_t size)
function swrite called 0 returned 0% blocks executed 0%
#####: 301:{
#####: 302: return wr_sync(fd, (void *) buffer, size, 0);
call 0 never executed
-: 303:}
-: 304:
-: 305:/**
-: 306: * swrites:
-: 307: * @fd: the file descriptor
-: 308: * @string: the string to write
-: 309: *
-: 310: * Internal routine to do a synchronous write of a string
-: 311: *
-: 312: * Returns the number of bytes written, or -1 in case of error
-: 313: */
-: 314:static ssize_t
-: 315:swrites(int fd, const char *string)
function swrites called 0 returned 0% blocks executed 0%
#####: 316:{
#####: 317: return swrite(fd, string, strlen(string));
call 0 never executed
call 1 never executed
-: 318:}
-: 319:
-: 320:/**
-: 321: * sreads:
-: 322: * @fd: the file descriptor
-: 323: * @buffer: the I/O buffer
-: 324: * @n_buffer: the size of the I/O buffer
-: 325: *
-: 326: * Internal routine to do a synchronous read of a line
-: 327: *
-: 328: * Returns the number of bytes read, or -1 in case of error
-: 329: */
-: 330:static ssize_t
-: 331:sreads(int fd, char *buffer, size_t n_buffer)
function sreads called 0 returned 0% blocks executed 0%
#####: 332:{
-: 333: size_t offset;
-: 334:
#####: 335: if (n_buffer < 1)
branch 0 never executed
branch 1 never executed
#####: 336: return (-1);
-: 337:
#####: 338: for (offset = 0; offset < (n_buffer - 1); offset++) {
branch 0 never executed
branch 1 never executed
-: 339: ssize_t ret;
-: 340:
#####: 341: ret = sread(fd, buffer + offset, 1);
call 0 never executed
#####: 342: if (ret == 0)
branch 0 never executed
branch 1 never executed
#####: 343: break;
#####: 344: else if (ret == -1)
branch 0 never executed
branch 1 never executed
#####: 345: return ret;
-: 346:
#####: 347: if (buffer[offset] == '\n') {
branch 0 never executed
branch 1 never executed
#####: 348: offset++;
#####: 349: break;
-: 350: }
-: 351: }
#####: 352: buffer[offset] = 0;
-: 353:
#####: 354: return offset;
-: 355:}
-: 356:
-: 357:static int
-: 358:istartswith(const char *haystack, const char *needle)
function istartswith called 0 returned 0% blocks executed 0%
#####: 359:{
#####: 360: return (strncasecmp(haystack, needle, strlen(needle)) == 0);
call 0 never executed
call 1 never executed
-: 361:}
-: 362:
-: 363:
-: 364:/**
-: 365: * xend_req:
-: 366: * @fd: the file descriptor
-: 367: * @content: the buffer to store the content
-: 368: * @n_content: the size of the buffer
-: 369: *
-: 370: * Read the HTTP response from a Xen Daemon request.
-: 371: *
-: 372: * Returns the HTTP return code.
-: 373: */
-: 374:static int
-: 375:xend_req(int fd, char *content, size_t n_content)
function xend_req called 0 returned 0% blocks executed 0%
#####: 376:{
-: 377: char buffer[4096];
#####: 378: int content_length = -1;
#####: 379: int retcode = 0;
-: 380:
#####: 381: while (sreads(fd, buffer, sizeof(buffer)) > 0) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 382: if (strcmp(buffer, "\r\n") == 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
call 8 never executed
branch 9 never executed
branch 10 never executed
#####: 383: break;
-: 384:
#####: 385: if (istartswith(buffer, "Content-Length: "))
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 386: content_length = atoi(buffer + 16);
#####: 387: else if (istartswith(buffer, "HTTP/1.1 "))
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 388: retcode = atoi(buffer + 9);
-: 389: }
-: 390:
#####: 391: if (content_length > -1) {
branch 0 never executed
branch 1 never executed
-: 392: ssize_t ret;
-: 393:
#####: 394: if ((unsigned int) content_length > (n_content + 1))
branch 0 never executed
branch 1 never executed
#####: 395: content_length = n_content - 1;
-: 396:
#####: 397: ret = sread(fd, content, content_length);
call 0 never executed
#####: 398: if (ret < 0)
branch 0 never executed
branch 1 never executed
#####: 399: return -1;
-: 400:
#####: 401: content[ret] = 0;
-: 402: } else {
#####: 403: content[0] = 0;
-: 404: }
-: 405:
#####: 406: return retcode;
-: 407:}
-: 408:
-: 409:/**
-: 410: * xend_get:
-: 411: * @xend: pointer to the Xen Daemon structure
-: 412: * @path: the path used for the HTTP request
-: 413: * @content: the buffer to store the content
-: 414: * @n_content: the size of the buffer
-: 415: *
-: 416: * Do an HTTP GET RPC with the Xen Daemon
-: 417: *
-: 418: * Returns the HTTP return code or -1 in case or error.
-: 419: */
-: 420:static int
-: 421:xend_get(virConnectPtr xend, const char *path,
-: 422: char *content, size_t n_content)
function xend_get called 0 returned 0% blocks executed 0%
#####: 423:{
-: 424: int ret;
#####: 425: int s = do_connect(xend);
call 0 never executed
-: 426:
#####: 427: if (s == -1)
branch 0 never executed
branch 1 never executed
#####: 428: return s;
-: 429:
#####: 430: swrites(s, "GET ");
call 0 never executed
#####: 431: swrites(s, path);
call 0 never executed
#####: 432: swrites(s, " HTTP/1.1\r\n");
call 0 never executed
-: 433:
#####: 434: swrites(s,
call 0 never executed
-: 435: "Host: localhost:8000\r\n"
-: 436: "Accept-Encoding: identity\r\n"
-: 437: "Content-Type: application/x-www-form-urlencoded\r\n" "\r\n");
-: 438:
#####: 439: ret = xend_req(s, content, n_content);
call 0 never executed
#####: 440: close(s);
call 0 never executed
-: 441:
#####: 442: if ((ret < 0) || (ret >= 300)) {
branch 0 never executed
branch 1 never executed
#####: 443: virXendError(NULL, VIR_ERR_GET_FAILED, content);
call 0 never executed
-: 444: }
-: 445:
#####: 446: return ret;
-: 447:}
-: 448:
-: 449:#ifndef PROXY
-: 450:/**
-: 451: * xend_post:
-: 452: * @xend: pointer to the Xen Daemon structure
-: 453: * @path: the path used for the HTTP request
-: 454: * @ops: the information sent for the POST
-: 455: * @content: the buffer to store the content
-: 456: * @n_content: the size of the buffer
-: 457: *
-: 458: * Do an HTTP POST RPC with the Xen Daemon, this usually makes changes at the
-: 459: * Xen level.
-: 460: *
-: 461: * Returns the HTTP return code or -1 in case or error.
-: 462: */
-: 463:static int
-: 464:xend_post(virConnectPtr xend, const char *path, const char *ops,
-: 465: char *content, size_t n_content)
function xend_post called 0 returned 0% blocks executed 0%
#####: 466:{
-: 467: char buffer[100];
-: 468: int ret;
#####: 469: int s = do_connect(xend);
call 0 never executed
-: 470:
#####: 471: if (s == -1)
branch 0 never executed
branch 1 never executed
#####: 472: return s;
-: 473:
#####: 474: swrites(s, "POST ");
call 0 never executed
#####: 475: swrites(s, path);
call 0 never executed
#####: 476: swrites(s, " HTTP/1.1\r\n");
call 0 never executed
-: 477:
#####: 478: swrites(s,
call 0 never executed
-: 479: "Host: localhost:8000\r\n"
-: 480: "Accept-Encoding: identity\r\n"
-: 481: "Content-Type: application/x-www-form-urlencoded\r\n"
-: 482: "Content-Length: ");
#####: 483: snprintf(buffer, sizeof(buffer), "%d", (int) strlen(ops));
call 0 never executed
call 1 never executed
#####: 484: swrites(s, buffer);
call 0 never executed
#####: 485: swrites(s, "\r\n\r\n");
call 0 never executed
#####: 486: swrites(s, ops);
call 0 never executed
-: 487:
#####: 488: ret = xend_req(s, content, n_content);
call 0 never executed
#####: 489: close(s);
call 0 never executed
-: 490:
#####: 491: if ((ret < 0) || (ret >= 300)) {
branch 0 never executed
branch 1 never executed
#####: 492: virXendError(NULL, VIR_ERR_POST_FAILED, content);
call 0 never executed
#####: 493: } else if ((ret = 202) && (strstr(content, "failed") != NULL)) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 494: virXendError(NULL, VIR_ERR_POST_FAILED, content);
call 0 never executed
#####: 495: ret = -1;
-: 496: }
-: 497:
#####: 498: return ret;
-: 499:}
-: 500:#endif /* ! PROXY */
-: 501:
-: 502:
-: 503:/**
-: 504: * http2unix:
-: 505: * @ret: the http return code
-: 506: *
-: 507: * Convert the HTTP return code to 0/-1 and set errno if needed
-: 508: *
-: 509: * Return -1 in case of error code 0 otherwise
-: 510: */
-: 511:static int
-: 512:http2unix(int ret)
function http2unix called 0 returned 0% blocks executed 0%
#####: 513:{
#####: 514: switch (ret) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
-: 515: case -1:
-: 516: break;
-: 517: case 200:
-: 518: case 201:
-: 519: case 202:
#####: 520: return 0;
-: 521: case 404:
#####: 522: errno = ESRCH;
call 0 never executed
#####: 523: break;
-: 524: default:
#####: 525: virXendErrorInt(NULL, VIR_ERR_HTTP_ERROR, ret);
call 0 never executed
#####: 526: errno = EINVAL;
call 0 never executed
-: 527: break;
-: 528: }
#####: 529: return -1;
-: 530:}
-: 531:
-: 532:#ifndef PROXY
-: 533:/**
-: 534: * xend_op_ext2:
-: 535: * @xend: pointer to the Xen Daemon structure
-: 536: * @path: path for the object
-: 537: * @error: buffer for the error output
-: 538: * @n_error: size of @error
-: 539: * @key: the key for the operation
-: 540: * @ap: input values to pass to the operation
-: 541: *
-: 542: * internal routine to run a POST RPC operation to the Xen Daemon
-: 543: *
-: 544: * Returns 0 in case of success, -1 in case of failure.
-: 545: */
-: 546:static int
-: 547:xend_op_ext2(virConnectPtr xend, const char *path, char *error,
-: 548: size_t n_error, const char *key, va_list ap)
function xend_op_ext2 called 0 returned 0% blocks executed 0%
#####: 549:{
-: 550: char ops[1024];
#####: 551: const char *k = key, *v;
#####: 552: int offset = 0;
-: 553:
#####: 554: while (k) {
branch 0 never executed
branch 1 never executed
#####: 555: v = va_arg(ap, const char *);
branch 0 never executed
branch 1 never executed
-: 556:
#####: 557: offset += snprintf(ops + offset, sizeof(ops) - offset, "%s", k);
call 0 never executed
#####: 558: offset += snprintf(ops + offset, sizeof(ops) - offset, "%s", "=");
call 0 never executed
#####: 559: offset += snprintf(ops + offset, sizeof(ops) - offset, "%s", v);
call 0 never executed
#####: 560: k = va_arg(ap, const char *);
branch 0 never executed
branch 1 never executed
-: 561:
#####: 562: if (k)
branch 0 never executed
branch 1 never executed
#####: 563: offset += snprintf(ops + offset,
call 0 never executed
-: 564: sizeof(ops) - offset, "%s", "&");
-: 565: }
-: 566:
#####: 567: return http2unix(xend_post(xend, path, ops, error, n_error));
call 0 never executed
call 1 never executed
-: 568:}
-: 569:
-: 570:
-: 571:/**
-: 572: * xend_node_op:
-: 573: * @xend: pointer to the Xen Daemon structure
-: 574: * @path: path for the object
-: 575: * @key: the key for the operation
-: 576: * @...: input values to pass to the operation
-: 577: *
-: 578: * internal routine to run a POST RPC operation to the Xen Daemon
-: 579: *
-: 580: * Returns 0 in case of success, -1 in case of failure.
-: 581: */
-: 582:static int
-: 583:xend_node_op(virConnectPtr xend, const char *path, const char *key, ...)
function xend_node_op called 0 returned 0% blocks executed 0%
#####: 584:{
-: 585: va_list ap;
-: 586: int ret;
-: 587: char error[1024];
-: 588:
#####: 589: va_start(ap, key);
call 0 never executed
#####: 590: ret = xend_op_ext2(xend, path, error, sizeof(error), key, ap);
call 0 never executed
#####: 591: va_end(ap);
call 0 never executed
-: 592:
#####: 593: return ret;
-: 594:}
-: 595:
-: 596:
-: 597:/**
-: 598: * xend_node_op:
-: 599: * @xend: pointer to the Xen Daemon structure
-: 600: * @name: the domain name target of this operation
-: 601: * @error: buffer for the error output
-: 602: * @n_error: size of @error
-: 603: * @key: the key for the operation
-: 604: * @ap: input values to pass to the operation
-: 605: * @...: input values to pass to the operation
-: 606: *
-: 607: * internal routine to run a POST RPC operation to the Xen Daemon targetting
-: 608: * a given domain.
-: 609: *
-: 610: * Returns 0 in case of success, -1 in case of failure.
-: 611: */
-: 612:static int
-: 613:xend_op_ext(virConnectPtr xend, const char *name, char *error,
-: 614: size_t n_error, const char *key, ...)
function xend_op_ext called 0 returned 0% blocks executed 0%
#####: 615:{
-: 616: char buffer[1024];
-: 617: va_list ap;
-: 618: int ret;
-: 619:
#####: 620: snprintf(buffer, sizeof(buffer), "/xend/domain/%s", name);
call 0 never executed
-: 621:
#####: 622: va_start(ap, key);
call 0 never executed
#####: 623: ret = xend_op_ext2(xend, buffer, error, n_error, key, ap);
call 0 never executed
#####: 624: va_end(ap);
call 0 never executed
-: 625:
#####: 626: return ret;
-: 627:}
-: 628:
-: 629:#define xend_op(xend, name, key, ...) ({char error[1024]; xend_op_ext(xend, name, error, sizeof(error), key, __VA_ARGS__);})
-: 630:#endif /* ! PROXY */
-: 631:
-: 632:/**
-: 633: * sexpr_get:
-: 634: * @xend: pointer to the Xen Daemon structure
-: 635: * @fmt: format string for the path of the operation
-: 636: * @...: extra data to build the path of the operation
-: 637: *
-: 638: * Internal routine to run a simple GET RPC operation to the Xen Daemon
-: 639: *
-: 640: * Returns a parsed S-Expression in case of success, NULL in case of failure
-: 641: */
-: 642:static struct sexpr *
-: 643:sexpr_get(virConnectPtr xend, const char *fmt, ...)
function sexpr_get called 0 returned 0% blocks executed 0%
#####: 644:{
-: 645: char buffer[4096];
-: 646: char path[1024];
-: 647: va_list ap;
-: 648: int ret;
-: 649:
#####: 650: va_start(ap, fmt);
call 0 never executed
#####: 651: vsnprintf(path, sizeof(path), fmt, ap);
call 0 never executed
#####: 652: va_end(ap);
call 0 never executed
-: 653:
#####: 654: ret = xend_get(xend, path, buffer, sizeof(buffer));
call 0 never executed
#####: 655: ret = http2unix(ret);
call 0 never executed
#####: 656: if (ret == -1)
branch 0 never executed
branch 1 never executed
#####: 657: return NULL;
-: 658:
#####: 659: return string2sexpr(buffer);
call 0 never executed
-: 660:}
-: 661:
-: 662:/**
-: 663: * sexpr_int:
-: 664: * @sexpr: an S-Expression
-: 665: * @name: the name for the value
-: 666: *
-: 667: * convenience function to lookup an int value in the S-Expression
-: 668: *
-: 669: * Returns the value found or 0 if not found (but may not be an error)
-: 670: */
-: 671:static int
-: 672:sexpr_int(struct sexpr *sexpr, const char *name)
function sexpr_int called 7 returned 100% blocks executed 100%
7: 673:{
7: 674: const char *value = sexpr_node(sexpr, name);
call 0 returned 100%
-: 675:
7: 676: if (value) {
branch 0 taken 71% (fallthrough)
branch 1 taken 29%
5: 677: return strtol(value, NULL, 0);
-: 678: }
2: 679: return 0;
-: 680:}
-: 681:
-: 682:/**
-: 683: * sexpr_float:
-: 684: * @sexpr: an S-Expression
-: 685: * @name: the name for the value
-: 686: *
-: 687: * convenience function to lookup a float value in the S-Expression
-: 688: *
-: 689: * Returns the value found or 0 if not found (but may not be an error)
-: 690: */
-: 691:static double
-: 692:sexpr_float(struct sexpr *sexpr, const char *name)
function sexpr_float called 0 returned 0% blocks executed 0%
#####: 693:{
#####: 694: const char *value = sexpr_node(sexpr, name);
call 0 never executed
-: 695:
#####: 696: if (value) {
branch 0 never executed
branch 1 never executed
#####: 697: return strtod(value, NULL);
-: 698: }
#####: 699: return 0;
-: 700:}
-: 701:
-: 702:/**
-: 703: * sexpr_u64:
-: 704: * @sexpr: an S-Expression
-: 705: * @name: the name for the value
-: 706: *
-: 707: * convenience function to lookup a 64bits unsigned int value in the
-: 708: * S-Expression
-: 709: *
-: 710: * Returns the value found or 0 if not found (but may not be an error)
-: 711: */
-: 712:static uint64_t
-: 713:sexpr_u64(struct sexpr *sexpr, const char *name)
function sexpr_u64 called 2 returned 100% blocks executed 88%
2: 714:{
2: 715: const char *value = sexpr_node(sexpr, name);
call 0 returned 100%
-: 716:
2: 717: if (value) {
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
2: 718: return strtoll(value, NULL, 0);
-: 719: }
#####: 720: return 0;
-: 721:}
-: 722:
-: 723:static int
-: 724:sexpr_strlen(struct sexpr *sexpr, const char *path)
function sexpr_strlen called 0 returned 0% blocks executed 0%
#####: 725:{
#####: 726: const char *r = sexpr_node(sexpr, path);
call 0 never executed
-: 727:
#####: 728: return r ? (strlen(r) + 1) : 0;
branch 0 never executed
branch 1 never executed
call 2 never executed
-: 729:}
-: 730:
-: 731:static const char *
-: 732:sexpr_strcpy(char **ptr, struct sexpr *node, const char *path)
function sexpr_strcpy called 0 returned 0% blocks executed 0%
#####: 733:{
#####: 734: const char *ret = sexpr_node(node, path);
call 0 never executed
-: 735:
#####: 736: if (ret) {
branch 0 never executed
branch 1 never executed
#####: 737: strcpy(*ptr, ret);
call 0 never executed
#####: 738: ret = *ptr;
#####: 739: *ptr += (strlen(ret) + 1);
call 0 never executed
-: 740: }
#####: 741: return ret;
-: 742:}
-: 743:
-: 744:
-: 745:/**
-: 746: * sexpr_node_system:
-: 747: * @sexpr: an S-Expression
-: 748: * @name: the name for the value
-: 749: *
-: 750: * convenience function to lookup a value describing the kind of system
-: 751: * from the S-Expression
-: 752: *
-: 753: * Returns the value found or 0 if not found (but may not be an error)
-: 754: */
-: 755:static enum xend_node_system
-: 756:sexpr_node_system(struct sexpr *node, const char *path)
function sexpr_node_system called 0 returned 0% blocks executed 0%
#####: 757:{
#####: 758: const char *syst = sexpr_node(node, path);
call 0 never executed
-: 759:
#####: 760: if (syst) {
branch 0 never executed
branch 1 never executed
#####: 761: if (strcmp(syst, "Linux") == 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
call 8 never executed
branch 9 never executed
branch 10 never executed
#####: 762: return XEND_SYSTEM_LINUX;
-: 763: }
-: 764: }
-: 765:
#####: 766: return XEND_DEFAULT;
-: 767:}
-: 768:
-: 769:/**
-: 770: * sexpr_uuid:
-: 771: * @ptr: where to store the UUID, incremented
-: 772: * @sexpr: an S-Expression
-: 773: * @name: the name for the value
-: 774: *
-: 775: * convenience function to lookup an UUID value from the S-Expression
-: 776: *
-: 777: * Returns a pointer to the stored UUID or NULL in case of error.
-: 778: */
-: 779:static unsigned char *
-: 780:sexpr_uuid(char **ptr, struct sexpr *node, const char *path)
function sexpr_uuid called 0 returned 0% blocks executed 0%
#####: 781:{
#####: 782: const char *r = sexpr_node(node, path);
call 0 never executed
#####: 783: return virParseUUID(ptr, r);
call 0 never executed
-: 784:}
-: 785:
-: 786:
-: 787:#ifndef PROXY
-: 788:/**
-: 789: * urlencode:
-: 790: * @string: the input URL
-: 791: *
-: 792: * Encode an URL see RFC 2396 and following
-: 793: *
-: 794: * Returns the new string or NULL in case of error.
-: 795: */
-: 796:static char *
-: 797:urlencode(const char *string)
function urlencode called 0 returned 0% blocks executed 0%
#####: 798:{
#####: 799: size_t len = strlen(string);
call 0 never executed
#####: 800: char *buffer = malloc(len * 3 + 1);
call 0 never executed
#####: 801: char *ptr = buffer;
-: 802: size_t i;
-: 803:
#####: 804: if (buffer == NULL)
branch 0 never executed
branch 1 never executed
#####: 805: return (NULL);
#####: 806: for (i = 0; i < len; i++) {
branch 0 never executed
branch 1 never executed
#####: 807: switch (string[i]) {
branch 0 never executed
branch 1 never executed
-: 808: case ' ':
-: 809: case '\n':
#####: 810: sprintf(ptr, "%%%02x", string[i]);
call 0 never executed
#####: 811: ptr += 3;
#####: 812: break;
-: 813: default:
#####: 814: *ptr = string[i];
#####: 815: ptr++;
-: 816: }
-: 817: }
-: 818:
#####: 819: *ptr = 0;
-: 820:
#####: 821: return buffer;
-: 822:}
-: 823:#endif /* ! PROXY */
-: 824:
-: 825:/* PUBLIC FUNCTIONS */
-: 826:
-: 827:/**
-: 828: * xenDaemonOpen_unix:
-: 829: * @conn: an existing virtual connection block
-: 830: * @path: the path for the Xen Daemon socket
-: 831: *
-: 832: * Creates a localhost Xen Daemon connection
-: 833: * Note: this doesn't try to check if the connection actually works
-: 834: *
-: 835: * Returns 0 in case of success, -1 in case of error.
-: 836: */
-: 837:int
-: 838:xenDaemonOpen_unix(virConnectPtr conn, const char *path)
function xenDaemonOpen_unix called 0 returned 0% blocks executed 0%
#####: 839:{
-: 840: struct sockaddr_un *addr;
-: 841:
#####: 842: if ((conn == NULL) || (path == NULL))
branch 0 never executed
branch 1 never executed
#####: 843: return (-1);
-: 844:
#####: 845: addr = &conn->addr_un;
#####: 846: addr->sun_family = AF_UNIX;
#####: 847: memset(addr->sun_path, 0, sizeof(addr->sun_path));
call 0 never executed
#####: 848: strncpy(addr->sun_path, path, sizeof(addr->sun_path));
call 0 never executed
-: 849:
#####: 850: conn->len = sizeof(addr->sun_family) + strlen(addr->sun_path);
call 0 never executed
#####: 851: if ((unsigned int) conn->len > sizeof(addr->sun_path))
branch 0 never executed
branch 1 never executed
#####: 852: conn->len = sizeof(addr->sun_path);
-: 853:
#####: 854: conn->addr = (struct sockaddr *) addr;
#####: 855: conn->type = PF_UNIX;
-: 856:
#####: 857: return (0);
-: 858:}
-: 859:
-: 860:#ifndef PROXY
-: 861:/**
-: 862: * xenDaemonOpen_tcp:
-: 863: * @conn: an existing virtual connection block
-: 864: * @host: the host name for the Xen Daemon
-: 865: * @port: the port
-: 866: *
-: 867: * Creates a possibly remote Xen Daemon connection
-: 868: * Note: this doesn't try to check if the connection actually works
-: 869: *
-: 870: * Returns 0 in case of success, -1 in case of error.
-: 871: */
-: 872:int
-: 873:xenDaemonOpen_tcp(virConnectPtr conn, const char *host, int port)
function xenDaemonOpen_tcp called 0 returned 0% blocks executed 0%
#####: 874:{
-: 875: struct in_addr ip;
-: 876: struct hostent *pent;
-: 877:
#####: 878: if ((conn == NULL) || (host == NULL) || (port <= 0))
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 879: return (-1);
-: 880:
#####: 881: pent = gethostbyname(host);
call 0 never executed
#####: 882: if (pent == NULL) {
branch 0 never executed
branch 1 never executed
#####: 883: if (inet_aton(host, &ip) == 0) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 884: virXendError(conn, VIR_ERR_UNKNOWN_HOST, host);
call 0 never executed
#####: 885: errno = ESRCH;
call 0 never executed
#####: 886: return (-1);
-: 887: }
-: 888: } else {
#####: 889: memcpy(&ip, pent->h_addr_list[0], sizeof(ip));
call 0 never executed
-: 890: }
-: 891:
#####: 892: conn->len = sizeof(struct sockaddr_in);
#####: 893: conn->addr = (struct sockaddr *) &conn->addr_in;
#####: 894: conn->type = PF_INET;
-: 895:
#####: 896: conn->addr_in.sin_family = AF_INET;
#####: 897: conn->addr_in.sin_port = htons(port);
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 898: memcpy(&conn->addr_in.sin_addr, &ip, sizeof(ip));
call 0 never executed
-: 899:
#####: 900: return (0);
-: 901:}
-: 902:
-: 903:
-: 904:/**
-: 905: * xend_wait_for_devices:
-: 906: * @xend: pointer to the Xem Daemon block
-: 907: * @name: name for the domain
-: 908: *
-: 909: * Block the domain until all the virtual devices are ready. This operation
-: 910: * is needed when creating a domain before resuming it.
-: 911: *
-: 912: * Returns 0 in case of success, -1 (with errno) in case of error.
-: 913: */
-: 914:int
-: 915:xend_wait_for_devices(virConnectPtr xend, const char *name)
function xend_wait_for_devices called 0 returned 0% blocks executed 0%
#####: 916:{
#####: 917: return xend_op(xend, name, "op", "wait_for_devices", NULL);
call 0 never executed
-: 918:}
-: 919:
-: 920:
-: 921:/**
-: 922: * xend_rename:
-: 923: * @xend: pointer to the Xem Daemon block
-: 924: * @old: old name for the domain
-: 925: * @new: new name for the domain
-: 926: *
-: 927: * Rename the domain
-: 928: *
-: 929: * Returns 0 in case of success, -1 (with errno) in case of error.
-: 930: */
-: 931:int
-: 932:xend_rename(virConnectPtr xend, const char *old, const char *new)
function xend_rename called 0 returned 0% blocks executed 0%
#####: 933:{
#####: 934: if ((xend == NULL) || (old == NULL) || (new == NULL)) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
-: 935: /* this should be caught at the interface but ... */
#####: 936: virXendError(xend, VIR_ERR_INVALID_ARG, __FUNCTION__);
call 0 never executed
#####: 937: return (-1);
-: 938: }
#####: 939: return xend_op(xend, old, "op", "rename", "name", new, NULL);
call 0 never executed
-: 940:}
-: 941:
-: 942:
-: 943:/**
-: 944: * xend_sysrq:
-: 945: * @xend: pointer to the Xem Daemon block
-: 946: * @name: name for the domain
-: 947: * @key: the SysReq key
-: 948: *
-: 949: * Send a SysReq key which is used to debug Linux kernels running in the domain
-: 950: *
-: 951: * Returns 0 in case of success, -1 (with errno) in case of error.
-: 952: */
-: 953:int
-: 954:xend_sysrq(virConnectPtr xend, const char *name, const char *key)
function xend_sysrq called 0 returned 0% blocks executed 0%
#####: 955:{
#####: 956: if ((xend == NULL) || (name == NULL) || (key == NULL)) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
-: 957: /* this should be caught at the interface but ... */
#####: 958: virXendError(xend, VIR_ERR_INVALID_ARG, __FUNCTION__);
call 0 never executed
#####: 959: return (-1);
-: 960: }
#####: 961: return xend_op(xend, name, "op", "sysrq", "key", key, NULL);
call 0 never executed
-: 962:}
-: 963:#endif /* PROXY */
-: 964:
-: 965:
-: 966:/**
-: 967: * xenDaemonListDomainsOld:
-: 968: * @xend: pointer to the Xem Daemon block
-: 969: *
-: 970: * This method will return an array of names of currently running
-: 971: * domains. The memory should be released will a call to free().
-: 972: *
-: 973: * Returns a list of names or NULL in case of error.
-: 974: */
-: 975:char **
-: 976:xenDaemonListDomainsOld(virConnectPtr xend)
function xenDaemonListDomainsOld called 0 returned 0% blocks executed 0%
#####: 977:{
#####: 978: size_t extra = 0;
#####: 979: struct sexpr *root = NULL;
#####: 980: char **ret = NULL;
#####: 981: int count = 0;
-: 982: int i;
-: 983: char *ptr;
-: 984: struct sexpr *_for_i, *node;
-: 985:
#####: 986: root = sexpr_get(xend, "/xend/domain");
call 0 never executed
#####: 987: if (root == NULL)
branch 0 never executed
branch 1 never executed
#####: 988: goto error;
-: 989:
#####: 990: for (_for_i = root, node = root->car; _for_i->kind == SEXPR_CONS;
branch 0 never executed
branch 1 never executed
#####: 991: _for_i = _for_i->cdr, node = _for_i->car) {
#####: 992: if (node->kind != SEXPR_VALUE)
branch 0 never executed
branch 1 never executed
#####: 993: continue;
#####: 994: extra += strlen(node->value) + 1;
call 0 never executed
#####: 995: count++;
-: 996: }
-: 997:
#####: 998: ptr = malloc((count + 1) * sizeof(char *) + extra);
call 0 never executed
#####: 999: if (ptr == NULL)
branch 0 never executed
branch 1 never executed
#####: 1000: goto error;
-: 1001:
#####: 1002: ret = (char **) ptr;
#####: 1003: ptr += sizeof(char *) * (count + 1);
-: 1004:
#####: 1005: i = 0;
#####: 1006: for (_for_i = root, node = root->car; _for_i->kind == SEXPR_CONS;
branch 0 never executed
branch 1 never executed
#####: 1007: _for_i = _for_i->cdr, node = _for_i->car) {
#####: 1008: if (node->kind != SEXPR_VALUE)
branch 0 never executed
branch 1 never executed
#####: 1009: continue;
#####: 1010: ret[i] = ptr;
#####: 1011: strcpy(ptr, node->value);
call 0 never executed
#####: 1012: ptr += strlen(node->value) + 1;
call 0 never executed
#####: 1013: i++;
-: 1014: }
-: 1015:
#####: 1016: ret[i] = NULL;
-: 1017:
#####: 1018: error:
#####: 1019: sexpr_free(root);
call 0 never executed
#####: 1020: return ret;
-: 1021:}
-: 1022:
-: 1023:#ifndef PROXY
-: 1024:/**
-: 1025: * xenDaemonDomainCreateLinux:
-: 1026: * @xend: A xend instance
-: 1027: * @sexpr: An S-Expr description of the domain.
-: 1028: *
-: 1029: * This method will create a domain based the passed in description. The
-: 1030: * domain will be paused after creation and must be unpaused with
-: 1031: * xenDaemonResumeDomain() to begin execution.
-: 1032: * This method may be deprecated once switching to XML-RPC based communcations
-: 1033: * with xend.
-: 1034: *
-: 1035: * Returns 0 for success, -1 (with errno) on error
-: 1036: */
-: 1037:
-: 1038:int
-: 1039:xenDaemonDomainCreateLinux(virConnectPtr xend, const char *sexpr)
function xenDaemonDomainCreateLinux called 0 returned 0% blocks executed 0%
#####: 1040:{
-: 1041: int ret, serrno;
-: 1042: char *ptr;
-: 1043:
#####: 1044: ptr = urlencode(sexpr);
call 0 never executed
#####: 1045: if (ptr == NULL) {
branch 0 never executed
branch 1 never executed
-: 1046: /* this should be caught at the interface but ... */
#####: 1047: virXendError(xend, VIR_ERR_INTERNAL_ERROR,
call 0 never executed
-: 1048: "Failed to urlencode the create S-Expr");
#####: 1049: return (-1);
-: 1050: }
-: 1051:
#####: 1052: ret = xend_op(xend, "", "op", "create", "config", ptr, NULL);
call 0 never executed
-: 1053:
#####: 1054: serrno = errno;
call 0 never executed
#####: 1055: free(ptr);
call 0 never executed
#####: 1056: errno = serrno;
call 0 never executed
-: 1057:
#####: 1058: return ret;
-: 1059:}
-: 1060:#endif /* ! PROXY */
-: 1061:
-: 1062:/**
-: 1063: * xenDaemonDomainLookupByName_ids:
-: 1064: * @xend: A xend instance
-: 1065: * @domname: The name of the domain
-: 1066: * @uuid: return value for the UUID if not NULL
-: 1067: *
-: 1068: * This method looks up the id of a domain
-: 1069: *
-: 1070: * Returns the id on success; -1 (with errno) on error
-: 1071: */
-: 1072:int
-: 1073:xenDaemonDomainLookupByName_ids(virConnectPtr xend, const char *domname,
-: 1074: unsigned char *uuid)
function xenDaemonDomainLookupByName_ids called 0 returned 0% blocks executed 0%
#####: 1075:{
-: 1076: struct sexpr *root;
-: 1077: const char *value;
#####: 1078: int ret = -1;
-: 1079:
#####: 1080: if (uuid != NULL)
branch 0 never executed
branch 1 never executed
#####: 1081: memset(uuid, 0, 16);
call 0 never executed
#####: 1082: root = sexpr_get(xend, "/xend/domain/%s?detail=1", domname);
call 0 never executed
#####: 1083: if (root == NULL)
branch 0 never executed
branch 1 never executed
#####: 1084: goto error;
-: 1085:
#####: 1086: value = sexpr_node(root, "domain/domid");
call 0 never executed
#####: 1087: if (value == NULL) {
branch 0 never executed
branch 1 never executed
#####: 1088: virXendError(xend, VIR_ERR_INTERNAL_ERROR,
call 0 never executed
-: 1089: "domain information incomplete, missing domid");
#####: 1090: goto error;
-: 1091: }
#####: 1092: ret = strtol(value, NULL, 0);
#####: 1093: if ((ret == 0) && (value[0] != '0')) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 1094: virXendError(xend, VIR_ERR_INTERNAL_ERROR,
call 0 never executed
-: 1095: "domain information incorrect domid not numberic");
#####: 1096: ret = -1;
#####: 1097: } else if (uuid != NULL) {
branch 0 never executed
branch 1 never executed
#####: 1098: char **ptr = (char **) &uuid;
-: 1099:
#####: 1100: if (sexpr_uuid(ptr, root, "domain/uuid") == NULL) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 1101: virXendError(xend, VIR_ERR_INTERNAL_ERROR,
call 0 never executed
-: 1102: "domain information incomplete, missing uuid");
-: 1103: }
-: 1104: }
-: 1105:
#####: 1106: error:
#####: 1107: sexpr_free(root);
call 0 never executed
#####: 1108: return (ret);
-: 1109:}
-: 1110:
-: 1111:
-: 1112:/**
-: 1113: * xenDaemonDomainLookupByID:
-: 1114: * @xend: A xend instance
-: 1115: * @id: The id of the domain
-: 1116: * @name: return value for the name if not NULL
-: 1117: * @uuid: return value for the UUID if not NULL
-: 1118: *
-: 1119: * This method looks up the name of a domain based on its id
-: 1120: *
-: 1121: * Returns the 0 on success; -1 (with errno) on error
-: 1122: */
-: 1123:int
-: 1124:xenDaemonDomainLookupByID(virConnectPtr xend,
-: 1125: int id,
-: 1126: char **domname,
-: 1127: unsigned char *uuid)
function xenDaemonDomainLookupByID called 0 returned 0% blocks executed 0%
#####: 1128:{
#####: 1129: const char *name = NULL;
-: 1130: char *dst_uuid;
-: 1131: struct sexpr *root;
-: 1132:
#####: 1133: memset(uuid, 0, 16);
call 0 never executed
-: 1134:
#####: 1135: root = sexpr_get(xend, "/xend/domain/%d?detail=1", id);
call 0 never executed
#####: 1136: if (root == NULL)
branch 0 never executed
branch 1 never executed
#####: 1137: goto error;
-: 1138:
#####: 1139: name = sexpr_node(root, "domain/name");
call 0 never executed
#####: 1140: if (name == NULL) {
branch 0 never executed
branch 1 never executed
#####: 1141: virXendError(xend, VIR_ERR_INTERNAL_ERROR,
call 0 never executed
-: 1142: "domain information incomplete, missing name");
#####: 1143: goto error;
-: 1144: }
#####: 1145: if (domname)
branch 0 never executed
branch 1 never executed
#####: 1146: *domname = strdup(name);
call 0 never executed
-: 1147:
#####: 1148: dst_uuid = (char *)&uuid[0];
#####: 1149: if (sexpr_uuid(&dst_uuid, root, "domain/uuid") == NULL) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 1150: virXendError(xend, VIR_ERR_INTERNAL_ERROR,
call 0 never executed
-: 1151: "domain information incomplete, missing uuid");
#####: 1152: goto error;
-: 1153: }
-: 1154:
#####: 1155: sexpr_free(root);
call 0 never executed
#####: 1156: return (0);
-: 1157:
#####: 1158:error:
#####: 1159: sexpr_free(root);
call 0 never executed
#####: 1160: if (domname && *domname) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 1161: free(*domname);
call 0 never executed
#####: 1162: *domname = NULL;
-: 1163: }
#####: 1164: return (-1);
-: 1165:}
-: 1166:
-: 1167:/**
-: 1168: * xend_get_node:
-: 1169: * @xend: A xend instance
-: 1170: *
-: 1171: * This method returns information about the physical host
-: 1172: * machine running Xen.
-: 1173: *
-: 1174: * Returns node info on success; NULL (with errno) on error
-: 1175: */
-: 1176:struct xend_node *
-: 1177:xend_get_node(virConnectPtr xend)
function xend_get_node called 0 returned 0% blocks executed 0%
#####: 1178:{
-: 1179: struct sexpr *root;
#####: 1180: struct xend_node *node = NULL;
-: 1181: size_t size;
-: 1182: char *ptr;
-: 1183:
#####: 1184: root = sexpr_get(xend, "/xend/node/");
call 0 never executed
#####: 1185: if (root == NULL)
branch 0 never executed
branch 1 never executed
#####: 1186: goto error;
-: 1187:
#####: 1188: size = sizeof(struct xend_node);
#####: 1189: size += sexpr_strlen(root, "node/host");
call 0 never executed
#####: 1190: size += sexpr_strlen(root, "node/release");
call 0 never executed
#####: 1191: size += sexpr_strlen(root, "node/version");
call 0 never executed
#####: 1192: size += sexpr_strlen(root, "node/machine");
call 0 never executed
#####: 1193: size += sexpr_strlen(root, "node/hw_caps");
call 0 never executed
#####: 1194: size += sexpr_strlen(root, "node/xen_caps");
call 0 never executed
#####: 1195: size += sexpr_strlen(root, "node/platform_params");
call 0 never executed
#####: 1196: size += sexpr_strlen(root, "node/xen_changeset");
call 0 never executed
#####: 1197: size += sexpr_strlen(root, "node/cc_compiler");
call 0 never executed
#####: 1198: size += sexpr_strlen(root, "node/cc_compile_by");
call 0 never executed
#####: 1199: size += sexpr_strlen(root, "node/cc_compile_domain");
call 0 never executed
#####: 1200: size += sexpr_strlen(root, "node/cc_compile_date");
call 0 never executed
-: 1201:
#####: 1202: ptr = malloc(size);
call 0 never executed
#####: 1203: if (ptr == NULL)
branch 0 never executed
branch 1 never executed
#####: 1204: goto error;
-: 1205:
#####: 1206: node = (struct xend_node *) ptr;
#####: 1207: ptr += sizeof(struct xend_node);
-: 1208:
#####: 1209: node->system = sexpr_node_system(root, "node/system");
call 0 never executed
#####: 1210: node->host = sexpr_strcpy(&ptr, root, "node/host");
call 0 never executed
#####: 1211: node->release = sexpr_strcpy(&ptr, root, "node/release");
call 0 never executed
#####: 1212: node->version = sexpr_strcpy(&ptr, root, "node/version");
call 0 never executed
#####: 1213: node->machine = sexpr_strcpy(&ptr, root, "node/machine");
call 0 never executed
#####: 1214: node->nr_cpus = sexpr_int(root, "node/nr_cpus");
call 0 never executed
#####: 1215: node->nr_nodes = sexpr_int(root, "node/nr_nodes");
call 0 never executed
#####: 1216: node->sockets_per_node = sexpr_int(root, "node/sockets_per_node");
call 0 never executed
#####: 1217: node->cores_per_socket = sexpr_int(root, "node/cores_per_socket");
call 0 never executed
#####: 1218: node->threads_per_core = sexpr_int(root, "node/threads_per_core");
call 0 never executed
#####: 1219: node->cpu_mhz = sexpr_int(root, "node/cpu_mhz");
call 0 never executed
#####: 1220: node->hw_caps = sexpr_strcpy(&ptr, root, "node/hw_caps");
call 0 never executed
#####: 1221: node->total_memory = sexpr_u64(root, "node/total_memory") << 12;
call 0 never executed
#####: 1222: node->free_memory = sexpr_u64(root, "node/free_memory") << 12;
call 0 never executed
#####: 1223: node->xen_major = sexpr_int(root, "node/xen_major");
call 0 never executed
#####: 1224: node->xen_minor = sexpr_int(root, "node/xen_minor");
call 0 never executed
-: 1225: {
-: 1226: const char *tmp;
-: 1227:
#####: 1228: tmp = sexpr_node(root, "node/xen_extra");
call 0 never executed
#####: 1229: if (tmp) {
branch 0 never executed
branch 1 never executed
#####: 1230: if (*tmp == '.')
branch 0 never executed
branch 1 never executed
#####: 1231: tmp++;
#####: 1232: node->xen_extra = atoi(tmp);
call 0 never executed
-: 1233: } else {
#####: 1234: node->xen_extra = 0;
-: 1235: }
-: 1236: }
#####: 1237: node->xen_caps = sexpr_strcpy(&ptr, root, "node/xen_caps");
call 0 never executed
#####: 1238: node->platform_params =
call 0 never executed
-: 1239: sexpr_strcpy(&ptr, root, "node/platform_params");
#####: 1240: node->xen_changeset = sexpr_strcpy(&ptr, root, "node/xen_changeset");
call 0 never executed
#####: 1241: node->cc_compiler = sexpr_strcpy(&ptr, root, "node/cc_compiler");
call 0 never executed
#####: 1242: node->cc_compile_by = sexpr_strcpy(&ptr, root, "node/cc_compile_by");
call 0 never executed
#####: 1243: node->cc_compile_domain =
call 0 never executed
-: 1244: sexpr_strcpy(&ptr, root, "node/cc_compile_domain");
#####: 1245: node->cc_compile_date =
call 0 never executed
-: 1246: sexpr_strcpy(&ptr, root, "node/cc_compile_date");
-: 1247:
#####: 1248: error:
#####: 1249: sexpr_free(root);
call 0 never executed
#####: 1250: return node;
-: 1251:}
-: 1252:
-: 1253:#ifndef PROXY
-: 1254:/**
-: 1255: * xend_node_shutdown:
-: 1256: * @xend: A xend instance
-: 1257: *
-: 1258: * This method shuts down the physical machine running Xen.
-: 1259: *
-: 1260: * Returns 0 on success; -1 (with errno) on error
-: 1261: */
-: 1262:int
-: 1263:xend_node_shutdown(virConnectPtr xend)
function xend_node_shutdown called 0 returned 0% blocks executed 0%
#####: 1264:{
#####: 1265: return xend_node_op(xend, "/xend/node/", "op", "halt", NULL);
call 0 never executed
-: 1266:}
-: 1267:
-: 1268:/**
-: 1269: * xend_node_restart:
-: 1270: * @xend: A xend instance
-: 1271: *
-: 1272: * This method restarts the physical machine running Xen.
-: 1273: *
-: 1274: * Returns 0 on success; -1 (with errno) on error
-: 1275: */
-: 1276:int
-: 1277:xend_node_restart(virConnectPtr xend)
function xend_node_restart called 0 returned 0% blocks executed 0%
#####: 1278:{
#####: 1279: return xend_node_op(xend, "/xend/node/", "op", "restart", NULL);
call 0 never executed
-: 1280:}
-: 1281:
-: 1282:
-: 1283:/**
-: 1284: * xend_dmesg:
-: 1285: * @xend: A xend instance
-: 1286: * @buffer: A buffer to hold the messages
-: 1287: * @n_buffer: Size of buffer (including null terminator)
-: 1288: *
-: 1289: * This function will place the debugging messages from the
-: 1290: * hypervisor into a buffer with a null terminator.
-: 1291: *
-: 1292: * Returns 0 on success; -1 (with errno) on error
-: 1293: */
-: 1294:int
-: 1295:xend_dmesg(virConnectPtr xend, char *buffer, size_t n_buffer)
function xend_dmesg called 0 returned 0% blocks executed 0%
#####: 1296:{
#####: 1297: return http2unix(xend_get(xend, "/xend/node/dmesg", buffer, n_buffer));
call 0 never executed
call 1 never executed
-: 1298:}
-: 1299:
-: 1300:/**
-: 1301: * xend_dmesg_clear:
-: 1302: * @xend: A xend instance
-: 1303: *
-: 1304: * This function will clear the debugging message ring queue
-: 1305: * in the hypervisor.
-: 1306: *
-: 1307: * Returns 0 on success; -1 (with errno) on error
-: 1308: */
-: 1309:int
-: 1310:xend_dmesg_clear(virConnectPtr xend)
function xend_dmesg_clear called 0 returned 0% blocks executed 0%
#####: 1311:{
#####: 1312: return xend_node_op(xend, "/xend/node/dmesg", "op", "clear", NULL);
call 0 never executed
-: 1313:}
-: 1314:
-: 1315:/**
-: 1316: * xend_log:
-: 1317: * @xend: A xend instance
-: 1318: * @buffer: The buffer to hold the messages
-: 1319: * @n_buffer: Size of buffer (including null terminator)
-: 1320: *
-: 1321: * This function will place the Xend debugging messages into
-: 1322: * a buffer with a null terminator.
-: 1323: *
-: 1324: * Returns 0 on success; -1 (with errno) on error
-: 1325: */
-: 1326:int
-: 1327:xend_log(virConnectPtr xend, char *buffer, size_t n_buffer)
function xend_log called 0 returned 0% blocks executed 0%
#####: 1328:{
#####: 1329: return http2unix(xend_get(xend, "/xend/node/log", buffer, n_buffer));
call 0 never executed
call 1 never executed
-: 1330:}
-: 1331:#endif /* PROXY */
-: 1332:
-: 1333:/*****************************************************************
-: 1334: ******
-: 1335: ******
-: 1336: ******
-: 1337: ******
-: 1338: Needed helper code
-: 1339: ******
-: 1340: ******
-: 1341: ******
-: 1342: ******
-: 1343: *****************************************************************/
-: 1344:
-: 1345:/**
-: 1346: * xend_parse_sexp_desc_os:
-: 1347: * @node: the root of the parsed S-Expression
-: 1348: * @buf: output buffer object
-: 1349: * @hvm: true or 1 if no contains HVM S-Expression
-: 1350: *
-: 1351: * Parse the xend sexp for description of os and append it to buf.
-: 1352: *
-: 1353: * Returns 0 in case of success and -1 in case of error
-: 1354: */
-: 1355:static int
-: 1356:xend_parse_sexp_desc_os(struct sexpr *node, virBufferPtr buf, int hvm)
function xend_parse_sexp_desc_os called 2 returned 100% blocks executed 64%
2: 1357:{
-: 1358: const char *tmp;
-: 1359:
2: 1360: if (node == NULL || buf == NULL) {
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
#####: 1361: return(-1);
-: 1362: }
-: 1363:
2: 1364: virBufferAdd(buf, " <os>\n", 7);
call 0 returned 100%
2: 1365: if (hvm) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
1: 1366: virBufferVSprintf(buf, " <type>hvm</type>\n");
call 0 returned 100%
1: 1367: tmp = sexpr_node(node, "domain/image/hvm/kernel");
call 0 returned 100%
1: 1368: if (tmp == NULL) {
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
#####: 1369: virXendError(NULL, VIR_ERR_INTERNAL_ERROR,
call 0 never executed
-: 1370: "domain information incomplete, missing kernel");
#####: 1371: return(-1);
-: 1372: }
1: 1373: virBufferVSprintf(buf, " <loader>%s</loader>\n", tmp);
call 0 returned 100%
1: 1374: tmp = sexpr_node(node, "domain/image/hvm/boot");
call 0 returned 100%
1: 1375: if ((tmp != NULL) && (tmp[0] != 0)) {
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
branch 2 taken 100% (fallthrough)
branch 3 taken 0%
1: 1376: if (tmp[0] == 'a')
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
-: 1377: /* XXX no way to deal with boot from 2nd floppy */
#####: 1378: virBufferAdd(buf, " <boot dev='fd'/>\n", 21 );
call 0 never executed
1: 1379: else if (tmp[0] == 'c')
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
-: 1380: /*
-: 1381: * Don't know what to put here. Say the vm has been given 3
-: 1382: * disks - hda, hdb, hdc. How does one identify the boot disk?
-: 1383: * We're going to assume that first disk is the boot disk since
-: 1384: * this is most common practice
-: 1385: */
1: 1386: virBufferAdd(buf, " <boot dev='hd'/>\n", 21 );
call 0 returned 100%
#####: 1387: else if (strcmp(tmp, "d") == 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
call 8 never executed
branch 9 never executed
branch 10 never executed
#####: 1388: virBufferAdd(buf, " <boot dev='cdrom'/>\n", 24 );
call 0 never executed
-: 1389: }
-: 1390: } else {
1: 1391: virBufferVSprintf(buf, " <type>linux</type>\n");
call 0 returned 100%
1: 1392: tmp = sexpr_node(node, "domain/image/linux/kernel");
call 0 returned 100%
1: 1393: if (tmp == NULL) {
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
#####: 1394: virXendError(NULL, VIR_ERR_INTERNAL_ERROR,
call 0 never executed
-: 1395: "domain information incomplete, missing kernel");
#####: 1396: return(-1);
-: 1397: }
1: 1398: virBufferVSprintf(buf, " <kernel>%s</kernel>\n", tmp);
call 0 returned 100%
1: 1399: tmp = sexpr_node(node, "domain/image/linux/ramdisk");
call 0 returned 100%
1: 1400: if ((tmp != NULL) && (tmp[0] != 0))
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
branch 2 taken 100% (fallthrough)
branch 3 taken 0%
1: 1401: virBufferVSprintf(buf, " <initrd>%s</initrd>\n", tmp);
call 0 returned 100%
1: 1402: tmp = sexpr_node(node, "domain/image/linux/root");
call 0 returned 100%
1: 1403: if ((tmp != NULL) && (tmp[0] != 0))
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
branch 2 never executed
branch 3 never executed
#####: 1404: virBufferVSprintf(buf, " <root>%s</root>\n", tmp);
call 0 never executed
1: 1405: tmp = sexpr_node(node, "domain/image/linux/args");
call 0 returned 100%
1: 1406: if ((tmp != NULL) && (tmp[0] != 0))
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
branch 2 taken 100% (fallthrough)
branch 3 taken 0%
1: 1407: virBufferVSprintf(buf, " <cmdline>%s</cmdline>\n", tmp);
call 0 returned 100%
-: 1408: }
-: 1409:
2: 1410: virBufferAdd(buf, " </os>\n", 8);
call 0 returned 100%
2: 1411: return(0);
-: 1412:}
-: 1413:
-: 1414:/**
-: 1415: * xend_parse_sexp_desc:
-: 1416: * @domain: the domain associated with the XML
-: 1417: * @root: the root of the parsed S-Expression
-: 1418: *
-: 1419: * Parse the xend sexp description and turn it into the XML format similar
-: 1420: * to the one unsed for creation.
-: 1421: *
-: 1422: * Returns the 0 terminated XML string or NULL in case of error.
-: 1423: * the caller must free() the returned value.
-: 1424: */
-: 1425:static char *
-: 1426:xend_parse_sexp_desc(virConnectPtr conn, struct sexpr *root)
function xend_parse_sexp_desc called 2 returned 100% blocks executed 64%
2: 1427:{
-: 1428: char *ret;
-: 1429: struct sexpr *cur, *node;
-: 1430: const char *tmp;
-: 1431: char *tty;
-: 1432: virBuffer buf;
2: 1433: int hvm = 0;
2: 1434: int domid = -1;
-: 1435:
2: 1436: if (root == NULL) {
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
-: 1437: /* ERROR */
#####: 1438: return (NULL);
-: 1439: }
2: 1440: ret = malloc(4000);
call 0 returned 100%
2: 1441: if (ret == NULL)
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
#####: 1442: return (NULL);
2: 1443: buf.content = ret;
2: 1444: buf.size = 4000;
2: 1445: buf.use = 0;
-: 1446:
2: 1447: domid = sexpr_int(root, "domain/domid");
call 0 returned 100%
2: 1448: virBufferVSprintf(&buf, "<domain type='xen' id='%d'>\n", domid);
call 0 returned 100%
-: 1449:
2: 1450: tmp = sexpr_node(root, "domain/name");
call 0 returned 100%
2: 1451: if (tmp == NULL) {
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
#####: 1452: virXendError(NULL, VIR_ERR_INTERNAL_ERROR,
call 0 never executed
-: 1453: "domain information incomplete, missing name");
#####: 1454: goto error;
-: 1455: }
2: 1456: virBufferVSprintf(&buf, " <name>%s</name>\n", tmp);
call 0 returned 100%
2: 1457: tmp = sexpr_node(root, "domain/uuid");
call 0 returned 100%
2: 1458: if (tmp != NULL) {
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
-: 1459: char compact[33];
-: 1460: int i, j;
66: 1461: for (i = 0, j = 0;(i < 32) && (tmp[j] != 0);j++) {
branch 0 taken 97% (fallthrough)
branch 1 taken 3%
branch 2 taken 100%
branch 3 taken 0% (fallthrough)
64: 1462: if (((tmp[j] >= '0') && (tmp[j] <= '9')) ||
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
-: 1463: ((tmp[j] >= 'a') && (tmp[j] <= 'f')))
64: 1464: compact[i++] = tmp[j];
#####: 1465: else if ((tmp[j] >= 'A') && (tmp[j] <= 'F'))
branch 0 never executed
branch 1 never executed
#####: 1466: compact[i++] = tmp[j] + 'a' - 'A';
-: 1467: }
2: 1468: compact[i] = 0;
2: 1469: if (i > 0)
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
2: 1470: virBufferVSprintf(&buf, " <uuid>%s</uuid>\n", compact);
call 0 returned 100%
-: 1471: }
2: 1472: tmp = sexpr_node(root, "domain/bootloader");
call 0 returned 100%
2: 1473: if (tmp != NULL)
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
#####: 1474: virBufferVSprintf(&buf, " <bootloader>%s</bootloader>\n", tmp);
call 0 never executed
-: 1475:
2: 1476: if (sexpr_lookup(root, "domain/image")) {
call 0 returned 100%
branch 1 taken 100% (fallthrough)
branch 2 taken 0%
2: 1477: hvm = sexpr_lookup(root, "domain/image/hvm") ? 1 : 0;
call 0 returned 100%
2: 1478: xend_parse_sexp_desc_os(root, &buf, hvm);
call 0 returned 100%
-: 1479: }
-: 1480:
2: 1481: virBufferVSprintf(&buf, " <memory>%d</memory>\n",
call 0 returned 100%
call 1 returned 100%
-: 1482: (int) (sexpr_u64(root, "domain/maxmem") << 10));
2: 1483: virBufferVSprintf(&buf, " <vcpu>%d</vcpu>\n",
call 0 returned 100%
call 1 returned 100%
-: 1484: sexpr_int(root, "domain/vcpus"));
2: 1485: tmp = sexpr_node(root, "domain/on_poweroff");
call 0 returned 100%
2: 1486: if (tmp != NULL)
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
2: 1487: virBufferVSprintf(&buf, " <on_poweroff>%s</on_poweroff>\n", tmp);
call 0 returned 100%
2: 1488: tmp = sexpr_node(root, "domain/on_reboot");
call 0 returned 100%
2: 1489: if (tmp != NULL)
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
2: 1490: virBufferVSprintf(&buf, " <on_reboot>%s</on_reboot>\n", tmp);
call 0 returned 100%
2: 1491: tmp = sexpr_node(root, "domain/on_crash");
call 0 returned 100%
2: 1492: if (tmp != NULL)
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
2: 1493: virBufferVSprintf(&buf, " <on_crash>%s</on_crash>\n", tmp);
call 0 returned 100%
-: 1494:
2: 1495: if (hvm) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
1: 1496: virBufferAdd(&buf, " <features>\n", 13);
call 0 returned 100%
1: 1497: if (sexpr_int(root, "domain/image/hvm/acpi"))
call 0 returned 100%
branch 1 taken 100% (fallthrough)
branch 2 taken 0%
1: 1498: virBufferAdd(&buf, " <acpi/>\n", 12);
call 0 returned 100%
1: 1499: if (sexpr_int(root, "domain/image/hvm/apic"))
call 0 returned 100%
branch 1 taken 0% (fallthrough)
branch 2 taken 100%
#####: 1500: virBufferAdd(&buf, " <apic/>\n", 12);
call 0 never executed
1: 1501: if (sexpr_int(root, "domain/image/hvm/pae"))
call 0 returned 100%
branch 1 taken 0% (fallthrough)
branch 2 taken 100%
#####: 1502: virBufferAdd(&buf, " <pae/>\n", 11);
call 0 never executed
1: 1503: virBufferAdd(&buf, " </features>\n", 14);
call 0 returned 100%
-: 1504: }
-: 1505:
2: 1506: virBufferAdd(&buf, " <devices>\n", 12);
call 0 returned 100%
-: 1507:
-: 1508: /* in case of HVM we have devices emulation */
2: 1509: tmp = sexpr_node(root, "domain/image/hvm/device_model");
call 0 returned 100%
2: 1510: if ((tmp != NULL) && (tmp[0] != 0))
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
branch 2 taken 100% (fallthrough)
branch 3 taken 0%
1: 1511: virBufferVSprintf(&buf, " <emulator>%s</emulator>\n", tmp);
call 0 returned 100%
-: 1512:
27: 1513: for (cur = root; cur->kind == SEXPR_CONS; cur = cur->cdr) {
branch 0 taken 93%
branch 1 taken 7% (fallthrough)
25: 1514: node = cur->car;
25: 1515: if (sexpr_lookup(node, "device/vbd")) {
call 0 returned 100%
branch 1 taken 8% (fallthrough)
branch 2 taken 92%
2: 1516: tmp = sexpr_node(node, "device/vbd/uname");
call 0 returned 100%
2: 1517: if (tmp == NULL)
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
#####: 1518: continue;
2: 1519: if (!memcmp(tmp, "file:", 5)) {
call 0 returned 100%
branch 1 taken 100% (fallthrough)
branch 2 taken 0%
2: 1520: tmp += 5;
2: 1521: virBufferVSprintf(&buf, " <disk type='file' device='disk'>\n");
call 0 returned 100%
2: 1522: virBufferVSprintf(&buf, " <source file='%s'/>\n",
call 0 returned 100%
-: 1523: tmp);
2: 1524: tmp = sexpr_node(node, "device/vbd/dev");
call 0 returned 100%
2: 1525: if (tmp == NULL) {
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
#####: 1526: virXendError(NULL, VIR_ERR_INTERNAL_ERROR,
call 0 never executed
-: 1527: "domain information incomplete, vbd has no dev");
#####: 1528: goto error;
-: 1529: }
2: 1530: if (!strncmp(tmp, "ioemu:", 6))
call 0 returned 100%
branch 1 taken 50% (fallthrough)
branch 2 taken 50%
1: 1531: tmp += 6;
2: 1532: virBufferVSprintf(&buf, " <target dev='%s'/>\n", tmp);
call 0 returned 100%
2: 1533: tmp = sexpr_node(node, "device/vbd/mode");
call 0 returned 100%
2: 1534: if ((tmp != NULL) && (!strcmp(tmp, "r")))
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
branch 2 taken 100% (fallthrough)
branch 3 taken 0%
branch 4 taken 0% (fallthrough)
branch 5 taken 100%
branch 6 never executed
branch 7 never executed
branch 8 never executed
branch 9 never executed
call 10 never executed
branch 11 taken 0% (fallthrough)
branch 12 taken 100%
#####: 1535: virBufferVSprintf(&buf, " <readonly/>\n");
call 0 never executed
2: 1536: virBufferAdd(&buf, " </disk>\n", 12);
call 0 returned 100%
#####: 1537: } else if (!memcmp(tmp, "phy:", 4)) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 1538: tmp += 4;
#####: 1539: virBufferVSprintf(&buf, " <disk type='block' device='disk'>\n");
call 0 never executed
#####: 1540: virBufferVSprintf(&buf, " <source dev='%s'/>\n", tmp);
call 0 never executed
#####: 1541: tmp = sexpr_node(node, "device/vbd/dev");
call 0 never executed
#####: 1542: if (tmp == NULL) {
branch 0 never executed
branch 1 never executed
#####: 1543: virXendError(NULL, VIR_ERR_INTERNAL_ERROR,
call 0 never executed
-: 1544: "domain information incomplete, vbd has no dev");
#####: 1545: goto error;
-: 1546: }
#####: 1547: if (!strncmp(tmp, "ioemu:", 6))
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 1548: tmp += 6;
#####: 1549: virBufferVSprintf(&buf, " <target dev='%s'/>\n", tmp);
call 0 never executed
#####: 1550: tmp = sexpr_node(node, "device/vbd/mode");
call 0 never executed
#####: 1551: if ((tmp != NULL) && (!strcmp(tmp, "r")))
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
branch 8 never executed
branch 9 never executed
call 10 never executed
branch 11 never executed
branch 12 never executed
#####: 1552: virBufferVSprintf(&buf, " <readonly/>\n");
call 0 never executed
#####: 1553: virBufferAdd(&buf, " </disk>\n", 12);
call 0 never executed
-: 1554: } else {
-: 1555: char serial[1000];
-: 1556:
#####: 1557: TODO sexpr2string(node, serial, 1000);
call 0 never executed
call 1 never executed
#####: 1558: virBufferVSprintf(&buf, "<!-- Failed to parse %s -->\n",
call 0 never executed
-: 1559: serial);
#####: 1560: TODO}
call 0 never executed
23: 1561: } else if (sexpr_lookup(node, "device/vif")) {
call 0 returned 100%
branch 1 taken 4% (fallthrough)
branch 2 taken 96%
-: 1562: const char *tmp2;
-: 1563:
1: 1564: tmp = sexpr_node(node, "device/vif/bridge");
call 0 returned 100%
1: 1565: tmp2 = sexpr_node(node, "device/vif/script");
call 0 returned 100%
2: 1566: if ((tmp != NULL) || (strstr(tmp2, "bridge"))) {
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
call 2 never executed
branch 3 never executed
branch 4 never executed
1: 1567: virBufferVSprintf(&buf, " <interface type='bridge'>\n");
call 0 returned 100%
1: 1568: if (tmp != NULL)
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
1: 1569: virBufferVSprintf(&buf, " <source bridge='%s'/>\n",
call 0 returned 100%
-: 1570: tmp);
1: 1571: tmp = sexpr_node(node, "device/vif/vifname");
call 0 returned 100%
1: 1572: if (tmp != NULL)
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
#####: 1573: virBufferVSprintf(&buf, " <target dev='%s'/>\n",
call 0 never executed
-: 1574: tmp);
1: 1575: tmp = sexpr_node(node, "device/vif/mac");
call 0 returned 100%
1: 1576: if (tmp != NULL)
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
1: 1577: virBufferVSprintf(&buf, " <mac address='%s'/>\n",
call 0 returned 100%
-: 1578: tmp);
1: 1579: tmp = sexpr_node(node, "device/vif/ip");
call 0 returned 100%
1: 1580: if (tmp != NULL)
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
#####: 1581: virBufferVSprintf(&buf, " <ip address='%s'/>\n",
call 0 never executed
-: 1582: tmp);
1: 1583: if (tmp2 != NULL)
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
1: 1584: virBufferVSprintf(&buf, " <script path='%s'/>\n",
call 0 returned 100%
-: 1585: tmp2);
1: 1586: virBufferAdd(&buf, " </interface>\n", 17);
call 0 returned 100%
-: 1587: } else {
-: 1588: char serial[1000];
-: 1589:
#####: 1590: TODO sexpr2string(node, serial, 1000);
call 0 never executed
call 1 never executed
#####: 1591: virBufferVSprintf(&buf, "<!-- Failed to parse vif: %s -->\n",
call 0 never executed
-: 1592: serial);
-: 1593: }
-: 1594: }
-: 1595: }
-: 1596:
2: 1597: if (hvm) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
1: 1598: tmp = sexpr_node(root, "domain/image/hvm/fda");
call 0 returned 100%
1: 1599: if ((tmp != NULL) && (tmp[0] != 0)) {
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
branch 2 never executed
branch 3 never executed
#####: 1600: virBufferAdd(&buf, " <disk type='file' device='floppy'>\n", 39);
call 0 never executed
#####: 1601: virBufferVSprintf(&buf, " <source file='%s'/>\n", tmp);
call 0 never executed
#####: 1602: virBufferAdd(&buf, " <target dev='fda'/>\n", 26);
call 0 never executed
#####: 1603: virBufferAdd(&buf, " </disk>\n", 12);
call 0 never executed
-: 1604: }
1: 1605: tmp = sexpr_node(root, "domain/image/hvm/fdb");
call 0 returned 100%
1: 1606: if ((tmp != NULL) && (tmp[0] != 0)) {
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
branch 2 never executed
branch 3 never executed
#####: 1607: virBufferAdd(&buf, " <disk type='file' device='floppy'>\n", 39);
call 0 never executed
#####: 1608: virBufferVSprintf(&buf, " <source file='%s'/>\n", tmp);
call 0 never executed
#####: 1609: virBufferAdd(&buf, " <target dev='fdb'/>\n", 26);
call 0 never executed
#####: 1610: virBufferAdd(&buf, " </disk>\n", 12);
call 0 never executed
-: 1611: }
-: 1612: /* XXX new (3.0.3) Xend puts cdrom devs in usual (devices) block */
1: 1613: tmp = sexpr_node(root, "domain/image/hvm/cdrom");
call 0 returned 100%
1: 1614: if ((tmp != NULL) && (tmp[0] != 0)) {
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
branch 2 taken 100% (fallthrough)
branch 3 taken 0%
1: 1615: virBufferAdd(&buf, " <disk type='file' device='cdrom'>\n", 38);
call 0 returned 100%
1: 1616: virBufferVSprintf(&buf, " <source file='%s'/>\n", tmp);
call 0 returned 100%
1: 1617: virBufferAdd(&buf, " <target dev='hdc'/>\n", 26);
call 0 returned 100%
1: 1618: virBufferAdd(&buf, " <readonly/>\n", 18);
call 0 returned 100%
1: 1619: virBufferAdd(&buf, " </disk>\n", 12);
call 0 returned 100%
-: 1620: }
-: 1621:
-: 1622: /* Graphics device */
1: 1623: tmp = sexpr_node(root, "domain/image/hvm/vnc");
call 0 returned 100%
1: 1624: if (tmp != NULL) {
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
1: 1625: if (tmp[0] == '1') {
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
1: 1626: int port = xenStoreDomainGetVNCPort(conn, domid);
call 0 returned 100%
1: 1627: if (port == -1)
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
1: 1628: port = 5900 + domid;
1: 1629: virBufferVSprintf(&buf, " <graphics type='vnc' port='%d'/>\n", port);
call 0 returned 100%
-: 1630: }
-: 1631: }
-: 1632:
1: 1633: tmp = sexpr_node(root, "domain/image/hvm/sdl");
call 0 returned 100%
1: 1634: if (tmp != NULL) {
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
#####: 1635: if (tmp[0] == '1')
branch 0 never executed
branch 1 never executed
#####: 1636: virBufferAdd(&buf, " <graphics type='sdl'/>\n", 27 );
call 0 never executed
-: 1637: }
-: 1638: }
-: 1639:
2: 1640: tty = xenStoreDomainGetConsolePath(conn, domid);
call 0 returned 100%
2: 1641: if (tty) {
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
#####: 1642: virBufferVSprintf(&buf, " <console tty='%s'/>\n", tty);
call 0 never executed
#####: 1643: free(tty);
call 0 never executed
-: 1644: }
-: 1645:
2: 1646: virBufferAdd(&buf, " </devices>\n", 13);
call 0 returned 100%
2: 1647: virBufferAdd(&buf, "</domain>\n", 10);
call 0 returned 100%
-: 1648:
2: 1649: buf.content[buf.use] = 0;
2: 1650: return (ret);
-: 1651:
#####: 1652: error:
#####: 1653: if (ret != NULL)
branch 0 never executed
branch 1 never executed
#####: 1654: free(ret);
call 0 never executed
#####: 1655: return (NULL);
-: 1656:}
-: 1657:
-: 1658:char *
function xend_parse_domain_sexp called 2 returned 100% blocks executed 86%
2: 1659:xend_parse_domain_sexp(virConnectPtr conn, char *sexpr) {
2: 1660: struct sexpr *root = string2sexpr(sexpr);
call 0 returned 100%
-: 1661: char *data;
-: 1662:
2: 1663: if (!root)
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
#####: 1664: return NULL;
-: 1665:
2: 1666: data = xend_parse_sexp_desc(conn, root);
call 0 returned 100%
-: 1667:
2: 1668: sexpr_free(root);
call 0 returned 100%
-: 1669:
2: 1670: return data;
-: 1671:}
-: 1672:
-: 1673:/**
-: 1674: * sexpr_to_xend_domain_info:
-: 1675: * @root: an S-Expression describing a domain
-: 1676: * @info: a info data structure to fill=up
-: 1677: *
-: 1678: * Internal routine filling up the info structure with the values from
-: 1679: * the domain root provided.
-: 1680: *
-: 1681: * Returns 0 in case of success, -1 in case of error
-: 1682: */
-: 1683:static int
-: 1684:sexpr_to_xend_domain_info(struct sexpr *root, virDomainInfoPtr info)
function sexpr_to_xend_domain_info called 0 returned 0% blocks executed 0%
#####: 1685:{
-: 1686: const char *flags;
-: 1687:
-: 1688:
#####: 1689: if ((root == NULL) || (info == NULL))
branch 0 never executed
branch 1 never executed
#####: 1690: return (-1);
-: 1691:
#####: 1692: info->memory = sexpr_u64(root, "domain/memory") << 10;
call 0 never executed
#####: 1693: info->maxMem = sexpr_u64(root, "domain/maxmem") << 10;
call 0 never executed
#####: 1694: flags = sexpr_node(root, "domain/state");
call 0 never executed
-: 1695:
#####: 1696: if (flags) {
branch 0 never executed
branch 1 never executed
#####: 1697: if (strchr(flags, 'c'))
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 1698: info->state = VIR_DOMAIN_CRASHED;
#####: 1699: else if (strchr(flags, 's'))
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 1700: info->state = VIR_DOMAIN_SHUTDOWN;
#####: 1701: else if (strchr(flags, 'd'))
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 1702: info->state = VIR_DOMAIN_SHUTOFF;
#####: 1703: else if (strchr(flags, 'p'))
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 1704: info->state = VIR_DOMAIN_PAUSED;
#####: 1705: else if (strchr(flags, 'b'))
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 1706: info->state = VIR_DOMAIN_BLOCKED;
#####: 1707: else if (strchr(flags, 'r'))
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 1708: info->state = VIR_DOMAIN_RUNNING;
-: 1709: } else {
#####: 1710: info->state = VIR_DOMAIN_NOSTATE;
-: 1711: }
#####: 1712: info->cpuTime = sexpr_float(root, "domain/cpu_time") * 1000000000;
call 0 never executed
#####: 1713: info->nrVirtCpu = sexpr_int(root, "domain/vcpus");
call 0 never executed
#####: 1714: return (0);
-: 1715:}
-: 1716:
-: 1717:/**
-: 1718: * sexpr_to_xend_node_info:
-: 1719: * @root: an S-Expression describing a domain
-: 1720: * @info: a info data structure to fill up
-: 1721: *
-: 1722: * Internal routine filling up the info structure with the values from
-: 1723: * the node root provided.
-: 1724: *
-: 1725: * Returns 0 in case of success, -1 in case of error
-: 1726: */
-: 1727:static int
-: 1728:sexpr_to_xend_node_info(struct sexpr *root, virNodeInfoPtr info)
function sexpr_to_xend_node_info called 0 returned 0% blocks executed 0%
#####: 1729:{
-: 1730: const char *machine;
-: 1731:
-: 1732:
#####: 1733: if ((root == NULL) || (info == NULL))
branch 0 never executed
branch 1 never executed
#####: 1734: return (-1);
-: 1735:
#####: 1736: machine = sexpr_node(root, "node/machine");
call 0 never executed
#####: 1737: if (machine == NULL)
branch 0 never executed
branch 1 never executed
#####: 1738: info->model[0] = 0;
-: 1739: else {
#####: 1740: snprintf(&info->model[0], sizeof(info->model) - 1, "%s", machine);
call 0 never executed
#####: 1741: info->model[sizeof(info->model) - 1] = 0;
-: 1742: }
#####: 1743: info->memory = (unsigned long) sexpr_u64(root, "node/total_memory") << 10;
call 0 never executed
-: 1744:
#####: 1745: info->cpus = sexpr_int(root, "node/nr_cpus");
call 0 never executed
#####: 1746: info->mhz = sexpr_int(root, "node/cpu_mhz");
call 0 never executed
#####: 1747: info->nodes = sexpr_int(root, "node/nr_nodes");
call 0 never executed
#####: 1748: info->sockets = sexpr_int(root, "node/sockets_per_node");
call 0 never executed
#####: 1749: info->cores = sexpr_int(root, "node/cores_per_socket");
call 0 never executed
#####: 1750: info->threads = sexpr_int(root, "node/threads_per_core");
call 0 never executed
#####: 1751: return (0);
-: 1752:}
-: 1753:
-: 1754:#ifndef PROXY
-: 1755:/**
-: 1756: * sexpr_to_domain:
-: 1757: * @conn: an existing virtual connection block
-: 1758: * @root: an S-Expression describing a domain
-: 1759: *
-: 1760: * Internal routine returning the associated virDomainPtr for this domain
-: 1761: *
-: 1762: * Returns the domain pointer or NULL in case of error.
-: 1763: */
-: 1764:static virDomainPtr
-: 1765:sexpr_to_domain(virConnectPtr conn, struct sexpr *root)
function sexpr_to_domain called 0 returned 0% blocks executed 0%
#####: 1766:{
#####: 1767: virDomainPtr ret = NULL;
#####: 1768: char *dst_uuid = NULL;
-: 1769: char uuid[16];
-: 1770: const char *name;
-: 1771:
#####: 1772: if ((conn == NULL) || (root == NULL))
branch 0 never executed
branch 1 never executed
#####: 1773: return(NULL);
-: 1774:
#####: 1775: dst_uuid = (char *) &uuid[0];
#####: 1776: if (sexpr_uuid(&dst_uuid, root, "domain/uuid") == NULL)
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 1777: goto error;
#####: 1778: name = sexpr_node(root, "domain/name");
call 0 never executed
#####: 1779: if (name == NULL)
branch 0 never executed
branch 1 never executed
#####: 1780: goto error;
-: 1781:
#####: 1782: ret = virGetDomain(conn, name, (const unsigned char *) &uuid[0]);
call 0 never executed
#####: 1783: if (ret == NULL) {
branch 0 never executed
branch 1 never executed
#####: 1784: virXendError(conn, VIR_ERR_NO_MEMORY, "Allocating domain");
call 0 never executed
#####: 1785: return(NULL);
-: 1786: }
#####: 1787: ret->handle = sexpr_int(root, "domain/domid");
call 0 never executed
#####: 1788: if (ret->handle < 0)
branch 0 never executed
branch 1 never executed
#####: 1789: goto error;
-: 1790:
#####: 1791: return (ret);
-: 1792:
#####: 1793:error:
#####: 1794: virXendError(conn, VIR_ERR_INTERNAL_ERROR,
call 0 never executed
-: 1795: "failed to parse Xend domain information");
#####: 1796: if (ret != NULL)
branch 0 never executed
branch 1 never executed
#####: 1797: virFreeDomain(conn, ret);
call 0 never executed
#####: 1798: return(NULL);
-: 1799:}
-: 1800:#endif /* !PROXY */
-: 1801:
-: 1802:/*****************************************************************
-: 1803: ******
-: 1804: ******
-: 1805: ******
-: 1806: ******
-: 1807: Refactored
-: 1808: ******
-: 1809: ******
-: 1810: ******
-: 1811: ******
-: 1812: *****************************************************************/
-: 1813:#ifndef PROXY
-: 1814:/**
-: 1815: * xenDaemonOpen:
-: 1816: * @conn: an existing virtual connection block
-: 1817: * @name: optional argument to select a connection type
-: 1818: * @flags: combination of virDrvOpenFlag(s)
-: 1819: *
-: 1820: * Creates a localhost Xen Daemon connection
-: 1821: * Note: this doesn't try to check if the connection actually works
-: 1822: *
-: 1823: * Returns 0 in case of success, -1 in case of error.
-: 1824: */
-: 1825:int
-: 1826:xenDaemonOpen(virConnectPtr conn, const char *name, int flags)
function xenDaemonOpen called 0 returned 0% blocks executed 0%
#####: 1827:{
#####: 1828: xmlURIPtr uri = NULL;
-: 1829: int ret;
-: 1830: unsigned long version;
-: 1831:
#####: 1832: if ((name == NULL) || (name[0] == 0) || (!strcasecmp(name, "xen"))) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
call 4 never executed
branch 5 never executed
branch 6 never executed
-: 1833: /*
-: 1834: * try first to open the unix socket
-: 1835: */
#####: 1836: ret = xenDaemonOpen_unix(conn, "/var/lib/xend/xend-socket");
call 0 never executed
#####: 1837: if (ret < 0)
branch 0 never executed
branch 1 never executed
#####: 1838: goto try_http;
#####: 1839: ret = xenDaemonGetVersion(conn, &version);
call 0 never executed
#####: 1840: if (ret == 0)
branch 0 never executed
branch 1 never executed
#####: 1841: goto done;
-: 1842:
#####: 1843:try_http:
-: 1844: /*
-: 1845: * try though http on port 8000
-: 1846: */
#####: 1847: ret = xenDaemonOpen_tcp(conn, "localhost", 8000);
call 0 never executed
#####: 1848: if (ret < 0)
branch 0 never executed
branch 1 never executed
#####: 1849: goto failed;
#####: 1850: ret = xenDaemonGetVersion(conn, &version);
call 0 never executed
#####: 1851: if (ret < 0)
branch 0 never executed
branch 1 never executed
#####: 1852: goto failed;
-: 1853: } else {
-: 1854: /*
-: 1855: * We were given a connection name, expected to be an URL
-: 1856: */
#####: 1857: uri = xmlParseURI(name);
call 0 never executed
#####: 1858: if (uri == NULL) {
branch 0 never executed
branch 1 never executed
#####: 1859: if (!(flags & VIR_DRV_OPEN_QUIET))
branch 0 never executed
branch 1 never executed
#####: 1860: virXendError(conn, VIR_ERR_NO_SUPPORT, name);
call 0 never executed
-: 1861: goto failed;
-: 1862: }
-: 1863:
#####: 1864: if (uri->scheme == NULL) {
branch 0 never executed
branch 1 never executed
-: 1865: /* It should be a file access */
#####: 1866: if (uri->path == NULL) {
branch 0 never executed
branch 1 never executed
#####: 1867: if (!(flags & VIR_DRV_OPEN_QUIET))
branch 0 never executed
branch 1 never executed
#####: 1868: virXendError(conn, VIR_ERR_NO_SUPPORT, name);
call 0 never executed
-: 1869: goto failed;
-: 1870: }
#####: 1871: ret = xenDaemonOpen_unix(conn, uri->path);
call 0 never executed
#####: 1872: if (ret < 0)
branch 0 never executed
branch 1 never executed
#####: 1873: goto failed;
-: 1874:
#####: 1875: ret = xenDaemonGetVersion(conn, &version);
call 0 never executed
#####: 1876: if (ret < 0)
branch 0 never executed
branch 1 never executed
#####: 1877: goto failed;
#####: 1878: } else if (!strcasecmp(uri->scheme, "http")) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 1879: ret = xenDaemonOpen_tcp(conn, uri->server, uri->port);
call 0 never executed
#####: 1880: if (ret < 0)
branch 0 never executed
branch 1 never executed
#####: 1881: goto failed;
#####: 1882: ret = xenDaemonGetVersion(conn, &version);
call 0 never executed
#####: 1883: if (ret < 0)
branch 0 never executed
branch 1 never executed
#####: 1884: goto failed;
-: 1885: } else {
#####: 1886: if (!(flags & VIR_DRV_OPEN_QUIET))
branch 0 never executed
branch 1 never executed
#####: 1887: virXendError(conn, VIR_ERR_NO_SUPPORT, name);
call 0 never executed
-: 1888: goto failed;
-: 1889: }
-: 1890: }
-: 1891:
#####: 1892:done:
#####: 1893: if (uri != NULL)
branch 0 never executed
branch 1 never executed
#####: 1894: xmlFreeURI(uri);
call 0 never executed
#####: 1895: return(ret);
#####: 1896:failed:
#####: 1897: if (uri != NULL)
branch 0 never executed
branch 1 never executed
#####: 1898: xmlFreeURI(uri);
call 0 never executed
#####: 1899: return(-1);
-: 1900:}
-: 1901:
-: 1902:
-: 1903:/**
-: 1904: * xenDaemonClose:
-: 1905: * @conn: an existing virtual connection block
-: 1906: *
-: 1907: * This method should be called when a connection to xend instance
-: 1908: * initialized with xenDaemonOpen is no longer needed
-: 1909: * to free the associated resources.
-: 1910: *
-: 1911: * Returns 0 in case of succes, -1 in case of error
-: 1912: */
-: 1913:int
-: 1914:xenDaemonClose(virConnectPtr conn ATTRIBUTE_UNUSED)
function xenDaemonClose called 0 returned 0% blocks executed 0%
#####: 1915:{
#####: 1916: return(0);
-: 1917:}
-: 1918:
-: 1919:/**
-: 1920: * xenDaemonDomainSuspend:
-: 1921: * @domain: pointer to the Domain block
-: 1922: *
-: 1923: * Pause the domain, the domain is not scheduled anymore though its resources
-: 1924: * are preserved. Use xenDaemonDomainResume() to resume execution.
-: 1925: *
-: 1926: * Returns 0 in case of success, -1 (with errno) in case of error.
-: 1927: */
-: 1928:int
-: 1929:xenDaemonDomainSuspend(virDomainPtr domain)
function xenDaemonDomainSuspend called 0 returned 0% blocks executed 0%
#####: 1930:{
#####: 1931: if ((domain == NULL) || (domain->conn == NULL) || (domain->name == 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
#####: 1932: virXendError((domain ? domain->conn : NULL), VIR_ERR_INVALID_ARG,
branch 0 never executed
branch 1 never executed
call 2 never executed
-: 1933: __FUNCTION__);
#####: 1934: return(-1);
-: 1935: }
#####: 1936: return xend_op(domain->conn, domain->name, "op", "pause", NULL);
call 0 never executed
-: 1937:}
-: 1938:
-: 1939:/**
-: 1940: * xenDaemonDomainResume:
-: 1941: * @xend: pointer to the Xem Daemon block
-: 1942: * @name: name for the domain
-: 1943: *
-: 1944: * Resume the domain after xenDaemonDomainSuspend() has been called
-: 1945: *
-: 1946: * Returns 0 in case of success, -1 (with errno) in case of error.
-: 1947: */
-: 1948:int
-: 1949:xenDaemonDomainResume(virDomainPtr domain)
function xenDaemonDomainResume called 0 returned 0% blocks executed 0%
#####: 1950:{
#####: 1951: if ((domain == NULL) || (domain->conn == NULL) || (domain->name == 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
#####: 1952: virXendError((domain ? domain->conn : NULL), VIR_ERR_INVALID_ARG,
branch 0 never executed
branch 1 never executed
call 2 never executed
-: 1953: __FUNCTION__);
#####: 1954: return(-1);
-: 1955: }
#####: 1956: return xend_op(domain->conn, domain->name, "op", "unpause", NULL);
call 0 never executed
-: 1957:}
-: 1958:
-: 1959:/**
-: 1960: * xenDaemonDomainShutdown:
-: 1961: * @domain: pointer to the Domain block
-: 1962: *
-: 1963: * Shutdown the domain, the OS is requested to properly shutdown
-: 1964: * and the domain may ignore it. It will return immediately
-: 1965: * after queuing the request.
-: 1966: *
-: 1967: * Returns 0 in case of success, -1 (with errno) in case of error.
-: 1968: */
-: 1969:int
-: 1970:xenDaemonDomainShutdown(virDomainPtr domain)
function xenDaemonDomainShutdown called 0 returned 0% blocks executed 0%
#####: 1971:{
#####: 1972: if ((domain == NULL) || (domain->conn == NULL) || (domain->name == 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
#####: 1973: virXendError((domain ? domain->conn : NULL), VIR_ERR_INVALID_ARG,
branch 0 never executed
branch 1 never executed
call 2 never executed
-: 1974: __FUNCTION__);
#####: 1975: return(-1);
-: 1976: }
#####: 1977: return xend_op(domain->conn, domain->name, "op", "shutdown", "reason", "halt", NULL);
call 0 never executed
-: 1978:}
-: 1979:
-: 1980:/**
-: 1981: * xenDaemonDomainReboot:
-: 1982: * @domain: pointer to the Domain block
-: 1983: * @flags: extra flags for the reboot operation, not used yet
-: 1984: *
-: 1985: * Reboot the domain, the OS is requested to properly shutdown
-: 1986: * and restart but the domain may ignore it. It will return immediately
-: 1987: * after queuing the request.
-: 1988: *
-: 1989: * Returns 0 in case of success, -1 (with errno) in case of error.
-: 1990: */
-: 1991:int
-: 1992:xenDaemonDomainReboot(virDomainPtr domain, unsigned int flags ATTRIBUTE_UNUSED)
function xenDaemonDomainReboot called 0 returned 0% blocks executed 0%
#####: 1993:{
#####: 1994: if ((domain == NULL) || (domain->conn == NULL) || (domain->name == 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
#####: 1995: virXendError((domain ? domain->conn : NULL), VIR_ERR_INVALID_ARG,
branch 0 never executed
branch 1 never executed
call 2 never executed
-: 1996: __FUNCTION__);
#####: 1997: return(-1);
-: 1998: }
#####: 1999: return xend_op(domain->conn, domain->name, "op", "shutdown", "reason", "reboot", NULL);
call 0 never executed
-: 2000:}
-: 2001:
-: 2002:/**
-: 2003: * xenDaemonDomainDestroy:
-: 2004: * @domain: pointer to the Domain block
-: 2005: *
-: 2006: * Abruptly halt the domain, the OS is not properly shutdown and the
-: 2007: * resources allocated for the domain are immediately freed, mounted
-: 2008: * filesystems will be marked as uncleanly shutdown.
-: 2009: * After calling this function, the domain's status will change to
-: 2010: * dying and will go away completely once all of the resources have been
-: 2011: * unmapped (usually from the backend devices).
-: 2012: *
-: 2013: * Returns 0 in case of success, -1 (with errno) in case of error.
-: 2014: */
-: 2015:int
-: 2016:xenDaemonDomainDestroy(virDomainPtr domain)
function xenDaemonDomainDestroy called 0 returned 0% blocks executed 0%
#####: 2017:{
#####: 2018: if ((domain == NULL) || (domain->conn == NULL) || (domain->name == 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
#####: 2019: virXendError((domain ? domain->conn : NULL), VIR_ERR_INVALID_ARG,
branch 0 never executed
branch 1 never executed
call 2 never executed
-: 2020: __FUNCTION__);
#####: 2021: return(-1);
-: 2022: }
#####: 2023: return xend_op(domain->conn, domain->name, "op", "destroy", NULL);
call 0 never executed
-: 2024:}
-: 2025:
-: 2026:/**
-: 2027: * xenDaemonDomainSave:
-: 2028: * @domain: pointer to the Domain block
-: 2029: * @filename: path for the output file
-: 2030: *
-: 2031: * This method will suspend a domain and save its memory contents to
-: 2032: * a file on disk. Use xenDaemonDomainRestore() to restore a domain after
-: 2033: * saving.
-: 2034: * Note that for remote Xen Daemon the file path will be interpreted in
-: 2035: * the remote host.
-: 2036: *
-: 2037: * Returns 0 in case of success, -1 (with errno) in case of error.
-: 2038: */
-: 2039:int
-: 2040:xenDaemonDomainSave(virDomainPtr domain, const char *filename)
function xenDaemonDomainSave called 0 returned 0% blocks executed 0%
#####: 2041:{
#####: 2042: if ((domain == NULL) || (domain->conn == NULL) || (domain->name == 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
-: 2043: (filename == NULL)) {
#####: 2044: virXendError((domain ? domain->conn : NULL), VIR_ERR_INVALID_ARG,
branch 0 never executed
branch 1 never executed
call 2 never executed
-: 2045: __FUNCTION__);
#####: 2046: return(-1);
-: 2047: }
#####: 2048: return xend_op(domain->conn, domain->name, "op", "save", "file", filename, NULL);
call 0 never executed
-: 2049:}
-: 2050:
-: 2051:/**
-: 2052: * xenDaemonDomainRestore:
-: 2053: * @conn: pointer to the Xem Daemon block
-: 2054: * @filename: path for the output file
-: 2055: *
-: 2056: * This method will restore a domain saved to disk by xenDaemonDomainSave().
-: 2057: * Note that for remote Xen Daemon the file path will be interpreted in
-: 2058: * the remote host.
-: 2059: *
-: 2060: * Returns 0 in case of success, -1 (with errno) in case of error.
-: 2061: */
-: 2062:int
-: 2063:xenDaemonDomainRestore(virConnectPtr conn, const char *filename)
function xenDaemonDomainRestore called 0 returned 0% blocks executed 0%
#####: 2064:{
#####: 2065: if ((conn == NULL) || (filename == NULL)) {
branch 0 never executed
branch 1 never executed
-: 2066: /* this should be caught at the interface but ... */
#####: 2067: virXendError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
call 0 never executed
#####: 2068: return (-1);
-: 2069: }
#####: 2070: return xend_op(conn, "", "op", "restore", "file", filename, NULL);
call 0 never executed
-: 2071:}
-: 2072:#endif /* !PROXY */
-: 2073:
-: 2074:/**
-: 2075: * xenDaemonDomainGetMaxMemory:
-: 2076: * @domain: pointer to the domain block
-: 2077: *
-: 2078: * Ask the Xen Daemon for the maximum memory allowed for a domain
-: 2079: *
-: 2080: * Returns the memory size in kilobytes or 0 in case of error.
-: 2081: */
-: 2082:unsigned long
-: 2083:xenDaemonDomainGetMaxMemory(virDomainPtr domain)
function xenDaemonDomainGetMaxMemory called 0 returned 0% blocks executed 0%
#####: 2084:{
#####: 2085: unsigned long ret = 0;
-: 2086: struct sexpr *root;
-: 2087:
#####: 2088: if ((domain == NULL) || (domain->conn == NULL) || (domain->name == 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
#####: 2089: virXendError((domain ? domain->conn : NULL), VIR_ERR_INVALID_ARG,
branch 0 never executed
branch 1 never executed
call 2 never executed
-: 2090: __FUNCTION__);
#####: 2091: return(-1);
-: 2092: }
-: 2093:
-: 2094: /* can we ask for a subset ? worth it ? */
#####: 2095: root = sexpr_get(domain->conn, "/xend/domain/%s?detail=1", domain->name);
call 0 never executed
#####: 2096: if (root == NULL)
branch 0 never executed
branch 1 never executed
#####: 2097: return(0);
-: 2098:
#####: 2099: ret = (unsigned long) sexpr_u64(root, "domain/memory") << 10;
call 0 never executed
#####: 2100: sexpr_free(root);
call 0 never executed
-: 2101:
#####: 2102: return(ret);
-: 2103:}
-: 2104:
-: 2105:#ifndef PROXY
-: 2106:/**
-: 2107: * xenDaemonDomainSetMaxMemory:
-: 2108: * @domain: pointer to the Domain block
-: 2109: * @memory: The maximum memory in kilobytes
-: 2110: *
-: 2111: * This method will set the maximum amount of memory that can be allocated to
-: 2112: * a domain. Please note that a domain is able to allocate up to this amount
-: 2113: * on its own.
-: 2114: *
-: 2115: * Returns 0 for success; -1 (with errno) on error
-: 2116: */
-: 2117:int
-: 2118:xenDaemonDomainSetMaxMemory(virDomainPtr domain, unsigned long memory)
function xenDaemonDomainSetMaxMemory called 0 returned 0% blocks executed 0%
#####: 2119:{
-: 2120: char buf[1024];
-: 2121:
#####: 2122: if ((domain == NULL) || (domain->conn == NULL) || (domain->name == 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
#####: 2123: virXendError((domain ? domain->conn : NULL), VIR_ERR_INVALID_ARG,
branch 0 never executed
branch 1 never executed
call 2 never executed
-: 2124: __FUNCTION__);
#####: 2125: return(-1);
-: 2126: }
#####: 2127: snprintf(buf, sizeof(buf), "%lu", memory >> 10);
call 0 never executed
#####: 2128: return xend_op(domain->conn, domain->name, "op", "maxmem_set", "memory",
call 0 never executed
-: 2129: buf, NULL);
-: 2130:}
-: 2131:
-: 2132:/**
-: 2133: * xenDaemonDomainSetMemory:
-: 2134: * @domain: pointer to the Domain block
-: 2135: * @memory: The target memory in kilobytes
-: 2136: *
-: 2137: * This method will set a target memory allocation for a given domain and
-: 2138: * request that the guest meet this target. The guest may or may not actually
-: 2139: * achieve this target. When this function returns, it does not signify that
-: 2140: * the domain has actually reached that target.
-: 2141: *
-: 2142: * Memory for a domain can only be allocated up to the maximum memory setting.
-: 2143: * There is no safe guard for allocations that are too small so be careful
-: 2144: * when using this function to reduce a domain's memory usage.
-: 2145: *
-: 2146: * Returns 0 for success; -1 (with errno) on error
-: 2147: */
-: 2148:int
-: 2149:xenDaemonDomainSetMemory(virDomainPtr domain, unsigned long memory)
function xenDaemonDomainSetMemory called 0 returned 0% blocks executed 0%
#####: 2150:{
-: 2151: char buf[1024];
-: 2152:
#####: 2153: if ((domain == NULL) || (domain->conn == NULL) || (domain->name == 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
#####: 2154: virXendError((domain ? domain->conn : NULL), VIR_ERR_INVALID_ARG,
branch 0 never executed
branch 1 never executed
call 2 never executed
-: 2155: __FUNCTION__);
#####: 2156: return(-1);
-: 2157: }
#####: 2158: snprintf(buf, sizeof(buf), "%lu", memory >> 10);
call 0 never executed
#####: 2159: return xend_op(domain->conn, domain->name, "op", "mem_target_set",
call 0 never executed
-: 2160: "target", buf, NULL);
-: 2161:}
-: 2162:
-: 2163:#endif /* ! PROXY */
-: 2164:
-: 2165:char *
-: 2166:xenDaemonDomainDumpXMLByID(virConnectPtr conn, int domid)
function xenDaemonDomainDumpXMLByID called 0 returned 0% blocks executed 0%
#####: 2167:{
#####: 2168: char *ret = NULL;
-: 2169: struct sexpr *root;
-: 2170:
#####: 2171: root = sexpr_get(conn, "/xend/domain/%d?detail=1", domid);
call 0 never executed
#####: 2172: if (root == NULL)
branch 0 never executed
branch 1 never executed
#####: 2173: return (NULL);
-: 2174:
#####: 2175: ret = xend_parse_sexp_desc(conn, root);
call 0 never executed
#####: 2176: sexpr_free(root);
call 0 never executed
-: 2177:
#####: 2178: return (ret);
-: 2179:}
-: 2180:
-: 2181:
-: 2182:#ifndef PROXY
-: 2183:/**
-: 2184: * xenDaemonDomainDumpXML:
-: 2185: * @domain: a domain object
-: 2186: *
-: 2187: * Provide an XML description of the domain.
-: 2188: *
-: 2189: * Returns a 0 terminated UTF-8 encoded XML instance, or NULL in case of error.
-: 2190: * the caller must free() the returned value.
-: 2191: */
-: 2192:char *
-: 2193:xenDaemonDomainDumpXML(virDomainPtr domain, int flags ATTRIBUTE_UNUSED)
function xenDaemonDomainDumpXML called 0 returned 0% blocks executed 0%
#####: 2194:{
#####: 2195: if ((domain == NULL) || (domain->conn == NULL) || (domain->name == 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
#####: 2196: virXendError((domain ? domain->conn : NULL), VIR_ERR_INVALID_ARG,
branch 0 never executed
branch 1 never executed
call 2 never executed
-: 2197: __FUNCTION__);
#####: 2198: return(NULL);
-: 2199: }
-: 2200:
#####: 2201: return xenDaemonDomainDumpXMLByID(domain->conn, domain->handle);
call 0 never executed
-: 2202:}
-: 2203:#endif /* !PROXY */
-: 2204:
-: 2205:/**
-: 2206: * xenDaemonDomainGetInfo:
-: 2207: * @domain: a domain object
-: 2208: * @info: pointer to a virDomainInfo structure allocated by the user
-: 2209: *
-: 2210: * This method looks up information about a domain and update the
-: 2211: * information block provided.
-: 2212: *
-: 2213: * Returns 0 in case of success, -1 in case of error
-: 2214: */
-: 2215:int
-: 2216:xenDaemonDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info)
function xenDaemonDomainGetInfo called 0 returned 0% blocks executed 0%
#####: 2217:{
-: 2218: struct sexpr *root;
-: 2219: int ret;
-: 2220:
#####: 2221: if ((domain == NULL) || (domain->conn == NULL) || (domain->name == 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
-: 2222: (info == NULL)) {
#####: 2223: virXendError((domain ? domain->conn : NULL), VIR_ERR_INVALID_ARG,
branch 0 never executed
branch 1 never executed
call 2 never executed
-: 2224: __FUNCTION__);
#####: 2225: return(-1);
-: 2226: }
-: 2227:
-: 2228:
#####: 2229: root = sexpr_get(domain->conn, "/xend/domain/%s?detail=1", domain->name);
call 0 never executed
#####: 2230: if (root == NULL)
branch 0 never executed
branch 1 never executed
#####: 2231: return (-1);
-: 2232:
#####: 2233: ret = sexpr_to_xend_domain_info(root, info);
call 0 never executed
#####: 2234: sexpr_free(root);
call 0 never executed
#####: 2235: return (ret);
-: 2236:}
-: 2237:
-: 2238:#ifndef PROXY
-: 2239:/**
-: 2240: * xenDaemonDomainLookupByName:
-: 2241: * @conn: A xend instance
-: 2242: * @name: The name of the domain
-: 2243: *
-: 2244: * This method looks up information about a domain and returns
-: 2245: * it in the form of a struct xend_domain. This should be
-: 2246: * free()'d when no longer needed.
-: 2247: *
-: 2248: * Returns domain info on success; NULL (with errno) on error
-: 2249: */
-: 2250:virDomainPtr
-: 2251:xenDaemonDomainLookupByName(virConnectPtr conn, const char *domname)
function xenDaemonDomainLookupByName called 0 returned 0% blocks executed 0%
#####: 2252:{
-: 2253: struct sexpr *root;
#####: 2254: virDomainPtr ret = NULL;
-: 2255:
#####: 2256: if ((conn == NULL) || (domname == NULL)) {
branch 0 never executed
branch 1 never executed
#####: 2257: virXendError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
call 0 never executed
#####: 2258: return(NULL);
-: 2259: }
#####: 2260: root = sexpr_get(conn, "/xend/domain/%s?detail=1", domname);
call 0 never executed
#####: 2261: if (root == NULL)
branch 0 never executed
branch 1 never executed
#####: 2262: goto error;
-: 2263:
#####: 2264: ret = sexpr_to_domain(conn, root);
call 0 never executed
-: 2265:
#####: 2266:error:
#####: 2267: sexpr_free(root);
call 0 never executed
#####: 2268: return(ret);
-: 2269:}
-: 2270:#endif /* ! PROXY */
-: 2271:
-: 2272:/**
-: 2273: * xenDaemonNodeGetInfo:
-: 2274: * @conn: pointer to the Xen Daemon block
-: 2275: * @info: pointer to a virNodeInfo structure allocated by the user
-: 2276: *
-: 2277: * Extract hardware information about the node.
-: 2278: *
-: 2279: * Returns 0 in case of success and -1 in case of failure.
-: 2280: */
-: 2281:int
function xenDaemonNodeGetInfo called 0 returned 0% blocks executed 0%
#####: 2282:xenDaemonNodeGetInfo(virConnectPtr conn, virNodeInfoPtr info) {
#####: 2283: int ret = -1;
-: 2284: struct sexpr *root;
-: 2285:
#####: 2286: if (!VIR_IS_CONNECT(conn)) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 2287: virXendError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__);
call 0 never executed
#####: 2288: return (-1);
-: 2289: }
#####: 2290: if (info == NULL) {
branch 0 never executed
branch 1 never executed
#####: 2291: virXendError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
call 0 never executed
#####: 2292: return (-1);
-: 2293: }
-: 2294:
#####: 2295: root = sexpr_get(conn, "/xend/node/");
call 0 never executed
#####: 2296: if (root == NULL)
branch 0 never executed
branch 1 never executed
#####: 2297: return (-1);
-: 2298:
#####: 2299: ret = sexpr_to_xend_node_info(root, info);
call 0 never executed
#####: 2300: sexpr_free(root);
call 0 never executed
#####: 2301: return (ret);
-: 2302:}
-: 2303:
-: 2304:#ifndef PROXY
-: 2305:/**
-: 2306: * xenDaemonGetType:
-: 2307: * @conn: pointer to the Xen Daemon block
-: 2308: *
-: 2309: * Get the version level of the Hypervisor running.
-: 2310: *
-: 2311: * Returns -1 in case of error, 0 otherwise. if the version can't be
-: 2312: * extracted by lack of capacities returns 0 and @hvVer is 0, otherwise
-: 2313: * @hvVer value is major * 1,000,000 + minor * 1,000 + release
-: 2314: */
-: 2315:static const char *
-: 2316:xenDaemonGetType(virConnectPtr conn)
function xenDaemonGetType called 0 returned 0% blocks executed 0%
#####: 2317:{
#####: 2318: if (!VIR_IS_CONNECT(conn)) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 2319: virXendError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__);
call 0 never executed
#####: 2320: return (NULL);
-: 2321: }
#####: 2322: return("XenDaemon");
-: 2323:}
-: 2324:#endif /* ! PROXY */
-: 2325:
-: 2326:/**
-: 2327: * xenDaemonGetVersion:
-: 2328: * @conn: pointer to the Xen Daemon block
-: 2329: * @hvVer: return value for the version of the running hypervisor (OUT)
-: 2330: *
-: 2331: * Get the version level of the Hypervisor running.
-: 2332: *
-: 2333: * Returns -1 in case of error, 0 otherwise. if the version can't be
-: 2334: * extracted by lack of capacities returns 0 and @hvVer is 0, otherwise
-: 2335: * @hvVer value is major * 1,000,000 + minor * 1,000 + release
-: 2336: */
-: 2337:int
-: 2338:xenDaemonGetVersion(virConnectPtr conn, unsigned long *hvVer)
function xenDaemonGetVersion called 0 returned 0% blocks executed 0%
#####: 2339:{
-: 2340: static unsigned long version = 0;
-: 2341:
#####: 2342: if (!VIR_IS_CONNECT(conn)) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 2343: virXendError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__);
call 0 never executed
#####: 2344: return (-1);
-: 2345: }
#####: 2346: if (hvVer == NULL) {
branch 0 never executed
branch 1 never executed
#####: 2347: virXendError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
call 0 never executed
#####: 2348: return (-1);
-: 2349: }
#####: 2350: if (version == 0) {
branch 0 never executed
branch 1 never executed
-: 2351: struct sexpr *root;
-: 2352: const char *extra;
#####: 2353: int major, minor, release = 0;
-: 2354:
#####: 2355: root = sexpr_get(conn, "/xend/node/");
call 0 never executed
#####: 2356: if (root == NULL)
branch 0 never executed
branch 1 never executed
#####: 2357: return(-1);
-: 2358:
#####: 2359: major = sexpr_int(root, "node/xen_major");
call 0 never executed
#####: 2360: minor = sexpr_int(root, "node/xen_minor");
call 0 never executed
#####: 2361: extra = sexpr_node(root, "node/xen_extra");
call 0 never executed
#####: 2362: if (extra != NULL) {
branch 0 never executed
branch 1 never executed
#####: 2363: while (*extra != 0) {
branch 0 never executed
branch 1 never executed
#####: 2364: if ((*extra >= '0') && (*extra <= '9'))
branch 0 never executed
branch 1 never executed
#####: 2365: release = release * 10 + (*extra - '0');
#####: 2366: extra++;
-: 2367: }
-: 2368: }
#####: 2369: sexpr_free(root);
call 0 never executed
#####: 2370: version = major * 1000000 + minor * 1000 + release;
-: 2371: }
#####: 2372: *hvVer = version;
#####: 2373: return(0);
-: 2374:}
-: 2375:
-: 2376:#ifndef PROXY
-: 2377:/**
-: 2378: * xenDaemonListDomains:
-: 2379: * @conn: pointer to the hypervisor connection
-: 2380: * @ids: array to collect the list of IDs of active domains
-: 2381: * @maxids: size of @ids
-: 2382: *
-: 2383: * Collect the list of active domains, and store their ID in @maxids
-: 2384: * TODO: this is quite expensive at the moment since there isn't one
-: 2385: * xend RPC providing both name and id for all domains.
-: 2386: *
-: 2387: * Returns the number of domain found or -1 in case of error
-: 2388: */
-: 2389:static int
-: 2390:xenDaemonListDomains(virConnectPtr conn, int *ids, int maxids)
function xenDaemonListDomains called 0 returned 0% blocks executed 0%
#####: 2391:{
#####: 2392: struct sexpr *root = NULL;
#####: 2393: int ret = -1;
-: 2394: struct sexpr *_for_i, *node;
-: 2395: long id;
-: 2396:
#####: 2397: if ((ids == NULL) || (maxids <= 0))
branch 0 never executed
branch 1 never executed
#####: 2398: goto error;
#####: 2399: root = sexpr_get(conn, "/xend/domain");
call 0 never executed
#####: 2400: if (root == NULL)
branch 0 never executed
branch 1 never executed
#####: 2401: goto error;
-: 2402:
#####: 2403: ret = 0;
-: 2404:
#####: 2405: for (_for_i = root, node = root->car; _for_i->kind == SEXPR_CONS;
branch 0 never executed
branch 1 never executed
#####: 2406: _for_i = _for_i->cdr, node = _for_i->car) {
#####: 2407: if (node->kind != SEXPR_VALUE)
branch 0 never executed
branch 1 never executed
#####: 2408: continue;
#####: 2409: id = xenDaemonDomainLookupByName_ids(conn, node->value, NULL);
call 0 never executed
#####: 2410: if (id >= 0)
branch 0 never executed
branch 1 never executed
#####: 2411: ids[ret++] = (int) id;
-: 2412: }
-: 2413:
#####: 2414:error:
#####: 2415: if (root != NULL)
branch 0 never executed
branch 1 never executed
#####: 2416: sexpr_free(root);
call 0 never executed
#####: 2417: return(ret);
-: 2418:}
-: 2419:
-: 2420:/**
-: 2421: * xenDaemonNumOfDomains:
-: 2422: * @conn: pointer to the hypervisor connection
-: 2423: *
-: 2424: * Provides the number of active domains.
-: 2425: *
-: 2426: * Returns the number of domain found or -1 in case of error
-: 2427: */
-: 2428:static int
-: 2429:xenDaemonNumOfDomains(virConnectPtr conn)
function xenDaemonNumOfDomains called 0 returned 0% blocks executed 0%
#####: 2430:{
#####: 2431: struct sexpr *root = NULL;
#####: 2432: int ret = -1;
-: 2433: struct sexpr *_for_i, *node;
-: 2434:
#####: 2435: root = sexpr_get(conn, "/xend/domain");
call 0 never executed
#####: 2436: if (root == NULL)
branch 0 never executed
branch 1 never executed
#####: 2437: goto error;
-: 2438:
#####: 2439: ret = 0;
-: 2440:
#####: 2441: for (_for_i = root, node = root->car; _for_i->kind == SEXPR_CONS;
branch 0 never executed
branch 1 never executed
#####: 2442: _for_i = _for_i->cdr, node = _for_i->car) {
#####: 2443: if (node->kind != SEXPR_VALUE)
branch 0 never executed
branch 1 never executed
#####: 2444: continue;
#####: 2445: ret++;
-: 2446: }
-: 2447:
#####: 2448:error:
#####: 2449: if (root != NULL)
branch 0 never executed
branch 1 never executed
#####: 2450: sexpr_free(root);
call 0 never executed
#####: 2451: return(ret);
-: 2452:}
-: 2453:#endif /* ! PROXY */
-: 2454:
-: 2455:#ifndef PROXY
-: 2456:/**
-: 2457: * xenDaemonLookupByID:
-: 2458: * @conn: pointer to the hypervisor connection
-: 2459: * @id: the domain ID number
-: 2460: *
-: 2461: * Try to find a domain based on the hypervisor ID number
-: 2462: *
-: 2463: * Returns a new domain object or NULL in case of failure
-: 2464: */
-: 2465:static virDomainPtr
function xenDaemonLookupByID called 0 returned 0% blocks executed 0%
#####: 2466:xenDaemonLookupByID(virConnectPtr conn, int id) {
#####: 2467: char *name = NULL;
-: 2468: unsigned char uuid[16];
-: 2469: virDomainPtr ret;
-: 2470:
#####: 2471: if (xenDaemonDomainLookupByID(conn, id, &name, uuid) < 0) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 2472: goto error;
-: 2473: }
-: 2474:
#####: 2475: ret = virGetDomain(conn, name, uuid);
call 0 never executed
#####: 2476: if (ret == NULL) {
branch 0 never executed
branch 1 never executed
#####: 2477: virXendError(conn, VIR_ERR_NO_MEMORY, "Allocating domain");
call 0 never executed
#####: 2478: goto error;
-: 2479: }
#####: 2480: ret->handle = id;
#####: 2481: free(name);
call 0 never executed
#####: 2482: return (ret);
-: 2483:
#####: 2484: error:
#####: 2485: if (name != NULL)
branch 0 never executed
branch 1 never executed
#####: 2486: free(name);
call 0 never executed
#####: 2487: return (NULL);
-: 2488:}
-: 2489:
-: 2490:/**
-: 2491: * xenDaemonDomainSetVcpus:
-: 2492: * @domain: pointer to domain object
-: 2493: * @nvcpus: the new number of virtual CPUs for this domain
-: 2494: *
-: 2495: * Dynamically change the number of virtual CPUs used by the domain.
-: 2496: *
-: 2497: * Returns 0 for success; -1 (with errno) on error
-: 2498: */
-: 2499:int
-: 2500:xenDaemonDomainSetVcpus(virDomainPtr domain, unsigned int vcpus)
function xenDaemonDomainSetVcpus called 0 returned 0% blocks executed 0%
#####: 2501:{
-: 2502: char buf[16];
-: 2503:
#####: 2504: if ((domain == NULL) || (domain->conn == NULL) || (domain->name == 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
-: 2505: || (vcpus < 1)) {
#####: 2506: virXendError((domain ? domain->conn : NULL), VIR_ERR_INVALID_ARG,
branch 0 never executed
branch 1 never executed
call 2 never executed
-: 2507: __FUNCTION__);
#####: 2508: return (-1);
-: 2509: }
#####: 2510: snprintf(buf, sizeof(buf), "%d", vcpus);
call 0 never executed
#####: 2511: return(xend_op(domain->conn, domain->name, "op", "set_vcpus", "vcpus",
call 0 never executed
-: 2512: buf, NULL));
-: 2513:}
-: 2514:
-: 2515:/**
-: 2516: * xenDaemonDomainPinCpu:
-: 2517: * @domain: pointer to domain object
-: 2518: * @vcpu: virtual CPU number
-: 2519: * @cpumap: pointer to a bit map of real CPUs (in 8-bit bytes)
-: 2520: * @maplen: length of cpumap in bytes
-: 2521: *
-: 2522: * Dynamically change the real CPUs which can be allocated to a virtual CPU.
-: 2523: *
-: 2524: * Returns 0 for success; -1 (with errno) on error
-: 2525: */
-: 2526:int
-: 2527:xenDaemonDomainPinVcpu(virDomainPtr domain, unsigned int vcpu,
-: 2528: unsigned char *cpumap, int maplen)
function xenDaemonDomainPinVcpu called 0 returned 0% blocks executed 0%
#####: 2529:{
#####: 2530: char buf[16], mapstr[sizeof(cpumap_t) * 64] = "[";
-: 2531: int i, j;
-: 2532:
#####: 2533: if ((domain == NULL) || (domain->conn == NULL) || (domain->name == 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
-: 2534: || (cpumap == NULL) || (maplen < 1) || (maplen > (int)sizeof(cpumap_t))) {
#####: 2535: virXendError((domain ? domain->conn : NULL), VIR_ERR_INVALID_ARG,
branch 0 never executed
branch 1 never executed
call 2 never executed
-: 2536: __FUNCTION__);
#####: 2537: return (-1);
-: 2538: }
-: 2539:
-: 2540: /* from bit map, build character string of mapped CPU numbers */
#####: 2541: for (i = 0; i < maplen; i++) for (j = 0; j < 8; j++)
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 2542: if (cpumap[i] & (1 << j)) {
branch 0 never executed
branch 1 never executed
#####: 2543: sprintf(buf, "%d,", (8 * i) + j);
call 0 never executed
#####: 2544: strcat(mapstr, buf);
call 0 never executed
-: 2545: }
#####: 2546: mapstr[strlen(mapstr) - 1] = ']';
call 0 never executed
#####: 2547: snprintf(buf, sizeof(buf), "%d", vcpu);
call 0 never executed
#####: 2548: return(xend_op(domain->conn, domain->name, "op", "pincpu", "vcpu", buf,
call 0 never executed
-: 2549: "cpumap", mapstr, NULL));
-: 2550:}
-: 2551:
-: 2552:/**
-: 2553: * virDomainGetVcpus:
-: 2554: * @domain: pointer to domain object, or NULL for Domain0
-: 2555: * @info: pointer to an array of virVcpuInfo structures (OUT)
-: 2556: * @maxinfo: number of structures in info array
-: 2557: * @cpumaps: pointer to an bit map of real CPUs for all vcpus of this domain (in 8-bit bytes) (OUT)
-: 2558: * If cpumaps is NULL, then no cupmap information is returned by the API.
-: 2559: * It's assumed there is <maxinfo> cpumap in cpumaps array.
-: 2560: * The memory allocated to cpumaps must be (maxinfo * maplen) bytes
-: 2561: * (ie: calloc(maxinfo, maplen)).
-: 2562: * One cpumap inside cpumaps has the format described in virDomainPinVcpu() API.
-: 2563: * @maplen: number of bytes in one cpumap, from 1 up to size of CPU map in
-: 2564: * underlying virtualization system (Xen...).
-: 2565: *
-: 2566: * Extract information about virtual CPUs of domain, store it in info array
-: 2567: * and also in cpumaps if this pointer is'nt NULL.
-: 2568: *
-: 2569: * Returns the number of info filled in case of success, -1 in case of failure.
-: 2570: */
-: 2571:int
-: 2572:xenDaemonDomainGetVcpus(virDomainPtr domain, virVcpuInfoPtr info, int maxinfo,
-: 2573: unsigned char *cpumaps, int maplen)
function xenDaemonDomainGetVcpus called 0 returned 0% blocks executed 0%
#####: 2574:{
-: 2575: struct sexpr *root, *s, *t;
#####: 2576: virVcpuInfoPtr ipt = info;
#####: 2577: int nbinfo = 0, oln;
-: 2578: unsigned char *cpumap;
-: 2579: int vcpu, cpu;
-: 2580:
#####: 2581: if ((domain == NULL) || (domain->conn == NULL) || (domain->name == 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
-: 2582: || (info == NULL) || (maxinfo < 1)) {
#####: 2583: virXendError((domain ? domain->conn : NULL), VIR_ERR_INVALID_ARG,
branch 0 never executed
branch 1 never executed
call 2 never executed
-: 2584: __FUNCTION__);
#####: 2585: return (-1);
-: 2586: }
#####: 2587: if (cpumaps != NULL && maplen < 1) {
branch 0 never executed
branch 1 never executed
#####: 2588: virXendError((domain ? domain->conn : NULL), VIR_ERR_INVALID_ARG,
branch 0 never executed
branch 1 never executed
call 2 never executed
-: 2589: __FUNCTION__);
#####: 2590: return (-1);
-: 2591: }
#####: 2592: root = sexpr_get(domain->conn, "/xend/domain/%s?op=vcpuinfo", domain->name);
call 0 never executed
#####: 2593: if (root == NULL)
branch 0 never executed
branch 1 never executed
#####: 2594: return (-1);
-: 2595:
#####: 2596: if (cpumaps != NULL)
branch 0 never executed
branch 1 never executed
#####: 2597: memset(cpumaps, 0, maxinfo * maplen);
call 0 never executed
-: 2598:
-: 2599: /* scan the sexprs from "(vcpu (number x)...)" and get parameter values */
#####: 2600: for (s = root; s->kind == SEXPR_CONS; s = s->cdr)
branch 0 never executed
branch 1 never executed
#####: 2601: if ((s->car->kind == SEXPR_CONS) &&
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
branch 4 never executed
branch 5 never executed
-: 2602: (s->car->car->kind == SEXPR_VALUE) &&
#####: 2603: !strcmp(s->car->car->value, "vcpu")) {
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
call 8 never executed
#####: 2604: t = s->car;
#####: 2605: vcpu = ipt->number = sexpr_int(t, "vcpu/number");
call 0 never executed
#####: 2606: if ((oln = sexpr_int(t, "vcpu/online")) != 0) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 2607: if (sexpr_int(t, "vcpu/running")) ipt->state = VIR_VCPU_RUNNING;
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 2608: if (sexpr_int(t, "vcpu/blocked")) ipt->state = VIR_VCPU_BLOCKED;
call 0 never executed
branch 1 never executed
branch 2 never executed
-: 2609: }
#####: 2610: else ipt->state = VIR_VCPU_OFFLINE;
#####: 2611: ipt->cpuTime = sexpr_float(t, "vcpu/cpu_time") * 1000000000;
call 0 never executed
#####: 2612: ipt->cpu = oln ? sexpr_int(t, "vcpu/cpu") : -1;
branch 0 never executed
branch 1 never executed
call 2 never executed
-: 2613:
#####: 2614: if (cpumaps != NULL && vcpu >= 0 && vcpu < maxinfo) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 2615: cpumap = (unsigned char *) VIR_GET_CPUMAP(cpumaps, maplen, vcpu);
-: 2616: /*
-: 2617: * get sexpr from "(cpumap (x y z...))" and convert values
-: 2618: * to bitmap
-: 2619: */
#####: 2620: for (t = t->cdr; t->kind == SEXPR_CONS; t = t->cdr)
branch 0 never executed
branch 1 never executed
#####: 2621: if ((t->car->kind == SEXPR_CONS) &&
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
-: 2622: (t->car->car->kind == SEXPR_VALUE) &&
#####: 2623: !strcmp(t->car->car->value, "cpumap") &&
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
call 8 never executed
-: 2624: (t->car->cdr->kind == SEXPR_CONS)) {
#####: 2625: for (t = t->car->cdr->car; t->kind == SEXPR_CONS; t = t->cdr)
branch 0 never executed
branch 1 never executed
#####: 2626: if (t->car->kind == SEXPR_VALUE) {
branch 0 never executed
branch 1 never executed
#####: 2627: cpu = strtol(t->car->value, NULL, 0);
call 0 never executed
#####: 2628: if (cpu >= 0)
branch 0 never executed
branch 1 never executed
#####: 2629: VIR_USE_CPU(cpumap, cpu);
-: 2630: }
-: 2631: break;
-: 2632: }
-: 2633: }
-: 2634:
#####: 2635: if (++nbinfo == maxinfo) break;
branch 0 never executed
branch 1 never executed
#####: 2636: ipt++;
-: 2637: }
#####: 2638: sexpr_free(root);
call 0 never executed
#####: 2639: return(nbinfo);
-: 2640:}
-: 2641:
-: 2642:/**
-: 2643: * xenDaemonLookupByUUID:
-: 2644: * @conn: pointer to the hypervisor connection
-: 2645: * @uuid: the raw UUID for the domain
-: 2646: *
-: 2647: * Try to lookup a domain on xend based on its UUID.
-: 2648: *
-: 2649: * Returns a new domain object or NULL in case of failure
-: 2650: */
-: 2651:static virDomainPtr
-: 2652:xenDaemonLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
function xenDaemonLookupByUUID called 0 returned 0% blocks executed 0%
#####: 2653:{
-: 2654: virDomainPtr ret;
#####: 2655: char *name = NULL;
-: 2656: char **names;
-: 2657: char **tmp;
-: 2658: unsigned char ident[16];
#####: 2659: int id = -1;
-: 2660:
#####: 2661: names = xenDaemonListDomainsOld(conn);
call 0 never executed
#####: 2662: tmp = names;
-: 2663:
#####: 2664: if (names == NULL) {
branch 0 never executed
branch 1 never executed
#####: 2665: TODO /* try to fallback to xenstore lookup */
call 0 never executed
#####: 2666: return (NULL);
-: 2667: }
#####: 2668: while (*tmp != NULL) {
branch 0 never executed
branch 1 never executed
#####: 2669: id = xenDaemonDomainLookupByName_ids(conn, *tmp, &ident[0]);
call 0 never executed
#####: 2670: if (id >= 0) {
branch 0 never executed
branch 1 never executed
#####: 2671: if (!memcmp(uuid, ident, 16)) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 2672: name = strdup(*tmp);
call 0 never executed
#####: 2673: break;
-: 2674: }
-: 2675: }
#####: 2676: tmp++;
-: 2677: }
#####: 2678: free(names);
call 0 never executed
-: 2679:
#####: 2680: if (name == NULL)
branch 0 never executed
branch 1 never executed
#####: 2681: goto error;
-: 2682:
#####: 2683: ret = virGetDomain(conn, name, uuid);
call 0 never executed
#####: 2684: if (ret == NULL) {
branch 0 never executed
branch 1 never executed
#####: 2685: virXendError(conn, VIR_ERR_NO_MEMORY, "Allocating domain");
call 0 never executed
#####: 2686: goto error;
-: 2687: }
#####: 2688: ret->handle = id;
#####: 2689: if (name != NULL)
branch 0 never executed
branch 1 never executed
#####: 2690: free(name);
call 0 never executed
#####: 2691: return (ret);
-: 2692:
#####: 2693:error:
#####: 2694: if (name != NULL)
branch 0 never executed
branch 1 never executed
#####: 2695: free(name);
call 0 never executed
#####: 2696: return (NULL);
-: 2697:}
-: 2698:
-: 2699:/**
-: 2700: * xenDaemonCreateLinux:
-: 2701: * @conn: pointer to the hypervisor connection
-: 2702: * @xmlDesc: an XML description of the domain
-: 2703: * @flags: an optional set of virDomainFlags
-: 2704: *
-: 2705: * Launch a new Linux guest domain, based on an XML description similar
-: 2706: * to the one returned by virDomainGetXMLDesc()
-: 2707: * This function may requires priviledged access to the hypervisor.
-: 2708: *
-: 2709: * Returns a new domain object or NULL in case of failure
-: 2710: */
-: 2711:static virDomainPtr
-: 2712:xenDaemonCreateLinux(virConnectPtr conn, const char *xmlDesc,
-: 2713: unsigned int flags ATTRIBUTE_UNUSED)
function xenDaemonCreateLinux called 0 returned 0% blocks executed 0%
#####: 2714:{
-: 2715: int ret;
-: 2716: char *sexpr;
#####: 2717: char *name = NULL;
-: 2718: virDomainPtr dom;
-: 2719:
#####: 2720: if (!VIR_IS_CONNECT(conn)) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 2721: virXendError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__);
call 0 never executed
#####: 2722: return (NULL);
-: 2723: }
#####: 2724: if (xmlDesc == NULL) {
branch 0 never executed
branch 1 never executed
#####: 2725: virXendError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
call 0 never executed
#####: 2726: return (NULL);
-: 2727: }
-: 2728:
#####: 2729: sexpr = virDomainParseXMLDesc(xmlDesc, &name);
call 0 never executed
#####: 2730: if ((sexpr == NULL) || (name == NULL)) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 2731: if (sexpr != NULL)
branch 0 never executed
branch 1 never executed
#####: 2732: free(sexpr);
call 0 never executed
#####: 2733: if (name != NULL)
branch 0 never executed
branch 1 never executed
#####: 2734: free(name);
call 0 never executed
-: 2735:
#####: 2736: return (NULL);
-: 2737: }
-: 2738:
#####: 2739: ret = xenDaemonDomainCreateLinux(conn, sexpr);
call 0 never executed
#####: 2740: free(sexpr);
call 0 never executed
#####: 2741: if (ret != 0) {
branch 0 never executed
branch 1 never executed
#####: 2742: fprintf(stderr, "Failed to create domain %s\n", name);
call 0 never executed
#####: 2743: goto error;
-: 2744: }
-: 2745:
#####: 2746: ret = xend_wait_for_devices(conn, name);
call 0 never executed
#####: 2747: if (ret != 0) {
branch 0 never executed
branch 1 never executed
#####: 2748: fprintf(stderr, "Failed to get devices for domain %s\n", name);
call 0 never executed
#####: 2749: goto error;
-: 2750: }
-: 2751:
#####: 2752: dom = virDomainLookupByName(conn, name);
call 0 never executed
#####: 2753: if (dom == NULL) {
branch 0 never executed
branch 1 never executed
#####: 2754: goto error;
-: 2755: }
-: 2756:
#####: 2757: ret = xenDaemonDomainResume(dom);
call 0 never executed
#####: 2758: if (ret != 0) {
branch 0 never executed
branch 1 never executed
#####: 2759: fprintf(stderr, "Failed to resume new domain %s\n", name);
call 0 never executed
#####: 2760: xenDaemonDomainDestroy(dom);
call 0 never executed
#####: 2761: goto error;
-: 2762: }
-: 2763:
#####: 2764: dom = virDomainLookupByName(conn, name);
call 0 never executed
#####: 2765: free(name);
call 0 never executed
-: 2766:
#####: 2767: return (dom);
#####: 2768: error:
#####: 2769: if (name != NULL)
branch 0 never executed
branch 1 never executed
#####: 2770: free(name);
call 0 never executed
#####: 2771: return (NULL);
-: 2772:}
-: 2773:#endif /* ! PROXY */
-: 2774: