/* Check if a shared device's setting conflicts with the conf
* used by other domain(s). Currently only checks the sgio
* setting. Note that this should only be called for disk with
* block source if the device type is disk.
*
* Returns 0 if no conflicts, otherwise returns -1.
*/
static int
qemuCheckSharedDisk(virHashTablePtr sharedDevices,
virDomainDiskDefPtr disk)
{
int ret;
if (disk->device != VIR_DOMAIN_DISK_DEVICE_LUN)
return 0;
if ((ret = qemuCheckUnprivSGIO(sharedDevices, disk->src->path,
disk->sgio)) < 0) {
if (ret == -2) {
if (virDomainDiskGetType(disk) == VIR_STORAGE_TYPE_VOLUME) {
virReportError(VIR_ERR_OPERATION_INVALID,
_("sgio of shared disk 'pool=%s' 'volume=%s' "
"conflicts with other active domains"),
disk->src->srcpool->pool,
disk->src->srcpool->volume);
} else {
virReportError(VIR_ERR_OPERATION_INVALID,
_("sgio of shared disk '%s' conflicts with "
"other active domains"),
disk->src->path);
}
}
return -1;
}
return 0;
}
static int
bhyveBuildDiskArgStr(const virDomainDef *def, virCommandPtr cmd)
{
virDomainDiskDefPtr disk;
const char *bus_type;
if (def->ndisks != 1) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("domain should have one and only one disk defined"));
return -1;
}
disk = def->disks[0];
switch (disk->bus) {
case VIR_DOMAIN_DISK_BUS_SATA:
bus_type = "ahci-hd";
break;
case VIR_DOMAIN_DISK_BUS_VIRTIO:
bus_type = "virtio-blk";
break;
default:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("unsupported disk bus type"));
return -1;
}
if (disk->device != VIR_DOMAIN_DISK_DEVICE_DISK) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("unsupported disk device"));
return -1;
}
if (virDomainDiskGetType(disk) != VIR_STORAGE_TYPE_FILE) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("unsupported disk type"));
return -1;
}
virCommandAddArg(cmd, "-s");
virCommandAddArgFormat(cmd, "2:0,%s,%s", bus_type,
virDomainDiskGetSource(disk));
return 0;
}
virCommandPtr
virBhyveProcessBuildLoadCmd(bhyveConnPtr driver ATTRIBUTE_UNUSED,
virDomainObjPtr vm)
{
virCommandPtr cmd;
virDomainDiskDefPtr disk;
if (vm->def->ndisks != 1) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("domain should have one and only one disk defined"));
return NULL;
}
disk = vm->def->disks[0];
if (disk->device != VIR_DOMAIN_DISK_DEVICE_DISK) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("unsupported disk device"));
return NULL;
}
if (virDomainDiskGetType(disk) != VIR_STORAGE_TYPE_FILE) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("unsupported disk type"));
return NULL;
}
cmd = virCommandNew(BHYVELOAD);
/* Memory */
virCommandAddArg(cmd, "-m");
virCommandAddArgFormat(cmd, "%llu",
VIR_DIV_UP(vm->def->mem.max_balloon, 1024));
/* Image path */
virCommandAddArg(cmd, "-d");
virCommandAddArg(cmd, virDomainDiskGetSource(disk));
/* VM name */
virCommandAddArg(cmd, vm->def->name);
return cmd;
}
/*
* For details on xl disk config syntax, see
* docs/misc/xl-disk-configuration.txt in the Xen sources. The important
* section of text is:
*
* More formally, the string is a series of comma-separated keyword/value
* pairs, flags and positional parameters. Parameters which are not bare
* keywords and which do not contain "=" symbols are assigned to the
* so-far-unspecified positional parameters, in the order below. The
* positional parameters may also be specified explicitly by name.
*
* Each parameter may be specified at most once, either as a positional
* parameter or a named parameter. Default values apply if the parameter
* is not specified, or if it is specified with an empty value (whether
* positionally or explicitly).
*
* Whitespace may appear before each parameter and will be ignored.
*
* The order of the positional parameters mentioned in the quoted text is:
*
* target,format,vdev,access
*
* The following options must be specified by key=value:
*
* devtype=<devtype>
* backendtype=<backend-type>
*
* The following options are currently not supported:
*
* backend=<domain-name>
* script=<script>
* direct-io-safe
*
*/
static int
xenParseXLDisk(virConfPtr conf, virDomainDefPtr def)
{
int ret = -1;
virConfValuePtr list = virConfGetValue(conf, "disk");
XLU_Config *xluconf;
libxl_device_disk *libxldisk;
virDomainDiskDefPtr disk = NULL;
if (VIR_ALLOC(libxldisk) < 0)
return -1;
if (!(xluconf = xlu_cfg_init(stderr, "command line")))
goto cleanup;
if (list && list->type == VIR_CONF_LIST) {
list = list->list;
while (list) {
const char *disk_spec = list->str;
if (list->type != VIR_CONF_STRING || list->str == NULL)
goto skipdisk;
libxl_device_disk_init(libxldisk);
if (xlu_disk_parse(xluconf, 1, &disk_spec, libxldisk))
goto fail;
if (!(disk = virDomainDiskDefNew(NULL)))
goto fail;
if (xenParseXLDiskSrc(disk, libxldisk->pdev_path) < 0)
goto fail;
if (VIR_STRDUP(disk->dst, libxldisk->vdev) < 0)
goto fail;
disk->src->readonly = !libxldisk->readwrite;
disk->removable = libxldisk->removable;
if (libxldisk->is_cdrom) {
if (virDomainDiskSetDriver(disk, "qemu") < 0)
goto fail;
virDomainDiskSetType(disk, VIR_STORAGE_TYPE_FILE);
disk->device = VIR_DOMAIN_DISK_DEVICE_CDROM;
if (!disk->src->path || STREQ(disk->src->path, ""))
disk->src->format = VIR_STORAGE_FILE_NONE;
else
disk->src->format = VIR_STORAGE_FILE_RAW;
} else {
switch (libxldisk->format) {
case LIBXL_DISK_FORMAT_QCOW:
disk->src->format = VIR_STORAGE_FILE_QCOW;
break;
case LIBXL_DISK_FORMAT_QCOW2:
disk->src->format = VIR_STORAGE_FILE_QCOW2;
break;
case LIBXL_DISK_FORMAT_VHD:
disk->src->format = VIR_STORAGE_FILE_VHD;
break;
case LIBXL_DISK_FORMAT_RAW:
case LIBXL_DISK_FORMAT_UNKNOWN:
disk->src->format = VIR_STORAGE_FILE_RAW;
break;
case LIBXL_DISK_FORMAT_EMPTY:
break;
}
switch (libxldisk->backend) {
case LIBXL_DISK_BACKEND_QDISK:
case LIBXL_DISK_BACKEND_UNKNOWN:
if (virDomainDiskSetDriver(disk, "qemu") < 0)
goto fail;
if (virDomainDiskGetType(disk) == VIR_STORAGE_TYPE_NONE)
virDomainDiskSetType(disk, VIR_STORAGE_TYPE_FILE);
break;
case LIBXL_DISK_BACKEND_TAP:
if (virDomainDiskSetDriver(disk, "tap") < 0)
goto fail;
virDomainDiskSetType(disk, VIR_STORAGE_TYPE_FILE);
break;
case LIBXL_DISK_BACKEND_PHY:
if (virDomainDiskSetDriver(disk, "phy") < 0)
goto fail;
virDomainDiskSetType(disk, VIR_STORAGE_TYPE_BLOCK);
break;
}
}
if (STRPREFIX(libxldisk->vdev, "xvd") ||
def->os.type != VIR_DOMAIN_OSTYPE_HVM)
disk->bus = VIR_DOMAIN_DISK_BUS_XEN;
else if (STRPREFIX(libxldisk->vdev, "sd"))
disk->bus = VIR_DOMAIN_DISK_BUS_SCSI;
else
disk->bus = VIR_DOMAIN_DISK_BUS_IDE;
if (VIR_APPEND_ELEMENT(def->disks, def->ndisks, disk) < 0)
goto fail;
libxl_device_disk_dispose(libxldisk);
skipdisk:
list = list->next;
}
}
ret = 0;
cleanup:
virDomainDiskDefFree(disk);
xlu_cfg_destroy(xluconf);
VIR_FREE(libxldisk);
return ret;
fail:
libxl_device_disk_dispose(libxldisk);
goto cleanup;
}
int
vmwareVmxPath(virDomainDefPtr vmdef, char **vmxPath)
{
virDomainDiskDefPtr disk = NULL;
char *directoryName = NULL;
char *fileName = NULL;
int ret = -1;
size_t i;
const char *src;
/*
* Build VMX URL. Use the source of the first file-based harddisk
* to deduce the path for the VMX file. Don't just use the
* first disk, because it may be CDROM disk and ISO images are normally not
* located in the virtual machine's directory. This approach
* isn't perfect but should work in the majority of cases.
*/
if (vmdef->ndisks < 1) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Domain XML doesn't contain any disks, "
"cannot deduce datastore and path for VMX file"));
goto cleanup;
}
for (i = 0; i < vmdef->ndisks; ++i) {
if (vmdef->disks[i]->device == VIR_DOMAIN_DISK_DEVICE_DISK &&
virDomainDiskGetType(vmdef->disks[i]) == VIR_STORAGE_TYPE_FILE) {
disk = vmdef->disks[i];
break;
}
}
if (disk == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Domain XML doesn't contain any file-based harddisks, "
"cannot deduce datastore and path for VMX file"));
goto cleanup;
}
src = virDomainDiskGetSource(disk);
if (!src) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("First file-based harddisk has no source, cannot "
"deduce datastore and path for VMX file"));
goto cleanup;
}
if (vmwareParsePath(src, &directoryName, &fileName) < 0)
goto cleanup;
if (!virFileHasSuffix(fileName, ".vmdk")) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Expecting source '%s' of first file-based harddisk "
"to be a VMDK image"), src);
goto cleanup;
}
if (vmwareConstructVmxPath(directoryName, vmdef->name, vmxPath) < 0)
goto cleanup;
ret = 0;
cleanup:
VIR_FREE(directoryName);
VIR_FREE(fileName);
return ret;
}
static int
xenFormatXMDisk(virConfValuePtr list,
virDomainDiskDefPtr disk)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
virConfValuePtr val, tmp;
const char *src = virDomainDiskGetSource(disk);
int format = virDomainDiskGetFormat(disk);
const char *driver = virDomainDiskGetDriver(disk);
if (src) {
if (format) {
const char *type;
if (format == VIR_STORAGE_FILE_RAW)
type = "aio";
else
type = virStorageFileFormatTypeToString(format);
virBufferAsprintf(&buf, "%s:", driver);
if (STREQ(driver, "tap"))
virBufferAsprintf(&buf, "%s:", type);
} else {
switch (virDomainDiskGetType(disk)) {
case VIR_STORAGE_TYPE_FILE:
virBufferAddLit(&buf, "file:");
break;
case VIR_STORAGE_TYPE_BLOCK:
virBufferAddLit(&buf, "phy:");
break;
default:
virReportError(VIR_ERR_INTERNAL_ERROR,
_("unsupported disk type %s"),
virStorageTypeToString(virDomainDiskGetType(disk)));
goto cleanup;
}
}
virBufferAdd(&buf, src, -1);
}
virBufferAddLit(&buf, ",");
virBufferAdd(&buf, disk->dst, -1);
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM)
virBufferAddLit(&buf, ":cdrom");
if (disk->src->readonly)
virBufferAddLit(&buf, ",r");
else if (disk->src->shared)
virBufferAddLit(&buf, ",!");
else
virBufferAddLit(&buf, ",w");
if (disk->transient) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("transient disks not supported yet"));
return -1;
}
if (virBufferCheckError(&buf) < 0)
goto cleanup;
if (VIR_ALLOC(val) < 0)
goto cleanup;
val->type = VIR_CONF_STRING;
val->str = virBufferContentAndReset(&buf);
tmp = list->list;
while (tmp && tmp->next)
tmp = tmp->next;
if (tmp)
tmp->next = val;
else
list->list = val;
return 0;
cleanup:
virBufferFreeAndReset(&buf);
return -1;
}
