static int
virInterfaceDefParseProtoIPv4(virInterfaceProtocolDefPtr def,
xmlXPathContextPtr ctxt) {
xmlNodePtr dhcp;
xmlNodePtr *ipNodes = NULL;
int nIpNodes, ret = -1;
size_t i;
char *tmp;
tmp = virXPathString("string(./route[1]/@gateway)", ctxt);
def->gateway = tmp;
dhcp = virXPathNode("./dhcp", ctxt);
if (dhcp != NULL) {
if (virInterfaceDefParseDhcp(def, dhcp, ctxt) < 0)
return -1;
}
nIpNodes = virXPathNodeSet("./ip", ctxt, &ipNodes);
if (nIpNodes < 0)
return -1;
if (ipNodes == NULL)
return 0;
if (VIR_ALLOC_N(def->ips, nIpNodes) < 0)
goto error;
def->nips = 0;
for (i = 0; i < nIpNodes; i++) {
virInterfaceIpDefPtr ip;
if (VIR_ALLOC(ip) < 0)
goto error;
ctxt->node = ipNodes[i];
if (virInterfaceDefParseIp(ip, ctxt) < 0) {
virInterfaceIpDefFree(ip);
goto error;
}
def->ips[def->nips++] = ip;
}
ret = 0;
error:
VIR_FREE(ipNodes);
return ret;
}
static char *
munge_param(const char *datain,
size_t *params,
size_t paramnum,
int *type)
{
char *dataout;
const char *sol;
const char *eol;
const char *eq;
const char *tmp;
size_t dataoutlen;
const char *replace = NULL;
sol = datain + params[paramnum];
eq = strchr(sol, '=');
eol = strchr(sol, '\n');
for (tmp = eq + 1; tmp < eol && !replace; tmp++) {
if (c_isspace(*tmp))
continue;
if (c_isdigit(*tmp)) {
*type = VIR_CONF_LONG;
replace = "\"foo\"";
} else if (*tmp == '[') {
*type = VIR_CONF_LIST;
replace = "666";
} else {
*type = VIR_CONF_STRING;
replace = "666";
}
}
dataoutlen = (eq - datain) + 1 +
strlen(replace) +
strlen(eol) + 1;
if (VIR_ALLOC_N(dataout, dataoutlen) < 0) {
virReportOOMError();
return NULL;
}
memcpy(dataout, datain, (eq - datain) + 1);
memcpy(dataout + (eq - datain) + 1,
replace, strlen(replace));
memcpy(dataout + (eq - datain) + 1 + strlen(replace),
eol, strlen(eol) + 1);
return dataout;
}
virSecurityManagerPtr*
virSecurityManagerGetNested(virSecurityManagerPtr mgr)
{
virSecurityManagerPtr* list = NULL;
if (STREQ("stack", mgr->drv->name))
return virSecurityStackGetNested(mgr);
if (VIR_ALLOC_N(list, 2) < 0)
return NULL;
list[0] = mgr;
list[1] = NULL;
return list;
}
/*
* str is callee allocated
*/
int lxctoolsReadConfigItem(struct lxc_container* cont, const char* key, char** str)
{
int ret_len;
if ((ret_len = cont->get_config_item(cont, key, NULL, 0)) < 0)
goto error;
if (VIR_ALLOC_N(*str, ret_len+1) < 0)
goto error;
if ((cont->get_config_item(cont, key, *str, ret_len+1)) < 0)
goto error;
return 0;
error:
VIR_ERROR("Error on reading config for container: '%s'", cont->error_string);
*str = NULL;
return -1;
}
virNetServerServicePtr virNetServerServiceNewFD(int fd,
int auth,
bool readonly,
size_t nrequests_client_max,
virNetTLSContextPtr tls)
{
virNetServerServicePtr svc;
int i;
if (virNetServerServiceInitialize() < 0)
return NULL;
if (!(svc = virObjectNew(virNetServerServiceClass)))
return NULL;
svc->auth = auth;
svc->readonly = readonly;
svc->nrequests_client_max = nrequests_client_max;
svc->tls = virObjectRef(tls);
svc->nsocks = 1;
if (VIR_ALLOC_N(svc->socks, svc->nsocks) < 0)
goto no_memory;
if (virNetSocketNewListenFD(fd,
&svc->socks[0]) < 0)
goto error;
for (i = 0 ; i < svc->nsocks ; i++) {
/* IO callback is initially disabled, until we're ready
* to deal with incoming clients */
if (virNetSocketAddIOCallback(svc->socks[i],
0,
virNetServerServiceAccept,
svc,
virObjectFreeCallback) < 0)
goto error;
}
return svc;
no_memory:
virReportOOMError();
error:
virObjectUnref(svc);
return NULL;
}
static virNetServerClientPtr
virNetServerClientNewInternal(virNetSocketPtr sock,
int auth,
#ifdef WITH_GNUTLS
virNetTLSContextPtr tls,
#endif
bool readonly,
size_t nrequests_max)
{
virNetServerClientPtr client;
if (virNetServerClientInitialize() < 0)
return NULL;
if (!(client = virObjectLockableNew(virNetServerClientClass)))
return NULL;
client->sock = virObjectRef(sock);
client->auth = auth;
client->readonly = readonly;
#ifdef WITH_GNUTLS
client->tlsCtxt = virObjectRef(tls);
#endif
client->nrequests_max = nrequests_max;
client->sockTimer = virEventAddTimeout(-1, virNetServerClientSockTimerFunc,
client, NULL);
if (client->sockTimer < 0)
goto error;
/* Prepare one for packet receive */
if (!(client->rx = virNetMessageNew(true)))
goto error;
client->rx->bufferLength = VIR_NET_MESSAGE_LEN_MAX;
if (VIR_ALLOC_N(client->rx->buffer, client->rx->bufferLength) < 0)
goto error;
client->nrequests = 1;
PROBE(RPC_SERVER_CLIENT_NEW,
"client=%p sock=%p",
client, client->sock);
return client;
error:
virObjectUnref(client);
return NULL;
}
/**
* virXPathNodeSet:
* @xpath: the XPath string to evaluate
* @ctxt: an XPath context
* @list: the returned list of nodes (or NULL if only count matters)
*
* Convenience function to evaluate an XPath node set
*
* Returns the number of nodes found in which case @list is set (and
* must be freed) or -1 if the evaluation failed.
*/
int
virXPathNodeSet(const char *xpath,
xmlXPathContextPtr ctxt,
xmlNodePtr **list)
{
xmlXPathObjectPtr obj;
xmlNodePtr relnode;
int ret;
if ((ctxt == NULL) || (xpath == NULL)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("Invalid parameter to virXPathNodeSet()"));
return -1;
}
if (list != NULL)
*list = NULL;
relnode = ctxt->node;
obj = xmlXPathEval(BAD_CAST xpath, ctxt);
ctxt->node = relnode;
if (obj == NULL)
return 0;
if (obj->type != XPATH_NODESET) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Incorrect xpath '%s'"), xpath);
xmlXPathFreeObject(obj);
return -1;
}
if ((obj->nodesetval == NULL) || (obj->nodesetval->nodeNr < 0)) {
xmlXPathFreeObject(obj);
return 0;
}
ret = obj->nodesetval->nodeNr;
if (list != NULL && ret) {
if (VIR_ALLOC_N(*list, ret) < 0) {
ret = -1;
} else {
memcpy(*list, obj->nodesetval->nodeTab,
ret * sizeof(xmlNodePtr));
}
}
xmlXPathFreeObject(obj);
return ret;
}
static qemuMigrationCookieNetworkPtr
qemuMigrationCookieNetworkXMLParse(xmlXPathContextPtr ctxt)
{
qemuMigrationCookieNetworkPtr optr;
size_t i;
int n;
xmlNodePtr *interfaces = NULL;
char *vporttype;
xmlNodePtr save_ctxt = ctxt->node;
if (VIR_ALLOC(optr) < 0)
goto error;
if ((n = virXPathNodeSet("./network/interface", ctxt, &interfaces)) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("missing interface information"));
goto error;
}
optr->nnets = n;
if (VIR_ALLOC_N(optr->net, optr->nnets) < 0)
goto error;
for (i = 0; i < n; i++) {
/* portdata is optional, and may not exist */
ctxt->node = interfaces[i];
optr->net[i].portdata = virXPathString("string(./portdata[1])", ctxt);
if (!(vporttype = virXMLPropString(interfaces[i], "vporttype"))) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("missing vporttype attribute in migration data"));
goto error;
}
optr->net[i].vporttype = virNetDevVPortTypeFromString(vporttype);
}
VIR_FREE(interfaces);
cleanup:
ctxt->node = save_ctxt;
return optr;
error:
VIR_FREE(interfaces);
qemuMigrationCookieNetworkFree(optr);
optr = NULL;
goto cleanup;
}
/**
* virTimeStringNow:
*
* Creates a string containing a formatted timestamp
* corresponding to the current time.
*
* This function is not async signal safe
*
* Returns a formatted allocated string, or NULL on error
*/
char *virTimeStringNow(void)
{
char *ret;
if (VIR_ALLOC_N(ret, VIR_TIME_STRING_BUFLEN) < 0)
return NULL;
if (virTimeStringNowRaw(ret) < 0) {
virReportSystemError(errno, "%s",
_("Unable to format time"));
VIR_FREE(ret);
return NULL;
}
return ret;
}
/**
* virTimeStringThen:
* @when: the time to format in milliseconds
*
* Creates a string containing a formatted timestamp
* corresponding to the time @when.
*
* This function is not async signal safe
*
* Returns a formatted allocated string, or NULL on error
*/
char *virTimeStringThen(unsigned long long when)
{
char *ret;
if (VIR_ALLOC_N(ret, VIR_TIME_STRING_BUFLEN) < 0)
return NULL;
if (virTimeStringThenRaw(when, ret) < 0) {
virReportSystemError(errno, "%s",
_("Unable to format time"));
VIR_FREE(ret);
return NULL;
}
return ret;
}
/*
* virNetDevVlanCopy - copy from src into (already existing) dst.
* If src is NULL, dst will have nTags set to 0.
* dst is assumed to be empty on entry.
*/
int
virNetDevVlanCopy(virNetDevVlanPtr dst, const virNetDevVlanPtr src)
{
if (!src || src->nTags == 0)
return 0;
if (VIR_ALLOC_N(dst->tag, src->nTags) < 0) {
virReportOOMError();
return -1;
}
dst->trunk = src->trunk;
dst->nTags = src->nTags;
memcpy(dst->tag, src->tag, src->nTags * sizeof(*src->tag));
return 0;
}
virCPUDefPtr
virCPUDefCopy(const virCPUDef *cpu)
{
virCPUDefPtr copy;
size_t i;
if (!cpu || VIR_ALLOC(copy) < 0)
return NULL;
copy->type = cpu->type;
copy->mode = cpu->mode;
copy->match = cpu->match;
copy->fallback = cpu->fallback;
copy->sockets = cpu->sockets;
copy->cores = cpu->cores;
copy->threads = cpu->threads;
copy->arch = cpu->arch;
if (virCPUDefCopyModel(copy, cpu, false) < 0)
goto error;
if (cpu->ncells) {
if (VIR_ALLOC_N(copy->cells, cpu->ncells) < 0)
goto error;
copy->ncells_max = copy->ncells = cpu->ncells;
for (i = 0; i < cpu->ncells; i++) {
copy->cells[i].cellid = cpu->cells[i].cellid;
copy->cells[i].mem = cpu->cells[i].mem;
copy->cells[i].cpumask = virBitmapNewCopy(cpu->cells[i].cpumask);
if (!copy->cells[i].cpumask)
goto error;
if (VIR_STRDUP(copy->cells[i].cpustr, cpu->cells[i].cpustr) < 0)
goto error;
}
copy->cells_cpus = cpu->cells_cpus;
}
return copy;
error:
virCPUDefFree(copy);
return NULL;
}
static virCPUDefPtr *
cpuTestLoadMultiXML(const char *arch,
const char *name,
unsigned int *count)
{
char *xml = NULL;
xmlDocPtr doc = NULL;
xmlXPathContextPtr ctxt = NULL;
xmlNodePtr *nodes = NULL;
virCPUDefPtr *cpus = NULL;
int n;
size_t i;
if (virAsprintf(&xml, "%s/cputestdata/%s-%s.xml", abs_srcdir, arch, name) < 0)
goto cleanup;
if (!(doc = virXMLParseFileCtxt(xml, &ctxt)))
goto cleanup;
n = virXPathNodeSet("/cpuTest/cpu", ctxt, &nodes);
if (n <= 0 || (VIR_ALLOC_N(cpus, n) < 0)) {
fprintf(stderr, "\nNo /cpuTest/cpu elements found in %s\n", xml);
goto cleanup;
}
for (i = 0; i < n; i++) {
ctxt->node = nodes[i];
cpus[i] = virCPUDefParseXML(nodes[i], ctxt, VIR_CPU_TYPE_HOST);
if (!cpus[i])
goto cleanup_cpus;
}
*count = n;
cleanup:
VIR_FREE(xml);
VIR_FREE(nodes);
xmlXPathFreeContext(ctxt);
xmlFreeDoc(doc);
return cpus;
cleanup_cpus:
for (i = 0; i < n; i++)
virCPUDefFree(cpus[i]);
VIR_FREE(cpus);
goto cleanup;
}
/*
* Parses domXML to virDomainDef object, which is then converted to xl.cfg(5)
* config and compared with expected config.
*/
static int
testCompareParseXML(const char *xlcfg, const char *xml)
{
char *gotxlcfgData = NULL;
virConfPtr conf = NULL;
virConnectPtr conn = NULL;
int wrote = 4096;
int ret = -1;
virDomainDefPtr def = NULL;
if (VIR_ALLOC_N(gotxlcfgData, wrote) < 0)
goto fail;
conn = virGetConnect();
if (!conn) goto fail;
if (!(def = virDomainDefParseFile(xml, caps, xmlopt,
VIR_DOMAIN_XML_INACTIVE)))
goto fail;
if (!virDomainDefCheckABIStability(def, def)) {
fprintf(stderr, "ABI stability check failed on %s", xml);
goto fail;
}
if (!(conf = xenFormatXL(def, conn)))
goto fail;
if (virConfWriteMem(gotxlcfgData, &wrote, conf) < 0)
goto fail;
gotxlcfgData[wrote] = '\0';
if (virtTestCompareToFile(gotxlcfgData, xlcfg) < 0)
goto fail;
ret = 0;
fail:
VIR_FREE(gotxlcfgData);
if (conf)
virConfFree(conf);
virDomainDefFree(def);
virObjectUnref(conn);
return ret;
}
static int
ppc64DataCopy(virCPUppc64Data *dst, const virCPUppc64Data *src)
{
size_t i;
if (VIR_ALLOC_N(dst->pvr, src->len) < 0)
return -1;
dst->len = src->len;
for (i = 0; i < src->len; i++) {
dst->pvr[i].value = src->pvr[i].value;
dst->pvr[i].mask = src->pvr[i].mask;
}
return 0;
}
/*
* Output only lxc.net.x
*/
int lxctoolsSetNetConfig(lxctoolsConffilePtr conffile, virDomainDefPtr def)
{
int ret = -1;
char *mac_str = NULL;
// Remove old net config
if (lxctoolsConffileRemoveItems(conffile, "lxc.net.") < 0)
goto cleanup;
if (lxctoolsConffileRemoveItems(conffile, "lxc.network.") < 0)
goto cleanup;
// Insert new net config
if (lxctoolsConffileAddComment(conffile, "begin: generated network configuration") < 0)
goto cleanup;
for (size_t i = 0; i != def->nnets; i++) {
if (def->nets[i]->type != VIR_DOMAIN_NET_TYPE_BRIDGE) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, _("only network type bridge is currently supported."));
goto cleanup;
}
if (lxctoolsConffileAddItemEnumerated(conffile, "lxc.net.%zu.type", "veth", i) < 0) {
VIR_ERROR("Failed to set lxc.net.%zu.type to veth", i);
goto cleanup;
}
if (VIR_ALLOC_N(mac_str, VIR_MAC_STRING_BUFLEN) < 0)
goto cleanup;
virMacAddrFormat(&def->nets[i]->mac, mac_str);
if (lxctoolsConffileAddItemEnumerated(conffile, "lxc.net.%zu.hwaddr", mac_str, i) < 0) {
VIR_ERROR("Failed to set lxc.net.%zu.hwaddr", i);
goto cleanup;
}
if (lxctoolsConffileAddItemEnumerated(conffile, "lxc.net.%zu.link", def->nets[i]->data.bridge.brname, i) < 0) {
VIR_ERROR("failed to set lxc.net.%zu.link", i);
goto cleanup;
}
if (def->nets[i]->linkstate == VIR_DOMAIN_NET_INTERFACE_LINK_STATE_UP) {
if (lxctoolsConffileAddItemEnumerated(conffile, "lxc.net.%zu.flags", "up", i) < 0)
goto cleanup;
}
}
if (lxctoolsConffileAddComment(conffile, "end: generated network configuration") < 0)
goto cleanup;
ret = 0;
cleanup:
VIR_FREE(mac_str);
return ret;
}
/*
* Return new file path in malloced string created by
* concatenating first and second function arguments.
*/
char *
parallelsAddFileExt(const char *path, const char *ext)
{
char *new_path = NULL;
size_t len = strlen(path) + strlen(ext) + 1;
if (VIR_ALLOC_N(new_path, len) < 0)
return NULL;
if (!virStrcpy(new_path, path, len)) {
VIR_FREE(new_path);
return NULL;
}
strcat(new_path, ext);
return new_path;
}
/*
* Build NUMA Toplogy with cell id starting from (0 + seq)
* for testing
*/
static virCapsPtr
buildNUMATopology(int seq)
{
virCapsPtr caps;
virCapsHostNUMACellCPUPtr cell_cpus = NULL;
int core_id, cell_id;
int id;
if ((caps = virCapabilitiesNew(VIR_ARCH_X86_64, false, false)) == NULL)
goto error;
id = 0;
for (cell_id = 0; cell_id < MAX_CELLS; cell_id++) {
if (VIR_ALLOC_N(cell_cpus, MAX_CPUS_IN_CELL) < 0)
goto error;
for (core_id = 0; core_id < MAX_CPUS_IN_CELL; core_id++) {
cell_cpus[core_id].id = id + core_id;
cell_cpus[core_id].socket_id = cell_id + seq;
cell_cpus[core_id].core_id = id + core_id;
if (!(cell_cpus[core_id].siblings =
virBitmapNew(MAX_CPUS_IN_CELL)))
goto error;
ignore_value(virBitmapSetBit(cell_cpus[core_id].siblings, id));
}
id++;
if (virCapabilitiesAddHostNUMACell(caps, cell_id + seq,
MAX_MEM_IN_CELL,
MAX_CPUS_IN_CELL, cell_cpus,
VIR_ARCH_NONE, NULL,
VIR_ARCH_NONE, NULL) < 0)
goto error;
cell_cpus = NULL;
}
return caps;
error:
virCapabilitiesClearHostNUMACellCPUTopology(cell_cpus, MAX_CPUS_IN_CELL);
VIR_FREE(cell_cpus);
virObjectUnref(caps);
return NULL;
}
static virStoragePoolObjPtr
parallelsPoolCreateByPath(virConnectPtr conn, const char *path)
{
parallelsConnPtr privconn = conn->privateData;
virStoragePoolObjListPtr pools = &privconn->pools;
virStoragePoolDefPtr def;
virStoragePoolObjPtr pool = NULL;
if (VIR_ALLOC(def) < 0)
goto no_memory;
if (!(def->name = parallelsMakePoolName(conn, path)))
goto error;
if (VIR_ALLOC_N(def->uuid, VIR_UUID_BUFLEN))
goto no_memory;
if (virUUIDGenerate(def->uuid)) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Can't generate UUID"));
goto error;
}
def->type = VIR_STORAGE_POOL_DIR;
if (VIR_STRDUP(def->target.path, path) < 0)
goto error;
if (!(pool = virStoragePoolObjAssignDef(pools, def)))
goto error;
if (virStoragePoolObjSaveDef(conn->storagePrivateData, pool, def) < 0) {
virStoragePoolObjRemove(pools, pool);
goto error;
}
virStoragePoolObjUnlock(pool);
return pool;
no_memory:
virReportOOMError();
error:
virStoragePoolDefFree(def);
if (pool)
virStoragePoolObjUnlock(pool);
return NULL;
}
/*
* Return new file path in malloced string created by
* concatenating first and second function arguments.
*/
char *
parallelsAddFileExt(const char *path, const char *ext)
{
char *new_path = NULL;
size_t len = strlen(path) + strlen(ext) + 1;
if (VIR_ALLOC_N(new_path, len) < 0) {
virReportOOMError();
return NULL;
}
if (!virStrcpy(new_path, path, len))
return NULL;
strcat(new_path, ext);
return new_path;
}
static int
virInterfaceDefParseBondItfs(virInterfaceDefPtr def,
xmlXPathContextPtr ctxt) {
xmlNodePtr *interfaces = NULL;
xmlNodePtr bond = ctxt->node;
virInterfaceDefPtr itf;
int nbItf, i;
int ret = 0;
nbItf = virXPathNodeSet("./interface", ctxt, &interfaces);
if (nbItf < 0) {
ret = -1;
goto error;
}
if (nbItf == 0) {
virInterfaceReportError(VIR_ERR_XML_ERROR,
"%s", _("bond has no interfaces"));
ret = -1;
goto error;
}
if (VIR_ALLOC_N(def->data.bond.itf, nbItf) < 0) {
virReportOOMError();
ret = -1;
goto error;
}
def->data.bond.nbItf = nbItf;
for (i = 0; i < nbItf;i++) {
ctxt->node = interfaces[i];
itf = virInterfaceDefParseXML(ctxt, VIR_INTERFACE_TYPE_BOND);
if (itf == NULL) {
ret = -1;
def->data.bond.nbItf = i;
goto error;
}
def->data.bond.itf[i] = itf;
}
error:
VIR_FREE(interfaces);
ctxt->node = bond;
return ret;
}
static int
adminDispatchConnectListServers(virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr ATTRIBUTE_UNUSED,
admin_connect_list_servers_args *args,
admin_connect_list_servers_ret *ret)
{
virAdmServerPtr *servers = NULL;
int nservers = 0;
int rv = -1;
size_t i;
struct daemonAdmClientPrivate *priv =
virNetServerClientGetPrivateData(client);
if ((nservers =
adminDaemonListServers(priv->dmn,
args->need_results ? &servers : NULL,
args->flags)) < 0)
goto cleanup;
if (servers && nservers) {
if (VIR_ALLOC_N(ret->servers.servers_val, nservers) < 0)
goto cleanup;
ret->servers.servers_len = nservers;
for (i = 0; i < nservers; i++)
make_nonnull_server(ret->servers.servers_val + i, servers[i]);
} else {
ret->servers.servers_len = 0;
ret->servers.servers_val = NULL;
}
ret->ret = nservers;
rv = 0;
cleanup:
if (rv < 0)
virNetMessageSaveError(rerr);
if (servers && nservers > 0)
for (i = 0; i < nservers; i++)
virObjectUnref(servers[i]);
VIR_FREE(servers);
return rv;
}
virDomainPCIAddressSetPtr
virDomainPCIAddressSetAlloc(unsigned int nbuses)
{
virDomainPCIAddressSetPtr addrs;
if (VIR_ALLOC(addrs) < 0)
goto error;
if (VIR_ALLOC_N(addrs->buses, nbuses) < 0)
goto error;
addrs->nbuses = nbuses;
return addrs;
error:
virDomainPCIAddressSetFree(addrs);
return NULL;
}
/**
* virBitmapToData:
* @data: the data
* @len: len of @data in byte
*
* Convert a bitmap to a chunk of data containing bits information.
* Data consists of sequential bytes, with lower bytes containing
* lower bits. This function allocates @data.
*
* Returns 0 on success, -1 otherwise.
*/
int virBitmapToData(virBitmapPtr bitmap, unsigned char **data, int *dataLen)
{
ssize_t len;
if ((len = virBitmapLastSetBit(bitmap)) < 0)
len = 1;
else
len = (len + CHAR_BIT) / CHAR_BIT;
if (VIR_ALLOC_N(*data, len) < 0)
return -1;
*dataLen = len;
virBitmapToDataBuf(bitmap, *data, *dataLen);
return 0;
}
static int
virStorageBackendFileSystemNetFindPoolSourcesFunc(virStoragePoolObjPtr pool ATTRIBUTE_UNUSED,
char **const groups,
void *data)
{
virNetfsDiscoverState *state = data;
const char *name, *path;
virStoragePoolSource *src = NULL;
int ret = -1;
path = groups[0];
if (!(name = strrchr(path, '/'))) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("invalid netfs path (no /): %s"), path);
goto cleanup;
}
name += 1;
if (*name == '\0') {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("invalid netfs path (ends in /): %s"), path);
goto cleanup;
}
if (!(src = virStoragePoolSourceListNewSource(&state->list)))
goto cleanup;
if (VIR_ALLOC_N(src->hosts, 1) < 0) {
virReportOOMError();
goto cleanup;
}
src->nhost = 1;
if (!(src->hosts[0].name = strdup(state->host)) ||
!(src->dir = strdup(path))) {
virReportOOMError();
goto cleanup;
}
src->format = VIR_STORAGE_POOL_NETFS_NFS;
ret = 0;
cleanup:
return ret;
}
static int
lxcCreateConsoles(virDomainDefPtr def, virConfPtr properties)
{
VIR_AUTOFREE(char *) value = NULL;
int nbttys = 0;
virDomainChrDefPtr console;
size_t i;
if (virConfGetValueString(properties, "lxc.tty.max", &value) <= 0) {
virResetLastError();
/* Check for pre LXC 3.0 legacy key */
if (virConfGetValueString(properties, "lxc.tty", &value) <= 0)
return 0;
}
if (virStrToLong_i(value, NULL, 10, &nbttys) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, _("failed to parse int: '%s'"),
value);
return -1;
}
if (VIR_ALLOC_N(def->consoles, nbttys) < 0)
return -1;
def->nconsoles = nbttys;
for (i = 0; i < nbttys; i++) {
if (!(console = virDomainChrDefNew(NULL)))
goto error;
console->deviceType = VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE;
console->targetType = VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_LXC;
console->target.port = i;
console->source->type = VIR_DOMAIN_CHR_TYPE_PTY;
def->consoles[i] = console;
}
return 0;
error:
virDomainChrDefFree(console);
return -1;
}
/**
* virBufferEscapeSexpr:
* @buf: the buffer to dump
* @format: a printf like format string but with only one %s parameter
* @str: the string argument which need to be escaped
*
* Do a formatted print with a single string to an sexpr buffer. The string
* is escaped to avoid generating a sexpr that xen will choke on. This
* doesn't fully escape the sexpr, just enough for our code to work.
*/
void
virBufferEscapeSexpr(const virBufferPtr buf,
const char *format,
const char *str)
{
int len;
char *escaped, *out;
const char *cur;
if ((format == NULL) || (buf == NULL) || (str == NULL))
return;
if (buf->error)
return;
len = strlen(str);
if (strcspn(str, "\\'") == len) {
virBufferVSprintf(buf, format, str);
return;
}
if (VIR_ALLOC_N(escaped, 2 * len + 1) < 0) {
virBufferNoMemory(buf);
return;
}
cur = str;
out = escaped;
while (*cur != 0) {
switch (*cur) {
case '\\':
case '\'':
*out++ = '\\';
/* fallthrough */
default:
*out++ = *cur;
}
cur++;
}
*out = 0;
virBufferVSprintf(buf, format, escaped);
VIR_FREE(escaped);
}
static int
libxlMakePCIList(virDomainDefPtr def, libxl_domain_config *d_config)
{
virDomainHostdevDefPtr *l_hostdevs = def->hostdevs;
size_t nhostdevs = def->nhostdevs;
size_t npcidevs = 0;
libxl_device_pci *x_pcidevs;
size_t i, j;
if (nhostdevs == 0)
return 0;
if (VIR_ALLOC_N(x_pcidevs, nhostdevs) < 0)
return -1;
for (i = 0, j = 0; i < nhostdevs; i++) {
if (l_hostdevs[i]->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS)
continue;
if (l_hostdevs[i]->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI)
continue;
libxl_device_pci_init(&x_pcidevs[j]);
if (libxlMakePCI(l_hostdevs[i], &x_pcidevs[j]) < 0)
goto error;
npcidevs++;
j++;
}
VIR_SHRINK_N(x_pcidevs, nhostdevs, nhostdevs - npcidevs);
d_config->pcidevs = x_pcidevs;
d_config->num_pcidevs = npcidevs;
return 0;
error:
for (i = 0; i < npcidevs; i++)
libxl_device_pci_dispose(&x_pcidevs[i]);
VIR_FREE(x_pcidevs);
return -1;
}
/**
* virCapabilitiesAllocMachines:
* @machines: machine variants for emulator ('pc', or 'isapc', etc)
* @nmachines: number of machine variants for emulator
*
* Allocate a table of virCapsGuestMachinePtr from the supplied table
* of machine names.
*/
virCapsGuestMachinePtr *
virCapabilitiesAllocMachines(const char *const *names, int nnames)
{
virCapsGuestMachinePtr *machines;
int i;
if (VIR_ALLOC_N(machines, nnames) < 0)
return NULL;
for (i = 0; i < nnames; i++) {
if (VIR_ALLOC(machines[i]) < 0 ||
!(machines[i]->name = strdup(names[i]))) {
virCapabilitiesFreeMachines(machines, nnames);
return NULL;
}
}
return machines;
}
/**
* virLogSetBufferSize:
* @size: size of the buffer in kilobytes or <= 0 to deactivate
*
* Dynamically set the size or deactivate the logging buffer used to keep
* a trace of all recent debug output. Note that the content of the buffer
* is lost if it gets reallocated.
*
* Return -1 in case of failure or 0 in case of success
*/
extern int
virLogSetBufferSize(int size) {
int ret = 0;
int oldsize;
char *oldLogBuffer;
const char *pbm = NULL;
if (size < 0)
size = 0;
if ((virLogInitialized == 0) || (size * 1024 == virLogSize))
return ret;
virLogLock();
oldsize = virLogSize;
oldLogBuffer = virLogBuffer;
if (INT_MAX / 1024 <= size) {
pbm = "Requested log size of %d kB too large\n";
ret = -1;
goto error;
}
virLogSize = size * 1024;
if (VIR_ALLOC_N(virLogBuffer, virLogSize + 1) < 0) {
pbm = "Failed to allocate debug buffer of %d kB\n";
virLogBuffer = oldLogBuffer;
virLogSize = oldsize;
ret = -1;
goto error;
}
VIR_FREE(oldLogBuffer);
virLogLen = 0;
virLogStart = 0;
virLogEnd = 0;
error:
virLogUnlock();
if (pbm)
VIR_ERROR(pbm, size);
return ret;
}
