External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2025-03-20 07:59:00 +00:00
Code

virFDStreamData: Turn into virObjectLockable

Browse Source 
While this is no functional change, it makes the code look a bit
nicer. Moreover, it prepares ground for future work.

Signed-off-by: Michal Privoznik <mprivozn@redhat.com>
Reviewed-by: John Ferlan <jferlan@redhat.com>
This commit is contained in:
Michal Privoznik 2016-06-16 12:07:41 +02:00
parent 58667ddd5b
commit 585eb46920
1 changed files with 57 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

97
src/util/virfdstream.c
View File

@ -53,6 +53,8 @@ VIR_LOG_INIT("fdstream");
typedef struct virFDStreamData virFDStreamData; typedef struct virFDStreamData virFDStreamData;
typedef virFDStreamData *virFDStreamDataPtr; typedef virFDStreamData *virFDStreamDataPtr;
struct virFDStreamData { struct virFDStreamData {
virObjectLockable parent;
int fd; int fd;
int errfd; int errfd;
virCommandPtr cmd; virCommandPtr cmd;
@ -77,10 +79,31 @@ struct virFDStreamData {
virFDStreamInternalCloseCb icbCb; virFDStreamInternalCloseCb icbCb;
virFDStreamInternalCloseCbFreeOpaque icbFreeOpaque; virFDStreamInternalCloseCbFreeOpaque icbFreeOpaque;
void *icbOpaque; void *icbOpaque;
virMutex lock;
}; };
static virClassPtr virFDStreamDataClass;
static void
virFDStreamDataDispose(void *obj)
{
virFDStreamDataPtr fdst = obj;
VIR_DEBUG("obj=%p", fdst);
}
static int virFDStreamDataOnceInit(void)
{
if (!(virFDStreamDataClass = virClassNew(virClassForObjectLockable(),
"virFDStreamData",
sizeof(virFDStreamData),
virFDStreamDataDispose)))
return -1;
return 0;
}
VIR_ONCE_GLOBAL_INIT(virFDStreamData)
static int virFDStreamRemoveCallback(virStreamPtr stream) static int virFDStreamRemoveCallback(virStreamPtr stream)
{ {
@ -93,7 +116,7 @@ static int virFDStreamRemoveCallback(virStreamPtr stream)
return -1; return -1;
} }
virMutexLock(&fdst->lock); virObjectLock(fdst);
if (fdst->watch == 0) { if (fdst->watch == 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("stream does not have a callback registered")); "%s", _("stream does not have a callback registered"));
@ -115,7 +138,7 @@ static int virFDStreamRemoveCallback(virStreamPtr stream)
ret = 0; ret = 0;
cleanup: cleanup:
virMutexUnlock(&fdst->lock); virObjectUnlock(fdst);
return ret; return ret;
} }
@ -130,7 +153,7 @@ static int virFDStreamUpdateCallback(virStreamPtr stream, int events)
return -1; return -1;
} }
virMutexLock(&fdst->lock); virObjectLock(fdst);
if (fdst->watch == 0) { if (fdst->watch == 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("stream does not have a callback registered")); "%s", _("stream does not have a callback registered"));
@ -143,7 +166,7 @@ static int virFDStreamUpdateCallback(virStreamPtr stream, int events)
ret = 0; ret = 0;
cleanup: cleanup:
virMutexUnlock(&fdst->lock); virObjectUnlock(fdst);
return ret; return ret;
} }
@ -162,9 +185,9 @@ static void virFDStreamEvent(int watch ATTRIBUTE_UNUSED,
if (!fdst) if (!fdst)
return; return;
virMutexLock(&fdst->lock); virObjectLock(fdst);
if (!fdst->cb) { if (!fdst->cb) {
virMutexUnlock(&fdst->lock); virObjectUnlock(fdst);
return; return;
} }
@ -172,21 +195,19 @@ static void virFDStreamEvent(int watch ATTRIBUTE_UNUSED,
cbopaque = fdst->opaque; cbopaque = fdst->opaque;
ff = fdst->ff; ff = fdst->ff;
fdst->dispatching = true; fdst->dispatching = true;
virMutexUnlock(&fdst->lock); virObjectUnlock(fdst);
cb(stream, events, cbopaque); cb(stream, events, cbopaque);
virMutexLock(&fdst->lock); virObjectLock(fdst);
fdst->dispatching = false; fdst->dispatching = false;
if (fdst->cbRemoved && ff) if (fdst->cbRemoved && ff)
(ff)(cbopaque); (ff)(cbopaque);
closed = fdst->closed; closed = fdst->closed;
virMutexUnlock(&fdst->lock); virObjectUnlock(fdst);
if (closed) { if (closed)
virMutexDestroy(&fdst->lock); virObjectUnref(fdst);
VIR_FREE(fdst);
}
} }
static void virFDStreamCallbackFree(void *opaque) static void virFDStreamCallbackFree(void *opaque)
@ -211,7 +232,7 @@ virFDStreamAddCallback(virStreamPtr st,
return -1; return -1;
} }
virMutexLock(&fdst->lock); virObjectLock(fdst);
if (fdst->watch != 0) { if (fdst->watch != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("stream already has a callback registered")); "%s", _("stream already has a callback registered"));
@ -239,7 +260,7 @@ virFDStreamAddCallback(virStreamPtr st,
ret = 0; ret = 0;
cleanup: cleanup:
virMutexUnlock(&fdst->lock); virObjectUnlock(fdst);
return ret; return ret;
} }
@ -307,7 +328,7 @@ virFDStreamCloseInt(virStreamPtr st, bool streamAbort)
if (!st || !(fdst = st->privateData) || fdst->abortCallbackDispatching) if (!st || !(fdst = st->privateData) || fdst->abortCallbackDispatching)
return 0; return 0;
virMutexLock(&fdst->lock); virObjectLock(fdst);
/* aborting the stream, ensure the callback is called if it's /* aborting the stream, ensure the callback is called if it's
* registered for stream error event */ * registered for stream error event */
@ -317,7 +338,7 @@ virFDStreamCloseInt(virStreamPtr st, bool streamAbort)
VIR_STREAM_EVENT_WRITABLE))) { VIR_STREAM_EVENT_WRITABLE))) {
/* don't enter this function accidentally from the callback again */ /* don't enter this function accidentally from the callback again */
if (fdst->abortCallbackCalled) { if (fdst->abortCallbackCalled) {
virMutexUnlock(&fdst->lock); virObjectUnlock(fdst);
return 0; return 0;
} }
@ -327,12 +348,12 @@ virFDStreamCloseInt(virStreamPtr st, bool streamAbort)
/* cache the pointers */ /* cache the pointers */
cb = fdst->cb; cb = fdst->cb;
opaque = fdst->opaque; opaque = fdst->opaque;
virMutexUnlock(&fdst->lock); virObjectUnlock(fdst);
/* call failure callback, poll reports nothing on closed fd */ /* call failure callback, poll reports nothing on closed fd */
(cb)(st, VIR_STREAM_EVENT_ERROR, opaque); (cb)(st, VIR_STREAM_EVENT_ERROR, opaque);
virMutexLock(&fdst->lock); virObjectLock(fdst);
fdst->abortCallbackDispatching = false; fdst->abortCallbackDispatching = false;
} }
@ -356,11 +377,10 @@ virFDStreamCloseInt(virStreamPtr st, bool streamAbort)
if (fdst->dispatching) { if (fdst->dispatching) {
fdst->closed = true; fdst->closed = true;
virMutexUnlock(&fdst->lock); virObjectUnlock(fdst);
} else { } else {
virMutexUnlock(&fdst->lock); virObjectUnlock(fdst);
virMutexDestroy(&fdst->lock); virObjectUnref(fdst);
VIR_FREE(fdst);
} }
return ret; return ret;
@ -395,13 +415,13 @@ static int virFDStreamWrite(virStreamPtr st, const char *bytes, size_t nbytes)
return -1; return -1;
} }
virMutexLock(&fdst->lock); virObjectLock(fdst);
if (fdst->length) { if (fdst->length) {
if (fdst->length == fdst->offset) { if (fdst->length == fdst->offset) {
virReportSystemError(ENOSPC, "%s", virReportSystemError(ENOSPC, "%s",
_("cannot write to stream")); _("cannot write to stream"));
virMutexUnlock(&fdst->lock); virObjectUnlock(fdst);
return -1; return -1;
} }
@ -427,7 +447,7 @@ static int virFDStreamWrite(virStreamPtr st, const char *bytes, size_t nbytes)
fdst->offset += ret; fdst->offset += ret;
} }
virMutexUnlock(&fdst->lock); virObjectUnlock(fdst);
return ret; return ret;
} }
@ -449,11 +469,11 @@ static int virFDStreamRead(virStreamPtr st, char *bytes, size_t nbytes)
return -1; return -1;
} }
virMutexLock(&fdst->lock); virObjectLock(fdst);
if (fdst->length) { if (fdst->length) {
if (fdst->length == fdst->offset) { if (fdst->length == fdst->offset) {
virMutexUnlock(&fdst->lock); virObjectUnlock(fdst);
return 0; return 0;
} }
@ -479,7 +499,7 @@ static int virFDStreamRead(virStreamPtr st, char *bytes, size_t nbytes)
fdst->offset += ret; fdst->offset += ret;
} }
virMutexUnlock(&fdst->lock); virObjectUnlock(fdst);
return ret; return ret;
} }
@ -505,25 +525,22 @@ static int virFDStreamOpenInternal(virStreamPtr st,
VIR_DEBUG("st=%p fd=%d cmd=%p errfd=%d length=%llu", VIR_DEBUG("st=%p fd=%d cmd=%p errfd=%d length=%llu",
st, fd, cmd, errfd, length); st, fd, cmd, errfd, length);
if (virFDStreamDataInitialize() < 0)
return -1;
if ((st->flags & VIR_STREAM_NONBLOCK) && if ((st->flags & VIR_STREAM_NONBLOCK) &&
virSetNonBlock(fd) < 0) { virSetNonBlock(fd) < 0) {
virReportSystemError(errno, "%s", _("Unable to set non-blocking mode")); virReportSystemError(errno, "%s", _("Unable to set non-blocking mode"));
return -1; return -1;
} }
if (VIR_ALLOC(fdst) < 0) if (!(fdst = virObjectLockableNew(virFDStreamDataClass)))
return -1; return -1;
fdst->fd = fd; fdst->fd = fd;
fdst->cmd = cmd; fdst->cmd = cmd;
fdst->errfd = errfd; fdst->errfd = errfd;
fdst->length = length; fdst->length = length;
if (virMutexInit(&fdst->lock) < 0) {
VIR_FREE(fdst);
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Unable to initialize mutex"));
return -1;
}
st->driver = &virFDStreamDrv; st->driver = &virFDStreamDrv;
st->privateData = fdst; st->privateData = fdst;
@ -821,7 +838,7 @@ int virFDStreamSetInternalCloseCb(virStreamPtr st,
{ {
virFDStreamDataPtr fdst = st->privateData; virFDStreamDataPtr fdst = st->privateData;
virMutexLock(&fdst->lock); virObjectLock(fdst);
if (fdst->icbFreeOpaque) if (fdst->icbFreeOpaque)
(fdst->icbFreeOpaque)(fdst->icbOpaque); (fdst->icbFreeOpaque)(fdst->icbOpaque);
@ -830,6 +847,6 @@ int virFDStreamSetInternalCloseCb(virStreamPtr st,
fdst->icbOpaque = opaque; fdst->icbOpaque = opaque;
fdst->icbFreeOpaque = fcb; fdst->icbFreeOpaque = fcb;
virMutexUnlock(&fdst->lock); virObjectUnlock(fdst);
return 0; return 0;
} }