virDomainPtr domain;
if (VIR_ALLOC(domain) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
int ndomains = 10;
if (VIR_ALLOC_N(domains, ndomains) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
int ndomains = 10;
if (VIR_ALLOC_N(domains, ndomains) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
ndomains = 20
if (VIR_REALLOC_N(domains, ndomains) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
if (virBufferError(&buf)) {
virBufferFreeAndReset(&buf);
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
if (server->privileged) {
dir_prefix = strdup (LOCAL_STATE_DIR);
if (dir_prefix == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
if (snprintf (sock_dir, maxlen, "%s/run/libvirt",
sock_dir_prefix = strdup (sock_dir);
if (!sock_dir_prefix) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
if (server->privileged) {
if (!(server->logDir = strdup (LOCAL_STATE_DIR "/log/libvirt")))
- virReportOOMError(NULL);
+ virReportOOMError();
} else {
if (virAsprintf(&server->logDir, "%s/.libvirt/log", dir_prefix) < 0)
- virReportOOMError(NULL);
+ virReportOOMError();
}
if (server->logDir == NULL)
}
if (virAsprintf(&addr, "%s;%s", host, port) == -1) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
+ parent_host,
+ operation_file) < 0) {
+
-+ virReportOOMError(conn);
++ virReportOOMError();
+ retval = -1;
+ goto cleanup;
+ }
+ wwpn,
+ wwnn) < 0) {
+
-+ virReportOOMError(conn);
++ virReportOOMError();
+ retval = -1;
+ goto cleanup;
+ }
+ VIR_FREE(wwnn);
+ VIR_FREE(wwpn);
+ ret = -1;
-+ virReportOOMError(conn);
++ virReportOOMError();
+ }
+
+ return ret;
+ obj = NULL;
+
+ if (parent_name == NULL) {
-+ virReportOOMError(dev->conn);
++ virReportOOMError();
+ goto out;
+ }
+
+ if (virAsprintf(&sysfs_path, "%s/host%d",
+ LINUX_SYSFS_FC_HOST_PREFIX,
+ d->scsi_host.host) < 0) {
-+ virReportOOMError(NULL);
++ virReportOOMError();
+ goto out;
+ }
+
+
+ if (virAsprintf(&wwnn_path, "%s/node_name",
+ sysfs_path) < 0) {
-+ virReportOOMError(NULL);
++ virReportOOMError();
+ goto out;
+ }
+
+
+ d->scsi_host.wwnn = strndup(p, sizeof(buf));
+ if (d->scsi_host.wwnn == NULL) {
-+ virReportOOMError(NULL);
++ virReportOOMError();
+ goto out;
+ }
+
+
+ if (virAsprintf(&wwpn_path, "%s/port_name",
+ sysfs_path) < 0) {
-+ virReportOOMError(NULL);
++ virReportOOMError();
+ goto out;
+ }
+
+
+ d->scsi_host.wwpn = strndup(p, sizeof(buf));
+ if (d->scsi_host.wwpn == NULL) {
-+ virReportOOMError(NULL);
++ virReportOOMError();
+ goto out;
+ }
+
+ if (virAsprintf(&sysfs_path, "%s/host%d/vport_create",
+ LINUX_SYSFS_FC_HOST_PREFIX,
+ d->scsi_host.host) < 0) {
-+ virReportOOMError(NULL);
++ virReportOOMError();
+ goto out;
+ }
+
virDomainPtr domain;
if (VIR_ALLOC(domain) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
</pre></li>
int ndomains = 10;
if (VIR_ALLOC_N(domains, ndomains) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
</pre></li>
int ndomains = 10;
if (VIR_ALLOC_N(domains, ndomains) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
</pre></li>
ndomains = 20
if (VIR_REALLOC_N(domains, ndomains) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
</pre></li>
if (virBufferError(&buf)) {
virBufferFreeAndReset(&buf);
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
unsigned int i;
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
return def;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
error:
virCPUDefFree(def);
return virBufferContentAndReset(&buf);
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
cleanup:
virBufferFreeAndReset(&buf);
return NULL;
return 0;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
{
doms->objs = virHashCreate(50);
if (!doms->objs) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
return 0;
virDomainObjPtr domain;
if (VIR_ALLOC(domain) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
if (caps->privateDataAllocFunc &&
!(domain->privateData = (caps->privateDataAllocFunc)())) {
- virReportOOMError(conn);
+ virReportOOMError();
VIR_FREE(domain);
return NULL;
}
virUUIDFormat(def->uuid, uuidstr);
if (virHashAddEntry(doms->objs, uuidstr, domain) < 0) {
VIR_FREE(domain);
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
char *serial = NULL;
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
char *idx = NULL;
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
char *target = NULL;
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
char *devaddr = NULL;
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
virDomainChrDefPtr def;
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
goto error;
}
if (VIR_ALLOC(def->target.addr) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
if (virSocketParseAddr(addrStr, def->target.addr, 0) < 0)
char *bus = NULL;
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
char *type = NULL;
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
virDomainSoundDefPtr def;
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
virDomainWatchdogDefPtr def;
if (VIR_ALLOC (def) < 0) {
- virReportOOMError (conn);
+ virReportOOMError();
return NULL;
}
}
static virDomainVideoAccelDefPtr
-virDomainVideoAccelDefParseXML(virConnectPtr conn, const xmlNodePtr node) {
+virDomainVideoAccelDefParseXML(const xmlNodePtr node) {
xmlNodePtr cur;
virDomainVideoAccelDefPtr def;
char *support3d = NULL;
return(NULL);
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
char *vram = NULL;
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
type = virXMLPropString(cur, "type");
vram = virXMLPropString(cur, "vram");
heads = virXMLPropString(cur, "heads");
- def->accel = virDomainVideoAccelDefParseXML(conn, cur);
+ def->accel = virDomainVideoAccelDefParseXML(cur);
}
}
cur = cur->next;
char *mode, *type = NULL, *managed = NULL;
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
def->target = NULL;
}
if (VIR_ALLOC(dev) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
retemu = strdup(emulator);
if (!retemu)
- virReportOOMError(conn);
+ virReportOOMError();
return retemu;
}
virDomainDefPtr def;
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
char *set = tmp;
def->cpumasklen = VIR_DOMAIN_CPUMASK_LEN;
if (VIR_ALLOC_N(def->cpumask, def->cpumasklen) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
if (virDomainCpuSetParse(conn, (const char **)&set,
if (def->os.bootloader) {
def->os.type = strdup("xen");
if (!def->os.type) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
} else {
def->virtType == VIR_DOMAIN_VIRT_XEN) {
VIR_FREE(def->os.type);
if (!(def->os.type = strdup("xen"))) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
}
goto error;
}
if (!(def->os.arch = strdup(defaultArch))) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
}
virDomainVirtTypeToString(def->virtType));
if (defaultMachine != NULL) {
if (!(def->os.machine = strdup(defaultMachine))) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
}
virDomainInputDefPtr input;
if (VIR_ALLOC(input) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
if (STREQ(def->os.type, "hvm")) {
return def;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
/* fallthrough */
error:
ctxt = xmlXPathNewContext(xml);
if (ctxt == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
ctxt = xmlXPathNewContext(xml);
if (ctxt == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
return 0;
if (VIR_ALLOC(cont) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
if (VIR_REALLOC_N(def->controllers, def->ncontrollers+1) < 0) {
VIR_FREE(cont);
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
def->controllers[def->ncontrollers] = cont;
* freed by the caller.
*/
char *
-virDomainCpuSetFormat(virConnectPtr conn, char *cpuset, int maxcpu)
+virDomainCpuSetFormat(virConnectPtr conn ATTRIBUTE_UNUSED /*TEMPORARY*/, char *cpuset, int maxcpu)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
int start, cur;
if (virBufferError(&buf)) {
virBufferFreeAndReset(&buf);
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
return virBufferContentAndReset(&buf);
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
cleanup:
virBufferFreeAndReset(&buf);
return NULL;
return virBufferContentAndReset(&buf);
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
error:
virBufferFreeAndReset(&buf);
return NULL;
}
if (virHashAddEntry(doms->objs, uuidstr, obj) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
return ret;
}
-char *virDomainConfigFile(virConnectPtr conn,
+char *virDomainConfigFile(virConnectPtr conn ATTRIBUTE_UNUSED /*TEMPORARY*/,
const char *dir,
const char *name)
{
char *ret = NULL;
if (virAsprintf(&ret, "%s/%s.xml", dir, name) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
int i;
virHashForEach(doms->objs, virDomainObjListCopyInactiveNames, &data);
if (data.oom) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
}
/* Allocate new event */
if (VIR_ALLOC(event) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
event->conn = conn;
/* Make space on list */
n = cbList->count;
if (VIR_REALLOC_N(cbList->callbacks, n + 1) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
VIR_FREE(event);
return -1;
}
virDomainEventQueuePtr ret;
if (VIR_ALLOC(ret) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
virDomainEventPtr event;
if (VIR_ALLOC(event) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
event->type = type;
event->detail = detail;
if (!(event->name = strdup(name))) {
- virReportOOMError(NULL);
+ virReportOOMError();
VIR_FREE(event);
return NULL;
}
/* Make space on queue */
if (VIR_REALLOC_N(evtQueue->events,
evtQueue->count + 1) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
return 0;
if (VIR_ALLOC_N(def->ips, nIpNodes) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
virInterfaceIpDefPtr ip;
if (VIR_ALLOC(ip) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
return 0;
if (VIR_ALLOC_N(def->ips, nIpNodes) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
virInterfaceIpDefPtr ip;
if (VIR_ALLOC(ip) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
}
if (VIR_ALLOC_N(def->protos, nProtoNodes) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
virInterfaceProtocolDefPtr proto;
if (VIR_ALLOC(proto) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
}
if (nbItf > 0) {
if (VIR_ALLOC_N(def->data.bridge.itf, nbItf) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
ret = -1;
goto error;
}
goto error;
}
if (VIR_ALLOC_N(def->data.bond.itf, nbItf) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
ret = -1;
goto error;
}
VIR_FREE(tmp);
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
ctxt = xmlXPathNewContext(xml);
if (ctxt == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
goto no_memory;
return 0;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
cleanup:
return -1;
}
}
if (VIR_ALLOC(iface) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
if (virMutexInit(&iface->lock) < 0) {
iface->def = def;
if (VIR_REALLOC_N(interfaces->objs, interfaces->count + 1) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
VIR_FREE(iface);
return NULL;
}
}
if (VIR_ALLOC(network) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
if (virMutexInit(&network->lock) < 0) {
network->def = def;
if (VIR_REALLOC_N(nets->objs, nets->count + 1) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
VIR_FREE(network);
return NULL;
}
if (VIR_REALLOC_N(def->ranges, def->nranges + 1) < 0) {
xmlFree(start);
xmlFree(end);
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
def->ranges[def->nranges].start = (char *)start;
VIR_FREE(ip);
VIR_FREE(mac);
VIR_FREE(name);
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
def->hosts[def->nhosts].mac = (char *)mac;
char *tmp;
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
netaddr = inet_ntoa(inaddress);
if (virAsprintf(&def->network, "%s/%s", netaddr, def->netmask) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
ctxt = xmlXPathNewContext(xml);
if (ctxt == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
return def;
}
-char *virNetworkDefFormat(virConnectPtr conn,
+char *virNetworkDefFormat(virConnectPtr conn ATTRIBUTE_UNUSED /*TEMPORARY*/,
const virNetworkDefPtr def)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
return virBufferContentAndReset(&buf);
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
virBufferFreeAndReset(&buf);
return NULL;
}
return ret;
}
-char *virNetworkConfigFile(virConnectPtr conn,
+char *virNetworkConfigFile(virConnectPtr conn ATTRIBUTE_UNUSED /*TEMPORARY*/,
const char *dir,
const char *name)
{
char *ret = NULL;
if (virAsprintf(&ret, "%s/%s.xml", dir, name) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
if (!virNetworkBridgeInUse(nets, try, NULL)) {
if (!(newname = strdup(try))) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
return newname;
}
if (VIR_ALLOC(device) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
device->def = NULL;
virNodeDeviceObjUnlock(device);
virNodeDeviceObjFree(device);
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
devs->objs[devs->count++] = device;
}
}
-char *virNodeDeviceDefFormat(virConnectPtr conn,
+char *virNodeDeviceDefFormat(virConnectPtr conn ATTRIBUTE_UNUSED /*TEMPORARY*/,
const virNodeDeviceDefPtr def)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
return virBufferContentAndReset(&buf);
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
virBufferFreeAndReset(&buf);
return NULL;
}
int val, ret;
if (VIR_ALLOC(caps) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
int n, i;
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
def->name = strdup("new device");
if (!def->name) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
}
ctxt = xmlXPathNewContext(xml);
if (ctxt == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
VIR_FREE(wwnn);
VIR_FREE(wwpn);
ret = -1;
- virReportOOMError(conn);
+ virReportOOMError();
}
return ret;
ctxt = xmlXPathNewContext(xml);
if (ctxt == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
ctxt->node = root;
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
return virBufferContentAndReset(&buf);
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
error:
virBufferFreeAndReset(&buf);
return NULL;
if (nsource > 0) {
if (VIR_ALLOC_N(source->devices, nsource) < 0) {
VIR_FREE(nodeset);
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
xpath_ctxt = xmlXPathNewContext(doc);
if (xpath_ctxt == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
char *uuid = NULL;
if (VIR_ALLOC(ret) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
/* source name defaults to pool name */
ret->source.name = strdup(ret->name);
if (ret->source.name == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
}
ctxt = xmlXPathNewContext(xml);
if (ctxt == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
return virBufferContentAndReset(&buf);
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
cleanup:
virBufferFreeAndReset(&buf);
return NULL;
return NULL;
if (VIR_ALLOC(ret) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
ctxt = xmlXPathNewContext(xml);
if (ctxt == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
return virBufferContentAndReset(&buf);
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
cleanup:
virBufferFreeAndReset(&buf);
return NULL;
}
if (VIR_ALLOC(pool) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
pool->def = NULL;
virStoragePoolObjUnlock(pool);
virStoragePoolObjFree(pool);
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
pools->objs[pools->count++] = pool;
pool->configFile = strdup(path);
if (pool->configFile == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
virStoragePoolDefFree(def);
return NULL;
}
pool->autostartLink = strdup(autostartLink);
if (pool->autostartLink == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
virStoragePoolDefFree(def);
return NULL;
}
return -1;
}
if (!(pool->configFile = strdup(path))) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
return -1;
}
if (!(pool->autostartLink = strdup(path))) {
- virReportOOMError(conn);
+ virReportOOMError();
VIR_FREE(pool->configFile);
return -1;
}
}
virStoragePoolSourcePtr
-virStoragePoolSourceListNewSource(virConnectPtr conn,
+virStoragePoolSourceListNewSource(virConnectPtr conn ATTRIBUTE_UNUSED /*TEMPORARY*/,
virStoragePoolSourceListPtr list)
{
virStoragePoolSourcePtr source;
if (VIR_REALLOC_N(list->sources, list->nsources+1) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
return virBufferContentAndReset(&buf);
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
cleanup:
virBufferFreeAndReset(&buf);
return NULL;
char *uuidstr = NULL;
if (VIR_ALLOC(ret) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
int format, i, n;
if (VIR_ALLOC(ret) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
goto cleanup;
}
if (n != 0 && VIR_ALLOC_N(ret->secrets, n) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
ret->nsecrets = n;
ctxt = xmlXPathNewContext(xml);
if (ctxt == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
doc = xmlParseMemory(xml, strlen(xml));
if (doc == NULL || (ctxt = xmlXPathNewContext(doc)) == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
return VIR_CPU_COMPARE_INCOMPATIBLE;
if ((hash = genericHashFeatures(host)) == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
return ret;
no_memory:
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
return cpu;
no_memory:
- virReportOOMError(NULL);
+ virReportOOMError();
error:
virCPUDefFree(cpu);
cpu = NULL;
return ret;
no_memory:
- virReportOOMError(NULL);
+ virReportOOMError();
ret = -1;
ignore:
return model;
no_memory:
- virReportOOMError(NULL);
+ virReportOOMError();
error:
x86ModelFree(model);
return ret;
no_memory:
- virReportOOMError(NULL);
+ virReportOOMError();
ret = -1;
ignore:
struct x86_map *map;
if (VIR_ALLOC(map) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
return ret;
no_memory:
- virReportOOMError(NULL);
+ virReportOOMError();
error:
ret = VIR_CPU_COMPARE_ERROR;
return NULL;
if (!(data = x86DataFromModel(model)))
- virReportOOMError(NULL);
+ virReportOOMError();
x86ModelFree(model);
max = cpuid.eax - base;
if (VIR_ALLOC_N(*set, max + 1) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
union cpuData *data;
if (VIR_ALLOC(data) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
virConnectPtr ret;
if (VIR_ALLOC(ret) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failed;
}
if (virMutexInit(&ret->lock) < 0) {
if (ret == NULL) {
if (VIR_ALLOC(ret) < 0) {
virMutexUnlock(&conn->lock);
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
ret->name = strdup(name);
if (ret->name == NULL) {
virMutexUnlock(&conn->lock);
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
ret->magic = VIR_DOMAIN_MAGIC;
if (ret == NULL) {
if (VIR_ALLOC(ret) < 0) {
virMutexUnlock(&conn->lock);
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
ret->name = strdup(name);
if (ret->name == NULL) {
virMutexUnlock(&conn->lock);
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
ret->magic = VIR_NETWORK_MAGIC;
} else {
if (VIR_ALLOC(ret) < 0) {
virMutexUnlock(&conn->lock);
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
ret->name = strdup(name);
if (ret->name == NULL) {
virMutexUnlock(&conn->lock);
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
ret->mac = strdup(mac);
if (ret->mac == NULL) {
virMutexUnlock(&conn->lock);
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
if (ret == NULL) {
if (VIR_ALLOC(ret) < 0) {
virMutexUnlock(&conn->lock);
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
ret->name = strdup(name);
if (ret->name == NULL) {
virMutexUnlock(&conn->lock);
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
ret->magic = VIR_STORAGE_POOL_MAGIC;
if (ret == NULL) {
if (VIR_ALLOC(ret) < 0) {
virMutexUnlock(&conn->lock);
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
ret->pool = strdup(pool);
if (ret->pool == NULL) {
virMutexUnlock(&conn->lock);
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
ret->name = strdup(name);
if (ret->name == NULL) {
virMutexUnlock(&conn->lock);
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
if (virStrcpyStatic(ret->key, key) == NULL) {
if (ret == NULL) {
if (VIR_ALLOC(ret) < 0) {
virMutexUnlock(&conn->lock);
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
ret->magic = VIR_NODE_DEVICE_MAGIC;
ret->name = strdup(name);
if (ret->name == NULL) {
virMutexUnlock(&conn->lock);
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
if (ret == NULL) {
if (VIR_ALLOC(ret) < 0) {
virMutexUnlock(&conn->lock);
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
ret->magic = VIR_SECRET_MAGIC;
ret->usageType = usageType;
if (!(ret->usageID = strdup(usageID))) {
virMutexUnlock(&conn->lock);
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
if (virHashAddEntry(conn->secrets, uuidstr, ret) < 0) {
virMutexLock(&conn->lock);
if (VIR_ALLOC(ret) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
ret->magic = VIR_STREAM_MAGIC;
}
if (caps == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
/* Allocate per-connection private data */
if (VIR_ALLOC(priv) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
if (virAsprintf(&url, "%s://%s:%d/sdk", priv->transport,
conn->uri->server, conn->uri->port) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
username = strdup(conn->uri->user);
if (username == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
} else {
vCenter = strdup(dynamicProperty->val->string);
if (vCenter == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
if (virAsprintf(&url, "%s://%s/sdk", priv->transport,
vCenter) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
complete = strdup(hostName);
if (complete == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
} else {
if (virAsprintf(&complete, "%s.%s", hostName, domainName) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
}
char *xml = virCapabilitiesFormatXML(priv->caps);
if (xml == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
char *osType = strdup("hvm");
if (osType == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
virBufferURIEncodeString(&buffer, datastoreName);
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
names[count] = strdup(dynamicProperty->val->string);
if (names[count] == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
virBufferURIEncodeString(&buffer, datastoreName);
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
if (directoryName != NULL) {
if (virAsprintf(&datastoreRelatedPath, "[%s] %s/%s.vmx", datastoreName,
directoryName, def->name) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
} else {
if (virAsprintf(&datastoreRelatedPath, "[%s] %s.vmx", datastoreName,
def->name) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
}
char *type = strdup("allocation");
if (type == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
if (virAsprintf(uri_out, "%s://%s:%d/sdk", transport,
dconn->uri->server, dconn->uri->port) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
}
xmlUri = xmlParseURI(uri);
if (xmlUri == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
*transport = strdup(queryParam->value);
if (*transport == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
*vCenter = strdup(queryParam->value);
if (*vCenter == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
} else if (STRCASEEQ(queryParam->name, "no_verify")) {
*transport = strdup("https");
if (*transport == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
}
*fileName = strdup(separator);
if (*fileName == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
} else {
*string = strdup(value->str);
if (*string == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
ctx->password = strdup(password);
if (ctx->username == NULL || ctx->password == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
}
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
}
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
if (virAsprintf(&xpathExpression,
"/soapenv:Envelope/soapenv:Body/vim:%sResponse",
methodName) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
}
if (virAllocN(ptrptr, size, 1) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
*name = strdup(dynamicProperty->val->string);
if (*name == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
esxVI_Response *response = NULL;
if (virAsprintf(&methodName, "%s_Task", name) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
virBufferAddLit(&buffer, ESX_VI__SOAP__REQUEST_FOOTER);
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
virBufferAddLit(&buffer, ESX_VI__SOAP__REQUEST_FOOTER);
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
}
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
version = strdup("");
if (version == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
version = strdup(updateSet->version);
if (version == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
virBufferAddLit(&buffer, ESX_VI__SOAP__REQUEST_FOOTER);
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
virBufferAddLit(&buffer, ESX_VI__SOAP__REQUEST_FOOTER);
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
virBufferAddLit(&buffer, ESX_VI__SOAP__REQUEST_FOOTER);
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
virBufferAddLit(&buffer, ESX_VI__SOAP__REQUEST_FOOTER);
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
virBufferAddLit(&buffer, ESX_VI__SOAP__REQUEST_FOOTER);
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
virBufferAddLit(&buffer, ESX_VI__SOAP__REQUEST_FOOTER);
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
virBufferAddLit(&buffer, ESX_VI__SOAP__REQUEST_FOOTER);
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
virBufferAddLit(&buffer, ESX_VI__SOAP__REQUEST_FOOTER);
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
virBufferAddLit(&buffer, ESX_VI__SOAP__REQUEST_FOOTER);
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
virBufferAddLit(&buffer, ESX_VI__SOAP__REQUEST_FOOTER);
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
virBufferAddLit(&buffer, ESX_VI__SOAP__REQUEST_FOOTER);
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
virBufferAddLit(&buffer, ESX_VI__SOAP__REQUEST_FOOTER);
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
virBufferAddLit(&buffer, ESX_VI__SOAP__REQUEST_FOOTER);
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
virBufferAddLit(&buffer, ESX_VI__SOAP__REQUEST_FOOTER);
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
virBufferAddLit(&buffer, ESX_VI__SOAP__REQUEST_FOOTER);
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
virBufferAddLit(&buffer, ESX_VI__SOAP__REQUEST_FOOTER);
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
virBufferAddLit(&buffer, ESX_VI__SOAP__REQUEST_FOOTER);
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
virBufferAddLit(&buffer, ESX_VI__SOAP__REQUEST_FOOTER);
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
virBufferAddLit(&buffer, ESX_VI__SOAP__REQUEST_FOOTER);
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
(*anyType)->value = strdup("");
if ((*anyType)->value == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
}
string->value = strdup(value);
if (string->value == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
*dest = strdup(src);
if (*dest == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
(*string)->value = strdup("");
if ((*string)->value == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
}
*value = strdup("");
if (*value == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
}
if (virAsprintf(&datastoreRelatedPath, "[%s] %s", datastoreName,
directoryAndFileName) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
src = strdup(fileName);
if (src == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
/* Found single file name referencing a file inside a datastore */
if (virAsprintf(&src, "[%s] %s/%s", datastoreName, directoryName,
fileName) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
}
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
def->cpumasklen = 0;
if (VIR_ALLOC_N(def->cpumask, VIR_DOMAIN_CPUMASK_LEN) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
def->os.type = strdup("hvm");
if (def->os.type == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
}
if (def->os.arch == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
/* def:graphics */
if (VIR_ALLOC_N(def->graphics, 1) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
/* def:disks: 4 * 15 scsi + 2 * 2 ide + 2 floppy = 66 */
if (VIR_ALLOC_N(def->disks, 66) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
/* def:nets */
if (VIR_ALLOC_N(def->nets, 4) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
/* def:serials */
if (VIR_ALLOC_N(def->serials, 4) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
/* def:parallels */
if (VIR_ALLOC_N(def->parallels, 3) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
}
if (VIR_ALLOC(*def) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
}
if (VIR_ALLOC(*def) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
}
if (virAsprintf(&prefix, "scsi%d:%d", controller, id) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
(*def)->driverName = strdup(virtualDev);
if ((*def)->driverName == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
}
}
if (virAsprintf(&prefix, "ide%d:%d", controller, id) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
}
if (virAsprintf(&prefix, "floppy%d", controller) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
}
if (VIR_ALLOC(*def) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
}
if (VIR_ALLOC(*def) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
}
if (VIR_ALLOC(*def) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
if (directoryName == NULL) {
if (virAsprintf(&absolutePath, "/vmfs/volumes/%s/%s",
datastoreName, fileName) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
} else {
if (virAsprintf(&absolutePath, "/vmfs/volumes/%s/%s/%s",
datastoreName, directoryName, fileName) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
}
absolutePath = strdup(src);
if (absolutePath == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
} else {
/* Get final VMX output */
if (virBufferError(&buffer)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failure;
}
if (VIR_ALLOC(driverState) < 0)
{
- virReportOOMError(conn);
+ virReportOOMError();
goto alloc_error;
}
name = (char *)xmlSaveUri(conn->uri);
if (!name) {
- virReportOOMError (conn);
+ virReportOOMError();
goto error;
}
return name;
}
if (VIR_ALLOC_N(bytes, want) < 0) {
- virReportOOMError(stream->conn);
+ virReportOOMError();
goto cleanup;
}
if (VIR_ALLOC_N(bytes, want) < 0) {
- virReportOOMError(stream->conn);
+ virReportOOMError();
goto cleanup;
}
return 0;
no_memory:
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
}
if (virAsprintf(&oldroot, "%s/.oldroot", root->src) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto err;
}
/* Create a directory called 'new' in tmpfs */
if (virAsprintf(&newroot, "%s/new", oldroot) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto err;
}
char *devpts;
if (virAsprintf(&devpts, "/.oldroot%s/dev/pts", root->src) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return rc;
}
continue;
if (virAsprintf(&src, "/.oldroot/%s", vmDef->fss[i]->src) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
if (VIR_REALLOC_N(mounts, nmounts+1) < 0) {
endmntent(procmnt);
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
if (!(mounts[nmounts++] = strdup(mntent.mnt_dir))) {
endmntent(procmnt);
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
}
if (root) {
if (virAsprintf(&ttyPath, "%s%s", root->src, argv->ttyPath) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
} else {
if (!(ttyPath = strdup(argv->ttyPath))) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
}
/* allocate a stack for the container */
if (VIR_ALLOC_N(stack, stacksize) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
stacktop = stack + stacksize;
if (virAsprintf(&sockpath, "%s/%s.sock",
LXC_STATE_DIR, def->name) < 0)
- virReportOOMError(NULL);
+ virReportOOMError();
return sockpath;
}
if (virAsprintf(&devpts, "%s/dev/pts", root->src) < 0 ||
virAsprintf(&devptmx, "%s/dev/pts/ptmx", root->src) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
case 'n':
if ((name = strdup(optarg)) == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
break;
case 'v':
if (VIR_REALLOC_N(veths, nveths+1) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
if ((veths[nveths++] = strdup(optarg)) == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
break;
conn->uri = xmlParseURI("lxc:///");
if (!conn->uri) {
- virReportOOMError(conn);
+ virReportOOMError();
return VIR_DRV_OPEN_ERROR;
}
} else {
lxcDriverLock(driver);
if ((xml = virCapabilitiesFormatXML(driver->caps)) == NULL)
- virReportOOMError(conn);
+ virReportOOMError();
lxcDriverUnlock(driver);
return xml;
ret = strdup(vm->def->os.type);
if (ret == NULL)
- virReportOOMError(dom->conn);
+ virReportOOMError();
cleanup:
if (vm)
def->nets[i]->ifname = strdup(parentVeth);
}
if (VIR_REALLOC_N(*veths, (*nveths)+1) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error_exit;
}
if (((*veths)[(*nveths)] = strdup(containerVeth)) == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error_exit;
}
(*nveths)++;
if (NULL == def->nets[i]->ifname) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error_exit;
}
if (virAsprintf(&sockpath, "%s/%s.sock",
driver->stateDir, vm->def->name) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
return 0;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
cleanup:
if (largv) {
for (i = 0 ; i < largc ; i++)
if (virAsprintf(&logfile, "%s/%s.log",
driver->logDir, vm->def->name) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
return 0;
}
-static char *lxcGetSchedulerType(virDomainPtr domain, int *nparams)
+static char *lxcGetSchedulerType(virDomainPtr domain ATTRIBUTE_UNUSED,
+ int *nparams)
{
char *schedulerType = NULL;
schedulerType = strdup("posix");
if (schedulerType == NULL)
- virReportOOMError(domain->conn);
+ virReportOOMError();
return schedulerType;
}
char *pidpath;
if (virAsprintf(&pidpath, "/proc/%d/exe", obj->dnsmasqPid) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
if (virFileLinkPointsTo(pidpath, DNSMASQ) == 0)
return 0;
out_of_memory:
- virReportOOMError(NULL);
+ virReportOOMError();
error:
if (driverState)
static int
-networkBuildDnsmasqArgv(virConnectPtr conn,
- virNetworkObjPtr network,
+networkBuildDnsmasqArgv(virNetworkObjPtr network,
const char *pidfile,
const char ***argv) {
int i, len, r;
VIR_FREE((*argv)[i]);
VIR_FREE(*argv);
}
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
}
if (!(pidfile = virFilePid(NETWORK_PID_DIR, network->def->name))) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
argv = NULL;
- if (networkBuildDnsmasqArgv(conn, network, pidfile, &argv) < 0) {
+ if (networkBuildDnsmasqArgv(network, pidfile, &argv) < 0) {
VIR_FREE(pidfile);
return -1;
}
int ret = -1;
if (virAsprintf(&field, SYSCTL_PATH "/net/ipv6/conf/%s/disable_ipv6", network->def->bridge) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
VIR_FREE(field);
if (virAsprintf(&field, SYSCTL_PATH "/net/ipv6/conf/%s/accept_ra", network->def->bridge) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
VIR_FREE(field);
if (virAsprintf(&field, SYSCTL_PATH "/net/ipv6/conf/%s/autoconf", network->def->bridge) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
if (virNetworkObjIsActive(driver->networks.objs[i])) {
if (!(names[got] = strdup(driver->networks.objs[i]->def->name))) {
virNetworkObjUnlock(driver->networks.objs[i]);
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
got++;
if (!virNetworkObjIsActive(driver->networks.objs[i])) {
if (!(names[got] = strdup(driver->networks.objs[i]->def->name))) {
virNetworkObjUnlock(driver->networks.objs[i]);
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
got++;
bridge = strdup(network->def->bridge);
if (!bridge)
- virReportOOMError(net->conn);
+ virReportOOMError();
cleanup:
if (network)
VIR_FREE(dev->def->driver);
if (virAsprintf(&driver_link, "%s/driver", dev->def->sysfs_path) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
if (p) {
dev->def->driver = strdup(p+1);
if (!dev->def->driver) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
}
virNodeDeviceHasCap(driver->devs.objs[i], cap)) {
if ((names[ndevs++] = strdup(driver->devs.objs[i]->def->name)) == NULL) {
virNodeDeviceObjUnlock(driver->devs.objs[i]);
- virReportOOMError(conn);
+ virReportOOMError();
goto failure;
}
}
if (obj->def->parent) {
ret = strdup(obj->def->parent);
if (!ret)
- virReportOOMError(dev->conn);
+ virReportOOMError();
} else {
virNodeDeviceReportError(dev->conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("no parent for this device"));
for (caps = obj->def->caps; caps && ncaps < maxnames; caps = caps->next) {
names[ncaps] = strdup(virNodeDevCapTypeToString(caps->type));
if (names[ncaps++] == NULL) {
- virReportOOMError(dev->conn);
+ virReportOOMError();
goto cleanup;
}
}
parent_host,
operation_file) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
retval = -1;
goto cleanup;
}
wwpn,
wwnn) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
retval = -1;
goto cleanup;
}
obj = NULL;
if (parent_name == NULL) {
- virReportOOMError(dev->conn);
+ virReportOOMError();
goto out;
}
char *wwn_path = NULL;
if (virAsprintf(&wwn_path, "%s/host%d/%s", prefix, host, file) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
retval = -1;
goto out;
}
*wwn = strndup(p, sizeof(buf));
if (*wwn == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
retval = -1;
goto out;
}
if (virAsprintf(&sysfs_path, "%s/host%d",
LINUX_SYSFS_FC_HOST_PREFIX,
d->scsi_host.host) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
retval = -1;
goto out;
}
if (virAsprintf(&sysfs_path, "%s/host%d/vport_create",
LINUX_SYSFS_FC_HOST_PREFIX,
d->scsi_host.host) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
retval = -1;
goto out;
}
"with sysfs path '%s'\n", sysfs_path);
if (virBuildPath(&device_link, sysfs_path, "physfn") == -1) {
- virReportOOMError(NULL);
+ virReportOOMError();
} else {
ret = get_sriov_function(device_link, &d->pci_dev.physical_function);
if (ret == SRIOV_FOUND) {
unsigned int *num_funcs = &d->pci_dev.num_virtual_functions;
if (virBuildPath(&device_link, sysfs_path, entry->d_name) == -1) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto out;
}
VIR_DEBUG("Number of virtual functions: %d", *num_funcs);
if (VIR_REALLOC_N(d->pci_dev.virtual_functions,
(*num_funcs) + 1) != 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto out;
}
VIR_ERROR("Failed to allocate memory for property value for "
"property key '%s' on device with sysname '%s'",
property_key, udev_device_get_sysname(udev_device));
- virReportOOMError(NULL);
+ virReportOOMError();
ret = PROPERTY_ERROR;
goto out;
}
VIR_ERROR("Failed to allocate memory for sysfs attribute value for "
"sysfs attribute '%s' on device with sysname '%s'",
attr_name, udev_device_get_sysname(udev_device));
- virReportOOMError(NULL);
+ virReportOOMError();
ret = PROPERTY_ERROR;
goto out;
}
if (vendor_name != NULL) {
*vendor_string = strdup(vendor_name);
if (*vendor_string == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto out;
}
}
if (device_name != NULL) {
*product_string = strdup(device_name);
if (*product_string == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto out;
}
}
data->scsi_target.name = strdup(sysname);
if (data->scsi_target.name == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto out;
}
if (*typestring == NULL) {
if (foundtype == 1) {
ret = -1;
- virReportOOMError(NULL);
+ virReportOOMError();
} else {
VIR_ERROR("Failed to find SCSI device type %d", type);
}
data->storage.drive_type = strdup("disk");
if (data->storage.drive_type == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
ret = -1;
goto out;
}
VIR_FREE(def->caps->data.storage.drive_type);
def->caps->data.storage.drive_type = strdup("cdrom");
if (def->caps->data.storage.drive_type == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto out;
}
def->parent_sysfs_path = strdup(parent_sysfs_path);
if (def->parent_sysfs_path == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto out;
}
}
if (def->parent == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto out;
}
int ret = -1;
if (VIR_ALLOC(def) != 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto out;
}
}
if (VIR_ALLOC(def->caps) != 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto out;
}
int ret = -1;
if (VIR_ALLOC(def) != 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto out;
}
def->name = strdup("computer");
if (def->name == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto out;
}
if (VIR_ALLOC(def->caps) != 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto out;
}
int ret = 0;
if (VIR_ALLOC(priv) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
ret = -1;
goto out;
}
priv->watch = -1;
if (VIR_ALLOC(driverState) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
VIR_FREE(priv);
ret = -1;
goto out;
char* templ;
int oneid;
- if ((templ = xmlOneTemplate(conn,vm->def)) == NULL)
+ if ((templ = xmlOneTemplate(vm->def)) == NULL)
return -1;
if ((oneid = c_oneAllocateTemplate(templ)) < 0) {
* @return OpenNebula VM template.
*/
-char* xmlOneTemplate(virConnectPtr conn,virDomainDefPtr def)
+char* xmlOneTemplate(virDomainDefPtr def)
{
int i;
virBuffer buf= VIR_BUFFER_INITIALIZER;
return virBufferContentAndReset(&buf);
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
virBufferFreeAndReset(&buf);
return NULL;
};
int oneSubmitVM(virConnectPtr conn ,one_driver_t* driver, virDomainObjPtr vm);
-char* xmlOneTemplate(virConnectPtr conn,virDomainDefPtr def);
+char* xmlOneTemplate(virDomainDefPtr def);
#define oneError(conn, dom, code, fmt...) \
virReportErrorHelper(conn, VIR_FROM_ONE, code, __FILE__, \
if (conn->uri == NULL) {
conn->uri = xmlParseURI("one:///");
if (!conn->uri) {
- virReportOOMError(conn);
+ virReportOOMError();
return VIR_DRV_OPEN_ERROR;
}
} else if (conn->uri->scheme == NULL ||
ret = strdup(vm->def->os.type);
if (!ret)
- virReportOOMError(dom->conn);
+ virReportOOMError();
cleanup:
if (vm)
one_driver->nextid=1;
if ((one_driver->caps = oneCapsInit()) == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto error;
}
oneDriverUnlock(one_driver);
char *xml;
oneDriverLock(privconn);
if ((xml = virCapabilitiesFormatXML(privconn->caps)) == NULL)
- virReportOOMError(conn);
+ virReportOOMError();
oneDriverUnlock(privconn);
return xml;
}
return 0;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
error:
virDomainNetDefFree(net);
return -1;
return 0;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
error:
virDomainFSDefFree(fs);
return -1;
return 0;
no_memory:
- virReportOOMError(NULL);
+ virReportOOMError();
cleanup:
fclose(fp);
char line[PATH_MAX] ;
if (virAsprintf(&temp_file, "%s.tmp", conf_file)<0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
goto cleanup;
if (virAsprintf(&default_conf_file, "%s/ve-%s.conf-sample", confdir, configfile_value) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
}
if (!(ret = strdup(vm->def->os.type)))
- virReportOOMError(dom->conn);
+ virReportOOMError();
cleanup:
if (vm)
if (vmdef->os.init == NULL) {
if (!(vmdef->os.init = strdup("/sbin/init"))) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
}
if (vmdef->os.init == NULL) {
if (!(vmdef->os.init = strdup("/sbin/init"))) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
}
conn->uri = xmlParseURI("openvz:///system");
if (conn->uri == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
return VIR_DRV_OPEN_ERROR;
}
} else {
* here, don't return DECLINED, always use ERROR */
if (VIR_ALLOC(driver) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return VIR_DRV_OPEN_ERROR;
}
return got;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
for ( ; got >= 0 ; got--)
VIR_FREE(names[got]);
return -1;
}
if (VIR_ALLOC(phyp_driver) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto failure;
}
if (VIR_ALLOC(uuid_table) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto failure;
}
if (VIR_ALLOC(connection_data) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto failure;
}
len = strlen(conn->uri->path) + 1;
if (VIR_ALLOC_N(string, len) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto failure;
}
managed_system = strdup(conn->uri->path);
if (!managed_system) {
- virReportOOMError(conn);
+ virReportOOMError();
goto failure;
}
phyp_driver->managed_system = managed_system;
phyp_driver->uuid_table = uuid_table;
if ((phyp_driver->caps = phypCapsInit()) == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto failure;
}
goto err;
if (virAsprintf(&pubkey, "%s/.ssh/id_rsa.pub", userhome) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
if (virAsprintf(&pvtkey, "%s/.ssh/id_rsa", userhome) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
exit:
if (virBufferError(&tex_ret)) {
virBufferFreeAndReset(&tex_ret);
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
return virBufferContentAndReset(&tex_ret);
if (virAsprintf(&cmd,
"lssyscfg -r lpar -m %s --filter lpar_names=%s -F lpar_id",
managed_system, name) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
if (virAsprintf(&cmd,
"lssyscfg -r lpar -m %s --filter lpar_ids=%d -F name",
managed_system, lpar_id) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
"lshwres -m %s -r mem --level lpar -F curr_mem "
"--filter lpar_ids=%d",
managed_system, lpar_id) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
} else {
"lshwres -m %s -r mem --level lpar -F "
"curr_max_mem --filter lpar_ids=%d",
managed_system, lpar_id) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
}
"lshwres -m %s -r proc --level lpar -F "
"curr_max_procs --filter lpar_ids=%d",
managed_system, lpar_id) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
} else {
"lshwres -m %s -r proc --level lpar -F "
"curr_procs --filter lpar_ids=%d",
managed_system, lpar_id) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
}
"lshwres -m %s -r virtualio --rsubtype scsi -F "
"remote_slot_num --filter lpar_names=%s",
managed_system, lpar_name) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
ret = phypExec(session, cmd, &exit_status, conn);
"lshwres -m %s -r virtualio --rsubtype scsi -F "
"backing_devices --filter slots=%d",
managed_system, remote_slot) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
backing_device = strdup(char_ptr);
if (backing_device == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
} else {
if (virAsprintf(&cmd,
"lssyscfg -r lpar -m %s -F state --filter lpar_ids=%d",
managed_system, lpar_id) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
if (virAsprintf(&cmd,
"lssyscfg -m %s -r lpar -F lpar_id,lpar_env|grep "
"vioserver|sed -s 's/,.*$//g'", managed_system) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
"viosvrcmd -m %s -p %d -c \"lssp -field name type "
"-fmt , -all|grep %s|sed -e 's/^.*,//g'\"",
managed_system, vios_id, backing_device) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
if (virAsprintf(&cmd,
"lssyscfg -r lpar -m %s -F lpar_id,state %s |grep -c "
"^[0-9]*", managed_system, state) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
(&cmd,
"lssyscfg -r lpar -m %s -F lpar_id,state %s | sed -e 's/,.*$//g'",
managed_system, state) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
ret = phypExec(session, cmd, &exit_status, conn);
(&cmd,
"lssyscfg -r lpar -m %s -F name,state | grep \"Not Activated\" | "
"sed -e 's/,.*$//g'", managed_system) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
if (char_ptr2) {
*char_ptr2 = '\0';
if ((names[got++] = strdup(domains)) == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
char_ptr2++;
(&cmd,
"chsysstate -m %s -r lpar -o on --id %d -f %s",
managed_system, dom->id, dom->name) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto err;
}
(&cmd,
"chsysstate -m %s -r lpar -o shutdown --id %d",
managed_system, dom->id) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto err;
}
if (virAsprintf
(&cmd,
"rmsyscfg -m %s -r lpar --id %d", managed_system, dom->id) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto err;
}
char *xml;
if ((xml = virCapabilitiesFormatXML(phyp_driver->caps)) == NULL)
- virReportOOMError(conn);
+ virReportOOMError();
return xml;
}
"chhwres -r proc -m %s --id %d -o %c --procunits %d 2>&1 |sed"
"-e 's/^.*\\([0-9]\\+.[0-9]\\+\\).*$/\\1/g'",
managed_system, dom->id, operation, amount) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto err;
}
managed_system, def->name, (int) def->memory,
(int) def->memory, (int) def->maxmem, (int) def->vcpus,
def->disks[0]->src) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
i--;
if (VIR_REALLOC_N(uuid_table->lpars, uuid_table->nlpars) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
if (VIR_ALLOC(uuid_table->lpars[i]) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
rc = read(fd, &id, sizeof(int));
if (rc == sizeof(int)) {
if (VIR_ALLOC(uuid_table->lpars[i]) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
uuid_table->lpars[i]->id = id;
}
}
} else
- virReportOOMError(conn);
+ virReportOOMError();
close(fd);
return 0;
return 0;
if (VIR_ALLOC_N(ids, nids) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
if (VIR_ALLOC_N(uuid_table->lpars, uuid_table->nlpars) >= 0) {
for (i = 0; i < uuid_table->nlpars; i++) {
if (VIR_ALLOC(uuid_table->lpars[i]) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
uuid_table->lpars[i]->id = ids[i];
ids[i]);
}
} else {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
driver->dynamicOwnership = 1;
if (!(driver->vncListen = strdup("127.0.0.1"))) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
if (!(driver->vncTLSx509certdir = strdup(SYSCONF_DIR "/pki/libvirt-vnc"))) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
if (p && p->str) {
VIR_FREE(driver->vncTLSx509certdir);
if (!(driver->vncTLSx509certdir = strdup(p->str))) {
- virReportOOMError(NULL);
+ virReportOOMError();
virConfFree(conf);
return -1;
}
if (p && p->str) {
VIR_FREE(driver->vncListen);
if (!(driver->vncListen = strdup(p->str))) {
- virReportOOMError(NULL);
+ virReportOOMError();
virConfFree(conf);
return -1;
}
if (p && p->str) {
VIR_FREE(driver->vncPassword);
if (!(driver->vncPassword = strdup(p->str))) {
- virReportOOMError(NULL);
+ virReportOOMError();
virConfFree(conf);
return -1;
}
CHECK_TYPE ("security_driver", VIR_CONF_STRING);
if (p && p->str) {
if (!(driver->securityDriverName = strdup(p->str))) {
- virReportOOMError(NULL);
+ virReportOOMError();
virConfFree(conf);
return -1;
}
if (p && p->str) {
VIR_FREE(driver->vncSASLdir);
if (!(driver->vncSASLdir = strdup(p->str))) {
- virReportOOMError(NULL);
+ virReportOOMError();
virConfFree(conf);
return -1;
}
p = virConfGetValue (conf, "user");
CHECK_TYPE ("user", VIR_CONF_STRING);
if (!(user = strdup(p && p->str ? p->str : QEMU_USER))) {
- virReportOOMError(NULL);
+ virReportOOMError();
virConfFree(conf);
return -1;
}
p = virConfGetValue (conf, "group");
CHECK_TYPE ("group", VIR_CONF_STRING);
if (!(group = strdup(p && p->str ? p->str : QEMU_GROUP))) {
- virReportOOMError(NULL);
+ virReportOOMError();
virConfFree(conf);
return -1;
}
for (pp = p->list; pp; pp = pp->next)
len++;
if (VIR_ALLOC_N(driver->cgroupDeviceACL, 1+len) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
virConfFree(conf);
return -1;
}
}
driver->cgroupDeviceACL[i] = strdup (pp->str);
if (driver->cgroupDeviceACL[i] == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
virConfFree(conf);
return -1;
}
if (p && p->str) {
VIR_FREE(driver->saveImageFormat);
if (!(driver->saveImageFormat = strdup(p->str))) {
- virReportOOMError(NULL);
+ virReportOOMError();
virConfFree(conf);
return -1;
}
if (p && p->str) {
VIR_FREE(driver->hugetlbfs_mount);
if (!(driver->hugetlbfs_mount = strdup(p->str))) {
- virReportOOMError(NULL);
+ virReportOOMError();
virConfFree(conf);
return -1;
}
return 0;
no_memory:
- virReportOOMError(NULL);
+ virReportOOMError();
virCapabilitiesFreeMachines(list, nitems);
return -1;
}
}
if (VIR_ALLOC_N(list, info->nmachines) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return 0;
}
return 1;
no_memory:
- virReportOOMError(NULL);
+ virReportOOMError();
virCapabilitiesFreeMachines(list, info->nmachines);
return 0;
}
}
if (parse(output, count, cpus) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
return ret;
no_memory:
- virReportOOMError(NULL);
+ virReportOOMError();
error:
virCapabilitiesFreeMachines(machines, nmachines);
if (VIR_ALLOC(cpu) < 0
|| !(cpu->arch = strdup(arch))) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto error;
}
return -1;
} else if (net->type == VIR_DOMAIN_NET_TYPE_BRIDGE) {
if (!(brname = strdup(net->data.bridge.brname))) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
} else {
strchr(net->ifname, '%')) {
VIR_FREE(net->ifname);
if (!(net->ifname = strdup("vnet%d"))) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
/* avoid exposing vnet%d in dumpxml or error outputs */
devname = strdup(disk->dst);
if (!devname) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
}
if (ret == -1) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
return 0;
no_memory:
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
}
if (virAsprintf(&net->info.alias, "net%d", idx) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
}
if (virAsprintf(&hostdev->info.alias, "hostdev%d", idx) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
if (virAsprintf(&controller->info.alias, "%s%d", prefix,
controller->idx) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
return 0;
no_memory:
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
dev->addr.pci.domain,
dev->addr.pci.bus,
dev->addr.pci.slot) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
return addr;
return addrs;
no_memory:
- virReportOOMError(NULL);
+ virReportOOMError();
error:
qemuDomainPCIAddressSetFree(addrs);
return NULL;
}
if (virBufferError(&opt)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto error;
}
virBufferVSprintf(&opt, ",id=%s", disk->info.alias);
if (virBufferError(&opt)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto error;
}
goto error;
if (virBufferError(&buf)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto error;
}
char *
-qemuBuildNicStr(virConnectPtr conn,
+qemuBuildNicStr(virConnectPtr conn ATTRIBUTE_UNUSED /*TEMPORARY*/,
virDomainNetDefPtr net,
const char *prefix,
int vlan)
(net->model ? net->model : ""),
(net->info.alias ? ",name=" : ""),
(net->info.alias ? net->info.alias : "")) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
goto error;
if (virBufferError(&buf)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto error;
}
char *
-qemuBuildHostNetStr(virConnectPtr conn,
+qemuBuildHostNetStr(virConnectPtr conn ATTRIBUTE_UNUSED /*TEMPORARY*/,
virDomainNetDefPtr net,
char type_sep,
int vlan,
if (virBufferError(&buf)) {
virBufferFreeAndReset(&buf);
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
goto error;
if (virBufferError(&buf)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto error;
}
virBufferVSprintf(&buf, ",id=%s", dev->info.alias);
if (virBufferError(&buf)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto error;
}
goto error;
if (virBufferError(&buf)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto error;
}
goto error;
if (virBufferError(&buf)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto error;
}
dev->source.subsys.u.pci.bus,
dev->source.subsys.u.pci.slot,
dev->source.subsys.u.pci.function) < 0)
- virReportOOMError(NULL);
+ virReportOOMError();
return ret;
}
dev->source.subsys.u.usb.bus,
dev->source.subsys.u.usb.device,
dev->info.alias) < 0)
- virReportOOMError(NULL);
+ virReportOOMError();
return ret;
}
if (virAsprintf(&ret, "host:%.3d.%.3d",
dev->source.subsys.u.usb.bus,
dev->source.subsys.u.usb.device) < 0)
- virReportOOMError(NULL);
+ virReportOOMError();
return ret;
}
}
if (virBufferError(&buf)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto error;
}
}
if (virBufferError(&buf)) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto error;
}
return ret;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
static char *
-qemuBuildSmpArgStr(virConnectPtr conn,
- const virDomainDefPtr def,
+qemuBuildSmpArgStr(const virDomainDefPtr def,
int qemuCmdFlags)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
if (virBufferError(&buf)) {
virBufferFreeAndReset(&buf);
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
}
ADD_ARG_LIT("-smp");
- if (!(smp = qemuBuildSmpArgStr(conn, def, qemuCmdFlags)))
+ if (!(smp = qemuBuildSmpArgStr(def, qemuCmdFlags)))
goto error;
ADD_ARG(smp);
return 0;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
error:
if (tapfds &&
*tapfds) {
for (i = 0 ; i < argcount ; i++)
VIR_FREE(arglist[i]);
VIR_FREE(arglist);
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
return keywordCount;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
error:
for (i = 0 ; i < keywordCount ; i++) {
VIR_FREE(keywords[i]);
return NULL;
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
if (!def->driverName) {
virDomainDiskDefFree(def);
def = NULL;
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
def->driverType = values[i];
if (!def->dst) {
virDomainDiskDefFree(def);
def = NULL;
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
if (STREQ(def->dst, "xvda"))
}
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
}
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
}
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
return def;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
error:
virDomainChrDefFree(def);
return NULL;
static virCPUDefPtr
-qemuInitGuestCPU(virConnectPtr conn,
- virDomainDefPtr dom)
+qemuInitGuestCPU(virDomainDefPtr dom)
{
if (!dom->cpu) {
virCPUDefPtr cpu;
if (VIR_ALLOC(cpu) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
const char *p = val;
const char *next;
- if (!(cpu = qemuInitGuestCPU(conn, dom)))
+ if (!(cpu = qemuInitGuestCPU(dom)))
goto error;
do {
goto error;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
error:
return -1;
}
if (sockets && cores && threads) {
virCPUDefPtr cpu;
- if (!(cpu = qemuInitGuestCPU(conn, dom)))
+ if (!(cpu = qemuInitGuestCPU(dom)))
goto error;
cpu->sockets = sockets;
cpu->cores = cores;
return def;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
error:
virDomainDefFree(def);
VIR_FREE(nics);
xmlNodePtr *nodes = NULL;
if (VIR_ALLOC(priv->monConfig) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto error;
}
if (!(priv->monConfig->info.alias = strdup("monitor"))) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto error;
}
if (n) {
priv->nvcpupids = n;
if (VIR_REALLOC_N(priv->vcpupids, priv->nvcpupids) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto error;
}
if ((ret = snprintf(logfile, sizeof(logfile), "%s/%s.log",
driver->logDir, name))
< 0 || ret >= sizeof(logfile)) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
* Returns 0 on success
*/
static int
-qemudRemoveDomainStatus(virConnectPtr conn,
- struct qemud_driver *driver,
+qemudRemoveDomainStatus(struct qemud_driver *driver,
virDomainObjPtr vm)
{
char ebuf[1024];
char *file = NULL;
if (virAsprintf(&file, "%s/%s.xml", driver->stateDir, vm->def->name) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return(-1);
}
if (VIR_ALLOC_N(passphrase, size + 1) < 0) {
memset(data, 0, size);
VIR_FREE(data);
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
memcpy(passphrase, data, size);
/* Basic host arch / guest machine capabilities */
if (!(caps = qemudCapsInit(oldcaps))) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
return caps;
no_memory:
- virReportOOMError(NULL);
+ virReportOOMError();
virCapabilitiesFree(caps);
return NULL;
}
return 0;
out_of_memory:
- virReportOOMError(NULL);
+ virReportOOMError();
error:
if (qemu_driver)
qemuDriverUnlock(qemu_driver);
* Returns -1 for error, 0 success, 1 continue reading
*/
static int
-qemudExtractTTYPath(virConnectPtr conn,
- const char *haystack,
+qemudExtractTTYPath(const char *haystack,
size_t *offset,
char **path)
{
if (c_isspace(*tmp)) {
*path = strndup(dev, tmp-dev);
if (*path == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
chr->data.file.path = strdup(path); \
\
if (chr->data.file.path == NULL) { \
- virReportOOMError(conn); \
+ virReportOOMError(); \
return -1; \
} \
} \
}
static int
-qemudFindCharDevicePTYs(virConnectPtr conn,
+qemudFindCharDevicePTYs(virConnectPtr conn ATTRIBUTE_UNUSED /*TEMPORARY*/,
virDomainObjPtr vm,
const char *output,
int fd ATTRIBUTE_UNUSED)
for (i = 0 ; i < vm->def->nserials ; i++) {
virDomainChrDefPtr chr = vm->def->serials[i];
if (chr->type == VIR_DOMAIN_CHR_TYPE_PTY) {
- if ((ret = qemudExtractTTYPath(conn, output, &offset,
+ if ((ret = qemudExtractTTYPath(output, &offset,
&chr->data.file.path)) != 0)
return ret;
}
for (i = 0 ; i < vm->def->nparallels ; i++) {
virDomainChrDefPtr chr = vm->def->parallels[i];
if (chr->type == VIR_DOMAIN_CHR_TYPE_PTY) {
- if ((ret = qemudExtractTTYPath(conn, output, &offset,
+ if ((ret = qemudExtractTTYPath(output, &offset,
&chr->data.file.path)) != 0)
return ret;
}
for (i = 0 ; i < vm->def->nchannels ; i++) {
virDomainChrDefPtr chr = vm->def->channels[i];
if (chr->type == VIR_DOMAIN_CHR_TYPE_PTY) {
- if ((ret = qemudExtractTTYPath(conn, output, &offset,
+ if ((ret = qemudExtractTTYPath(output, &offset,
&chr->data.file.path)) != 0)
return ret;
}
* log output method. */
virHashTablePtr paths = virHashCreate(0);
if (paths == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
if (vm->def->virtType != VIR_DOMAIN_VIRT_KVM) {
priv->nvcpupids = 1;
if (VIR_ALLOC_N(priv->vcpupids, priv->nvcpupids) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
priv->vcpupids[0] = vm->pid;
cpumaplen = VIR_CPU_MAPLEN(maxcpu);
if (VIR_ALLOC_N(cpumap, cpumaplen) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
}
static int
-qemuPrepareMonitorChr(virConnectPtr conn,
- struct qemud_driver *driver,
+qemuPrepareMonitorChr(struct qemud_driver *driver,
virDomainChrDefPtr monConfig,
const char *vm)
{
monConfig->data.nix.listen = 1;
if (!(monConfig->info.alias = strdup("monitor"))) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
if (virAsprintf(&monConfig->data.nix.path, "%s/%s.monitor",
driver->libDir, vm) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
goto cleanup;
if (VIR_ALLOC(priv->monConfig) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
- if (qemuPrepareMonitorChr(conn, driver, priv->monConfig, vm->def->name) < 0)
+ if (qemuPrepareMonitorChr(driver, priv->monConfig, vm->def->name) < 0)
goto cleanup;
#if HAVE_YAJL
vm->def->name);
}
- qemudRemoveDomainStatus(conn, driver, vm);
+ qemudRemoveDomainStatus(driver, vm);
vm->pid = -1;
vm->def->id = -1;
"qemu:///system" :
"qemu:///session");
if (!conn->uri) {
- virReportOOMError(conn);
+ virReportOOMError();
return VIR_DRV_OPEN_ERROR;
}
} else {
qemu_driver->caps = caps;
if ((xml = virCapabilitiesFormatXML(driver->caps)) == NULL)
- virReportOOMError(conn);
+ virReportOOMError();
cleanup:
qemuDriverUnlock(driver);
}
if (!(type = strdup(vm->def->os.type)))
- virReportOOMError(dom->conn);
+ virReportOOMError();
cleanup:
if (vm)
}
if (VIR_ALLOC_N(xml, header.xml_len) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
goto cleanup;
}
- if (qemuPrepareMonitorChr(conn, driver, &monConfig, def->name) < 0)
+ if (qemuPrepareMonitorChr(driver, &monConfig, def->name) < 0)
goto cleanup;
if (qemudBuildCommandLine(conn, driver, def,
if (virBufferError(&buf)) {
virBufferFreeAndReset(&buf);
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
continue;
if (!(*canonical = strdup(machine->canonical))) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
int i, nmachines = 0;
if (qemudProbeMachineTypes(def->emulator, &machines, &nmachines) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
}
if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks+1) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
}
if (!(devstr = qemuBuildControllerDevStr(controller))) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
if (VIR_REALLOC_N(vm->def->controllers, vm->def->ncontrollers+1) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
/* No SCSI controller present, for back compatability we
* now hotplug a controller */
if (VIR_ALLOC(cont) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
cont->type = VIR_DOMAIN_CONTROLLER_TYPE_SCSI;
}
if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks+1) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
}
if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks+1) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
goto cleanup;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
char *devstr = NULL;
if (VIR_REALLOC_N(vm->def->hostdevs, vm->def->nhostdevs+1) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
}
-static int qemudDomainAttachHostUsbDevice(virConnectPtr conn,
- struct qemud_driver *driver,
+static int qemudDomainAttachHostUsbDevice(struct qemud_driver *driver,
virDomainObjPtr vm,
virDomainHostdevDefPtr hostdev,
int qemuCmdFlags)
goto error;
if (VIR_REALLOC_N(vm->def->hostdevs, vm->def->nhostdevs+1) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
break;
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB:
- if (qemudDomainAttachHostUsbDevice(conn, driver, vm,
+ if (qemudDomainAttachHostUsbDevice(driver, vm,
hostdev, qemuCmdFlags) < 0)
goto error;
break;
}
if (virAsprintf(&hostnet_name, "host%s", detach->info.alias) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
ret = strdup("posix");
if (!ret)
- virReportOOMError(dom->conn);
+ virReportOOMError();
cleanup:
qemuDriverUnlock(driver);
}
if (virAsprintf(&tmp, driver->cacheDir, "/qemu.mem.XXXXXX") < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto endjob;
}
int ret;
if (VIR_ALLOC(qemust) < 0) {
- virReportOOMError(st->conn);
+ virReportOOMError();
return NULL;
}
if (virAsprintf(&unixfile, "%s/qemu.tunnelmigrate.dest.%s",
driver->stateDir, vm->def->name) < 0) {
- virReportOOMError (dconn);
+ virReportOOMError();
goto endjob;
}
unlink(unixfile);
goto endjob;
}
if (internalret < 0) {
- virReportOOMError(dconn);
+ virReportOOMError();
goto endjob;
}
/* Start the QEMU daemon, with the same command-line arguments plus
internalret = virAsprintf(uri_out, "tcp:%s:%d", hostname, this_port);
VIR_FREE(hostname);
if (internalret < 0) {
- virReportOOMError (dconn);
+ virReportOOMError();
goto cleanup;
}
} else {
/* Caller frees */
if (virAsprintf(uri_out, "%s:%d", uri_in, this_port) < 0) {
- virReportOOMError (dconn);
+ virReportOOMError();
goto cleanup;
}
/* HACK: source host generates bogus URIs, so fix them up */
char *tmpuri;
if (virAsprintf(&tmpuri, "tcp://%s", uri + strlen("tcp:")) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto cleanup;
}
uribits = xmlParseURI(tmpuri);
if (virAsprintf(&unixfile, "%s/qemu.tunnelmigrate.src.%s",
driver->stateDir, vm->def->name) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto cleanup;
}
}
if (VIR_ALLOC(mon) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
memset(&msg, 0, sizeof msg);
if (!(cmdstr = virJSONValueToString(cmd))) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
if (virAsprintf(&msg.txBuffer, "%s\r\n", cmdstr) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
msg.txLength = strlen(msg.txBuffer);
return 0;
no_memory:
- virReportOOMError(NULL);
+ virReportOOMError();
virJSONValueFree(timestamp);
return -1;
}
return obj;
no_memory:
- virReportOOMError(NULL);
+ virReportOOMError();
error:
virJSONValueFree(obj);
virJSONValueFree(jargs);
}
if (VIR_REALLOC_N(threads, ncpus) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
virJSONValuePtr cmd;
virJSONValuePtr reply = NULL;
if (virAsprintf(&bandwidthstr, "%lum", bandwidth) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
cmd = qemuMonitorJSONMakeCommand("migrate_set_speed",
int ret;
if (virAsprintf(&uri, "tcp:%s:%d", hostname, port) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
argstr = virArgvToString(argv);
if (!argstr) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
/* Migrate to file */
safe_target = qemuMonitorEscapeShell(target);
if (!safe_target) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
if (virAsprintf(&dest, "exec:%s >>%s 2>/dev/null", argstr, safe_target) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
int ret = -1;
if (virAsprintf(&dest, "unix:%s", unixfile) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
char *disk;
if (virAsprintf(&disk, "disk:%s", path) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
char *addr;
if (virAsprintf(&addr, "host:%.3d.%.3d", bus, dev) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
char *addr;
if (virAsprintf(&addr, "host:%.4x:%.4x", vendor, product) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
/* XXX hostDomain */
if (virAsprintf(&dev, "host=%.2x:%.2x.%.1x",
hostAddr->bus, hostAddr->slot, hostAddr->function) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
memset(guestAddr, 0, sizeof(*guestAddr));
if (virAsprintf(&dev, "file=%s,if=%s", path, bus) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
/* XXX what about function ? */
if (virAsprintf(&addr, "%.4x:%.2x:%.2x",
guestAddr->domain, guestAddr->bus, guestAddr->slot) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
if (STRPREFIX(type, "pty:")) {
char *path = strdup(type + strlen("pty:"));
if (!path) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
memset(guestAddr, 0, sizeof(*guestAddr));
if (virAsprintf(&dev, "if=%s", bus) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
if (virAsprintf(&dev, "%.2x:%.2x.%.1x",
controllerAddr->bus, controllerAddr->slot, controllerAddr->function) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
memset(&msg, 0, sizeof msg);
if (virAsprintf(&msg.txBuffer, "%s\r", cmd) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
msg.txLength = strlen(msg.txBuffer);
} else {
*reply = strdup("");
if (!*reply) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
}
* we just worked in bytes with unsigned long long everywhere.
*/
if (virAsprintf(&cmd, "balloon %lu", (newmem / 1024)) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
int ret = -1;
if (virAsprintf(&cmd, "eject %s", devname) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
int ret = -1;
if (!(safepath = qemuMonitorEscapeArg(newmedia))) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
if (virAsprintf(&cmd, "change %s \"%s\"", devname, safepath) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
int ret = -1;
if (!(safepath = qemuMonitorEscapeArg(path))) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
if (virAsprintf(&cmd, "%s %llu %zi \"%s\"", cmdtype, offset, length, safepath) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
int ret = -1;
if (virAsprintf(&cmd, "migrate_set_speed %lum", bandwidth) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
const char *extra;
if (!safedest) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
extra = " ";
if (virAsprintf(&cmd, "migrate %s\"%s\"", extra, safedest) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
int ret;
if (virAsprintf(&uri, "tcp:%s:%d", hostname, port) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
argstr = virArgvToString(argv);
if (!argstr) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
/* Migrate to file */
safe_target = qemuMonitorEscapeShell(target);
if (!safe_target) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
if (virAsprintf(&dest, "exec:%s >>%s 2>/dev/null", argstr, safe_target) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
int ret = -1;
if (virAsprintf(&dest, "unix:%s", unixfile) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
safepath = qemuMonitorEscapeArg(path);
if (!safepath) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
if (virAsprintf(&cmd, "usb_add disk:%s", safepath) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
int ret = -1;
if (virAsprintf(&cmd, "usb_add %s", addr) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
char *addr;
if (virAsprintf(&addr, "host:%.3d.%.3d", bus, dev) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
char *addr;
if (virAsprintf(&addr, "host:%.4x:%.4x", vendor, product) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
/* XXX hostAddr->domain */
if (virAsprintf(&cmd, "pci_add pci_addr=auto host host=%.2x:%.2x.%.1x",
hostAddr->bus, hostAddr->slot, hostAddr->function) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
safe_path = qemuMonitorEscapeArg(path);
if (!safe_path) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
try_command:
if (virAsprintf(&cmd, "pci_add %s storage file=%s,if=%s",
(tryOldSyntax ? "0": "pci_addr=auto"), safe_path, bus) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
int ret = -1;
if (virAsprintf(&cmd, "pci_add pci_addr=auto nic %s", nicstr) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
try_command:
if (tryOldSyntax) {
if (virAsprintf(&cmd, "pci_del 0 %.2x", guestAddr->slot) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
} else {
/* XXX function ? */
if (virAsprintf(&cmd, "pci_del pci_addr=%.4x:%.2x:%.2x",
guestAddr->domain, guestAddr->bus, guestAddr->slot) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
}
int ret = -1;
if (virAsprintf(&cmd, "getfd %s", fdname) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
int ret = -1;
if (virAsprintf(&cmd, "closefd %s", fdname) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
int ret = -1;
if (virAsprintf(&cmd, "host_net_add %s", netstr) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
int ret = -1;
if (virAsprintf(&cmd, "host_net_remove %d %s", vlan, netname) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
*eol = '\0';
char *path = strdup(needle + strlen(NEEDLE));
if (path == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
try_command:
if (virAsprintf(&cmd, "pci_add %s storage if=%s",
(tryOldSyntax ? "0": "pci_addr=auto"), bus) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
safe_str = qemuMonitorEscapeArg(drivestr);
if (!safe_str) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
controllerAddr->domain, controllerAddr->bus,
controllerAddr->slot, safe_str);
if (ret == -1) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
GET_INT(p, 16, product);
if (VIR_REALLOC_N(addrs, naddrs+1) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto error;
}
int ret = -1;
if (!(safedev = qemuMonitorEscapeArg(devicestr))) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
if (virAsprintf(&cmd, "device_add %s", safedev) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
safe_str = qemuMonitorEscapeArg(drivestr);
if (!safe_str) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
* address required when attaching drives to a controller */
ret = virAsprintf(&cmd, "drive_add dummy %s", safe_str);
if (ret == -1) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
}
if (!name) {
- virReportOOMError(conn);
+ virReportOOMError();
goto failed;
}
conn->uri = xmlParseURI(uriret.uri);
VIR_FREE(uriret.uri);
if (!conn->uri) {
- virReportOOMError (conn);
+ virReportOOMError();
goto failed;
}
}
if(VIR_ALLOC(priv->callbackList)<0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto failed;
}
if(VIR_ALLOC(priv->domainEvents)<0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto failed;
}
return retcode;
out_of_memory:
- virReportOOMError (conn);
+ virReportOOMError();
failed:
/* Close the socket if we failed. */
{
struct private_data *priv;
if (VIR_ALLOC(priv) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
}
/* Serialise the scheduler parameters. */
args.params.params_len = nparams;
if (VIR_ALLOC_N(args.params.params_val, nparams) < 0) {
- virReportOOMError(domain->conn);
+ virReportOOMError();
goto done;
}
// call() will free this:
args.params.params_val[i].field = strdup (params[i].field);
if (args.params.params_val[i].field == NULL) {
- virReportOOMError (domain->conn);
+ virReportOOMError();
do_error = 1;
}
args.params.params_val[i].value.type = params[i].type;
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
}
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
}
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
}
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
}
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
}
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
}
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
- virReportOOMError(pool->conn);
+ virReportOOMError();
goto cleanup;
}
}
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
}
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
- virReportOOMError(dev->conn);
+ virReportOOMError();
goto cleanup;
}
}
}
if (virAsprintf(&addr, "%s;%s", host, port) == -1) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
for (--i; i >= 0; --i)
VIR_FREE(uuids[i]);
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
}
struct private_stream_data *stpriv;
if (VIR_ALLOC(stpriv) < 0) {
- virReportOOMError(st->conn);
+ virReportOOMError();
return NULL;
}
memset(&hdr, 0, sizeof hdr);
if (VIR_ALLOC(thiscall) < 0) {
- virReportOOMError(st->conn);
+ virReportOOMError();
return -1;
}
struct remote_thread_call *thiscall;
if (VIR_ALLOC(thiscall) < 0) {
- virReportOOMError(st->conn);
+ virReportOOMError();
goto cleanup;
}
struct remote_thread_call *rv;
if (VIR_ALLOC(rv) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
ret_filter, ret);
if (!thiscall) {
- virReportOOMError (flags & REMOTE_CALL_IN_OPEN ? NULL : conn);
+ virReportOOMError();
return -1;
}
int fd = -1, ret = -1;
if (virAsprintf(&tmp_path, "%sXXXXXX", filename) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
fd = mkstemp (tmp_path);
}
static char *
-secretComputePath(virConnectPtr conn, virSecretDriverStatePtr driver,
+secretComputePath(virSecretDriverStatePtr driver,
const virSecretEntry *secret, const char *suffix)
{
char *ret;
if (virAsprintf(&ret, "%s/%s%s", driver->directory, uuidstr, suffix) < 0)
/* ret is NULL */
- virReportOOMError(conn);
+ virReportOOMError();
return ret;
}
static char *
-secretXMLPath(virConnectPtr conn, virSecretDriverStatePtr driver,
+secretXMLPath(virConnectPtr conn ATTRIBUTE_UNUSED /*TEMPORARY*/,
+ virSecretDriverStatePtr driver,
const virSecretEntry *secret)
{
- return secretComputePath(conn, driver, secret, ".xml");
+ return secretComputePath(driver, secret, ".xml");
}
static char *
-secretBase64Path(virConnectPtr conn, virSecretDriverStatePtr driver,
+secretBase64Path(virConnectPtr conn ATTRIBUTE_UNUSED /*TEMPORARY*/,
+ virSecretDriverStatePtr driver,
const virSecretEntry *secret)
{
- return secretComputePath(conn, driver, secret, ".base64");
+ return secretComputePath(driver, secret, ".base64");
}
static int
base64_encode_alloc((const char *)secret->value, secret->value_size,
&base64);
if (base64 == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
}
if (VIR_ALLOC_N(contents, st.st_size) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
if (saferead(fd, contents, st.st_size) != st.st_size) {
goto cleanup;
}
if (value == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
if (virAsprintf(&xml_filename, "%s/%s", driver->directory,
xml_basename) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
def = virSecretDefParseFile(conn, xml_filename);
goto cleanup;
if (VIR_ALLOC(secret) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
secret->def = def;
if (i == maxuuids)
break;
if (VIR_ALLOC_N(uuidstr, VIR_UUID_STRING_BUFLEN) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
virUUIDFormat(secret->def->uuid, uuidstr);
/* No existing secret at all, create one */
if (VIR_ALLOC(secret) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
virSecretEntryPtr secret;
if (VIR_ALLOC_N(new_value, value_size) < 0) {
- virReportOOMError(obj->conn);
+ virReportOOMError();
return -1;
}
}
if (VIR_ALLOC_N(ret, secret->value_size) < 0) {
- virReportOOMError(obj->conn);
+ virReportOOMError();
goto cleanup;
}
memcpy(ret, secret->value, secret->value_size);
/* create string that is '<str> \0' for accurate matching */
if (virAsprintf(&tmp, "%s ", str) == -1) {
- virReportOOMError(NULL);
+ virReportOOMError();
return rc;
}
/* create string that is '<str> (enforce)\0' for accurate matching */
if (virAsprintf(&etmp, "%s (enforce)", str) == -1) {
VIR_FREE(tmp);
- virReportOOMError(NULL);
+ virReportOOMError();
return rc;
}
}
int len;
if (virAsprintf(&profile, "%s/%s", APPARMOR_DIR "/libvirt", str) == -1) {
- virReportOOMError(NULL);
+ virReportOOMError();
return rc;
}
/* create string that is ' <str> flags=(complain)\0' */
if (virAsprintf(&tmp, " %s flags=(complain)", str) == -1) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto failed;
}
}
static char *
-get_profile_name(virConnectPtr conn, virDomainObjPtr vm)
+get_profile_name(virDomainObjPtr vm)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
char *name = NULL;
virUUIDFormat(vm->def->uuid, uuidstr);
if (virAsprintf(&name, "%s%s", AA_PREFIX, uuidstr) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
/* see if template file exists */
if (virAsprintf(&template, "%s/TEMPLATE",
APPARMOR_DIR "/libvirt") == -1) {
- virReportOOMError(NULL);
+ virReportOOMError();
return rc;
}
return rc;
}
- if ((profile_name = get_profile_name(conn, vm)) == NULL)
+ if ((profile_name = get_profile_name(vm)) == NULL)
return rc;
vm->def->seclabel.label = strndup(profile_name, strlen(profile_name));
if (!vm->def->seclabel.label) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto clean;
}
vm->def->seclabel.imagelabel = strndup(profile_name,
strlen(profile_name));
if (!vm->def->seclabel.imagelabel) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto err;
}
vm->def->seclabel.model = strdup(SECURITY_APPARMOR_NAME);
if (!vm->def->seclabel.model) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
int rc = -1;
char *profile_name = NULL;
- if ((profile_name = get_profile_name(conn, vm)) == NULL)
+ if ((profile_name = get_profile_name(vm)) == NULL)
return rc;
if (virStrcpy(sec->label, profile_name,
int rc = -1;
char *profile_name = NULL;
- if ((profile_name = get_profile_name(conn, vm)) == NULL)
+ if ((profile_name = get_profile_name(vm)) == NULL)
return rc;
if (STRNEQ(drv->name, secdef->model)) {
if (secdef->type == VIR_DOMAIN_SECLABEL_STATIC)
return 0;
- if ((profile_name = get_profile_name(conn, vm)) == NULL)
+ if ((profile_name = get_profile_name(vm)) == NULL)
return rc;
/* Update the profile only if it is loaded */
return rc;
}
- if ((profile_name = get_profile_name(conn, vm)) == NULL)
+ if ((profile_name = get_profile_name(vm)) == NULL)
return rc;
/* update the profile only if it is loaded */
}
vm->def->seclabel.model = strdup(SECURITY_SELINUX_NAME);
if (!vm->def->seclabel.model) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err;
}
bzero(&zerobuf, sizeof(zerobuf));
if (VIR_ALLOC_N(buf, bytes) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
if (VIR_ALLOC(enc_secret) < 0 || VIR_REALLOC_N(enc->secrets, 1) < 0 ||
VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
def->usage_type = VIR_SECRET_USAGE_TYPE_VOLUME;
def->usage.volume = strdup(vol->target.path);
if (def->usage.volume == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
xml = virSecretDefFormat(conn, def);
} else {
target->perms.label = strdup(filecon);
if (target->perms.label == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
freecon(filecon);
if (virAsprintf(&stablepath, "%s/%s",
pool->def->target.path,
dent->d_name) == -1) {
- virReportOOMError(conn);
+ virReportOOMError();
closedir(dh);
return NULL;
}
stablepath = strdup(devpath);
if (stablepath == NULL)
- virReportOOMError(conn);
+ virReportOOMError();
return stablepath;
}
/* Compile all regular expressions */
if (VIR_ALLOC_N(reg, nregex) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
/* Storage for matched variables */
if (VIR_ALLOC_N(groups, totgroups) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
if (VIR_ALLOC_N(vars, maxvars+1) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
line[vars[j+1].rm_eo] = '\0';
if ((groups[ngroup++] =
strdup(line + vars[j+1].rm_so)) == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
}
return -1;
if (VIR_ALLOC_N(v, n_columns) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
for (i = 0; i < n_columns; i++)
if (vol == NULL) {
if (VIR_ALLOC(vol) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
if (VIR_REALLOC_N(pool->volumes.objs,
pool->volumes.count+1) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
virStorageVolDefFree(vol);
return -1;
}
*/
tmp = strrchr(groups[0], '/');
if ((vol->name = strdup(tmp ? tmp + 1 : groups[0])) == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
}
if (vol->target.path == NULL) {
if ((devpath = strdup(groups[0])) == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
if (vol->key == NULL) {
/* XXX base off a unique key of the underlying disk */
if ((vol->key = strdup(vol->target.path)) == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
}
if (vol->source.extents == NULL) {
if (VIR_ALLOC(vol->source.extents) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
vol->source.nextent = 1;
if ((vol->source.extents[0].path =
strdup(pool->def->source.devices[0].path)) == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
}
if (encryption != NULL && meta.encrypted) {
if (VIR_ALLOC(*encryption) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
if (backingStore)
VIR_FREE(*backingStore);
return -1;
if (!(src->host.name = strdup(state->host)) ||
!(src->dir = strdup(path))) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
src->format = VIR_STORAGE_POOL_NETFS_NFS;
retval = virStoragePoolSourceListFormat(conn, &state.list);
if (retval == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
if (pool->def->type == VIR_STORAGE_POOL_NETFS) {
if (pool->def->source.format == VIR_STORAGE_POOL_NETFS_GLUSTERFS) {
if (virAsprintf(&options, "direct-io-mode=1") == -1) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
}
if (virAsprintf(&src, "%s:%s",
pool->def->source.host.name,
pool->def->source.dir) == -1) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
} else {
if ((src = strdup(pool->def->source.devices[0].path)) == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
}
char *p;
if ((parent = strdup(pool->def->target.path)) == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
if (!(p = strrchr(parent, '/'))) {
return 0;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
/* fallthrough */
cleanup:
* function), and can drop the parent pool lock during the (slow) allocation.
*/
static int
-virStorageBackendFileSystemVolCreate(virConnectPtr conn,
+virStorageBackendFileSystemVolCreate(virConnectPtr conn ATTRIBUTE_UNUSED,
virStoragePoolObjPtr pool,
virStorageVolDefPtr vol)
{
if (virAsprintf(&vol->target.path, "%s/%s",
pool->def->target.path,
vol->name) == -1) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
VIR_FREE(vol->key);
vol->key = strdup(vol->target.path);
if (vol->key == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
if (VIR_ALLOC_N(vol->target.encryption->secrets, 1) < 0 ||
VIR_ALLOC(encsec) < 0) {
VIR_FREE(vol->target.encryption->secrets);
- virReportOOMError(conn);
+ virReportOOMError();
virSecretFree(sec);
return -1;
}
}
static int
-virStorageBackendISCSIExtractSession(virConnectPtr conn,
+virStorageBackendISCSIExtractSession(virConnectPtr conn ATTRIBUTE_UNUSED,
virStoragePoolObjPtr pool,
char **const groups,
void *data)
if (STREQ(groups[1], pool->def->source.devices[0].path)) {
if ((*session = strdup(groups[0])) == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
}
*ifacename = strdup(token);
if (*ifacename == NULL) {
ret = IQN_ERROR;
- virReportOOMError(conn);
+ virReportOOMError();
goto out;
}
VIR_DEBUG("Found interface '%s' with IQN '%s'", *ifacename, iqn);
return NULL;
if (VIR_ALLOC_N(portal, strlen(ipaddr) + 1 + 4 + 2 + 1) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
/* Or a completely new volume */
if (vol == NULL) {
if (VIR_ALLOC(vol) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
vol->type = VIR_STORAGE_VOL_BLOCK;
if ((vol->name = strdup(groups[0])) == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
virStorageVolDefFree(vol);
return -1;
}
if (VIR_REALLOC_N(pool->volumes.objs,
pool->volumes.count + 1)) {
- virReportOOMError(conn);
+ virReportOOMError();
virStorageVolDefFree(vol);
return -1;
}
if (vol->target.path == NULL) {
if (virAsprintf(&vol->target.path, "%s/%s",
pool->def->target.path, vol->name) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
virStorageVolDefFree(vol);
return -1;
}
if (groups[1] && !STREQ(groups[1], "")) {
if (virAsprintf(&vol->backingStore.path, "%s/%s",
pool->def->target.path, groups[1]) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
virStorageVolDefFree(vol);
return -1;
}
if (vol->key == NULL &&
(vol->key = strdup(groups[2])) == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
/* Finally fill in extents information */
if (VIR_REALLOC_N(vol->source.extents,
vol->source.nextent + 1) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
if ((vol->source.extents[vol->source.nextent].path =
strdup(groups[3])) == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
vgname = strdup(groups[1]);
if (pvname == NULL || vgname == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err_no_memory;
}
VIR_FREE(vgname);
if (VIR_REALLOC_N(thisSource->devices, thisSource->ndevice + 1) != 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto err_no_memory;
}
memset(zeros, 0, sizeof(zeros));
if (VIR_ALLOC_N(vgargv, 3 + pool->def->source.ndevice) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
if (virAsprintf(&vol->target.path, "%s/%s",
pool->def->target.path,
vol->name) == -1) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
int ret = -1;
if (VIR_ALLOC(vol) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
vol->type = VIR_STORAGE_VOL_BLOCK;
if (virAsprintf(&(vol->name), "dm-%u", devnum) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
if (virAsprintf(&vol->target.path, "/dev/%s", dev) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
/* XXX should use logical unit's UUID instead */
vol->key = strdup(vol->target.path);
if (vol->key == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
if (VIR_REALLOC_N(pool->volumes.objs,
pool->volumes.count + 1) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
pool->volumes.objs[pool->volumes.count++] = vol;
if (is_mpath == 1) {
if (virAsprintf(&map_device, "mapper/%s", names->name) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
retval = -1;
goto out;
}
if (virAsprintf(&type_path, "/sys/bus/scsi/devices/%u:%u:%u:%u/type",
host, bus, target, lun) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto out;
}
int retval = 0;
if (VIR_ALLOC(vol) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
retval = -1;
goto out;
}
vol->type = VIR_STORAGE_VOL_BLOCK;
if (virAsprintf(&(vol->name), "%u.%u.%u.%u", host, bus, target, lun) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
retval = -1;
goto free_vol;
}
if (virAsprintf(&devpath, "/dev/%s", dev) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
retval = -1;
goto free_vol;
}
/* XXX should use logical unit's UUID instead */
vol->key = strdup(vol->target.path);
if (vol->key == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
retval = -1;
goto free_vol;
}
if (VIR_REALLOC_N(pool->volumes.objs,
pool->volumes.count + 1) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
retval = -1;
goto free_vol;
}
int retval = 0;
if (virAsprintf(&block_path, "%s/block", lun_path) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto out;
}
*block_device = strdup(block_dirent->d_name);
if (*block_device == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
closedir(block_dir);
retval = -1;
goto out;
*block_device = strdup(blockp);
if (*block_device == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
retval = -1;
goto out;
}
if (virAsprintf(&lun_path, "/sys/bus/scsi/devices/%u:%u:%u:%u",
host, bus, target, lun) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto out;
}
virFileWaitForDevices(conn);
if (virAsprintf(&device_path, "/sys/bus/scsi/devices") < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto out;
}
VIR_DEBUG(_("Triggering rescan of host %d"), host);
if (virAsprintf(&path, "/sys/class/scsi_host/host%u/scan", host) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
retval = -1;
goto out;
}
return 0;
out_of_memory:
- virReportOOMError(NULL);
+ virReportOOMError();
error:
VIR_FREE(base);
storageDriverUnlock(driverState);
if (virStoragePoolObjIsActive(driver->pools.objs[i])) {
if (!(names[got] = strdup(driver->pools.objs[i]->def->name))) {
virStoragePoolObjUnlock(driver->pools.objs[i]);
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
got++;
if (!virStoragePoolObjIsActive(driver->pools.objs[i])) {
if (!(names[got] = strdup(driver->pools.objs[i]->def->name))) {
virStoragePoolObjUnlock(driver->pools.objs[i]);
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
got++;
for (i = 0 ; i < pool->volumes.count && n < maxnames ; i++) {
if ((names[n++] = strdup(pool->volumes.objs[i]->name)) == NULL) {
- virReportOOMError(obj->conn);
+ virReportOOMError();
goto cleanup;
}
}
if (VIR_REALLOC_N(pool->volumes.objs,
pool->volumes.count+1) < 0) {
- virReportOOMError(obj->conn);
+ virReportOOMError();
goto cleanup;
}
virStorageVolDefPtr buildvoldef = NULL;
if (VIR_ALLOC(buildvoldef) < 0) {
- virReportOOMError(obj->conn);
+ virReportOOMError();
voldef = NULL;
goto cleanup;
}
if (VIR_REALLOC_N(pool->volumes.objs,
pool->volumes.count+1) < 0) {
- virReportOOMError(obj->conn);
+ virReportOOMError();
goto cleanup;
}
ret = strdup(vol->target.path);
if (ret == NULL)
- virReportOOMError(obj->conn);
+ virReportOOMError();
cleanup:
if (pool)
return caps;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
virCapabilitiesFree(caps);
return NULL;
}
static const unsigned long long defaultPoolCap = (100 * 1024 * 1024 * 1024ull);
static const unsigned long long defaultPoolAlloc = 0;
-static int testStoragePoolObjSetDefaults(virConnectPtr conn,
- virStoragePoolObjPtr pool);
+static int testStoragePoolObjSetDefaults(virStoragePoolObjPtr pool);
static int testNodeGetInfo(virConnectPtr conn, virNodeInfoPtr info);
static char *
int found = 0;
if (virAsprintf(&ifname, "testnet%d", ifctr) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
cpumaplen = VIR_CPU_MAPLEN(maxcpu);
if (VIR_REALLOC_N(privdata->vcpu_infos, nvcpus) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
if (VIR_REALLOC_N(privdata->cpumaps, nvcpus * cpumaplen) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
virNodeDeviceObjPtr nodeobj = NULL;
if (VIR_ALLOC(privconn) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return VIR_DRV_OPEN_ERROR;
}
if (virMutexInit(&privconn->lock) < 0) {
goto error;
}
- if (testStoragePoolObjSetDefaults(conn, poolobj) == -1) {
+ if (testStoragePoolObjSetDefaults(poolobj) == -1) {
virStoragePoolObjUnlock(poolobj);
goto error;
}
/* Find storage volumes */
if (virAsprintf(&vol_xpath, "/node/pool[%d]/volume", poolidx) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto error;
}
if (VIR_REALLOC_N(pool->volumes.objs,
pool->volumes.count+1) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
if (virAsprintf(&def->target.path, "%s/%s",
pool->def->target.path,
def->name) == -1) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
def->key = strdup(def->target.path);
if (def->key == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
virDomainObjPtr dom;
testConnPtr privconn;
if (VIR_ALLOC(privconn) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return VIR_DRV_OPEN_ERROR;
}
if (virMutexInit(&privconn->lock) < 0) {
goto error;
}
- if (testStoragePoolObjSetDefaults(conn, pool) == -1) {
+ if (testStoragePoolObjSetDefaults(pool) == -1) {
virStoragePoolObjUnlock(pool);
goto error;
}
/* Init callback list */
if (VIR_ALLOC(privconn->domainEventCallbacks) < 0 ||
!(privconn->domainEventQueue = virDomainEventQueueNew())) {
- virReportOOMError(NULL);
+ virReportOOMError();
testDriverUnlock(privconn);
testClose(conn);
return VIR_DRV_OPEN_ERROR;
char *xml;
testDriverLock(privconn);
if ((xml = virCapabilitiesFormatXML(privconn->caps)) == NULL)
- virReportOOMError(conn);
+ virReportOOMError();
testDriverUnlock(privconn);
return xml;
}
goto cleanup;
}
if (VIR_ALLOC_N(xml, len+1) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
if (saferead(fd, xml, len) != len) {
return ret;
}
-static char *testGetOSType(virDomainPtr dom) {
+static char *testGetOSType(virDomainPtr dom ATTRIBUTE_UNUSED) {
char *ret = strdup("linux");
if (!ret)
- virReportOOMError(dom->conn);
+ virReportOOMError();
return ret;
}
return ret;
}
-static char *testDomainGetSchedulerType(virDomainPtr domain,
+static char *testDomainGetSchedulerType(virDomainPtr domain ATTRIBUTE_UNUSED,
int *nparams)
{
char *type = NULL;
*nparams = 1;
type = strdup("fair");
if (!type)
- virReportOOMError(domain->conn);
+ virReportOOMError();
return type;
}
return n;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
for (n = 0 ; n < nnames ; n++)
VIR_FREE(names[n]);
testDriverUnlock(privconn);
return n;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
for (n = 0 ; n < nnames ; n++)
VIR_FREE(names[n]);
testDriverUnlock(privconn);
}
if (!(bridge = strdup(privnet->def->bridge))) {
- virReportOOMError(network->conn);
+ virReportOOMError();
goto cleanup;
}
return n;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
for (n = 0 ; n < nnames ; n++)
VIR_FREE(names[n]);
testDriverUnlock(privconn);
return n;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
for (n = 0 ; n < nnames ; n++)
VIR_FREE(names[n]);
testDriverUnlock(privconn);
*/
-static int testStoragePoolObjSetDefaults(virConnectPtr conn,
- virStoragePoolObjPtr pool) {
+static int testStoragePoolObjSetDefaults(virStoragePoolObjPtr pool) {
pool->def->capacity = defaultPoolCap;
pool->def->allocation = defaultPoolAlloc;
pool->configFile = strdup("\0");
if (!pool->configFile) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
return n;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
for (n = 0 ; n < nnames ; n++)
VIR_FREE(names[n]);
testDriverUnlock(privconn);
return n;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
for (n = 0 ; n < nnames ; n++)
VIR_FREE(names[n]);
testDriverUnlock(privconn);
case VIR_STORAGE_POOL_LOGICAL:
ret = strdup(defaultPoolSourcesLogicalXML);
if (!ret)
- virReportOOMError(conn);
+ virReportOOMError();
break;
case VIR_STORAGE_POOL_NETFS:
if (virAsprintf(&ret, defaultPoolSourcesNetFSXML,
source->host.name) < 0)
- virReportOOMError(conn);
+ virReportOOMError();
break;
default:
goto cleanup;
def = NULL;
- if (testStoragePoolObjSetDefaults(conn, pool) == -1) {
+ if (testStoragePoolObjSetDefaults(pool) == -1) {
virStoragePoolObjRemove(&privconn->pools, pool);
pool = NULL;
goto cleanup;
goto cleanup;
def = NULL;
- if (testStoragePoolObjSetDefaults(conn, pool) == -1) {
+ if (testStoragePoolObjSetDefaults(pool) == -1) {
virStoragePoolObjRemove(&privconn->pools, pool);
pool = NULL;
goto cleanup;
for (i = 0 ; i < privpool->volumes.count && n < maxnames ; i++) {
if ((names[n++] = strdup(privpool->volumes.objs[i]->name)) == NULL) {
- virReportOOMError(pool->conn);
+ virReportOOMError();
goto cleanup;
}
}
if (VIR_REALLOC_N(privpool->volumes.objs,
privpool->volumes.count+1) < 0) {
- virReportOOMError(pool->conn);
+ virReportOOMError();
goto cleanup;
}
if (virAsprintf(&privvol->target.path, "%s/%s",
privpool->def->target.path,
privvol->name) == -1) {
- virReportOOMError(pool->conn);
+ virReportOOMError();
goto cleanup;
}
privvol->key = strdup(privvol->target.path);
if (privvol->key == NULL) {
- virReportOOMError(pool->conn);
+ virReportOOMError();
goto cleanup;
}
if (VIR_REALLOC_N(privpool->volumes.objs,
privpool->volumes.count+1) < 0) {
- virReportOOMError(pool->conn);
+ virReportOOMError();
goto cleanup;
}
if (virAsprintf(&privvol->target.path, "%s/%s",
privpool->def->target.path,
privvol->name) == -1) {
- virReportOOMError(pool->conn);
+ virReportOOMError();
goto cleanup;
}
privvol->key = strdup(privvol->target.path);
if (privvol->key == NULL) {
- virReportOOMError(pool->conn);
+ virReportOOMError();
goto cleanup;
}
ret = strdup(privvol->target.path);
if (ret == NULL)
- virReportOOMError(vol->conn);
+ virReportOOMError();
cleanup:
if (privpool)
if (obj->def->parent) {
ret = strdup(obj->def->parent);
if (!ret)
- virReportOOMError(dev->conn);
+ virReportOOMError();
} else {
virNodeDeviceReportError(dev->conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("no parent for this device"));
* we don't have. Use WWPN instead. */
VIR_FREE(def->name);
if (!(def->name = strdup(wwpn))) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
parent_name = strdup(obj->def->parent);
if (parent_name == NULL) {
- virReportOOMError(dev->conn);
+ virReportOOMError();
goto out;
}
return 0;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
error:
brShutdown(brctl);
return -1;
}
if (virBufferError(&buf)) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
switch (def->type) {
case VIR_DOMAIN_CHR_TYPE_NULL:
if (virAsprintf(&ret, "%s%d=null", dev, def->target.port) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
break;
case VIR_DOMAIN_CHR_TYPE_PTY:
if (virAsprintf(&ret, "%s%d=pts", dev, def->target.port) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
break;
case VIR_DOMAIN_CHR_TYPE_DEV:
if (virAsprintf(&ret, "%s%d=tty:%s", dev, def->target.port,
def->data.file.path) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
break;
case VIR_DOMAIN_CHR_TYPE_STDIO:
if (virAsprintf(&ret, "%s%d=fd:0,fd:1", dev, def->target.port) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
break;
if (virAsprintf(&ret, "%s%d=port:%s", dev, def->target.port,
def->data.tcp.service) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
break;
return 0;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
error:
if (qargv) {
static int
-umlIdentifyOneChrPTY(virConnectPtr conn,
- struct uml_driver *driver,
+umlIdentifyOneChrPTY(struct uml_driver *driver,
virDomainObjPtr dom,
virDomainChrDefPtr def,
const char *dev)
char *res = NULL;
int retries = 0;
if (virAsprintf(&cmd, "config %s%d", dev, def->target.port) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
requery:
if (res && STRPREFIX(res, "pts:")) {
VIR_FREE(def->data.file.path);
if ((def->data.file.path = strdup(res + 4)) == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
VIR_FREE(res);
VIR_FREE(cmd);
return -1;
}
static int
-umlIdentifyChrPTY(virConnectPtr conn,
- struct uml_driver *driver,
+umlIdentifyChrPTY(struct uml_driver *driver,
virDomainObjPtr dom)
{
int i;
if (dom->def->console &&
dom->def->console->type == VIR_DOMAIN_CHR_TYPE_PTY)
- if (umlIdentifyOneChrPTY(conn, driver, dom,
+ if (umlIdentifyOneChrPTY(driver, dom,
dom->def->console, "con") < 0)
return -1;
for (i = 0 ; i < dom->def->nserials; i++)
if (dom->def->serials[i]->type == VIR_DOMAIN_CHR_TYPE_PTY &&
- umlIdentifyOneChrPTY(conn, driver, dom,
+ umlIdentifyOneChrPTY(driver, dom,
dom->def->serials[i], "ssl") < 0)
return -1;
if (umlOpenMonitor(NULL, driver, dom) < 0) {
VIR_WARN0("Could not open monitor for new domain");
umlShutdownVMDaemon(NULL, driver, dom);
- } else if (umlIdentifyChrPTY(NULL, driver, dom) < 0) {
+ } else if (umlIdentifyChrPTY(driver, dom) < 0) {
VIR_WARN0("Could not identify charater devices for new domain");
umlShutdownVMDaemon(NULL, driver, dom);
}
vm->pid = -1;
if (virAsprintf(&pidfile, "%s/%s/pid",
driver->monitorDir, vm->def->name) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
if (virAsprintf(&sockname, "%s/%s/mconsole",
driver->monitorDir, vm->def->name) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
}
if (VIR_REALLOC_N(retdata, retlen + res.length) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
memcpy(retdata + retlen, res.data, res.length);
if (virAsprintf(&logfile, "%s/%s.log",
driver->logDir, vm->def->name) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
"uml:///system" :
"uml:///session");
if (!conn->uri) {
- virReportOOMError(conn);
+ virReportOOMError();
return VIR_DRV_OPEN_ERROR;
}
} else {
umlDriverLock(driver);
if ((xml = virCapabilitiesFormatXML(driver->caps)) == NULL)
- virReportOOMError(conn);
+ virReportOOMError();
umlDriverUnlock(driver);
return xml;
}
if (!(type = strdup(vm->def->os.type)))
- virReportOOMError(dom->conn);
+ virReportOOMError();
cleanup:
if (vm)
virConfPtr ret;
if (VIR_ALLOC(ret) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return(NULL);
}
ret->filename = NULL;
return(NULL);
if (VIR_ALLOC(ret) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return(NULL);
}
}
ret = strndup(base, ctxt->cur - base);
if (ret == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
NEXT;
}
ret = strndup(base, ctxt->cur - base);
if (ret == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
ctxt->cur += 3;
}
ret = strndup(base, ctxt->cur - base);
if (ret == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
NEXT;
return(NULL);
}
if (VIR_ALLOC(ret) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
virConfFreeList(lst);
VIR_FREE(str);
return(NULL);
NEXT;
ret = strndup(base, ctxt->cur - base);
if (ret == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
return(NULL);
}
return(ret);
while ((ctxt->cur < ctxt->end) && (!IS_EOL(CUR))) NEXT;
comm = strndup(base, ctxt->cur - base);
if (comm == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
return(-1);
}
virConfAddEntry(ctxt->conf, NULL, NULL, comm);
while ((ctxt->cur < ctxt->end) && (!IS_EOL(CUR))) NEXT;
comm = strndup(base, ctxt->cur - base);
if (comm == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
VIR_FREE(name);
virConfFreeValue(value);
return(-1);
if (!cur) {
if (VIR_ALLOC(cur) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
virConfFreeValue(value);
return (-1);
}
cur->comment = NULL;
if (!(cur->name = strdup(setting))) {
- virReportOOMError(NULL);
+ virReportOOMError();
virConfFreeValue(value);
VIR_FREE(cur);
return (-1);
if (virBufferError(&buf)) {
virBufferFreeAndReset(&buf);
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
if (virBufferError(&buf)) {
virBufferFreeAndReset(&buf);
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
tmp = virAsprintf(&filename, USB_SYSFS "/devices/%s/%s", d_name, f_name);
if (tmp < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
usbDevice *dev;
if (VIR_ALLOC(dev) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
g = yajl_gen_alloc(&conf, NULL);
if (virJSONValueToStringOne(object, g) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
if (yajl_gen_get_buf(g, &str, &len) != yajl_gen_status_ok) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto cleanup;
}
if (!(ret = strdup((const char *)str)))
- virReportOOMError(NULL);
+ virReportOOMError();
cleanup:
yajl_gen_free(g);
char *vendor, *product;
if (VIR_ALLOC(dev) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
}
pciDeviceList *
-pciDeviceListNew(virConnectPtr conn)
+pciDeviceListNew(virConnectPtr conn ATTRIBUTE_UNUSED /*TEMPORARY*/)
{
pciDeviceList *list;
if (VIR_ALLOC(list) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
}
if (VIR_REALLOC_N(list->devs, list->count+1) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
if (virAsprintf(&pcidir, "/sys/bus/pci/devices/%04x:%02x:%02x.%x",
dev->domain, dev->bus, dev->slot, dev->function) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
STRPREFIX(ent->d_name, "resource") ||
STREQ(ent->d_name, "rom")) {
if (virAsprintf(&file, "%s/%s", pcidir, ent->d_name) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
if ((actor)(conn, dev, file, opaque) < 0)
mask = CPU_ALLOC(numcpus);
if (!mask) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
mask = CPU_ALLOC(numcpus);
if (!mask) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
if (init_alloc <= 0) init_alloc = 1;
if (VIR_ALLOC(ps) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
ps->n = 0;
ps->alloc = init_alloc;
if (VIR_ALLOC_N(ps->p, ps->alloc) < 0) {
VIR_FREE (ps);
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
{
if (ps->n >= ps->alloc) {
if (VIR_REALLOC_N(ps->p, ps->alloc * 2) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
ps->alloc *= 2;
pname = strdup (name);
if (!pname) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
pvalue = strdup (value);
if (!pvalue) {
VIR_FREE (pname);
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
if (virBufferError(&buf)) {
virBufferFreeAndReset(&buf);
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
ps = new_qparam_set (0, NULL);
if (!ps) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
return ps;
out_of_memory:
- virReportOOMError(NULL);
+ virReportOOMError();
free_qparam_set (ps);
return NULL;
}
};
static int
-cowGetBackingStore(virConnectPtr conn,
+cowGetBackingStore(virConnectPtr conn ATTRIBUTE_UNUSED /*TEMPORARY*/,
char **res,
const unsigned char *buf,
size_t buf_size)
*res = strndup ((const char*)buf + 4+4, COW_FILENAME_MAXLEN);
if (*res == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
return BACKING_STORE_ERROR;
}
return BACKING_STORE_OK;
}
static int
-qcowXGetBackingStore(virConnectPtr conn,
+qcowXGetBackingStore(virConnectPtr conn ATTRIBUTE_UNUSED /*TEMPORARY*/,
char **res,
const unsigned char *buf,
size_t buf_size)
if (size + 1 == 0)
return BACKING_STORE_INVALID;
if (VIR_ALLOC_N(*res, size + 1) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return BACKING_STORE_ERROR;
}
memcpy(*res, buf + offset, size);
static int
-vmdk4GetBackingStore(virConnectPtr conn,
+vmdk4GetBackingStore(virConnectPtr conn ATTRIBUTE_UNUSED /*TEMPORARY*/,
char **res,
const unsigned char *buf,
size_t buf_size)
*end = '\0';
*res = strdup(start);
if (*res == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
return BACKING_STORE_ERROR;
}
return BACKING_STORE_OK;
meta->backingStore = absolutePathFromBaseFile(path, base);
VIR_FREE(base);
if (meta->backingStore == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
}
char *envp_str;
if ((argv_str = virArgvToString(argv)) == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
if (envp) {
if ((envp_str = virArgvToString(envp)) == NULL) {
VIR_FREE(argv_str);
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
VIR_DEBUG("%s %s", envp_str, argv_str);
buf = ((fds[i].fd == outfd) ? outbuf : errbuf);
size = (*buf ? strlen(*buf) : 0);
if (VIR_REALLOC_N(*buf, size+got+1) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
memmove(*buf+size, data, got);
char *argv_str = NULL;
if ((argv_str = virArgvToString(argv)) == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
DEBUG0(argv_str);
offset = strlen(prefix);
if (VIR_ALLOC_N(name, offset + i + 1)) {
- virReportOOMError(NULL);
+ virReportOOMError();
return NULL;
}
/* Caller frees this string. */
result = strdup (info->ai_canonname);
if (!result)
- virReportOOMError(conn);
+ virReportOOMError();
freeaddrinfo(info);
return result;
}
if (VIR_ALLOC_N(strbuf, strbuflen) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
VIR_FREE(strbuf);
if (!ret)
- virReportOOMError(conn);
+ virReportOOMError();
return ret;
}
}
if (VIR_ALLOC_N(strbuf, strbuflen) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
}
if (VIR_ALLOC_N(strbuf, strbuflen) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
/**
* virReportOOMErrorFull:
- * @conn: the hyperisor connection
* @domcode: the virErrorDomain indicating where it's coming from
* @filename: filename where error was raised
* @funcname: function name where error was raised
* Convenience internal routine called when an out of memory error is
* detected
*/
-void virReportOOMErrorFull(virConnectPtr conn,
- int domcode,
+void virReportOOMErrorFull(int domcode,
const char *filename,
const char *funcname,
size_t linenr)
const char *virerr;
virerr = virErrorMsg(VIR_ERR_NO_MEMORY, NULL);
- virRaiseErrorFull(conn, filename, funcname, linenr,
+ virRaiseErrorFull(NULL, filename, funcname, linenr,
domcode, VIR_ERR_NO_MEMORY, VIR_ERR_ERROR,
virerr, NULL, NULL, -1, -1, virerr, NULL);
}
__FILE__, __FUNCTION__, __LINE__, \
(fmt), __VA_ARGS__)
-void virReportOOMErrorFull(virConnectPtr conn,
- int domcode,
+void virReportOOMErrorFull(int domcode,
const char *filename,
const char *funcname,
size_t linenr);
-#define virReportOOMError(conn) \
- virReportOOMErrorFull((conn), VIR_FROM_THIS, \
- __FILE__, __FUNCTION__, __LINE__)
+#define virReportOOMError() \
+ virReportOOMErrorFull(VIR_FROM_THIS, __FILE__, __FUNCTION__, __LINE__)
int virSetError(virErrorPtr newerr);
ret = strdup((char *) obj->stringval);
xmlXPathFreeObject(obj);
if (ret == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
}
return (ret);
}
ret = obj->nodesetval->nodeNr;
if (list != NULL && ret) {
if (VIR_ALLOC_N(*list, ret) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
ret = -1;
} else {
memcpy(*list, obj->nodesetval->nodeTab,
return false;
}
-static void vboxIIDtoUtf8(virConnectPtr conn, vboxIID *iid, char **uuidstr) {
+static void vboxIIDtoUtf8(vboxIID *iid, char **uuidstr) {
unsigned char hddUUID[VIR_UUID_BUFLEN];
if (VIR_ALLOC_N(*uuidstr, VIR_UUID_STRING_BUFLEN) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return;
}
virUUIDFormat(hddUUID, *uuidstr);
}
-static void vboxUtf8toIID(virConnectPtr conn, char *uuidstr, vboxIID **iid) {
+static void vboxUtf8toIID(char *uuidstr, vboxIID **iid) {
unsigned char hddUUID[VIR_UUID_BUFLEN];
if (VIR_ALLOC(*iid) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return;
}
return false;
}
-static void vboxIIDtoUtf8(virConnectPtr conn, vboxIID *iid, char **uuidstr) {
+static void vboxIIDtoUtf8(vboxIID *iid, char **uuidstr) {
g_pVBoxGlobalData->pFuncs->pfnUtf16ToUtf8(iid, uuidstr);
if (!(*uuidstr))
- virReportOOMError(conn);
+ virReportOOMError();
}
-static void vboxUtf8toIID(virConnectPtr conn, char *uuidstr, vboxIID **iid) {
+static void vboxUtf8toIID(char *uuidstr, vboxIID **iid) {
g_pVBoxGlobalData->pFuncs->pfnUtf8ToUtf16(uuidstr, iid);
if (!(*iid))
- virReportOOMError(conn);
+ virReportOOMError();
}
#if VBOX_API_VERSION >= 3001
if (conn->uri == NULL) {
conn->uri = xmlParseURI(uid ? "vbox:///session" : "vbox:///system");
if (conn->uri == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
return VIR_DRV_OPEN_ERROR;
}
}
}
if (VIR_ALLOC(data) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return VIR_DRV_OPEN_ERROR;
}
#else /* !(VBOX_API_VERSION == 2002) */
if (VIR_ALLOC(data->domainEventCallbacks) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return VIR_DRV_OPEN_ERROR;
}
#if VBOX_API_VERSION == 2002
if (VIR_ALLOC(iid) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto cleanup;
}
#endif
#if VBOX_API_VERSION == 2002
if (VIR_ALLOC(iid) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto cleanup;
}
#endif
#if VBOX_API_VERSION == 2002
if (VIR_ALLOC(iid) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto cleanup;
}
#endif
#if VBOX_API_VERSION == 2002
if (VIR_ALLOC(iid) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto cleanup;
}
#endif
#if VBOX_API_VERSION == 2002
if (VIR_ALLOC(iid) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto cleanup;
}
#endif
return ret;
}
-static char *vboxDomainGetOSType(virDomainPtr dom) {
+static char *vboxDomainGetOSType(virDomainPtr dom ATTRIBUTE_UNUSED) {
/* Returning "hvm" always as suggested on list, cause
* this functions seems to be badly named and it
* is supposed to pass the ABI name and not the domain
char *osType = strdup("hvm");
if (osType == NULL)
- virReportOOMError(dom->conn);
+ virReportOOMError();
return osType;
}
#if VBOX_API_VERSION == 2002
if (VIR_ALLOC(iid) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto cleanup;
}
#endif
*/
#if VBOX_API_VERSION == 2002
if (VIR_ALLOC(iid) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto cleanup;
}
#endif
#if VBOX_API_VERSION == 2002
if (VIR_ALLOC(iid) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto cleanup;
}
#endif
#if VBOX_API_VERSION == 2002
if (VIR_ALLOC(iid) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto cleanup;
}
#endif
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto cleanup;
}
def->videos[0]->accel->support3d = accelerate3DEnabled;
def->videos[0]->accel->support2d = accelerate2DEnabled;
} else
- virReportOOMError(dom->conn);
+ virReportOOMError();
} else
- virReportOOMError(dom->conn);
+ virReportOOMError();
} else
- virReportOOMError(dom->conn);
+ virReportOOMError();
}
/* dump display options vrdp/gui/sdl */
if (valueDisplayUtf8)
sdlDisplay = strdup(valueDisplayUtf8);
if (sdlDisplay == NULL) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
/* just don't go to cleanup yet as it is ok to have
* sdlDisplay as NULL and we check it below if it
* exist and then only use it there
if (valueDisplayUtf8)
guiDisplay = strdup(valueDisplayUtf8);
if (guiDisplay == NULL) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
/* just don't go to cleanup yet as it is ok to have
* guiDisplay as NULL and we check it below if it
* exist and then only use it there
def->graphics[def->ngraphics]->type = VIR_DOMAIN_GRAPHICS_TYPE_DESKTOP;
def->graphics[def->ngraphics]->data.desktop.display = strdup(getenv("DISPLAY"));
if (def->graphics[def->ngraphics]->data.desktop.display == NULL) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
/* just don't go to cleanup yet as it is ok to have
* display as NULL
*/
def->ngraphics++;
} else
- virReportOOMError(dom->conn);
+ virReportOOMError();
}
VBOX_RELEASE(VRDPServer);
}
def->disks[i]->bus = VIR_DOMAIN_DISK_BUS_IDE;
def->disks[i]->type = VIR_DOMAIN_DISK_TYPE_FILE;
} else
- virReportOOMError(dom->conn);
+ virReportOOMError();
}
}
if (VIR_ALLOC_N(def->disks, def->ndisks) >= 0) {
for (i = 0; i < def->ndisks; i++) {
if (VIR_ALLOC(def->disks[i]) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
error = true;
break;
}
}
} else {
- virReportOOMError(dom->conn);
+ virReportOOMError();
error = true;
}
if (!(def->disks[diskCount]->src)) {
VBOX_RELEASE(medium);
VBOX_RELEASE(storageController);
- virReportOOMError(dom->conn);
+ virReportOOMError();
error = true;
break;
}
for (i = 0; i < def->nnets; i++) {
if (VIR_ALLOC(def->nets[i]) >= 0) {
} else
- virReportOOMError(dom->conn);
+ virReportOOMError();
}
}
} else {
VIR_FREE(def->sounds);
def->nsounds = 0;
- virReportOOMError(dom->conn);
+ virReportOOMError();
}
} else {
def->nsounds = 0;
- virReportOOMError(dom->conn);
+ virReportOOMError();
}
}
VBOX_RELEASE(audioAdapter);
def->disks[def->ndisks - 1]->dst = strdup("hdc");
} else {
def->ndisks--;
- virReportOOMError(dom->conn);
+ virReportOOMError();
}
} else {
def->ndisks--;
- virReportOOMError(dom->conn);
+ virReportOOMError();
}
VBOX_UTF8_FREE(location);
def->disks[def->ndisks - 1]->dst = strdup("fda");
} else {
def->ndisks--;
- virReportOOMError(dom->conn);
+ virReportOOMError();
}
} else {
def->ndisks--;
- virReportOOMError(dom->conn);
+ virReportOOMError();
}
VBOX_UTF8_FREE(location);
for (i = 0; i < def->nserials; i++) {
if (VIR_ALLOC(def->serials[i]) >= 0) {
} else
- virReportOOMError(dom->conn);
+ virReportOOMError();
}
}
for (i = 0; i < def->nparallels; i++) {
if (VIR_ALLOC(def->parallels[i]) >= 0) {
} else
- virReportOOMError(dom->conn);
+ virReportOOMError();
}
}
USBFilterCount++;
} else
- virReportOOMError(dom->conn);
+ virReportOOMError();
}
}
} else
- virReportOOMError(dom->conn);
+ virReportOOMError();
}
}
machine->vtbl->GetName(machine, &machineNameUtf16);
VBOX_UTF16_TO_UTF8(machineNameUtf16, &machineName);
if (!(names[j++] = strdup(machineName))) {
- virReportOOMError(conn);
+ virReportOOMError();
for ( ; j >= 0 ; j--)
VIR_FREE(names[j]);
ret = -1;
#if VBOX_API_VERSION == 2002
if (VIR_ALLOC(iid) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
#endif
if (def->graphics[i]->data.desktop.display) {
guiDisplay = strdup(def->graphics[i]->data.desktop.display);
if (guiDisplay == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
/* just don't go to cleanup yet as it is ok to have
* guiDisplay as NULL and we check it below if it
* exist and then only use it there
if (def->graphics[i]->data.sdl.display) {
sdlDisplay = strdup(def->graphics[i]->data.sdl.display);
if (sdlDisplay == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
/* just don't go to cleanup yet as it is ok to have
* sdlDisplay as NULL and we check it below if it
* exist and then only use it there
#if VBOX_API_VERSION == 2002
if (VIR_ALLOC(iid) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto cleanup;
}
#endif
nsresult rc;
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
return ret;
}
def->os.type = strdup("hvm");
if (def->os.type == NULL) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto cleanup;
}
dev = virDomainDeviceDefParse(dom->conn, data->caps, def, xml,
VIR_DOMAIN_XML_INACTIVE);
if (dev == NULL) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto cleanup;
}
#if VBOX_API_VERSION == 2002
if (VIR_ALLOC(iid) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto cleanup;
}
#endif
nsresult rc;
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
return ret;
}
def->os.type = strdup("hvm");
if (def->os.type == NULL) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto cleanup;
}
dev = virDomainDeviceDefParse(dom->conn, data->caps, def, xml,
VIR_DOMAIN_XML_INACTIVE);
if (dev == NULL) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto cleanup;
}
#if VBOX_API_VERSION == 2002
if (VIR_ALLOC(iid) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto cleanup;
}
#endif
}
-static IVirtualBoxCallback *vboxAllocCallbackObj (virConnectPtr conn) {
+static IVirtualBoxCallback *vboxAllocCallbackObj(void) {
IVirtualBoxCallback *vboxCallback = NULL;
/* Allocate, Initialize and return a validi
* IVirtualBoxCallback object here
*/
if ((VIR_ALLOC(vboxCallback) < 0) || (VIR_ALLOC(vboxCallback->vtbl) < 0)) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
vboxDriverLock(data);
if (data->vboxCallback == NULL) {
- data->vboxCallback = vboxAllocCallbackObj(conn);
+ data->vboxCallback = vboxAllocCallbackObj();
if (data->vboxCallback != NULL) {
rc = data->vboxObj->vtbl->RegisterCallback(data->vboxObj, data->vboxCallback);
if (NS_SUCCEEDED(rc)) {
#if VBOX_API_VERSION == 2002
if (VIR_ALLOC(iid) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
#endif
if (virAsprintf(&networkNameUtf8, "HostInterfaceNetworking-%s", networkInterfaceNameUtf8) < 0) {
VBOX_RELEASE(host);
VBOX_RELEASE(networkInterface);
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
}
*/
if (virAsprintf(&networkNameUtf8, "HostInterfaceNetworking-%s", network->name) < 0) {
- virReportOOMError(network->conn);
+ virReportOOMError();
goto cleanup;
}
*/
if (virAsprintf(&networkNameUtf8, "HostInterfaceNetworking-%s", network->name) < 0) {
- virReportOOMError(network->conn);
+ virReportOOMError();
goto cleanup;
}
char *networkNameUtf8 = NULL;
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(network->conn);
+ virReportOOMError();
goto cleanup;
}
if (virAsprintf(&networkNameUtf8, "HostInterfaceNetworking-%s", network->name) < 0) {
- virReportOOMError(network->conn);
+ virReportOOMError();
goto cleanup;
}
VBOX_UTF16_FREE(toIPAddressUtf16);
} else {
def->nranges = 0;
- virReportOOMError(network->conn);
+ virReportOOMError();
}
def->nhosts = 1;
return 1;
}
-static int vboxStorageListPools(virConnectPtr conn, char **const names, int nnames) {
+static int vboxStorageListPools(virConnectPtr conn ATTRIBUTE_UNUSED,
+ char **const names, int nnames) {
int numActive = 0;
if (nnames == 1) {
names[numActive] = strdup("default-pool");
if (names[numActive] == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
} else {
numActive++;
}
DEBUG("nnames[%d]: %s", numActive, nameUtf8);
names[numActive] = strdup(nameUtf8);
if (names[numActive] == NULL) {
- virReportOOMError(pool->conn);
+ virReportOOMError();
} else {
numActive++;
}
VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetId, &hddIID);
if (hddIID) {
- vboxIIDtoUtf8(pool->conn, hddIID, &hddIIDUtf8);
+ vboxIIDtoUtf8(hddIID, &hddIIDUtf8);
vboxIIDUnalloc(hddIID);
}
#if VBOX_API_VERSION == 2002
if (VIR_ALLOC(hddIID) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
}
if (hddIID) {
- vboxIIDtoUtf8(conn, hddIID, &hddIIDUtf8);
+ vboxIIDtoUtf8(hddIID, &hddIIDUtf8);
vboxIIDUnalloc(hddIID);
}
if (NS_SUCCEEDED(rc)) {
char *hddKey = NULL;
- vboxIIDtoUtf8(pool->conn, hddIID, &hddKey);
+ vboxIIDtoUtf8(hddIID, &hddKey);
if (hddKey)
ret = virGetStorageVol(pool->conn, pool->name, def->name, hddKey);
int i = 0;
int j = 0;
- vboxUtf8toIID(vol->conn, vol->key, &hddIID);
+ vboxUtf8toIID(vol->key, &hddIID);
if (!hddIID)
return ret;
if (!info)
return ret;
- vboxUtf8toIID(vol->conn, vol->key, &hddIID);
+ vboxUtf8toIID(vol->key, &hddIID);
if (!hddIID)
return ret;
memset(&pool, 0, sizeof(pool));
memset(&def, 0, sizeof(def));
- vboxUtf8toIID(vol->conn, vol->key, &hddIID);
+ vboxUtf8toIID(vol->key, &hddIID);
if (!hddIID)
return ret;
vboxIID *hddIID = NULL;
nsresult rc;
- vboxUtf8toIID(vol->conn, vol->key, &hddIID);
+ vboxUtf8toIID(vol->key, &hddIID);
if (!hddIID)
return ret;
ret = strdup(hddLocationUtf8);
if (!ret)
- virReportOOMError(vol->conn);
+ virReportOOMError();
DEBUG("Storage Volume Name: %s", vol->name);
DEBUG("Storage Volume Path: %s", hddLocationUtf8);
retval = virAsprintf(&mod_path, "/dev/%s", path);
if (retval < 0) {
- virReportOOMError (conn);
+ virReportOOMError();
return -1;
}
xmllen = ans.len - sizeof (virProxyPacket);
if (VIR_ALLOC_N(xml, xmllen+1) < 0) {
- virReportOOMError (conn);
+ virReportOOMError();
return NULL;
}
memmove (xml, ans.extra.str, xmllen);
}
xmllen = ans.len - sizeof(virProxyPacket);
if (VIR_ALLOC_N(xml, xmllen+1) < 0) {
- virReportOOMError(domain->conn);
+ virReportOOMError();
return NULL;
}
memmove(xml, &ans.extra.dinfo, xmllen);
}
oslen = ans.len - sizeof(virProxyPacket);
if (VIR_ALLOC_N(ostype, oslen+1) < 0) {
- virReportOOMError(domain->conn);
+ virReportOOMError();
return NULL;
}
memmove(ostype, &ans.extra.dinfo, oslen);
struct sexpr *ret;
if (VIR_ALLOC(ret) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return (NULL);
}
ret->kind = SEXPR_NIL;
ret->u.value = strndup(start, ptr - start);
if (ret->u.value == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto error;
}
ret->u.value = strndup(start, ptr - start);
if (ret->u.value == NULL) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto error;
}
}
return(NULL);
if (VIR_ALLOC_N(cpulist, priv->nbNodeCpus) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto done;
}
if (VIR_ALLOC_N(cpuinfo, nb_vcpu) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto done;
}
cpumaplen = VIR_CPU_MAPLEN(VIR_NODEINFO_MAXCPUS(nodeinfo));
if (xalloc_oversized(nb_vcpu, cpumaplen) ||
VIR_ALLOC_N(cpumap, nb_vcpu * cpumaplen) < 0) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto done;
}
conn->uri = xmlParseURI("xen:///");
if (!conn->uri) {
- virReportOOMError (NULL);
+ virReportOOMError();
return VIR_DRV_OPEN_ERROR;
}
} else {
/* Allocate per-connection private data. */
if (VIR_ALLOC(priv) < 0) {
- virReportOOMError (NULL);
+ virReportOOMError();
return VIR_DRV_OPEN_ERROR;
}
if (virMutexInit(&priv->lock) < 0) {
/* Allocate callback list */
if (VIR_ALLOC(cbList) < 0) {
- virReportOOMError (NULL);
+ virReportOOMError();
virMutexDestroy(&priv->lock);
VIR_FREE(priv);
return VIR_DRV_OPEN_ERROR;
char *xml;
if (!(xml = virCapabilitiesFormatXML(priv->caps))) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
virUUIDFormat(dom->uuid, uuidstr);
if (virAsprintf(&path, "%s/%s", XEND_DOMAINS_DIR, uuidstr) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
goto done;
}
if (access(path, R_OK) == 0)
goto cleanup;
if (VIR_ALLOC_N(ret, len) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
list->count++;
return 0;
memory_error:
- virReportOOMError (NULL);
+ virReportOOMError();
if (info)
VIR_FREE(info->name);
VIR_FREE(info);
case XEN_SCHEDULER_SEDF:
schedulertype = strdup("sedf");
if (schedulertype == NULL)
- virReportOOMError(domain->conn);
+ virReportOOMError();
if (nparams)
*nparams = 6;
break;
case XEN_SCHEDULER_CREDIT:
schedulertype = strdup("credit");
if (schedulertype == NULL)
- virReportOOMError(domain->conn);
+ virReportOOMError();
if (nparams)
*nparams = 2;
break;
* for Xen, and also nr_cpus must be 'sizeof(uint64_t) * 8' */
if (maplen < 8) {
if (VIR_ALLOC_N(new, sizeof(uint64_t)) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return (-1);
}
memcpy(new, cpumap, maplen);
hypervisor_version = 2;
if (VIR_ALLOC(ipt) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return(-1);
}
/* Currently consider RHEL5.0 Fedora7, xen-3.1, and xen-unstable */
utsname.machine,
pae, hvm,
guest_arches, i)) == NULL)
- virReportOOMError(NULL);
+ virReportOOMError();
return caps;
}
return caps;
no_memory:
- virReportOOMError(NULL);
+ virReportOOMError();
virCapabilitiesFree(caps);
return NULL;
}
char *xml;
if (!(xml = virCapabilitiesFormatXML(priv->caps))) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
retry:
if (!(XEN_GETDOMAININFOLIST_ALLOC(dominfos, maxids))) {
- virReportOOMError(conn);
+ virReportOOMError();
return(-1);
}
return(0);
if (!(XEN_GETDOMAININFOLIST_ALLOC(dominfos, maxids))) {
- virReportOOMError(conn);
+ virReportOOMError();
return(-1);
}
ostype = strdup("linux");
if (ostype == NULL)
- virReportOOMError(dom->conn);
+ virReportOOMError();
return ostype;
}
retry:
if (!(XEN_GETDOMAININFOLIST_ALLOC(dominfos, maxids))) {
- virReportOOMError(conn);
+ virReportOOMError();
return(NULL);
}
if (!*name) {
DEBUG0("Error getting dom from def");
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
return 0;
if (!memcmp(rawuuid, priv->configInfoList->doms[i]->uuid, VIR_UUID_BUFLEN)) {
*name = strdup(priv->configInfoList->doms[i]->name);
if (!*name) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
memcpy(uuid, priv->configInfoList->doms[i]->uuid, VIR_UUID_BUFLEN);
}
if (!(*name = strdup(dom->name))) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
memcpy(uuid, dom->uuid, VIR_UUID_BUFLEN);
priv->useXenConfigCache = 0;
if (VIR_ALLOC(priv->configInfoList) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
if (virBufferError(&buf)) {
virBufferFreeAndReset(&buf);
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
size_t i;
if (VIR_ALLOC_N(buffer, len * 3 + 1) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return (NULL);
}
ptr = buffer;
if (domname) {
*domname = strdup(name);
if (*domname == NULL) {
- virReportOOMError(xend);
+ virReportOOMError();
goto error;
}
}
return 0;
no_memory:
- virReportOOMError(xend);
+ virReportOOMError();
return -1;
}
if (ret == -1) {
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
}
error:
virDomainChrDefPtr def;
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
return def;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
error:
virDomainChrDefFree(def);
return NULL;
return 0;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
error:
virDomainDiskDefFree(disk);
return 0;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
cleanup:
virDomainNetDefFree(net);
return -1;
return 0;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
error:
return -1;
}
static int
-xenDaemonParseSxprUSB(virConnectPtr conn,
- virDomainDefPtr def,
+xenDaemonParseSxprUSB(virDomainDefPtr def,
const struct sexpr *root)
{
struct sexpr *cur, *node;
return 0;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
return 0;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
virDomainGraphicsDefFree(graphics);
return -1;
}
return 0;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
error:
virDomainGraphicsDefFree(graphics);
return -1;
return 0;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
error:
virDomainHostdevDefFree(dev);
if (cpus != NULL) {
def->cpumasklen = VIR_DOMAIN_CPUMASK_LEN;
if (VIR_ALLOC_N(def->cpumask, def->cpumasklen) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
/* in case of HVM we have USB device emulation */
if (hvm &&
- xenDaemonParseSxprUSB(conn, def, root) < 0)
+ xenDaemonParseSxprUSB(def, root) < 0)
goto error;
/* Character device config */
return def;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
error:
VIR_FREE(tty);
virDomainDefFree(def);
memory_error:
VIR_FREE(cpuNums);
VIR_FREE(cpuset);
- virReportOOMError(conn);
+ virReportOOMError();
return (-1);
}
} else if (STRCASEEQ (conn->uri->scheme, "http")) {
if (conn->uri->port &&
virAsprintf(&port, "%d", conn->uri->port) == -1) {
- virReportOOMError(conn);
+ virReportOOMError();
goto failed;
}
}
if (type == NULL)
- virReportOOMError(domain->conn);
+ virReportOOMError();
sexpr_free(root);
name = strdup(*tmp);
if (name == NULL)
- virReportOOMError(conn);
+ virReportOOMError();
break;
}
name = strdup(domname);
if (name == NULL)
- virReportOOMError(conn);
+ virReportOOMError();
}
sexpr_free(root);
autonode->u.s.car->u.value = (autostart ? strdup("start")
: strdup("ignore"));
if (!(autonode->u.s.car->u.value)) {
- virReportOOMError(domain->conn);
+ virReportOOMError();
goto error;
}
}
hostname = strdup (uriptr->server);
if (!hostname) {
- virReportOOMError (conn);
+ virReportOOMError();
xmlFreeURI (uriptr);
return -1;
}
n = p - uri; /* n = Length of hostname in bytes. */
hostname = strdup (uri);
if (!hostname) {
- virReportOOMError (conn);
+ virReportOOMError();
return -1;
}
hostname[n] = '\0';
else { /* "hostname" (or IP address) */
hostname = strdup (uri);
if (!hostname) {
- virReportOOMError (conn);
+ virReportOOMError();
return -1;
}
}
continue;
if ((names[ret++] = strdup(node->u.value)) == NULL) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
if (STREQ (ret, "credit")) {
schedulertype = strdup("credit");
if (schedulertype == NULL){
- virReportOOMError(domain->conn);
+ virReportOOMError();
goto error;
}
*nparams = XEN_SCHED_CRED_NPARAM;
} else if (STREQ (ret, "sedf")) {
schedulertype = strdup("sedf");
if (schedulertype == NULL){
- virReportOOMError(domain->conn);
+ virReportOOMError();
goto error;
}
*nparams = XEN_SCHED_SEDF_NPARAM;
}
if (virBufferError(buf)) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
}
if (virBufferError(buf)) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
virBufferAddLit(&buf, ")"); /* closes (vm */
if (virBufferError(&buf)) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
def->source.subsys.u.pci.bus,
def->source.subsys.u.pci.slot,
def->source.subsys.u.pci.function) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
}
if (!(*value = strdup(val->str))) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
} else { /* Completely new entry */
newborn = 1;
if (VIR_ALLOC(entry) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
memcpy(entry->filename, filename, PATH_MAX);
const char *defaultArch, *defaultMachine;
if (VIR_ALLOC(def) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return NULL;
}
return def;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
/* fallthrough */
cleanup:
virDomainGraphicsDefFree(graphics);
if (virBufferError(&mapbuf)) {
virBufferFreeAndReset(&mapbuf);
- virReportOOMError(domain->conn);
+ virReportOOMError();
goto cleanup;
}
mapsave = mapstr;
if (VIR_ALLOC_N(cpuset, maxcpu) < 0) {
- virReportOOMError(domain->conn);
+ virReportOOMError();
goto cleanup;
}
if (virDomainCpuSetParse(domain->conn,
virConfValuePtr value = NULL;
if (VIR_ALLOC(value) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
virConfValuePtr value = NULL;
if (VIR_ALLOC(value) < 0) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
value->next = NULL;
if (!(value->str = strdup(str))) {
VIR_FREE(value);
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
virBufferAddLit(&buf, ",w");
if (virBufferError(&buf)) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
if (VIR_ALLOC(val) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
net->ifname);
if (virBufferError(&buf)) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
if (VIR_ALLOC(val) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
static int
-xenXMDomainConfigFormatPCI(virConnectPtr conn,
- virConfPtr conf,
+xenXMDomainConfigFormatPCI(virConfPtr conf,
virDomainDefPtr def)
{
return 0;
if (VIR_ALLOC(pciVal) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
def->hostdevs[i]->source.subsys.u.pci.bus,
def->hostdevs[i]->source.subsys.u.pci.slot,
def->hostdevs[i]->source.subsys.u.pci.function) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
if (VIR_ALLOC(val) < 0) {
VIR_FREE(buf);
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
val->type = VIR_CONF_STRING;
}
VIR_FREE(netVal);
- if (xenXMDomainConfigFormatPCI(conn, conf, def) < 0)
+ if (xenXMDomainConfigFormatPCI(conf, def) < 0)
goto cleanup;
if (hvm) {
return conf;
no_memory:
- virReportOOMError(conn);
+ virReportOOMError();
cleanup:
virConfFreeValue(diskVal);
goto error;
if (VIR_ALLOC(entry) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
goto error;
}
for (i = 0; i < ctx.count; i++)
VIR_FREE(ctx.names[i]);
- virReportOOMError(conn);
+ virReportOOMError();
goto cleanup;
}
case VIR_DOMAIN_DEVICE_DISK:
{
if (virDomainDiskInsert(def, dev->data.disk) < 0) {
- virReportOOMError(domain->conn);
+ virReportOOMError();
goto cleanup;
}
dev->data.disk = NULL;
case VIR_DOMAIN_DEVICE_NET:
{
if (VIR_REALLOC_N(def->nets, def->nnets+1) < 0) {
- virReportOOMError(domain->conn);
+ virReportOOMError();
goto cleanup;
}
def->nets[def->nnets++] = dev->data.net;
int ret = -1;
if (!linkname || !config) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto cleanup;
}
int ret = -1;
if (!linkname || !config) {
- virReportOOMError(dom->conn);
+ virReportOOMError();
goto cleanup;
}
#ifndef PROXY
/* Init activeDomainList */
if (VIR_ALLOC(priv->activeDomainList) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
so we can know if it is the first time through
when the callback fires */
if (VIR_ALLOC(priv->xsWatchList) < 0) {
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
if (str == NULL)
str = strdup("linux");
if (str == NULL)
- virReportOOMError(conn);
+ virReportOOMError();
return (str);
}
ret = strdup(list[i]);
if (ret == NULL)
- virReportOOMError(conn);
+ virReportOOMError();
break;
}
ret = strdup(list[i]);
if (ret == NULL)
- virReportOOMError(conn);
+ virReportOOMError();
VIR_FREE (val);
VIR_FREE (list);
ret = strdup(list[i]);
if (ret == NULL)
- virReportOOMError(conn);
+ virReportOOMError();
VIR_FREE (val);
VIR_FREE (list);
VIR_FREE(watch);
}
- virReportOOMError(conn);
+ virReportOOMError();
return -1;
}
return -1;
if( VIR_ALLOC_N(new_domids,new_domain_cnt) < 0 ) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
nread = xenStoreDoListDomains(conn, priv, new_domids, new_domain_cnt);
return -1;
if( VIR_ALLOC_N(new_domids,new_domain_cnt) < 0 ) {
- virReportOOMError(NULL);
+ virReportOOMError();
return -1;
}
nread = xenStoreDoListDomains(conn, priv, new_domids, new_domain_cnt);
projects / libvirt.git / commitdiff