External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2025-02-08 12:41:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

Switch daemon over to use internal memory allocation APIs

Browse Source
This commit is contained in:
Daniel P. Berrange 2008-06-06 10:52:01 +00:00
parent a73a88a19f
commit d7d21c85e0
8 changed files with 217 additions and 169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
ChangeLog
View File

@ -1,3 +1,10 @@
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:
Switch over to use internal memory allocation APIs.
* src/libvirt_sym.version, src/memory.c, src/memory.h: Export
virAlloc/Realloc/Free to use by libvirtd daemon
Thu Jun 5 22:08:00 BST 2008 Richard W.M. Jones <rjones@redhat.com> Thu Jun 5 22:08:00 BST 2008 Richard W.M. Jones <rjones@redhat.com>
virDomainBlockPeek QEMU and remote support virDomainBlockPeek QEMU and remote support

49
qemud/event.c
View File

@ -31,6 +31,7 @@
#include "qemud.h" #include "qemud.h"
#include "event.h" #include "event.h"
#include "memory.h"
#define EVENT_DEBUG(fmt, ...) qemudDebug("EVENT: " fmt, __VA_ARGS__) #define EVENT_DEBUG(fmt, ...) qemudDebug("EVENT: " fmt, __VA_ARGS__)
@ -82,16 +83,11 @@ static int nextTimer = 0;
int virEventAddHandleImpl(int fd, int events, virEventHandleCallback cb, void *opaque) { int virEventAddHandleImpl(int fd, int events, virEventHandleCallback cb, void *opaque) {
EVENT_DEBUG("Add handle %d %d %p %p", fd, events, cb, opaque); EVENT_DEBUG("Add handle %d %d %p %p", fd, events, cb, opaque);
if (eventLoop.handlesCount == eventLoop.handlesAlloc) { if (eventLoop.handlesCount == eventLoop.handlesAlloc) {
struct virEventHandle *tmp;
EVENT_DEBUG("Used %d handle slots, adding %d more", EVENT_DEBUG("Used %d handle slots, adding %d more",
eventLoop.handlesAlloc, EVENT_ALLOC_EXTENT); eventLoop.handlesAlloc, EVENT_ALLOC_EXTENT);
tmp = realloc(eventLoop.handles, if (VIR_REALLOC_N(eventLoop.handles,
sizeof(struct virEventHandle) * (eventLoop.handlesAlloc + EVENT_ALLOC_EXTENT)) < 0)
(eventLoop.handlesAlloc + EVENT_ALLOC_EXTENT));
if (!tmp) {
return -1; return -1;
}
eventLoop.handles = tmp;
eventLoop.handlesAlloc += EVENT_ALLOC_EXTENT; eventLoop.handlesAlloc += EVENT_ALLOC_EXTENT;
} }
@ -152,16 +148,11 @@ int virEventAddTimeoutImpl(int frequency, virEventTimeoutCallback cb, void *opaq
} }
if (eventLoop.timeoutsCount == eventLoop.timeoutsAlloc) { if (eventLoop.timeoutsCount == eventLoop.timeoutsAlloc) {
struct virEventTimeout *tmp;
EVENT_DEBUG("Used %d timeout slots, adding %d more", EVENT_DEBUG("Used %d timeout slots, adding %d more",
eventLoop.timeoutsAlloc, EVENT_ALLOC_EXTENT); eventLoop.timeoutsAlloc, EVENT_ALLOC_EXTENT);
tmp = realloc(eventLoop.timeouts, if (VIR_REALLOC_N(eventLoop.timeouts,
sizeof(struct virEventTimeout) * (eventLoop.timeoutsAlloc + EVENT_ALLOC_EXTENT)) < 0)
(eventLoop.timeoutsAlloc + EVENT_ALLOC_EXTENT));
if (!tmp) {
return -1; return -1;
}
eventLoop.timeouts = tmp;
eventLoop.timeoutsAlloc += EVENT_ALLOC_EXTENT; eventLoop.timeoutsAlloc += EVENT_ALLOC_EXTENT;
} }
@ -281,7 +272,7 @@ static int virEventMakePollFDs(struct pollfd **retfds) {
} }
*retfds = NULL; *retfds = NULL;
/* Setup the poll file handle data structs */ /* Setup the poll file handle data structs */
if (!(fds = malloc(sizeof(*fds) * nfds))) if (VIR_ALLOC_N(fds, nfds) < 0)
return -1; return -1;
for (i = 0, nfds = 0 ; i < eventLoop.handlesCount ; i++) { for (i = 0, nfds = 0 ; i < eventLoop.handlesCount ; i++) {
@ -398,16 +389,11 @@ static int virEventCleanupTimeouts(void) {
/* Release some memory if we've got a big chunk free */ /* Release some memory if we've got a big chunk free */
if ((eventLoop.timeoutsAlloc - EVENT_ALLOC_EXTENT) > eventLoop.timeoutsCount) { if ((eventLoop.timeoutsAlloc - EVENT_ALLOC_EXTENT) > eventLoop.timeoutsCount) {
struct virEventTimeout *tmp;
EVENT_DEBUG("Releasing %d out of %d timeout slots used, releasing %d", EVENT_DEBUG("Releasing %d out of %d timeout slots used, releasing %d",
eventLoop.timeoutsCount, eventLoop.timeoutsAlloc, EVENT_ALLOC_EXTENT); eventLoop.timeoutsCount, eventLoop.timeoutsAlloc, EVENT_ALLOC_EXTENT);
tmp = realloc(eventLoop.timeouts, if (VIR_REALLOC_N(eventLoop.timeouts,
sizeof(struct virEventTimeout) * (eventLoop.timeoutsAlloc - EVENT_ALLOC_EXTENT)) < 0)
(eventLoop.timeoutsAlloc - EVENT_ALLOC_EXTENT));
if (!tmp) {
return -1; return -1;
}
eventLoop.timeouts = tmp;
eventLoop.timeoutsAlloc -= EVENT_ALLOC_EXTENT; eventLoop.timeoutsAlloc -= EVENT_ALLOC_EXTENT;
} }
return 0; return 0;
@ -439,16 +425,11 @@ static int virEventCleanupHandles(void) {
/* Release some memory if we've got a big chunk free */ /* Release some memory if we've got a big chunk free */
if ((eventLoop.handlesAlloc - EVENT_ALLOC_EXTENT) > eventLoop.handlesCount) { if ((eventLoop.handlesAlloc - EVENT_ALLOC_EXTENT) > eventLoop.handlesCount) {
struct virEventHandle *tmp;
EVENT_DEBUG("Releasing %d out of %d handles slots used, releasing %d", EVENT_DEBUG("Releasing %d out of %d handles slots used, releasing %d",
eventLoop.handlesCount, eventLoop.handlesAlloc, EVENT_ALLOC_EXTENT); eventLoop.handlesCount, eventLoop.handlesAlloc, EVENT_ALLOC_EXTENT);
tmp = realloc(eventLoop.handles, if (VIR_REALLOC_N(eventLoop.handles,
sizeof(struct virEventHandle) * (eventLoop.handlesAlloc - EVENT_ALLOC_EXTENT)) < 0)
(eventLoop.handlesAlloc - EVENT_ALLOC_EXTENT));
if (!tmp) {
return -1; return -1;
}
eventLoop.handles = tmp;
eventLoop.handlesAlloc -= EVENT_ALLOC_EXTENT; eventLoop.handlesAlloc -= EVENT_ALLOC_EXTENT;
} }
return 0; return 0;
@ -466,7 +447,7 @@ int virEventRunOnce(void) {
return -1; return -1;
if (virEventCalculateTimeout(&timeout) < 0) { if (virEventCalculateTimeout(&timeout) < 0) {
free(fds); VIR_FREE(fds);
return -1; return -1;
} }
@ -478,20 +459,20 @@ int virEventRunOnce(void) {
if (errno == EINTR) { if (errno == EINTR) {
goto retry; goto retry;
} }
free(fds); VIR_FREE(fds);
return -1; return -1;
} }
if (virEventDispatchTimeouts() < 0) { if (virEventDispatchTimeouts() < 0) {
free(fds); VIR_FREE(fds);
return -1; return -1;
} }
if (ret > 0 && if (ret > 0 &&
virEventDispatchHandles(fds) < 0) { virEventDispatchHandles(fds) < 0) {
free(fds); VIR_FREE(fds);
return -1; return -1;
} }
free(fds); VIR_FREE(fds);
if (virEventCleanupTimeouts() < 0) if (virEventCleanupTimeouts() < 0)
return -1; return -1;

53
qemud/mdns.c
View File

@ -42,6 +42,7 @@
#include "mdns.h" #include "mdns.h"
#include "event.h" #include "event.h"
#include "remote_internal.h" #include "remote_internal.h"
#include "memory.h"
#define AVAHI_DEBUG(fmt, ...) qemudDebug("AVAHI: " fmt, __VA_ARGS__) #define AVAHI_DEBUG(fmt, ...) qemudDebug("AVAHI: " fmt, __VA_ARGS__)
@ -99,7 +100,7 @@ static void libvirtd_mdns_group_callback(AvahiEntryGroup *g ATTRIBUTE_UNUSED, Av
/* A service name collision happened. Let's pick a new name */ /* A service name collision happened. Let's pick a new name */
n = avahi_alternative_service_name(group->name); n = avahi_alternative_service_name(group->name);
free(group->name); VIR_FREE(group->name);
group->name = n; group->name = n;
AVAHI_DEBUG("Group name collision, renaming service to '%s'", group->name); AVAHI_DEBUG("Group name collision, renaming service to '%s'", group->name);
@ -237,8 +238,8 @@ static void libvirtd_mdns_watch_dispatch(int fd, int events, void *opaque)
static AvahiWatch *libvirtd_mdns_watch_new(const AvahiPoll *api ATTRIBUTE_UNUSED, static AvahiWatch *libvirtd_mdns_watch_new(const AvahiPoll *api ATTRIBUTE_UNUSED,
int fd, AvahiWatchEvent event, AvahiWatchCallback cb, void *userdata) { int fd, AvahiWatchEvent event, AvahiWatchCallback cb, void *userdata) {
AvahiWatch *w = malloc(sizeof(*w)); AvahiWatch *w;
if (!w) if (VIR_ALLOC(w) < 0)
return NULL; return NULL;
w->fd = fd; w->fd = fd;
@ -248,7 +249,7 @@ static AvahiWatch *libvirtd_mdns_watch_new(const AvahiPoll *api ATTRIBUTE_UNUSED
AVAHI_DEBUG("New handle %p FD %d Event %d", w, w->fd, event); AVAHI_DEBUG("New handle %p FD %d Event %d", w, w->fd, event);
if (virEventAddHandleImpl(fd, event, libvirtd_mdns_watch_dispatch, w) < 0) { if (virEventAddHandleImpl(fd, event, libvirtd_mdns_watch_dispatch, w) < 0) {
free(w); VIR_FREE(w);
return NULL; return NULL;
} }
@ -271,7 +272,7 @@ static void libvirtd_mdns_watch_free(AvahiWatch *w)
{ {
AVAHI_DEBUG("Free handle %p %d", w, w->fd); AVAHI_DEBUG("Free handle %p %d", w, w->fd);
virEventRemoveHandleImpl(w->fd); virEventRemoveHandleImpl(w->fd);
free(w); VIR_FREE(w);
} }
static void libvirtd_mdns_timeout_dispatch(int timer ATTRIBUTE_UNUSED, void *opaque) static void libvirtd_mdns_timeout_dispatch(int timer ATTRIBUTE_UNUSED, void *opaque)
@ -287,15 +288,15 @@ static AvahiTimeout *libvirtd_mdns_timeout_new(const AvahiPoll *api ATTRIBUTE_UN
AvahiTimeoutCallback cb, AvahiTimeoutCallback cb,
void *userdata) void *userdata)
{ {
AvahiTimeout *t = malloc(sizeof(*t)); AvahiTimeout *t;
struct timeval now; struct timeval now;
long long nowms, thenms, timeout; long long nowms, thenms, timeout;
AVAHI_DEBUG("Add timeout %p TV %p", t, tv); AVAHI_DEBUG("Add timeout %p TV %p", t, tv);
if (!t) if (VIR_ALLOC(t) < 0)
return NULL; return NULL;
if (gettimeofday(&now, NULL) < 0) { if (gettimeofday(&now, NULL) < 0) {
free(t); VIR_FREE(t);
return NULL; return NULL;
} }
@ -317,7 +318,7 @@ static AvahiTimeout *libvirtd_mdns_timeout_new(const AvahiPoll *api ATTRIBUTE_UN
t->userdata = userdata; t->userdata = userdata;
if (t->timer < 0) { if (t->timer < 0) {
free(t); VIR_FREE(t);
return NULL; return NULL;
} }
@ -330,7 +331,7 @@ static void libvirtd_mdns_timeout_update(AvahiTimeout *t, const struct timeval *
long long nowms, thenms, timeout; long long nowms, thenms, timeout;
AVAHI_DEBUG("Update timeout %p TV %p", t, tv); AVAHI_DEBUG("Update timeout %p TV %p", t, tv);
if (gettimeofday(&now, NULL) < 0) { if (gettimeofday(&now, NULL) < 0) {
free(t); VIR_FREE(t);
return; return;
} }
@ -351,14 +352,14 @@ static void libvirtd_mdns_timeout_free(AvahiTimeout *t)
{ {
AVAHI_DEBUG("Free timeout %p", t); AVAHI_DEBUG("Free timeout %p", t);
virEventRemoveTimeoutImpl(t->timer); virEventRemoveTimeoutImpl(t->timer);
free(t); VIR_FREE(t);
} }
static AvahiPoll *libvirtd_create_poll(void) static AvahiPoll *libvirtd_create_poll(void)
{ {
AvahiPoll *p = malloc(sizeof(*p)); AvahiPoll *p;
if (!p) if (VIR_ALLOC(p) < 0)
return NULL; return NULL;
p->userdata = NULL; p->userdata = NULL;
@ -377,14 +378,13 @@ static AvahiPoll *libvirtd_create_poll(void)
struct libvirtd_mdns *libvirtd_mdns_new(void) struct libvirtd_mdns *libvirtd_mdns_new(void)
{ {
struct libvirtd_mdns *mdns = malloc(sizeof(*mdns)); struct libvirtd_mdns *mdns;
if (!mdns) if (VIR_ALLOC(mdns) < 0)
return NULL; return NULL;
memset(mdns, 0, sizeof(*mdns));
/* Allocate main loop object */ /* Allocate main loop object */
if (!(mdns->poller = libvirtd_create_poll())) { if (!(mdns->poller = libvirtd_create_poll())) {
free(mdns); VIR_FREE(mdns);
return NULL; return NULL;
} }
@ -406,15 +406,14 @@ int libvirtd_mdns_start(struct libvirtd_mdns *mdns)
} }
struct libvirtd_mdns_group *libvirtd_mdns_add_group(struct libvirtd_mdns *mdns, const char *name) { struct libvirtd_mdns_group *libvirtd_mdns_add_group(struct libvirtd_mdns *mdns, const char *name) {
struct libvirtd_mdns_group *group = malloc(sizeof(*group)); struct libvirtd_mdns_group *group;
AVAHI_DEBUG("Adding group '%s'", name); AVAHI_DEBUG("Adding group '%s'", name);
if (!group) if (VIR_ALLOC(group) < 0)
return NULL; return NULL;
memset(group, 0, sizeof(*group));
if (!(group->name = strdup(name))) { if (!(group->name = strdup(name))) {
free(group); VIR_FREE(group);
return NULL; return NULL;
} }
group->mdns = mdns; group->mdns = mdns;
@ -428,12 +427,12 @@ void libvirtd_mdns_remove_group(struct libvirtd_mdns *mdns, struct libvirtd_mdns
while (tmp) { while (tmp) {
if (tmp == group) { if (tmp == group) {
free(group->name); VIR_FREE(group->name);
if (prev) if (prev)
prev->next = group->next; prev->next = group->next;
else else
group->mdns->group = group->next; group->mdns->group = group->next;
free(group); VIR_FREE(group);
return; return;
} }
prev = tmp; prev = tmp;
@ -442,15 +441,15 @@ void libvirtd_mdns_remove_group(struct libvirtd_mdns *mdns, struct libvirtd_mdns
} }
struct libvirtd_mdns_entry *libvirtd_mdns_add_entry(struct libvirtd_mdns_group *group, const char *type, int port) { struct libvirtd_mdns_entry *libvirtd_mdns_add_entry(struct libvirtd_mdns_group *group, const char *type, int port) {
struct libvirtd_mdns_entry *entry = malloc(sizeof(*entry)); struct libvirtd_mdns_entry *entry;
AVAHI_DEBUG("Adding entry %s %d to group %s", type, port, group->name); AVAHI_DEBUG("Adding entry %s %d to group %s", type, port, group->name);
if (!entry) if (VIR_ALLOC(entry) < 0)
return NULL; return NULL;
entry->port = port; entry->port = port;
if (!(entry->type = strdup(type))) { if (!(entry->type = strdup(type))) {
free(entry); VIR_FREE(entry);
return NULL; return NULL;
} }
entry->next = group->entry; entry->next = group->entry;
@ -463,7 +462,7 @@ void libvirtd_mdns_remove_entry(struct libvirtd_mdns_group *group, struct libvir
while (tmp) { while (tmp) {
if (tmp == entry) { if (tmp == entry) {
free(entry->type); VIR_FREE(entry->type);
if (prev) if (prev)
prev->next = entry->next; prev->next = entry->next;
else else

43
qemud/qemud.c
View File

@ -56,6 +56,7 @@
#include "remote_internal.h" #include "remote_internal.h"
#include "conf.h" #include "conf.h"
#include "event.h" #include "event.h"
#include "memory.h"
#ifdef HAVE_AVAHI #ifdef HAVE_AVAHI
#include "mdns.h" #include "mdns.h"
#endif #endif
@ -466,12 +467,12 @@ static int qemudWritePidFile(const char *pidFile) {
static int qemudListenUnix(struct qemud_server *server, static int qemudListenUnix(struct qemud_server *server,
const char *path, int readonly, int auth) { const char *path, int readonly, int auth) {
struct qemud_socket *sock = calloc(1, sizeof(*sock)); struct qemud_socket *sock;
struct sockaddr_un addr; struct sockaddr_un addr;
mode_t oldmask; mode_t oldmask;
gid_t oldgrp; gid_t oldgrp;
if (!sock) { if (VIR_ALLOC(sock) < 0) {
qemudLog(QEMUD_ERR, qemudLog(QEMUD_ERR,
"%s", _("Failed to allocate memory for struct qemud_socket")); "%s", _("Failed to allocate memory for struct qemud_socket"));
return -1; return -1;
@ -611,12 +612,10 @@ remoteListenTCP (struct qemud_server *server,
struct sockaddr_storage sa; struct sockaddr_storage sa;
socklen_t salen = sizeof(sa); socklen_t salen = sizeof(sa);
sock = calloc (1, sizeof *sock); if (VIR_ALLOC(sock) < 0) {
if (!sock) {
qemudLog (QEMUD_ERR, qemudLog (QEMUD_ERR,
_("remoteListenTCP: calloc: %s"), strerror (errno)); _("remoteListenTCP: calloc: %s"), strerror (errno));
return -1; goto cleanup;
} }
sock->readonly = 0; sock->readonly = 0;
@ -629,7 +628,7 @@ remoteListenTCP (struct qemud_server *server,
sock->auth = auth; sock->auth = auth;
if (getsockname(sock->fd, (struct sockaddr *)(&sa), &salen) < 0) if (getsockname(sock->fd, (struct sockaddr *)(&sa), &salen) < 0)
return -1; goto cleanup;
if (sa.ss_family == AF_INET) if (sa.ss_family == AF_INET)
sock->port = htons(((struct sockaddr_in*)&sa)->sin_port); sock->port = htons(((struct sockaddr_in*)&sa)->sin_port);
@ -642,12 +641,12 @@ remoteListenTCP (struct qemud_server *server,
if (qemudSetCloseExec(sock->fd) < 0 || if (qemudSetCloseExec(sock->fd) < 0 ||
qemudSetNonBlock(sock->fd) < 0) qemudSetNonBlock(sock->fd) < 0)
return -1; goto cleanup;
if (listen (sock->fd, 30) < 0) { if (listen (sock->fd, 30) < 0) {
qemudLog (QEMUD_ERR, qemudLog (QEMUD_ERR,
_("remoteListenTCP: listen: %s"), strerror (errno)); _("remoteListenTCP: listen: %s"), strerror (errno));
return -1; goto cleanup;
} }
if (virEventAddHandleImpl(sock->fd, if (virEventAddHandleImpl(sock->fd,
@ -655,12 +654,17 @@ remoteListenTCP (struct qemud_server *server,
qemudDispatchServerEvent, qemudDispatchServerEvent,
server) < 0) { server) < 0) {
qemudLog(QEMUD_ERR, "%s", _("Failed to add server event callback")); qemudLog(QEMUD_ERR, "%s", _("Failed to add server event callback"));
return -1; goto cleanup;
} }
} }
return 0; return 0;
cleanup:
for (i = 0; i < nfds; ++i)
close(fds[0]);
return -1;
} }
static int qemudInitPaths(struct qemud_server *server, static int qemudInitPaths(struct qemud_server *server,
@ -712,7 +716,7 @@ static int qemudInitPaths(struct qemud_server *server,
static struct qemud_server *qemudInitialize(int sigread) { static struct qemud_server *qemudInitialize(int sigread) {
struct qemud_server *server; struct qemud_server *server;
if (!(server = calloc(1, sizeof(*server)))) { if (VIR_ALLOC(server) < 0) {
qemudLog(QEMUD_ERR, "%s", _("Failed to allocate struct qemud_server")); qemudLog(QEMUD_ERR, "%s", _("Failed to allocate struct qemud_server"));
return NULL; return NULL;
} }
@ -1092,8 +1096,7 @@ static int qemudDispatchServer(struct qemud_server *server, struct qemud_socket
return -1; return -1;
} }
client = calloc(1, sizeof(*client)); if (VIR_ALLOC(client) < 0)
if (client == NULL)
goto cleanup; goto cleanup;
client->magic = QEMUD_CLIENT_MAGIC; client->magic = QEMUD_CLIENT_MAGIC;
client->fd = fd; client->fd = fd;
@ -1733,8 +1736,7 @@ remoteConfigGetStringList(virConfPtr conf, const char *key, char ***list_arg,
switch (p->type) { switch (p->type) {
case VIR_CONF_STRING: case VIR_CONF_STRING:
list = malloc (2 * sizeof (*list)); if (VIR_ALLOC_N(list, 2) < 0) {
if (list == NULL) {
qemudLog (QEMUD_ERR, qemudLog (QEMUD_ERR,
_("failed to allocate memory for %s config list"), key); _("failed to allocate memory for %s config list"), key);
return -1; return -1;
@ -1745,7 +1747,7 @@ remoteConfigGetStringList(virConfPtr conf, const char *key, char ***list_arg,
qemudLog (QEMUD_ERR, qemudLog (QEMUD_ERR,
_("failed to allocate memory for %s config list value"), _("failed to allocate memory for %s config list value"),
key); key);
free (list); VIR_FREE(list);
return -1; return -1;
} }
break; break;
@ -1755,8 +1757,7 @@ remoteConfigGetStringList(virConfPtr conf, const char *key, char ***list_arg,
virConfValuePtr pp; virConfValuePtr pp;
for (pp = p->list; pp; pp = pp->next) for (pp = p->list; pp; pp = pp->next)
len++; len++;
list = calloc (1+len, sizeof (*list)); if (VIR_ALLOC_N(list, 1+len) < 0) {
if (list == NULL) {
qemudLog (QEMUD_ERR, qemudLog (QEMUD_ERR,
_("failed to allocate memory for %s config list"), key); _("failed to allocate memory for %s config list"), key);
return -1; return -1;
@ -1766,15 +1767,15 @@ remoteConfigGetStringList(virConfPtr conf, const char *key, char ***list_arg,
qemudLog (QEMUD_ERR, _("remoteReadConfigFile: %s: %s:" qemudLog (QEMUD_ERR, _("remoteReadConfigFile: %s: %s:"
" must be a string or list of strings\n"), " must be a string or list of strings\n"),
filename, key); filename, key);
free (list); VIR_FREE(list);
return -1; return -1;
} }
list[i] = strdup (pp->str); list[i] = strdup (pp->str);
if (list[i] == NULL) { if (list[i] == NULL) {
int j; int j;
for (j = 0 ; j < i ; j++) for (j = 0 ; j < i ; j++)
free (list[j]); VIR_FREE(list[j]);
free (list); VIR_FREE(list);
qemudLog (QEMUD_ERR, _("failed to allocate memory" qemudLog (QEMUD_ERR, _("failed to allocate memory"
" for %s config list value"), key); " for %s config list value"), key);
return -1; return -1;

205
qemud/remote.c
View File

@ -50,6 +50,7 @@
#include "internal.h" #include "internal.h"
#include "qemud.h" #include "qemud.h"
#include "memory.h"
#define DEBUG 0 #define DEBUG 0
@ -609,14 +610,19 @@ remoteDispatchNodeGetCellsFreeMemory (struct qemud_server *server ATTRIBUTE_UNUS
} }
/* Allocate return buffer. */ /* Allocate return buffer. */
ret->freeMems.freeMems_val = calloc (args->maxCells, sizeof (*(ret->freeMems.freeMems_val))); if (VIR_ALLOC_N(ret->freeMems.freeMems_val, args->maxCells) < 0) {
remoteDispatchSendError(client, req, VIR_ERR_NO_MEMORY, NULL);
return -2;
}
ret->freeMems.freeMems_len = virNodeGetCellsFreeMemory(client->conn, ret->freeMems.freeMems_len = virNodeGetCellsFreeMemory(client->conn,
(unsigned long long *)ret->freeMems.freeMems_val, (unsigned long long *)ret->freeMems.freeMems_val,
args->startCell, args->startCell,
args->maxCells); args->maxCells);
if (ret->freeMems.freeMems_len == 0) if (ret->freeMems.freeMems_len == 0) {
VIR_FREE(ret->freeMems.freeMems_val);
return -1; return -1;
}
return 0; return 0;
} }
@ -688,15 +694,14 @@ remoteDispatchDomainGetSchedulerParameters (struct qemud_server *server ATTRIBUT
remoteDispatchError (client, req, "%s", _("nparams too large")); remoteDispatchError (client, req, "%s", _("nparams too large"));
return -2; return -2;
} }
params = malloc (sizeof (*params) * nparams); if (VIR_ALLOC_N(params, nparams) < 0) {
if (params == NULL) { remoteDispatchSendError(client, req, VIR_ERR_NO_MEMORY, NULL);
remoteDispatchError (client, req, "%s", _("out of memory allocating array"));
return -2; return -2;
} }
dom = get_nonnull_domain (client->conn, args->dom); dom = get_nonnull_domain (client->conn, args->dom);
if (dom == NULL) { if (dom == NULL) {
free (params); VIR_FREE(params);
remoteDispatchError (client, req, "%s", _("domain not found")); remoteDispatchError (client, req, "%s", _("domain not found"));
return -2; return -2;
} }
@ -704,32 +709,21 @@ remoteDispatchDomainGetSchedulerParameters (struct qemud_server *server ATTRIBUT
r = virDomainGetSchedulerParameters (dom, params, &nparams); r = virDomainGetSchedulerParameters (dom, params, &nparams);
if (r == -1) { if (r == -1) {
virDomainFree(dom); virDomainFree(dom);
free (params); VIR_FREE(params);
return -1; return -1;
} }
/* Serialise the scheduler parameters. */ /* Serialise the scheduler parameters. */
ret->params.params_len = nparams; ret->params.params_len = nparams;
ret->params.params_val = malloc (sizeof (*(ret->params.params_val)) if (VIR_ALLOC_N(ret->params.params_val, nparams) < 0)
* nparams); goto oom;
if (ret->params.params_val == NULL) {
virDomainFree(dom);
free (params);
remoteDispatchError (client, req,
"%s", _("out of memory allocating return array"));
return -2;
}
for (i = 0; i < nparams; ++i) { for (i = 0; i < nparams; ++i) {
// remoteDispatchClientRequest will free this: // remoteDispatchClientRequest will free this:
ret->params.params_val[i].field = strdup (params[i].field); ret->params.params_val[i].field = strdup (params[i].field);
if (ret->params.params_val[i].field == NULL) { if (ret->params.params_val[i].field == NULL)
virDomainFree(dom); goto oom;
free (params);
remoteDispatchError (client, req,
"%s", _("out of memory allocating return array"));
return -2;
}
ret->params.params_val[i].value.type = params[i].type; ret->params.params_val[i].value.type = params[i].type;
switch (params[i].type) { switch (params[i].type) {
case VIR_DOMAIN_SCHED_FIELD_INT: case VIR_DOMAIN_SCHED_FIELD_INT:
@ -745,16 +739,23 @@ remoteDispatchDomainGetSchedulerParameters (struct qemud_server *server ATTRIBUT
case VIR_DOMAIN_SCHED_FIELD_BOOLEAN: case VIR_DOMAIN_SCHED_FIELD_BOOLEAN:
ret->params.params_val[i].value.remote_sched_param_value_u.b = params[i].value.b; break; ret->params.params_val[i].value.remote_sched_param_value_u.b = params[i].value.b; break;
default: default:
virDomainFree(dom);
free (params);
remoteDispatchError (client, req, "%s", _("unknown type")); remoteDispatchError (client, req, "%s", _("unknown type"));
return -2; goto cleanup;
} }
} }
virDomainFree(dom); virDomainFree(dom);
free (params); VIR_FREE(params);
return 0; return 0;
oom:
remoteDispatchSendError(client, req, VIR_ERR_NO_MEMORY, NULL);
cleanup:
virDomainFree(dom);
for (i = 0 ; i < nparams ; i++)
VIR_FREE(ret->params.params_val[i].field);
VIR_FREE(params);
return -2;
} }
static int static int
@ -775,9 +776,8 @@ remoteDispatchDomainSetSchedulerParameters (struct qemud_server *server ATTRIBUT
remoteDispatchError (client, req, "%s", _("nparams too large")); remoteDispatchError (client, req, "%s", _("nparams too large"));
return -2; return -2;
} }
params = malloc (sizeof (*params) * nparams); if (VIR_ALLOC_N(params, nparams)) {
if (params == NULL) { remoteDispatchSendError(client, req, VIR_ERR_NO_MEMORY, NULL);
remoteDispatchError (client, req, "%s", _("out of memory allocating array"));
return -2; return -2;
} }
@ -805,14 +805,14 @@ remoteDispatchDomainSetSchedulerParameters (struct qemud_server *server ATTRIBUT
dom = get_nonnull_domain (client->conn, args->dom); dom = get_nonnull_domain (client->conn, args->dom);
if (dom == NULL) { if (dom == NULL) {
free (params); VIR_FREE(params);
remoteDispatchError (client, req, "%s", _("domain not found")); remoteDispatchError (client, req, "%s", _("domain not found"));
return -2; return -2;
} }
r = virDomainSetSchedulerParameters (dom, params, nparams); r = virDomainSetSchedulerParameters (dom, params, nparams);
virDomainFree(dom); virDomainFree(dom);
free (params); VIR_FREE(params);
if (r == -1) return -1; if (r == -1) return -1;
return 0; return 0;
@ -914,14 +914,15 @@ remoteDispatchDomainBlockPeek (struct qemud_server *server ATTRIBUTE_UNUSED,
flags = args->flags; flags = args->flags;
if (size > REMOTE_DOMAIN_BLOCK_PEEK_BUFFER_MAX) { if (size > REMOTE_DOMAIN_BLOCK_PEEK_BUFFER_MAX) {
virDomainFree (dom);
remoteDispatchError (client, req, remoteDispatchError (client, req,
"%s", _("size > maximum buffer size")); "%s", _("size > maximum buffer size"));
return -2; return -2;
} }
ret->buffer.buffer_len = size; ret->buffer.buffer_len = size;
ret->buffer.buffer_val = malloc (size); if (VIR_ALLOC_N(ret->buffer.buffer_val, size) < 0) {
if (!ret->buffer.buffer_val) { virDomainFree (dom);
remoteDispatchError (client, req, "%s", strerror (errno)); remoteDispatchError (client, req, "%s", strerror (errno));
return -2; return -2;
} }
@ -1238,9 +1239,9 @@ remoteDispatchDomainGetVcpus (struct qemud_server *server ATTRIBUTE_UNUSED,
remote_domain_get_vcpus_args *args, remote_domain_get_vcpus_args *args,
remote_domain_get_vcpus_ret *ret) remote_domain_get_vcpus_ret *ret)
{ {
virDomainPtr dom; virDomainPtr dom = NULL;
virVcpuInfoPtr info; virVcpuInfoPtr info = NULL;
unsigned char *cpumaps; unsigned char *cpumaps = NULL;
int info_len, i; int info_len, i;
CHECK_CONN(client); CHECK_CONN(client);
@ -1263,20 +1264,25 @@ remoteDispatchDomainGetVcpus (struct qemud_server *server ATTRIBUTE_UNUSED,
} }
/* Allocate buffers to take the results. */ /* Allocate buffers to take the results. */
info = calloc (args->maxinfo, sizeof (*info)); if (VIR_ALLOC_N(info, args->maxinfo) < 0)
cpumaps = calloc (args->maxinfo * args->maplen, sizeof (*cpumaps)); goto oom;
if (VIR_ALLOC_N(cpumaps, args->maxinfo) < 0)
goto oom;
info_len = virDomainGetVcpus (dom, info_len = virDomainGetVcpus (dom,
info, args->maxinfo, info, args->maxinfo,
cpumaps, args->maplen); cpumaps, args->maplen);
if (info_len == -1) { if (info_len == -1) {
VIR_FREE(info);
VIR_FREE(cpumaps);
virDomainFree(dom); virDomainFree(dom);
return -1; return -1;
} }
/* Allocate the return buffer for info. */ /* Allocate the return buffer for info. */
ret->info.info_len = info_len; ret->info.info_len = info_len;
ret->info.info_val = calloc (info_len, sizeof (*(ret->info.info_val))); if (VIR_ALLOC_N(ret->info.info_val, info_len) < 0)
goto oom;
for (i = 0; i < info_len; ++i) { for (i = 0; i < info_len; ++i) {
ret->info.info_val[i].number = info[i].number; ret->info.info_val[i].number = info[i].number;
@ -1292,8 +1298,16 @@ remoteDispatchDomainGetVcpus (struct qemud_server *server ATTRIBUTE_UNUSED,
ret->cpumaps.cpumaps_len = args->maxinfo * args->maplen; ret->cpumaps.cpumaps_len = args->maxinfo * args->maplen;
ret->cpumaps.cpumaps_val = (char *) cpumaps; ret->cpumaps.cpumaps_val = (char *) cpumaps;
VIR_FREE(info);
virDomainFree(dom); virDomainFree(dom);
return 0; return 0;
oom:
VIR_FREE(info);
VIR_FREE(cpumaps);
virDomainFree(dom);
remoteDispatchSendError(client, req, VIR_ERR_NO_MEMORY, NULL);
return -2;
} }
static int static int
@ -1315,13 +1329,16 @@ remoteDispatchDomainMigratePrepare (struct qemud_server *server ATTRIBUTE_UNUSED
dname = args->dname == NULL ? NULL : *args->dname; dname = args->dname == NULL ? NULL : *args->dname;
/* Wacky world of XDR ... */ /* Wacky world of XDR ... */
uri_out = calloc (1, sizeof (*uri_out)); if (VIR_ALLOC(uri_out) < 0) {
remoteDispatchSendError(client, req, VIR_ERR_NO_MEMORY, NULL);
return -2;
}
r = __virDomainMigratePrepare (client->conn, &cookie, &cookielen, r = __virDomainMigratePrepare (client->conn, &cookie, &cookielen,
uri_in, uri_out, uri_in, uri_out,
args->flags, dname, args->resource); args->flags, dname, args->resource);
if (r == -1) { if (r == -1) {
free(uri_out); VIR_FREE(uri_out);
return -1; return -1;
} }
@ -1332,7 +1349,7 @@ remoteDispatchDomainMigratePrepare (struct qemud_server *server ATTRIBUTE_UNUSED
ret->cookie.cookie_val = cookie; ret->cookie.cookie_val = cookie;
if (*uri_out == NULL) { if (*uri_out == NULL) {
ret->uri_out = NULL; ret->uri_out = NULL;
free(uri_out); VIR_FREE(uri_out);
} else { } else {
ret->uri_out = uri_out; ret->uri_out = uri_out;
} }
@ -1409,12 +1426,18 @@ remoteDispatchListDefinedDomains (struct qemud_server *server ATTRIBUTE_UNUSED,
} }
/* Allocate return buffer. */ /* Allocate return buffer. */
ret->names.names_val = calloc (args->maxnames, sizeof (*(ret->names.names_val))); if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
remoteDispatchSendError(client, req, VIR_ERR_NO_MEMORY, NULL);
return -2;
}
ret->names.names_len = ret->names.names_len =
virConnectListDefinedDomains (client->conn, virConnectListDefinedDomains (client->conn,
ret->names.names_val, args->maxnames); ret->names.names_val, args->maxnames);
if (ret->names.names_len == -1) return -1; if (ret->names.names_len == -1) {
VIR_FREE(ret->names.names_val);
return -1;
}
return 0; return 0;
} }
@ -1817,12 +1840,18 @@ remoteDispatchListDefinedNetworks (struct qemud_server *server ATTRIBUTE_UNUSED,
} }
/* Allocate return buffer. */ /* Allocate return buffer. */
ret->names.names_val = calloc (args->maxnames, sizeof (*(ret->names.names_val))); if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
remoteDispatchSendError(client, req, VIR_ERR_NO_MEMORY, NULL);
return -2;
}
ret->names.names_len = ret->names.names_len =
virConnectListDefinedNetworks (client->conn, virConnectListDefinedNetworks (client->conn,
ret->names.names_val, args->maxnames); ret->names.names_val, args->maxnames);
if (ret->names.names_len == -1) return -1; if (ret->names.names_len == -1) {
VIR_FREE(ret->names.names_val);
return -1;
}
return 0; return 0;
} }
@ -1843,11 +1872,17 @@ remoteDispatchListDomains (struct qemud_server *server ATTRIBUTE_UNUSED,
} }
/* Allocate return buffer. */ /* Allocate return buffer. */
ret->ids.ids_val = calloc (args->maxids, sizeof (*(ret->ids.ids_val))); if (VIR_ALLOC_N(ret->ids.ids_val, args->maxids) < 0) {
remoteDispatchSendError(client, req, VIR_ERR_NO_MEMORY, NULL);
return -2;
}
ret->ids.ids_len = virConnectListDomains (client->conn, ret->ids.ids_len = virConnectListDomains (client->conn,
ret->ids.ids_val, args->maxids); ret->ids.ids_val, args->maxids);
if (ret->ids.ids_len == -1) return -1; if (ret->ids.ids_len == -1) {
VIR_FREE(ret->ids.ids_val);
return -1;
}
return 0; return 0;
} }
@ -1868,12 +1903,18 @@ remoteDispatchListNetworks (struct qemud_server *server ATTRIBUTE_UNUSED,
} }
/* Allocate return buffer. */ /* Allocate return buffer. */
ret->names.names_val = calloc (args->maxnames, sizeof (*(ret->names.names_val))); if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
remoteDispatchSendError(client, req, VIR_ERR_NO_MEMORY, NULL);
return -2;
}
ret->names.names_len = ret->names.names_len =
virConnectListNetworks (client->conn, virConnectListNetworks (client->conn,
ret->names.names_val, args->maxnames); ret->names.names_val, args->maxnames);
if (ret->names.names_len == -1) return -1; if (ret->names.names_len == -1) {
VIR_FREE(ret->names.names_len);
return -1;
}
return 0; return 0;
} }
@ -2176,8 +2217,8 @@ remoteDispatchAuthList (struct qemud_server *server ATTRIBUTE_UNUSED,
remote_auth_list_ret *ret) remote_auth_list_ret *ret)
{ {
ret->types.types_len = 1; ret->types.types_len = 1;
if ((ret->types.types_val = calloc (ret->types.types_len, sizeof (*(ret->types.types_val)))) == NULL) { if (VIR_ALLOC_N(ret->types.types_val, ret->types.types_len) < 0) {
remoteDispatchSendError(client, req, VIR_ERR_NO_MEMORY, "auth types"); remoteDispatchSendError(client, req, VIR_ERR_NO_MEMORY, NULL);
return -2; return -2;
} }
ret->types.types_val[0] = client->auth; ret->types.types_val[0] = client->auth;
@ -2206,9 +2247,8 @@ static char *addrToString(struct qemud_client *client,
return NULL; return NULL;
} }
addr = malloc(strlen(host) + 1 + strlen(port) + 1); if (VIR_ALLOC_N(addr, strlen(host) + 1 + strlen(port) + 1) < 0) {
if (!addr) { remoteDispatchSendError(client, req, VIR_ERR_NO_MEMORY, NULL);
remoteDispatchError(client, req, "%s", _("cannot allocate address"));
return NULL; return NULL;
} }
@ -2264,11 +2304,11 @@ remoteDispatchAuthSaslInit (struct qemud_server *server ATTRIBUTE_UNUSED,
if (getpeername(client->fd, (struct sockaddr*)&sa, &salen) < 0) { if (getpeername(client->fd, (struct sockaddr*)&sa, &salen) < 0) {
remoteDispatchError(client, req, _("failed to get peer address %d (%s)"), remoteDispatchError(client, req, _("failed to get peer address %d (%s)"),
errno, strerror(errno)); errno, strerror(errno));
free(localAddr); VIR_FREE(localAddr);
return -2; return -2;
} }
if ((remoteAddr = addrToString(client, req, &sa, salen)) == NULL) { if ((remoteAddr = addrToString(client, req, &sa, salen)) == NULL) {
free(localAddr); VIR_FREE(localAddr);
return -2; return -2;
} }
@ -2280,8 +2320,8 @@ remoteDispatchAuthSaslInit (struct qemud_server *server ATTRIBUTE_UNUSED,
NULL, /* XXX Callbacks */ NULL, /* XXX Callbacks */
SASL_SUCCESS_DATA, SASL_SUCCESS_DATA,
&client->saslconn); &client->saslconn);
free(localAddr); VIR_FREE(localAddr);
free(remoteAddr); VIR_FREE(remoteAddr);
if (err != SASL_OK) { if (err != SASL_OK) {
qemudLog(QEMUD_ERR, _("sasl context setup failed %d (%s)"), qemudLog(QEMUD_ERR, _("sasl context setup failed %d (%s)"),
err, sasl_errstring(err, NULL, NULL)); err, sasl_errstring(err, NULL, NULL));
@ -2525,10 +2565,8 @@ remoteDispatchAuthSaslStart (struct qemud_server *server,
/* NB, distinction of NULL vs "" is *critical* in SASL */ /* NB, distinction of NULL vs "" is *critical* in SASL */
if (serverout) { if (serverout) {
ret->data.data_val = malloc(serveroutlen); if (VIR_ALLOC_N(ret->data.data_val, serveroutlen) < 0) {
if (!ret->data.data_val) { remoteDispatchSendError(client, req, VIR_ERR_NO_MEMORY, NULL);
remoteDispatchError (client, req,
"%s", _("out of memory allocating array"));
return -2; return -2;
} }
memcpy(ret->data.data_val, serverout, serveroutlen); memcpy(ret->data.data_val, serverout, serveroutlen);
@ -2606,10 +2644,8 @@ remoteDispatchAuthSaslStep (struct qemud_server *server,
/* NB, distinction of NULL vs "" is *critical* in SASL */ /* NB, distinction of NULL vs "" is *critical* in SASL */
if (serverout) { if (serverout) {
ret->data.data_val = malloc(serveroutlen); if (VIR_ALLOC_N(ret->data.data_val, serveroutlen) < 0) {
if (!ret->data.data_val) { remoteDispatchSendError(client, req, VIR_ERR_NO_MEMORY, NULL);
remoteDispatchError (client, req,
"%s", _("out of memory allocating array"));
return -2; return -2;
} }
memcpy(ret->data.data_val, serverout, serveroutlen); memcpy(ret->data.data_val, serverout, serveroutlen);
@ -2826,12 +2862,18 @@ remoteDispatchListDefinedStoragePools (struct qemud_server *server ATTRIBUTE_UNU
} }
/* Allocate return buffer. */ /* Allocate return buffer. */
ret->names.names_val = calloc (args->maxnames, sizeof (char *)); if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
remoteDispatchSendError(client, req, VIR_ERR_NO_MEMORY, NULL);
return -2;
}
ret->names.names_len = ret->names.names_len =
virConnectListDefinedStoragePools (client->conn, virConnectListDefinedStoragePools (client->conn,
ret->names.names_val, args->maxnames); ret->names.names_val, args->maxnames);
if (ret->names.names_len == -1) return -1; if (ret->names.names_len == -1) {
VIR_FREE(ret->names.names_val);
return -1;
}
return 0; return 0;
} }
@ -2852,12 +2894,18 @@ remoteDispatchListStoragePools (struct qemud_server *server ATTRIBUTE_UNUSED,
} }
/* Allocate return buffer. */ /* Allocate return buffer. */
ret->names.names_val = calloc (args->maxnames, sizeof (char *)); if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
remoteDispatchSendError(client, req, VIR_ERR_NO_MEMORY, NULL);
return -2;
}
ret->names.names_len = ret->names.names_len =
virConnectListStoragePools (client->conn, virConnectListStoragePools (client->conn,
ret->names.names_val, args->maxnames); ret->names.names_val, args->maxnames);
if (ret->names.names_len == -1) return -1; if (ret->names.names_len == -1) {
VIR_FREE(ret->names.names_val);
return -1;
}
return 0; return 0;
} }
@ -3261,13 +3309,20 @@ remoteDispatchStoragePoolListVolumes (struct qemud_server *server ATTRIBUTE_UNUS
} }
/* Allocate return buffer. */ /* Allocate return buffer. */
ret->names.names_val = calloc (args->maxnames, sizeof (char *)); if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
virStoragePoolFree(pool);
remoteDispatchSendError(client, req, VIR_ERR_NO_MEMORY, NULL);
return -2;
}
ret->names.names_len = ret->names.names_len =
virStoragePoolListVolumes (pool, virStoragePoolListVolumes (pool,
ret->names.names_val, args->maxnames); ret->names.names_val, args->maxnames);
virStoragePoolFree(pool); virStoragePoolFree(pool);
if (ret->names.names_len == -1) return -1; if (ret->names.names_len == -1) {
VIR_FREE(ret->names.names_val);
return -1;
}
return 0; return 0;
} }

5
src/libvirt_sym.version
View File

@ -191,5 +191,10 @@
__virMacAddrCompare; __virMacAddrCompare;
__virAlloc;
__virAllocN;
__virReallocN;
__virFree;
local: *; local: *;
}; };

8
src/memory.c
View File

@ -104,7 +104,7 @@ static int virAllocTestFail(void)
* *
* Returns -1 on failure to allocate, zero on success * Returns -1 on failure to allocate, zero on success
*/ */
int virAlloc(void *ptrptr, size_t size) int __virAlloc(void *ptrptr, size_t size)
{ {
#if TEST_OOM #if TEST_OOM
if (virAllocTestFail()) { if (virAllocTestFail()) {
@ -137,7 +137,7 @@ int virAlloc(void *ptrptr, size_t size)
* *
* Returns -1 on failure to allocate, zero on success * Returns -1 on failure to allocate, zero on success
*/ */
int virAllocN(void *ptrptr, size_t size, size_t count) int __virAllocN(void *ptrptr, size_t size, size_t count)
{ {
#if TEST_OOM #if TEST_OOM
if (virAllocTestFail()) { if (virAllocTestFail()) {
@ -171,7 +171,7 @@ int virAllocN(void *ptrptr, size_t size, size_t count)
* *
* Returns -1 on failure to allocate, zero on success * Returns -1 on failure to allocate, zero on success
*/ */
int virReallocN(void *ptrptr, size_t size, size_t count) int __virReallocN(void *ptrptr, size_t size, size_t count)
{ {
void *tmp; void *tmp;
#if TEST_OOM #if TEST_OOM
@ -203,7 +203,7 @@ int virReallocN(void *ptrptr, size_t size, size_t count)
* the 'ptrptr' variable. After release, 'ptrptr' will be * the 'ptrptr' variable. After release, 'ptrptr' will be
* updated to point to NULL. * updated to point to NULL.
*/ */
void virFree(void *ptrptr) void __virFree(void *ptrptr)
{ {
free(*(void**)ptrptr); free(*(void**)ptrptr);
*(void**)ptrptr = NULL; *(void**)ptrptr = NULL;

16
src/memory.h
View File

@ -26,10 +26,10 @@
#include "internal.h" #include "internal.h"
/* Don't call these directly - use the macros below */ /* Don't call these directly - use the macros below */
int virAlloc(void *ptrptr, size_t size) ATTRIBUTE_RETURN_CHECK; int __virAlloc(void *ptrptr, size_t size) ATTRIBUTE_RETURN_CHECK;
int virAllocN(void *ptrptr, size_t size, size_t count) ATTRIBUTE_RETURN_CHECK; int __virAllocN(void *ptrptr, size_t size, size_t count) ATTRIBUTE_RETURN_CHECK;
int virReallocN(void *ptrptr, size_t size, size_t count) ATTRIBUTE_RETURN_CHECK; int __virReallocN(void *ptrptr, size_t size, size_t count) ATTRIBUTE_RETURN_CHECK;
void virFree(void *ptrptr); void __virFree(void *ptrptr);
/** /**
* VIR_ALLOC: * VIR_ALLOC:
@ -41,7 +41,7 @@ void virFree(void *ptrptr);
* *
* Returns -1 on failure, 0 on success * Returns -1 on failure, 0 on success
*/ */
#define VIR_ALLOC(ptr) virAlloc(&(ptr), sizeof(*(ptr))) #define VIR_ALLOC(ptr) __virAlloc(&(ptr), sizeof(*(ptr)))
/** /**
* VIR_ALLOC_N: * VIR_ALLOC_N:
@ -54,7 +54,7 @@ void virFree(void *ptrptr);
* *
* Returns -1 on failure, 0 on success * Returns -1 on failure, 0 on success
*/ */
#define VIR_ALLOC_N(ptr, count) virAllocN(&(ptr), sizeof(*(ptr)), (count)) #define VIR_ALLOC_N(ptr, count) __virAllocN(&(ptr), sizeof(*(ptr)), (count))
/** /**
* VIR_REALLOC_N: * VIR_REALLOC_N:
@ -67,7 +67,7 @@ void virFree(void *ptrptr);
* *
* Returns -1 on failure, 0 on success * Returns -1 on failure, 0 on success
*/ */
#define VIR_REALLOC_N(ptr, count) virReallocN(&(ptr), sizeof(*(ptr)), (count)) #define VIR_REALLOC_N(ptr, count) __virReallocN(&(ptr), sizeof(*(ptr)), (count))
/** /**
* VIR_FREE: * VIR_FREE:
@ -76,7 +76,7 @@ void virFree(void *ptrptr);
* Free the memory stored in 'ptr' and update to point * Free the memory stored in 'ptr' and update to point
* to NULL. * to NULL.
*/ */
#define VIR_FREE(ptr) virFree(&(ptr)); #define VIR_FREE(ptr) __virFree(&(ptr))
#if TEST_OOM #if TEST_OOM