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

virStorageVolPtrparallelsStorageVolLookupByPathLocked(virConnectPtr conn, const char *path){    parallelsConnPtr privconn = conn->privateData;    size_t i;    virStorageVolPtr ret = NULL;    for (i = 0; i < privconn->pools.count; i++) {        virStoragePoolObjLock(privconn->pools.objs[i]);        if (virStoragePoolObjIsActive(privconn->pools.objs[i])) {            virStorageVolDefPtr privvol =                virStorageVolDefFindByPath(privconn->pools.objs[i], path);            if (privvol) {                ret = virGetStorageVol(conn,                                       privconn->pools.objs[i]->def->name,                                       privvol->name, privvol->key,                                       NULL, NULL);                virStoragePoolObjUnlock(privconn->pools.objs[i]);                break;            }        }        virStoragePoolObjUnlock(privconn->pools.objs[i]);    }    if (!ret)        virReportError(VIR_ERR_NO_STORAGE_VOL,                       _("no storage vol with matching path '%s'"), path);    return ret;}

static intparallelsConnectListDefinedStoragePools(virConnectPtr conn,                                        char **const names, int nnames){    parallelsConnPtr privconn = conn->privateData;    int n = 0;    size_t i;    parallelsDriverLock(privconn);    memset(names, 0, sizeof(*names) * nnames);    for (i = 0; i < privconn->pools.count && n < nnames; i++) {        virStoragePoolObjLock(privconn->pools.objs[i]);        if (!virStoragePoolObjIsActive(privconn->pools.objs[i]) &&            VIR_STRDUP(names[n++], privconn->pools.objs[i]->def->name) < 0) {            virStoragePoolObjUnlock(privconn->pools.objs[i]);            goto error;        }        virStoragePoolObjUnlock(privconn->pools.objs[i]);    }    parallelsDriverUnlock(privconn);    return n; error:    for (n = 0; n < nnames; n++)        VIR_FREE(names[n]);    parallelsDriverUnlock(privconn);    return -1;}

static intparallelsStoragePoolDestroy(virStoragePoolPtr pool){    parallelsConnPtr privconn = pool->conn->privateData;    virStoragePoolObjPtr privpool;    int ret = -1;    parallelsDriverLock(privconn);    privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name);    if (privpool == NULL) {        parallelsPoolNotFoundError(pool->name);        goto cleanup;    }    if (!virStoragePoolObjIsActive(privpool)) {        virReportError(VIR_ERR_OPERATION_INVALID,                       _("storage pool '%s' is not active"), pool->name);        goto cleanup;    }    if (privpool->configFile == NULL) {        virStoragePoolObjRemove(&privconn->pools, privpool);        privpool = NULL;    }    ret = 0; cleanup:    if (privpool)        virStoragePoolObjUnlock(privpool);    parallelsDriverUnlock(privconn);    return ret;}

static intparallelsStoragePoolRefresh(virStoragePoolPtr pool, unsigned int flags){    parallelsConnPtr privconn = pool->conn->privateData;    virStoragePoolObjPtr privpool;    int ret = -1;    virCheckFlags(0, -1);    parallelsDriverLock(privconn);    privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name);    parallelsDriverUnlock(privconn);    if (privpool == NULL) {        parallelsPoolNotFoundError(pool->name);        goto cleanup;    }    if (!virStoragePoolObjIsActive(privpool)) {        virReportError(VIR_ERR_OPERATION_INVALID,                       _("storage pool '%s' is not active"), pool->name);        goto cleanup;    }    ret = 0; cleanup:    if (privpool)        virStoragePoolObjUnlock(privpool);    return ret;}

static intparallelsStoragePoolGetInfo(virStoragePoolPtr pool, virStoragePoolInfoPtr info){    parallelsConnPtr privconn = pool->conn->privateData;    virStoragePoolObjPtr privpool;    int ret = -1;    parallelsDriverLock(privconn);    privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name);    parallelsDriverUnlock(privconn);    if (privpool == NULL) {        parallelsPoolNotFoundError(pool->name);        goto cleanup;    }    memset(info, 0, sizeof(virStoragePoolInfo));    if (privpool->active)        info->state = VIR_STORAGE_POOL_RUNNING;    else        info->state = VIR_STORAGE_POOL_INACTIVE;    info->capacity = privpool->def->capacity;    info->allocation = privpool->def->allocation;    info->available = privpool->def->available;    ret = 0; cleanup:    if (privpool)        virStoragePoolObjUnlock(privpool);    return ret;}

static char *parallelsStoragePoolGetXMLDesc(virStoragePoolPtr pool, unsigned int flags){    parallelsConnPtr privconn = pool->conn->privateData;    virStoragePoolObjPtr privpool;    char *ret = NULL;    virCheckFlags(0, NULL);    parallelsDriverLock(privconn);    privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name);    parallelsDriverUnlock(privconn);    if (privpool == NULL) {        parallelsPoolNotFoundError(pool->name);        goto cleanup;    }    ret = virStoragePoolDefFormat(privpool->def); cleanup:    if (privpool)        virStoragePoolObjUnlock(privpool);    return ret;}

static intparallelsStoragePoolGetAutostart(virStoragePoolPtr pool, int *autostart){    parallelsConnPtr privconn = pool->conn->privateData;    virStoragePoolObjPtr privpool;    int ret = -1;    parallelsDriverLock(privconn);    privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name);    parallelsDriverUnlock(privconn);    if (privpool == NULL) {        parallelsPoolNotFoundError(pool->name);        goto cleanup;    }    if (!privpool->configFile) {        *autostart = 0;    } else {        *autostart = privpool->autostart;    }    ret = 0; cleanup:    if (privpool)        virStoragePoolObjUnlock(privpool);    return ret;}

static intparallelsStoragePoolSetAutostart(virStoragePoolPtr pool, int autostart){    parallelsConnPtr privconn = pool->conn->privateData;    virStoragePoolObjPtr privpool;    int ret = -1;    parallelsDriverLock(privconn);    privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name);    parallelsDriverUnlock(privconn);    if (privpool == NULL) {        parallelsPoolNotFoundError(pool->name);        goto cleanup;    }    if (!privpool->configFile) {        virReportError(VIR_ERR_INVALID_ARG, "%s", _("pool has no config file"));        goto cleanup;    }    privpool->autostart = (autostart != 0);    ret = 0; cleanup:    if (privpool)        virStoragePoolObjUnlock(privpool);    return ret;}

static virStoragePoolObjPtrparallelsPoolCreateByPath(virConnectPtr conn, const char *path){    parallelsConnPtr privconn = conn->privateData;    virStoragePoolObjListPtr pools = &privconn->pools;    virStoragePoolDefPtr def;    virStoragePoolObjPtr pool = NULL;    if (VIR_ALLOC(def) < 0)        goto no_memory;    if (!(def->name = parallelsMakePoolName(conn, path)))        goto error;    if (VIR_ALLOC_N(def->uuid, VIR_UUID_BUFLEN))        goto no_memory;    if (virUUIDGenerate(def->uuid)) {        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",                       _("Can't generate UUID"));        goto error;    }    def->type = VIR_STORAGE_POOL_DIR;    if (VIR_STRDUP(def->target.path, path) < 0)        goto error;    if (!(pool = virStoragePoolObjAssignDef(pools, def)))        goto error;    if (virStoragePoolObjSaveDef(conn->storagePrivateData, pool, def) < 0) {        virStoragePoolObjRemove(pools, pool);        goto error;    }    virStoragePoolObjUnlock(pool);    return pool;no_memory:    virReportOOMError();error:    virStoragePoolDefFree(def);    if (pool)        virStoragePoolObjUnlock(pool);    return NULL;}

static int parallelsLoadPools(virConnectPtr conn){    parallelsConnPtr privconn = conn->privateData;    virStorageDriverStatePtr storageState = conn->storagePrivateData;    char *base = NULL;    size_t i;    if (VIR_STRDUP(base, SYSCONFDIR "/libvirt") < 0)        goto error;    /* Configuration path is /etc/libvirt/parallels-storage/... . */    if (virAsprintf(&storageState->configDir,                    "%s/parallels-storage", base) == -1)        goto out_of_memory;    if (virAsprintf(&storageState->autostartDir,                    "%s/parallels-storage/autostart", base) == -1)        goto out_of_memory;    VIR_FREE(base);    if (virStoragePoolLoadAllConfigs(&privconn->pools,                                     storageState->configDir,                                     storageState->autostartDir) < 0) {        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",                       _("Failed to load pool configs"));        goto error;    }    if (virDomainObjListForEach(privconn->domains, parallelsPoolsAdd, conn) < 0)        goto error;    for (i = 0; i < privconn->pools.count; i++) {        virStoragePoolObjLock(privconn->pools.objs[i]);        virStoragePoolObjPtr pool;        pool = privconn->pools.objs[i];        pool->active = 1;        if (parallelsStoragePoolGetAlloc(pool->def) < 0)            goto error;        if (parallelsFindVolumes(pool) < 0)            goto error;        virStoragePoolObjUnlock(privconn->pools.objs[i]);    }    return 0;out_of_memory:    virReportOOMError();error:    VIR_FREE(base);    return -1;}

static intparallelsStoragePoolListVolumes(virStoragePoolPtr pool,                                char **const names, int maxnames){    parallelsConnPtr privconn = pool->conn->privateData;    virStoragePoolObjPtr privpool;    int n = 0;    size_t i = 0;    memset(names, 0, maxnames * sizeof(*names));    parallelsDriverLock(privconn);    privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name);    parallelsDriverUnlock(privconn);    if (privpool == NULL) {        parallelsPoolNotFoundError(pool->name);        goto error;    }    if (!virStoragePoolObjIsActive(privpool)) {        virReportError(VIR_ERR_OPERATION_INVALID,                 _("storage pool '%s' is not active"), pool->name);        goto error;    }    for (i = 0; i < privpool->volumes.count && n < maxnames; i++) {        if (VIR_STRDUP(names[n++], privpool->volumes.objs[i]->name) < 0)            goto error;    }    virStoragePoolObjUnlock(privpool);    return n; error:    for (n = 0; n < maxnames; n++)        VIR_FREE(names[i]);    if (privpool)        virStoragePoolObjUnlock(privpool);    return -1;}

static virStoragePoolPtrparallelsStoragePoolDefineXML(virConnectPtr conn,                              const char *xml, unsigned int flags){    parallelsConnPtr privconn = conn->privateData;    virStoragePoolDefPtr def;    virStoragePoolObjPtr pool = NULL;    virStoragePoolPtr ret = NULL;    virCheckFlags(0, NULL);    parallelsDriverLock(privconn);    if (!(def = virStoragePoolDefParseString(xml)))        goto cleanup;    if (def->type != VIR_STORAGE_POOL_DIR) {        virReportError(VIR_ERR_NO_SUPPORT, "%s",                       _("Only local directories are supported"));        goto cleanup;    }    if (virStoragePoolObjIsDuplicate(&privconn->pools, def, 0) < 0)        goto cleanup;    if (virStoragePoolSourceFindDuplicate(&privconn->pools, def) < 0)        goto cleanup;    if (parallelsStoragePoolGetAlloc(def))        goto cleanup;    if (!(pool = virStoragePoolObjAssignDef(&privconn->pools, def)))        goto cleanup;    if (virStoragePoolObjSaveDef(conn->storagePrivateData, pool, def) < 0) {        virStoragePoolObjRemove(&privconn->pools, pool);        def = NULL;        goto cleanup;    }    def = NULL;    if (VIR_STRDUP(pool->configFile, "/0") < 0)        goto cleanup;    ret = virGetStoragePool(conn, pool->def->name, pool->def->uuid,                            NULL, NULL); cleanup:    virStoragePoolDefFree(def);    if (pool)        virStoragePoolObjUnlock(pool);    parallelsDriverUnlock(privconn);    return ret;}

static intparallelsStorageVolDelete(virStorageVolPtr vol, unsigned int flags){    parallelsConnPtr privconn = vol->conn->privateData;    virStoragePoolObjPtr privpool;    virStorageVolDefPtr privvol;    int ret = -1;    virCheckFlags(0, -1);    parallelsDriverLock(privconn);    privpool = virStoragePoolObjFindByName(&privconn->pools, vol->pool);    parallelsDriverUnlock(privconn);    if (privpool == NULL) {        parallelsPoolNotFoundError(vol->pool);        goto cleanup;    }    privvol = virStorageVolDefFindByName(privpool, vol->name);    if (privvol == NULL) {        virReportError(VIR_ERR_NO_STORAGE_VOL,                       _("no storage vol with matching name '%s'"), vol->name);        goto cleanup;    }    if (!virStoragePoolObjIsActive(privpool)) {        virReportError(VIR_ERR_OPERATION_INVALID,                       _("storage pool '%s' is not active"), vol->pool);        goto cleanup;    }    if (parallelsStorageVolDefRemove(privpool, privvol))        goto cleanup;    ret = 0; cleanup:    if (privpool)        virStoragePoolObjUnlock(privpool);    return ret;}

static intparallelsConnectNumOfDefinedStoragePools(virConnectPtr conn){    parallelsConnPtr privconn = conn->privateData;    int numInactive = 0;    size_t i;    parallelsDriverLock(privconn);    for (i = 0; i < privconn->pools.count; i++) {        virStoragePoolObjLock(privconn->pools.objs[i]);        if (!virStoragePoolObjIsActive(privconn->pools.objs[i]))            numInactive++;        virStoragePoolObjUnlock(privconn->pools.objs[i]);    }    parallelsDriverUnlock(privconn);    return numInactive;}

static virStorageVolPtrparallelsStorageVolLookupByName(virStoragePoolPtr pool,                                   const char *name){    parallelsConnPtr privconn = pool->conn->privateData;    virStoragePoolObjPtr privpool;    virStorageVolDefPtr privvol;    virStorageVolPtr ret = NULL;    parallelsDriverLock(privconn);    privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name);    parallelsDriverUnlock(privconn);    if (privpool == NULL) {        parallelsPoolNotFoundError(pool->name);        goto cleanup;    }    if (!virStoragePoolObjIsActive(privpool)) {        virReportError(VIR_ERR_OPERATION_INVALID,                       _("storage pool '%s' is not active"), pool->name);        goto cleanup;    }    privvol = virStorageVolDefFindByName(privpool, name);    if (!privvol) {        virReportError(VIR_ERR_NO_STORAGE_VOL,                       _("no storage vol with matching name '%s'"), name);        goto cleanup;    }    ret = virGetStorageVol(pool->conn, privpool->def->name,                           privvol->name, privvol->key,                           NULL, NULL); cleanup:    if (privpool)        virStoragePoolObjUnlock(privpool);    return ret;}

static intparallelsStorageVolGetInfo(virStorageVolPtr vol, virStorageVolInfoPtr info){    parallelsConnPtr privconn = vol->conn->privateData;    virStoragePoolObjPtr privpool;    virStorageVolDefPtr privvol;    int ret = -1;    parallelsDriverLock(privconn);    privpool = virStoragePoolObjFindByName(&privconn->pools, vol->pool);    parallelsDriverUnlock(privconn);    if (privpool == NULL) {        parallelsPoolNotFoundError(vol->pool);        goto cleanup;    }    privvol = virStorageVolDefFindByName(privpool, vol->name);    if (privvol == NULL) {        virReportError(VIR_ERR_NO_STORAGE_VOL,                       _("no storage vol with matching name '%s'"), vol->name);        goto cleanup;    }    if (!virStoragePoolObjIsActive(privpool)) {        virReportError(VIR_ERR_OPERATION_INVALID,                       _("storage pool '%s' is not active"), vol->pool);        goto cleanup;    }    memset(info, 0, sizeof(*info));    info->type = parallelsStorageVolTypeForPool(privpool->def->type);    info->capacity = privvol->target.capacity;    info->allocation = privvol->target.allocation;    ret = 0; cleanup:    if (privpool)        virStoragePoolObjUnlock(privpool);    return ret;}

static intparallelsStoragePoolIsActive(virStoragePoolPtr pool){    parallelsConnPtr privconn = pool->conn->privateData;    virStoragePoolObjPtr obj;    int ret = -1;    parallelsDriverLock(privconn);    obj = virStoragePoolObjFindByUUID(&privconn->pools, pool->uuid);    parallelsDriverUnlock(privconn);    if (!obj) {        virReportError(VIR_ERR_NO_STORAGE_POOL, NULL);        goto cleanup;    }    ret = virStoragePoolObjIsActive(obj); cleanup:    if (obj)        virStoragePoolObjUnlock(obj);    return ret;}

static virStorageVolPtrparallelsStorageVolCreateXML(virStoragePoolPtr pool,                                const char *xmldesc, unsigned int flags){    parallelsConnPtr privconn = pool->conn->privateData;    virStoragePoolObjPtr privpool;    virStorageVolPtr ret = NULL;    virStorageVolDefPtr privvol = NULL;    virCheckFlags(0, NULL);    parallelsDriverLock(privconn);    privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name);    parallelsDriverUnlock(privconn);    if (privpool == NULL) {        parallelsPoolNotFoundError(pool->name);        goto cleanup;    }    if (!virStoragePoolObjIsActive(privpool)) {        virReportError(VIR_ERR_OPERATION_INVALID,                       _("storage pool '%s' is not active"), pool->name);        goto cleanup;    }    privvol = parallelsStorageVolDefineXML(privpool, xmldesc, NULL, true);    if (!privvol)        goto cleanup;    ret = virGetStorageVol(pool->conn, privpool->def->name,                           privvol->name, privvol->key,                           NULL, NULL); cleanup:    if (privpool)        virStoragePoolObjUnlock(privpool);    return ret;}

static char *parallelsStorageVolGetPath(virStorageVolPtr vol){    parallelsConnPtr privconn = vol->conn->privateData;    virStoragePoolObjPtr privpool;    virStorageVolDefPtr privvol;    char *ret = NULL;    parallelsDriverLock(privconn);    privpool = virStoragePoolObjFindByName(&privconn->pools, vol->pool);    parallelsDriverUnlock(privconn);    if (privpool == NULL) {        parallelsPoolNotFoundError(vol->pool);        goto cleanup;    }    privvol = virStorageVolDefFindByName(privpool, vol->name);    if (privvol == NULL) {        virReportError(VIR_ERR_NO_STORAGE_VOL,                       _("no storage vol with matching name '%s'"), vol->name);        goto cleanup;    }    if (!virStoragePoolObjIsActive(privpool)) {        virReportError(VIR_ERR_OPERATION_INVALID,                       _("storage pool '%s' is not active"), vol->pool);        goto cleanup;    }    ignore_value(VIR_STRDUP(ret, privvol->target.path)); cleanup:    if (privpool)        virStoragePoolObjUnlock(privpool);    return ret;}

static virStoragePoolPtrparallelsStoragePoolLookupByName(virConnectPtr conn, const char *name){    parallelsConnPtr privconn = conn->privateData;    virStoragePoolObjPtr pool;    virStoragePoolPtr ret = NULL;    parallelsDriverLock(privconn);    pool = virStoragePoolObjFindByName(&privconn->pools, name);    parallelsDriverUnlock(privconn);    if (pool == NULL) {        virReportError(VIR_ERR_NO_STORAGE_POOL, NULL);        goto cleanup;    }    ret = virGetStoragePool(conn, pool->def->name, pool->def->uuid,                            NULL, NULL); cleanup:    if (pool)        virStoragePoolObjUnlock(pool);    return ret;}

static virStorageVolPtrparallelsStorageVolCreateXMLFrom(virStoragePoolPtr pool,                                    const char *xmldesc,                                    virStorageVolPtr clonevol,                                    unsigned int flags){    parallelsConnPtr privconn = pool->conn->privateData;    virStoragePoolObjPtr privpool;    virStorageVolDefPtr privvol = NULL, origvol = NULL;    virStorageVolPtr ret = NULL;    virCheckFlags(0, NULL);    parallelsDriverLock(privconn);    privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name);    parallelsDriverUnlock(privconn);    if (privpool == NULL) {        parallelsPoolNotFoundError(pool->name);        goto cleanup;    }    if (!virStoragePoolObjIsActive(privpool)) {        virReportError(VIR_ERR_OPERATION_INVALID,                       _("storage pool '%s' is not active"), pool->name);        goto cleanup;    }    privvol = virStorageVolDefParseString(privpool->def, xmldesc);    if (privvol == NULL)        goto cleanup;    if (virStorageVolDefFindByName(privpool, privvol->name)) {        virReportError(VIR_ERR_OPERATION_FAILED,                       "%s", _("storage vol already exists"));        goto cleanup;    }    origvol = virStorageVolDefFindByName(privpool, clonevol->name);    if (!origvol) {        virReportError(VIR_ERR_NO_STORAGE_VOL,                       _("no storage vol with matching name '%s'"),                       clonevol->name);        goto cleanup;    }    /* Make sure enough space */    if ((privpool->def->allocation + privvol->target.allocation) >        privpool->def->capacity) {        virReportError(VIR_ERR_INTERNAL_ERROR,                       _("Not enough free space in pool for volume '%s'"),                       privvol->name);        goto cleanup;    }    privpool->def->available = (privpool->def->capacity -                                privpool->def->allocation);    if (virAsprintf(&privvol->target.path, "%s/%s",                    privpool->def->target.path, privvol->name) == -1)        goto cleanup;    if (VIR_STRDUP(privvol->key, privvol->target.path) < 0)        goto cleanup;    privpool->def->allocation += privvol->target.allocation;    privpool->def->available = (privpool->def->capacity -                                privpool->def->allocation);    if (VIR_APPEND_ELEMENT_COPY(privpool->volumes.objs,                                privpool->volumes.count, privvol) < 0)        goto cleanup;    ret = virGetStorageVol(pool->conn, privpool->def->name,                           privvol->name, privvol->key,                           NULL, NULL);    privvol = NULL; cleanup:    virStorageVolDefFree(privvol);    if (privpool)        virStoragePoolObjUnlock(privpool);    return ret;}