External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2024-07-16 22:57:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

Switch over remaining driver code to use memory alloc apis

Browse Source
This commit is contained in:
Daniel P. Berrange 2008-06-06 11:09:57 +00:00
parent d7d21c85e0
commit d789ef5a88
25 changed files with 408 additions and 424 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
ChangeLog
View File

@ -1,3 +1,15 @@
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:

18
src/bridge.c
View File

@ -45,6 +45,7 @@
#include <net/if_arp.h> /* ARPHRD_ETHER */
#include "internal.h"
#include "memory.h"
#define MAX_BRIDGE_ID 256
@ -84,8 +85,7 @@ brInit(brControl **ctlp)
return err;
}
*ctlp = malloc(sizeof(**ctlp));
if (!*ctlp) {
if (VIR_ALLOC(*ctlp) < 0) {
close(fd);
return ENOMEM;
}
@ -110,7 +110,7 @@ brShutdown(brControl *ctl)
close(ctl->fd);
ctl->fd = 0;
free(ctl);
VIR_FREE(ctl);
}
/**
@ -681,7 +681,7 @@ brSetForwardDelay(brControl *ctl ATTRIBUTE_UNUSED,
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;
@ -706,8 +706,8 @@ brSetForwardDelay(brControl *ctl ATTRIBUTE_UNUSED,
if (argv) {
n = 0;
while (argv[n])
free(argv[n++]);
free(argv);
VIR_FREE(argv[n++]);
VIR_FREE(argv);
}
return retval;
@ -738,7 +738,7 @@ brSetEnableSTP(brControl *ctl ATTRIBUTE_UNUSED,
1 + /* brige name */
1; /* value */
if (!(argv = calloc(n + 1, sizeof(*argv))))
if (VIR_ALLOC_N(argv, n + 1) < 0)
goto error;
n = 0;
@ -763,8 +763,8 @@ brSetEnableSTP(brControl *ctl ATTRIBUTE_UNUSED,
if (argv) {
n = 0;
while (argv[n])
free(argv[n++]);
free(argv);
VIR_FREE(argv[n++]);
VIR_FREE(argv);
}
return retval;

51
src/conf.c
View File

@ -23,6 +23,7 @@
#include "conf.h"
#include "util.h"
#include "c-ctype.h"
#include "memory.h"
/************************************************************************
* *
@ -138,11 +139,11 @@ __virConfFreeValue(virConfValuePtr val)
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
@ -150,8 +151,7 @@ __virConfNew(void)
{
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);
}
@ -199,8 +199,7 @@ virConfAddEntry(virConfPtr conf, char *name, virConfValuePtr value, char *comm)
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);
}
@ -441,7 +440,8 @@ virConfParseValue(virConfParserCtxtPtr ctxt)
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 != ']')) {
@ -484,10 +484,10 @@ virConfParseValue(virConfParserCtxtPtr ctxt)
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;
@ -618,7 +618,7 @@ virConfParseStatement(virConfParserCtxtPtr ctxt)
SKIP_BLANKS;
value = virConfParseValue(ctxt);
if (value == NULL) {
free(name);
VIR_FREE(name);
return(-1);
}
SKIP_BLANKS;
@ -630,15 +630,15 @@ virConfParseStatement(virConfParserCtxtPtr ctxt)
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);
@ -720,7 +720,7 @@ __virConfReadFile(const char *filename)
conf = virConfParse(filename, content, len);
free(content);
VIR_FREE(content);
return conf;
}
@ -769,14 +769,14 @@ __virConfFree(virConfPtr 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);
}
@ -834,14 +834,14 @@ __virConfSetValue (virConfPtr conf,
}
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;
@ -897,15 +897,16 @@ __virConfWriteFile(const char *filename, virConfPtr conf)
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);
@ -955,11 +956,11 @@ __virConfWriteMem(char *memory, int *len, virConfPtr conf)
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;
}

60
src/iptables.c
View File

@ -45,6 +45,7 @@
#include "internal.h"
#include "iptables.h"
#include "util.h"
#include "memory.h"
#define qemudLog(level, msg...) fprintf(stderr, msg)
@ -156,7 +157,7 @@ notifyRulesRemoved(const char *table,
snprintf(arg, sizeof(arg), "--custom-rules=ipv4:%s:%s", table, path);
if (!stripLine(content, len, arg)) {
free(content);
VIR_FREE(content);
return;
}
@ -171,7 +172,7 @@ notifyRulesRemoved(const char *table,
goto write_error;
}
free(content);
VIR_FREE(content);
return;
@ -181,7 +182,7 @@ notifyRulesRemoved(const char *table,
strerror(errno));
if (f)
fclose(f);
free(content);
VIR_FREE(content);
#undef MAX_FILE_LEN
}
@ -264,14 +265,14 @@ iptRulesSave(iptRules *rules)
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;
}
}
@ -282,18 +283,14 @@ iptRulesAppend(iptRules *rules,
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;
@ -332,23 +329,17 @@ iptRulesFree(iptRules *rules)
{
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;
}
@ -358,7 +349,7 @@ iptRulesFree(iptRules *rules)
rules->path[0] = '\0';
#endif /* ENABLE_IPTABLES_LOKKIT */
free(rules);
VIR_FREE(rules);
}
static iptRules *
@ -367,7 +358,7 @@ iptRulesNew(const char *table,
{
iptRules *rules;
if (!(rules = calloc(1, sizeof (*rules))))
if (VIR_ALLOC(rules) < 0)
return NULL;
if (!(rules->table = strdup(table)))
@ -404,8 +395,9 @@ argvToString(char **argv)
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)
@ -441,7 +433,7 @@ iptablesAddRemoveRule(iptRules *rules, int action, const char *arg, ...)
va_end(args);
if (!(argv = calloc(n + 1, sizeof(*argv))))
if (VIR_ALLOC_N(argv, n + 1) < 0)
goto error;
n = 0;
@ -478,7 +470,7 @@ iptablesAddRemoveRule(iptRules *rules, int action, const char *arg, ...)
goto error;
if (action == REMOVE) {
free(argv[command_idx]);
VIR_FREE(argv[command_idx]);
if (!(argv[command_idx] = strdup("--delete")))
goto error;
}
@ -497,13 +489,13 @@ iptablesAddRemoveRule(iptRules *rules, int action, const char *arg, ...)
}
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;
@ -521,7 +513,7 @@ iptablesContextNew(void)
{
iptablesContext *ctx;
if (!(ctx = calloc(1, sizeof (*ctx))))
if (VIR_ALLOC(ctx) < 0)
return NULL;
if (!(ctx->input_filter = iptRulesNew("filter", "INPUT")))
@ -555,7 +547,7 @@ iptablesContextFree(iptablesContext *ctx)
iptRulesFree(ctx->forward_filter);
if (ctx->nat_postrouting)
iptRulesFree(ctx->nat_postrouting);
free(ctx);
VIR_FREE(ctx);
}
/**

45
src/lxc_conf.c
View File

@ -42,7 +42,7 @@
#include "util.h"
#include "uuid.h"
#include "xml.h"
#include "memory.h"
#include "lxc_conf.h"
/* debug macros */
@ -183,10 +183,10 @@ static int lxcParseDomainUUID(virConnectPtr conn, unsigned char *uuid,
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);
}
@ -206,15 +206,14 @@ static int lxcParseDomainMounts(virConnectPtr conn,
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;
}
@ -228,7 +227,7 @@ static int lxcParseDomainMounts(virConnectPtr conn,
}
prevObj = mountObj;
}
free(list);
VIR_FREE(list);
}
rc = nmounts;
@ -252,7 +251,7 @@ static int lxcParseDomainInit(virConnectPtr conn, char** init,
if (strlen(res) >= PATH_MAX - 1) {
lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
_("init string too long"));
free(res);
VIR_FREE(res);
return(-1);
}
@ -307,7 +306,7 @@ static lxc_vm_def_t * lxcParseXML(virConnectPtr conn, xmlDocPtr docPtr)
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;
}
@ -339,8 +338,7 @@ static lxc_vm_def_t * lxcParseXML(virConnectPtr conn, xmlDocPtr docPtr)
_("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))) {
@ -357,8 +355,7 @@ static lxc_vm_def_t * lxcParseXML(virConnectPtr conn, xmlDocPtr docPtr)
} else {
containerDef->id = -1;
}
free(xmlProp);
xmlProp = NULL;
VIR_FREE(xmlProp);
if (lxcParseDomainName(conn, &(containerDef->name), contextPtr) < 0) {
goto error;
@ -391,7 +388,7 @@ static lxc_vm_def_t * lxcParseXML(virConnectPtr conn, xmlDocPtr docPtr)
return containerDef;
error:
free(xmlProp);
VIR_FREE(xmlProp);
xmlXPathFreeContext(contextPtr);
lxcFreeVMDef(containerDef);
@ -442,7 +439,7 @@ lxc_vm_t * lxcAssignVMDef(virConnectPtr conn,
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;
}
@ -575,7 +572,7 @@ int lxcSaveConfig(virConnectPtr conn,
close(fd);
}
free(xmlDef);
VIR_FREE(xmlDef);
return rc;
}
@ -689,7 +686,7 @@ int lxcLoadContainerConfigFile(lxc_driver_t *driver,
lxcLoadConfig(driver, file, tempPath, xmlData);
free(xmlData);
VIR_FREE(xmlData);
load_complete:
return rc;
@ -796,14 +793,14 @@ void lxcFreeVMDef(lxc_vm_def_t *vmdef)
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)
@ -821,8 +818,8 @@ 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)

5
src/lxc_container.c
View File

@ -35,6 +35,7 @@
#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)
@ -54,8 +55,8 @@ static int lxcExecContainerInit(const lxc_vm_def_t *vmDef)
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;

27
src/lxc_driver.c
View File

@ -42,6 +42,7 @@
#include "driver.h"
#include "internal.h"
#include "util.h"
#include "memory.h"
/* debug macros */
#define DEBUG(fmt,...) VIR_DEBUG(__FILE__, fmt, __VA_ARGS__)
@ -85,8 +86,7 @@ static int lxcCheckContainerSupport( void )
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;
@ -102,7 +102,7 @@ static int lxcCheckContainerSupport( void )
waitpid(cpid, &childStatus, 0);
}
free(stack);
VIR_FREE(stack);
check_complete:
return rc;
@ -263,7 +263,7 @@ static int lxcListDefinedDomains(virConnectPtr conn,
cleanup:
for (i = 0 ; i < numDoms ; i++) {
free(names[i]);
VIR_FREE(names[i]);
}
return -1;
@ -400,16 +400,15 @@ static int lxcStartContainer(virConnectPtr conn,
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;
@ -574,8 +573,7 @@ static int lxcSetupContainerTty(virConnectPtr conn,
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;
@ -1046,8 +1044,7 @@ static int lxcStartup(void)
return -1;
}
lxc_driver = calloc(1, sizeof(lxc_driver_t));
if (NULL == lxc_driver) {
if (VIR_ALLOC(lxc_driver) < 0) {
return -1;
}
@ -1074,9 +1071,9 @@ static int lxcStartup(void)
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)

16
src/memory.c
View File

@ -77,22 +77,6 @@ static int virAllocTestFail(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

19
src/memory.h
View File

@ -25,6 +25,25 @@
#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;

49
src/openvz_conf.c
View File

@ -53,6 +53,7 @@
#include "openvz_conf.h"
#include "uuid.h"
#include "buf.h"
#include "memory.h"
#include <string.h>
@ -152,23 +153,22 @@ openvzFreeVMDef(struct openvz_vm_def *def)
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);
}
}
@ -201,8 +201,7 @@ openvzFreeVM(struct openvz_driver *driver, struct openvz_vm *vm,
}
if (vms) {
openvzFreeVMDef(vm->vmdef);
free(vm);
vm = NULL;
VIR_FREE(vm);
}
}
@ -217,8 +216,7 @@ openvzFreeDriver(struct openvz_driver *driver)
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 *
@ -247,7 +245,7 @@ openvzAssignVMDef(virConnectPtr conn,
return vm;
}
if (!(vm = calloc(1, sizeof(*vm)))) {
if (VIR_ALLOC(vm) < 0) {
openvzFreeVMDef(def);
error(conn, VIR_ERR_NO_MEMORY, "vm");
return NULL;
@ -299,7 +297,7 @@ static struct openvz_vm_def
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;
}
@ -328,8 +326,7 @@ static struct openvz_vm_def
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);
@ -396,7 +393,7 @@ static struct openvz_vm_def
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;
@ -478,7 +475,7 @@ static struct openvz_vm_def
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;
@ -509,7 +506,7 @@ static struct openvz_vm_def
return def;
bail_out:
free(prop);
VIR_FREE(prop);
xmlXPathFreeObject(obj);
xmlXPathFreeContext(ctxt);
openvzFreeVMDef(def);
@ -539,8 +536,7 @@ openvzGetVPSInfo(virConnectPtr conn) {
}
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;
}
@ -568,8 +564,7 @@ openvzGetVPSInfo(virConnectPtr conn) {
(*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;
}
@ -581,7 +576,7 @@ openvzGetVPSInfo(virConnectPtr conn) {
if(ret == -1) {
error(conn, VIR_ERR_INTERNAL_ERROR,
_("UUID in config file malformed"));
free(vmdef);
VIR_FREE(vmdef);
goto error;
}
@ -594,8 +589,8 @@ error:
struct openvz_vm *next;
next = vm->next;
free(vm->vmdef);
free(vm);
VIR_FREE(vm->vmdef);
VIR_FREE(vm);
vm = next;
}
return NULL;
@ -656,7 +651,7 @@ openvzGetVPSUUID(int vpsid, char *uuidstr)
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)
@ -697,7 +692,7 @@ openvzSetUUID(int vpsid)
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;
@ -741,7 +736,7 @@ int openvzAssignUUIDs(void)
dp = opendir(conf_dir);
if(dp == NULL) {
free(conf_dir);
VIR_FREE(conf_dir);
return 0;
}
@ -753,7 +748,7 @@ int openvzAssignUUIDs(void)
openvzSetUUID(vpsid);
}
closedir(dp);
free(conf_dir);
VIR_FREE(conf_dir);
return 0;
}

3
src/openvz_driver.c
View File

@ -49,8 +49,7 @@
#include <stdio.h>
#include <sys/wait.h>
#include "libvirt/virterror.h"
#include "internal.h"
#include "openvz_driver.h"
#include "event.h"
#include "buf.h"

8
src/proxy_internal.c
View File

@ -28,6 +28,7 @@
#include "proxy_internal.h"
#include "util.h"
#include "xen_unified.h"
#include "memory.h"
#define STANDALONE
@ -992,8 +993,7 @@ xenProxyGetCapabilities (virConnectPtr conn)
}
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;
}
@ -1044,7 +1044,7 @@ xenProxyDomainDumpXML(virDomainPtr domain, int flags ATTRIBUTE_UNUSED)
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;
}
@ -1097,7 +1097,7 @@ xenProxyDomainGetOSType(virDomainPtr domain)
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;
}

77
src/remote_internal.c
View File

@ -71,6 +71,7 @@
#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)
@ -638,8 +639,7 @@ doRemoteOpen (virConnectPtr conn,
// 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;
}
@ -702,8 +702,7 @@ doRemoteOpen (virConnectPtr conn,
// 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;
}
@ -811,8 +810,7 @@ remoteOpen (virConnectPtr conn,
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;
}
@ -856,7 +854,7 @@ remoteOpen (virConnectPtr conn,
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;
@ -2268,9 +2266,7 @@ remoteDomainSetSchedulerParameters (virDomainPtr domain,
/* 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;
}
@ -2446,9 +2442,9 @@ remoteNetworkOpen (virConnectPtr conn,
* 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;
}
@ -2461,7 +2457,7 @@ remoteNetworkOpen (virConnectPtr conn,
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;
@ -2480,7 +2476,7 @@ remoteNetworkClose (virConnectPtr conn)
priv->localUses--;
if (!priv->localUses) {
ret = doRemoteClose(conn, priv);
free(priv);
VIR_FREE(priv);
conn->networkPrivateData = NULL;
}
}
@ -2852,9 +2848,9 @@ remoteStorageOpen (virConnectPtr conn,
* 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;
}
@ -2867,7 +2863,7 @@ remoteStorageOpen (virConnectPtr conn,
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;
@ -2886,7 +2882,7 @@ remoteStorageClose (virConnectPtr conn)
priv->localUses--;
if (!priv->localUses) {
ret = doRemoteClose(conn, priv);
free(priv);
VIR_FREE(priv);
conn->storagePrivateData = NULL;
}
}
@ -3605,7 +3601,7 @@ remoteAuthenticate (virConnectPtr conn, struct private_data *priv, int in_open,
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;
@ -3615,7 +3611,7 @@ remoteAuthenticate (virConnectPtr conn, struct private_data *priv, int in_open,
#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;
@ -3631,11 +3627,11 @@ remoteAuthenticate (virConnectPtr conn, struct private_data *priv, int in_open,
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;
}
@ -3664,8 +3660,7 @@ static char *addrToString(struct sockaddr_storage *sa, socklen_t salen)
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,
@ -3758,9 +3753,9 @@ static int remoteAuthCredSASL2Vir(int vircred)
*/
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;
}
@ -3795,14 +3790,13 @@ static int remoteAuthMakeCredentials(sasl_interact_t *interact,
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)
@ -3821,8 +3815,8 @@ static void remoteAuthFreeCredentials(virConnectCredentialPtr cred,
{
int i;
for (i = 0 ; i < ncred ; i++)
free(cred[i].result);
free(cred);
VIR_FREE(cred[i].result);
VIR_FREE(cred);
}
@ -3990,7 +3984,7 @@ remoteAuthSASL (virConnectPtr conn, struct private_data *priv, int in_open,
NULL, NULL, NULL, 0, 0,
_("SASL mechanism %s not supported by server"),
wantmech);
free(iret.mechlist);
VIR_FREE(iret.mechlist);
goto cleanup;
}
mechlist = wantmech;
@ -4009,7 +4003,7 @@ remoteAuthSASL (virConnectPtr conn, struct private_data *priv, int in_open,
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;
}
@ -4026,7 +4020,7 @@ remoteAuthSASL (virConnectPtr conn, struct private_data *priv, int in_open,
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 */
@ -4044,7 +4038,7 @@ remoteAuthSASL (virConnectPtr conn, struct private_data *priv, int in_open,
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,
@ -4123,8 +4117,7 @@ remoteAuthSASL (virConnectPtr conn, struct private_data *priv, int in_open,
}
if (serverin) {
free(serverin);
serverin = NULL;
VIR_FREE(serverin);
}
DEBUG("Client step result %d. Data %d bytes %p", err, clientoutlen, clientout);
@ -4156,7 +4149,7 @@ remoteAuthSASL (virConnectPtr conn, struct private_data *priv, int in_open,
/* This server call shows complete, and earlier client step was OK */
if (complete && err == SASL_OK) {
free(serverin);
VIR_FREE(serverin);
break;
}
}
@ -4186,11 +4179,11 @@ remoteAuthSASL (virConnectPtr conn, struct private_data *priv, int in_open,
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);

31
src/sexpr.c
View File

@ -21,6 +21,7 @@
#include "internal.h"
#include "sexpr.h"
#include "util.h"
#include "memory.h"
/**
* virSexprError:
@ -55,8 +56,7 @@ sexpr_new(void)
{
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);
}
@ -85,13 +85,13 @@ sexpr_free(struct sexpr *sexpr)
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;
}
@ -171,16 +171,23 @@ sexpr_cons(const struct sexpr *car, const struct sexpr *cdr)
*
* 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;
}
/**
@ -198,7 +205,8 @@ sexpr_append(struct sexpr *lst, const struct sexpr *value)
return (NULL);
if (value == NULL)
return (lst);
append(lst, value);
if (append(lst, value) < 0)
return (NULL);
return (lst);
}
@ -318,8 +326,11 @@ _string2sexpr(const char *buffer, size_t * end)
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];
@ -351,6 +362,7 @@ _string2sexpr(const char *buffer, size_t * end)
if (ret->u.value == NULL) {
virSexprError(VIR_ERR_NO_MEMORY,
_("failed to copy a string"));
goto error;
}
if (*ptr == '\'')
@ -367,6 +379,7 @@ _string2sexpr(const char *buffer, size_t * end)
if (ret->u.value == NULL) {
virSexprError(VIR_ERR_NO_MEMORY,
_("failed to copy a string"));
goto error;
}
}

32
src/storage_backend.c
View File

@ -50,6 +50,7 @@
#endif
#include "util.h"
#include "memory.h"
#include "storage_backend.h"
#include "storage_backend_fs.h"
@ -237,8 +238,7 @@ virStorageBackendUpdateVolInfoFD(virConnectPtr conn,
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) {
@ -310,9 +310,8 @@ virStorageBackendStablePath(virConnectPtr conn,
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;
@ -327,7 +326,7 @@ virStorageBackendStablePath(virConnectPtr conn,
return stablepath;
}
free(stablepath);
VIR_FREE(stablepath);
}
closedir(dh);
@ -365,7 +364,7 @@ virStorageBackendRunProgRegex(virConnectPtr conn,
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;
}
@ -379,7 +378,7 @@ virStorageBackendRunProgRegex(virConnectPtr conn,
_("Failed to compile regex %s"), error);
for (j = 0 ; j <= i ; j++)
regfree(&reg[j]);
free(reg);
VIR_FREE(reg);
return -1;
}
@ -390,12 +389,12 @@ virStorageBackendRunProgRegex(virConnectPtr conn,
}
/* 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;
@ -445,7 +444,7 @@ virStorageBackendRunProgRegex(virConnectPtr conn,
/* 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;
@ -460,15 +459,15 @@ virStorageBackendRunProgRegex(virConnectPtr conn,
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(&reg[i]);
free(reg);
VIR_FREE(reg);
if (list)
fclose(list);
@ -534,8 +533,7 @@ virStorageBackendRunProgNul(virConnectPtr conn,
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;

24
src/storage_backend_disk.c
View File

@ -26,6 +26,7 @@
#include "internal.h"
#include "storage_backend_disk.h"
#include "util.h"
#include "memory.h"
enum {
VIR_STORAGE_POOL_DISK_DOS = 0,
@ -174,7 +175,7 @@ virStorageBackendDiskMakeDataVol(virConnectPtr conn,
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;
}
@ -211,8 +212,7 @@ virStorageBackendDiskMakeDataVol(virConnectPtr conn,
return -1;
if (devpath != vol->target.path)
free(devpath);
devpath = NULL;
VIR_FREE(devpath);
}
if (vol->key == NULL) {
@ -224,8 +224,7 @@ virStorageBackendDiskMakeDataVol(virConnectPtr conn,
}
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;
@ -275,16 +274,15 @@ virStorageBackendDiskMakeFreeExtent(virConnectPtr conn ATTRIBUTE_UNUSED,
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)
@ -388,9 +386,8 @@ static int
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);
}
@ -476,9 +473,8 @@ virStorageBackendDiskCreateVol(virConnectPtr conn,
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)

56
src/storage_backend_fs.c
View File

@ -40,8 +40,7 @@
#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,
@ -530,25 +529,27 @@ virStorageBackendFileSystemMount(virConnectPtr conn,
}
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;
}
@ -679,8 +680,7 @@ virStorageBackendFileSystemRefresh(virConnectPtr conn,
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;
@ -688,18 +688,17 @@ virStorageBackendFileSystemRefresh(virConnectPtr conn,
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;
@ -708,19 +707,19 @@ virStorageBackendFileSystemRefresh(virConnectPtr conn,
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
@ -821,9 +820,8 @@ virStorageBackendFileSystemVolCreate(virConnectPtr conn,
{
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;
}

30
src/storage_backend_iscsi.c
View File

@ -37,6 +37,7 @@
#include "internal.h"
#include "storage_backend_iscsi.h"
#include "util.h"
#include "memory.h"
static int
virStorageBackendISCSITargetIP(virConnectPtr conn,
@ -253,7 +254,7 @@ virStorageBackendISCSIMakeLUN(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;
}
@ -263,14 +264,13 @@ virStorageBackendISCSIMakeLUN(virConnectPtr conn,
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.
@ -303,8 +303,7 @@ virStorageBackendISCSIMakeLUN(virConnectPtr conn,
goto cleanup;
if (devpath != vol->target.path)
free(devpath);
devpath = NULL;
VIR_FREE(devpath);
if (virStorageBackendUpdateVolInfoFD(conn, vol, fd, 1) < 0)
goto cleanup;
@ -330,9 +329,9 @@ virStorageBackendISCSIMakeLUN(virConnectPtr conn,
cleanup:
if (fd != -1) close(fd);
free(devpath);
VIR_FREE(devpath);
virStorageVolDefFree(vol);
free(dev);
VIR_FREE(dev);
return -1;
}
@ -422,8 +421,7 @@ virStorageBackendISCSIPortal(virConnectPtr conn,
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;
}
@ -457,10 +455,10 @@ virStorageBackendISCSIStartPool(virConnectPtr conn,
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;
}
@ -478,12 +476,12 @@ virStorageBackendISCSIRefreshPool(virConnectPtr conn,
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;
}
@ -498,10 +496,10 @@ virStorageBackendISCSIStopPool(virConnectPtr conn,
return -1;
if (virStorageBackendISCSILogout(conn, pool, portal) < 0) {
free(portal);
VIR_FREE(portal);
return -1;
}
free(portal);
VIR_FREE(portal);
return 0;
}

20
src/storage_backend_logical.c
View File

@ -35,7 +35,7 @@
#include "storage_backend_logical.h"
#include "storage_conf.h"
#include "util.h"
#include "memory.h"
#define PV_BLANK_SECTOR_SIZE 512
@ -97,7 +97,6 @@ virStorageBackendLogicalMakeVol(virConnectPtr conn,
void *data)
{
virStorageVolDefPtr vol = NULL;
virStorageVolSourceExtentPtr tmp;
unsigned long long offset, size, length;
/* See if we're only looking for a specific volume */
@ -113,7 +112,7 @@ virStorageBackendLogicalMakeVol(virConnectPtr conn,
/* 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;
}
@ -129,8 +128,8 @@ virStorageBackendLogicalMakeVol(virConnectPtr conn,
}
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;
}
@ -150,12 +149,11 @@ virStorageBackendLogicalMakeVol(virConnectPtr conn,
/* 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) {
@ -266,7 +264,7 @@ virStorageBackendLogicalBuildPool(virConnectPtr conn,
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;
}
@ -318,12 +316,12 @@ virStorageBackendLogicalBuildPool(virConnectPtr conn,
if (virRun(conn, (char**)vgargv, NULL) < 0)
goto cleanup;
free(vgargv);
VIR_FREE(vgargv);
return 0;
cleanup:
free(vgargv);
VIR_FREE(vgargv);
return -1;
}

114
src/storage_conf.c
View File

@ -45,6 +45,7 @@
#include "uuid.h"
#include "buf.h"
#include "util.h"
#include "memory.h"
#define virStorageLog(msg...) fprintf(stderr, msg)
@ -70,40 +71,40 @@ virStorageReportError(virConnectPtr conn, int code, const char *fmt, ...) {
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);
}
@ -114,9 +115,9 @@ virStoragePoolObjFree(virStoragePoolObjPtr obj) {
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
@ -225,8 +226,11 @@ virStoragePoolDefParseDoc(virConnectPtr conn,
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,
@ -263,17 +267,16 @@ virStoragePoolDefParseDoc(virConnectPtr conn,
"%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) {
@ -292,22 +295,22 @@ virStoragePoolDefParseDoc(virConnectPtr conn,
"%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) {
@ -329,12 +332,10 @@ virStoragePoolDefParseDoc(virConnectPtr conn,
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) {
@ -354,7 +355,7 @@ virStoragePoolDefParseDoc(virConnectPtr conn,
return ret;
cleanup:
free(uuid);
VIR_FREE(uuid);
xmlFree(type);
virStoragePoolDefFree(ret);
return NULL;
@ -649,8 +650,11 @@ virStorageVolDefParseDoc(virConnectPtr conn,
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,
@ -677,20 +681,16 @@ virStorageVolDefParseDoc(virConnectPtr conn,
}
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;
}
@ -699,10 +699,10 @@ virStorageVolDefParseDoc(virConnectPtr conn,
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)
@ -711,9 +711,9 @@ virStorageVolDefParseDoc(virConnectPtr conn,
return ret;
cleanup:
free(allocation);
free(capacity);
free(unit);
VIR_FREE(allocation);
VIR_FREE(capacity);
VIR_FREE(unit);
virStorageVolDefFree(ret);
return NULL;
}
@ -772,6 +772,7 @@ virStorageVolDefFormat(virConnectPtr conn,
virStorageVolDefPtr def) {
virStorageBackendVolOptionsPtr options;
virBuffer buf = VIR_BUFFER_INITIALIZER;
char *tmp;
options = virStorageBackendVolOptionsForType(pool->type);
if (options == NULL)
@ -849,7 +850,8 @@ virStorageVolDefFormat(virConnectPtr conn,
no_memory:
virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("xml"));
cleanup:
free(virBufferContentAndReset(&buf));
tmp = virBufferContentAndReset(&buf);
VIR_FREE(tmp);
return NULL;
}
@ -955,7 +957,7 @@ virStoragePoolObjAssignDef(virConnectPtr conn,
return pool;
}
if (!(pool = calloc(1, sizeof(virStoragePoolObj)))) {
if (VIR_ALLOC(pool) < 0) {
virStorageReportError(conn, VIR_ERR_NO_MEMORY,
"%s", _("pool"));
return NULL;
@ -1063,7 +1065,7 @@ virStoragePoolObjScanConfigs(virStorageDriverStatePtr driver) {
virStoragePoolObjLoad(driver, entry->d_name, path, xml, autostartLink);
free(xml);
VIR_FREE(xml);
}
closedir(dir);
@ -1108,15 +1110,13 @@ virStoragePoolObjSaveDef(virConnectPtr conn,
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;
}
}
@ -1157,7 +1157,7 @@ virStoragePoolObjSaveDef(virConnectPtr conn,
if (fd != -1)
close(fd);
free(xml);
VIR_FREE(xml);
return ret;
}

5
src/storage_driver.c
View File

@ -37,7 +37,7 @@
#include "util.h"
#include "storage_driver.h"
#include "storage_conf.h"
#include "memory.h"
#include "storage_backend.h"
#define storageLog(msg...) fprintf(stderr, msg)
@ -104,9 +104,8 @@ storageDriverStartup(void) {
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)

38
src/xen_internal.c
View File

@ -48,6 +48,7 @@
#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)
@ -223,17 +224,17 @@ typedef struct xen_v2s4_availheap xen_v2s4_availheap;
#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 ? \
@ -796,8 +797,7 @@ virXenPerror (virConnectPtr conn, const char *msg)
{
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");
}
@ -1659,8 +1659,7 @@ virXen_setvcpumap(int handle, int id, unsigned int vcpu,
/* 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);
@ -1683,7 +1682,7 @@ virXen_setvcpumap(int handle, int id, unsigned int vcpu,
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);
@ -1985,8 +1984,7 @@ xenHypervisorInit(void)
*/
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);
}
@ -2053,13 +2051,13 @@ xenHypervisorInit(void)
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);
}
@ -2647,7 +2645,7 @@ xenHypervisorLookupDomainByID(virConnectPtr conn,
ret = virGetDomain(conn, name, XEN_GETDOMAININFO_UUID(dominfo));
if (ret)
ret->id = id;
free(name);
VIR_FREE(name);
return ret;
}
@ -2714,7 +2712,7 @@ xenHypervisorLookupDomainByUUID(virConnectPtr conn,
ret = virGetDomain(conn, name, uuid);
if (ret)
ret->id = id;
free(name);
VIR_FREE(name);
return ret;
}
#endif

24
src/xen_unified.c
View File

@ -40,6 +40,7 @@
#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)
@ -172,15 +173,13 @@ xenDomainUsedCpus(virDomainPtr dom)
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,
@ -202,9 +201,9 @@ xenDomainUsedCpus(virDomainPtr dom)
}
done:
free(cpulist);
free(cpumap);
free(cpuinfo);
VIR_FREE(cpulist);
VIR_FREE(cpumap);
VIR_FREE(cpuinfo);
return(res);
}
@ -262,8 +261,7 @@ xenUnifiedOpen (virConnectPtr conn, xmlURIPtr uri, virConnectAuthPtr auth, int f
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;
}
@ -342,7 +340,7 @@ xenUnifiedOpen (virConnectPtr conn, xmlURIPtr uri, virConnectAuthPtr auth, int f
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;
}
@ -961,7 +959,7 @@ xenUnifiedDomainDumpXML (virDomainPtr dom, int flags)
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])

1
src/xend_internal.c
View File

@ -26,7 +26,6 @@
#include <stdbool.h>
#include <math.h>
#include <stdarg.h>
#include <malloc.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>

67
src/xmlrpc.c
View File

@ -12,6 +12,7 @@
#include "xmlrpc.h"
#include "internal.h"
#include "memory.h"
#include <libxml/nanohttp.h>
@ -47,9 +48,8 @@ static void xmlRpcError(virErrorNumber error, const char *info, int value)
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;
@ -115,7 +115,7 @@ static xmlRpcValuePtr xmlRpcValueUnmarshalInteger(xmlNodePtr node)
if (ret && value)
ret->value.integer = atoi(value);
free(value);
VIR_FREE(value);
return ret;
}
@ -130,7 +130,7 @@ static xmlRpcValuePtr xmlRpcValueUnmarshalBoolean(xmlNodePtr node)
ret->value.boolean = true;
else
ret->value.boolean = false;
free(value);
VIR_FREE(value);
return ret;
}
@ -141,7 +141,7 @@ static xmlRpcValuePtr xmlRpcValueUnmarshalDouble(xmlNodePtr node)
if (ret && value)
ret->value.real = atof(value);
free(value);
VIR_FREE(value);
return ret;
}
@ -158,11 +158,10 @@ static xmlRpcValuePtr xmlRpcValueUnmarshalArray(xmlNodePtr node)
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;
@ -179,10 +178,10 @@ static xmlRpcValuePtr xmlRpcValueUnmarshalArray(xmlNodePtr node)
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;
}
@ -195,10 +194,10 @@ static xmlRpcValueDictElementPtr xmlRpcValueUnmarshalDictElement(xmlNodePtr node
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;
}
}
@ -283,26 +282,26 @@ void xmlRpcValueFree(xmlRpcValuePtr value)
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)
@ -436,15 +435,14 @@ static char *xmlRpcCallRaw(const char *url, const char *request)
}
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);
}
@ -455,7 +453,7 @@ static char *xmlRpcCallRaw(const char *url, const char *request)
serrno = errno;
if (cxt) {
xmlNanoHTTPClose(cxt);
free(contentType);
VIR_FREE(contentType);
}
errno = serrno;
@ -477,7 +475,7 @@ static char **xmlRpcStringArray(xmlRpcValuePtr value)
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;
}
@ -507,7 +505,7 @@ xmlRpcArgvNew(const char *fmt, va_list ap, int *argc)
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;
}
@ -552,7 +550,7 @@ xmlRpcArgvFree(int argc, xmlRpcValuePtr *argv)
for (i = 0; i < argc; i++)
xmlRpcValueFree(argv[i]);
free(argv);
VIR_FREE(argv);
}
int xmlRpcCall(xmlRpcContextPtr context, const char *method,
@ -589,7 +587,7 @@ int xmlRpcCall(xmlRpcContextPtr context, const char *method,
content = virBufferContentAndReset(&buf);
ret = xmlRpcCallRaw(context->uri, content);
free(content);
VIR_FREE(content);
if (!ret)
return -1;
@ -597,7 +595,7 @@ int xmlRpcCall(xmlRpcContextPtr context, const char *method,
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;
@ -659,13 +657,14 @@ int xmlRpcCall(xmlRpcContextPtr context, const char *method,
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;
}
@ -673,9 +672,9 @@ xmlRpcContextPtr xmlRpcContextNew(const char *uri)
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);
}
}