External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2024-07-11 12:25:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

Turn virNetClient* into virObject instances

Browse Source 
Make all the virNetClient* objects use virObject APIs for
reference counting

Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
This commit is contained in:
Daniel P. Berrange 2012-07-30 10:14:56 +01:00
parent 958499b0c1
commit 05e4e7b46e
12 changed files with 111 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
cfg.mk
View File

@ -145,9 +145,6 @@ useless_free_options = \
--name=virJSONValueFree \
--name=virLastErrFreeData \
--name=virNetMessageFree \
--name=virNetClientFree \
--name=virNetClientProgramFree \
--name=virNetClientStreamFree \
--name=virNetServerMDNSFree \
--name=virNetServerMDNSEntryFree \
--name=virNetServerMDNSGroupFree \

6
src/libvirt_private.syms
View File

@ -1304,7 +1304,6 @@ virNetClientAddProgram;
virNetClientAddStream;
virNetClientClose;
virNetClientDupFD;
virNetClientFree;
virNetClientGetFD;
virNetClientGetTLSKeySize;
virNetClientHasPassFD;
@ -1318,7 +1317,6 @@ virNetClientNewExternal;
virNetClientNewSSH;
virNetClientNewTCP;
virNetClientNewUNIX;
virNetClientRef;
virNetClientRemoteAddrString;
virNetClientRemoveStream;
virNetClientSendNoReply;
@ -1333,12 +1331,10 @@ virNetClientSetTLSSession;
# virnetclientprogram.h
virNetClientProgramCall;
virNetClientProgramDispatch;
virNetClientProgramFree;
virNetClientProgramGetProgram;
virNetClientProgramGetVersion;
virNetClientProgramMatches;
virNetClientProgramNew;
virNetClientProgramRef;
# virnetclientstream.h
@ -1346,13 +1342,11 @@ virNetClientStreamEOF;
virNetClientStreamEventAddCallback;
virNetClientStreamEventRemoveCallback;
virNetClientStreamEventUpdateCallback;
virNetClientStreamFree;
virNetClientStreamMatches;
virNetClientStreamNew;
virNetClientStreamQueuePacket;
virNetClientStreamRaiseError;
virNetClientStreamRecvPacket;
virNetClientStreamRef;
virNetClientStreamSendPacket;
virNetClientStreamSetError;

4
src/libvirt_probes.d
View File

@ -40,9 +40,7 @@ provider libvirt {
# file: src/rpc/virnetclient.c
# prefix: rpc
probe rpc_client_new(void *client, int refs, void *sock);
probe rpc_client_ref(void *client, int refs);
probe rpc_client_free(void *client, int refs);
probe rpc_client_new(void *client, void *sock);
probe rpc_client_msg_tx_queue(void *client, int len, int prog, int vers, int proc, int type, int status, int serial);
probe rpc_client_msg_rx(void *client, int len, int prog, int vers, int proc, int type, int status, int serial);

4
src/lxc/lxc_monitor.c
View File

@ -170,7 +170,7 @@ static void virLXCMonitorFree(virLXCMonitorPtr mon)
if (mon->cb && mon->cb->destroy)
(mon->cb->destroy)(mon, mon->vm);
virMutexDestroy(&mon->lock);
virNetClientProgramFree(mon->program);
virObjectUnref(mon->program);
VIR_FREE(mon);
}
@ -199,7 +199,7 @@ void virLXCMonitorClose(virLXCMonitorPtr mon)
{
if (mon->client) {
virNetClientClose(mon->client);
virNetClientFree(mon->client);
virObjectUnref(mon->client);
mon->client = NULL;
}
}

20
src/remote/remote_driver.c
View File

@ -792,10 +792,10 @@ doRemoteOpen (virConnectPtr conn,
virReportOOMError();
failed:
virNetClientProgramFree(priv->remoteProgram);
virNetClientProgramFree(priv->qemuProgram);
virObjectUnref(priv->remoteProgram);
virObjectUnref(priv->qemuProgram);
virNetClientClose(priv->client);
virNetClientFree(priv->client);
virObjectUnref(priv->client);
priv->client = NULL;
VIR_FREE(priv->hostname);
@ -946,10 +946,10 @@ doRemoteClose (virConnectPtr conn, struct private_data *priv)
virObjectUnref(priv->tls);
priv->tls = NULL;
virNetClientClose(priv->client);
virNetClientFree(priv->client);
virObjectUnref(priv->client);
priv->client = NULL;
virNetClientProgramFree(priv->remoteProgram);
virNetClientProgramFree(priv->qemuProgram);
virObjectUnref(priv->remoteProgram);
virObjectUnref(priv->qemuProgram);
priv->remoteProgram = priv->qemuProgram = NULL;
/* Free hostname copy */
@ -4171,7 +4171,7 @@ remoteStreamFinish(virStreamPtr st)
cleanup:
virNetClientRemoveStream(priv->client, privst);
virNetClientStreamFree(privst);
virObjectUnref(privst);
st->privateData = NULL;
st->driver = NULL;
@ -4206,7 +4206,7 @@ remoteStreamAbort(virStreamPtr st)
cleanup:
virNetClientRemoveStream(priv->client, privst);
virNetClientStreamFree(privst);
virObjectUnref(privst);
st->privateData = NULL;
st->driver = NULL;
@ -4507,7 +4507,7 @@ remoteDomainMigratePrepareTunnel3(virConnectPtr dconn,
goto done;
if (virNetClientAddStream(priv->client, netst) < 0) {
virNetClientStreamFree(netst);
virObjectUnref(netst);
goto done;
}
@ -4525,7 +4525,7 @@ remoteDomainMigratePrepareTunnel3(virConnectPtr dconn,
(xdrproc_t) xdr_remote_domain_migrate_prepare_tunnel3_args, (char *) &args,
(xdrproc_t) xdr_remote_domain_migrate_prepare_tunnel3_ret, (char *) &ret) == -1) {
virNetClientRemoveStream(priv->client, netst);
virNetClientStreamFree(netst);
virObjectUnref(netst);
goto done;
}

4
src/rpc/gendispatch.pl
View File

@ -1450,7 +1450,7 @@ elsif ($opt_k) {
print " goto done;\n";
print "\n";
print " if (virNetClientAddStream(priv->client, netst) < 0) {\n";
print " virNetClientStreamFree(netst);\n";
print " virObjectUnref(netst);\n";
print " goto done;\n";
print " }";
print "\n";
@ -1526,7 +1526,7 @@ elsif ($opt_k) {
if ($call->{streamflag} ne "none") {
print " virNetClientRemoveStream(priv->client, netst);\n";
print " virNetClientStreamFree(netst);\n";
print " virObjectUnref(netst);\n";
print " st->driver = NULL;\n";
print " st->privateData = NULL;\n";
}

98
src/rpc/virnetclient.c
View File

@ -63,7 +63,7 @@ struct _virNetClientCall {
struct _virNetClient {
int refs;
virObject object;
virMutex lock;
@ -109,6 +109,21 @@ struct _virNetClient {
};
static virClassPtr virNetClientClass;
static void virNetClientDispose(void *obj);
static int virNetClientOnceInit(void)
{
if (!(virNetClientClass = virClassNew("virNetClient",
sizeof(virNetClient),
virNetClientDispose)))
return -1;
return 0;
}
VIR_ONCE_GLOBAL_INIT(virNetClient)
static void virNetClientIOEventLoopPassTheBuck(virNetClientPtr client,
virNetClientCallPtr thiscall);
static int virNetClientQueueNonBlocking(virNetClientPtr client,
@ -237,13 +252,6 @@ static bool virNetClientCallMatchPredicate(virNetClientCallPtr head,
}
static void virNetClientEventFree(void *opaque)
{
virNetClientPtr client = opaque;
virNetClientFree(client);
}
bool
virNetClientKeepAliveIsSupported(virNetClientPtr client)
{
@ -303,20 +311,23 @@ static virNetClientPtr virNetClientNew(virNetSocketPtr sock,
int wakeupFD[2] = { -1, -1 };
virKeepAlivePtr ka = NULL;
if (virNetClientInitialize() < 0)
return NULL;
if (pipe2(wakeupFD, O_CLOEXEC) < 0) {
virReportSystemError(errno, "%s",
_("unable to make pipe"));
goto error;
}
if (VIR_ALLOC(client) < 0)
goto no_memory;
client->refs = 1;
if (virMutexInit(&client->lock) < 0)
if (!(client = virObjectNew(virNetClientClass)))
goto error;
if (virMutexInit(&client->lock) < 0) {
VIR_FREE(client);
goto error;
}
client->sock = sock;
client->wakeupReadFD = wakeupFD[0];
client->wakeupSendFD = wakeupFD[1];
@ -327,13 +338,13 @@ static virNetClientPtr virNetClientNew(virNetSocketPtr sock,
goto no_memory;
/* Set up a callback to listen on the socket data */
client->refs++;
virObjectRef(client);
if (virNetSocketAddIOCallback(client->sock,
VIR_EVENT_HANDLE_READABLE,
virNetClientIncomingEvent,
client,
virNetClientEventFree) < 0) {
client->refs--;
virObjectFreeCallback) < 0) {
virObjectUnref(client);
VIR_DEBUG("Failed to add event watch, disabling events and support for"
" keepalive messages");
} else {
@ -342,16 +353,16 @@ static virNetClientPtr virNetClientNew(virNetSocketPtr sock,
if (!(ka = virKeepAliveNew(-1, 0, client,
virNetClientKeepAliveSendCB,
virNetClientKeepAliveDeadCB,
virNetClientEventFree)))
virObjectFreeCallback)))
goto error;
/* keepalive object has a reference to client */
client->refs++;
virObjectRef(client);
}
client->keepalive = ka;
PROBE(RPC_CLIENT_NEW,
"client=%p refs=%d sock=%p",
client, client->refs, client->sock);
"client=%p sock=%p",
client, client->sock);
return client;
no_memory:
@ -363,7 +374,7 @@ error:
virKeepAliveStop(ka);
virObjectUnref(ka);
}
virNetClientFree(client);
virObjectUnref(client);
return NULL;
}
@ -422,17 +433,6 @@ virNetClientPtr virNetClientNewExternal(const char **cmdargv)
}
void virNetClientRef(virNetClientPtr client)
{
virNetClientLock(client);
client->refs++;
PROBE(RPC_CLIENT_REF,
"client=%p refs=%d",
client, client->refs);
virNetClientUnlock(client);
}
int virNetClientGetFD(virNetClientPtr client)
{
int fd;
@ -463,28 +463,16 @@ bool virNetClientHasPassFD(virNetClientPtr client)
}
void virNetClientFree(virNetClientPtr client)
void virNetClientDispose(void *obj)
{
virNetClientPtr client = obj;
int i;
if (!client)
return;
virNetClientLock(client);
PROBE(RPC_CLIENT_FREE,
"client=%p refs=%d",
client, client->refs);
client->refs--;
if (client->refs > 0) {
virNetClientUnlock(client);
return;
}
if (client->closeFf)
client->closeFf(client->closeOpaque);
for (i = 0 ; i < client->nprograms ; i++)
virNetClientProgramFree(client->programs[i]);
virObjectUnref(client->programs[i]);
VIR_FREE(client->programs);
VIR_FORCE_CLOSE(client->wakeupSendFD);
@ -504,8 +492,6 @@ void virNetClientFree(virNetClientPtr client)
virNetClientUnlock(client);
virMutexDestroy(&client->lock);
VIR_FREE(client);
}
@ -546,7 +532,7 @@ virNetClientCloseLocked(virNetClientPtr client)
virNetClientCloseFunc closeCb = client->closeCb;
void *closeOpaque = client->closeOpaque;
int closeReason = client->closeReason;
client->refs++;
virObjectRef(client);
virNetClientUnlock(client);
if (ka) {
@ -557,7 +543,7 @@ virNetClientCloseLocked(virNetClientPtr client)
closeCb(client, closeReason, closeOpaque);
virNetClientLock(client);
client->refs--;
virObjectUnref(client);
}
}
@ -754,8 +740,7 @@ int virNetClientAddProgram(virNetClientPtr client,
if (VIR_EXPAND_N(client->programs, client->nprograms, 1) < 0)
goto no_memory;
client->programs[client->nprograms-1] = prog;
virNetClientProgramRef(prog);
client->programs[client->nprograms-1] = virObjectRef(prog);
virNetClientUnlock(client);
return 0;
@ -775,8 +760,7 @@ int virNetClientAddStream(virNetClientPtr client,
if (VIR_EXPAND_N(client->streams, client->nstreams, 1) < 0)
goto no_memory;
client->streams[client->nstreams-1] = st;
virNetClientStreamRef(st);
client->streams[client->nstreams-1] = virObjectRef(st);
virNetClientUnlock(client);
return 0;
@ -810,7 +794,7 @@ void virNetClientRemoveStream(virNetClientPtr client,
VIR_FREE(client->streams);
client->nstreams = 0;
}
virNetClientStreamFree(st);
virObjectUnref(st);
cleanup:
virNetClientUnlock(client);

4
src/rpc/virnetclient.h
View File

@ -30,6 +30,7 @@
# endif
# include "virnetclientprogram.h"
# include "virnetclientstream.h"
# include "virobject.h"
virNetClientPtr virNetClientNewUNIX(const char *path,
@ -60,8 +61,6 @@ void virNetClientSetCloseCallback(virNetClientPtr client,
void *opaque,
virFreeCallback ff);
void virNetClientRef(virNetClientPtr client);
int virNetClientGetFD(virNetClientPtr client);
int virNetClientDupFD(virNetClientPtr client, bool cloexec);
@ -105,7 +104,6 @@ const char *virNetClientRemoteAddrString(virNetClientPtr client);
int virNetClientGetTLSKeySize(virNetClientPtr client);
void virNetClientFree(virNetClientPtr client);
void virNetClientClose(virNetClientPtr client);
bool virNetClientKeepAliveIsSupported(virNetClientPtr client);

43
src/rpc/virnetclientprogram.c
View File

@ -33,11 +33,12 @@
#include "logging.h"
#include "util.h"
#include "virfile.h"
#include "threads.h"
#define VIR_FROM_THIS VIR_FROM_RPC
struct _virNetClientProgram {
int refs;
virObject object;
unsigned program;
unsigned version;
@ -46,6 +47,22 @@ struct _virNetClientProgram {
void *eventOpaque;
};
static virClassPtr virNetClientProgramClass;
static void virNetClientProgramDispose(void *obj);
static int virNetClientProgramOnceInit(void)
{
if (!(virNetClientProgramClass = virClassNew("virNetClientProgram",
sizeof(virNetClientProgram),
virNetClientProgramDispose)))
return -1;
return 0;
}
VIR_ONCE_GLOBAL_INIT(virNetClientProgram)
virNetClientProgramPtr virNetClientProgramNew(unsigned program,
unsigned version,
virNetClientProgramEventPtr events,
@ -54,12 +71,12 @@ virNetClientProgramPtr virNetClientProgramNew(unsigned program,
{
virNetClientProgramPtr prog;
if (VIR_ALLOC(prog) < 0) {
virReportOOMError();
if (virNetClientProgramInitialize() < 0)
return NULL;
if (!(prog = virObjectNew(virNetClientProgramClass)))
return NULL;
}
prog->refs = 1;
prog->program = program;
prog->version = version;
prog->events = events;
@ -70,22 +87,8 @@ virNetClientProgramPtr virNetClientProgramNew(unsigned program,
}
void virNetClientProgramRef(virNetClientProgramPtr prog)
void virNetClientProgramDispose(void *obj ATTRIBUTE_UNUSED)
{
prog->refs++;
}
void virNetClientProgramFree(virNetClientProgramPtr prog)
{
if (!prog)
return;
prog->refs--;
if (prog->refs > 0)
return;
VIR_FREE(prog);
}

5
src/rpc/virnetclientprogram.h
View File

@ -27,6 +27,7 @@
# include <rpc/xdr.h>
# include "virnetmessage.h"
# include "virobject.h"
typedef struct _virNetClient virNetClient;
typedef virNetClient *virNetClientPtr;
@ -62,10 +63,6 @@ virNetClientProgramPtr virNetClientProgramNew(unsigned program,
unsigned virNetClientProgramGetProgram(virNetClientProgramPtr prog);
unsigned virNetClientProgramGetVersion(virNetClientProgramPtr prog);
void virNetClientProgramRef(virNetClientProgramPtr prog);
void virNetClientProgramFree(virNetClientProgramPtr prog);
int virNetClientProgramMatches(virNetClientProgramPtr prog,
virNetMessagePtr msg);

65
src/rpc/virnetclientstream.c
View File

@ -33,12 +33,13 @@
#define VIR_FROM_THIS VIR_FROM_RPC
struct _virNetClientStream {
virObject object;
virMutex lock;
virNetClientProgramPtr prog;
int proc;
unsigned serial;
int refs;
virError err;
@ -63,6 +64,22 @@ struct _virNetClientStream {
};
static virClassPtr virNetClientStreamClass;
static void virNetClientStreamDispose(void *obj);
static int virNetClientStreamOnceInit(void)
{
if (!(virNetClientStreamClass = virClassNew("virNetClientStream",
sizeof(virNetClientStream),
virNetClientStreamDispose)))
return -1;
return 0;
}
VIR_ONCE_GLOBAL_INIT(virNetClientStream)
static void
virNetClientStreamEventTimerUpdate(virNetClientStreamPtr st)
{
@ -119,26 +136,18 @@ virNetClientStreamEventTimer(int timer ATTRIBUTE_UNUSED, void *opaque)
}
static void
virNetClientStreamEventTimerFree(void *opaque)
{
virNetClientStreamPtr st = opaque;
virNetClientStreamFree(st);
}
virNetClientStreamPtr virNetClientStreamNew(virNetClientProgramPtr prog,
int proc,
unsigned serial)
{
virNetClientStreamPtr st;
if (VIR_ALLOC(st) < 0) {
virReportOOMError();
if (virNetClientStreamInitialize() < 0)
return NULL;
if (!(st = virObjectNew(virNetClientStreamClass)))
return NULL;
}
st->refs = 1;
st->prog = prog;
st->proc = proc;
st->serial = serial;
@ -150,35 +159,19 @@ virNetClientStreamPtr virNetClientStreamNew(virNetClientProgramPtr prog,
return NULL;
}
virNetClientProgramRef(prog);
virObjectRef(prog);
return st;
}
void virNetClientStreamRef(virNetClientStreamPtr st)
void virNetClientStreamDispose(void *obj)
{
virMutexLock(&st->lock);
st->refs++;
virMutexUnlock(&st->lock);
}
void virNetClientStreamFree(virNetClientStreamPtr st)
{
virMutexLock(&st->lock);
st->refs--;
if (st->refs > 0) {
virMutexUnlock(&st->lock);
return;
}
virMutexUnlock(&st->lock);
virNetClientStreamPtr st = obj;
virResetError(&st->err);
VIR_FREE(st->incoming);
virMutexDestroy(&st->lock);
virNetClientProgramFree(st->prog);
VIR_FREE(st);
virObjectUnref(st->prog);
}
bool virNetClientStreamMatches(virNetClientStreamPtr st,
@ -454,13 +447,13 @@ int virNetClientStreamEventAddCallback(virNetClientStreamPtr st,
goto cleanup;
}
st->refs++;
virObjectRef(st);
if ((st->cbTimer =
virEventAddTimeout(-1,
virNetClientStreamEventTimer,
st,
virNetClientStreamEventTimerFree)) < 0) {
st->refs--;
virObjectFreeCallback)) < 0) {
virObjectUnref(st);
goto cleanup;
}

5
src/rpc/virnetclientstream.h
View File

@ -24,6 +24,7 @@
# define __VIR_NET_CLIENT_STREAM_H__
# include "virnetclientprogram.h"
# include "virobject.h"
typedef struct _virNetClientStream virNetClientStream;
typedef virNetClientStream *virNetClientStreamPtr;
@ -35,10 +36,6 @@ virNetClientStreamPtr virNetClientStreamNew(virNetClientProgramPtr prog,
int proc,
unsigned serial);
void virNetClientStreamRef(virNetClientStreamPtr st);
void virNetClientStreamFree(virNetClientStreamPtr st);
bool virNetClientStreamRaiseError(virNetClientStreamPtr st);
int virNetClientStreamSetError(virNetClientStreamPtr st,