/** * 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); }