* src/uml_conf.c (VIR_FROM_THIS): Define to VIR_FROM_UML.
* src/xs_internal.c (VIR_FROM_THIS): Define to VIR_FROM_XEN.
* src/xml.c (VIR_FROM_THIS): Define to VIR_FROM_XML.
* src/stats_linux.c (VIR_FROM_THIS): Define to VIR_FROM_STATS_LINUX.
* src/datatypes.c (VIR_FROM_THIS): Define to VIR_FROM_NONE.
* src/lxc_conf.c (VIR_FROM_THIS): Define to VIR_FROM_LXC.
* src/libvirt.c (VIR_FROM_THIS): Define to VIR_FROM_NONE.
* src/node_device_conf.c (VIR_FROM_THIS): Define to VIR_FROM_NODEDEV.
* src/openvz_conf.c (VIR_FROM_THIS): Define to VIR_FROM_OPENVZ.
* src/openvz_driver.c (VIR_FROM_THIS): Define to VIR_FROM_OPENVZ.
* src/conf.c (VIR_FROM_THIS): Define to VIR_FROM_CONF.
Note: this loses config_filename:config_lineno diagnostics,
but that's ok.
* src/node_device.c (VIR_FROM_THIS): Define to VIR_FROM_NODEDEV.
* src/sexpr.c (VIR_FROM_THIS): Define to VIR_FROM_SEXPR.
* po/POTFILES.in: remove src/sexpr.c and src/lxc_conf.c
+Thu Jan 29 13:06:51 +0100 2009 Jim Meyering <meyering@redhat.com>
+
+ error-reporting calls using VIR_ERR_NO_MEMORY: use virReportOOMError instead
+ * src/uml_conf.c (VIR_FROM_THIS): Define to VIR_FROM_UML.
+ * src/xs_internal.c (VIR_FROM_THIS): Define to VIR_FROM_XEN.
+ * src/xml.c (VIR_FROM_THIS): Define to VIR_FROM_XML.
+ * src/stats_linux.c (VIR_FROM_THIS): Define to VIR_FROM_STATS_LINUX.
+ * src/datatypes.c (VIR_FROM_THIS): Define to VIR_FROM_NONE.
+ * src/lxc_conf.c (VIR_FROM_THIS): Define to VIR_FROM_LXC.
+ * src/libvirt.c (VIR_FROM_THIS): Define to VIR_FROM_NONE.
+ * src/node_device_conf.c (VIR_FROM_THIS): Define to VIR_FROM_NODEDEV.
+ * src/openvz_conf.c (VIR_FROM_THIS): Define to VIR_FROM_OPENVZ.
+ * src/openvz_driver.c (VIR_FROM_THIS): Define to VIR_FROM_OPENVZ.
+ * src/conf.c (VIR_FROM_THIS): Define to VIR_FROM_CONF.
+ Note: this loses config_filename:config_lineno diagnostics,
+ but that's ok.
+ * src/node_device.c (VIR_FROM_THIS): Define to VIR_FROM_NODEDEV.
+ * src/sexpr.c (VIR_FROM_THIS): Define to VIR_FROM_SEXPR.
+ * po/POTFILES.in: remove src/sexpr.c and src/lxc_conf.c
+
Thu Jan 29 12:44:15 CET 2009 Guido Günther <agx@sigxcpu.org>
* src/virsh.c (main): don't abort when setlocale() fails
src/domain_conf.c
src/iptables.c
src/libvirt.c
-src/lxc_conf.c
src/lxc_container.c
src/lxc_controller.c
src/lxc_driver.c
src/qemu_conf.c
src/qemu_driver.c
src/remote_internal.c
-src/sexpr.c
src/storage_backend.c
src/storage_backend_disk.c
src/storage_backend_fs.c
#include "c-ctype.h"
#include "memory.h"
+#define VIR_FROM_THIS VIR_FROM_CONF
+
/************************************************************************
* *
* Structures and macros used by the mini parser *
virConfPtr ret;
if (VIR_ALLOC(ret) < 0) {
- virConfError(NULL, VIR_ERR_NO_MEMORY, _("allocating configuration"));
+ virReportOOMError(NULL);
return(NULL);
}
ret->filename = NULL;
return(NULL);
if (VIR_ALLOC(ret) < 0) {
- virConfError(NULL, VIR_ERR_NO_MEMORY, _("allocating configuration"));
+ virReportOOMError(NULL);
return(NULL);
}
return(NULL);
}
if (VIR_ALLOC(ret) < 0) {
- virConfError(ctxt, VIR_ERR_NO_MEMORY, _("allocating configuration"));
+ virReportOOMError(NULL);
virConfFreeList(lst);
VIR_FREE(str);
return(NULL);
NEXT;
ret = strndup(base, ctxt->cur - base);
if (ret == NULL) {
- virConfError(ctxt, VIR_ERR_NO_MEMORY, _("allocating configuration"));
+ virReportOOMError(NULL);
return(NULL);
}
return(ret);
while ((ctxt->cur < ctxt->end) && (!IS_EOL(CUR))) NEXT;
comm = strndup(base, ctxt->cur - base);
if (comm == NULL) {
- virConfError(ctxt, VIR_ERR_NO_MEMORY, _("allocating configuration"));
+ virReportOOMError(NULL);
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) {
- virConfError(ctxt, VIR_ERR_NO_MEMORY, _("allocating configuration"));
+ virReportOOMError(NULL);
VIR_FREE(name);
virConfFreeValue(value);
return(-1);
}
if (virBufferError(&buf)) {
- virConfError(NULL, VIR_ERR_NO_MEMORY, _("allocate buffer"));
+ virReportOOMError(NULL);
return -1;
}
}
if (virBufferError(&buf)) {
- virConfError(NULL, VIR_ERR_NO_MEMORY, _("allocate buffer"));
+ virReportOOMError(NULL);
return -1;
}
/*
* datatypes.h: management of structs for public data types
*
- * Copyright (C) 2006-2008 Red Hat, Inc.
+ * Copyright (C) 2006-2009 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
#include "logging.h"
#include "memory.h"
+#define VIR_FROM_THIS VIR_FROM_NONE
+
/************************************************************************
* *
* Domain and Connections allocations *
virConnectPtr ret;
if (VIR_ALLOC(ret) < 0) {
- virLibConnError(NULL, VIR_ERR_NO_MEMORY, _("allocating connection"));
+ virReportOOMError(NULL);
goto failed;
}
if (virMutexInit(&ret->lock) < 0) {
/* TODO check the UUID */
if (ret == NULL) {
if (VIR_ALLOC(ret) < 0) {
- virLibConnError(conn, VIR_ERR_NO_MEMORY, _("allocating domain"));
+ virReportOOMError(conn);
goto error;
}
ret->name = strdup(name);
if (ret->name == NULL) {
- virLibConnError(conn, VIR_ERR_NO_MEMORY, _("allocating domain"));
+ virReportOOMError(conn);
goto error;
}
ret->magic = VIR_DOMAIN_MAGIC;
/* TODO check the UUID */
if (ret == NULL) {
if (VIR_ALLOC(ret) < 0) {
- virLibConnError(conn, VIR_ERR_NO_MEMORY, _("allocating network"));
+ virReportOOMError(conn);
goto error;
}
ret->name = strdup(name);
if (ret->name == NULL) {
- virLibConnError(conn, VIR_ERR_NO_MEMORY, _("allocating network"));
+ virReportOOMError(conn);
goto error;
}
ret->magic = VIR_NETWORK_MAGIC;
/* TODO check the UUID */
if (ret == NULL) {
if (VIR_ALLOC(ret) < 0) {
- virLibConnError(conn, VIR_ERR_NO_MEMORY, _("allocating storage pool"));
+ virReportOOMError(conn);
goto error;
}
ret->name = strdup(name);
if (ret->name == NULL) {
- virLibConnError(conn, VIR_ERR_NO_MEMORY, _("allocating storage pool"));
+ virReportOOMError(conn);
goto error;
}
ret->magic = VIR_STORAGE_POOL_MAGIC;
ret = (virStorageVolPtr) virHashLookup(conn->storageVols, key);
if (ret == NULL) {
if (VIR_ALLOC(ret) < 0) {
- virLibConnError(conn, VIR_ERR_NO_MEMORY, _("allocating storage vol"));
+ virReportOOMError(conn);
goto error;
}
ret->pool = strdup(pool);
if (ret->pool == NULL) {
- virLibConnError(conn, VIR_ERR_NO_MEMORY, _("allocating storage vol"));
+ virReportOOMError(conn);
goto error;
}
ret->name = strdup(name);
if (ret->name == NULL) {
- virLibConnError(conn, VIR_ERR_NO_MEMORY, _("allocating storage vol"));
+ virReportOOMError(conn);
goto error;
}
strncpy(ret->key, key, sizeof(ret->key)-1);
ret = (virNodeDevicePtr) virHashLookup(conn->nodeDevices, name);
if (ret == NULL) {
if (VIR_ALLOC(ret) < 0) {
- virLibConnError(conn, VIR_ERR_NO_MEMORY, _("allocating node dev"));
+ virReportOOMError(conn);
goto error;
}
ret->magic = VIR_NODE_DEVICE_MAGIC;
ret->conn = conn;
ret->name = strdup(name);
if (ret->name == NULL) {
- virLibConnError(conn, VIR_ERR_NO_MEMORY, _("copying node dev name"));
+ virReportOOMError(conn);
goto error;
}
}
if (VIR_ALLOC(domain) < 0) {
- virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
domain->def = def;
if (VIR_REALLOC_N(doms->objs, doms->count + 1) < 0) {
- virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
VIR_FREE(domain);
return NULL;
}
char *bus = NULL;
if (VIR_ALLOC(def) < 0) {
- virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
char *target = NULL;
if (VIR_ALLOC(def) < 0) {
- virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
char *model = NULL;
if (VIR_ALLOC(def) < 0) {
- virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
virDomainChrDefPtr def;
if (VIR_ALLOC(def) < 0) {
- virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
char *bus = NULL;
if (VIR_ALLOC(def) < 0) {
- virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
char *type = NULL;
if (VIR_ALLOC(def) < 0) {
- virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
virDomainSoundDefPtr def;
if (VIR_ALLOC(def) < 0) {
- virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
char *mode, *type = NULL;
if (VIR_ALLOC(def) < 0) {
- virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
def->target = NULL;
}
if (VIR_ALLOC(dev) < 0) {
- virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
goto error;
}
virDomainDefPtr def;
if (VIR_ALLOC(def) < 0) {
- virDomainReportError(conn, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate space for xmlXPathContext"));
+ virReportOOMError(conn);
return NULL;
}
char *set = tmp;
def->cpumasklen = VIR_DOMAIN_CPUMASK_LEN;
if (VIR_ALLOC_N(def->cpumask, def->cpumasklen) < 0) {
- virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
goto error;
}
if (virDomainCpuSetParse(conn, (const char **)&set,
if (def->os.bootloader) {
def->os.type = strdup("xen");
if (!def->os.type) {
- virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
goto error;
}
} else {
def->virtType == VIR_DOMAIN_VIRT_XEN) {
VIR_FREE(def->os.type);
if (!(def->os.type = strdup("xen"))) {
- virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
goto error;
}
}
goto error;
}
if (!(def->os.arch = strdup(defaultArch))) {
- virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
goto error;
}
}
def->os.arch);
if (defaultMachine != NULL) {
if (!(def->os.machine = strdup(defaultMachine))) {
- virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
goto error;
}
}
virDomainInputDefPtr input;
if (VIR_ALLOC(input) < 0) {
- virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
goto error;
}
if (STREQ(def->os.type, "hvm")) {
return def;
no_memory:
- virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
/* fallthrough */
error:
ctxt = xmlXPathNewContext(xml);
if (ctxt == NULL) {
- virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
goto cleanup;
}
}
if (virBufferError(&buf)) {
- virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
return virBufferContentAndReset(&buf);
no_memory:
- virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
cleanup:
tmp = virBufferContentAndReset(&buf);
VIR_FREE(tmp);
char *ret = NULL;
if (virAsprintf(&ret, "%s/%s.xml", dir, name) < 0) {
- virDomainReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
#endif
#endif
+#define VIR_FROM_THIS VIR_FROM_NONE
+
/*
* TODO:
* - use lock to protect against concurrent accesses ?
name = (char *)xmlSaveUri(conn->uri);
if (!name) {
- virLibConnError (conn, VIR_ERR_NO_MEMORY, __FUNCTION__);
+ virReportOOMError (conn);
goto error;
}
return name;
#include "nodeinfo.h"
#include "virterror_internal.h"
+#define VIR_FROM_THIS VIR_FROM_LXC
+
/* Functions */
virCapsPtr lxcCapsInit(void)
{
return 0;
no_memory:
- lxcError(NULL, NULL, VIR_ERR_NO_MEMORY,
- "%s", _("while loading LXC driver config"));
+ virReportOOMError(NULL);
return -1;
}
continue;
if (virAsprintf(&src, "/.oldroot/%s", vmDef->fss[i]->src) < 0) {
- lxcError(NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(NULL);
return -1;
}
if (VIR_REALLOC_N(mounts, nmounts+1) < 0) {
endmntent(procmnt);
- lxcError(NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(NULL);
return -1;
}
if (!(mounts[nmounts++] = strdup(mntent.mnt_dir))) {
endmntent(procmnt);
- lxcError(NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(NULL);
return -1;
}
}
/* allocate a stack for the container */
if (VIR_ALLOC_N(stack, stacksize) < 0) {
- lxcError(NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(NULL);
return -1;
}
stacktop = stack + stacksize;
if (virAsprintf(&sockpath, "%s/%s.sock",
LXC_STATE_DIR, def->name) < 0)
- lxcError(NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(NULL);
return sockpath;
}
if (conn->uri == NULL) {
conn->uri = xmlParseURI("lxc:///");
if (!conn->uri) {
- lxcError(conn, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return VIR_DRV_OPEN_ERROR;
}
} else if (conn->uri->scheme == NULL ||
virDomainObjLock(driver->domains.objs[i]);
if (!virDomainIsActive(driver->domains.objs[i])) {
if (!(names[got++] = strdup(driver->domains.objs[i]->def->name))) {
- lxcError(conn, NULL, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate space for VM name string"));
+ virReportOOMError(conn);
virDomainObjUnlock(driver->domains.objs[i]);
goto cleanup;
}
if (virAsprintf(&sockpath, "%s/%s.sock",
driver->stateDir, vm->def->name) < 0) {
- lxcError(conn, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return -1;
}
return ret;
no_memory:
- lxcError(conn, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
goto cleanup;
}
if (virAsprintf(&logfile, "%s/%s.log",
driver->logDir, vm->def->name) < 0) {
- lxcError(conn, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return -1;
}
}
if (VIR_ALLOC(network) < 0) {
- virNetworkReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
if (virMutexInit(&network->lock) < 0) {
network->def = def;
if (VIR_REALLOC_N(nets->objs, nets->count + 1) < 0) {
- virNetworkReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
VIR_FREE(network);
return NULL;
}
if (VIR_REALLOC_N(def->ranges, def->nranges + 1) < 0) {
xmlFree(start);
xmlFree(end);
- virNetworkReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return -1;
}
def->ranges[def->nranges].start = (char *)start;
VIR_FREE(ip);
VIR_FREE(mac);
VIR_FREE(name);
- virNetworkReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return -1;
}
def->hosts[def->nhosts].mac = (char *)mac;
char *tmp;
if (VIR_ALLOC(def) < 0) {
- virNetworkReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
netaddr = inet_ntoa(inaddress);
if (virAsprintf(&def->network, "%s/%s", netaddr, def->netmask) < 0) {
- virNetworkReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
goto error;
}
ctxt = xmlXPathNewContext(xml);
if (ctxt == NULL) {
- virNetworkReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
goto cleanup;
}
return virBufferContentAndReset(&buf);
no_memory:
- virNetworkReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
tmp = virBufferContentAndReset(&buf);
VIR_FREE(tmp);
return NULL;
char *ret = NULL;
if (virAsprintf(&ret, "%s/%s.xml", dir, name) < 0) {
- virNetworkReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
}
if (!(driverState->iptables = iptablesContextNew())) {
- networkReportError(NULL, NULL, NULL, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate space for IP tables support"));
+ virReportOOMError(NULL);
goto error;
}
VIR_FREE((*argv)[i]);
VIR_FREE(*argv);
}
- networkReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate space for dnsmasq argv"));
+ virReportOOMError(conn);
return -1;
}
if (virNetworkIsActive(driver->networks.objs[i])) {
if (!(names[got] = strdup(driver->networks.objs[i]->def->name))) {
virNetworkObjUnlock(driver->networks.objs[i]);
- networkReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate space for VM name string"));
+ virReportOOMError(conn);
goto cleanup;
}
got++;
if (!virNetworkIsActive(driver->networks.objs[i])) {
if (!(names[got] = strdup(driver->networks.objs[i]->def->name))) {
virNetworkObjUnlock(driver->networks.objs[i]);
- networkReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate space for VM name string"));
+ virReportOOMError(conn);
goto cleanup;
}
got++;
bridge = strdup(network->def->bridge);
if (!bridge)
- networkReportError(net->conn, NULL, net, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate space for network bridge string"));
+ virReportOOMError(net->conn);
cleanup:
if (network)
#include "node_device_conf.h"
#include "node_device.h"
+#define VIR_FROM_THIS VIR_FROM_NODEDEV
+
static int dev_has_cap(const virNodeDeviceObjPtr dev, const char *cap)
{
virNodeDevCapsDefPtr caps = dev->def->caps;
ret = strdup(obj->def->parent);
if (!ret)
- virNodeDeviceReportError(dev->conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(dev->conn);
cleanup:
if (obj)
#include "buf.h"
#include "uuid.h"
+#define VIR_FROM_THIS VIR_FROM_NODEDEV
VIR_ENUM_IMPL(virNodeDevCap, VIR_NODE_DEV_CAP_LAST,
"system",
}
if (VIR_ALLOC(device) < 0) {
- virNodeDeviceReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
device->def = NULL;
virNodeDeviceObjUnlock(device);
virNodeDeviceObjFree(device);
- virNodeDeviceReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
devs->objs[devs->count++] = device;
return virBufferContentAndReset(&buf);
no_memory:
- virNodeDeviceReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
tmp = virBufferContentAndReset(&buf);
VIR_FREE(tmp);
return NULL;
{
virMutexUnlock(&obj->lock);
}
-
#include "util.h"
#include "nodeinfo.h"
+#define VIR_FROM_THIS VIR_FROM_OPENVZ
+
static char *openvzLocateConfDir(void);
static int openvzGetVPSUUID(int vpsid, char *uuidstr);
static int openvzLocateConfFile(int vpsid, char *conffile, int maxlen, const char *ext);
return 0;
no_memory:
- openvzError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
error:
virDomainNetDefFree(net);
return -1;
return 0;
no_memory:
- openvzError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
error:
virDomainFSDefFree(fs);
return -1;
return 0;
no_memory:
- openvzError(NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(NULL);
cleanup:
fclose(fp);
#include "memory.h"
#include "bridge.h"
+#define VIR_FROM_THIS VIR_FROM_OPENVZ
+
#define OPENVZ_MAX_ARG 28
#define CMDBUF_LEN 1488
#define CMDOP_LEN 288
}
if (!(ret = strdup(vm->def->os.type)))
- openvzError(dom->conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(dom->conn);
cleanup:
if (vm)
}
if (VIR_ALLOC(driver) < 0) {
- openvzError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return VIR_DRV_OPEN_ERROR;
}
return got;
no_memory:
- openvzError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
for ( ; got >= 0 ; got--)
VIR_FREE(names[got]);
return -1;
virRegisterDriver(&openvzDriver);
return 0;
}
-
xmllen = ans.len - sizeof (virProxyPacket);
if (VIR_ALLOC_N(xml, xmllen+1) < 0) {
- virProxyError (conn, VIR_ERR_NO_MEMORY, __FUNCTION__);
+ virReportOOMError (conn);
return NULL;
}
memmove (xml, ans.extra.str, xmllen);
}
xmllen = ans.len - sizeof(virProxyPacket);
if (VIR_ALLOC_N(xml, xmllen+1) < 0) {
- virProxyError(domain->conn, VIR_ERR_NO_MEMORY, __FUNCTION__);
+ virReportOOMError(domain->conn);
return NULL;
}
memmove(xml, &ans.extra.dinfo, xmllen);
}
oslen = ans.len - sizeof(virProxyPacket);
if (VIR_ALLOC_N(ostype, oslen+1) < 0) {
- virProxyError(domain->conn, VIR_ERR_NO_MEMORY, __FUNCTION__);
+ virReportOOMError(domain->conn);
return NULL;
}
memmove(ostype, &ans.extra.dinfo, oslen);
/* Setup 2 critical defaults */
if (!(driver->vncListen = strdup("127.0.0.1"))) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate vncListen"));
+ virReportOOMError(NULL);
return -1;
}
if (!(driver->vncTLSx509certdir = strdup(SYSCONF_DIR "/pki/libvirt-vnc"))) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate vncTLSx509certdir"));
+ virReportOOMError(NULL);
return -1;
}
if (p && p->str) {
VIR_FREE(driver->vncTLSx509certdir);
if (!(driver->vncTLSx509certdir = strdup(p->str))) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate vncTLSx509certdir"));
+ virReportOOMError(NULL);
virConfFree(conf);
return -1;
}
if (p && p->str) {
VIR_FREE(driver->vncListen);
if (!(driver->vncListen = strdup(p->str))) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate vnc_listen"));
+ virReportOOMError(NULL);
virConfFree(conf);
return -1;
}
strchr(net->ifname, '%')) {
VIR_FREE(net->ifname);
if (!(net->ifname = strdup("vnet%d"))) {
- qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
goto error;
}
}
return retval;
no_memory:
- qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate space for tapfds string"));
+ virReportOOMError(conn);
error:
VIR_FREE(retval);
if (tapfd != -1)
return 0;
no_memory:
- qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate space for argv string"));
+ virReportOOMError(conn);
error:
if (tapfds &&
*tapfds) {
qemudDomainStatusPtr status = NULL;
if (VIR_ALLOC(status) < 0) {
- qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate space for vm status"));
+ virReportOOMError(conn);
goto error;
}
ctxt = xmlXPathNewContext(xml);
if (ctxt == NULL) {
- qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
goto error;
}
/*
* driver.c: core driver methods for managing qemu guests
*
- * Copyright (C) 2006, 2007, 2008 Red Hat, Inc.
+ * Copyright (C) 2006, 2007, 2008, 2009 Red Hat, Inc.
* Copyright (C) 2006 Daniel P. Berrange
*
* This library is free software; you can redistribute it and/or
char *file = NULL;
if (virAsprintf(&file, "%s/%s.xml", driver->stateDir, vm->def->name) < 0) {
- qemudReportError(conn, vm, NULL, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate space for status file"));
+ virReportOOMError(conn);
goto cleanup;
}
goto error;
if (!(vm->monitorpath = strdup(monitor))) {
- qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate space for monitor path"));
+ virReportOOMError(conn);
goto error;
}
while (*tmp) {
if (c_isspace(*tmp)) {
if (VIR_ALLOC_N(*path, (tmp-dev)+1) < 0) {
- qemudReportError(conn, NULL, NULL,
- VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return -1;
}
strncpy(*path, dev, (tmp-dev));
vm->nvcpupids = vm->def->vcpus;
if (VIR_ALLOC_N(vm->vcpupids, vm->nvcpupids) < 0) {
- qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY,
- "%s", _("allocate cpumap"));
+ virReportOOMError(conn);
return -1;
}
if (conn->uri == NULL) {
conn->uri = xmlParseURI(uid ? "qemu:///session" : "qemu:///system");
if (!conn->uri) {
- qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY,NULL);
+ virReportOOMError(conn);
return VIR_DRV_OPEN_ERROR;
}
} else if (conn->uri->scheme == NULL ||
qemuDriverLock(driver);
if ((xml = virCapabilitiesFormatXML(driver->caps)) == NULL)
- qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate space for capabilities support"));
+ virReportOOMError(conn);
qemuDriverUnlock(driver);
return xml;
}
if (!(type = strdup(vm->def->os.type)))
- qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate space for ostype"));
+ virReportOOMError(dom->conn);
cleanup:
if (vm)
virDomainObjLock(driver->domains.objs[i]);
if (!virDomainIsActive(driver->domains.objs[i])) {
if (!(names[got++] = strdup(driver->domains.objs[i]->def->name))) {
- qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate space for VM name string"));
+ virReportOOMError(conn);
virDomainObjUnlock(driver->domains.objs[i]);
goto cleanup;
}
}
if (ret == -1) {
- qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
}
if (!devname) {
- qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return -1;
}
}
if (newdisk->src) {
safe_path = qemudEscapeMonitorArg(newdisk->src);
if (!safe_path) {
- qemudReportError(conn, dom, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
VIR_FREE(devname);
return -1;
}
if (virAsprintf(&cmd, "change %s \"%s\"", devname, safe_path) == -1) {
- qemudReportError(conn, dom, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
VIR_FREE(safe_path);
VIR_FREE(devname);
return -1;
VIR_FREE(safe_path);
} else if (virAsprintf(&cmd, "eject %s", devname) == -1) {
- qemudReportError(conn, dom, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
VIR_FREE(devname);
return -1;
}
}
if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks+1) < 0) {
- qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return -1;
}
safe_path, type);
VIR_FREE(safe_path);
if (ret == -1) {
- qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return ret;
}
}
if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks+1) < 0) {
- qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return -1;
}
ret = virAsprintf(&cmd, "usb_add disk:%s", safe_path);
VIR_FREE(safe_path);
if (ret == -1) {
- qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return ret;
}
char *cmd, *reply;
if (VIR_REALLOC_N(vm->def->hostdevs, vm->def->nhostdevs+1) < 0) {
- qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return -1;
}
dev->data.hostdev->source.subsys.u.usb.device);
}
if (ret == -1) {
- qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return -1;
}
}
if (virAsprintf(&cmd, "pci_del 0 %d", detach->slotnum) < 0) {
- qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
goto cleanup;
}
if (vm->def->ndisks > 1) {
vm->def->disks[i] = vm->def->disks[--vm->def->ndisks];
if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks) < 0) {
- qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
goto cleanup;
}
qsort(vm->def->disks, vm->def->ndisks, sizeof(*vm->def->disks),
/* Caller frees */
if (virAsprintf(uri_out, "tcp:%s:%d", hostname, this_port) < 0) {
- qemudReportError (dconn, NULL, NULL, VIR_ERR_NO_MEMORY,
- "%s", strerror (errno));
+ virReportOOMError (dconn);
goto cleanup;
}
} else {
}
if (!name) {
- error(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
goto failed;
}
conn->uri = xmlParseURI(uriret.uri);
VIR_FREE(uriret.uri);
if (!conn->uri) {
- error (conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError (conn);
goto failed;
}
}
return retcode;
out_of_memory:
- error (conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError (conn);
failed:
/* Close the socket if we failed. */
return VIR_DRV_OPEN_DECLINED;
if (VIR_ALLOC(priv) < 0) {
- error (conn, VIR_ERR_NO_MEMORY, _("struct private_data"));
+ virReportOOMError (conn);
return VIR_DRV_OPEN_ERROR;
}
// call() will free this:
args.params.params_val[i].field = strdup (params[i].field);
if (args.params.params_val[i].field == NULL) {
- error (domain->conn, VIR_ERR_NO_MEMORY, _("out of memory"));
+ virReportOOMError (domain->conn);
do_error = 1;
}
args.params.params_val[i].value.type = params[i].type;
struct private_data *priv;
int ret, rflags = 0;
if (VIR_ALLOC(priv) < 0) {
- error (conn, VIR_ERR_NO_MEMORY, _("struct private_data"));
+ virReportOOMError (conn);
return VIR_DRV_OPEN_ERROR;
}
if (virMutexInit(&priv->lock) < 0) {
struct private_data *priv;
int ret, rflags = 0;
if (VIR_ALLOC(priv) < 0) {
- error (NULL, VIR_ERR_NO_MEMORY, _("struct private_data"));
+ virReportOOMError (NULL);
return VIR_DRV_OPEN_ERROR;
}
if (virMutexInit(&priv->lock) < 0) {
struct private_data *priv;
int ret, rflags = 0;
if (VIR_ALLOC(priv) < 0) {
- error (NULL, VIR_ERR_NO_MEMORY, _("struct private_data"));
+ virReportOOMError (NULL);
return VIR_DRV_OPEN_ERROR;
}
if (virMutexInit(&priv->lock) < 0) {
}
if (VIR_ALLOC_N(addr, strlen(host) + 1 + strlen(port) + 1) < 0) {
- virRaiseError (NULL, NULL, NULL, VIR_FROM_REMOTE,
- VIR_ERR_NO_MEMORY, VIR_ERR_ERROR,
- NULL, NULL, NULL, 0, 0,
- "address");
+ virReportOOMError (NULL);
return NULL;
}
ret_filter, ret);
if (!thiscall) {
- error (flags & REMOTE_CALL_IN_OPEN ? NULL : conn,
- VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError (flags & REMOTE_CALL_IN_OPEN ? NULL : conn);
return -1;
}
#include "util.h"
#include "memory.h"
+#define VIR_FROM_THIS VIR_FROM_SEXPR
+
#define virSexprError(code, fmt...) \
virReportErrorHelper(NULL, VIR_FROM_SEXPR, code, __FILE__, \
__FUNCTION__, __LINE__, fmt)
struct sexpr *ret;
if (VIR_ALLOC(ret) < 0) {
- virSexprError(VIR_ERR_NO_MEMORY, "%s", _("failed to allocate a node"));
+ virReportOOMError(NULL);
return (NULL);
}
ret->kind = SEXPR_NIL;
ret->u.value = strndup(start, ptr - start);
if (ret->u.value == NULL) {
- virSexprError(VIR_ERR_NO_MEMORY,
- "%s", _("failed to copy a string"));
+ virReportOOMError(NULL);
goto error;
}
ret->u.value = strndup(start, ptr - start);
if (ret->u.value == NULL) {
- virSexprError(VIR_ERR_NO_MEMORY,
- "%s", _("failed to copy a string"));
+ virReportOOMError(NULL);
goto error;
}
}
/*
* Linux block and network stats.
*
- * Copyright (C) 2007, 2008 Red Hat, Inc.
+ * Copyright (C) 2007-2009 Red Hat, Inc.
*
* See COPYING.LIB for the License of this software
*
#include "stats_linux.h"
#include "memory.h"
+#define VIR_FROM_THIS VIR_FROM_STATS_LINUX
+
/**
* statsErrorFunc:
* @conn: the connection
retval = virAsprintf(&mod_path, "/dev/%s", path);
if (retval < 0) {
- statsErrorFunc (conn, VIR_ERR_NO_MEMORY, __FUNCTION__,
- "allocating mod_path", domid);
+ virReportOOMError (conn);
return -1;
}
if (size + 1 == 0)
return BACKING_STORE_INVALID;
if (VIR_ALLOC_N(*res, size + 1) < 0) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, _("backing store path"));
+ virReportOOMError(conn);
return BACKING_STORE_ERROR;
}
memcpy(*res, buf + offset, size);
*end = '\0';
*res = strdup(start);
if (*res == NULL) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, _("backing store path"));
+ virReportOOMError(conn);
return BACKING_STORE_ERROR;
}
return BACKING_STORE_OK;
= absolutePathFromBaseFile(target->path, base);
VIR_FREE(base);
if (*backingStore == NULL) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY,
- _("backing store path"));
+ virReportOOMError(conn);
return -1;
}
}
if (STREQ(groups[1], pool->def->source.devices[0].path)) {
if ((*session = strdup(groups[0])) == NULL) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("session"));
+ virReportOOMError(conn);
return -1;
}
}
int opentries = 0;
if (VIR_ALLOC(vol) < 0) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("volume"));
+ virReportOOMError(conn);
goto cleanup;
}
vol->type = VIR_STORAGE_VOL_BLOCK;
if (virAsprintf(&(vol->name), "lun-%d", lun) < 0) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("name"));
+ virReportOOMError(conn);
goto cleanup;
}
if (virAsprintf(&devpath, "/dev/%s", dev) < 0) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("devpath"));
+ virReportOOMError(conn);
goto cleanup;
}
/* XXX use unique iSCSI id instead */
vol->key = strdup(vol->target.path);
if (vol->key == NULL) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("key"));
+ virReportOOMError(conn);
goto cleanup;
}
if (VIR_REALLOC_N(pool->volumes.objs,
pool->volumes.count+1) < 0) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
goto cleanup;
}
pool->volumes.objs[pool->volumes.count++] = vol;
scsidev = strdup(block2);
}
if (scsidev == NULL) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s",
- _("Failed allocating memory for scsidev"));
+ virReportOOMError(conn);
retval = -1;
goto namelist_cleanup;
}
return NULL;
if (VIR_ALLOC_N(portal, strlen(ipaddr) + 1 + 4 + 2 + 1) < 0) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("portal"));
+ virReportOOMError(conn);
return NULL;
}
/*
* storage_backend_logvol.c: storage backend for logical volume handling
*
- * Copyright (C) 2007-2008 Red Hat, Inc.
+ * Copyright (C) 2007-2009 Red Hat, Inc.
* Copyright (C) 2007-2008 Daniel P. Berrange
*
* This library is free software; you can redistribute it and/or
/* Or a completely new volume */
if (vol == NULL) {
if (VIR_ALLOC(vol) < 0) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("volume"));
+ virReportOOMError(conn);
return -1;
}
vol->type = VIR_STORAGE_VOL_BLOCK;
if ((vol->name = strdup(groups[0])) == NULL) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("volume"));
+ virReportOOMError(conn);
virStorageVolDefFree(vol);
return -1;
}
if (VIR_REALLOC_N(pool->volumes.objs,
pool->volumes.count + 1)) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
virStorageVolDefFree(vol);
return -1;
}
if (vol->key == NULL &&
(vol->key = strdup(groups[2])) == NULL) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("volume"));
+ virReportOOMError(conn);
return -1;
}
/* Finally fill in extents information */
if (VIR_REALLOC_N(vol->source.extents,
vol->source.nextent + 1) < 0) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("extents"));
+ virReportOOMError(conn);
return -1;
}
if ((vol->source.extents[vol->source.nextent].path =
strdup(groups[3])) == NULL) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("extents"));
+ virReportOOMError(conn);
return -1;
}
vgname = strdup(groups[1]);
if (pvname == NULL || vgname == NULL) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s",
- _("allocating pvname or vgname"));
+ virReportOOMError(conn);
goto err_no_memory;
}
if (thisSource == NULL) {
if (VIR_REALLOC_N(sourceList->sources, sourceList->nsources + 1) != 0) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s",
- _("allocating new source"));
+ virReportOOMError(conn);
goto err_no_memory;
}
VIR_FREE(vgname);
if (VIR_REALLOC_N(thisSource->devices, thisSource->ndevice + 1) != 0) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s",
- _("allocating new device"));
+ virReportOOMError(conn);
goto err_no_memory;
}
memset(zeros, 0, sizeof(zeros));
if (VIR_ALLOC_N(vgargv, 3 + pool->def->source.ndevice) < 0) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("command line"));
+ virReportOOMError(conn);
return -1;
}
}
if (VIR_ALLOC_N(vol->target.path, strlen(pool->def->target.path) +
1 + strlen(vol->name) + 1) < 0) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("volume"));
+ virReportOOMError(conn);
return -1;
}
strcpy(vol->target.path, pool->def->target.path);
char *authType = NULL;
if (VIR_ALLOC(ret) < 0) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY,
- "%s", _("cannot allocate storage pool"));
+ virReportOOMError(conn);
return NULL;
}
}
if (VIR_ALLOC_N(ret->source.devices, nsource) < 0) {
VIR_FREE(nodeset);
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("device"));
+ virReportOOMError(conn);
goto cleanup;
}
for (i = 0 ; i < nsource ; i++) {
/* source name defaults to pool name */
ret->source.name = strdup(ret->name);
if (ret->source.name == NULL) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s",
- _("pool name"));
+ virReportOOMError(conn);
goto cleanup;
}
}
ctxt = xmlXPathNewContext(xml);
if (ctxt == NULL) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY,
- "%s", _("xmlXPathContext"));
+ virReportOOMError(conn);
goto cleanup;
}
return virBufferContentAndReset(&buf);
no_memory:
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("xml"));
+ virReportOOMError(conn);
cleanup:
free(virBufferContentAndReset(&buf));
return NULL;
return NULL;
if (VIR_ALLOC(ret) < 0) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY,
- "%s", _("cannot allocate storage vol"));
+ virReportOOMError(conn);
return NULL;
}
ctxt = xmlXPathNewContext(xml);
if (ctxt == NULL) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY,
- "%s", _("xmlXPathContext"));
+ virReportOOMError(conn);
goto cleanup;
}
return virBufferContentAndReset(&buf);
no_memory:
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("xml"));
+ virReportOOMError(conn);
cleanup:
tmp = virBufferContentAndReset(&buf);
VIR_FREE(tmp);
}
if (VIR_ALLOC(pool) < 0) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY,
- "%s", _("pool"));
+ virReportOOMError(conn);
return NULL;
}
pool->def = NULL;
virStoragePoolObjUnlock(pool);
virStoragePoolObjFree(pool);
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
pools->objs[pools->count++] = pool;
return -1;
}
if (!(pool->configFile = strdup(path))) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY,
- "%s", _("configFile"));
+ virReportOOMError(conn);
return -1;
}
return -1;
}
if (!(pool->autostartLink = strdup(path))) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY,
- "%s", _("config file"));
+ virReportOOMError(conn);
VIR_FREE(pool->configFile);
return -1;
}
return virBufferContentAndReset(&buf);
no_memory:
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
cleanup:
free(virBufferContentAndReset(&buf));
return NULL;
/*
* uml_conf.c: UML driver configuration
*
- * Copyright (C) 2006, 2007, 2008 Red Hat, Inc.
+ * Copyright (C) 2006-2009 Red Hat, Inc.
* Copyright (C) 2006 Daniel P. Berrange
*
* This library is free software; you can redistribute it and/or
#include "nodeinfo.h"
#include "verify.h"
+#define VIR_FROM_THIS VIR_FROM_UML
#define umlLog(level, msg, ...) \
virLogMessage(__FILE__, level, 0, msg, __VA_ARGS__)
switch (def->type) {
case VIR_DOMAIN_CHR_TYPE_NULL:
if (virAsprintf(&ret, "%s%d=null", dev, def->dstPort) < 0) {
- umlReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
break;
case VIR_DOMAIN_CHR_TYPE_PTY:
if (virAsprintf(&ret, "%s%d=pts", dev, def->dstPort) < 0) {
- umlReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
break;
case VIR_DOMAIN_CHR_TYPE_DEV:
if (virAsprintf(&ret, "%s%d=tty:%s", dev, def->dstPort,
def->data.file.path) < 0) {
- umlReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
break;
case VIR_DOMAIN_CHR_TYPE_STDIO:
if (virAsprintf(&ret, "%s%d=fd:0,fd:1", dev, def->dstPort) < 0) {
- umlReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
break;
if (virAsprintf(&ret, "%s%d=port:%s", dev, def->dstPort,
def->data.tcp.service) < 0) {
- umlReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
break;
return 0;
no_memory:
- umlReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate space for argv string"));
+ virReportOOMError(conn);
error:
if (tapfds &&
*tapfds) {
char *argv_str;
if ((argv_str = virArgvToString(argv)) == NULL) {
- ReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("command debug string"));
+ virReportOOMError(conn);
return -1;
}
DEBUG0(argv_str);
buf = ((fds[i].fd == outfd) ? outbuf : errbuf);
size = (*buf ? strlen(*buf) : 0);
if (VIR_REALLOC_N(*buf, size+got+1) < 0) {
- ReportError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
goto error;
}
memmove(*buf+size, data, got);
char *argv_str = NULL;
if ((argv_str = virArgvToString(argv)) == NULL) {
- ReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("command debug string"));
+ virReportOOMError(conn);
goto error;
}
DEBUG0(argv_str);
* for Xen, and also nr_cpus must be 'sizeof(uint64_t) * 8' */
if (maplen < 8) {
if (VIR_ALLOC_N(new, sizeof(uint64_t)) < 0) {
- virXenErrorFunc(NULL, VIR_ERR_NO_MEMORY, __FUNCTION__,
- "allocating private data", 0);
+ virReportOOMError(NULL);
return (-1);
}
memcpy(new, cpumap, maplen);
hypervisor_version = 2;
if (VIR_ALLOC(ipt) < 0) {
- virXenError(NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(NULL);
return(-1);
}
/* Currently consider RHEL5.0 Fedora7, xen-3.1, and xen-unstable */
utsname.machine,
pae, hvm,
guest_arches, i)) == NULL)
- virXenError(NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(NULL);
return caps;
}
return caps;
no_memory:
- virXenError(NULL, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(NULL);
virCapabilitiesFree(caps);
return NULL;
}
char *xml;
if (!(xml = virCapabilitiesFormatXML(priv->caps))) {
- virXenError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
retry:
if (!(XEN_GETDOMAININFOLIST_ALLOC(dominfos, maxids))) {
- virXenError(conn, VIR_ERR_NO_MEMORY, _("allocating %d domain info"),
- maxids);
+ virReportOOMError(conn);
return(-1);
}
return(0);
if (!(XEN_GETDOMAININFOLIST_ALLOC(dominfos, maxids))) {
- virXenError(conn, VIR_ERR_NO_MEMORY, "allocating %d domain info",
- maxids);
+ virReportOOMError(conn);
return(-1);
}
retry:
if (!(XEN_GETDOMAININFOLIST_ALLOC(dominfos, maxids))) {
- virXenError(conn, VIR_ERR_NO_MEMORY, "allocating %d domain info",
- maxids);
+ virReportOOMError(conn);
return(NULL);
}
}
if (virBufferError(&buf)) {
- virXendError(NULL, VIR_ERR_NO_MEMORY, "%s", _("allocate buffer"));
+ virReportOOMError(NULL);
return -1;
}
size_t i;
if (VIR_ALLOC_N(buffer, len * 3 + 1) < 0) {
- virXendError(NULL, VIR_ERR_NO_MEMORY, "%s", _("allocate new buffer"));
+ virReportOOMError(NULL);
return (NULL);
}
ptr = buffer;
return 0;
no_memory:
- virXendError(xend, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(xend);
return -1;
}
if (ret == -1) {
no_memory:
- virXendError(conn, VIR_ERR_NO_MEMORY,
- "%s", _("no memory for char device config"));
+ virReportOOMError(conn);
}
error:
virDomainChrDefPtr def;
if (VIR_ALLOC(def) < 0) {
- virXendError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return NULL;
}
return def;
no_memory:
- virXendError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
error:
virDomainChrDefFree(def);
return NULL;
return 0;
no_memory:
- virXendError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
error:
virDomainDiskDefFree(disk);
return 0;
no_memory:
- virXendError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
cleanup:
virDomainNetDefFree(net);
return -1;
return 0;
no_memory:
- virXendError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
error:
return -1;
}
return 0;
no_memory:
- virXendError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
return -1;
}
return 0;
no_memory:
- virXendError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
virDomainGraphicsDefFree(graphics);
return -1;
}
return 0;
no_memory:
- virXendError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
error:
virDomainGraphicsDefFree(graphics);
return -1;
return def;
no_memory:
- virXendError(conn, VIR_ERR_NO_MEMORY, NULL);
+ virReportOOMError(conn);
error:
VIR_FREE(tty);
virDomainDefFree(def);
memory_error:
VIR_FREE(cpuNums);
VIR_FREE(cpuset);
- virXendError(conn, VIR_ERR_NO_MEMORY, "%s", _("allocate buffer"));
+ virReportOOMError(conn);
return (-1);
}
}
hostname = strdup (uriptr->server);
if (!hostname) {
- virXendError (conn, VIR_ERR_NO_MEMORY, "%s", _("strdup failed"));
+ virReportOOMError (conn);
xmlFreeURI (uriptr);
return -1;
}
n = p - uri; /* n = Length of hostname in bytes. */
hostname = strdup (uri);
if (!hostname) {
- virXendError (conn, VIR_ERR_NO_MEMORY, "%s", _("strdup failed"));
+ virReportOOMError (conn);
return -1;
}
hostname[n] = '\0';
else { /* "hostname" (or IP address) */
hostname = strdup (uri);
if (!hostname) {
- virXendError (conn, VIR_ERR_NO_MEMORY, "%s", _("strdup failed"));
+ virReportOOMError (conn);
return -1;
}
}
/*
* xml.c: XML based interfaces for the libvir library
*
- * Copyright (C) 2005, 2007, 2008 Red Hat, Inc.
+ * Copyright (C) 2005, 2007-2009 Red Hat, Inc.
*
* See COPYING.LIB for the License of this software
*
#include "util.h"
#include "memory.h"
+#define VIR_FROM_THIS VIR_FROM_XML
+
#define virXMLError(conn, code, fmt...) \
virReportErrorHelper(conn, VIR_FROM_XML, code, __FILE__, \
__FUNCTION__, __LINE__, fmt)
ret = strdup((char *) obj->stringval);
xmlXPathFreeObject(obj);
if (ret == NULL) {
- virXMLError(conn, VIR_ERR_NO_MEMORY, "%s", _("strdup failed"));
+ virReportOOMError(conn);
}
ctxt->node = relnode;
return (ret);
ret = obj->nodesetval->nodeNr;
if (list != NULL && ret) {
if (VIR_ALLOC_N(*list, ret) < 0) {
- virXMLError(conn, VIR_ERR_NO_MEMORY,
- _("allocate string array size %lu"),
- (unsigned long)ret * sizeof(**list));
+ virReportOOMError(conn);
ret = -1;
} else {
memcpy(*list, obj->nodesetval->nodeTab,
ctxt->node = relnode;
return (ret);
}
-
/*
* xs_internal.c: access to Xen Store
*
- * Copyright (C) 2006 Red Hat, Inc.
+ * Copyright (C) 2006, 2009 Red Hat, Inc.
*
* See COPYING.LIB for the License of this software
*
#include "xs_internal.h"
#include "xen_internal.h"
+#define VIR_FROM_THIS VIR_FROM_XEN
+
#ifndef PROXY
static char *xenStoreDomainGetOSType(virDomainPtr domain);
static void xenStoreWatchEvent(int watch, int fd, int events, void *data);
retry:
new_domain_cnt = xenStoreNumOfDomains(conn);
if( VIR_ALLOC_N(new_domids,new_domain_cnt) < 0 ) {
- virXenStoreError(NULL, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate domids"));
+ virReportOOMError(NULL);
return -1;
}
nread = xenStoreDoListDomains(priv, new_domids, new_domain_cnt);
new_domain_cnt = xenStoreNumOfDomains(conn);
if( VIR_ALLOC_N(new_domids,new_domain_cnt) < 0 ) {
- virXenStoreError(NULL, VIR_ERR_NO_MEMORY,
- "%s", _("failed to allocate domids"));
+ virReportOOMError(NULL);
return -1;
}
nread = xenStoreDoListDomains(priv, new_domids, new_domain_cnt);
projects / thirdparty / libvirt.git / commitdiff
