static virStoragePoolPtr
parallelsStoragePoolDefineXML(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 virStoragePoolPtr
esxStoragePoolLookupByName(virConnectPtr conn,
const char *name)
{
esxPrivate *priv = conn->privateData;
esxVI_ObjectContent *datastore = NULL;
esxVI_DatastoreHostMount *hostMount = NULL;
/* MD5_DIGEST_SIZE = VIR_UUID_BUFLEN = 16 */
unsigned char md5[MD5_DIGEST_SIZE];
virStoragePoolPtr pool = NULL;
if (esxVI_LookupDatastoreByName(priv->primary, name, NULL, &datastore,
esxVI_Occurrence_OptionalItem) < 0) {
goto cleanup;
}
if (!datastore) {
/* Not found, let the base storage driver handle error reporting */
goto cleanup;
}
/*
* Datastores don't have a UUID, but we can use the 'host.mountInfo.path'
* property as source for a UUID. The mount path is unique per host and
* cannot change during the lifetime of the datastore.
*
* The MD5 sum of the mount path can be used as UUID, assuming MD5 is
* considered to be collision-free enough for this use case.
*/
if (esxVI_LookupDatastoreHostMount(priv->primary, datastore->obj, &hostMount,
esxVI_Occurrence_OptionalItem) < 0) {
goto cleanup;
}
if (!hostMount) {
/* Not found, let the base storage driver handle error reporting */
goto cleanup;
}
md5_buffer(hostMount->mountInfo->path,
strlen(hostMount->mountInfo->path), md5);
pool = virGetStoragePool(conn, name, md5, &esxStorageBackendVMFS, NULL);
cleanup:
esxVI_ObjectContent_Free(&datastore);
esxVI_DatastoreHostMount_Free(&hostMount);
return pool;
}
static virStoragePoolPtr
esxStoragePoolLookupByUUID(virConnectPtr conn,
const unsigned char *uuid)
{
virStoragePoolPtr pool = NULL;
esxPrivate *priv = conn->storagePrivateData;
esxVI_HostInternetScsiHba *hostInternetScsiHba = NULL;
esxVI_HostInternetScsiHbaStaticTarget *target;
/* MD5_DIGEST_SIZE = VIR_UUID_BUFLEN = 16 */
unsigned char md5[MD5_DIGEST_SIZE];
if (esxVI_LookupHostInternetScsiHba(priv->primary,
&hostInternetScsiHba) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Unable to obtain iSCSI adapter"));
goto cleanup;
}
/* FIXME: code just looks for software iSCSI adapter */
if (!hostInternetScsiHba) {
/* iSCSI adapter may not be enabled for this host */
return NULL;
}
for (target = hostInternetScsiHba->configuredStaticTarget;
target; target = target->_next) {
md5_buffer(target->iScsiName, strlen(target->iScsiName), md5);
if (memcmp(uuid, md5, VIR_UUID_STRING_BUFLEN) == 0) {
break;
}
}
if (!target) {
/* pool not found, error handling done by the base driver */
goto cleanup;
}
pool = virGetStoragePool(conn, target->iScsiName, md5,
&esxStorageBackendISCSI, NULL);
cleanup:
esxVI_HostInternetScsiHba_Free(&hostInternetScsiHba);
return pool;
}
static virStoragePoolPtr
vboxStoragePoolLookupByName(virConnectPtr conn, const char *name)
{
virStoragePoolPtr ret = NULL;
/** Current limitation of the function: since
* the default pool doesn't have UUID just assign
* one till vbox can handle pools
*/
if (STREQ("default-pool", name)) {
unsigned char uuid[VIR_UUID_BUFLEN];
const char *uuidstr = "1deff1ff-1481-464f-967f-a50fe8936cc4";
ignore_value(virUUIDParse(uuidstr, uuid));
ret = virGetStoragePool(conn, name, uuid, NULL, NULL);
}
return ret;
}
static virStoragePoolPtr
esxStoragePoolLookupByName(virConnectPtr conn,
const char *name)
{
esxPrivate *priv = conn->privateData;
esxVI_HostInternetScsiHbaStaticTarget *target = NULL;
/* VIR_CRYPTO_HASH_SIZE_MD5 = VIR_UUID_BUFLEN = 16 */
unsigned char md5[VIR_CRYPTO_HASH_SIZE_MD5];
virStoragePoolPtr pool = NULL;
/*
* Lookup routine are used by the base driver to determine
* appropriate backend driver, lookup targetName as optional
* parameter
*/
if (esxVI_LookupHostInternetScsiHbaStaticTargetByName
(priv->primary, name, &target, esxVI_Occurrence_OptionalItem) < 0) {
goto cleanup;
}
if (!target) {
/* pool not found, error handling done by the base driver */
goto cleanup;
}
/*
* HostInternetScsiHbaStaticTarget does not provide a uuid field,
* but iScsiName (or widely known as IQN) is unique across the multiple
* hosts, using it to compute key
*/
if (virCryptoHashBuf(VIR_CRYPTO_HASH_MD5, target->iScsiName, md5) < 0)
goto cleanup;
pool = virGetStoragePool(conn, name, md5, &esxStorageBackendISCSI, NULL);
cleanup:
esxVI_HostInternetScsiHbaStaticTarget_Free(&target);
return pool;
}
static virStoragePoolPtr
parallelsStoragePoolLookupByName(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 virStoragePoolPtr
esxStoragePoolLookupByUUID(virConnectPtr conn,
const unsigned char *uuid)
{
esxPrivate *priv = conn->privateData;
esxVI_String *propertyNameList = NULL;
esxVI_ObjectContent *datastoreList = NULL;
esxVI_ObjectContent *datastore = NULL;
esxVI_DatastoreHostMount *hostMount = NULL;
/* MD5_DIGEST_SIZE = VIR_UUID_BUFLEN = 16 */
unsigned char md5[MD5_DIGEST_SIZE];
char *name = NULL;
virStoragePoolPtr pool = NULL;
if (esxVI_String_AppendValueToList(&propertyNameList, "summary.name") < 0 ||
esxVI_LookupDatastoreList(priv->primary, propertyNameList,
&datastoreList) < 0) {
goto cleanup;
}
for (datastore = datastoreList; datastore;
datastore = datastore->_next) {
esxVI_DatastoreHostMount_Free(&hostMount);
if (esxVI_LookupDatastoreHostMount(priv->primary, datastore->obj,
&hostMount,
esxVI_Occurrence_OptionalItem) < 0) {
goto cleanup;
}
if (!hostMount) {
/*
* Storage pool is not of VMFS type, leave error reporting to the
* base storage driver.
*/
goto cleanup;
}
md5_buffer(hostMount->mountInfo->path,
strlen(hostMount->mountInfo->path), md5);
if (memcmp(uuid, md5, VIR_UUID_BUFLEN) == 0)
break;
}
if (!datastore) {
/* Not found, let the base storage driver handle error reporting */
goto cleanup;
}
if (esxVI_GetStringValue(datastore, "summary.name", &name,
esxVI_Occurrence_RequiredItem) < 0) {
goto cleanup;
}
pool = virGetStoragePool(conn, name, uuid, &esxStorageBackendVMFS, NULL);
cleanup:
esxVI_String_Free(&propertyNameList);
esxVI_ObjectContent_Free(&datastoreList);
esxVI_DatastoreHostMount_Free(&hostMount);
return pool;
}