+Fri Jun 6 12:01:00 BST 2008 Daniel P. Berrange <berrange@redhat.com>
+
+ * src/bridge.c, src/conf.c, src/iptables.c, src/lxc_conf.c,
+ src/lxc_container.c, src/lxc_driver.c, src/openvz_conf.c,
+ src/openvz_driver.c, src/proxy_internal.c, src/remote_internal.c,
+ src/sexpr.c, src/storage_backend.c, src/storage_backend_disk.c,
+ src/storage_backend_fs.c, src/storage_backend_iscsi.c,
+ src/storage_backend_logical.c, src/storage_conf.c,
+ src/storage_driver.c, src/xen_internal.c, src/xen_unified.c,
+ src/xend_internal.c, src/xmlrpc.c: Switch over to use the
+ internal memory allocation APIs.
+
Fri Jun 6 11:41:00 BST 2008 Daniel P. Berrange <berrange@redhat.com>
* qemud/event.c, qemud/mdns.c, qemud/qemud.c, qemud/remote.c:
#include <net/if_arp.h> /* ARPHRD_ETHER */
#include "internal.h"
+#include "memory.h"
#define MAX_BRIDGE_ID 256
return err;
}
- *ctlp = malloc(sizeof(**ctlp));
- if (!*ctlp) {
+ if (VIR_ALLOC(*ctlp) < 0) {
close(fd);
return ENOMEM;
}
close(ctl->fd);
ctl->fd = 0;
- free(ctl);
+ VIR_FREE(ctl);
}
/**
snprintf(delayStr, sizeof(delayStr), "%d", delay);
- if (!(argv = calloc(n + 1, sizeof(*argv))))
+ if (VIR_ALLOC_N(argv, n + 1) < 0)
goto error;
n = 0;
if (argv) {
n = 0;
while (argv[n])
- free(argv[n++]);
- free(argv);
+ VIR_FREE(argv[n++]);
+ VIR_FREE(argv);
}
return retval;
1 + /* brige name */
1; /* value */
- if (!(argv = calloc(n + 1, sizeof(*argv))))
+ if (VIR_ALLOC_N(argv, n + 1) < 0)
goto error;
n = 0;
if (argv) {
n = 0;
while (argv[n])
- free(argv[n++]);
- free(argv);
+ VIR_FREE(argv[n++]);
+ VIR_FREE(argv);
}
return retval;
#include "conf.h"
#include "util.h"
#include "c-ctype.h"
+#include "memory.h"
/************************************************************************
* *
return;
if (val->type == VIR_CONF_STRING &&
val->str != NULL)
- free(val->str);
+ VIR_FREE(val->str);
if (val->type == VIR_CONF_LIST &&
val->list != NULL)
virConfFreeList(val->list);
- free(val);
+ VIR_FREE(val);
}
virConfPtr
{
virConfPtr ret;
- ret = calloc(1, sizeof(*ret));
- if (ret == NULL) {
+ if (VIR_ALLOC(ret) < 0) {
virConfError(NULL, VIR_ERR_NO_MEMORY, _("allocating configuration"), 0);
return(NULL);
}
if ((comm == NULL) && (name == NULL))
return(NULL);
- ret = calloc(1, sizeof(*ret));
- if (ret == NULL) {
+ if (VIR_ALLOC(ret) < 0) {
virConfError(NULL, VIR_ERR_NO_MEMORY, _("allocating configuration"), 0);
return(NULL);
}
NEXT;
SKIP_BLANKS_AND_EOL;
if ((ctxt->cur < ctxt->end) && (CUR != ']')) {
- lst = virConfParseValue(ctxt);
+ if ((lst = virConfParseValue(ctxt)) == NULL)
+ return(NULL);
SKIP_BLANKS_AND_EOL;
}
while ((ctxt->cur < ctxt->end) && (CUR != ']')) {
ctxt->line);
return(NULL);
}
- ret = calloc(1, sizeof(*ret));
- if (ret == NULL) {
+ if (VIR_ALLOC(ret) < 0) {
virConfError(NULL, VIR_ERR_NO_MEMORY, _("allocating configuration"), 0);
- free(str);
+ virConfFreeList(lst);
+ VIR_FREE(str);
return(NULL);
}
ret->type = type;
SKIP_BLANKS;
value = virConfParseValue(ctxt);
if (value == NULL) {
- free(name);
+ VIR_FREE(name);
return(-1);
}
SKIP_BLANKS;
if (comm == NULL) {
virConfError(NULL, VIR_ERR_NO_MEMORY, _("allocating configuration"),
ctxt->line);
- free(name);
+ VIR_FREE(name);
virConfFreeValue(value);
return(-1);
}
}
if (virConfAddEntry(ctxt->conf, name, value, comm) == NULL) {
- free(name);
+ VIR_FREE(name);
virConfFreeValue(value);
- free(comm);
+ VIR_FREE(comm);
return(-1);
}
return(0);
conf = virConfParse(filename, content, len);
- free(content);
+ VIR_FREE(content);
return conf;
}
tmp = conf->entries;
while (tmp) {
virConfEntryPtr next;
- free(tmp->name);
+ VIR_FREE(tmp->name);
virConfFreeValue(tmp->value);
- free(tmp->comment);
+ VIR_FREE(tmp->comment);
next = tmp->next;
- free(tmp);
+ VIR_FREE(tmp);
tmp = next;
}
- free(conf);
+ VIR_FREE(conf);
return(0);
}
}
if (!cur) {
- if (!(cur = malloc(sizeof(*cur)))) {
+ if (VIR_ALLOC(cur) < 0) {
virConfFreeValue(value);
return (-1);
}
cur->comment = NULL;
if (!(cur->name = strdup(setting))) {
virConfFreeValue(value);
- free(cur);
+ VIR_FREE(cur);
return (-1);
}
cur->value = value;
fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR );
if (fd < 0) {
+ char *tmp = virBufferContentAndReset(&buf);
virConfError(NULL, VIR_ERR_WRITE_FAILED, _("failed to open file"), 0);
- free(virBufferContentAndReset(&buf));
+ VIR_FREE(tmp);
return -1;
}
use = virBufferUse(&buf);
content = virBufferContentAndReset(&buf);
ret = safewrite(fd, content, use);
- free(content);
+ VIR_FREE(content);
close(fd);
if (ret != (int)use) {
virConfError(NULL, VIR_ERR_WRITE_FAILED, _("failed to save content"), 0);
if ((int)use >= *len) {
*len = (int)use;
- free(content);
+ VIR_FREE(content);
return -1;
}
memcpy(memory, content, use);
- free(content);
+ VIR_FREE(content);
*len = use;
return use;
}
#include "internal.h"
#include "iptables.h"
#include "util.h"
+#include "memory.h"
#define qemudLog(level, msg...) fprintf(stderr, msg)
snprintf(arg, sizeof(arg), "--custom-rules=ipv4:%s:%s", table, path);
if (!stripLine(content, len, arg)) {
- free(content);
+ VIR_FREE(content);
return;
}
goto write_error;
}
- free(content);
+ VIR_FREE(content);
return;
strerror(errno));
if (f)
fclose(f);
- free(content);
+ VIR_FREE(content);
#undef MAX_FILE_LEN
}
static void
iptRuleFree(iptRule *rule)
{
- free(rule->rule);
+ VIR_FREE(rule->rule);
rule->rule = NULL;
if (rule->argv) {
int i = 0;
while (rule->argv[i])
- free(rule->argv[i++]);
- free(rule->argv);
+ VIR_FREE(rule->argv[i++]);
+ VIR_FREE(rule->argv);
rule->argv = NULL;
}
}
char **argv,
int command_idx)
{
- iptRule *r;
-
- if (!(r = realloc(rules->rules, sizeof(*r) * (rules->nrules+1)))) {
+ if (VIR_REALLOC_N(rules->rules, rules->nrules+1) < 0) {
int i = 0;
while (argv[i])
- free(argv[i++]);
- free(argv);
+ VIR_FREE(argv[i++]);
+ VIR_FREE(argv);
return ENOMEM;
}
- rules->rules = r;
-
rules->rules[rules->nrules].rule = rule;
rules->rules[rules->nrules].argv = argv;
rules->rules[rules->nrules].command_idx = command_idx;
{
int i;
- if (rules->table) {
- free(rules->table);
- rules->table = NULL;
- }
-
- if (rules->chain) {
- free(rules->chain);
- rules->chain = NULL;
- }
+ if (rules->table)
+ VIR_FREE(rules->table);
+ if (rules->chain)
+ VIR_FREE(rules->chain);
if (rules->rules) {
for (i = 0; i < rules->nrules; i++)
iptRuleFree(&rules->rules[i]);
- free(rules->rules);
- rules->rules = NULL;
+ VIR_FREE(rules->rules);
rules->nrules = 0;
}
rules->path[0] = '\0';
#endif /* ENABLE_IPTABLES_LOKKIT */
- free(rules);
+ VIR_FREE(rules);
}
static iptRules *
{
iptRules *rules;
- if (!(rules = calloc(1, sizeof (*rules))))
+ if (VIR_ALLOC(rules) < 0)
return NULL;
if (!(rules->table = strdup(table)))
for (len = 1, i = 0; argv[i]; i++)
len += strlen(argv[i]) + 1;
- if (!(p = ret = (char *)malloc(len)))
+ if (VIR_ALLOC_N(ret, len) < 0)
return NULL;
+ p = ret;
for (i = 0; argv[i]; i++) {
if (i != 0)
va_end(args);
- if (!(argv = calloc(n + 1, sizeof(*argv))))
+ if (VIR_ALLOC_N(argv, n + 1) < 0)
goto error;
n = 0;
goto error;
if (action == REMOVE) {
- free(argv[command_idx]);
+ VIR_FREE(argv[command_idx]);
if (!(argv[command_idx] = strdup("--delete")))
goto error;
}
}
error:
- free(rule);
+ VIR_FREE(rule);
if (argv) {
n = 0;
while (argv[n])
- free(argv[n++]);
- free(argv);
+ VIR_FREE(argv[n++]);
+ VIR_FREE(argv);
}
return retval;
{
iptablesContext *ctx;
- if (!(ctx = calloc(1, sizeof (*ctx))))
+ if (VIR_ALLOC(ctx) < 0)
return NULL;
if (!(ctx->input_filter = iptRulesNew("filter", "INPUT")))
iptRulesFree(ctx->forward_filter);
if (ctx->nat_postrouting)
iptRulesFree(ctx->nat_postrouting);
- free(ctx);
+ VIR_FREE(ctx);
}
/**
#include "util.h"
#include "uuid.h"
#include "xml.h"
-
+#include "memory.h"
#include "lxc_conf.h"
/* debug macros */
if (virUUIDParse(res, uuid) < 0) {
lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
_("invalid uuid element"));
- free(res);
+ VIR_FREE(res);
return(-1);
}
- free(res);
+ VIR_FREE(res);
}
return(0);
}
res = virXPathNodeSet("/domain/devices/filesystem", contextPtr, &list);
if (res > 0) {
for (i = 0; i < res; ++i) {
- mountObj = calloc(1, sizeof(lxc_mount_t));
- if (NULL == mountObj) {
+ if (VIR_ALLOC(mountObj) < 0) {
lxcError(conn, NULL, VIR_ERR_NO_MEMORY, "mount");
goto parse_complete;
}
rc = lxcParseMountXML(conn, list[i], mountObj);
if (0 > rc) {
- free(mountObj);
+ VIR_FREE(mountObj);
goto parse_complete;
}
}
prevObj = mountObj;
}
- free(list);
+ VIR_FREE(list);
}
rc = nmounts;
if (strlen(res) >= PATH_MAX - 1) {
lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
_("init string too long"));
- free(res);
+ VIR_FREE(res);
return(-1);
}
xmlChar *xmlProp = NULL;
lxc_vm_def_t *containerDef;
- if (!(containerDef = calloc(1, sizeof(*containerDef)))) {
+ if (VIR_ALLOC(containerDef) < 0) {
lxcError(conn, NULL, VIR_ERR_NO_MEMORY, "containerDef");
return NULL;
}
_("invalid domain type"));
goto error;
}
- free(xmlProp);
- xmlProp = NULL;
+ VIR_FREE(xmlProp);
if ((xmlProp = xmlGetProp(rootNodePtr, BAD_CAST "id"))) {
if (0 > virStrToLong_i((char*)xmlProp, NULL, 10, &(containerDef->id))) {
} else {
containerDef->id = -1;
}
- free(xmlProp);
- xmlProp = NULL;
+ VIR_FREE(xmlProp);
if (lxcParseDomainName(conn, &(containerDef->name), contextPtr) < 0) {
goto error;
return containerDef;
error:
- free(xmlProp);
+ VIR_FREE(xmlProp);
xmlXPathFreeContext(contextPtr);
lxcFreeVMDef(containerDef);
return vm;
}
- if (!(vm = calloc(1, sizeof(lxc_vm_t)))) {
+ if (VIR_ALLOC(vm) < 0) {
lxcError(conn, NULL, VIR_ERR_NO_MEMORY, "vm");
return NULL;
}
close(fd);
}
- free(xmlDef);
+ VIR_FREE(xmlDef);
return rc;
}
lxcLoadConfig(driver, file, tempPath, xmlData);
- free(xmlData);
+ VIR_FREE(xmlData);
load_complete:
return rc;
curMount = vmdef->mounts;
while (curMount) {
nextMount = curMount->next;
- free(curMount);
+ VIR_FREE(curMount);
curMount = nextMount;
}
- free(vmdef->name);
- free(vmdef->init);
- free(vmdef->tty);
- free(vmdef);
+ VIR_FREE(vmdef->name);
+ VIR_FREE(vmdef->init);
+ VIR_FREE(vmdef->tty);
+ VIR_FREE(vmdef);
}
void lxcFreeVMs(lxc_vm_t *vms)
void lxcFreeVM(lxc_vm_t *vm)
{
lxcFreeVMDef(vm->def);
- free(vm->containerTty);
- free(vm);
+ VIR_FREE(vm->containerTty);
+ VIR_FREE(vm);
}
lxc_vm_t *lxcFindVMByID(const lxc_driver_t *driver, int id)
#include "lxc_container.h"
#include "lxc_conf.h"
#include "util.h"
+#include "memory.h"
#define DEBUG(fmt,...) VIR_DEBUG(__FILE__, fmt, __VA_ARGS__)
#define DEBUG0(msg) VIR_DEBUG(__FILE__, "%s", msg)
char* execString;
size_t execStringLen = strlen(vmDef->init) + 1 + 5;
- if (NULL == (execString = calloc(execStringLen, sizeof(char)))) {
- lxcError(NULL, NULL, VIR_ERR_NO_MEMORY,
+ if (VIR_ALLOC_N(execString, execStringLen) < 0) {
+ lxcError(NULL, NULL, VIR_ERR_NO_MEMORY,
_("failed to calloc memory for init string: %s"),
strerror(errno));
goto error_out;
#include "driver.h"
#include "internal.h"
#include "util.h"
+#include "memory.h"
/* debug macros */
#define DEBUG(fmt,...) VIR_DEBUG(__FILE__, fmt, __VA_ARGS__)
char *stack;
int childStatus;
- stack = malloc(getpagesize() * 4);
- if(!stack) {
+ if (VIR_ALLOC_N(stack, getpagesize() * 4) < 0) {
DEBUG0("Unable to allocate stack");
rc = -1;
goto check_complete;
waitpid(cpid, &childStatus, 0);
}
- free(stack);
+ VIR_FREE(stack);
check_complete:
return rc;
cleanup:
for (i = 0 ; i < numDoms ; i++) {
- free(names[i]);
+ VIR_FREE(names[i]);
}
return -1;
int rc = -1;
int flags;
int stacksize = getpagesize() * 4;
- void *stack, *stacktop;
+ char *stack, *stacktop;
/* allocate a stack for the container */
- stack = malloc(stacksize);
- if (!stack) {
+ if (VIR_ALLOC_N(stack, stacksize) < 0) {
lxcError(conn, NULL, VIR_ERR_NO_MEMORY,
_("unable to allocate container stack"));
goto error_exit;
}
- stacktop = (char*)stack + stacksize;
+ stacktop = stack + stacksize;
flags = CLONE_NEWPID|CLONE_NEWNS|CLONE_NEWUTS|CLONE_NEWUSER|CLONE_NEWIPC|SIGCHLD;
goto cleanup;
}
- *ttyName = malloc(sizeof(char) * (strlen(tempTtyName) + 1));
- if (NULL == ttyName) {
+ if (VIR_ALLOC_N(*ttyName, strlen(tempTtyName) + 1) < 0) {
lxcError(conn, NULL, VIR_ERR_NO_MEMORY,
_("unable to allocate container name string"));
goto cleanup;
return -1;
}
- lxc_driver = calloc(1, sizeof(lxc_driver_t));
- if (NULL == lxc_driver) {
+ if (VIR_ALLOC(lxc_driver) < 0) {
return -1;
}
static void lxcFreeDriver(lxc_driver_t *driver)
{
- free(driver->configDir);
- free(driver->stateDir);
- free(driver);
+ VIR_FREE(driver->configDir);
+ VIR_FREE(driver->stateDir);
+ VIR_FREE(driver);
}
static int lxcShutdown(void)
#endif
-/* Return 1 if an array of N objects, each of size S, cannot exist due
- to size arithmetic overflow. S must be positive and N must be
- nonnegative. This is a macro, not an inline function, so that it
- works correctly even when SIZE_MAX < N.
-
- By gnulib convention, SIZE_MAX represents overflow in size
- calculations, so the conservative dividend to use here is
- SIZE_MAX - 1, since SIZE_MAX might represent an overflowed value.
- However, malloc (SIZE_MAX) fails on all known hosts where
- sizeof (ptrdiff_t) <= sizeof (size_t), so do not bother to test for
- exactly-SIZE_MAX allocations on such hosts; this avoids a test and
- branch when S is known to be 1. */
-# define xalloc_oversized(n, s) \
- ((size_t) (sizeof (ptrdiff_t) <= sizeof (size_t) ? -1 : -2) / (s) < (n))
-
-
/**
* virAlloc:
* @ptrptr: pointer to pointer for address of allocated memory
#include "internal.h"
+/* Return 1 if an array of N objects, each of size S, cannot exist due
+ to size arithmetic overflow. S must be positive and N must be
+ nonnegative. This is a macro, not an inline function, so that it
+ works correctly even when SIZE_MAX < N.
+
+ By gnulib convention, SIZE_MAX represents overflow in size
+ calculations, so the conservative dividend to use here is
+ SIZE_MAX - 1, since SIZE_MAX might represent an overflowed value.
+ However, malloc (SIZE_MAX) fails on all known hosts where
+ sizeof (ptrdiff_t) <= sizeof (size_t), so do not bother to test for
+ exactly-SIZE_MAX allocations on such hosts; this avoids a test and
+ branch when S is known to be 1. */
+#ifndef xalloc_oversized
+# define xalloc_oversized(n, s) \
+ ((size_t) (sizeof (ptrdiff_t) <= sizeof (size_t) ? -1 : -2) / (s) < (n))
+#endif
+
+
+
/* Don't call these directly - use the macros below */
int __virAlloc(void *ptrptr, size_t size) ATTRIBUTE_RETURN_CHECK;
int __virAllocN(void *ptrptr, size_t size, size_t count) ATTRIBUTE_RETURN_CHECK;
#include "openvz_conf.h"
#include "uuid.h"
#include "buf.h"
+#include "memory.h"
#include <string.h>
struct ovz_quota *prev = quota;
quota = quota->next;
- free(prev);
+ VIR_FREE(prev);
}
while (ip) {
struct ovz_ip *prev = ip;
ip = ip->next;
- free(prev);
+ VIR_FREE(prev);
}
while (ns) {
struct ovz_ns *prev = ns;
ns = ns->next;
- free(prev);
+ VIR_FREE(prev);
}
- free(def);
- def = NULL;
+ VIR_FREE(def);
}
}
}
if (vms) {
openvzFreeVMDef(vm->vmdef);
- free(vm);
- vm = NULL;
+ VIR_FREE(vm);
}
}
if (driver->vms)
for(next = driver->vms->next; driver->vms; driver->vms = next)
openvzFreeVM(driver, driver->vms, 0);
- free(driver);
- driver = NULL;
+ VIR_FREE(driver);
}
struct openvz_vm *
return vm;
}
- if (!(vm = calloc(1, sizeof(*vm)))) {
+ if (VIR_ALLOC(vm) < 0) {
openvzFreeVMDef(def);
error(conn, VIR_ERR_NO_MEMORY, "vm");
return NULL;
struct ovz_ip *ovzIp;
struct ovz_ns *ovzNs;
- if (!(def = calloc(1, sizeof(*def)))) {
+ if (VIR_ALLOC(def) < 0) {
error(conn, VIR_ERR_NO_MEMORY, "xmlXPathContext");
return NULL;
}
error(conn, VIR_ERR_INTERNAL_ERROR, _("invalid domain type attribute"));
goto bail_out;
}
- free(prop);
- prop = NULL;
+ VIR_FREE(prop);
/* Extract domain name */
obj = xmlXPathEval(BAD_CAST "string(/domain/name[1])", ctxt);
error(conn, VIR_ERR_INTERNAL_ERROR, errorMessage);
goto bail_out;
}
- if (!(ovzIp = calloc(1, sizeof(*ovzIp)))) {
+ if (VIR_ALLOC(ovzIp) < 0) {
openvzLog(OPENVZ_ERR,
_("Failed to Create Memory for 'ovz_ip' structure"));
goto bail_out;
error(conn, VIR_ERR_INTERNAL_ERROR, errorMessage);
goto bail_out;
}
- if (!(ovzNs = calloc(1, sizeof(*ovzNs)))) {
+ if (VIR_ALLOC(ovzNs) < 0) {
openvzLog(OPENVZ_ERR,
_("Failed to Create Memory for 'ovz_ns' structure"));
goto bail_out;
return def;
bail_out:
- free(prop);
+ VIR_FREE(prop);
xmlXPathFreeObject(obj);
xmlXPathFreeContext(ctxt);
openvzFreeVMDef(def);
}
pnext = &vm;
while(!feof(fp)) {
- *pnext = calloc(1, sizeof(**pnext));
- if(!*pnext) {
+ if (VIR_ALLOC(*pnext) < 0) {
error(conn, VIR_ERR_INTERNAL_ERROR, _("calloc failed"));
goto error;
}
(*pnext)->vpsid = -1;
}
- vmdef = calloc(1, sizeof(*vmdef));
- if(!vmdef) {
+ if (VIR_ALLOC(vmdef) < 0) {
error(conn, VIR_ERR_INTERNAL_ERROR, _("calloc failed"));
goto error;
}
if(ret == -1) {
error(conn, VIR_ERR_INTERNAL_ERROR,
_("UUID in config file malformed"));
- free(vmdef);
+ VIR_FREE(vmdef);
goto error;
}
struct openvz_vm *next;
next = vm->next;
- free(vm->vmdef);
- free(vm);
+ VIR_FREE(vm->vmdef);
+ VIR_FREE(vm);
vm = next;
}
return NULL;
if (conf_dir == NULL)
return -1;
sprintf(conf_file, "%s/%d.conf", conf_dir, vpsid);
- free(conf_dir);
+ VIR_FREE(conf_dir);
fd = open(conf_file, O_RDWR);
if(fd == -1)
if (conf_dir == NULL)
return -1;
sprintf(conf_file, "%s/%d.conf", conf_dir, vpsid);
- free(conf_dir);
+ VIR_FREE(conf_dir);
if (openvzGetVPSUUID(vpsid, uuidstr))
return -1;
dp = opendir(conf_dir);
if(dp == NULL) {
- free(conf_dir);
+ VIR_FREE(conf_dir);
return 0;
}
openvzSetUUID(vpsid);
}
closedir(dp);
- free(conf_dir);
+ VIR_FREE(conf_dir);
return 0;
}
#include <stdio.h>
#include <sys/wait.h>
-#include "libvirt/virterror.h"
-
+#include "internal.h"
#include "openvz_driver.h"
#include "event.h"
#include "buf.h"
#include "proxy_internal.h"
#include "util.h"
#include "xen_unified.h"
+#include "memory.h"
#define STANDALONE
}
xmllen = ans.len - sizeof (virProxyPacket);
- xml = malloc (xmllen+1);
- if (!xml) {
+ if (VIR_ALLOC_N(xml, xmllen+1) < 0) {
virProxyError (conn, VIR_ERR_NO_MEMORY, __FUNCTION__);
return NULL;
}
return (NULL);
}
xmllen = ans.len - sizeof(virProxyPacket);
- if (!(xml = malloc(xmllen+1))) {
+ if (VIR_ALLOC_N(xml, xmllen+1) < 0) {
virProxyError(domain->conn, VIR_ERR_NO_MEMORY, __FUNCTION__);
return NULL;
}
return (NULL);
}
oslen = ans.len - sizeof(virProxyPacket);
- if (!(ostype = malloc(oslen+1))) {
+ if (VIR_ALLOC_N(ostype, oslen+1) < 0) {
virProxyError(domain->conn, VIR_ERR_NO_MEMORY, __FUNCTION__);
return NULL;
}
#include "qparams.h"
#include "remote_internal.h"
#include "remote_protocol.h"
+#include "memory.h"
#define DEBUG(fmt,...) VIR_DEBUG(__FILE__, fmt,__VA_ARGS__)
#define DEBUG0(msg) VIR_DEBUG(__FILE__, "%s", msg)
// Generate the final command argv[] array.
// ssh -p $port [-l $username] $hostname $netcat -U $sockname [NULL]
- cmd_argv = malloc (nr_args * sizeof (*cmd_argv));
- if (cmd_argv == NULL) {
+ if (VIR_ALLOC_N(cmd_argv, nr_args) < 0) {
error (conn, VIR_ERR_SYSTEM_ERROR, strerror (errno));
goto failed;
}
// Run the external process.
if (!cmd_argv) {
- cmd_argv = malloc (2 * sizeof (*cmd_argv));
- if (cmd_argv == NULL) {
+ if (VIR_ALLOC_N(cmd_argv, 2) < 0) {
error (conn, VIR_ERR_SYSTEM_ERROR, strerror (errno));
goto failed;
}
if (inside_daemon)
return VIR_DRV_OPEN_DECLINED;
- priv = calloc (1, sizeof(*priv));
- if (!priv) {
+ if (VIR_ALLOC(priv) < 0) {
error (conn, VIR_ERR_NO_MEMORY, _("struct private_data"));
return VIR_DRV_OPEN_ERROR;
}
ret = doRemoteOpen(conn, priv, uri, auth, rflags);
if (ret != VIR_DRV_OPEN_SUCCESS) {
conn->privateData = NULL;
- free(priv);
+ VIR_FREE(priv);
} else {
priv->magic = MAGIC;
conn->privateData = priv;
/* Serialise the scheduler parameters. */
args.params.params_len = nparams;
- args.params.params_val = malloc (sizeof (*args.params.params_val)
- * nparams);
- if (args.params.params_val == NULL) {
+ if (VIR_ALLOC_N(args.params.params_val, nparams) < 0) {
error (domain->conn, VIR_ERR_RPC, _("out of memory allocating array"));
return -1;
}
* use the UNIX transport. This handles Xen driver
* which doesn't have its own impl of the network APIs.
*/
- struct private_data *priv = calloc (1, sizeof(*priv));
+ struct private_data *priv;
int ret, rflags = 0;
- if (!priv) {
+ if (VIR_ALLOC(priv) < 0) {
error (conn, VIR_ERR_NO_MEMORY, _("struct private_data"));
return VIR_DRV_OPEN_ERROR;
}
ret = doRemoteOpen(conn, priv, uri, auth, rflags);
if (ret != VIR_DRV_OPEN_SUCCESS) {
conn->networkPrivateData = NULL;
- free(priv);
+ VIR_FREE(priv);
} else {
priv->magic = MAGIC;
priv->localUses = 1;
priv->localUses--;
if (!priv->localUses) {
ret = doRemoteClose(conn, priv);
- free(priv);
+ VIR_FREE(priv);
conn->networkPrivateData = NULL;
}
}
* use the UNIX transport. This handles Xen driver
* which doesn't have its own impl of the network APIs.
*/
- struct private_data *priv = calloc (1, sizeof(struct private_data));
+ struct private_data *priv;
int ret, rflags = 0;
- if (!priv) {
+ if (VIR_ALLOC(priv) < 0) {
error (NULL, VIR_ERR_NO_MEMORY, _("struct private_data"));
return VIR_DRV_OPEN_ERROR;
}
ret = doRemoteOpen(conn, priv, uri, auth, rflags);
if (ret != VIR_DRV_OPEN_SUCCESS) {
conn->storagePrivateData = NULL;
- free(priv);
+ VIR_FREE(priv);
} else {
priv->magic = MAGIC;
priv->localUses = 1;
priv->localUses--;
if (!priv->localUses) {
ret = doRemoteClose(conn, priv);
- free(priv);
+ VIR_FREE(priv);
conn->storagePrivateData = NULL;
}
}
mech = authtype + 5;
if (remoteAuthSASL(conn, priv, in_open, auth, mech) < 0) {
- free(ret.types.types_val);
+ VIR_FREE(ret.types.types_val);
return -1;
}
break;
#if HAVE_POLKIT
case REMOTE_AUTH_POLKIT:
if (remoteAuthPolkit(conn, priv, in_open, auth) < 0) {
- free(ret.types.types_val);
+ VIR_FREE(ret.types.types_val);
return -1;
}
break;
NULL, NULL, NULL, 0, 0,
_("unsupported authentication type %d"),
ret.types.types_val[0]);
- free(ret.types.types_val);
+ VIR_FREE(ret.types.types_val);
return -1;
}
- free(ret.types.types_val);
+ VIR_FREE(ret.types.types_val);
return 0;
}
return NULL;
}
- addr = malloc(strlen(host) + 1 + strlen(port) + 1);
- if (!addr) {
+ 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,
*/
static sasl_callback_t *remoteAuthMakeCallbacks(int *credtype, int ncredtype)
{
- sasl_callback_t *cbs = calloc(ncredtype+1, sizeof (*cbs));
+ sasl_callback_t *cbs;
int i, n;
- if (!cbs) {
+ if (VIR_ALLOC_N(cbs, ncredtype+1) < 0) {
return NULL;
}
for (ninteract = 0 ; interact[ninteract].id != 0 ; ninteract++)
; /* empty */
- *cred = calloc(ninteract, sizeof(*cred));
- if (!*cred)
+ if (VIR_ALLOC_N(*cred, ninteract) < 0)
return -1;
for (ninteract = 0 ; interact[ninteract].id != 0 ; ninteract++) {
(*cred)[ninteract].type = remoteAuthCredSASL2Vir(interact[ninteract].id);
if (!(*cred)[ninteract].type) {
- free(*cred);
+ VIR_FREE(*cred);
return -1;
}
if (interact[ninteract].challenge)
{
int i;
for (i = 0 ; i < ncred ; i++)
- free(cred[i].result);
- free(cred);
+ VIR_FREE(cred[i].result);
+ VIR_FREE(cred);
}
NULL, NULL, NULL, 0, 0,
_("SASL mechanism %s not supported by server"),
wantmech);
- free(iret.mechlist);
+ VIR_FREE(iret.mechlist);
goto cleanup;
}
mechlist = wantmech;
VIR_ERR_AUTH_FAILED, VIR_ERR_ERROR, NULL, NULL, NULL, 0, 0,
_("Failed to start SASL negotiation: %d (%s)"),
err, sasl_errdetail(saslconn));
- free(iret.mechlist);
+ VIR_FREE(iret.mechlist);
goto cleanup;
}
VIR_ERR_AUTH_FAILED, VIR_ERR_ERROR,
NULL, NULL, NULL, 0, 0,
"%s", _("Failed to make auth credentials"));
- free(iret.mechlist);
+ VIR_FREE(iret.mechlist);
goto cleanup;
}
/* Run the authentication callback */
0, 0, "%s", msg);
goto cleanup;
}
- free(iret.mechlist);
+ VIR_FREE(iret.mechlist);
if (clientoutlen > REMOTE_AUTH_SASL_DATA_MAX) {
__virRaiseError (in_open ? NULL : conn, NULL, NULL, VIR_FROM_REMOTE,
}
if (serverin) {
- free(serverin);
- serverin = NULL;
+ VIR_FREE(serverin);
}
DEBUG("Client step result %d. Data %d bytes %p", err, clientoutlen, clientout);
/* This server call shows complete, and earlier client step was OK */
if (complete && err == SASL_OK) {
- free(serverin);
+ VIR_FREE(serverin);
break;
}
}
ret = 0;
cleanup:
- free(localAddr);
- free(remoteAddr);
- free(serverin);
+ VIR_FREE(localAddr);
+ VIR_FREE(remoteAddr);
+ VIR_FREE(serverin);
- free(saslcb);
+ VIR_FREE(saslcb);
remoteAuthFreeCredentials(cred, ncred);
if (ret != 0 && saslconn)
sasl_dispose(&saslconn);
#include "internal.h"
#include "sexpr.h"
#include "util.h"
+#include "memory.h"
/**
* virSexprError:
{
struct sexpr *ret;
- ret = (struct sexpr *) malloc(sizeof(*ret));
- if (ret == NULL) {
+ if (VIR_ALLOC(ret) < 0) {
virSexprError(VIR_ERR_NO_MEMORY, _("failed to allocate a node"));
return (NULL);
}
sexpr_free(sexpr->u.s.cdr);
break;
case SEXPR_VALUE:
- free(sexpr->u.value);
+ VIR_FREE(sexpr->u.value);
break;
case SEXPR_NIL:
break;
}
- free(sexpr);
+ VIR_FREE(sexpr);
errno = serrno;
}
*
* Internal operation appending a value at the end of an existing list
*/
-static void
+static int
append(struct sexpr *lst, const struct sexpr *value)
{
+ struct sexpr *nil = sexpr_nil();
+
+ if (nil == NULL)
+ return -1;
+
while (lst->kind != SEXPR_NIL) {
lst = lst->u.s.cdr;
}
lst->kind = SEXPR_CONS;
lst->u.s.car = (struct sexpr *) value;
- lst->u.s.cdr = sexpr_nil();
+ lst->u.s.cdr = nil;
+
+ return 0;
}
/**
return (NULL);
if (value == NULL)
return (lst);
- append(lst, value);
+ if (append(lst, value) < 0)
+ return (NULL);
return (lst);
}
tmp = _string2sexpr(ptr, &tmp_len);
if (tmp == NULL)
- return NULL;
- append(ret, tmp);
+ goto error;
+ if (append(ret, tmp) < 0) {
+ sexpr_free(tmp);
+ goto error;
+ }
#if 0
if (0) {
char buf[4096];
if (ret->u.value == NULL) {
virSexprError(VIR_ERR_NO_MEMORY,
_("failed to copy a string"));
+ goto error;
}
if (*ptr == '\'')
if (ret->u.value == NULL) {
virSexprError(VIR_ERR_NO_MEMORY,
_("failed to copy a string"));
+ goto error;
}
}
#endif
#include "util.h"
+#include "memory.h"
#include "storage_backend.h"
#include "storage_backend_fs.h"
vol->target.perms.uid = sb.st_uid;
vol->target.perms.gid = sb.st_gid;
- free(vol->target.perms.label);
- vol->target.perms.label = NULL;
+ VIR_FREE(vol->target.perms.label);
#if HAVE_SELINUX
if (fgetfilecon(fd, &filecon) == -1) {
if (dent->d_name[0] == '.')
continue;
- stablepath = malloc(strlen(pool->def->target.path) +
- 1 + strlen(dent->d_name) + 1);
- if (stablepath == NULL) {
+ if (VIR_ALLOC_N(stablepath, strlen(pool->def->target.path) +
+ 1 + strlen(dent->d_name) + 1) < 0) {
virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("path"));
closedir(dh);
return NULL;
return stablepath;
}
- free(stablepath);
+ VIR_FREE(stablepath);
}
closedir(dh);
char **groups;
/* Compile all regular expressions */
- if ((reg = calloc(nregex, sizeof(*reg))) == NULL) {
+ if (VIR_ALLOC_N(reg, nregex) < 0) {
virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("regex"));
return -1;
}
_("Failed to compile regex %s"), error);
for (j = 0 ; j <= i ; j++)
regfree(®[j]);
- free(reg);
+ VIR_FREE(reg);
return -1;
}
}
/* Storage for matched variables */
- if ((groups = calloc(totgroups, sizeof(*groups))) == NULL) {
+ if (VIR_ALLOC_N(groups, totgroups) < 0) {
virStorageReportError(conn, VIR_ERR_NO_MEMORY,
"%s", _("regex groups"));
goto cleanup;
}
- if ((vars = calloc(maxvars+1, sizeof(*vars))) == NULL) {
+ if (VIR_ALLOC_N(vars, maxvars+1) < 0) {
virStorageReportError(conn, VIR_ERR_NO_MEMORY,
"%s", _("regex groups"));
goto cleanup;
/* Release matches & restart to matching the first regex */
for (j = 0 ; j < totgroups ; j++) {
- free(groups[j]);
+ VIR_FREE(groups[j]);
groups[j] = NULL;
}
maxReg = 0;
cleanup:
if (groups) {
for (j = 0 ; j < totgroups ; j++)
- free(groups[j]);
- free(groups);
+ VIR_FREE(groups[j]);
+ VIR_FREE(groups);
}
- free(vars);
+ VIR_FREE(vars);
for (i = 0 ; i < nregex ; i++)
regfree(®[i]);
- free(reg);
+ VIR_FREE(reg);
if (list)
fclose(list);
if (n_columns == 0)
return -1;
- if (n_columns > SIZE_MAX / sizeof *v
- || (v = malloc (n_columns * sizeof *v)) == NULL) {
+ if (VIR_ALLOC_N(v, n_columns) < 0) {
virStorageReportError(conn, VIR_ERR_NO_MEMORY,
"%s", _("n_columns too large"));
return -1;
#include "internal.h"
#include "storage_backend_disk.h"
#include "util.h"
+#include "memory.h"
enum {
VIR_STORAGE_POOL_DISK_DOS = 0,
char *tmp, *devpath;
if (vol == NULL) {
- if ((vol = calloc(1, sizeof(virStorageVolDef))) == NULL) {
+ if (VIR_ALLOC(vol) < 0) {
virStorageReportError(conn, VIR_ERR_NO_MEMORY, _("volume"));
return -1;
}
return -1;
if (devpath != vol->target.path)
- free(devpath);
- devpath = NULL;
+ VIR_FREE(devpath);
}
if (vol->key == NULL) {
}
if (vol->source.extents == NULL) {
- if ((vol->source.extents =
- calloc(1, sizeof(*(vol->source.extents)))) == NULL) {
+ if (VIR_ALLOC(vol->source.extents) < 0) {
virStorageReportError(conn, VIR_ERR_NO_MEMORY,
_("volume extents"));
return -1;
virStoragePoolObjPtr pool,
char **const groups)
{
- virStoragePoolSourceDeviceExtentPtr tmp;
virStoragePoolSourceDevicePtr dev = &pool->def->source.devices[0];
- if ((tmp = realloc(dev->freeExtents,
- sizeof(*tmp) * (dev->nfreeExtent+1))) == NULL)
+ if (VIR_REALLOC_N(dev->freeExtents,
+ dev->nfreeExtent + 1) < 0)
return -1;
- dev->freeExtents = tmp;
memset(dev->freeExtents +
- dev->nfreeExtent, 0, sizeof(*tmp));
+ dev->nfreeExtent, 0,
+ sizeof(dev->freeExtents[0]));
if (virStrToLong_ull(groups[3], NULL, 10,
&dev->freeExtents[dev->nfreeExtent].start) < 0)
virStorageBackendDiskRefreshPool(virConnectPtr conn,
virStoragePoolObjPtr pool)
{
- free(pool->def->source.devices[0].freeExtents);
+ VIR_FREE(pool->def->source.devices[0].freeExtents);
pool->def->source.devices[0].nfreeExtent = 0;
- pool->def->source.devices[0].freeExtents = NULL;
return virStorageBackendDiskReadPartitions(conn, pool, NULL);
}
return -1;
/* Blow away free extent info, as we're about to re-populate it */
- free(pool->def->source.devices[0].freeExtents);
+ VIR_FREE(pool->def->source.devices[0].freeExtents);
pool->def->source.devices[0].nfreeExtent = 0;
- pool->def->source.devices[0].freeExtents = NULL;
/* Fetch actual extent info */
if (virStorageBackendDiskReadPartitions(conn, pool, vol) < 0)
#include "storage_backend_fs.h"
#include "storage_conf.h"
#include "util.h"
-#include "config.h"
-
+#include "memory.h"
enum {
VIR_STORAGE_POOL_FS_AUTO = 0,
}
if (pool->def->type == VIR_STORAGE_POOL_NETFS) {
- src = malloc(strlen(pool->def->source.host.name) +
- 1 + strlen(pool->def->source.dir) + 1);
+ if (VIR_ALLOC_N(src, strlen(pool->def->source.host.name) +
+ 1 + strlen(pool->def->source.dir) + 1) < 0) {
+ virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("source"));
+ return -1;
+ }
strcpy(src, pool->def->source.host.name);
strcat(src, ":");
strcat(src, pool->def->source.dir);
} else {
- src = strdup(pool->def->source.devices[0].path);
- }
- if (src == NULL) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("source"));
- return -1;
+ if ((src = strdup(pool->def->source.devices[0].path)) == NULL) {
+ virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("source"));
+ return -1;
+ }
}
mntargv[3] = src;
if (virRun(conn, (char**)mntargv, NULL) < 0) {
- free(src);
+ VIR_FREE(src);
return -1;
}
- free(src);
+ VIR_FREE(src);
return 0;
}
virStorageVolDefPtr vol;
int ret;
- vol = calloc(1, sizeof(virStorageVolDef));
- if (vol == NULL) {
+ if (VIR_ALLOC(vol) < 0) {
virStorageReportError(conn, VIR_ERR_NO_MEMORY,
"%s", _("volume"));
goto cleanup;
vol->name = strdup(ent->d_name);
if (vol->name == NULL) {
- free(vol);
+ VIR_FREE(vol);
virStorageReportError(conn, VIR_ERR_NO_MEMORY,
"%s", _("volume name"));
goto cleanup;
}
vol->target.format = VIR_STORAGE_VOL_RAW; /* Real value is filled in during probe */
- vol->target.path = malloc(strlen(pool->def->target.path) +
- 1 + strlen(vol->name) + 1);
- if (vol->target.path == NULL) {
- free(vol->target.path);
- free(vol);
+ if (VIR_ALLOC_N(vol->target.path, strlen(pool->def->target.path) +
+ 1 + strlen(vol->name) + 1) < 0) {
+ VIR_FREE(vol->target.path);
+ VIR_FREE(vol);
virStorageReportError(conn, VIR_ERR_NO_MEMORY,
"%s", _("volume name"));
goto cleanup;
strcat(vol->target.path, "/");
strcat(vol->target.path, vol->name);
if ((vol->key = strdup(vol->target.path)) == NULL) {
- free(vol->name);
- free(vol->target.path);
- free(vol);
+ VIR_FREE(vol->name);
+ VIR_FREE(vol->target.path);
+ VIR_FREE(vol);
virStorageReportError(conn, VIR_ERR_NO_MEMORY,
"%s", _("volume key"));
goto cleanup;
}
if ((ret = virStorageBackendProbeFile(conn, vol) < 0)) {
- free(vol->key);
- free(vol->name);
- free(vol->target.path);
- free(vol);
+ VIR_FREE(vol->key);
+ VIR_FREE(vol->name);
+ VIR_FREE(vol->target.path);
+ VIR_FREE(vol);
if (ret == -1)
goto cleanup;
else
{
int fd;
- vol->target.path = malloc(strlen(pool->def->target.path) +
- 1 + strlen(vol->name) + 1);
- if (vol->target.path == NULL) {
+ 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", _("target"));
return -1;
}
#include "internal.h"
#include "storage_backend_iscsi.h"
#include "util.h"
+#include "memory.h"
static int
virStorageBackendISCSITargetIP(virConnectPtr conn,
snprintf(lunid, sizeof(lunid)-1, "lun-%s", groups[3]);
- if ((vol = calloc(1, sizeof(virStorageVolDef))) == NULL) {
+ if (VIR_ALLOC(vol) < 0) {
virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("volume"));
goto cleanup;
}
goto cleanup;
}
- if ((devpath = malloc(5 + strlen(dev) + 1)) == NULL) {
+ if (VIR_ALLOC_N(devpath, 5 + strlen(dev) + 1) < 0) {
virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("devpath"));
goto cleanup;
}
strcpy(devpath, "/dev/");
strcat(devpath, dev);
- free(dev);
- dev = NULL;
+ VIR_FREE(dev);
/* It can take a little while between logging into the ISCSI
* server and udev creating the /dev nodes, so if we get ENOENT
* we must retry a few times - they should eventually appear.
goto cleanup;
if (devpath != vol->target.path)
- free(devpath);
- devpath = NULL;
+ VIR_FREE(devpath);
if (virStorageBackendUpdateVolInfoFD(conn, vol, fd, 1) < 0)
goto cleanup;
cleanup:
if (fd != -1) close(fd);
- free(devpath);
+ VIR_FREE(devpath);
virStorageVolDefFree(vol);
- free(dev);
+ VIR_FREE(dev);
return -1;
}
ipaddr, sizeof(ipaddr)) < 0)
return NULL;
- portal = malloc(strlen(ipaddr) + 1 + 4 + 2 + 1);
- if (portal == NULL) {
+ if (VIR_ALLOC_N(portal, strlen(ipaddr) + 1 + 4 + 2 + 1) < 0) {
virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("portal"));
return NULL;
}
if ((portal = virStorageBackendISCSIPortal(conn, pool)) == NULL)
return -1;
if (virStorageBackendISCSILogin(conn, pool, portal) < 0) {
- free(portal);
+ VIR_FREE(portal);
return -1;
}
- free(portal);
+ VIR_FREE(portal);
return 0;
}
goto cleanup;
if (virStorageBackendISCSIFindLUNs(conn, pool, session) < 0)
goto cleanup;
- free(session);
+ VIR_FREE(session);
return 0;
cleanup:
- free(session);
+ VIR_FREE(session);
return -1;
}
return -1;
if (virStorageBackendISCSILogout(conn, pool, portal) < 0) {
- free(portal);
+ VIR_FREE(portal);
return -1;
}
- free(portal);
+ VIR_FREE(portal);
return 0;
}
#include "storage_backend_logical.h"
#include "storage_conf.h"
#include "util.h"
-
+#include "memory.h"
#define PV_BLANK_SECTOR_SIZE 512
void *data)
{
virStorageVolDefPtr vol = NULL;
- virStorageVolSourceExtentPtr tmp;
unsigned long long offset, size, length;
/* See if we're only looking for a specific volume */
/* Or a completely new volume */
if (vol == NULL) {
- if ((vol = calloc(1, sizeof(*vol))) == NULL) {
+ if (VIR_ALLOC(vol) < 0) {
virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("volume"));
return -1;
}
}
if (vol->target.path == NULL) {
- if ((vol->target.path = malloc(strlen(pool->def->target.path) +
- 1 + strlen(vol->name) + 1)) == NULL) {
+ 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"));
return -1;
}
/* Finally fill in extents information */
- if ((tmp = realloc(vol->source.extents, sizeof(*tmp)
- * (vol->source.nextent + 1))) == NULL) {
+ if (VIR_REALLOC_N(vol->source.extents,
+ vol->source.nextent + 1) < 0) {
virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("extents"));
return -1;
}
- vol->source.extents = tmp;
if ((vol->source.extents[vol->source.nextent].path =
strdup(groups[2])) == NULL) {
memset(zeros, 0, sizeof(zeros));
/* XXX multiple pvs */
- if ((vgargv = malloc(sizeof(char*) * (1))) == NULL) {
+ if (VIR_ALLOC_N(vgargv, 1) < 0) {
virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("command line"));
return -1;
}
if (virRun(conn, (char**)vgargv, NULL) < 0)
goto cleanup;
- free(vgargv);
+ VIR_FREE(vgargv);
return 0;
cleanup:
- free(vgargv);
+ VIR_FREE(vgargv);
return -1;
}
#include "uuid.h"
#include "buf.h"
#include "util.h"
+#include "memory.h"
#define virStorageLog(msg...) fprintf(stderr, msg)
void
virStorageVolDefFree(virStorageVolDefPtr def) {
int i;
- free(def->name);
- free(def->key);
+ VIR_FREE(def->name);
+ VIR_FREE(def->key);
for (i = 0 ; i < def->source.nextent ; i++) {
- free(def->source.extents[i].path);
+ VIR_FREE(def->source.extents[i].path);
}
- free(def->source.extents);
+ VIR_FREE(def->source.extents);
- free(def->target.path);
- free(def->target.perms.label);
- free(def);
+ VIR_FREE(def->target.path);
+ VIR_FREE(def->target.perms.label);
+ VIR_FREE(def);
}
void
virStoragePoolDefFree(virStoragePoolDefPtr def) {
int i;
- free(def->name);
- free(def->source.host.name);
+ VIR_FREE(def->name);
+ VIR_FREE(def->source.host.name);
for (i = 0 ; i < def->source.ndevice ; i++) {
- free(def->source.devices[i].freeExtents);
- free(def->source.devices[i].path);
+ VIR_FREE(def->source.devices[i].freeExtents);
+ VIR_FREE(def->source.devices[i].path);
}
- free(def->source.devices);
- free(def->source.dir);
+ VIR_FREE(def->source.devices);
+ VIR_FREE(def->source.dir);
if (def->source.authType == VIR_STORAGE_POOL_AUTH_CHAP) {
- free(def->source.auth.chap.login);
- free(def->source.auth.chap.passwd);
+ VIR_FREE(def->source.auth.chap.login);
+ VIR_FREE(def->source.auth.chap.passwd);
}
- free(def->target.path);
- free(def->target.perms.label);
- free(def);
+ VIR_FREE(def->target.path);
+ VIR_FREE(def->target.perms.label);
+ VIR_FREE(def);
}
if (obj->newDef)
virStoragePoolDefFree(obj->newDef);
- free(obj->configFile);
- free(obj->autostartLink);
- free(obj);
+ VIR_FREE(obj->configFile);
+ VIR_FREE(obj->autostartLink);
+ VIR_FREE(obj);
}
void
char *uuid = NULL;
char *authType = NULL;
- if ((ret = calloc(1, sizeof(virStoragePoolDef))) == NULL)
+ if (VIR_ALLOC(ret) < 0) {
+ virStorageReportError(conn, VIR_ERR_NO_MEMORY,
+ "%s", _("cannot allocate storage pool"));
return NULL;
+ }
if (STRNEQ((const char *)root->name, "pool")) {
virStorageReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("malformed uuid element"));
goto cleanup;
}
- free(uuid);
- uuid = NULL;
+ VIR_FREE(uuid);
}
if (options->formatFromString) {
char *format = virXPathString("string(/pool/source/format/@type)", ctxt);
if ((ret->source.format = (options->formatFromString)(conn, format)) < 0) {
- free(format);
+ VIR_FREE(format);
goto cleanup;
}
- free(format);
+ VIR_FREE(format);
}
if (options->flags & VIR_STORAGE_BACKEND_POOL_SOURCE_HOST) {
"%s", _("cannot extract source devices"));
goto cleanup;
}
- if ((ret->source.devices = calloc(nsource, sizeof(*ret->source.devices))) == NULL) {
- free(nodeset);
+ if (VIR_ALLOC_N(ret->source.devices, nsource) < 0) {
+ VIR_FREE(nodeset);
virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("device"));
goto cleanup;
}
for (i = 0 ; i < nsource ; i++) {
xmlChar *path = xmlGetProp(nodeset[i], BAD_CAST "path");
if (path == NULL) {
- free(nodeset);
+ VIR_FREE(nodeset);
virStorageReportError(conn, VIR_ERR_XML_ERROR,
"%s", _("missing source device path"));
goto cleanup;
}
ret->source.devices[i].path = (char *)path;
}
- free(nodeset);
+ VIR_FREE(nodeset);
ret->source.ndevice = nsource;
}
if (options->flags & VIR_STORAGE_BACKEND_POOL_SOURCE_DIR) {
virStorageReportError(conn, VIR_ERR_XML_ERROR,
_("unknown auth type '%s'"),
(const char *)authType);
- free(authType);
- authType = NULL;
+ VIR_FREE(authType);
goto cleanup;
}
- free(authType);
- authType = NULL;
+ VIR_FREE(authType);
}
if (ret->source.authType == VIR_STORAGE_POOL_AUTH_CHAP) {
return ret;
cleanup:
- free(uuid);
+ VIR_FREE(uuid);
xmlFree(type);
virStoragePoolDefFree(ret);
return NULL;
if (options == NULL)
return NULL;
- if ((ret = calloc(1, sizeof(virStorageVolDef))) == NULL)
+ if (VIR_ALLOC(ret) < 0) {
+ virStorageReportError(conn, VIR_ERR_NO_MEMORY,
+ "%s", _("cannot allocate storage vol"));
return NULL;
+ }
if (STRNEQ((const char *)root->name, "volume")) {
virStorageReportError(conn, VIR_ERR_XML_ERROR,
}
if (virStorageSize(conn, unit, capacity, &ret->capacity) < 0)
goto cleanup;
- free(capacity);
- capacity = NULL;
- free(unit);
- unit = NULL;
+ VIR_FREE(capacity);
+ VIR_FREE(unit);
allocation = virXPathString("string(/volume/allocation)", ctxt);
if (allocation) {
unit = virXPathString("string(/volume/allocation/@unit)", ctxt);
if (virStorageSize(conn, unit, allocation, &ret->allocation) < 0)
goto cleanup;
- free(allocation);
- allocation = NULL;
- free(unit);
- unit = NULL;
+ VIR_FREE(allocation);
+ VIR_FREE(unit);
} else {
ret->allocation = ret->capacity;
}
if (options->formatFromString) {
char *format = virXPathString("string(/volume/target/format/@type)", ctxt);
if ((ret->target.format = (options->formatFromString)(conn, format)) < 0) {
- free(format);
+ VIR_FREE(format);
goto cleanup;
}
- free(format);
+ VIR_FREE(format);
}
if (virStorageVolDefParsePerms(conn, ctxt, &ret->target.perms) < 0)
return ret;
cleanup:
- free(allocation);
- free(capacity);
- free(unit);
+ VIR_FREE(allocation);
+ VIR_FREE(capacity);
+ VIR_FREE(unit);
virStorageVolDefFree(ret);
return NULL;
}
virStorageVolDefPtr def) {
virStorageBackendVolOptionsPtr options;
virBuffer buf = VIR_BUFFER_INITIALIZER;
+ char *tmp;
options = virStorageBackendVolOptionsForType(pool->type);
if (options == NULL)
no_memory:
virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("xml"));
cleanup:
- free(virBufferContentAndReset(&buf));
+ tmp = virBufferContentAndReset(&buf);
+ VIR_FREE(tmp);
return NULL;
}
return pool;
}
- if (!(pool = calloc(1, sizeof(virStoragePoolObj)))) {
+ if (VIR_ALLOC(pool) < 0) {
virStorageReportError(conn, VIR_ERR_NO_MEMORY,
"%s", _("pool"));
return NULL;
virStoragePoolObjLoad(driver, entry->d_name, path, xml, autostartLink);
- free(xml);
+ VIR_FREE(xml);
}
closedir(dir);
virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot construct "
"autostart link path"));
- free(pool->configFile);
- pool->configFile = NULL;
+ VIR_FREE(pool->configFile);
return -1;
}
if (!(pool->autostartLink = strdup(path))) {
virStorageReportError(conn, VIR_ERR_NO_MEMORY,
"%s", _("config file"));
- free(pool->configFile);
- pool->configFile = NULL;
+ VIR_FREE(pool->configFile);
return -1;
}
}
if (fd != -1)
close(fd);
- free(xml);
+ VIR_FREE(xml);
return ret;
}
#include "util.h"
#include "storage_driver.h"
#include "storage_conf.h"
-
+#include "memory.h"
#include "storage_backend.h"
#define storageLog(msg...) fprintf(stderr, msg)
char *base = NULL;
char driverConf[PATH_MAX];
- if (!(driverState = calloc(1, sizeof(virStorageDriverState)))) {
+ if (VIR_ALLOC(driverState) < 0)
return -1;
- }
if (!uid) {
if ((base = strdup (SYSCONF_DIR "/libvirt")) == NULL)
#include "buf.h"
#include "capabilities.h"
+#include "memory.h"
#define DEBUG(fmt,...) VIR_DEBUG(__FILE__, fmt, __VA_ARGS__)
#define DEBUG0(msg) VIR_DEBUG(__FILE__, "%s", msg)
#define XEN_GETDOMAININFOLIST_ALLOC(domlist, size) \
(hypervisor_version < 2 ? \
- ((domlist.v0 = malloc(sizeof(*domlist.v0)*(size))) != NULL) : \
+ (VIR_ALLOC_N(domlist.v0, (size)) == 0) : \
(dom_interface_version < 5 ? \
- ((domlist.v2 = malloc(sizeof(*domlist.v2)*(size))) != NULL) : \
- ((domlist.v2d5 = malloc(sizeof(*domlist.v2d5)*(size))) != NULL)))
+ (VIR_ALLOC_N(domlist.v2, (size)) == 0) : \
+ (VIR_ALLOC_N(domlist.v2d5, (size)) == 0)))
-#define XEN_GETDOMAININFOLIST_FREE(domlist) \
- (hypervisor_version < 2 ? \
- free(domlist.v0) : \
- (dom_interface_version < 5 ? \
- free(domlist.v2) : \
- free(domlist.v2d5)))
+#define XEN_GETDOMAININFOLIST_FREE(domlist) \
+ (hypervisor_version < 2 ? \
+ VIR_FREE(domlist.v0) : \
+ (dom_interface_version < 5 ? \
+ VIR_FREE(domlist.v2) : \
+ VIR_FREE(domlist.v2d5)))
#define XEN_GETDOMAININFOLIST_CLEAR(domlist, size) \
(hypervisor_version < 2 ? \
{
char *msg_s;
- msg_s = malloc (strlen (msg) + 10);
- if (msg_s) {
+ if (VIR_ALLOC_N(msg_s, strlen (msg) + 10) == 0) {
strcpy (msg_s, msg);
strcat (msg_s, ": %s");
}
/* The allocated memory to cpumap must be 'sizeof(uint64_t)' byte *
* for Xen, and also nr_cpus must be 'sizeof(uint64_t) * 8' */
if (maplen < 8) {
- new = calloc(1, sizeof(uint64_t));
- if (!new) {
+ if (VIR_ALLOC_N(new, sizeof(uint64_t)) < 0) {
virXenErrorFunc(NULL, VIR_ERR_NO_MEMORY, __FUNCTION__,
"allocating private data", 0);
return (-1);
op.u.setvcpumapd5.cpumap.nr_cpus = nr_cpus;
}
ret = xenHypervisorDoV2Dom(handle, &op);
- free(new);
+ VIR_FREE(new);
if (unlock_pages(cpumap, maplen) < 0) {
virXenError(NULL, VIR_ERR_XEN_CALL, " release", maplen);
*/
hypervisor_version = 2;
- ipt = malloc(sizeof(*ipt));
- if (ipt == NULL){
+ if (VIR_ALLOC(ipt) < 0) {
virXenError(NULL, VIR_ERR_NO_MEMORY, __FUNCTION__, 0);
return(-1);
}
virXenError(NULL, VIR_ERR_XEN_CALL, " ioctl ", IOCTL_PRIVCMD_HYPERCALL);
close(fd);
in_init = 0;
- free(ipt);
+ VIR_FREE(ipt);
return(-1);
done:
close(fd);
in_init = 0;
- free(ipt);
+ VIR_FREE(ipt);
return(0);
}
ret = virGetDomain(conn, name, XEN_GETDOMAININFO_UUID(dominfo));
if (ret)
ret->id = id;
- free(name);
+ VIR_FREE(name);
return ret;
}
ret = virGetDomain(conn, name, uuid);
if (ret)
ret->id = id;
- free(name);
+ VIR_FREE(name);
return ret;
}
#endif
#include "xm_internal.h"
#include "xml.h"
#include "util.h"
+#include "memory.h"
#define DEBUG(fmt,...) VIR_DEBUG(__FILE__, fmt,__VA_ARGS__)
#define DEBUG0(msg) VIR_DEBUG(__FILE__, "%s", msg)
if (xenUnifiedNodeGetInfo(dom->conn, &nodeinfo) < 0)
return(NULL);
- cpulist = calloc(nb_cpu, sizeof(*cpulist));
- if (cpulist == NULL)
+ if (VIR_ALLOC_N(cpulist, nb_cpu) < 0)
goto done;
- cpuinfo = malloc(sizeof(*cpuinfo) * nb_vcpu);
- if (cpuinfo == NULL)
+ if (VIR_ALLOC_N(cpuinfo, nb_vcpu) < 0)
goto done;
cpumaplen = VIR_CPU_MAPLEN(VIR_NODEINFO_MAXCPUS(nodeinfo));
- cpumap = (unsigned char *) calloc(nb_vcpu, cpumaplen);
- if (cpumap == NULL)
+ if (xalloc_oversized(nb_vcpu, cpumaplen) ||
+ VIR_ALLOC_N(cpumap, nb_vcpu * cpumaplen) < 0)
goto done;
if ((ncpus = xenUnifiedDomainGetVcpus(dom, cpuinfo, nb_vcpu,
}
done:
- free(cpulist);
- free(cpumap);
- free(cpuinfo);
+ VIR_FREE(cpulist);
+ VIR_FREE(cpumap);
+ VIR_FREE(cpuinfo);
return(res);
}
return VIR_DRV_OPEN_DECLINED;
/* Allocate per-connection private data. */
- priv = calloc (1, sizeof *priv);
- if (!priv) {
+ if (VIR_ALLOC(priv) < 0) {
xenUnifiedError (NULL, VIR_ERR_NO_MEMORY, "allocating private data");
return VIR_DRV_OPEN_ERROR;
}
DEBUG0("Failed to activate a mandatory sub-driver");
for (i = 0 ; i < XEN_UNIFIED_NR_DRIVERS ; i++)
if (priv->opened[i]) drivers[i]->close(conn);
- free(priv);
+ VIR_FREE(priv);
return VIR_DRV_OPEN_ERROR;
}
char *cpus, *res;
cpus = xenDomainUsedCpus(dom);
res = xenDaemonDomainDumpXML(dom, flags, cpus);
- free(cpus);
+ VIR_FREE(cpus);
return(res);
}
if (priv->opened[XEN_UNIFIED_PROXY_OFFSET])
#include <stdbool.h>
#include <math.h>
#include <stdarg.h>
-#include <malloc.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include "xmlrpc.h"
#include "internal.h"
+#include "memory.h"
#include <libxml/nanohttp.h>
static xmlRpcValuePtr xmlRpcValueNew(xmlRpcValueType type)
{
- xmlRpcValuePtr ret = malloc(sizeof(*ret));
-
- if (!ret)
+ xmlRpcValuePtr ret = NULL;
+ if (VIR_ALLOC(ret) < 0)
xmlRpcError(VIR_ERR_NO_MEMORY, _("allocate value"), sizeof(*ret));
else
ret->kind = type;
if (ret && value)
ret->value.integer = atoi(value);
- free(value);
+ VIR_FREE(value);
return ret;
}
ret->value.boolean = true;
else
ret->value.boolean = false;
- free(value);
+ VIR_FREE(value);
return ret;
}
if (ret && value)
ret->value.real = atof(value);
- free(value);
+ VIR_FREE(value);
return ret;
}
for (cur = xmlFirstElement(node); cur; cur = xmlNextElement(cur))
n_elements += 1;
- elems = malloc(n_elements * sizeof(*elems));
- if (!elems) {
+ if (VIR_ALLOC_N(elems, n_elements) < 0) {
xmlRpcError(VIR_ERR_NO_MEMORY, _("allocate value array"),
n_elements * sizeof(*elems));
- free(ret);
+ VIR_FREE(ret);
return NULL;
}
n_elements = 0;
static xmlRpcValueDictElementPtr xmlRpcValueUnmarshalDictElement(xmlNodePtr node)
{
- xmlRpcValueDictElementPtr ret = malloc(sizeof(*ret));
+ xmlRpcValueDictElementPtr ret;
xmlNodePtr cur;
- if (!ret) {
+ if (VIR_ALLOC(ret) < 0) {
xmlRpcError(VIR_ERR_NO_MEMORY, _("allocate dict"), sizeof(*ret));
return NULL;
}
ret->value = xmlRpcValueUnmarshal(cur);
} else {
xmlRpcError(VIR_ERR_XML_ERROR, _("unexpected dict node"), 0);
- free(ret->name);
+ VIR_FREE(ret->name);
if (ret->value)
xmlRpcValueFree(ret->value);
- free(ret);
+ VIR_FREE(ret);
return NULL;
}
}
case XML_RPC_ARRAY:
for (i = 0; i < value->value.array.n_elements; i++)
xmlRpcValueFree(value->value.array.elements[i]);
- free(value->value.array.elements);
+ VIR_FREE(value->value.array.elements);
break;
case XML_RPC_STRUCT:
next = value->value.dict.root;
while (next) {
cur = next;
next = next->next;
- free(cur->name);
+ VIR_FREE(cur->name);
xmlRpcValueFree(cur->value);
- free(cur);
+ VIR_FREE(cur);
}
break;
case XML_RPC_STRING:
- free(value->value.string);
+ VIR_FREE(value->value.string);
break;
default:
break;
}
- free(value);
+ VIR_FREE(value);
}
void xmlRpcValueMarshal(xmlRpcValuePtr value, virBufferPtr buf, int indent)
}
len = xmlNanoHTTPContentLength(cxt);
- response = malloc(len + 1);
- if (response == NULL) {
+ if (VIR_ALLOC_N(response, len + 1) < 0) {
xmlRpcError(VIR_ERR_NO_MEMORY, _("allocate response"), len);
goto error;
}
ret = xmlNanoHTTPRead(cxt, response, len);
if (ret != len) {
errno = EINVAL;
- free(response);
+ VIR_FREE(response);
response = NULL;
xmlRpcError(VIR_ERR_POST_FAILED, _("read response"), 0);
}
serrno = errno;
if (cxt) {
xmlNanoHTTPClose(cxt);
- free(contentType);
+ VIR_FREE(contentType);
}
errno = serrno;
if (value->value.array.elements[i]->kind == XML_RPC_STRING)
size += strlen(value->value.array.elements[i]->value.string) + 1;
- if (!(ptr = malloc(size))) {
+ if (VIR_ALLOC_N(ptr, size) < 0) {
xmlRpcError(VIR_ERR_NO_MEMORY, _("allocate string array"), size);
return NULL;
}
int i;
*argc = strlen(fmt);
- if (!(argv = malloc(sizeof(*argv) * *argc))) {
+ if (VIR_ALLOC_N(argv, *argc) < 0) {
xmlRpcError(VIR_ERR_NO_MEMORY, _("read response"), sizeof(*argv) * *argc);
return NULL;
}
for (i = 0; i < argc; i++)
xmlRpcValueFree(argv[i]);
- free(argv);
+ VIR_FREE(argv);
}
int xmlRpcCall(xmlRpcContextPtr context, const char *method,
content = virBufferContentAndReset(&buf);
ret = xmlRpcCallRaw(context->uri, content);
- free(content);
+ VIR_FREE(content);
if (!ret)
return -1;
xml = xmlReadDoc((const xmlChar *)ret, "response.xml", NULL,
XML_PARSE_NOENT | XML_PARSE_NONET |
XML_PARSE_NOERROR | XML_PARSE_NOWARNING);
- free(ret);
+ VIR_FREE(ret);
if (xml == NULL) {
errno = EINVAL;
xmlRpcContextPtr xmlRpcContextNew(const char *uri)
{
- xmlRpcContextPtr ret = malloc(sizeof(*ret));
+ xmlRpcContextPtr ret;
- if (ret) {
+ if (VIR_ALLOC(ret) < 0) {
+ xmlRpcError(VIR_ERR_NO_MEMORY, _("allocate new context"), sizeof(*ret));
+ } else {
ret->uri = strdup(uri);
ret->faultMessage = NULL;
- } else
- xmlRpcError(VIR_ERR_NO_MEMORY, _("allocate new context"), sizeof(*ret));
+ }
return ret;
}
void xmlRpcContextFree(xmlRpcContextPtr context)
{
if (context) {
- free(context->uri);
- free(context->faultMessage);
- free(context);
+ VIR_FREE(context->uri);
+ VIR_FREE(context->faultMessage);
+ VIR_FREE(context);
}
}
projects / libvirt.git / commitdiff