自学教程：C++ virMutexDestroy函数代码示例

/** * 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 */intvirNetlinkEventServiceStop(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. */virConnectPtrvirGetConnect(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 voidvirReleaseConnect(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 */intvirNetlinkEventServiceStopAll(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 */intvirNetlinkEventServiceStop(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;}

voidremoteAdmClientFree(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 voidvirConsoleFree(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 */voidvmwareFreeDriver(struct vmware_driver *driver){    if (!driver)        return;    virMutexDestroy(&driver->lock);    virObjectUnref(driver->domains);    virObjectUnref(driver->caps);    virObjectUnref(driver->xmlopt);    VIR_FREE(driver);}

static intvirFDStreamClose(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 voidvirNWFilterObjFree(virNWFilterObjPtr obj){    if (!obj)        return;    virNWFilterDefFree(obj->def);    virNWFilterDefFree(obj->newDef);    virMutexDestroy(&obj->lock);    VIR_FREE(obj);}

static voidvirLogDaemonFree(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 voidvirLockDaemonFree(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. */voidvirObjectEventStateFree(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 intlightosStateCleanup(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 intsecretStateCleanup(void){    if (!driver)        return -1;    secretDriverLock();    virObjectUnref(driver->secrets);    VIR_FREE(driver->configDir);    secretDriverUnlock();    virMutexDestroy(&driver->lock);    VIR_FREE(driver);    return 0;}

static intparallelsStorageClose(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 boolvirshDeinit(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);}