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

intvirNetServerClientInitKeepAlive(virNetServerClientPtr client,                                int interval,                                unsigned int count){    virKeepAlivePtr ka;    int ret = -1;    virObjectLock(client);    if (!(ka = virKeepAliveNew(interval, count, client,                               virNetServerClientKeepAliveSendCB,                               virNetServerClientKeepAliveDeadCB,                               virObjectFreeCallback)))        goto cleanup;    /* keepalive object has a reference to client */    virObjectRef(client);    client->keepalive = ka; cleanup:    virObjectUnlock(client);    return ret;}

int qemuTestCapsCacheInsert(virQEMUCapsCachePtr cache, const char *binary,                            virQEMUCapsPtr caps){    int ret;    if (caps) {        /* Our caps were created artificially, so we don't want         * virQEMUCapsCacheFree() to attempt to deallocate them */        virObjectRef(caps);    } else {        caps = virQEMUCapsNew();        if (!caps)            return -ENOMEM;    }    /* We can have repeating names for our test data sets,     * so make sure there's no old copy */    virHashRemoveEntry(cache->binaries, binary);    ret = virHashAddEntry(cache->binaries, binary, caps);    if (ret < 0)        virObjectUnref(caps);    else        qemuTestCapsName = binary;    return ret;}

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

intvirNetServerClientGetInfo(virNetServerClientPtr client,                          bool *readonly, char **sock_addr,                          virIdentityPtr *identity){    int ret = -1;    const char *addr;    virObjectLock(client);    *readonly = client->readonly;    if (!(addr = virNetServerClientRemoteAddrStringURI(client))) {        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",                       _("No network socket associated with client"));        goto cleanup;    }    if (VIR_STRDUP(*sock_addr, addr) < 0)        goto cleanup;    if (!client->identity) {        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",                       _("No identity information available for client"));        goto cleanup;    }    *identity = virObjectRef(client->identity);    ret = 0; cleanup:    virObjectUnlock(client);    return ret;}

static voidvirKeepAliveTimer(int timer ATTRIBUTE_UNUSED, void *opaque){    virKeepAlivePtr ka = opaque;    virNetMessagePtr msg = NULL;    bool dead;    void *client;    virObjectLock(ka);    client = ka->client;    dead = virKeepAliveTimerInternal(ka, &msg);    if (!dead && !msg)        goto cleanup;    virObjectRef(ka);    virObjectUnlock(ka);    if (dead) {        ka->deadCB(client);    } else if (ka->sendCB(client, msg) < 0) {        VIR_WARN("Failed to send keepalive request to client %p", client);        virNetMessageFree(msg);    }    virObjectLock(ka);    virObjectUnref(ka); cleanup:    virObjectUnlock(ka);}

int qemuTestCapsCacheInsert(virQEMUCapsCachePtr cache,                            virQEMUCapsPtr caps){    size_t i;    virQEMUCapsPtr tmpCaps;    if (caps) {        tmpCaps = caps;    } else {        if (!(tmpCaps = virQEMUCapsNew()))            return -ENOMEM;    }    for (i = 0; i < ARRAY_CARDINALITY(QEMUBinList); i++) {        virObjectRef(tmpCaps);        if (virHashUpdateEntry(cache->binaries,                               QEMUBinList[i],                               tmpCaps) < 0) {            virObjectUnref(tmpCaps);            return -1;        }    }    if (!caps)        virObjectUnref(tmpCaps);    return 0;}

/** * virGetNWFilterBinding: * @conn: the hypervisor connection * @portdev: pointer to the network filter port device name * @filtername: name of the network filter * * Allocates a new network filter binding object. When the object is no longer * needed, virObjectUnref() must be called in order to not leak data. * * Returns a pointer to the network filter binding object, or NULL on error. */virNWFilterBindingPtrvirGetNWFilterBinding(virConnectPtr conn, const char *portdev,                      const char *filtername){    virNWFilterBindingPtr ret = NULL;    if (virDataTypesInitialize() < 0)        return NULL;    virCheckConnectGoto(conn, error);    virCheckNonNullArgGoto(portdev, error);    if (!(ret = virObjectNew(virNWFilterBindingClass)))        goto error;    if (VIR_STRDUP(ret->portdev, portdev) < 0)        goto error;    if (VIR_STRDUP(ret->filtername, filtername) < 0)        goto error;    ret->conn = virObjectRef(conn);    return ret; error:    virObjectUnref(ret);    return NULL;}

/** * virGetSecret: * @conn: the hypervisor connection * @uuid: secret UUID * * Allocates a new secret object. When the object is no longer needed, * virObjectUnref() must be called in order to not leak data. * * Returns a pointer to the secret object, or NULL on error. */virSecretPtrvirGetSecret(virConnectPtr conn, const unsigned char *uuid,             int usageType, const char *usageID){    virSecretPtr ret = NULL;    if (virDataTypesInitialize() < 0)        return NULL;    virCheckConnectGoto(conn, error);    virCheckNonNullArgGoto(uuid, error);    if (!(ret = virObjectNew(virSecretClass)))        return NULL;    memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN);    ret->usageType = usageType;    if (VIR_STRDUP(ret->usageID, usageID ? usageID : "") < 0)        goto error;    ret->conn = virObjectRef(conn);    return ret; error:    virObjectUnref(ret);    return NULL;}

/** * virGetNWFilter: * @conn: the hypervisor connection * @name: pointer to the network filter pool name * @uuid: pointer to the uuid * * Allocates a new network filter object. When the object is no longer needed, * virObjectUnref() must be called in order to not leak data. * * Returns a pointer to the network filter object, or NULL on error. */virNWFilterPtrvirGetNWFilter(virConnectPtr conn, const char *name,               const unsigned char *uuid){    virNWFilterPtr ret = NULL;    if (virDataTypesInitialize() < 0)        return NULL;    virCheckConnectGoto(conn, error);    virCheckNonNullArgGoto(name, error);    virCheckNonNullArgGoto(uuid, error);    if (!(ret = virObjectNew(virNWFilterClass)))        goto error;    if (VIR_STRDUP(ret->name, name) < 0)        goto error;    memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN);    ret->conn = virObjectRef(conn);    return ret; error:    virObjectUnref(ret);    return NULL;}

/** * virGetStoragePool: * @conn: the hypervisor connection * @name: pointer to the storage pool name * @uuid: pointer to the uuid * @privateData: pointer to driver specific private data * @freeFunc: private data cleanup function pointer specific to driver * * Allocates a new storage pool object. When the object is no longer needed, * virObjectUnref() must be called in order to not leak data. * * Returns a pointer to the storage pool object, or NULL on error. */virStoragePoolPtrvirGetStoragePool(virConnectPtr conn, const char *name,                  const unsigned char *uuid,                  void *privateData, virFreeCallback freeFunc){    virStoragePoolPtr ret = NULL;    if (virDataTypesInitialize() < 0)        return NULL;    virCheckConnectGoto(conn, error);    virCheckNonNullArgGoto(name, error);    virCheckNonNullArgGoto(uuid, error);    if (!(ret = virObjectNew(virStoragePoolClass)))        goto error;    if (VIR_STRDUP(ret->name, name) < 0)        goto error;    ret->conn = virObjectRef(conn);    memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN);    /* set the driver specific data */    ret->privateData = privateData;    ret->privateDataFreeFunc = freeFunc;    return ret; error:    virObjectUnref(ret);    return NULL;}

/** * virGetStorageVol: * @conn: the hypervisor connection * @pool: pool owning the volume * @name: pointer to the storage vol name * @key: pointer to unique key of the volume * @privateData: pointer to driver specific private data * @freeFunc: private data cleanup function pointer specific to driver * * Allocates a new storage volume object. When the object is no longer needed, * virObjectUnref() must be called in order to not leak data. * * Returns a pointer to the storage volume object, or NULL on error. */virStorageVolPtrvirGetStorageVol(virConnectPtr conn, const char *pool, const char *name,                 const char *key, void *privateData, virFreeCallback freeFunc){    virStorageVolPtr ret = NULL;    if (virDataTypesInitialize() < 0)        return NULL;    virCheckConnectGoto(conn, error);    virCheckNonNullArgGoto(pool, error);    virCheckNonNullArgGoto(name, error);    virCheckNonNullArgGoto(key, error);    if (!(ret = virObjectNew(virStorageVolClass)))        goto error;    if (VIR_STRDUP(ret->pool, pool) < 0 ||        VIR_STRDUP(ret->name, name) < 0 ||        VIR_STRDUP(ret->key, key) < 0)        goto error;    ret->conn = virObjectRef(conn);    /* set driver specific data */    ret->privateData = privateData;    ret->privateDataFreeFunc = freeFunc;    return ret; error:    virObjectUnref(ret);    return NULL;}

/** * virGetInterface: * @conn: the hypervisor connection * @name: pointer to the interface name * @mac: pointer to the mac * * Allocates a new interface object. When the object is no longer needed, * virObjectUnref() must be called in order to not leak data. * * Returns a pointer to the interface object, or NULL on error. */virInterfacePtrvirGetInterface(virConnectPtr conn, const char *name, const char *mac){    virInterfacePtr ret = NULL;    if (virDataTypesInitialize() < 0)        return NULL;    virCheckConnectGoto(conn, error);    virCheckNonNullArgGoto(name, error);    /* a NULL mac from caller is okay. Treat it as blank */    if (mac == NULL)       mac = "";    if (!(ret = virObjectNew(virInterfaceClass)))        goto error;    if (VIR_STRDUP(ret->name, name) < 0 ||        VIR_STRDUP(ret->mac, mac) < 0)        goto error;    ret->conn = virObjectRef(conn);    return ret; error:    virObjectUnref(ret);    return NULL;}

intvirAdmConnectCloseCallbackDataRegister(virAdmConnectCloseCallbackDataPtr cbdata,                                       virAdmConnectPtr conn,                                       virAdmConnectCloseFunc cb,                                       void *opaque,                                       virFreeCallback freecb){    int ret = -1;    virObjectLock(cbdata);    if (cbdata->callback) {        virReportError(VIR_ERR_OPERATION_INVALID, "%s",                       _("A close callback is already registered"));        goto cleanup;    }    cbdata->conn = virObjectRef(conn);    cbdata->callback = cb;    cbdata->opaque = opaque;    cbdata->freeCallback = freecb;    ret = 0; cleanup:    virObjectUnlock(conn->closeCallback);    return ret;}

static virLXCMonitorPtr virLXCProcessConnectMonitor(virLXCDriverPtr driver,                                                    virDomainObjPtr vm){    virLXCMonitorPtr monitor = NULL;    virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);    if (virSecurityManagerSetSocketLabel(driver->securityManager, vm->def) < 0)        goto cleanup;    /* Hold an extra reference because we can't allow 'vm' to be     * deleted while the monitor is active */    virObjectRef(vm);    monitor = virLXCMonitorNew(vm, cfg->stateDir, &monitorCallbacks);    if (monitor == NULL)        virObjectUnref(vm);    if (virSecurityManagerClearSocketLabel(driver->securityManager, vm->def) < 0) {        if (monitor) {            virObjectUnref(monitor);            monitor = NULL;        }        goto cleanup;    } cleanup:    virObjectUnref(cfg);    return monitor;}

/** * virQEMUDriverGetCapabilities: * * Get a reference to the virCapsPtr instance for the * driver. If @refresh is true, the capabilities will be * rebuilt first * * The caller must release the reference with virObjetUnref * * Returns: a reference to a virCapsPtr instance or NULL */virCapsPtr virQEMUDriverGetCapabilities(virQEMUDriverPtr driver,                                        bool refresh){    virCapsPtr ret = NULL;    if (refresh) {        virCapsPtr caps = NULL;        if ((caps = virQEMUDriverCreateCapabilities(driver)) == NULL)            return NULL;        qemuDriverLock(driver);        virObjectUnref(driver->caps);        driver->caps = caps;    } else {        qemuDriverLock(driver);    }    if (driver->caps->nguests == 0 && !refresh) {        VIR_DEBUG("Capabilities didn't detect any guests. Forcing a "            "refresh.");        qemuDriverUnlock(driver);        return virQEMUDriverGetCapabilities(driver, true);    }    ret = virObjectRef(driver->caps);    qemuDriverUnlock(driver);    return ret;}

static voidvirObjectEventStateFlush(virObjectEventStatePtr state){    virObjectEventQueue tempQueue;    /* We need to lock as well as ref due to the fact that we might     * unref the state we're working on in this very function */    virObjectRef(state);    virObjectLock(state);    state->isDispatching = true;    /* Copy the queue, so we're reentrant safe when dispatchFunc drops the     * driver lock */    tempQueue.count = state->queue->count;    tempQueue.events = state->queue->events;    state->queue->count = 0;    state->queue->events = NULL;    if (state->timer != -1)        virEventUpdateTimeout(state->timer, -1);    virObjectEventStateQueueDispatch(state,                                     &tempQueue,                                     state->callbacks);    /* Purge any deleted callbacks */    virObjectEventCallbackListPurgeMarked(state->callbacks);    /* If we purged all callbacks, we need to remove the timeout as     * well like virObjectEventStateDeregisterID() would do. */    virObjectEventStateCleanupTimer(state, true);    state->isDispatching = false;    virObjectUnlock(state);    virObjectUnref(state);}

virQEMUDriverConfigPtr virQEMUDriverGetConfig(virQEMUDriverPtr driver){    virQEMUDriverConfigPtr conf;    qemuDriverLock(driver);    conf = virObjectRef(driver->config);    qemuDriverUnlock(driver);    return conf;}

virLXCDriverConfigPtr virLXCDriverGetConfig(virLXCDriverPtr driver){    virLXCDriverConfigPtr cfg;    lxcDriverLock(driver);    cfg = virObjectRef(driver->config);    lxcDriverUnlock(driver);    return cfg;}

qemuBlockJobDataPtrqemuBlockJobGetByDisk(virDomainDiskDefPtr disk){    qemuBlockJobDataPtr job = QEMU_DOMAIN_DISK_PRIVATE(disk)->blockjob;    if (!job)        return NULL;    return virObjectRef(job);}

/** * virIdentityGetCurrent: * * Get the current identity associated with this thread. The * caller will own a reference to the returned identity, but * must not modify the object in any way, other than to * release the reference when done with virObjectUnref * * Returns: a reference to the current identity, or NULL */virIdentityPtr virIdentityGetCurrent(void){    virIdentityPtr ident;    if (virIdentityInitialize() < 0)        return NULL;    ident = virThreadLocalGet(&virIdentityCurrent);    return virObjectRef(ident);}

libxlDriverConfigPtrlibxlDriverConfigGet(libxlDriverPrivatePtr driver){    libxlDriverConfigPtr cfg;    libxlDriverLock(driver);    cfg = virObjectRef(driver->config);    libxlDriverUnlock(driver);    return cfg;}

/** * virSecretObjFindByUUIDLocked: * @secrets: list of secret objects * @uuid: secret uuid to find * * This functions requires @secrets to be locked already! * * Returns: not locked, but ref'd secret object. */virSecretObjPtrvirSecretObjListFindByUUIDLocked(virSecretObjListPtr secrets,                                 const unsigned char *uuid){    char uuidstr[VIR_UUID_STRING_BUFLEN];    virUUIDFormat(uuid, uuidstr);    return virObjectRef(virHashLookup(secrets->objs, uuidstr));}

virIdentityPtr virNetServerClientGetIdentity(virNetServerClientPtr client){    virIdentityPtr ret = NULL;    virObjectLock(client);    if (!client->identity)        client->identity = virNetServerClientCreateIdentity(client);    if (client->identity)        ret = virObjectRef(client->identity);    virObjectUnlock(client);    return ret;}

/** * virNodeDeviceRef: * @dev: the dev to hold a reference on * * Increment the reference count on the dev. For each * additional call to this method, there shall be a corresponding * call to virNodeDeviceFree to release the reference count, once * the caller no longer needs the reference to this object. * * This method is typically useful for applications where multiple * threads are using a connection, and it is required that the * connection remain open until all threads have finished using * it. ie, each new thread using a dev would increment * the reference count. * * Returns 0 in case of success, -1 in case of failure. */intvirNodeDeviceRef(virNodeDevicePtr dev){    VIR_DEBUG("dev=%p refs=%d", dev, dev ? dev->object.u.s.refs : 0);    virResetLastError();    virCheckNodeDeviceReturn(dev, -1);    virObjectRef(dev);    return 0;}

void virNetServerClientSetSASLSession(virNetServerClientPtr client,                                      virNetSASLSessionPtr sasl){    /* We don't set the sasl session on the socket here     * because we need to send out the auth confirmation     * in the clear. Only once we complete the next 'tx'     * operation do we switch to SASL mode     */    virNetServerClientLock(client);    client->sasl = virObjectRef(sasl);    virNetServerClientUnlock(client);}

static int virNetServerDispatchNewMessage(virNetServerClientPtr client,        virNetMessagePtr msg,        void *opaque){    virNetServerPtr srv = opaque;    virNetServerProgramPtr prog = NULL;    unsigned int priority = 0;    size_t i;    int ret = -1;    VIR_DEBUG("server=%p client=%p message=%p",              srv, client, msg);    virObjectLock(srv);    for (i = 0 ; i < srv->nprograms ; i++) {        if (virNetServerProgramMatches(srv->programs[i], msg)) {            prog = srv->programs[i];            break;        }    }    if (srv->workers) {        virNetServerJobPtr job;        if (VIR_ALLOC(job) < 0) {            virReportOOMError();            goto cleanup;        }        job->client = client;        job->msg = msg;        if (prog) {            virObjectRef(prog);            job->prog = prog;            priority = virNetServerProgramGetPriority(prog, msg->header.proc);        }        ret = virThreadPoolSendJob(srv->workers, priority, job);        if (ret < 0) {            VIR_FREE(job);            virObjectUnref(prog);        }    } else {        ret = virNetServerProcessMsg(srv, client, prog, msg);    }cleanup:    virObjectUnlock(srv);    return ret;}

/** * virNetworkRef: * @network: the network to hold a reference on * * Increment the reference count on the network. For each * additional call to this method, there shall be a corresponding * call to virNetworkFree to release the reference count, once * the caller no longer needs the reference to this object. * * This method is typically useful for applications where multiple * threads are using a connection, and it is required that the * connection remain open until all threads have finished using * it. ie, each new thread using a network would increment * the reference count. * * Returns 0 in case of success, -1 in case of failure. */intvirNetworkRef(virNetworkPtr network){    VIR_DEBUG("network=%p refs=%d", network,              network ? network->parent.u.s.refs : 0);    virResetLastError();    virCheckNetworkReturn(network, -1);    virObjectRef(network);    return 0;}

/** * virAdmConnectRef: * @conn: the connection to hold a reference on * * Increment the reference count on the connection. For each additional call to * this method, there shall be a corresponding call to virAdmConnectClose to * release the reference count, once the caller no longer needs the reference to * this object. * * This method is typically useful for applications where multiple threads are * using a connection, and it is required that the connection remain open until * all threads have finished using it. I.e., each new thread using a connection * would increment the reference count. * * Returns 0 in case of success, -1 in case of failure */intvirAdmConnectRef(virAdmConnectPtr conn){    VIR_DEBUG("conn=%p refs=%d", conn,              conn ? conn->object.parent.u.s.refs : 0);    virResetLastError();    virCheckAdmConnectReturn(conn, -1);    virObjectRef(conn);    return 0;}

/* * Separate function merely for the purpose of unified error * reporting. */static virNetServerPtrvirNetDaemonGetServerInternal(virNetDaemonPtr dmn,                              int subServerID){    if (subServerID < 0 || subServerID >= dmn->nservers) {        virReportError(VIR_ERR_INVALID_ARG,                       _("Invalid server ID: %d"),                       subServerID);        return NULL;    }    return virObjectRef(dmn->servers[subServerID]);}

/** * virDomainSnapshotRef: * @snapshot: the snapshot to hold a reference on * * Increment the reference count on the snapshot. For each * additional call to this method, there shall be a corresponding * call to virDomainSnapshotFree to release the reference count, once * the caller no longer needs the reference to this object. * * This method is typically useful for applications where multiple * threads are using a connection, and it is required that the * connection and domain remain open until all threads have finished * using the snapshot. ie, each new thread using a snapshot would * increment the reference count. * * Returns 0 in case of success and -1 in case of failure. */intvirDomainSnapshotRef(virDomainSnapshotPtr snapshot){    VIR_DEBUG("snapshot=%p, refs=%d", snapshot,              snapshot ? snapshot->parent.u.s.refs : 0);    virResetLastError();    virCheckDomainSnapshotReturn(snapshot, -1);    virObjectRef(snapshot);    return 0;}