/**
* virNetlinkEventServiceStop:
*
* stop the monitor to receive netlink messages for libvirtd.
* This removes the netlink socket fd from the event handler.
*
* @protocol: netlink protocol
*
* Returns -1 if the monitor cannot be unregistered, 0 upon success
*/
int
virNetlinkEventServiceStop(unsigned int protocol)
{
if (protocol >= MAX_LINKS)
return -EINVAL;
virNetlinkEventSrvPrivatePtr srv = server[protocol];
size_t i;
VIR_INFO("stopping netlink event service");
if (!server[protocol])
return 0;
virNetlinkEventServerLock(srv);
nl_close(srv->netlinknh);
virNetlinkFree(srv->netlinknh);
virEventRemoveHandle(srv->eventwatch);
/* free any remaining clients on the list */
for (i = 0; i < srv->handlesCount; i++) {
if (srv->handles[i].deleted == VIR_NETLINK_HANDLE_VALID)
virNetlinkEventRemoveClientPrimitive(i, protocol);
}
server[protocol] = NULL;
virNetlinkEventServerUnlock(srv);
virMutexDestroy(&srv->lock);
VIR_FREE(srv);
return 0;
}
/**
* virGetConnect:
*
* Allocates a new hypervisor connection structure
*
* Returns a new pointer or NULL in case of error.
*/
virConnectPtr
virGetConnect(void) {
virConnectPtr ret;
if (VIR_ALLOC(ret) < 0) {
virReportOOMError();
goto failed;
}
if (virMutexInit(&ret->lock) < 0) {
VIR_FREE(ret);
goto failed;
}
ret->magic = VIR_CONNECT_MAGIC;
ret->driver = NULL;
ret->networkDriver = NULL;
ret->privateData = NULL;
ret->networkPrivateData = NULL;
ret->interfacePrivateData = NULL;
ret->refs = 1;
return ret;
failed:
if (ret != NULL) {
virMutexDestroy(&ret->lock);
VIR_FREE(ret);
}
return NULL;
}
/**
* virReleaseConnect:
* @conn: the hypervisor connection to release
*
* Unconditionally release all memory associated with a connection.
* The conn.lock mutex must be held prior to calling this, and will
* be released prior to this returning. The connection obj must not
* be used once this method returns.
*/
static void
virReleaseConnect(virConnectPtr conn) {
VIR_DEBUG("release connection %p", conn);
/* make sure to release the connection lock before we call the
* close callbacks, otherwise we will deadlock if an error
* is raised by any of the callbacks */
virMutexUnlock(&conn->lock);
if (conn->networkDriver)
conn->networkDriver->close(conn);
if (conn->interfaceDriver)
conn->interfaceDriver->close(conn);
if (conn->storageDriver)
conn->storageDriver->close(conn);
if (conn->deviceMonitor)
conn->deviceMonitor->close(conn);
if (conn->secretDriver)
conn->secretDriver->close(conn);
if (conn->nwfilterDriver)
conn->nwfilterDriver->close(conn);
if (conn->driver)
conn->driver->close(conn);
virMutexLock(&conn->lock);
virResetError(&conn->err);
virURIFree(conn->uri);
virMutexUnlock(&conn->lock);
virMutexDestroy(&conn->lock);
VIR_FREE(conn);
}
/**
* virNetlinkEventServiceStopAll:
*
* Stop all the monitors to receive netlink messages for libvirtd.
*
* Returns -1 if any monitor cannot be unregistered, 0 upon success
*/
int
virNetlinkEventServiceStopAll(void)
{
size_t i, j;
virNetlinkEventSrvPrivatePtr srv = NULL;
VIR_INFO("stopping all netlink event services");
for (i = 0; i < MAX_LINKS; i++) {
srv = server[i];
if (!srv)
continue;
virNetlinkEventServerLock(srv);
nl_close(srv->netlinknh);
virNetlinkFree(srv->netlinknh);
virEventRemoveHandle(srv->eventwatch);
for (j = 0; j < srv->handlesCount; j++) {
if (srv->handles[j].deleted == VIR_NETLINK_HANDLE_VALID)
virNetlinkEventRemoveClientPrimitive(j, i);
}
server[i] = NULL;
virNetlinkEventServerUnlock(srv);
virMutexDestroy(&srv->lock);
VIR_FREE(srv);
}
return 0;
}
/**
* virNetlinkEventServiceStop:
*
* stop the monitor to receive netlink messages for libvirtd.
* This removes the netlink socket fd from the event handler.
*
* Returns -1 if the monitor cannot be unregistered, 0 upon success
*/
int
virNetlinkEventServiceStop(void)
{
virNetlinkEventSrvPrivatePtr srv = server;
int i;
VIR_INFO("stopping netlink event service");
if (!server)
return 0;
virNetlinkEventServerLock(srv);
nl_close(srv->netlinknh);
virNetlinkFree(srv->netlinknh);
virEventRemoveHandle(srv->eventwatch);
/* free any remaining clients on the list */
for (i = 0; i < srv->handlesCount; i++) {
if (srv->handles[i].deleted == VIR_NETLINK_HANDLE_VALID)
virNetlinkEventRemoveClientPrimitive(i);
}
server = 0;
virNetlinkEventServerUnlock(srv);
virMutexDestroy(&srv->lock);
VIR_FREE(srv);
return 0;
}
void qemuTestDriverFree(virQEMUDriver *driver)
{
virMutexDestroy(&driver->lock);
virQEMUCapsCacheFree(driver->qemuCapsCache);
virObjectUnref(driver->xmlopt);
virObjectUnref(driver->caps);
virObjectUnref(driver->config);
}
void virInterfaceObjFree(virInterfaceObjPtr iface)
{
if (!iface)
return;
virInterfaceDefFree(iface->def);
virMutexDestroy(&iface->lock);
VIR_FREE(iface);
}
int virCondDestroy(virCondPtr c)
{
if (c->waiters) {
errno = EINVAL;
return -1;
}
virMutexDestroy(&c->lock);
return 0;
}
void
remoteAdmClientFree(void *data)
{
struct daemonAdmClientPrivate *priv = data;
virMutexDestroy(&priv->lock);
virObjectUnref(priv->dmn);
VIR_FREE(priv);
}
void virNetSASLSessionDispose(void *obj)
{
virNetSASLSessionPtr sasl = obj;
if (sasl->conn)
sasl_dispose(&sasl->conn);
virMutexDestroy(&sasl->lock);
}
static void qemuAgentDispose(void *obj)
{
qemuAgentPtr mon = obj;
VIR_DEBUG("mon=%p", mon);
if (mon->cb && mon->cb->destroy)
(mon->cb->destroy)(mon, mon->vm);
ignore_value(virCondDestroy(&mon->notify));
virMutexDestroy(&mon->lock);
VIR_FREE(mon->buffer);
}
void virNWFilterTechDriversShutdown(void)
{
size_t i = 0;
while (filter_tech_drivers[i]) {
if ((filter_tech_drivers[i]->flags & TECHDRV_FLAG_INITIALIZED))
filter_tech_drivers[i]->shutdown();
i++;
}
virMutexDestroy(&updateMutex);
}
static void
virConsoleFree(virConsolePtr con)
{
if (!con)
return;
if (con->st)
virStreamFree(con->st);
virMutexDestroy(&con->lock);
virCondDestroy(&con->cond);
VIR_FREE(con);
}
/* Free all memory associated with a vmware_driver structure */
void
vmwareFreeDriver(struct vmware_driver *driver)
{
if (!driver)
return;
virMutexDestroy(&driver->lock);
virObjectUnref(driver->domains);
virObjectUnref(driver->caps);
virObjectUnref(driver->xmlopt);
VIR_FREE(driver);
}
static int
virFDStreamClose(virStreamPtr st)
{
struct virFDStreamData *fdst = st->privateData;
int ret;
VIR_DEBUG("st=%p", st);
if (!fdst)
return 0;
virMutexLock(&fdst->lock);
ret = VIR_CLOSE(fdst->fd);
if (fdst->cmd) {
char buf[1024];
ssize_t len;
int status;
if ((len = saferead(fdst->errfd, buf, sizeof(buf)-1)) < 0)
buf[0] = '\0';
else
buf[len] = '\0';
if (virCommandWait(fdst->cmd, &status) < 0) {
ret = -1;
} else if (status != 0) {
if (buf[0] == '\0') {
if (WIFEXITED(status)) {
streamsReportError(VIR_ERR_INTERNAL_ERROR,
_("I/O helper exited with status %d"),
WEXITSTATUS(status));
} else {
streamsReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("I/O helper exited abnormally"));
}
} else {
streamsReportError(VIR_ERR_INTERNAL_ERROR, "%s",
buf);
}
ret = -1;
}
virCommandFree(fdst->cmd);
}
st->privateData = NULL;
virMutexUnlock(&fdst->lock);
virMutexDestroy(&fdst->lock);
VIR_FREE(fdst);
return ret;
}
static void
virNWFilterObjFree(virNWFilterObjPtr obj)
{
if (!obj)
return;
virNWFilterDefFree(obj->def);
virNWFilterDefFree(obj->newDef);
virMutexDestroy(&obj->lock);
VIR_FREE(obj);
}
static void
virLogDaemonFree(virLogDaemonPtr logd)
{
if (!logd)
return;
virObjectUnref(logd->handler);
virMutexDestroy(&logd->lock);
virObjectUnref(logd->srv);
virObjectUnref(logd->dmn);
VIR_FREE(logd);
}
void qemuTestDriverFree(virQEMUDriver *driver)
{
virMutexDestroy(&driver->lock);
if (driver->config) {
virFileDeleteTree(driver->config->stateDir);
virFileDeleteTree(driver->config->configDir);
}
virQEMUCapsCacheFree(driver->qemuCapsCache);
virObjectUnref(driver->xmlopt);
virObjectUnref(driver->caps);
virObjectUnref(driver->config);
virObjectUnref(driver->securityManager);
}
/**
* virLogShutdown:
*
* Shutdown the logging module
*/
void virLogShutdown(void) {
if (!virLogInitialized)
return;
virLogLock();
virLogResetFilters();
virLogResetOutputs();
virLogLen = 0;
virLogStart = 0;
virLogEnd = 0;
virLogUnlock();
virMutexDestroy(&virLogMutex);
virLogInitialized = 0;
}
void virNodeDeviceObjFree(virNodeDeviceObjPtr dev)
{
if (!dev)
return;
virNodeDeviceDefFree(dev->def);
if (dev->privateFree)
(*dev->privateFree)(dev->privateData);
virMutexDestroy(&dev->lock);
VIR_FREE(dev);
}
static void
virLockDaemonFree(virLockDaemonPtr lockd)
{
if (!lockd)
return;
virMutexDestroy(&lockd->lock);
virObjectUnref(lockd->dmn);
virHashFree(lockd->lockspaces);
virLockSpaceFree(lockd->defaultLockspace);
VIR_FREE(lockd);
}
void qemuMonitorTestFree(qemuMonitorTestPtr test)
{
size_t i;
int timer = -1;
if (!test)
return;
virMutexLock(&test->lock);
if (test->running) {
test->quit = true;
/* HACK: Add a dummy timeout to break event loop */
timer = virEventAddTimeout(0, qemuMonitorTestFreeTimer, NULL, NULL);
}
virMutexUnlock(&test->lock);
if (test->client) {
virNetSocketRemoveIOCallback(test->client);
virNetSocketClose(test->client);
virObjectUnref(test->client);
}
virObjectUnref(test->server);
if (test->mon) {
virObjectUnlock(test->mon);
qemuMonitorClose(test->mon);
}
virObjectUnref(test->vm);
virThreadJoin(&test->thread);
if (timer != -1)
virEventRemoveTimeout(timer);
VIR_FREE(test->incoming);
VIR_FREE(test->outgoing);
for (i = 0 ; i < test->nitems ; i++)
qemuMonitorTestItemFree(test->items[i]);
VIR_FREE(test->items);
if (test->tmpdir && rmdir(test->tmpdir) < 0)
VIR_WARN("Failed to remove tempdir: %s", strerror(errno));
VIR_FREE(test->tmpdir);
virMutexDestroy(&test->lock);
VIR_FREE(test);
}
/**
* virObjectEventStateFree:
* @list: virObjectEventStatePtr to free
*
* Free a virObjectEventStatePtr and its members, and unregister the timer.
*/
void
virObjectEventStateFree(virObjectEventStatePtr state)
{
if (!state)
return;
virObjectEventCallbackListFree(state->callbacks);
virObjectEventQueueFree(state->queue);
if (state->timer != -1)
virEventRemoveTimeout(state->timer);
virMutexDestroy(&state->lock);
VIR_FREE(state);
}
void virNetSASLContextFree(virNetSASLContextPtr ctxt)
{
if (!ctxt)
return;
virMutexLock(&ctxt->lock);
ctxt->refs--;
if (ctxt->refs > 0) {
virMutexUnlock(&ctxt->lock);
return;
}
virMutexUnlock(&ctxt->lock);
virMutexDestroy(&ctxt->lock);
VIR_FREE(ctxt);
}
static int
lightosStateCleanup(void)
{
VIR_DEBUG("lightos state cleanup");
if (lightos_driver == NULL)
return -1;
virObjectUnref(lightos_driver->domains);
virObjectUnref(lightos_driver->caps);
virObjectUnref(lightos_driver->xmlopt);
virMutexDestroy(&lightos_driver->lock);
VIR_FREE(lightos_driver);
return 0;
}
void virNetClientStreamFree(virNetClientStreamPtr st)
{
virMutexLock(&st->lock);
st->refs--;
if (st->refs > 0) {
virMutexUnlock(&st->lock);
return;
}
virMutexUnlock(&st->lock);
virResetError(&st->err);
VIR_FREE(st->incoming);
virMutexDestroy(&st->lock);
virNetClientProgramFree(st->prog);
VIR_FREE(st);
}
static int
secretStateCleanup(void)
{
if (!driver)
return -1;
secretDriverLock();
virObjectUnref(driver->secrets);
VIR_FREE(driver->configDir);
secretDriverUnlock();
virMutexDestroy(&driver->lock);
VIR_FREE(driver);
return 0;
}
static int
parallelsStorageClose(virConnectPtr conn)
{
parallelsConnPtr privconn = conn->privateData;
virStorageDriverStatePtr storageState = conn->storagePrivateData;
conn->storagePrivateData = NULL;
parallelsStorageLock(storageState);
virStoragePoolObjListFree(&privconn->pools);
VIR_FREE(storageState->configDir);
VIR_FREE(storageState->autostartDir);
parallelsStorageUnlock(storageState);
virMutexDestroy(&storageState->lock);
VIR_FREE(storageState);
return 0;
}
/*
* Deinitialize virsh
*/
static bool
virshDeinit(vshControl *ctl)
{
virshControlPtr priv = ctl->privData;
vshDeinit(ctl);
VIR_FREE(ctl->connname);
if (priv->conn) {
int ret;
virConnectUnregisterCloseCallback(priv->conn, virshCatchDisconnect);
ret = virConnectClose(priv->conn);
if (ret < 0)
vshError(ctl, "%s", _("Failed to disconnect from the hypervisor"));
else if (ret > 0)
vshError(ctl, "%s", _("One or more references were leaked after "
"disconnect from the hypervisor"));
}
virResetLastError();
if (ctl->eventLoopStarted) {
int timer;
virMutexLock(&ctl->lock);
ctl->quit = true;
/* HACK: Add a dummy timeout to break event loop */
timer = virEventAddTimeout(0, virshDeinitTimer, NULL, NULL);
virMutexUnlock(&ctl->lock);
virThreadJoin(&ctl->eventLoop);
if (timer != -1)
virEventRemoveTimeout(timer);
if (ctl->eventTimerId != -1)
virEventRemoveTimeout(ctl->eventTimerId);
ctl->eventLoopStarted = false;
}
virMutexDestroy(&ctl->lock);
return true;
}
void virNetSASLSessionFree(virNetSASLSessionPtr sasl)
{
if (!sasl)
return;
virMutexLock(&sasl->lock);
sasl->refs--;
if (sasl->refs > 0) {
virMutexUnlock(&sasl->lock);
return;
}
if (sasl->conn)
sasl_dispose(&sasl->conn);
virMutexUnlock(&sasl->lock);
virMutexDestroy(&sasl->lock);
VIR_FREE(sasl);
}
