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

char *virSecurityManagerGetMountOptions(virSecurityManagerPtr mgr,                                        virDomainDefPtr vm){    if (mgr->drv->domainGetSecurityMountOptions) {        char *ret;        virObjectLock(mgr);        ret = mgr->drv->domainGetSecurityMountOptions(mgr, vm);        virObjectUnlock(mgr);        return ret;    }    virReportUnsupportedError();    return NULL;}

int virSecurityManagerSetHugepages(virSecurityManagerPtr mgr,                                    virDomainDefPtr vm,                                    const char *path){    if (mgr->drv->domainSetSecurityHugepages) {        int ret;        virObjectLock(mgr);        ret = mgr->drv->domainSetSecurityHugepages(mgr, vm, path);        virObjectUnlock(mgr);        return ret;    }    return 0;}

const char *virSecurityManagerGetModel(virSecurityManagerPtr mgr){    if (mgr->drv->getModel) {        const char *ret;        virObjectLock(mgr);        ret = mgr->drv->getModel(mgr);        virObjectUnlock(mgr);        return ret;    }    virReportUnsupportedError();    return NULL;}

int virSecurityManagerSetProcessLabel(virSecurityManagerPtr mgr,                                      virDomainDefPtr vm){    if (mgr->drv->domainSetSecurityProcessLabel) {        int ret;        virObjectLock(mgr);        ret = mgr->drv->domainSetSecurityProcessLabel(mgr, vm);        virObjectUnlock(mgr);        return ret;    }    virReportUnsupportedError();    return -1;}

static void virLXCProcessMonitorEOFNotify(virLXCMonitorPtr mon,                                          virDomainObjPtr vm){    virLXCDriverPtr driver = lxc_driver;    virObjectEventPtr event = NULL;    virLXCDomainObjPrivatePtr priv;    VIR_DEBUG("mon=%p vm=%p", mon, vm);    virObjectLock(vm);    priv = vm->privateData;    virLXCProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_SHUTDOWN);    if (!priv->wantReboot) {        virLXCProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_SHUTDOWN);        if (!priv->doneStopEvent) {            event = virDomainEventLifecycleNewFromObj(vm,                                             VIR_DOMAIN_EVENT_STOPPED,                                             priv->stopReason);            virDomainAuditStop(vm, "shutdown");        } else {            VIR_DEBUG("Stop event has already been sent");        }        if (!vm->persistent) {            virDomainObjListRemove(driver->domains, vm);            vm = NULL;        }    } else {        int ret = virLXCProcessReboot(driver, vm);        virDomainAuditStop(vm, "reboot");        virDomainAuditStart(vm, "reboot", ret == 0);        if (ret == 0) {            event = virDomainEventRebootNewFromObj(vm);        } else {            event = virDomainEventLifecycleNewFromObj(vm,                                             VIR_DOMAIN_EVENT_STOPPED,                                             priv->stopReason);            if (!vm->persistent) {                virDomainObjListRemove(driver->domains, vm);                vm = NULL;            }        }    }    if (vm)        virObjectUnlock(vm);    if (event) {        virObjectEventStateQueue(driver->domainEventState, event);    }}

boolvirKeepAliveCheckMessage(virKeepAlivePtr ka,                         virNetMessagePtr msg,                         virNetMessagePtr *response){    bool ret = false;    VIR_DEBUG("ka=%p, client=%p, msg=%p",              ka, ka ? ka->client : "(null)", msg);    *response = NULL;    if (!ka)        return false;    virObjectLock(ka);    ka->countToDeath = ka->count;    ka->lastPacketReceived = ka->intervalStart = time(NULL);    if (msg->header.prog == KEEPALIVE_PROGRAM &&        msg->header.vers == KEEPALIVE_PROTOCOL_VERSION &&        msg->header.type == VIR_NET_MESSAGE) {        PROBE(RPC_KEEPALIVE_RECEIVED,              "ka=%p client=%p prog=%d vers=%d proc=%d",              ka, ka->client, msg->header.prog,              msg->header.vers, msg->header.proc);        ret = true;        switch (msg->header.proc) {        case KEEPALIVE_PROC_PING:            VIR_DEBUG("Got keepalive request from client %p", ka->client);            *response = virKeepAliveMessage(ka, KEEPALIVE_PROC_PONG);            break;        case KEEPALIVE_PROC_PONG:            VIR_DEBUG("Got keepalive response from client %p", ka->client);            break;        default:            VIR_DEBUG("Ignoring unknown keepalive message %d from client %p",                      msg->header.proc, ka->client);        }    }    if (ka->timer >= 0)        virEventUpdateTimeout(ka->timer, ka->interval * 1000);    virObjectUnlock(ka);    return ret;}

/* return NULL if a base label is not present */const char *virSecurityManagerGetBaseLabel(virSecurityManagerPtr mgr,                               int virtType){    if (mgr->drv->getBaseLabel) {        const char *ret;        virObjectLock(mgr);        ret = mgr->drv->getBaseLabel(mgr, virtType);        virObjectUnlock(mgr);        return ret;    }    return NULL;}

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

/* * Must be called before fork()'ing to ensure mutex state * is sane for the child to use. A negative return means the * child must not be forked; a successful return must be * followed by a call to virSecurityManagerPostFork() in both * parent and child. */intvirSecurityManagerPreFork(virSecurityManagerPtr mgr){    int ret = 0;    virObjectLock(mgr);    if (mgr->drv->preFork) {        ret = mgr->drv->preFork(mgr);        if (ret < 0)            virObjectUnlock(mgr);    }    return ret;}

void virNetServerClientSetDispatcher(virNetServerClientPtr client,                                     virNetServerClientDispatchFunc func,                                     void *opaque){    virObjectLock(client);    /* Only set dispatcher if not already set, to avoid race     * with dispatch code that runs without locks held     */    if (!client->dispatchFunc) {        client->dispatchFunc = func;        client->dispatchOpaque = opaque;    }    virObjectUnlock(client);}

const char *virSecurityManagerGetModel(virSecurityManagerPtr mgr){    if (mgr->drv->getModel) {        const char *ret;        virObjectLock(mgr);        ret = mgr->drv->getModel(mgr);        virObjectUnlock(mgr);        return ret;    }    virReportError(VIR_ERR_NO_SUPPORT, __FUNCTION__);    return NULL;}

/** * virAdmConnectUnregisterCloseCallback: * @conn: pointer to connection object * @cb: pointer to the current registered callback * * Unregisters the callback previously set with the * virAdmConnectRegisterCloseCallback method. The callback * will no longer receive notifications when the connection * closes. If a virFreeCallback was provided at time of * registration, it will be invoked. * * Returns 0 on success, -1 on error */int virAdmConnectUnregisterCloseCallback(virAdmConnectPtr conn,                                         virAdmConnectCloseFunc cb){    VIR_DEBUG("conn=%p", conn);    virResetLastError();    virCheckAdmConnectReturn(conn, -1);    virObjectLock(conn);    virObjectLock(conn->closeCallback);    virCheckNonNullArgGoto(cb, error);    if (conn->closeCallback->callback != cb) {        virReportError(VIR_ERR_OPERATION_INVALID, "%s",                       _("A different callback was requested"));        goto error;    }    conn->closeCallback->callback = NULL;    if (conn->closeCallback->freeCallback)        conn->closeCallback->freeCallback(conn->closeCallback->opaque);    conn->closeCallback->freeCallback = NULL;    virObjectUnlock(conn->closeCallback);    virObjectUnlock(conn);    virObjectUnref(conn);    return 0; error:    virObjectUnlock(conn->closeCallback);    virObjectUnlock(conn);    virDispatchError(NULL);    return -1;}

intvirSecurityManagerDomainSetDirLabel(virSecurityManagerPtr mgr,                                    virDomainDefPtr vm,                                    const char *path){    if (mgr->drv->domainSetDirLabel) {        int ret;        virObjectLock(mgr);        ret = mgr->drv->domainSetDirLabel(mgr, vm, path);        virObjectUnlock(mgr);        return ret;    }    return 0;}

int virSecurityManagerRestoreImageLabel(virSecurityManagerPtr mgr,                                        virDomainDefPtr vm,                                        virDomainDiskDefPtr disk){    if (mgr->drv->domainRestoreSecurityImageLabel) {        int ret;        virObjectLock(mgr);        ret = mgr->drv->domainRestoreSecurityImageLabel(mgr, vm, disk);        virObjectUnlock(mgr);        return ret;    }    virReportError(VIR_ERR_NO_SUPPORT, __FUNCTION__);    return -1;}

bool virNetServerClientIsSecure(virNetServerClientPtr client){    bool secure = false;    virObjectLock(client);    if (client->tls)        secure = true;#if WITH_SASL    if (client->sasl)        secure = true;#endif    if (client->sock && virNetSocketIsLocal(client->sock))        secure = true;    virObjectUnlock(client);    return secure;}

int virSecurityManagerSetAllLabel(virSecurityManagerPtr mgr,                                  virDomainDefPtr vm,                                  const char *stdin_path){    if (mgr->drv->domainSetSecurityAllLabel) {        int ret;        virObjectLock(mgr);        ret = mgr->drv->domainSetSecurityAllLabel(mgr, vm, stdin_path);        virObjectUnlock(mgr);        return ret;    }    virReportUnsupportedError();    return -1;}

int virSecurityManagerRestoreAllLabel(virSecurityManagerPtr mgr,                                      virDomainDefPtr vm,                                      int migrated){    if (mgr->drv->domainRestoreSecurityAllLabel) {        int ret;        virObjectLock(mgr);        ret = mgr->drv->domainRestoreSecurityAllLabel(mgr, vm, migrated);        virObjectUnlock(mgr);        return ret;    }    virReportUnsupportedError();    return -1;}

int virSecurityManagerRestoreSavedStateLabel(virSecurityManagerPtr mgr,                                             virDomainDefPtr vm,                                             const char *savefile){    if (mgr->drv->domainRestoreSavedStateLabel) {        int ret;        virObjectLock(mgr);        ret = mgr->drv->domainRestoreSavedStateLabel(mgr, vm, savefile);        virObjectUnlock(mgr);        return ret;    }    virReportUnsupportedError();    return -1;}

int virSecurityManagerReserveLabel(virSecurityManagerPtr mgr,                                   virDomainDefPtr vm,                                   pid_t pid){    if (mgr->drv->domainReserveSecurityLabel) {        int ret;        virObjectLock(mgr);        ret = mgr->drv->domainReserveSecurityLabel(mgr, vm, pid);        virObjectUnlock(mgr);        return ret;    }    virReportUnsupportedError();    return -1;}

int virSecurityManagerSetImageLabel(virSecurityManagerPtr mgr,                                    virDomainDefPtr vm,                                    virDomainDiskDefPtr disk){    if (mgr->drv->domainSetSecurityImageLabel) {        int ret;        virObjectLock(mgr);        ret = mgr->drv->domainSetSecurityImageLabel(mgr, vm, disk);        virObjectUnlock(mgr);        return ret;    }    virReportUnsupportedError();    return -1;}

int virSecurityManagerSetTapFDLabel(virSecurityManagerPtr mgr,                                    virDomainDefPtr vm,                                    int fd){    if (mgr->drv->domainSetSecurityTapFDLabel) {        int ret;        virObjectLock(mgr);        ret = mgr->drv->domainSetSecurityTapFDLabel(mgr, vm, fd);        virObjectUnlock(mgr);        return ret;    }    virReportError(VIR_ERR_NO_SUPPORT, __FUNCTION__);    return -1;}

static int virNetServerAddClient(virNetServerPtr srv,                                 virNetServerClientPtr client){    virObjectLock(srv);    if (srv->nclients >= srv->nclients_max) {        virReportError(VIR_ERR_RPC,                       _("Too many active clients (%zu), dropping connection from %s"),                       srv->nclients_max, virNetServerClientRemoteAddrString(client));        goto error;    }    if (virNetServerClientInit(client) < 0)        goto error;    if (VIR_EXPAND_N(srv->clients, srv->nclients, 1) < 0) {        virReportOOMError();        goto error;    }    srv->clients[srv->nclients-1] = client;    virObjectRef(client);    virNetServerClientSetDispatcher(client,                                    virNetServerDispatchNewMessage,                                    srv);    virNetServerClientInitKeepAlive(client, srv->keepaliveInterval,                                    srv->keepaliveCount);    virObjectUnlock(srv);    return 0;error:    virObjectUnlock(srv);    return -1;}

int virSecurityManagerRestoreAllLabel(virSecurityManagerPtr mgr,                                      virDomainDefPtr vm,                                      int migrated){    if (mgr->drv->domainRestoreSecurityAllLabel) {        int ret;        virObjectLock(mgr);        ret = mgr->drv->domainRestoreSecurityAllLabel(mgr, vm, migrated);        virObjectUnlock(mgr);        return ret;    }    virReportError(VIR_ERR_NO_SUPPORT, __FUNCTION__);    return -1;}

int virSecurityManagerSetAllLabel(virSecurityManagerPtr mgr,                                  virDomainDefPtr vm,                                  const char *stdin_path){    if (mgr->drv->domainSetSecurityAllLabel) {        int ret;        virObjectLock(mgr);        ret = mgr->drv->domainSetSecurityAllLabel(mgr, vm, stdin_path);        virObjectUnlock(mgr);        return ret;    }    virReportError(VIR_ERR_NO_SUPPORT, __FUNCTION__);    return -1;}

int virSecurityManagerReserveLabel(virSecurityManagerPtr mgr,                                   virDomainDefPtr vm,                                   pid_t pid){    if (mgr->drv->domainReserveSecurityLabel) {        int ret;        virObjectLock(mgr);        ret = mgr->drv->domainReserveSecurityLabel(mgr, vm, pid);        virObjectUnlock(mgr);        return ret;    }    virReportError(VIR_ERR_NO_SUPPORT, __FUNCTION__);    return -1;}

int virSecurityManagerRestoreSavedStateLabel(virSecurityManagerPtr mgr,                                             virDomainDefPtr vm,                                             const char *savefile){    if (mgr->drv->domainRestoreSavedStateLabel) {        int ret;        virObjectLock(mgr);        ret = mgr->drv->domainRestoreSavedStateLabel(mgr, vm, savefile);        virObjectUnlock(mgr);        return ret;    }    virReportError(VIR_ERR_NO_SUPPORT, __FUNCTION__);    return -1;}

int virPortAllocatorAcquire(virPortAllocatorPtr pa,                            unsigned short *port){    int ret = -1;    size_t i;    *port = 0;    virObjectLock(pa);    for (i = pa->start; i <= pa->end && !*port; i++) {        bool used = false, v6used = false;        if (virBitmapGetBit(pa->bitmap,                            i - pa->start, &used) < 0) {            virReportError(VIR_ERR_INTERNAL_ERROR,                           _("Failed to query port %zu"), i);            goto cleanup;        }        if (used)            continue;        if (virPortAllocatorBindToPort(&v6used, i, AF_INET6) < 0 ||            virPortAllocatorBindToPort(&used, i, AF_INET) < 0)            goto cleanup;        if (!used && !v6used) {            /* Add port to bitmap of reserved ports */            if (virBitmapSetBit(pa->bitmap,                                i - pa->start) < 0) {                virReportError(VIR_ERR_INTERNAL_ERROR,                               _("Failed to reserve port %zu"), i);                goto cleanup;            }            *port = i;            ret = 0;        }    }    if (*port == 0) {        virReportError(VIR_ERR_INTERNAL_ERROR,                       _("Unable to find an unused port in range '%s' (%d-%d)"),                       pa->name, pa->start, pa->end);    } cleanup:    virObjectUnlock(pa);    return ret;}

static intvmwareDomainResume(virDomainPtr dom){    struct vmware_driver *driver = dom->conn->privateData;    virDomainObjPtr vm;    const char *cmd[] = {        VMRUN, "-T", PROGRAM_SENTINAL, "unpause", PROGRAM_SENTINAL,        NULL    };    int ret = -1;    if (driver->type == TYPE_PLAYER) {        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",                       _("vmplayer does not support libvirt suspend/resume "                         "(vmware pause/unpause) operation "));        return ret;    }    vmwareDriverLock(driver);    vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);    vmwareDriverUnlock(driver);    if (!vm) {        virReportError(VIR_ERR_NO_DOMAIN, "%s",                       _("no domain with matching uuid"));        goto cleanup;    }    vmwareSetSentinal(cmd, vmw_types[driver->type]);    vmwareSetSentinal(cmd, ((vmwareDomainPtr) vm->privateData)->vmxPath);    if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_PAUSED) {        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",                       _("domain is not in suspend state"));        goto cleanup;    }    if (virRun(cmd, NULL) < 0)        goto cleanup;    virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_UNPAUSED);    ret = 0;  cleanup:    if (vm)        virObjectUnlock(vm);    return ret;}

int virSecurityManagerSetHostdevLabel(virSecurityManagerPtr mgr,                                      virDomainDefPtr vm,                                      virDomainHostdevDefPtr dev,                                      const char *vroot){    if (mgr->drv->domainSetSecurityHostdevLabel) {        int ret;        virObjectLock(mgr);        ret = mgr->drv->domainSetSecurityHostdevLabel(mgr, vm, dev, vroot);        virObjectUnlock(mgr);        return ret;    }    virReportUnsupportedError();    return -1;}

int virSecurityManagerGetProcessLabel(virSecurityManagerPtr mgr,                                      virDomainDefPtr vm,                                      pid_t pid,                                      virSecurityLabelPtr sec){    if (mgr->drv->domainGetSecurityProcessLabel) {        int ret;        virObjectLock(mgr);        ret = mgr->drv->domainGetSecurityProcessLabel(mgr, vm, pid, sec);        virObjectUnlock(mgr);        return ret;    }    virReportError(VIR_ERR_NO_SUPPORT, __FUNCTION__);    return -1;}