[libvirt] [PATCH 4/7] Convert all rpc classes over to virObjectLockable

From: "Daniel P. Berrange" <berrange(a)redhat.com&gt; --- src/rpc/virkeepalive.c | 55 +++++----------- src/rpc/virnetclient.c | 128 +++++++++++++++-------------------- src/rpc/virnetclientstream.c | 67 ++++++++----------- src/rpc/virnetsaslcontext.c | 109 ++++++++++-------------------- src/rpc/virnetserver.c | 117 ++++++++++++++------------------ src/rpc/virnetserverclient.c | 154 +++++++++++++++++++------------------------ src/rpc/virnetsocket.c | 125 ++++++++++++++++------------------- src/rpc/virnetsshsession.c | 82 +++++++++++------------ src/rpc/virnettlscontext.c | 64 +++++++----------- 9 files changed, 366 insertions(+), 535 deletions(-) diff --git a/src/rpc/virkeepalive.c b/src/rpc/virkeepalive.c index 04962d4..5fe9e8b 100644 --- a/src/rpc/virkeepalive.c +++ b/src/rpc/virkeepalive.c @@ -35,9 +35,7 @@ #define VIR_FROM_THIS VIR_FROM_RPC struct _virKeepAlive { - virObject object; - - virMutex lock; + virObjectLockable parent; int interval; unsigned int count; @@ -58,7 +56,7 @@ static void virKeepAliveDispose(void *obj); static int virKeepAliveOnceInit(void) { - if (!(virKeepAliveClass = virClassNew(virClassForObject(), + if (!(virKeepAliveClass = virClassNew(virClassForObjectLockable(), "virKeepAlive", sizeof(virKeepAlive), virKeepAliveDispose))) @@ -69,19 +67,6 @@ static int virKeepAliveOnceInit(void) VIR_ONCE_GLOBAL_INIT(virKeepAlive) -static void -virKeepAliveLock(virKeepAlivePtr ka) -{ - virMutexLock(&ka->lock); -} - -static void -virKeepAliveUnlock(virKeepAlivePtr ka) -{ - virMutexUnlock(&ka->lock); -} - - static virNetMessagePtr virKeepAliveMessage(virKeepAlivePtr ka, int proc) { @@ -174,7 +159,7 @@ virKeepAliveTimer(int timer ATTRIBUTE_UNUSED, void *opaque) bool dead; void *client; - virKeepAliveLock(ka); + virObjectLock(ka); client = ka->client; dead = virKeepAliveTimerInternal(ka, &msg); @@ -183,7 +168,7 @@ virKeepAliveTimer(int timer ATTRIBUTE_UNUSED, void *opaque) goto cleanup; virObjectRef(ka); - virKeepAliveUnlock(ka); + virObjectUnlock(ka); if (dead) { ka->deadCB(client); @@ -192,11 +177,11 @@ virKeepAliveTimer(int timer ATTRIBUTE_UNUSED, void *opaque) virNetMessageFree(msg); } - virKeepAliveLock(ka); + virObjectLock(ka); virObjectUnref(ka); cleanup: - virKeepAliveUnlock(ka); + virObjectUnlock(ka); } @@ -215,14 +200,9 @@ virKeepAliveNew(int interval, if (virKeepAliveInitialize() < 0) return NULL; - if (!(ka = virObjectNew(virKeepAliveClass))) + if (!(ka = virObjectLockableNew(virKeepAliveClass))) return NULL; - if (virMutexInit(&ka->lock) < 0) { - VIR_FREE(ka); - return NULL; - } - ka->interval = interval; ka->count = count; ka->countToDeath = count; @@ -245,7 +225,6 @@ virKeepAliveDispose(void *obj) { virKeepAlivePtr ka = obj; - virMutexDestroy(&ka->lock); ka->freeCB(ka->client); } @@ -260,7 +239,7 @@ virKeepAliveStart(virKeepAlivePtr ka, int timeout; time_t now; - virKeepAliveLock(ka); + virObjectLock(ka); if (ka->timer >= 0) { VIR_DEBUG("Keepalive messages already enabled"); @@ -306,7 +285,7 @@ virKeepAliveStart(virKeepAlivePtr ka, ret = 0; cleanup: - virKeepAliveUnlock(ka); + virObjectUnlock(ka); return ret; } @@ -314,7 +293,7 @@ cleanup: void virKeepAliveStop(virKeepAlivePtr ka) { - virKeepAliveLock(ka); + virObjectLock(ka); PROBE(RPC_KEEPALIVE_STOP, "ka=%p client=%p", @@ -325,7 +304,7 @@ virKeepAliveStop(virKeepAlivePtr ka) ka->timer = -1; } - virKeepAliveUnlock(ka); + virObjectUnlock(ka); } @@ -337,7 +316,7 @@ virKeepAliveTimeout(virKeepAlivePtr ka) if (!ka) return -1; - virKeepAliveLock(ka); + virObjectLock(ka); if (ka->interval <= 0 || ka->intervalStart == 0) { timeout = -1; @@ -347,7 +326,7 @@ virKeepAliveTimeout(virKeepAlivePtr ka) timeout = 0; } - virKeepAliveUnlock(ka); + virObjectUnlock(ka); if (timeout < 0) return -1; @@ -366,9 +345,9 @@ virKeepAliveTrigger(virKeepAlivePtr ka, if (!ka) return false; - virKeepAliveLock(ka); + virObjectLock(ka); dead = virKeepAliveTimerInternal(ka, msg); - virKeepAliveUnlock(ka); + virObjectUnlock(ka); return dead; } @@ -388,7 +367,7 @@ virKeepAliveCheckMessage(virKeepAlivePtr ka, if (!ka) return false; - virKeepAliveLock(ka); + virObjectLock(ka); ka->countToDeath = ka->count; ka->lastPacketReceived = ka->intervalStart = time(NULL); @@ -420,7 +399,7 @@ virKeepAliveCheckMessage(virKeepAlivePtr ka, if (ka->timer >= 0) virEventUpdateTimeout(ka->timer, ka->interval * 1000); - virKeepAliveUnlock(ka); + virObjectUnlock(ka); return ret; } diff --git a/src/rpc/virnetclient.c b/src/rpc/virnetclient.c index f281548..1bcd765 100644 --- a/src/rpc/virnetclient.c +++ b/src/rpc/virnetclient.c @@ -63,9 +63,7 @@ struct _virNetClientCall { struct _virNetClient { - virObject object; - - virMutex lock; + virObjectLockable parent; virNetSocketPtr sock; bool asyncIO; @@ -136,28 +134,16 @@ static void virNetClientCloseInternal(virNetClientPtr client, int reason); -static void virNetClientLock(virNetClientPtr client) -{ - virMutexLock(&client->lock); -} - - -static void virNetClientUnlock(virNetClientPtr client) -{ - virMutexUnlock(&client->lock); -} - - void virNetClientSetCloseCallback(virNetClientPtr client, virNetClientCloseFunc cb, void *opaque, virFreeCallback ff) { - virNetClientLock(client); + virObjectLock(client); client->closeCb = cb; client->closeOpaque = opaque; client->closeFf = ff; - virNetClientUnlock(client); + virObjectUnlock(client); } @@ -261,9 +247,9 @@ virNetClientKeepAliveIsSupported(virNetClientPtr client) { bool supported; - virNetClientLock(client); + virObjectLock(client); supported = !!client->keepalive; - virNetClientUnlock(client); + virObjectUnlock(client); return supported; } @@ -275,9 +261,9 @@ virNetClientKeepAliveStart(virNetClientPtr client, { int ret; - virNetClientLock(client); + virObjectLock(client); ret = virKeepAliveStart(client->keepalive, interval, count); - virNetClientUnlock(client); + virObjectUnlock(client); return ret; } @@ -285,9 +271,9 @@ virNetClientKeepAliveStart(virNetClientPtr client, void virNetClientKeepAliveStop(virNetClientPtr client) { - virNetClientLock(client); + virObjectLock(client); virKeepAliveStop(client->keepalive); - virNetClientUnlock(client); + virObjectUnlock(client); } static void @@ -323,14 +309,9 @@ static virNetClientPtr virNetClientNew(virNetSocketPtr sock, goto error; } - if (!(client = virObjectNew(virNetClientClass))) + if (!(client = virObjectLockableNew(virNetClientClass))) goto error; - if (virMutexInit(&client->lock) < 0) { - VIR_FREE(client); - goto error; - } - client->sock = sock; client->wakeupReadFD = wakeupFD[0]; client->wakeupSendFD = wakeupFD[1]; @@ -583,9 +564,9 @@ int virNetClientRegisterKeepAlive(virNetClientPtr client) int virNetClientGetFD(virNetClientPtr client) { int fd; - virNetClientLock(client); + virObjectLock(client); fd = virNetSocketGetFD(client->sock); - virNetClientUnlock(client); + virObjectUnlock(client); return fd; } @@ -593,9 +574,9 @@ int virNetClientGetFD(virNetClientPtr client) int virNetClientDupFD(virNetClientPtr client, bool cloexec) { int fd; - virNetClientLock(client); + virObjectLock(client); fd = virNetSocketDupFD(client->sock, cloexec); - virNetClientUnlock(client); + virObjectUnlock(client); return fd; } @@ -603,9 +584,9 @@ int virNetClientDupFD(virNetClientPtr client, bool cloexec) bool virNetClientHasPassFD(virNetClientPtr client) { bool hasPassFD; - virNetClientLock(client); + virObjectLock(client); hasPassFD = virNetSocketHasPassFD(client->sock); - virNetClientUnlock(client); + virObjectUnlock(client); return hasPassFD; } @@ -639,8 +620,7 @@ void virNetClientDispose(void *obj) virNetMessageClear(&client->msg); - virNetClientUnlock(client); - virMutexDestroy(&client->lock); + virObjectUnlock(client); } @@ -685,7 +665,7 @@ virNetClientCloseLocked(virNetClientPtr client) void *closeOpaque = client->closeOpaque; int closeReason = client->closeReason; virObjectRef(client); - virNetClientUnlock(client); + virObjectUnlock(client); if (ka) { virKeepAliveStop(ka); @@ -694,7 +674,7 @@ virNetClientCloseLocked(virNetClientPtr client) if (closeCb) closeCb(client, closeReason, closeOpaque); - virNetClientLock(client); + virObjectLock(client); virObjectUnref(client); } } @@ -711,7 +691,7 @@ static void virNetClientCloseInternal(virNetClientPtr client, client->wantClose) return; - virNetClientLock(client); + virObjectLock(client); virNetClientMarkClose(client, reason); @@ -730,7 +710,7 @@ static void virNetClientCloseInternal(virNetClientPtr client, virNetClientIOEventLoopPassTheBuck(client, NULL); } - virNetClientUnlock(client); + virObjectUnlock(client); } @@ -744,10 +724,10 @@ void virNetClientClose(virNetClientPtr client) void virNetClientSetSASLSession(virNetClientPtr client, virNetSASLSessionPtr sasl) { - virNetClientLock(client); + virObjectLock(client); client->sasl = virObjectRef(sasl); virNetSocketSetSASLSession(client->sock, client->sasl); - virNetClientUnlock(client); + virObjectUnlock(client); } #endif @@ -771,7 +751,7 @@ int virNetClientSetTLSSession(virNetClientPtr client, # endif sigaddset(&blockedsigs, SIGPIPE); - virNetClientLock(client); + virObjectLock(client); if (!(client->tls = virNetTLSSessionNew(tls, client->hostname))) @@ -846,13 +826,13 @@ int virNetClientSetTLSSession(virNetClientPtr client, goto error; } - virNetClientUnlock(client); + virObjectUnlock(client); return 0; error: virObjectUnref(client->tls); client->tls = NULL; - virNetClientUnlock(client); + virObjectUnlock(client); return -1; } #endif @@ -860,7 +840,7 @@ error: bool virNetClientIsEncrypted(virNetClientPtr client) { bool ret = false; - virNetClientLock(client); + virObjectLock(client); #if HAVE_GNUTLS if (client->tls) ret = true; @@ -869,7 +849,7 @@ bool virNetClientIsEncrypted(virNetClientPtr client) if (client->sasl) ret = true; #endif - virNetClientUnlock(client); + virObjectUnlock(client); return ret; } @@ -881,9 +861,9 @@ bool virNetClientIsOpen(virNetClientPtr client) if (!client) return false; - virNetClientLock(client); + virObjectLock(client); ret = client->sock && !client->wantClose; - virNetClientUnlock(client); + virObjectUnlock(client); return ret; } @@ -891,19 +871,19 @@ bool virNetClientIsOpen(virNetClientPtr client) int virNetClientAddProgram(virNetClientPtr client, virNetClientProgramPtr prog) { - virNetClientLock(client); + virObjectLock(client); if (VIR_EXPAND_N(client->programs, client->nprograms, 1) < 0) goto no_memory; client->programs[client->nprograms-1] = virObjectRef(prog); - virNetClientUnlock(client); + virObjectUnlock(client); return 0; no_memory: virReportOOMError(); - virNetClientUnlock(client); + virObjectUnlock(client); return -1; } @@ -911,19 +891,19 @@ no_memory: int virNetClientAddStream(virNetClientPtr client, virNetClientStreamPtr st) { - virNetClientLock(client); + virObjectLock(client); if (VIR_EXPAND_N(client->streams, client->nstreams, 1) < 0) goto no_memory; client->streams[client->nstreams-1] = virObjectRef(st); - virNetClientUnlock(client); + virObjectUnlock(client); return 0; no_memory: virReportOOMError(); - virNetClientUnlock(client); + virObjectUnlock(client); return -1; } @@ -931,7 +911,7 @@ no_memory: void virNetClientRemoveStream(virNetClientPtr client, virNetClientStreamPtr st) { - virNetClientLock(client); + virObjectLock(client); size_t i; for (i = 0 ; i < client->nstreams ; i++) { if (client->streams[i] == st) @@ -953,7 +933,7 @@ void virNetClientRemoveStream(virNetClientPtr client, virObjectUnref(st); cleanup: - virNetClientUnlock(client); + virObjectUnlock(client); } @@ -971,10 +951,10 @@ const char *virNetClientRemoteAddrString(virNetClientPtr client) int virNetClientGetTLSKeySize(virNetClientPtr client) { int ret = 0; - virNetClientLock(client); + virObjectLock(client); if (client->tls) ret = virNetTLSSessionGetKeySize(client->tls); - virNetClientUnlock(client); + virObjectUnlock(client); return ret; } #endif @@ -1522,7 +1502,7 @@ static int virNetClientIOEventLoop(virNetClientPtr client, /* Release lock while poll'ing so other threads * can stuff themselves on the queue */ - virNetClientUnlock(client); + virObjectUnlock(client); /* Block SIGWINCH from interrupting poll in curses programs, * then restore the original signal mask again immediately @@ -1546,7 +1526,7 @@ static int virNetClientIOEventLoop(virNetClientPtr client, ignore_value(pthread_sigmask(SIG_SETMASK, &oldmask, NULL)); - virNetClientLock(client); + virObjectLock(client); if (ret < 0) { virReportSystemError(errno, @@ -1762,7 +1742,7 @@ static int virNetClientIO(virNetClientPtr client, VIR_DEBUG("Going to sleep head=%p call=%p", client->waitDispatch, thiscall); /* Go to sleep while other thread is working... */ - if (virCondWait(&thiscall->cond, &client->lock) < 0) { + if (virCondWait(&thiscall->cond, &client->parent.lock) < 0) { virNetClientCallRemove(&client->waitDispatch, thiscall); virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("failed to wait on condition")); @@ -1834,7 +1814,7 @@ void virNetClientIncomingEvent(virNetSocketPtr sock, { virNetClientPtr client = opaque; - virNetClientLock(client); + virObjectLock(client); VIR_DEBUG("client=%p wantclose=%d", client, client ? client->wantClose : false); @@ -1876,7 +1856,7 @@ void virNetClientIncomingEvent(virNetSocketPtr sock, done: if (client->wantClose) virNetClientCloseLocked(client); - virNetClientUnlock(client); + virObjectUnlock(client); } @@ -2012,9 +1992,9 @@ int virNetClientSendWithReply(virNetClientPtr client, virNetMessagePtr msg) { int ret; - virNetClientLock(client); + virObjectLock(client); ret = virNetClientSendInternal(client, msg, true, false); - virNetClientUnlock(client); + virObjectUnlock(client); if (ret < 0) return -1; return 0; @@ -2035,9 +2015,9 @@ int virNetClientSendNoReply(virNetClientPtr client, virNetMessagePtr msg) { int ret; - virNetClientLock(client); + virObjectLock(client); ret = virNetClientSendInternal(client, msg, false, false); - virNetClientUnlock(client); + virObjectUnlock(client); if (ret < 0) return -1; return 0; @@ -2058,9 +2038,9 @@ int virNetClientSendNonBlock(virNetClientPtr client, virNetMessagePtr msg) { int ret; - virNetClientLock(client); + virObjectLock(client); ret = virNetClientSendInternal(client, msg, false, true); - virNetClientUnlock(client); + virObjectUnlock(client); return ret; } @@ -2079,18 +2059,18 @@ int virNetClientSendWithReplyStream(virNetClientPtr client, virNetClientStreamPtr st) { int ret; - virNetClientLock(client); + virObjectLock(client); /* Other thread might have already received * stream EOF so we don't want sent anything. * Server won't respond anyway. */ if (virNetClientStreamEOF(st)) { - virNetClientUnlock(client); + virObjectUnlock(client); return 0; } ret = virNetClientSendInternal(client, msg, true, false); - virNetClientUnlock(client); + virObjectUnlock(client); if (ret < 0) return -1; return 0; diff --git a/src/rpc/virnetclientstream.c b/src/rpc/virnetclientstream.c index e1ee30e..b8c457e 100644 --- a/src/rpc/virnetclientstream.c +++ b/src/rpc/virnetclientstream.c @@ -32,9 +32,7 @@ #define VIR_FROM_THIS VIR_FROM_RPC struct _virNetClientStream { - virObject object; - - virMutex lock; + virObjectLockable parent; virNetClientProgramPtr prog; int proc; @@ -68,7 +66,7 @@ static void virNetClientStreamDispose(void *obj); static int virNetClientStreamOnceInit(void) { - if (!(virNetClientStreamClass = virClassNew(virClassForObject(), + if (!(virNetClientStreamClass = virClassNew(virClassForObjectLockable(), "virNetClientStream", sizeof(virNetClientStream), virNetClientStreamDispose))) @@ -106,8 +104,7 @@ virNetClientStreamEventTimer(int timer ATTRIBUTE_UNUSED, void *opaque) virNetClientStreamPtr st = opaque; int events = 0; - - virMutexLock(&st->lock); + virObjectLock(st); if (st->cb && (st->cbEvents & VIR_STREAM_EVENT_READABLE) && @@ -124,15 +121,15 @@ virNetClientStreamEventTimer(int timer ATTRIBUTE_UNUSED, void *opaque) virFreeCallback cbFree = st->cbFree; st->cbDispatch = 1; - virMutexUnlock(&st->lock); + virObjectUnlock(st); (cb)(st, events, cbOpaque); - virMutexLock(&st->lock); + virObjectLock(st); st->cbDispatch = 0; if (!st->cb && cbFree) (cbFree)(cbOpaque); } - virMutexUnlock(&st->lock); + virObjectUnlock(st); } @@ -145,20 +142,13 @@ virNetClientStreamPtr virNetClientStreamNew(virNetClientProgramPtr prog, if (virNetClientStreamInitialize() < 0) return NULL; - if (!(st = virObjectNew(virNetClientStreamClass))) + if (!(st = virObjectLockableNew(virNetClientStreamClass))) return NULL; st->prog = prog; st->proc = proc; st->serial = serial; - if (virMutexInit(&st->lock) < 0) { - virReportError(VIR_ERR_INTERNAL_ERROR, "%s", - _("cannot initialize mutex")); - VIR_FREE(st); - return NULL; - } - virObjectRef(prog); return st; @@ -170,7 +160,6 @@ void virNetClientStreamDispose(void *obj) virResetError(&st->err); VIR_FREE(st->incoming); - virMutexDestroy(&st->lock); virObjectUnref(st->prog); } @@ -178,21 +167,21 @@ bool virNetClientStreamMatches(virNetClientStreamPtr st, virNetMessagePtr msg) { bool match = false; - virMutexLock(&st->lock); + virObjectLock(st); if (virNetClientProgramMatches(st->prog, msg) && st->proc == msg->header.proc && st->serial == msg->header.serial) match = true; - virMutexUnlock(&st->lock); + virObjectUnlock(st); return match; } bool virNetClientStreamRaiseError(virNetClientStreamPtr st) { - virMutexLock(&st->lock); + virObjectLock(st); if (st->err.code == VIR_ERR_OK) { - virMutexUnlock(&st->lock); + virObjectUnlock(st); return false; } @@ -206,7 +195,7 @@ bool virNetClientStreamRaiseError(virNetClientStreamPtr st) st->err.int1, st->err.int2, "%s", st->err.message ? st->err.message : _("Unknown error")); - virMutexUnlock(&st->lock); + virObjectUnlock(st); return true; } @@ -217,7 +206,7 @@ int virNetClientStreamSetError(virNetClientStreamPtr st, virNetMessageError err; int ret = -1; - virMutexLock(&st->lock); + virObjectLock(st); if (st->err.code != VIR_ERR_OK) VIR_DEBUG("Overwriting existing stream error %s", NULLSTR(st->err.message)); @@ -265,7 +254,7 @@ int virNetClientStreamSetError(virNetClientStreamPtr st, cleanup: xdr_free((xdrproc_t)xdr_virNetMessageError, (void*)&err); - virMutexUnlock(&st->lock); + virObjectUnlock(st); return ret; } @@ -276,7 +265,7 @@ int virNetClientStreamQueuePacket(virNetClientStreamPtr st, int ret = -1; size_t need; - virMutexLock(&st->lock); + virObjectLock(st); need = msg->bufferLength - msg->bufferOffset; if (need) { size_t avail = st->incomingLength - st->incomingOffset; @@ -306,7 +295,7 @@ int virNetClientStreamQueuePacket(virNetClientStreamPtr st, ret = 0; cleanup: - virMutexUnlock(&st->lock); + virObjectUnlock(st); return ret; } @@ -323,7 +312,7 @@ int virNetClientStreamSendPacket(virNetClientStreamPtr st, if (!(msg = virNetMessageNew(false))) return -1; - virMutexLock(&st->lock); + virObjectLock(st); msg->header.prog = virNetClientProgramGetProgram(st->prog); msg->header.vers = virNetClientProgramGetVersion(st->prog); @@ -332,7 +321,7 @@ int virNetClientStreamSendPacket(virNetClientStreamPtr st, msg->header.serial = st->serial; msg->header.proc = st->proc; - virMutexUnlock(&st->lock); + virObjectUnlock(st); if (virNetMessageEncodeHeader(msg) < 0) goto error; @@ -373,7 +362,7 @@ int virNetClientStreamRecvPacket(virNetClientStreamPtr st, int rv = -1; VIR_DEBUG("st=%p client=%p data=%p nbytes=%zu nonblock=%d", st, client, data, nbytes, nonblock); - virMutexLock(&st->lock); + virObjectLock(st); if (!st->incomingOffset && !st->incomingEOF) { virNetMessagePtr msg; int ret; @@ -397,9 +386,9 @@ int virNetClientStreamRecvPacket(virNetClientStreamPtr st, msg->header.status = VIR_NET_CONTINUE; VIR_DEBUG("Dummy packet to wait for stream data"); - virMutexUnlock(&st->lock); + virObjectUnlock(st); ret = virNetClientSendWithReplyStream(client, msg, st); - virMutexLock(&st->lock); + virObjectLock(st); virNetMessageFree(msg); if (ret < 0) @@ -427,7 +416,7 @@ int virNetClientStreamRecvPacket(virNetClientStreamPtr st, virNetClientStreamEventTimerUpdate(st); cleanup: - virMutexUnlock(&st->lock); + virObjectUnlock(st); return rv; } @@ -440,7 +429,7 @@ int virNetClientStreamEventAddCallback(virNetClientStreamPtr st, { int ret = -1; - virMutexLock(&st->lock); + virObjectLock(st); if (st->cb) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("multiple stream callbacks not supported")); @@ -467,7 +456,7 @@ int virNetClientStreamEventAddCallback(virNetClientStreamPtr st, ret = 0; cleanup: - virMutexUnlock(&st->lock); + virObjectUnlock(st); return ret; } @@ -476,7 +465,7 @@ int virNetClientStreamEventUpdateCallback(virNetClientStreamPtr st, { int ret = -1; - virMutexLock(&st->lock); + virObjectLock(st); if (!st->cb) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("no stream callback registered")); @@ -490,7 +479,7 @@ int virNetClientStreamEventUpdateCallback(virNetClientStreamPtr st, ret = 0; cleanup: - virMutexUnlock(&st->lock); + virObjectUnlock(st); return ret; } @@ -498,7 +487,7 @@ int virNetClientStreamEventRemoveCallback(virNetClientStreamPtr st) { int ret = -1; - virMutexLock(&st->lock); + virObjectLock(st); if (!st->cb) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("no stream callback registered")); @@ -517,7 +506,7 @@ int virNetClientStreamEventRemoveCallback(virNetClientStreamPtr st) ret = 0; cleanup: - virMutexUnlock(&st->lock); + virObjectUnlock(st); return ret; } diff --git a/src/rpc/virnetsaslcontext.c b/src/rpc/virnetsaslcontext.c index 41a69d1..6943216 100644 --- a/src/rpc/virnetsaslcontext.c +++ b/src/rpc/virnetsaslcontext.c @@ -33,16 +33,14 @@ #define VIR_FROM_THIS VIR_FROM_RPC struct _virNetSASLContext { - virObject object; + virObjectLockable parent; - virMutex lock; const char *const*usernameWhitelist; }; struct _virNetSASLSession { - virObject object; + virObjectLockable parent; - virMutex lock; sasl_conn_t *conn; size_t maxbufsize; }; @@ -50,18 +48,17 @@ struct _virNetSASLSession { static virClassPtr virNetSASLContextClass; static virClassPtr virNetSASLSessionClass; -static void virNetSASLContextDispose(void *obj); static void virNetSASLSessionDispose(void *obj); static int virNetSASLContextOnceInit(void) { - if (!(virNetSASLContextClass = virClassNew(virClassForObject(), + if (!(virNetSASLContextClass = virClassNew(virClassForObjectLockable(), "virNetSASLContext", sizeof(virNetSASLContext), - virNetSASLContextDispose))) + NULL))) return -1; - if (!(virNetSASLSessionClass = virClassNew(virClassForObject(), + if (!(virNetSASLSessionClass = virClassNew(virClassForObjectLockable(), "virNetSASLSession", sizeof(virNetSASLSession), virNetSASLSessionDispose))) @@ -89,16 +86,9 @@ virNetSASLContextPtr virNetSASLContextNewClient(void) return NULL; } - if (!(ctxt = virObjectNew(virNetSASLContextClass))) + if (!(ctxt = virObjectLockableNew(virNetSASLContextClass))) return NULL; - if (virMutexInit(&ctxt->lock) < 0) { - virReportError(VIR_ERR_INTERNAL_ERROR, "%s", - _("Failed to initialized mutex")); - VIR_FREE(ctxt); - return NULL; - } - return ctxt; } @@ -118,15 +108,8 @@ virNetSASLContextPtr virNetSASLContextNewServer(const char *const*usernameWhitel return NULL; } - if (!(ctxt = virObjectNew(virNetSASLContextClass))) - return NULL; - - if (virMutexInit(&ctxt->lock) < 0) { - virReportError(VIR_ERR_INTERNAL_ERROR, "%s", - _("Failed to initialized mutex")); - VIR_FREE(ctxt); + if (!(ctxt = virObjectLockableNew(virNetSASLContextClass))) return NULL; - } ctxt->usernameWhitelist = usernameWhitelist; @@ -139,7 +122,7 @@ int virNetSASLContextCheckIdentity(virNetSASLContextPtr ctxt, const char *const*wildcards; int ret = -1; - virMutexLock(&ctxt->lock); + virObjectLock(ctxt); /* If the list is not set, allow any DN. */ wildcards = ctxt->usernameWhitelist; @@ -173,18 +156,11 @@ int virNetSASLContextCheckIdentity(virNetSASLContextPtr ctxt, ret = 0; cleanup: - virMutexUnlock(&ctxt->lock); + virObjectUnlock(ctxt); return ret; } -void virNetSASLContextDispose(void *obj) -{ - virNetSASLContextPtr ctxt = obj; - - virMutexDestroy(&ctxt->lock); -} - virNetSASLSessionPtr virNetSASLSessionNewClient(virNetSASLContextPtr ctxt ATTRIBUTE_UNUSED, const char *service, const char *hostname, @@ -195,15 +171,8 @@ virNetSASLSessionPtr virNetSASLSessionNewClient(virNetSASLContextPtr ctxt ATTRIB virNetSASLSessionPtr sasl = NULL; int err; - if (!(sasl = virObjectNew(virNetSASLSessionClass))) - return NULL; - - if (virMutexInit(&sasl->lock) < 0) { - virReportError(VIR_ERR_INTERNAL_ERROR, "%s", - _("Failed to initialized mutex")); - VIR_FREE(sasl); + if (!(sasl = virObjectLockableNew(virNetSASLSessionClass))) return NULL; - } /* Arbitrary size for amount of data we can encode in a single block */ sasl->maxbufsize = 1 << 16; @@ -237,15 +206,8 @@ virNetSASLSessionPtr virNetSASLSessionNewServer(virNetSASLContextPtr ctxt ATTRIB virNetSASLSessionPtr sasl = NULL; int err; - if (!(sasl = virObjectNew(virNetSASLSessionClass))) - return NULL; - - if (virMutexInit(&sasl->lock) < 0) { - virReportError(VIR_ERR_INTERNAL_ERROR, "%s", - _("Failed to initialized mutex")); - VIR_FREE(sasl); + if (!(sasl = virObjectLockableNew(virNetSASLSessionClass))) return NULL; - } /* Arbitrary size for amount of data we can encode in a single block */ sasl->maxbufsize = 1 << 16; @@ -277,7 +239,7 @@ int virNetSASLSessionExtKeySize(virNetSASLSessionPtr sasl, { int err; int ret = -1; - virMutexLock(&sasl->lock); + virObjectLock(sasl); err = sasl_setprop(sasl->conn, SASL_SSF_EXTERNAL, &ssf); if (err != SASL_OK) { @@ -290,7 +252,7 @@ int virNetSASLSessionExtKeySize(virNetSASLSessionPtr sasl, ret = 0; cleanup: - virMutexUnlock(&sasl->lock); + virObjectUnlock(sasl); return ret; } @@ -298,7 +260,7 @@ const char *virNetSASLSessionGetIdentity(virNetSASLSessionPtr sasl) { const void *val = NULL; int err; - virMutexLock(&sasl->lock); + virObjectLock(sasl); err = sasl_getprop(sasl->conn, SASL_USERNAME, &val); if (err != SASL_OK) { @@ -316,7 +278,7 @@ const char *virNetSASLSessionGetIdentity(virNetSASLSessionPtr sasl) VIR_DEBUG("SASL client username %s", (const char *)val); cleanup: - virMutexUnlock(&sasl->lock); + virObjectUnlock(sasl); return (const char*)val; } @@ -327,7 +289,7 @@ int virNetSASLSessionGetKeySize(virNetSASLSessionPtr sasl) int ssf; const void *val; - virMutexLock(&sasl->lock); + virObjectLock(sasl); err = sasl_getprop(sasl->conn, SASL_SSF, &val); if (err != SASL_OK) { virReportError(VIR_ERR_AUTH_FAILED, @@ -339,7 +301,7 @@ int virNetSASLSessionGetKeySize(virNetSASLSessionPtr sasl) ssf = *(const int *)val; cleanup: - virMutexUnlock(&sasl->lock); + virObjectUnlock(sasl); return ssf; } @@ -355,7 +317,7 @@ int virNetSASLSessionSecProps(virNetSASLSessionPtr sasl, VIR_DEBUG("minSSF=%d maxSSF=%d allowAnonymous=%d maxbufsize=%zu", minSSF, maxSSF, allowAnonymous, sasl->maxbufsize); - virMutexLock(&sasl->lock); + virObjectLock(sasl); memset(&secprops, 0, sizeof(secprops)); secprops.min_ssf = minSSF; @@ -375,7 +337,7 @@ int virNetSASLSessionSecProps(virNetSASLSessionPtr sasl, ret = 0; cleanup: - virMutexUnlock(&sasl->lock); + virObjectUnlock(sasl); return ret; } @@ -408,7 +370,7 @@ char *virNetSASLSessionListMechanisms(virNetSASLSessionPtr sasl) char *ret = NULL; int err; - virMutexLock(&sasl->lock); + virObjectLock(sasl); err = sasl_listmech(sasl->conn, NULL, /* Don't need to set user */ "", /* Prefix */ @@ -429,7 +391,7 @@ char *virNetSASLSessionListMechanisms(virNetSASLSessionPtr sasl) } cleanup: - virMutexUnlock(&sasl->lock); + virObjectUnlock(sasl); return ret; } @@ -448,7 +410,7 @@ int virNetSASLSessionClientStart(virNetSASLSessionPtr sasl, VIR_DEBUG("sasl=%p mechlist=%s prompt_need=%p clientout=%p clientoutlen=%p mech=%p", sasl, mechlist, prompt_need, clientout, clientoutlen, mech); - virMutexLock(&sasl->lock); + virObjectLock(sasl); err = sasl_client_start(sasl->conn, mechlist, prompt_need, @@ -478,7 +440,7 @@ int virNetSASLSessionClientStart(virNetSASLSessionPtr sasl, } cleanup: - virMutexUnlock(&sasl->lock); + virObjectUnlock(sasl); return ret; } @@ -498,7 +460,7 @@ int virNetSASLSessionClientStep(virNetSASLSessionPtr sasl, VIR_DEBUG("sasl=%p serverin=%s serverinlen=%zu prompt_need=%p clientout=%p clientoutlen=%p", sasl, serverin, serverinlen, prompt_need, clientout, clientoutlen); - virMutexLock(&sasl->lock); + virObjectLock(sasl); err = sasl_client_step(sasl->conn, serverin, inlen, @@ -527,7 +489,7 @@ int virNetSASLSessionClientStep(virNetSASLSessionPtr sasl, } cleanup: - virMutexUnlock(&sasl->lock); + virObjectUnlock(sasl); return ret; } @@ -543,7 +505,7 @@ int virNetSASLSessionServerStart(virNetSASLSessionPtr sasl, int err; int ret = -1; - virMutexLock(&sasl->lock); + virObjectLock(sasl); err = sasl_server_start(sasl->conn, mechname, clientin, @@ -573,7 +535,7 @@ int virNetSASLSessionServerStart(virNetSASLSessionPtr sasl, } cleanup: - virMutexUnlock(&sasl->lock); + virObjectUnlock(sasl); return ret; } @@ -589,7 +551,7 @@ int virNetSASLSessionServerStep(virNetSASLSessionPtr sasl, int err; int ret = -1; - virMutexLock(&sasl->lock); + virObjectLock(sasl); err = sasl_server_step(sasl->conn, clientin, inlen, @@ -618,16 +580,16 @@ int virNetSASLSessionServerStep(virNetSASLSessionPtr sasl, } cleanup: - virMutexUnlock(&sasl->lock); + virObjectUnlock(sasl); return ret; } size_t virNetSASLSessionGetMaxBufSize(virNetSASLSessionPtr sasl) { size_t ret; - virMutexLock(&sasl->lock); + virObjectLock(sasl); ret = sasl->maxbufsize; - virMutexUnlock(&sasl->lock); + virObjectUnlock(sasl); return ret; } @@ -642,7 +604,7 @@ ssize_t virNetSASLSessionEncode(virNetSASLSessionPtr sasl, int err; ssize_t ret = -1; - virMutexLock(&sasl->lock); + virObjectLock(sasl); if (inputLen > sasl->maxbufsize) { virReportSystemError(EINVAL, _("SASL data length %zu too long, max %zu"), @@ -666,7 +628,7 @@ ssize_t virNetSASLSessionEncode(virNetSASLSessionPtr sasl, ret = 0; cleanup: - virMutexUnlock(&sasl->lock); + virObjectUnlock(sasl); return ret; } @@ -681,7 +643,7 @@ ssize_t virNetSASLSessionDecode(virNetSASLSessionPtr sasl, int err; ssize_t ret = -1; - virMutexLock(&sasl->lock); + virObjectLock(sasl); if (inputLen > sasl->maxbufsize) { virReportSystemError(EINVAL, _("SASL data length %zu too long, max %zu"), @@ -704,7 +666,7 @@ ssize_t virNetSASLSessionDecode(virNetSASLSessionPtr sasl, ret = 0; cleanup: - virMutexUnlock(&sasl->lock); + virObjectUnlock(sasl); return ret; } @@ -715,5 +677,4 @@ void virNetSASLSessionDispose(void *obj) if (sasl->conn) sasl_dispose(&sasl->conn); - virMutexDestroy(&sasl->lock); } diff --git a/src/rpc/virnetserver.c b/src/rpc/virnetserver.c index 03efbb8..dd104be 100644 --- a/src/rpc/virnetserver.c +++ b/src/rpc/virnetserver.c @@ -64,9 +64,7 @@ struct _virNetServerJob { }; struct _virNetServer { - virObject object; - - virMutex lock; + virObjectLockable parent; virThreadPoolPtr workers; @@ -119,7 +117,7 @@ static void virNetServerDispose(void *obj); static int virNetServerOnceInit(void) { - if (!(virNetServerClass = virClassNew(virClassForObject(), + if (!(virNetServerClass = virClassNew(virClassForObjectLockable(), "virNetServer", sizeof(virNetServer), virNetServerDispose))) @@ -131,17 +129,6 @@ static int virNetServerOnceInit(void) VIR_ONCE_GLOBAL_INIT(virNetServer) -static void virNetServerLock(virNetServerPtr srv) -{ - virMutexLock(&srv->lock); -} - -static void virNetServerUnlock(virNetServerPtr srv) -{ - virMutexUnlock(&srv->lock); -} - - static int virNetServerProcessMsg(virNetServerPtr srv, virNetServerClientPtr client, virNetServerProgramPtr prog, @@ -222,7 +209,7 @@ static int virNetServerDispatchNewMessage(virNetServerClientPtr client, VIR_DEBUG("server=%p client=%p message=%p", srv, client, msg); - virNetServerLock(srv); + virObjectLock(srv); for (i = 0 ; i < srv->nprograms ; i++) { if (virNetServerProgramMatches(srv->programs[i], msg)) { prog = srv->programs[i]; @@ -258,7 +245,7 @@ static int virNetServerDispatchNewMessage(virNetServerClientPtr client, } cleanup: - virNetServerUnlock(srv); + virObjectUnlock(srv); return ret; } @@ -267,7 +254,7 @@ cleanup: static int virNetServerAddClient(virNetServerPtr srv, virNetServerClientPtr client) { - virNetServerLock(srv); + virObjectLock(srv); if (srv->nclients >= srv->nclients_max) { virReportError(VIR_ERR_RPC, @@ -293,11 +280,11 @@ static int virNetServerAddClient(virNetServerPtr srv, virNetServerClientInitKeepAlive(client, srv->keepaliveInterval, srv->keepaliveCount); - virNetServerUnlock(srv); + virObjectUnlock(srv); return 0; error: - virNetServerUnlock(srv); + virObjectUnlock(srv); return -1; } @@ -378,7 +365,7 @@ virNetServerPtr virNetServerNew(size_t min_workers, if (virNetServerInitialize() < 0) return NULL; - if (!(srv = virObjectNew(virNetServerClass))) + if (!(srv = virObjectLockableNew(virNetServerClass))) return NULL; if (max_workers && @@ -413,12 +400,6 @@ virNetServerPtr virNetServerNew(size_t min_workers, goto error; } - if (virMutexInit(&srv->lock) < 0) { - virReportError(VIR_ERR_INTERNAL_ERROR, "%s", - _("cannot initialize mutex")); - goto error; - } - if (virEventRegisterDefaultImpl() < 0) goto error; @@ -607,7 +588,7 @@ virJSONValuePtr virNetServerPreExecRestart(virNetServerPtr srv) virJSONValuePtr services; size_t i; - virMutexLock(&srv->lock); + virObjectLock(srv); if (!(object = virJSONValueNewObject())) goto error; @@ -692,13 +673,13 @@ virJSONValuePtr virNetServerPreExecRestart(virNetServerPtr srv) } } - virMutexUnlock(&srv->lock); + virObjectUnlock(srv); return object; error: virJSONValueFree(object); - virMutexUnlock(&srv->lock); + virObjectUnlock(srv); return NULL; } @@ -706,9 +687,9 @@ error: bool virNetServerIsPrivileged(virNetServerPtr srv) { bool priv; - virNetServerLock(srv); + virObjectLock(srv); priv = srv->privileged; - virNetServerUnlock(srv); + virObjectUnlock(srv); return priv; } @@ -716,11 +697,11 @@ bool virNetServerIsPrivileged(virNetServerPtr srv) void virNetServerAutoShutdown(virNetServerPtr srv, unsigned int timeout) { - virNetServerLock(srv); + virObjectLock(srv); srv->autoShutdownTimeout = timeout; - virNetServerUnlock(srv); + virObjectUnlock(srv); } @@ -732,7 +713,7 @@ static void virNetServerGotInhibitReply(DBusPendingCall *pending, DBusMessage *reply; int fd; - virNetServerLock(srv); + virObjectLock(srv); srv->autoShutdownCallingInhibit = false; VIR_DEBUG("srv=%p", srv); @@ -754,7 +735,7 @@ static void virNetServerGotInhibitReply(DBusPendingCall *pending, dbus_message_unref(reply); cleanup: - virNetServerUnlock(srv); + virObjectUnlock(srv); } @@ -808,7 +789,7 @@ static void virNetServerCallInhibit(virNetServerPtr srv, void virNetServerAddShutdownInhibition(virNetServerPtr srv) { - virNetServerLock(srv); + virObjectLock(srv); srv->autoShutdownInhibitions++; VIR_DEBUG("srv=%p inhibitions=%zu", srv, srv->autoShutdownInhibitions); @@ -822,13 +803,13 @@ void virNetServerAddShutdownInhibition(virNetServerPtr srv) "delay"); #endif - virNetServerUnlock(srv); + virObjectUnlock(srv); } void virNetServerRemoveShutdownInhibition(virNetServerPtr srv) { - virNetServerLock(srv); + virObjectLock(srv); srv->autoShutdownInhibitions--; VIR_DEBUG("srv=%p inhibitions=%zu", srv, srv->autoShutdownInhibitions); @@ -836,7 +817,7 @@ void virNetServerRemoveShutdownInhibition(virNetServerPtr srv) if (srv->autoShutdownInhibitions == 0) VIR_FORCE_CLOSE(srv->autoShutdownInhibitFd); - virNetServerUnlock(srv); + virObjectUnlock(srv); } @@ -879,7 +860,7 @@ virNetServerSignalEvent(int watch, siginfo_t siginfo; int i; - virNetServerLock(srv); + virObjectLock(srv); if (saferead(srv->sigread, &siginfo, sizeof(siginfo)) != sizeof(siginfo)) { virReportSystemError(errno, "%s", @@ -893,7 +874,7 @@ virNetServerSignalEvent(int watch, if (siginfo.si_signo == srv->signals[i]->signum) { virNetServerSignalFunc func = srv->signals[i]->func; void *funcopaque = srv->signals[i]->opaque; - virNetServerUnlock(srv); + virObjectUnlock(srv); func(srv, &siginfo, funcopaque); return; } @@ -903,7 +884,7 @@ virNetServerSignalEvent(int watch, _("Unexpected signal received: %d"), siginfo.si_signo); cleanup: - virNetServerUnlock(srv); + virObjectUnlock(srv); } static int virNetServerSignalSetup(virNetServerPtr srv) @@ -948,7 +929,7 @@ int virNetServerAddSignalHandler(virNetServerPtr srv, virNetServerSignalPtr sigdata; struct sigaction sig_action; - virNetServerLock(srv); + virObjectLock(srv); if (virNetServerSignalSetup(srv) < 0) goto error; @@ -972,14 +953,14 @@ int virNetServerAddSignalHandler(virNetServerPtr srv, srv->signals[srv->nsignals-1] = sigdata; - virNetServerUnlock(srv); + virObjectUnlock(srv); return 0; no_memory: virReportOOMError(); error: VIR_FREE(sigdata); - virNetServerUnlock(srv); + virObjectUnlock(srv); return -1; } @@ -989,7 +970,7 @@ int virNetServerAddService(virNetServerPtr srv, virNetServerServicePtr svc, const char *mdnsEntryName) { - virNetServerLock(srv); + virObjectLock(srv); if (VIR_EXPAND_N(srv->services, srv->nservices, 1) < 0) goto no_memory; @@ -1010,32 +991,32 @@ int virNetServerAddService(virNetServerPtr srv, virNetServerDispatchNewClient, srv); - virNetServerUnlock(srv); + virObjectUnlock(srv); return 0; no_memory: virReportOOMError(); error: - virNetServerUnlock(srv); + virObjectUnlock(srv); return -1; } int virNetServerAddProgram(virNetServerPtr srv, virNetServerProgramPtr prog) { - virNetServerLock(srv); + virObjectLock(srv); if (VIR_EXPAND_N(srv->programs, srv->nprograms, 1) < 0) goto no_memory; srv->programs[srv->nprograms-1] = virObjectRef(prog); - virNetServerUnlock(srv); + virObjectUnlock(srv); return 0; no_memory: virReportOOMError(); - virNetServerUnlock(srv); + virObjectUnlock(srv); return -1; } @@ -1053,14 +1034,14 @@ static void virNetServerAutoShutdownTimer(int timerid ATTRIBUTE_UNUSED, void *opaque) { virNetServerPtr srv = opaque; - virNetServerLock(srv); + virObjectLock(srv); if (!srv->autoShutdownInhibitions) { VIR_DEBUG("Automatic shutdown triggered"); srv->quit = 1; } - virNetServerUnlock(srv); + virObjectUnlock(srv); } @@ -1069,11 +1050,11 @@ void virNetServerUpdateServices(virNetServerPtr srv, { int i; - virNetServerLock(srv); + virObjectLock(srv); for (i = 0 ; i < srv->nservices ; i++) virNetServerServiceToggle(srv->services[i], enabled); - virNetServerUnlock(srv); + virObjectUnlock(srv); } @@ -1083,7 +1064,7 @@ void virNetServerRun(virNetServerPtr srv) int timerActive = 0; int i; - virNetServerLock(srv); + virObjectLock(srv); if (srv->mdns && virNetServerMDNSStart(srv->mdns) < 0) @@ -1123,13 +1104,13 @@ void virNetServerRun(virNetServerPtr srv) } } - virNetServerUnlock(srv); + virObjectUnlock(srv); if (virEventRunDefaultImpl() < 0) { - virNetServerLock(srv); + virObjectLock(srv); VIR_DEBUG("Loop iteration error, exiting"); break; } - virNetServerLock(srv); + virObjectLock(srv); reprocess: for (i = 0 ; i < srv->nclients ; i++) { @@ -1156,18 +1137,18 @@ void virNetServerRun(virNetServerPtr srv) } cleanup: - virNetServerUnlock(srv); + virObjectUnlock(srv); } void virNetServerQuit(virNetServerPtr srv) { - virNetServerLock(srv); + virObjectLock(srv); VIR_DEBUG("Quit requested %p", srv); srv->quit = 1; - virNetServerUnlock(srv); + virObjectUnlock(srv); } void virNetServerDispose(void *obj) @@ -1208,8 +1189,6 @@ void virNetServerDispose(void *obj) VIR_FREE(srv->mdnsGroupName); virNetServerMDNSFree(srv->mdns); - - virMutexDestroy(&srv->lock); } void virNetServerClose(virNetServerPtr srv) @@ -1219,20 +1198,20 @@ void virNetServerClose(virNetServerPtr srv) if (!srv) return; - virNetServerLock(srv); + virObjectLock(srv); for (i = 0; i < srv->nservices; i++) { virNetServerServiceClose(srv->services[i]); } - virNetServerUnlock(srv); + virObjectUnlock(srv); } bool virNetServerKeepAliveRequired(virNetServerPtr srv) { bool required; - virNetServerLock(srv); + virObjectLock(srv); required = srv->keepaliveRequired; - virNetServerUnlock(srv); + virObjectUnlock(srv); return required; } diff --git a/src/rpc/virnetserverclient.c b/src/rpc/virnetserverclient.c index ce8bd6d..10ac7e0 100644 --- a/src/rpc/virnetserverclient.c +++ b/src/rpc/virnetserverclient.c @@ -57,11 +57,10 @@ struct _virNetServerClientFilter { struct _virNetServerClient { - virObject object; + virObjectLockable parent; bool wantClose; bool delayedClose; - virMutex lock; virNetSocketPtr sock; int auth; bool readonly; @@ -112,7 +111,7 @@ static void virNetServerClientDispose(void *obj); static int virNetServerClientOnceInit(void) { - if (!(virNetServerClientClass = virClassNew(virClassForObject(), + if (!(virNetServerClientClass = virClassNew(virClassForObjectLockable(), "virNetServerClient", sizeof(virNetServerClient), virNetServerClientDispose))) @@ -130,17 +129,6 @@ static void virNetServerClientDispatchRead(virNetServerClientPtr client); static int virNetServerClientSendMessageLocked(virNetServerClientPtr client, virNetMessagePtr msg); -static void virNetServerClientLock(virNetServerClientPtr client) -{ - virMutexLock(&client->lock); -} - -static void virNetServerClientUnlock(virNetServerClientPtr client) -{ - virMutexUnlock(&client->lock); -} - - /* * @client: a locked client object */ @@ -253,7 +241,7 @@ int virNetServerClientAddFilter(virNetServerClientPtr client, return -1; } - virNetServerClientLock(client); + virObjectLock(client); filter->id = client->nextFilterID++; filter->func = func; @@ -266,7 +254,7 @@ int virNetServerClientAddFilter(virNetServerClientPtr client, ret = filter->id; - virNetServerClientUnlock(client); + virObjectUnlock(client); return ret; } @@ -276,7 +264,7 @@ void virNetServerClientRemoveFilter(virNetServerClientPtr client, { virNetServerClientFilterPtr tmp, prev; - virNetServerClientLock(client); + virObjectLock(client); prev = NULL; tmp = client->filters; @@ -294,7 +282,7 @@ void virNetServerClientRemoveFilter(virNetServerClientPtr client, tmp = tmp->next; } - virNetServerClientUnlock(client); + virObjectUnlock(client); } @@ -341,13 +329,13 @@ static void virNetServerClientSockTimerFunc(int timer, void *opaque) { virNetServerClientPtr client = opaque; - virNetServerClientLock(client); + virObjectLock(client); virEventUpdateTimeout(timer, -1); /* Although client->rx != NULL when this timer is enabled, it might have * changed since the client was unlocked in the meantime. */ if (client->rx) virNetServerClientDispatchRead(client); - virNetServerClientUnlock(client); + virObjectUnlock(client); } @@ -365,14 +353,9 @@ virNetServerClientNewInternal(virNetSocketPtr sock, if (virNetServerClientInitialize() < 0) return NULL; - if (!(client = virObjectNew(virNetServerClientClass))) + if (!(client = virObjectLockableNew(virNetServerClientClass))) return NULL; - if (virMutexInit(&client->lock) < 0) { - VIR_FREE(client); - return NULL; - } - client->sock = virObjectRef(sock); client->auth = auth; client->readonly = readonly; @@ -544,7 +527,7 @@ virJSONValuePtr virNetServerClientPreExecRestart(virNetServerClientPtr client) if (!object) return NULL; - virNetServerClientLock(client); + virObjectLock(client); if (virJSONValueObjectAppendNumberInt(object, "auth", client->auth) < 0) goto error; @@ -574,11 +557,11 @@ virJSONValuePtr virNetServerClientPreExecRestart(virNetServerClientPtr client) goto error; } - virNetServerClientUnlock(client); + virObjectUnlock(client); return object; error: - virNetServerClientUnlock(client); + virObjectUnlock(client); virJSONValueFree(object); return NULL; } @@ -587,18 +570,18 @@ error: int virNetServerClientGetAuth(virNetServerClientPtr client) { int auth; - virNetServerClientLock(client); + virObjectLock(client); auth = client->auth; - virNetServerClientUnlock(client); + virObjectUnlock(client); return auth; } bool virNetServerClientGetReadonly(virNetServerClientPtr client) { bool readonly; - virNetServerClientLock(client); + virObjectLock(client); readonly = client->readonly; - virNetServerClientUnlock(client); + virObjectUnlock(client); return readonly; } @@ -607,19 +590,19 @@ bool virNetServerClientGetReadonly(virNetServerClientPtr client) bool virNetServerClientHasTLSSession(virNetServerClientPtr client) { bool has; - virNetServerClientLock(client); + virObjectLock(client); has = client->tls ? true : false; - virNetServerClientUnlock(client); + virObjectUnlock(client); return has; } int virNetServerClientGetTLSKeySize(virNetServerClientPtr client) { int size = 0; - virNetServerClientLock(client); + virObjectLock(client); if (client->tls) size = virNetTLSSessionGetKeySize(client->tls); - virNetServerClientUnlock(client); + virObjectUnlock(client); return size; } #endif @@ -627,10 +610,10 @@ int virNetServerClientGetTLSKeySize(virNetServerClientPtr client) int virNetServerClientGetFD(virNetServerClientPtr client) { int fd = -1; - virNetServerClientLock(client); + virObjectLock(client); if (client->sock) fd = virNetSocketGetFD(client->sock); - virNetServerClientUnlock(client); + virObjectUnlock(client); return fd; } @@ -638,17 +621,17 @@ int virNetServerClientGetUNIXIdentity(virNetServerClientPtr client, uid_t *uid, gid_t *gid, pid_t *pid) { int ret = -1; - virNetServerClientLock(client); + virObjectLock(client); if (client->sock) ret = virNetSocketGetUNIXIdentity(client->sock, uid, gid, pid); - virNetServerClientUnlock(client); + virObjectUnlock(client); return ret; } bool virNetServerClientIsSecure(virNetServerClientPtr client) { bool secure = false; - virNetServerClientLock(client); + virObjectLock(client); #if HAVE_GNUTLS if (client->tls) secure = true; @@ -659,7 +642,7 @@ bool virNetServerClientIsSecure(virNetServerClientPtr client) #endif if (client->sock && virNetSocketIsLocal(client->sock)) secure = true; - virNetServerClientUnlock(client); + virObjectUnlock(client); return secure; } @@ -674,9 +657,9 @@ void virNetServerClientSetSASLSession(virNetServerClientPtr client, * in the clear. Only once we complete the next 'tx' * operation do we switch to SASL mode */ - virNetServerClientLock(client); + virObjectLock(client); client->sasl = virObjectRef(sasl); - virNetServerClientUnlock(client); + virObjectUnlock(client); } #endif @@ -685,7 +668,7 @@ int virNetServerClientSetIdentity(virNetServerClientPtr client, const char *identity) { int ret = -1; - virNetServerClientLock(client); + virObjectLock(client); if (!(client->identity = strdup(identity))) { virReportOOMError(); goto error; @@ -693,16 +676,16 @@ int virNetServerClientSetIdentity(virNetServerClientPtr client, ret = 0; error: - virNetServerClientUnlock(client); + virObjectUnlock(client); return ret; } const char *virNetServerClientGetIdentity(virNetServerClientPtr client) { const char *identity; - virNetServerClientLock(client); + virObjectLock(client); identity = client->identity; - virNetServerClientLock(client); + virObjectUnlock(client); return identity; } @@ -710,9 +693,9 @@ const char *virNetServerClientGetIdentity(virNetServerClientPtr client) void *virNetServerClientGetPrivateData(virNetServerClientPtr client) { void *data; - virNetServerClientLock(client); + virObjectLock(client); data = client->privateData; - virNetServerClientUnlock(client); + virObjectUnlock(client); return data; } @@ -720,9 +703,9 @@ void *virNetServerClientGetPrivateData(virNetServerClientPtr client) void virNetServerClientSetCloseHook(virNetServerClientPtr client, virNetServerClientCloseFunc cf) { - virNetServerClientLock(client); + virObjectLock(client); client->privateDataCloseFunc = cf; - virNetServerClientUnlock(client); + virObjectUnlock(client); } @@ -730,10 +713,10 @@ void virNetServerClientSetDispatcher(virNetServerClientPtr client, virNetServerClientDispatchFunc func, void *opaque) { - virNetServerClientLock(client); + virObjectLock(client); client->dispatchFunc = func; client->dispatchOpaque = opaque; - virNetServerClientUnlock(client); + virObjectUnlock(client); } @@ -772,8 +755,7 @@ void virNetServerClientDispose(void *obj) virObjectUnref(client->tlsCtxt); #endif virObjectUnref(client->sock); - virNetServerClientUnlock(client); - virMutexDestroy(&client->lock); + virObjectUnlock(client); } @@ -790,10 +772,10 @@ void virNetServerClientClose(virNetServerClientPtr client) virNetServerClientCloseFunc cf; virKeepAlivePtr ka; - virNetServerClientLock(client); + virObjectLock(client); VIR_DEBUG("client=%p", client); if (!client->sock) { - virNetServerClientUnlock(client); + virObjectUnlock(client); return; } @@ -802,18 +784,18 @@ void virNetServerClientClose(virNetServerClientPtr client) ka = client->keepalive; client->keepalive = NULL; virObjectRef(client); - virNetServerClientUnlock(client); + virObjectUnlock(client); virObjectUnref(ka); - virNetServerClientLock(client); + virObjectLock(client); virObjectUnref(client); } if (client->privateDataCloseFunc) { cf = client->privateDataCloseFunc; virObjectRef(client); - virNetServerClientUnlock(client); + virObjectUnlock(client); (cf)(client); - virNetServerClientLock(client); + virObjectLock(client); virObjectUnref(client); } @@ -847,46 +829,46 @@ void virNetServerClientClose(virNetServerClientPtr client) client->sock = NULL; } - virNetServerClientUnlock(client); + virObjectUnlock(client); } bool virNetServerClientIsClosed(virNetServerClientPtr client) { bool closed; - virNetServerClientLock(client); + virObjectLock(client); closed = client->sock == NULL ? true : false; - virNetServerClientUnlock(client); + virObjectUnlock(client); return closed; } void virNetServerClientDelayedClose(virNetServerClientPtr client) { - virNetServerClientLock(client); + virObjectLock(client); client->delayedClose = true; - virNetServerClientUnlock(client); + virObjectUnlock(client); } void virNetServerClientImmediateClose(virNetServerClientPtr client) { - virNetServerClientLock(client); + virObjectLock(client); client->wantClose = true; - virNetServerClientUnlock(client); + virObjectUnlock(client); } bool virNetServerClientWantClose(virNetServerClientPtr client) { bool wantClose; - virNetServerClientLock(client); + virObjectLock(client); wantClose = client->wantClose; - virNetServerClientUnlock(client); + virObjectUnlock(client); return wantClose; } int virNetServerClientInit(virNetServerClientPtr client) { - virNetServerClientLock(client); + virObjectLock(client); #if HAVE_GNUTLS if (!client->tlsCtxt) { @@ -925,12 +907,12 @@ int virNetServerClientInit(virNetServerClientPtr client) } #endif - virNetServerClientUnlock(client); + virObjectUnlock(client); return 0; error: client->wantClose = true; - virNetServerClientUnlock(client); + virObjectUnlock(client); return -1; } @@ -1256,11 +1238,11 @@ virNetServerClientDispatchEvent(virNetSocketPtr sock, int events, void *opaque) { virNetServerClientPtr client = opaque; - virNetServerClientLock(client); + virObjectLock(client); if (client->sock != sock) { virNetSocketRemoveIOCallback(sock); - virNetServerClientUnlock(client); + virObjectUnlock(client); return; } @@ -1289,7 +1271,7 @@ virNetServerClientDispatchEvent(virNetSocketPtr sock, int events, void *opaque) VIR_EVENT_HANDLE_HANGUP)) client->wantClose = true; - virNetServerClientUnlock(client); + virObjectUnlock(client); } @@ -1323,9 +1305,9 @@ int virNetServerClientSendMessage(virNetServerClientPtr client, { int ret; - virNetServerClientLock(client); + virObjectLock(client); ret = virNetServerClientSendMessageLocked(client, msg); - virNetServerClientUnlock(client); + virObjectUnlock(client); return ret; } @@ -1334,10 +1316,10 @@ int virNetServerClientSendMessage(virNetServerClientPtr client, bool virNetServerClientNeedAuth(virNetServerClientPtr client) { bool need = false; - virNetServerClientLock(client); + virObjectLock(client); if (client->auth && !client->identity) need = true; - virNetServerClientUnlock(client); + virObjectUnlock(client); return need; } @@ -1364,7 +1346,7 @@ virNetServerClientInitKeepAlive(virNetServerClientPtr client, virKeepAlivePtr ka; int ret = -1; - virNetServerClientLock(client); + virObjectLock(client); if (!(ka = virKeepAliveNew(interval, count, client, virNetServerClientKeepAliveSendCB, @@ -1378,7 +1360,7 @@ virNetServerClientInitKeepAlive(virNetServerClientPtr client, ka = NULL; cleanup: - virNetServerClientUnlock(client); + virObjectUnlock(client); if (ka) virKeepAliveStop(ka); virObjectUnref(ka); @@ -1390,8 +1372,8 @@ int virNetServerClientStartKeepAlive(virNetServerClientPtr client) { int ret; - virNetServerClientLock(client); + virObjectLock(client); ret = virKeepAliveStart(client->keepalive, 0, 0); - virNetServerClientUnlock(client); + virObjectUnlock(client); return ret; } diff --git a/src/rpc/virnetsocket.c b/src/rpc/virnetsocket.c index f96b47c..d4558c9 100644 --- a/src/rpc/virnetsocket.c +++ b/src/rpc/virnetsocket.c @@ -59,9 +59,7 @@ struct _virNetSocket { - virObject object; - - virMutex lock; + virObjectLockable parent; int fd; int watch; @@ -104,7 +102,7 @@ static void virNetSocketDispose(void *obj); static int virNetSocketOnceInit(void) { - if (!(virNetSocketClass = virClassNew(virClassForObject(), + if (!(virNetSocketClass = virClassNew(virClassForObjectLockable(), "virNetSocket", sizeof(virNetSocket), virNetSocketDispose))) @@ -163,15 +161,8 @@ static virNetSocketPtr virNetSocketNew(virSocketAddrPtr localAddr, return NULL; } - if (!(sock = virObjectNew(virNetSocketClass))) - return NULL; - - if (virMutexInit(&sock->lock) < 0) { - virReportSystemError(errno, "%s", - _("Unable to initialize mutex")); - VIR_FREE(sock); + if (!(sock = virObjectLockableNew(virNetSocketClass))) return NULL; - } if (localAddr) sock->localAddr = *localAddr; @@ -942,7 +933,7 @@ virJSONValuePtr virNetSocketPreExecRestart(virNetSocketPtr sock) { virJSONValuePtr object = NULL; - virMutexLock(&sock->lock); + virObjectLock(sock); #if HAVE_SASL if (sock->saslSession) { @@ -988,11 +979,11 @@ virJSONValuePtr virNetSocketPreExecRestart(virNetSocketPtr sock) goto error; } - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); return object; error: - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); virJSONValueFree(object); return NULL; } @@ -1037,17 +1028,15 @@ void virNetSocketDispose(void *obj) VIR_FREE(sock->localAddrStr); VIR_FREE(sock->remoteAddrStr); - - virMutexDestroy(&sock->lock); } int virNetSocketGetFD(virNetSocketPtr sock) { int fd; - virMutexLock(&sock->lock); + virObjectLock(sock); fd = sock->fd; - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); return fd; } @@ -1072,10 +1061,10 @@ int virNetSocketDupFD(virNetSocketPtr sock, bool cloexec) bool virNetSocketIsLocal(virNetSocketPtr sock) { bool isLocal = false; - virMutexLock(&sock->lock); + virObjectLock(sock); if (sock->localAddr.data.sa.sa_family == AF_UNIX) isLocal = true; - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); return isLocal; } @@ -1083,10 +1072,10 @@ bool virNetSocketIsLocal(virNetSocketPtr sock) bool virNetSocketHasPassFD(virNetSocketPtr sock) { bool hasPassFD = false; - virMutexLock(&sock->lock); + virObjectLock(sock); if (sock->localAddr.data.sa.sa_family == AF_UNIX) hasPassFD = true; - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); return hasPassFD; } @@ -1094,9 +1083,9 @@ bool virNetSocketHasPassFD(virNetSocketPtr sock) int virNetSocketGetPort(virNetSocketPtr sock) { int port; - virMutexLock(&sock->lock); + virObjectLock(sock); port = virSocketAddrGetPort(&sock->localAddr); - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); return port; } @@ -1109,12 +1098,12 @@ int virNetSocketGetUNIXIdentity(virNetSocketPtr sock, { struct ucred cr; socklen_t cr_len = sizeof(cr); - virMutexLock(&sock->lock); + virObjectLock(sock); if (getsockopt(sock->fd, SOL_SOCKET, SO_PEERCRED, &cr, &cr_len) < 0) { virReportSystemError(errno, "%s", _("Failed to get client socket identity")); - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); return -1; } @@ -1122,7 +1111,7 @@ int virNetSocketGetUNIXIdentity(virNetSocketPtr sock, *uid = cr.uid; *gid = cr.gid; - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); return 0; } #elif defined(LOCAL_PEERCRED) @@ -1133,12 +1122,12 @@ int virNetSocketGetUNIXIdentity(virNetSocketPtr sock, { struct xucred cr; socklen_t cr_len = sizeof(cr); - virMutexLock(&sock->lock); + virObjectLock(sock); if (getsockopt(sock->fd, SOL_SOCKET, LOCAL_PEERCRED, &cr, &cr_len) < 0) { virReportSystemError(errno, "%s", _("Failed to get client socket identity")); - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); return -1; } @@ -1146,7 +1135,7 @@ int virNetSocketGetUNIXIdentity(virNetSocketPtr sock, *uid = cr.cr_uid; *gid = cr.cr_gid; - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); return 0; } #else @@ -1167,9 +1156,9 @@ int virNetSocketSetBlocking(virNetSocketPtr sock, bool blocking) { int ret; - virMutexLock(&sock->lock); + virObjectLock(sock); ret = virSetBlocking(sock->fd, blocking); - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); return ret; } @@ -1207,14 +1196,14 @@ static ssize_t virNetSocketTLSSessionRead(char *buf, void virNetSocketSetTLSSession(virNetSocketPtr sock, virNetTLSSessionPtr sess) { - virMutexLock(&sock->lock); + virObjectLock(sock); virObjectUnref(sock->tlsSession); sock->tlsSession = virObjectRef(sess); virNetTLSSessionSetIOCallbacks(sess, virNetSocketTLSSessionWrite, virNetSocketTLSSessionRead, sock); - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); } #endif @@ -1222,10 +1211,10 @@ void virNetSocketSetTLSSession(virNetSocketPtr sock, void virNetSocketSetSASLSession(virNetSocketPtr sock, virNetSASLSessionPtr sess) { - virMutexLock(&sock->lock); + virObjectLock(sock); virObjectUnref(sock->saslSession); sock->saslSession = virObjectRef(sess); - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); } #endif @@ -1233,7 +1222,7 @@ void virNetSocketSetSASLSession(virNetSocketPtr sock, bool virNetSocketHasCachedData(virNetSocketPtr sock ATTRIBUTE_UNUSED) { bool hasCached = false; - virMutexLock(&sock->lock); + virObjectLock(sock); #if HAVE_LIBSSH2 if (virNetSSHSessionHasCachedData(sock->sshSession)) @@ -1244,7 +1233,7 @@ bool virNetSocketHasCachedData(virNetSocketPtr sock ATTRIBUTE_UNUSED) if (sock->saslDecoded) hasCached = true; #endif - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); return hasCached; } @@ -1267,12 +1256,12 @@ static ssize_t virNetSocketLibSSH2Write(virNetSocketPtr sock, bool virNetSocketHasPendingData(virNetSocketPtr sock ATTRIBUTE_UNUSED) { bool hasPending = false; - virMutexLock(&sock->lock); + virObjectLock(sock); #if HAVE_SASL if (sock->saslEncoded) hasPending = true; #endif - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); return hasPending; } @@ -1481,14 +1470,14 @@ static ssize_t virNetSocketWriteSASL(virNetSocketPtr sock, const char *buf, size ssize_t virNetSocketRead(virNetSocketPtr sock, char *buf, size_t len) { ssize_t ret; - virMutexLock(&sock->lock); + virObjectLock(sock); #if HAVE_SASL if (sock->saslSession) ret = virNetSocketReadSASL(sock, buf, len); else #endif ret = virNetSocketReadWire(sock, buf, len); - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); return ret; } @@ -1496,14 +1485,14 @@ ssize_t virNetSocketWrite(virNetSocketPtr sock, const char *buf, size_t len) { ssize_t ret; - virMutexLock(&sock->lock); + virObjectLock(sock); #if HAVE_SASL if (sock->saslSession) ret = virNetSocketWriteSASL(sock, buf, len); else #endif ret = virNetSocketWriteWire(sock, buf, len); - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); return ret; } @@ -1519,7 +1508,7 @@ int virNetSocketSendFD(virNetSocketPtr sock, int fd) _("Sending file descriptors is not supported on this socket")); return -1; } - virMutexLock(&sock->lock); + virObjectLock(sock); PROBE(RPC_SOCKET_SEND_FD, "sock=%p fd=%d", sock, fd); if (sendfd(sock->fd, fd) < 0) { @@ -1534,7 +1523,7 @@ int virNetSocketSendFD(virNetSocketPtr sock, int fd) ret = 1; cleanup: - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); return ret; } @@ -1553,7 +1542,7 @@ int virNetSocketRecvFD(virNetSocketPtr sock, int *fd) _("Receiving file descriptors is not supported on this socket")); return -1; } - virMutexLock(&sock->lock); + virObjectLock(sock); if ((*fd = recvfd(sock->fd, O_CLOEXEC)) < 0) { if (errno == EAGAIN) @@ -1568,20 +1557,20 @@ int virNetSocketRecvFD(virNetSocketPtr sock, int *fd) ret = 1; cleanup: - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); return ret; } int virNetSocketListen(virNetSocketPtr sock, int backlog) { - virMutexLock(&sock->lock); + virObjectLock(sock); if (listen(sock->fd, backlog > 0 ? backlog : 30) < 0) { virReportSystemError(errno, "%s", _("Unable to listen on socket")); - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); return -1; } - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); return 0; } @@ -1592,7 +1581,7 @@ int virNetSocketAccept(virNetSocketPtr sock, virNetSocketPtr *clientsock) virSocketAddr remoteAddr; int ret = -1; - virMutexLock(&sock->lock); + virObjectLock(sock); *clientsock = NULL; @@ -1629,7 +1618,7 @@ int virNetSocketAccept(virNetSocketPtr sock, virNetSocketPtr *clientsock) cleanup: VIR_FORCE_CLOSE(fd); - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); return ret; } @@ -1643,10 +1632,10 @@ static void virNetSocketEventHandle(int watch ATTRIBUTE_UNUSED, virNetSocketIOFunc func; void *eopaque; - virMutexLock(&sock->lock); + virObjectLock(sock); func = sock->func; eopaque = sock->opaque; - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); if (func) func(sock, events, eopaque); @@ -1659,13 +1648,13 @@ static void virNetSocketEventFree(void *opaque) virFreeCallback ff; void *eopaque; - virMutexLock(&sock->lock); + virObjectLock(sock); ff = sock->ff; eopaque = sock->opaque; sock->func = NULL; sock->ff = NULL; sock->opaque = NULL; - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); if (ff) ff(eopaque); @@ -1682,7 +1671,7 @@ int virNetSocketAddIOCallback(virNetSocketPtr sock, int ret = -1; virObjectRef(sock); - virMutexLock(&sock->lock); + virObjectLock(sock); if (sock->watch > 0) { VIR_DEBUG("Watch already registered on socket %p", sock); goto cleanup; @@ -1703,7 +1692,7 @@ int virNetSocketAddIOCallback(virNetSocketPtr sock, ret = 0; cleanup: - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); if (ret != 0) virObjectUnref(sock); return ret; @@ -1712,31 +1701,31 @@ cleanup: void virNetSocketUpdateIOCallback(virNetSocketPtr sock, int events) { - virMutexLock(&sock->lock); + virObjectLock(sock); if (sock->watch <= 0) { VIR_DEBUG("Watch not registered on socket %p", sock); - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); return; } virEventUpdateHandle(sock->watch, events); - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); } void virNetSocketRemoveIOCallback(virNetSocketPtr sock) { - virMutexLock(&sock->lock); + virObjectLock(sock); if (sock->watch <= 0) { VIR_DEBUG("Watch not registered on socket %p", sock); - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); return; } virEventRemoveHandle(sock->watch); - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); } void virNetSocketClose(virNetSocketPtr sock) @@ -1744,7 +1733,7 @@ void virNetSocketClose(virNetSocketPtr sock) if (!sock) return; - virMutexLock(&sock->lock); + virObjectLock(sock); VIR_FORCE_CLOSE(sock->fd); @@ -1758,5 +1747,5 @@ void virNetSocketClose(virNetSocketPtr sock) } #endif - virMutexUnlock(&sock->lock); + virObjectUnlock(sock); } diff --git a/src/rpc/virnetsshsession.c b/src/rpc/virnetsshsession.c index ca7d52e..9ce99f8 100644 --- a/src/rpc/virnetsshsession.c +++ b/src/rpc/virnetsshsession.c @@ -78,9 +78,8 @@ struct _virNetSSHAuthMethod { }; struct _virNetSSHSession { - virObject object; + virObjectLockable parent; virNetSSHSessionState state; - virMutex lock; /* libssh2 internal stuff */ LIBSSH2_SESSION *session; @@ -161,7 +160,7 @@ static virClassPtr virNetSSHSessionClass; static int virNetSSHSessionOnceInit(void) { - if (!(virNetSSHSessionClass = virClassNew(virClassForObject(), + if (!(virNetSSHSessionClass = virClassNew(virClassForObjectLockable(), "virNetSSHSession", sizeof(virNetSSHSession), virNetSSHSessionDispose))) @@ -927,18 +926,18 @@ int virNetSSHSessionAuthSetCallback(virNetSSHSessionPtr sess, virConnectAuthPtr auth) { - virMutexLock(&sess->lock); + virObjectLock(sess); sess->cred = auth; - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return 0; } void virNetSSHSessionAuthReset(virNetSSHSessionPtr sess) { - virMutexLock(&sess->lock); + virObjectLock(sess); virNetSSHSessionAuthMethodsFree(sess); - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); } int @@ -957,7 +956,7 @@ virNetSSHSessionAuthAddPasswordAuth(virNetSSHSessionPtr sess, return -1; } - virMutexLock(&sess->lock); + virObjectLock(sess); if (!(user = strdup(username)) || !(pass = strdup(password))) @@ -970,14 +969,14 @@ virNetSSHSessionAuthAddPasswordAuth(virNetSSHSessionPtr sess, auth->password = pass; auth->method = VIR_NET_SSH_AUTH_PASSWORD; - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return 0; no_memory: VIR_FREE(user); VIR_FREE(pass); virReportOOMError(); - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return -1; } @@ -995,7 +994,7 @@ virNetSSHSessionAuthAddAgentAuth(virNetSSHSessionPtr sess, return -1; } - virMutexLock(&sess->lock); + virObjectLock(sess); if (!(user = strdup(username))) goto no_memory; @@ -1006,13 +1005,13 @@ virNetSSHSessionAuthAddAgentAuth(virNetSSHSessionPtr sess, auth->username = user; auth->method = VIR_NET_SSH_AUTH_AGENT; - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return 0; no_memory: VIR_FREE(user); virReportOOMError(); - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return -1; } @@ -1035,7 +1034,7 @@ virNetSSHSessionAuthAddPrivKeyAuth(virNetSSHSessionPtr sess, return -1; } - virMutexLock(&sess->lock); + virObjectLock(sess); if (!(user = strdup(username)) || !(file = strdup(keyfile))) @@ -1052,7 +1051,7 @@ virNetSSHSessionAuthAddPrivKeyAuth(virNetSSHSessionPtr sess, auth->filename = file; auth->method = VIR_NET_SSH_AUTH_PRIVKEY; - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return 0; no_memory: @@ -1060,7 +1059,7 @@ no_memory: VIR_FREE(pass); VIR_FREE(file); virReportOOMError(); - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return -1; } @@ -1079,7 +1078,7 @@ virNetSSHSessionAuthAddKeyboardAuth(virNetSSHSessionPtr sess, return -1; } - virMutexLock(&sess->lock); + virObjectLock(sess); if (!(user = strdup(username))) goto no_memory; @@ -1091,13 +1090,13 @@ virNetSSHSessionAuthAddKeyboardAuth(virNetSSHSessionPtr sess, auth->tries = tries; auth->method = VIR_NET_SSH_AUTH_KEYBOARD_INTERACTIVE; - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return 0; no_memory: VIR_FREE(user); virReportOOMError(); - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return -1; } @@ -1107,7 +1106,7 @@ virNetSSHSessionSetChannelCommand(virNetSSHSessionPtr sess, const char *command) { int ret = 0; - virMutexLock(&sess->lock); + virObjectLock(sess); VIR_FREE(sess->channelCommand); @@ -1116,7 +1115,7 @@ virNetSSHSessionSetChannelCommand(virNetSSHSessionPtr sess, ret = -1; } - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return ret; } @@ -1130,7 +1129,7 @@ virNetSSHSessionSetHostKeyVerification(virNetSSHSessionPtr sess, { char *errmsg; - virMutexLock(&sess->lock); + virObjectLock(sess); sess->port = port; sess->hostKeyVerify = opt; @@ -1167,13 +1166,13 @@ virNetSSHSessionSetHostKeyVerification(virNetSSHSessionPtr sess, } } - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return 0; no_memory: virReportOOMError(); error: - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return -1; } @@ -1185,16 +1184,9 @@ virNetSSHSessionPtr virNetSSHSessionNew(void) if (virNetSSHSessionInitialize() < 0) goto error; - if (!(sess = virObjectNew(virNetSSHSessionClass))) + if (!(sess = virObjectLockableNew(virNetSSHSessionClass))) goto error; - /* initialize internal structures */ - if (virMutexInit(&sess->lock) < 0) { - virReportError(VIR_ERR_SSH, "%s", - _("Failed to initialize mutex")); - goto error; - } - /* initialize session data, use the internal data for callbacks * and stick to default memory management functions */ if (!(sess->session = libssh2_session_init_ex(NULL, @@ -1250,7 +1242,7 @@ virNetSSHSessionConnect(virNetSSHSessionPtr sess, return -1; } - virMutexLock(&sess->lock); + virObjectLock(sess); /* check if configuration is valid */ if ((ret = virNetSSHValidateConfig(sess)) < 0) @@ -1284,12 +1276,12 @@ virNetSSHSessionConnect(virNetSSHSessionPtr sess, libssh2_session_set_blocking(sess->session, 0); sess->state = VIR_NET_SSH_STATE_HANDSHAKE_COMPLETE; - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return ret; error: sess->state = VIR_NET_SSH_STATE_ERROR; - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return ret; } @@ -1302,7 +1294,7 @@ virNetSSHChannelRead(virNetSSHSessionPtr sess, ssize_t ret = -1; ssize_t read_n = 0; - virMutexLock(&sess->lock); + virObjectLock(sess); if (sess->state != VIR_NET_SSH_STATE_HANDSHAKE_COMPLETE) { if (sess->state == VIR_NET_SSH_STATE_ERROR_REMOTE) @@ -1314,7 +1306,7 @@ virNetSSHChannelRead(virNetSSHSessionPtr sess, virReportError(VIR_ERR_SSH, "%s", _("Tried to write socket in error state")); - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return -1; } @@ -1387,22 +1379,22 @@ virNetSSHChannelRead(virNetSSHSessionPtr sess, libssh2_channel_get_exit_status(sess->channel)); sess->channelCommandReturnValue = libssh2_channel_get_exit_status(sess->channel); sess->state = VIR_NET_SSH_STATE_ERROR_REMOTE; - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return -1; } sess->state = VIR_NET_SSH_STATE_CLOSED; - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return -1; } success: - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return read_n; error: sess->state = VIR_NET_SSH_STATE_ERROR; - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return ret; } @@ -1413,7 +1405,7 @@ virNetSSHChannelWrite(virNetSSHSessionPtr sess, { ssize_t ret; - virMutexLock(&sess->lock); + virObjectLock(sess); if (sess->state != VIR_NET_SSH_STATE_HANDSHAKE_COMPLETE) { if (sess->state == VIR_NET_SSH_STATE_ERROR_REMOTE) @@ -1459,7 +1451,7 @@ virNetSSHChannelWrite(virNetSSHSessionPtr sess, } cleanup: - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return ret; } @@ -1471,10 +1463,10 @@ virNetSSHSessionHasCachedData(virNetSSHSessionPtr sess) if (!sess) return false; - virMutexLock(&sess->lock); + virObjectLock(sess); ret = sess->bufUsed > 0; - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return ret; } diff --git a/src/rpc/virnettlscontext.c b/src/rpc/virnettlscontext.c index 3e194f9..0f0ddff 100644 --- a/src/rpc/virnettlscontext.c +++ b/src/rpc/virnettlscontext.c @@ -50,9 +50,7 @@ #define VIR_FROM_THIS VIR_FROM_RPC struct _virNetTLSContext { - virObject object; - - virMutex lock; + virObjectLockable parent; gnutls_certificate_credentials_t x509cred; gnutls_dh_params_t dhParams; @@ -63,9 +61,7 @@ struct _virNetTLSContext { }; struct _virNetTLSSession { - virObject object; - - virMutex lock; + virObjectLockable parent; bool handshakeComplete; @@ -85,13 +81,13 @@ static void virNetTLSSessionDispose(void *obj); static int virNetTLSContextOnceInit(void) { - if (!(virNetTLSContextClass = virClassNew(virClassForObject(), + if (!(virNetTLSContextClass = virClassNew(virClassForObjectLockable(), "virNetTLSContext", sizeof(virNetTLSContext), virNetTLSContextDispose))) return -1; - if (!(virNetTLSSessionClass = virClassNew(virClassForObject(), + if (!(virNetTLSSessionClass = virClassNew(virClassForObjectLockable(), "virNetTLSSession", sizeof(virNetTLSSession), virNetTLSSessionDispose))) @@ -676,15 +672,8 @@ static virNetTLSContextPtr virNetTLSContextNew(const char *cacert, if (virNetTLSContextInitialize() < 0) return NULL; - if (!(ctxt = virObjectNew(virNetTLSContextClass))) - return NULL; - - if (virMutexInit(&ctxt->lock) < 0) { - virReportError(VIR_ERR_INTERNAL_ERROR, "%s", - _("Failed to initialized mutex")); - VIR_FREE(ctxt); + if (!(ctxt = virObjectLockableNew(virNetTLSContextClass))) return NULL; - } if ((gnutlsdebug = getenv("LIBVIRT_GNUTLS_DEBUG")) != NULL) { int val; @@ -1097,8 +1086,8 @@ int virNetTLSContextCheckCertificate(virNetTLSContextPtr ctxt, { int ret = -1; - virMutexLock(&ctxt->lock); - virMutexLock(&sess->lock); + virObjectLock(ctxt); + virObjectLock(sess); if (virNetTLSContextValidCertificate(ctxt, sess) < 0) { virErrorPtr err = virGetLastError(); VIR_WARN("Certificate check failed %s", err && err->message ? err->message : "<unknown>"); @@ -1114,8 +1103,8 @@ int virNetTLSContextCheckCertificate(virNetTLSContextPtr ctxt, ret = 0; cleanup: - virMutexUnlock(&ctxt->lock); - virMutexUnlock(&sess->lock); + virObjectUnlock(ctxt); + virObjectUnlock(sess); return ret; } @@ -1126,7 +1115,6 @@ void virNetTLSContextDispose(void *obj) gnutls_dh_params_deinit(ctxt->dhParams); gnutls_certificate_free_credentials(ctxt->x509cred); - virMutexDestroy(&ctxt->lock); } @@ -1167,16 +1155,9 @@ virNetTLSSessionPtr virNetTLSSessionNew(virNetTLSContextPtr ctxt, VIR_DEBUG("ctxt=%p hostname=%s isServer=%d", ctxt, NULLSTR(hostname), ctxt->isServer); - if (!(sess = virObjectNew(virNetTLSSessionClass))) + if (!(sess = virObjectLockableNew(virNetTLSSessionClass))) return NULL; - if (virMutexInit(&sess->lock) < 0) { - virReportError(VIR_ERR_INTERNAL_ERROR, "%s", - _("Failed to initialized mutex")); - VIR_FREE(sess); - return NULL; - } - if (hostname && !(sess->hostname = strdup(hostname))) { virReportOOMError(); @@ -1243,11 +1224,11 @@ void virNetTLSSessionSetIOCallbacks(virNetTLSSessionPtr sess, virNetTLSSessionReadFunc readFunc, void *opaque) { - virMutexLock(&sess->lock); + virObjectLock(sess); sess->writeFunc = writeFunc; sess->readFunc = readFunc; sess->opaque = opaque; - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); } @@ -1256,7 +1237,7 @@ ssize_t virNetTLSSessionWrite(virNetTLSSessionPtr sess, { ssize_t ret; - virMutexLock(&sess->lock); + virObjectLock(sess); ret = gnutls_record_send(sess->session, buf, len); if (ret >= 0) @@ -1280,7 +1261,7 @@ ssize_t virNetTLSSessionWrite(virNetTLSSessionPtr sess, ret = -1; cleanup: - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return ret; } @@ -1289,7 +1270,7 @@ ssize_t virNetTLSSessionRead(virNetTLSSessionPtr sess, { ssize_t ret; - virMutexLock(&sess->lock); + virObjectLock(sess); ret = gnutls_record_recv(sess->session, buf, len); if (ret >= 0) @@ -1310,7 +1291,7 @@ ssize_t virNetTLSSessionRead(virNetTLSSessionPtr sess, ret = -1; cleanup: - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return ret; } @@ -1318,7 +1299,7 @@ int virNetTLSSessionHandshake(virNetTLSSessionPtr sess) { int ret; VIR_DEBUG("sess=%p", sess); - virMutexLock(&sess->lock); + virObjectLock(sess); ret = gnutls_handshake(sess->session); VIR_DEBUG("Ret=%d", ret); if (ret == 0) { @@ -1342,7 +1323,7 @@ int virNetTLSSessionHandshake(virNetTLSSessionPtr sess) ret = -1; cleanup: - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return ret; } @@ -1350,14 +1331,14 @@ virNetTLSSessionHandshakeStatus virNetTLSSessionGetHandshakeStatus(virNetTLSSessionPtr sess) { virNetTLSSessionHandshakeStatus ret; - virMutexLock(&sess->lock); + virObjectLock(sess); if (sess->handshakeComplete) ret = VIR_NET_TLS_HANDSHAKE_COMPLETE; else if (gnutls_record_get_direction(sess->session) == 0) ret = VIR_NET_TLS_HANDSHAKE_RECVING; else ret = VIR_NET_TLS_HANDSHAKE_SENDING; - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return ret; } @@ -1365,7 +1346,7 @@ int virNetTLSSessionGetKeySize(virNetTLSSessionPtr sess) { gnutls_cipher_algorithm_t cipher; int ssf; - virMutexLock(&sess->lock); + virObjectLock(sess); cipher = gnutls_cipher_get(sess->session); if (!(ssf = gnutls_cipher_get_key_size(cipher))) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", @@ -1375,7 +1356,7 @@ int virNetTLSSessionGetKeySize(virNetTLSSessionPtr sess) } cleanup: - virMutexUnlock(&sess->lock); + virObjectUnlock(sess); return ssf; } @@ -1386,7 +1367,6 @@ void virNetTLSSessionDispose(void *obj) VIR_FREE(sess->hostname); gnutls_deinit(sess->session); - virMutexDestroy(&sess->lock); } /* -- 1.8.0.1