External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2025-02-22 19:32:19 +00:00
Code Issues Packages Projects Releases Wiki Activity

conf: use disk source accessors in qemu/

Browse Source 
Part of a series of cleanups to use new accessor methods.

* src/qemu/qemu_conf.c (qemuCheckSharedDevice)
(qemuAddSharedDevice, qemuRemoveSharedDevice, qemuSetUnprivSGIO):
Use accessors.
* src/qemu/qemu_domain.c (qemuDomainDeviceDefPostParse)
(qemuDomainObjCheckDiskTaint, qemuDomainSnapshotForEachQcow2Raw)
(qemuDomainCheckRemoveOptionalDisk, qemuDomainCheckDiskPresence)
(qemuDiskChainCheckBroken, qemuDomainDetermineDiskChain):
Likewise.
* src/qemu/qemu_hotplug.c (qemuDomainChangeEjectableMedia)
(qemuDomainCheckEjectableMedia)
(qemuDomainAttachVirtioDiskDevice, qemuDomainAttachSCSIDisk)
(qemuDomainAttachUSBMassstorageDevice)
(qemuDomainAttachDeviceDiskLive, qemuDomainRemoveDiskDevice)
(qemuDomainDetachVirtioDiskDevice, qemuDomainDetachDiskDevice):
Likewise.
* src/qemu/qemu_migration.c (qemuMigrationStartNBDServer)
(qemuMigrationDriveMirror, qemuMigrationCancelDriveMirror)
(qemuMigrationIsSafe): Likewise.
* src/qemu/qemu_process.c (qemuProcessGetVolumeQcowPassphrase)
(qemuProcessHandleIOError, qemuProcessHandleBlockJob)
(qemuProcessInitPasswords): Likewise.
* src/qemu/qemu_driver.c (qemuDomainChangeDiskMediaLive)
(qemuDomainGetBlockInfo, qemuDiskPathToAlias): Likewise.

Signed-off-by: Eric Blake <eblake@redhat.com>
This commit is contained in:
Eric Blake 2014-03-18 13:16:47 -06:00
parent 73f4ae2a1f
commit cd01d2ad51
6 changed files with 135 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
src/qemu/qemu_conf.c
View File

@ -1,7 +1,7 @@
/* /*
* qemu_conf.c: QEMU configuration management * qemu_conf.c: QEMU configuration management
* *
* Copyright (C) 2006-2013 Red Hat, Inc. * Copyright (C) 2006-2014 Red Hat, Inc.
* Copyright (C) 2006 Daniel P. Berrange * Copyright (C) 2006 Daniel P. Berrange
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
@ -744,6 +744,7 @@ qemuCheckSharedDevice(virHashTablePtr sharedDevices,
char *key = NULL; char *key = NULL;
int val; int val;
int ret = 0; int ret = 0;
const char *src;
if (dev->type == VIR_DOMAIN_DEVICE_DISK) { if (dev->type == VIR_DOMAIN_DEVICE_DISK) {
disk = dev->data.disk; disk = dev->data.disk;
@ -757,7 +758,8 @@ qemuCheckSharedDevice(virHashTablePtr sharedDevices,
return 0; return 0;
} }
if (!(sysfs_path = virGetUnprivSGIOSysfsPath(disk->src, NULL))) { src = virDomainDiskGetSource(disk);
if (!(sysfs_path = virGetUnprivSGIOSysfsPath(src, NULL))) {
ret = -1; ret = -1;
goto cleanup; goto cleanup;
} }
@ -768,7 +770,7 @@ qemuCheckSharedDevice(virHashTablePtr sharedDevices,
if (!virFileExists(sysfs_path)) if (!virFileExists(sysfs_path))
goto cleanup; goto cleanup;
if (!(key = qemuGetSharedDeviceKey(disk->src))) { if (!(key = qemuGetSharedDeviceKey(src))) {
ret = -1; ret = -1;
goto cleanup; goto cleanup;
} }
@ -779,7 +781,7 @@ qemuCheckSharedDevice(virHashTablePtr sharedDevices,
if (!(virHashLookup(sharedDevices, key))) if (!(virHashLookup(sharedDevices, key)))
goto cleanup; goto cleanup;
if (virGetDeviceUnprivSGIO(disk->src, NULL, &val) < 0) { if (virGetDeviceUnprivSGIO(src, NULL, &val) < 0) {
ret = -1; ret = -1;
goto cleanup; goto cleanup;
} }
@ -791,7 +793,7 @@ qemuCheckSharedDevice(virHashTablePtr sharedDevices,
disk->sgio == VIR_DOMAIN_DEVICE_SGIO_UNFILTERED)) disk->sgio == VIR_DOMAIN_DEVICE_SGIO_UNFILTERED))
goto cleanup; goto cleanup;
if (disk->type == VIR_DOMAIN_DISK_TYPE_VOLUME) { if (virDomainDiskGetType(disk) == VIR_DOMAIN_DISK_TYPE_VOLUME) {
virReportError(VIR_ERR_OPERATION_INVALID, virReportError(VIR_ERR_OPERATION_INVALID,
_("sgio of shared disk 'pool=%s' 'volume=%s' conflicts " _("sgio of shared disk 'pool=%s' 'volume=%s' conflicts "
"with other active domains"), "with other active domains"),
@ -800,7 +802,7 @@ qemuCheckSharedDevice(virHashTablePtr sharedDevices,
} else { } else {
virReportError(VIR_ERR_OPERATION_INVALID, virReportError(VIR_ERR_OPERATION_INVALID,
_("sgio of shared disk '%s' conflicts with other " _("sgio of shared disk '%s' conflicts with other "
"active domains"), disk->src); "active domains"), src);
} }
ret = -1; ret = -1;
@ -917,7 +919,7 @@ qemuAddSharedDevice(virQEMUDriverPtr driver,
goto cleanup; goto cleanup;
if (dev->type == VIR_DOMAIN_DEVICE_DISK) { if (dev->type == VIR_DOMAIN_DEVICE_DISK) {
if (!(key = qemuGetSharedDeviceKey(disk->src))) if (!(key = qemuGetSharedDeviceKey(virDomainDiskGetSource(disk))))
goto cleanup; goto cleanup;
} else { } else {
if (!(dev_name = virSCSIDeviceGetDevName(NULL, if (!(dev_name = virSCSIDeviceGetDevName(NULL,
@ -1022,7 +1024,7 @@ qemuRemoveSharedDevice(virQEMUDriverPtr driver,
qemuDriverLock(driver); qemuDriverLock(driver);
if (dev->type == VIR_DOMAIN_DEVICE_DISK) { if (dev->type == VIR_DOMAIN_DEVICE_DISK) {
if (!(key = qemuGetSharedDeviceKey(disk->src))) if (!(key = qemuGetSharedDeviceKey(virDomainDiskGetSource(disk))))
goto cleanup; goto cleanup;
} else { } else {
if (!(dev_name = virSCSIDeviceGetDevName(NULL, if (!(dev_name = virSCSIDeviceGetDevName(NULL,
@ -1079,7 +1081,7 @@ qemuSetUnprivSGIO(virDomainDeviceDefPtr dev)
virDomainDiskDefPtr disk = NULL; virDomainDiskDefPtr disk = NULL;
virDomainHostdevDefPtr hostdev = NULL; virDomainHostdevDefPtr hostdev = NULL;
char *sysfs_path = NULL; char *sysfs_path = NULL;
char *path = NULL; const char *path = NULL;
int val = -1; int val = -1;
int ret = 0; int ret = 0;
@ -1093,7 +1095,7 @@ qemuSetUnprivSGIO(virDomainDeviceDefPtr dev)
!virDomainDiskSourceIsBlockType(disk)) !virDomainDiskSourceIsBlockType(disk))
return 0; return 0;
path = disk->src; path = virDomainDiskGetSource(disk);
} else if (dev->type == VIR_DOMAIN_DEVICE_HOSTDEV) { } else if (dev->type == VIR_DOMAIN_DEVICE_HOSTDEV) {
hostdev = dev->data.hostdev; hostdev = dev->data.hostdev;

60
src/qemu/qemu_domain.c
View File

@ -872,10 +872,10 @@ qemuDomainDeviceDefPostParse(virDomainDeviceDefPtr dev,
/* assign default storage format and driver according to config */ /* assign default storage format and driver according to config */
if (cfg->allowDiskFormatProbing) { if (cfg->allowDiskFormatProbing) {
/* default disk format for drives */ /* default disk format for drives */
if (disk->format == VIR_STORAGE_FILE_NONE && if (virDomainDiskGetFormat(disk) == VIR_STORAGE_FILE_NONE &&
(disk->type == VIR_DOMAIN_DISK_TYPE_FILE || (virDomainDiskGetType(disk) == VIR_DOMAIN_DISK_TYPE_FILE ||
disk->type == VIR_DOMAIN_DISK_TYPE_BLOCK)) virDomainDiskGetType(disk) == VIR_DOMAIN_DISK_TYPE_BLOCK))
disk->format = VIR_STORAGE_FILE_AUTO; virDomainDiskSetFormat(disk, VIR_STORAGE_FILE_AUTO);
/* default disk format for mirrored drive */ /* default disk format for mirrored drive */
if (disk->mirror && if (disk->mirror &&
@ -883,15 +883,15 @@ qemuDomainDeviceDefPostParse(virDomainDeviceDefPtr dev,
disk->mirrorFormat = VIR_STORAGE_FILE_AUTO; disk->mirrorFormat = VIR_STORAGE_FILE_AUTO;
} else { } else {
/* default driver if probing is forbidden */ /* default driver if probing is forbidden */
if (!disk->driverName && if (!virDomainDiskGetDriver(disk) &&
VIR_STRDUP(disk->driverName, "qemu") < 0) virDomainDiskSetDriver(disk, "qemu") < 0)
goto cleanup; goto cleanup;
/* default disk format for drives */ /* default disk format for drives */
if (disk->format == VIR_STORAGE_FILE_NONE && if (virDomainDiskGetFormat(disk) == VIR_STORAGE_FILE_NONE &&
(disk->type == VIR_DOMAIN_DISK_TYPE_FILE || (virDomainDiskGetType(disk) == VIR_DOMAIN_DISK_TYPE_FILE ||
disk->type == VIR_DOMAIN_DISK_TYPE_BLOCK)) virDomainDiskGetType(disk) == VIR_DOMAIN_DISK_TYPE_BLOCK))
disk->format = VIR_STORAGE_FILE_RAW; virDomainDiskSetFormat(disk, VIR_STORAGE_FILE_RAW);
/* default disk format for mirrored drive */ /* default disk format for mirrored drive */
if (disk->mirror && if (disk->mirror &&
@ -1697,8 +1697,9 @@ void qemuDomainObjCheckDiskTaint(virQEMUDriverPtr driver,
int logFD) int logFD)
{ {
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver); virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
int format = virDomainDiskGetFormat(disk);
if ((!disk->format || disk->format == VIR_STORAGE_FILE_AUTO) && if ((!format || format == VIR_STORAGE_FILE_AUTO) &&
cfg->allowDiskFormatProbing) cfg->allowDiskFormatProbing)
qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_DISK_PROBING, logFD); qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_DISK_PROBING, logFD);
@ -1939,8 +1940,9 @@ qemuDomainSnapshotForEachQcow2Raw(virQEMUDriverPtr driver,
for (i = 0; i < ndisks; i++) { for (i = 0; i < ndisks; i++) {
/* FIXME: we also need to handle LVM here */ /* FIXME: we also need to handle LVM here */
if (def->disks[i]->device == VIR_DOMAIN_DISK_DEVICE_DISK) { if (def->disks[i]->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
if (def->disks[i]->format > 0 && int format = virDomainDiskGetFormat(def->disks[i]);
def->disks[i]->format != VIR_STORAGE_FILE_QCOW2) {
if (format > 0 && format != VIR_STORAGE_FILE_QCOW2) {
if (try_all) { if (try_all) {
/* Continue on even in the face of error, since other /* Continue on even in the face of error, since other
* disks in this VM may have the same snapshot name. * disks in this VM may have the same snapshot name.
@ -1962,7 +1964,7 @@ qemuDomainSnapshotForEachQcow2Raw(virQEMUDriverPtr driver,
return -1; return -1;
} }
qemuimgarg[4] = def->disks[i]->src; qemuimgarg[4] = virDomainDiskGetSource(def->disks[i]);
if (virRun(qemuimgarg, NULL) < 0) { if (virRun(qemuimgarg, NULL) < 0) {
if (try_all) { if (try_all) {
@ -2160,28 +2162,29 @@ qemuDomainCheckRemoveOptionalDisk(virQEMUDriverPtr driver,
char uuid[VIR_UUID_STRING_BUFLEN]; char uuid[VIR_UUID_STRING_BUFLEN];
virObjectEventPtr event = NULL; virObjectEventPtr event = NULL;
virDomainDiskDefPtr del_disk = NULL; virDomainDiskDefPtr del_disk = NULL;
const char *src = virDomainDiskGetSource(disk);
virUUIDFormat(vm->def->uuid, uuid); virUUIDFormat(vm->def->uuid, uuid);
VIR_DEBUG("Dropping disk '%s' on domain '%s' (UUID '%s') " VIR_DEBUG("Dropping disk '%s' on domain '%s' (UUID '%s') "
"due to inaccessible source '%s'", "due to inaccessible source '%s'",
disk->dst, vm->def->name, uuid, disk->src); disk->dst, vm->def->name, uuid, src);
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM || if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM ||
disk->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY) { disk->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY) {
event = virDomainEventDiskChangeNewFromObj(vm, disk->src, NULL, event = virDomainEventDiskChangeNewFromObj(vm, src, NULL,
disk->info.alias, disk->info.alias,
VIR_DOMAIN_EVENT_DISK_CHANGE_MISSING_ON_START); VIR_DOMAIN_EVENT_DISK_CHANGE_MISSING_ON_START);
VIR_FREE(disk->src); ignore_value(virDomainDiskSetSource(disk, NULL));
} else { } else {
event = virDomainEventDiskChangeNewFromObj(vm, disk->src, NULL, event = virDomainEventDiskChangeNewFromObj(vm, src, NULL,
disk->info.alias, disk->info.alias,
VIR_DOMAIN_EVENT_DISK_DROP_MISSING_ON_START); VIR_DOMAIN_EVENT_DISK_DROP_MISSING_ON_START);
if (!(del_disk = virDomainDiskRemoveByName(vm->def, disk->src))) { if (!(del_disk = virDomainDiskRemoveByName(vm->def, src))) {
virReportError(VIR_ERR_INVALID_ARG, virReportError(VIR_ERR_INVALID_ARG,
_("no source device %s"), disk->src); _("no source device %s"), src);
return -1; return -1;
} }
virDomainDiskDefFree(del_disk); virDomainDiskDefFree(del_disk);
@ -2244,7 +2247,7 @@ qemuDomainCheckDiskPresence(virQEMUDriverPtr driver,
for (i = vm->def->ndisks; i > 0; i--) { for (i = vm->def->ndisks; i > 0; i--) {
disk = vm->def->disks[i - 1]; disk = vm->def->disks[i - 1];
if (!disk->src) if (!virDomainDiskGetSource(disk))
continue; continue;
if (qemuDomainDetermineDiskChain(driver, vm, disk, false) >= 0 && if (qemuDomainDetermineDiskChain(driver, vm, disk, false) >= 0 &&
@ -2339,7 +2342,7 @@ qemuDiskChainCheckBroken(virDomainDiskDefPtr disk)
{ {
char *brokenFile = NULL; char *brokenFile = NULL;
if (!disk->src || !disk->backingChain) if (!virDomainDiskGetSource(disk) || !disk->backingChain)
return 0; return 0;
if (virStorageFileChainGetBroken(disk->backingChain, &brokenFile) < 0) if (virStorageFileChainGetBroken(disk->backingChain, &brokenFile) < 0)
@ -2348,7 +2351,7 @@ qemuDiskChainCheckBroken(virDomainDiskDefPtr disk)
if (brokenFile) { if (brokenFile) {
virReportError(VIR_ERR_INVALID_ARG, virReportError(VIR_ERR_INVALID_ARG,
_("Backing file '%s' of image '%s' is missing."), _("Backing file '%s' of image '%s' is missing."),
brokenFile, disk->src); brokenFile, virDomainDiskGetSource(disk));
VIR_FREE(brokenFile); VIR_FREE(brokenFile);
return -1; return -1;
} }
@ -2397,10 +2400,12 @@ qemuDomainDetermineDiskChain(virQEMUDriverPtr driver,
int ret = 0; int ret = 0;
uid_t uid; uid_t uid;
gid_t gid; gid_t gid;
const char *src = virDomainDiskGetSource(disk);
int type = virDomainDiskGetType(disk);
if (!disk->src || if (!src ||
disk->type == VIR_DOMAIN_DISK_TYPE_NETWORK || type == VIR_DOMAIN_DISK_TYPE_NETWORK ||
disk->type == VIR_DOMAIN_DISK_TYPE_VOLUME) type == VIR_DOMAIN_DISK_TYPE_VOLUME)
goto cleanup; goto cleanup;
if (disk->backingChain) { if (disk->backingChain) {
@ -2414,7 +2419,8 @@ qemuDomainDetermineDiskChain(virQEMUDriverPtr driver,
qemuDomainGetImageIds(cfg, vm, disk, &uid, &gid); qemuDomainGetImageIds(cfg, vm, disk, &uid, &gid);
disk->backingChain = virStorageFileGetMetadata(disk->src, disk->format, disk->backingChain = virStorageFileGetMetadata(src,
virDomainDiskGetFormat(disk),
uid, gid, uid, gid,
cfg->allowDiskFormatProbing); cfg->allowDiskFormatProbing);
if (!disk->backingChain) if (!disk->backingChain)

18
src/qemu/qemu_driver.c
View File

@ -6546,7 +6546,7 @@ qemuDomainChangeDiskMediaLive(virConnectPtr conn,
if (ret != 0 && if (ret != 0 &&
qemuTeardownDiskCgroup(vm, disk) < 0) qemuTeardownDiskCgroup(vm, disk) < 0)
VIR_WARN("Failed to teardown cgroup for disk path %s", VIR_WARN("Failed to teardown cgroup for disk path %s",
NULLSTR(disk->src)); NULLSTR(virDomainDiskGetSource(disk)));
end: end:
virObjectUnref(caps); virObjectUnref(caps);
@ -10301,13 +10301,13 @@ qemuDomainGetBlockInfo(virDomainPtr dom,
goto cleanup; goto cleanup;
} }
disk = vm->def->disks[idx]; disk = vm->def->disks[idx];
if (!disk->src) { path = virDomainDiskGetSource(disk);
if (!path) {
virReportError(VIR_ERR_INVALID_ARG, virReportError(VIR_ERR_INVALID_ARG,
_("disk %s does not currently have a source assigned"), _("disk %s does not currently have a source assigned"),
path); path);
goto cleanup; goto cleanup;
} }
path = disk->src;
/* The path is correct, now try to open it and get its size. */ /* The path is correct, now try to open it and get its size. */
fd = qemuOpenFile(driver, vm, path, O_RDONLY, NULL, NULL); fd = qemuOpenFile(driver, vm, path, O_RDONLY, NULL, NULL);
@ -10315,18 +10315,18 @@ qemuDomainGetBlockInfo(virDomainPtr dom,
goto cleanup; goto cleanup;
/* Probe for magic formats */ /* Probe for magic formats */
if (disk->format) { if (virDomainDiskGetFormat(disk)) {
format = disk->format; format = virDomainDiskGetFormat(disk);
} else { } else {
if (cfg->allowDiskFormatProbing) { if (cfg->allowDiskFormatProbing) {
if ((format = virStorageFileProbeFormat(disk->src, if ((format = virStorageFileProbeFormat(path,
cfg->user, cfg->user,
cfg->group)) < 0) cfg->group)) < 0)
goto cleanup; goto cleanup;
} else { } else {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("no disk format for %s and probing is disabled"), _("no disk format for %s and probing is disabled"),
disk->src); path);
goto cleanup; goto cleanup;
} }
} }
@ -10377,7 +10377,7 @@ qemuDomainGetBlockInfo(virDomainPtr dom,
/* ..but if guest is not using raw disk format and on a block device, /* ..but if guest is not using raw disk format and on a block device,
* then query highest allocated extent from QEMU * then query highest allocated extent from QEMU
*/ */
if (disk->type == VIR_DOMAIN_DISK_TYPE_BLOCK && if (virDomainDiskGetType(disk) == VIR_DOMAIN_DISK_TYPE_BLOCK &&
format != VIR_STORAGE_FILE_RAW && format != VIR_STORAGE_FILE_RAW &&
S_ISBLK(sb.st_mode)) { S_ISBLK(sb.st_mode)) {
qemuDomainObjPrivatePtr priv = vm->privateData; qemuDomainObjPrivatePtr priv = vm->privateData;
@ -14659,7 +14659,7 @@ qemuDiskPathToAlias(virDomainObjPtr vm, const char *path, int *idxret)
if (idxret) if (idxret)
*idxret = idx; *idxret = idx;
if (disk->src) { if (virDomainDiskGetSource(disk)) {
if (virAsprintf(&ret, "drive-%s", disk->info.alias) < 0) if (virAsprintf(&ret, "drive-%s", disk->info.alias) < 0)
return NULL; return NULL;
} }

116
src/qemu/qemu_hotplug.c
View File

@ -71,6 +71,7 @@ int qemuDomainChangeEjectableMedia(virQEMUDriverPtr driver,
qemuDomainObjPrivatePtr priv = vm->privateData; qemuDomainObjPrivatePtr priv = vm->privateData;
int retries = CHANGE_MEDIA_RETRIES; int retries = CHANGE_MEDIA_RETRIES;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver); virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
const char *src = NULL;
if (!origdisk->info.alias) { if (!origdisk->info.alias) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
@ -93,7 +94,8 @@ int qemuDomainChangeEjectableMedia(virQEMUDriverPtr driver,
if (virSecurityManagerSetImageLabel(driver->securityManager, if (virSecurityManagerSetImageLabel(driver->securityManager,
vm->def, disk) < 0) { vm->def, disk) < 0) {
if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0) if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0)
VIR_WARN("Unable to release lock on %s", disk->src); VIR_WARN("Unable to release lock on %s",
virDomainDiskGetSource(disk));
goto cleanup; goto cleanup;
} }
@ -128,41 +130,49 @@ int qemuDomainChangeEjectableMedia(virQEMUDriverPtr driver,
} }
ret = 0; ret = 0;
if (disk->src) { src = virDomainDiskGetSource(disk);
if (src) {
/* deliberately don't depend on 'ret' as 'eject' may have failed the /* deliberately don't depend on 'ret' as 'eject' may have failed the
* first time and we are going to check the drive state anyway */ * first time and we are going to check the drive state anyway */
const char *format = NULL; const char *format = NULL;
int type = virDomainDiskGetType(disk);
int diskFormat = virDomainDiskGetFormat(disk);
if (disk->type != VIR_DOMAIN_DISK_TYPE_DIR) { if (type != VIR_DOMAIN_DISK_TYPE_DIR) {
if (disk->format > 0) if (diskFormat > 0) {
format = virStorageFileFormatTypeToString(disk->format); format = virStorageFileFormatTypeToString(diskFormat);
else if (origdisk->format > 0) } else {
format = virStorageFileFormatTypeToString(origdisk->format); diskFormat = virDomainDiskGetFormat(origdisk);
if (diskFormat > 0)
format = virStorageFileFormatTypeToString(diskFormat);
}
} }
qemuDomainObjEnterMonitor(driver, vm); qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorChangeMedia(priv->mon, ret = qemuMonitorChangeMedia(priv->mon,
driveAlias, driveAlias,
disk->src, format); src, format);
qemuDomainObjExitMonitor(driver, vm); qemuDomainObjExitMonitor(driver, vm);
} }
audit: audit:
virDomainAuditDisk(vm, origdisk->src, disk->src, "update", ret >= 0); if (src)
virDomainAuditDisk(vm, virDomainDiskGetSource(origdisk),
src, "update", ret >= 0);
if (ret < 0) if (ret < 0)
goto error; goto error;
if (virSecurityManagerRestoreImageLabel(driver->securityManager, if (virSecurityManagerRestoreImageLabel(driver->securityManager,
vm->def, origdisk) < 0) vm->def, origdisk) < 0)
VIR_WARN("Unable to restore security label on ejected image %s", origdisk->src); VIR_WARN("Unable to restore security label on ejected image %s",
virDomainDiskGetSource(origdisk));
if (virDomainLockDiskDetach(driver->lockManager, vm, origdisk) < 0) if (virDomainLockDiskDetach(driver->lockManager, vm, origdisk) < 0)
VIR_WARN("Unable to release lock on disk %s", origdisk->src); VIR_WARN("Unable to release lock on disk %s",
virDomainDiskGetSource(origdisk));
VIR_FREE(origdisk->src);
origdisk->src = disk->src;
disk->src = NULL;
origdisk->type = disk->type;
if (virDomainDiskSetSource(origdisk, src) < 0)
goto error;
virDomainDiskSetType(origdisk, virDomainDiskGetType(disk));
virDomainDiskDefFree(disk); virDomainDiskDefFree(disk);
@ -174,10 +184,10 @@ cleanup:
error: error:
if (virSecurityManagerRestoreImageLabel(driver->securityManager, if (virSecurityManagerRestoreImageLabel(driver->securityManager,
vm->def, disk) < 0) vm->def, disk) < 0)
VIR_WARN("Unable to restore security label on new media %s", disk->src); VIR_WARN("Unable to restore security label on new media %s", src);
if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0) if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0)
VIR_WARN("Unable to release lock on %s", disk->src); VIR_WARN("Unable to release lock on %s", src);
goto cleanup; goto cleanup;
} }
@ -213,8 +223,8 @@ qemuDomainCheckEjectableMedia(virQEMUDriverPtr driver,
if (!info) if (!info)
goto cleanup; goto cleanup;
if (info->tray_open && disk->src) if (info->tray_open && virDomainDiskGetSource(disk))
VIR_FREE(disk->src); ignore_value(virDomainDiskSetSource(disk, NULL));
} }
ret = 0; ret = 0;
@ -238,6 +248,7 @@ qemuDomainAttachVirtioDiskDevice(virConnectPtr conn,
char *drivestr = NULL; char *drivestr = NULL;
bool releaseaddr = false; bool releaseaddr = false;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver); virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
const char *src = virDomainDiskGetSource(disk);
if (!disk->info.type) { if (!disk->info.type) {
if (STREQLEN(vm->def->os.machine, "s390-ccw", 8) && if (STREQLEN(vm->def->os.machine, "s390-ccw", 8) &&
@ -262,7 +273,7 @@ qemuDomainAttachVirtioDiskDevice(virConnectPtr conn,
if (virSecurityManagerSetImageLabel(driver->securityManager, if (virSecurityManagerSetImageLabel(driver->securityManager,
vm->def, disk) < 0) { vm->def, disk) < 0) {
if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0) if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0)
VIR_WARN("Unable to release lock on %s", disk->src); VIR_WARN("Unable to release lock on %s", src);
goto cleanup; goto cleanup;
} }
@ -311,10 +322,7 @@ qemuDomainAttachVirtioDiskDevice(virConnectPtr conn,
} else if (!disk->info.type || } else if (!disk->info.type ||
disk->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) { disk->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
virDevicePCIAddress guestAddr = disk->info.addr.pci; virDevicePCIAddress guestAddr = disk->info.addr.pci;
ret = qemuMonitorAddPCIDisk(priv->mon, ret = qemuMonitorAddPCIDisk(priv->mon, src, type, &guestAddr);
disk->src,
type,
&guestAddr);
if (ret == 0) { if (ret == 0) {
disk->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI; disk->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
memcpy(&disk->info.addr.pci, &guestAddr, sizeof(guestAddr)); memcpy(&disk->info.addr.pci, &guestAddr, sizeof(guestAddr));
@ -322,7 +330,7 @@ qemuDomainAttachVirtioDiskDevice(virConnectPtr conn,
} }
qemuDomainObjExitMonitor(driver, vm); qemuDomainObjExitMonitor(driver, vm);
virDomainAuditDisk(vm, NULL, disk->src, "attach", ret >= 0); virDomainAuditDisk(vm, NULL, src, "attach", ret >= 0);
if (ret < 0) if (ret < 0)
goto error; goto error;
@ -337,14 +345,14 @@ cleanup:
error: error:
if (releaseaddr) if (releaseaddr)
qemuDomainReleaseDeviceAddress(vm, &disk->info, disk->src); qemuDomainReleaseDeviceAddress(vm, &disk->info, src);
if (virSecurityManagerRestoreImageLabel(driver->securityManager, if (virSecurityManagerRestoreImageLabel(driver->securityManager,
vm->def, disk) < 0) vm->def, disk) < 0)
VIR_WARN("Unable to restore security label on %s", disk->src); VIR_WARN("Unable to restore security label on %s", src);
if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0) if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0)
VIR_WARN("Unable to release lock on %s", disk->src); VIR_WARN("Unable to release lock on %s", src);
goto cleanup; goto cleanup;
} }
@ -487,6 +495,7 @@ qemuDomainAttachSCSIDisk(virConnectPtr conn,
char *devstr = NULL; char *devstr = NULL;
int ret = -1; int ret = -1;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver); virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
const char *src = virDomainDiskGetSource(disk);
for (i = 0; i < vm->def->ndisks; i++) { for (i = 0; i < vm->def->ndisks; i++) {
if (STREQ(vm->def->disks[i]->dst, disk->dst)) { if (STREQ(vm->def->disks[i]->dst, disk->dst)) {
@ -503,7 +512,7 @@ qemuDomainAttachSCSIDisk(virConnectPtr conn,
if (virSecurityManagerSetImageLabel(driver->securityManager, if (virSecurityManagerSetImageLabel(driver->securityManager,
vm->def, disk) < 0) { vm->def, disk) < 0) {
if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0) if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0)
VIR_WARN("Unable to release lock on %s", disk->src); VIR_WARN("Unable to release lock on %s", src);
goto cleanup; goto cleanup;
} }
@ -574,7 +583,7 @@ qemuDomainAttachSCSIDisk(virConnectPtr conn,
} }
qemuDomainObjExitMonitor(driver, vm); qemuDomainObjExitMonitor(driver, vm);
virDomainAuditDisk(vm, NULL, disk->src, "attach", ret >= 0); virDomainAuditDisk(vm, NULL, src, "attach", ret >= 0);
if (ret < 0) if (ret < 0)
goto error; goto error;
@ -590,10 +599,10 @@ cleanup:
error: error:
if (virSecurityManagerRestoreImageLabel(driver->securityManager, if (virSecurityManagerRestoreImageLabel(driver->securityManager,
vm->def, disk) < 0) vm->def, disk) < 0)
VIR_WARN("Unable to restore security label on %s", disk->src); VIR_WARN("Unable to restore security label on %s", src);
if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0) if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0)
VIR_WARN("Unable to release lock on %s", disk->src); VIR_WARN("Unable to release lock on %s", src);
goto cleanup; goto cleanup;
} }
@ -611,6 +620,7 @@ qemuDomainAttachUSBMassstorageDevice(virConnectPtr conn,
char *drivestr = NULL; char *drivestr = NULL;
char *devstr = NULL; char *devstr = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver); virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
const char *src = virDomainDiskGetSource(disk);
for (i = 0; i < vm->def->ndisks; i++) { for (i = 0; i < vm->def->ndisks; i++) {
if (STREQ(vm->def->disks[i]->dst, disk->dst)) { if (STREQ(vm->def->disks[i]->dst, disk->dst)) {
@ -627,12 +637,12 @@ qemuDomainAttachUSBMassstorageDevice(virConnectPtr conn,
if (virSecurityManagerSetImageLabel(driver->securityManager, if (virSecurityManagerSetImageLabel(driver->securityManager,
vm->def, disk) < 0) { vm->def, disk) < 0) {
if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0) if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0)
VIR_WARN("Unable to release lock on %s", disk->src); VIR_WARN("Unable to release lock on %s", src);
goto cleanup; goto cleanup;
} }
/* XXX not correct once we allow attaching a USB CDROM */ /* XXX not correct once we allow attaching a USB CDROM */
if (!disk->src) { if (!src) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("disk source path is missing")); "%s", _("disk source path is missing"));
goto error; goto error;
@ -663,11 +673,11 @@ qemuDomainAttachUSBMassstorageDevice(virConnectPtr conn,
} }
} }
} else { } else {
ret = qemuMonitorAddUSBDisk(priv->mon, disk->src); ret = qemuMonitorAddUSBDisk(priv->mon, src);
} }
qemuDomainObjExitMonitor(driver, vm); qemuDomainObjExitMonitor(driver, vm);
virDomainAuditDisk(vm, NULL, disk->src, "attach", ret >= 0); virDomainAuditDisk(vm, NULL, src, "attach", ret >= 0);
if (ret < 0) if (ret < 0)
goto error; goto error;
@ -683,10 +693,10 @@ cleanup:
error: error:
if (virSecurityManagerRestoreImageLabel(driver->securityManager, if (virSecurityManagerRestoreImageLabel(driver->securityManager,
vm->def, disk) < 0) vm->def, disk) < 0)
VIR_WARN("Unable to restore security label on %s", disk->src); VIR_WARN("Unable to restore security label on %s", src);
if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0) if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0)
VIR_WARN("Unable to release lock on %s", disk->src); VIR_WARN("Unable to release lock on %s", src);
goto cleanup; goto cleanup;
} }
@ -704,11 +714,13 @@ qemuDomainAttachDeviceDiskLive(virConnectPtr conn,
virDomainDiskDefPtr tmp = NULL; virDomainDiskDefPtr tmp = NULL;
virCapsPtr caps = NULL; virCapsPtr caps = NULL;
int ret = -1; int ret = -1;
const char *driverName = virDomainDiskGetDriver(disk);
const char *src = virDomainDiskGetSource(disk);
if (disk->driverName != NULL && !STREQ(disk->driverName, "qemu")) { if (driverName && !STREQ(driverName, "qemu")) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("unsupported driver name '%s' for disk '%s'"), _("unsupported driver name '%s' for disk '%s'"),
disk->driverName, disk->src); driverName, src);
goto end; goto end;
} }
@ -794,7 +806,7 @@ qemuDomainAttachDeviceDiskLive(virConnectPtr conn,
if (ret != 0 && if (ret != 0 &&
qemuTeardownDiskCgroup(vm, disk) < 0) { qemuTeardownDiskCgroup(vm, disk) < 0) {
VIR_WARN("Failed to teardown cgroup for disk path %s", VIR_WARN("Failed to teardown cgroup for disk path %s",
NULLSTR(disk->src)); NULLSTR(src));
} }
end: end:
@ -2460,11 +2472,12 @@ qemuDomainRemoveDiskDevice(virQEMUDriverPtr driver,
virDomainDeviceDef dev; virDomainDeviceDef dev;
virObjectEventPtr event; virObjectEventPtr event;
size_t i; size_t i;
const char *src = virDomainDiskGetSource(disk);
VIR_DEBUG("Removing disk %s from domain %p %s", VIR_DEBUG("Removing disk %s from domain %p %s",
disk->info.alias, vm, vm->def->name); disk->info.alias, vm, vm->def->name);
virDomainAuditDisk(vm, disk->src, NULL, "detach", true); virDomainAuditDisk(vm, src, NULL, "detach", true);
event = virDomainEventDeviceRemovedNewFromObj(vm, disk->info.alias); event = virDomainEventDeviceRemovedNewFromObj(vm, disk->info.alias);
if (event) if (event)
@ -2477,17 +2490,17 @@ qemuDomainRemoveDiskDevice(virQEMUDriverPtr driver,
} }
} }
qemuDomainReleaseDeviceAddress(vm, &disk->info, disk->src); qemuDomainReleaseDeviceAddress(vm, &disk->info, src);
if (virSecurityManagerRestoreImageLabel(driver->securityManager, if (virSecurityManagerRestoreImageLabel(driver->securityManager,
vm->def, disk) < 0) vm->def, disk) < 0)
VIR_WARN("Unable to restore security label on %s", disk->src); VIR_WARN("Unable to restore security label on %s", src);
if (qemuTeardownDiskCgroup(vm, disk) < 0) if (qemuTeardownDiskCgroup(vm, disk) < 0)
VIR_WARN("Failed to tear down cgroup for disk path %s", disk->src); VIR_WARN("Failed to tear down cgroup for disk path %s", src);
if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0) if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0)
VIR_WARN("Unable to release lock on %s", disk->src); VIR_WARN("Unable to release lock on %s", src);
dev.type = VIR_DOMAIN_DEVICE_DISK; dev.type = VIR_DOMAIN_DEVICE_DISK;
dev.data.disk = disk; dev.data.disk = disk;
@ -2858,14 +2871,16 @@ qemuDomainDetachVirtioDiskDevice(virQEMUDriverPtr driver,
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) { if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) { if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
qemuDomainObjExitMonitor(driver, vm); qemuDomainObjExitMonitor(driver, vm);
virDomainAuditDisk(vm, detach->src, NULL, "detach", false); virDomainAuditDisk(vm, virDomainDiskGetSource(detach),
NULL, "detach", false);
goto cleanup; goto cleanup;
} }
} else { } else {
if (qemuMonitorRemovePCIDevice(priv->mon, if (qemuMonitorRemovePCIDevice(priv->mon,
&detach->info.addr.pci) < 0) { &detach->info.addr.pci) < 0) {
qemuDomainObjExitMonitor(driver, vm); qemuDomainObjExitMonitor(driver, vm);
virDomainAuditDisk(vm, detach->src, NULL, "detach", false); virDomainAuditDisk(vm, virDomainDiskGetSource(detach),
NULL, "detach", false);
goto cleanup; goto cleanup;
} }
} }
@ -2919,7 +2934,8 @@ qemuDomainDetachDiskDevice(virQEMUDriverPtr driver,
qemuDomainObjEnterMonitor(driver, vm); qemuDomainObjEnterMonitor(driver, vm);
if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) { if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
qemuDomainObjExitMonitor(driver, vm); qemuDomainObjExitMonitor(driver, vm);
virDomainAuditDisk(vm, detach->src, NULL, "detach", false); virDomainAuditDisk(vm, virDomainDiskGetSource(detach),
NULL, "detach", false);
goto cleanup; goto cleanup;
} }

17
src/qemu/qemu_migration.c
View File

@ -1159,7 +1159,7 @@ qemuMigrationStartNBDServer(virQEMUDriverPtr driver,
virDomainDiskDefPtr disk = vm->def->disks[i]; virDomainDiskDefPtr disk = vm->def->disks[i];
/* skip shared, RO and source-less disks */ /* skip shared, RO and source-less disks */
if (disk->shared || disk->readonly || !disk->src) if (disk->shared || disk->readonly || !virDomainDiskGetSource(disk))
continue; continue;
VIR_FREE(diskAlias); VIR_FREE(diskAlias);
@ -1265,7 +1265,7 @@ qemuMigrationDriveMirror(virQEMUDriverPtr driver,
virDomainBlockJobInfo info; virDomainBlockJobInfo info;
/* skip shared, RO and source-less disks */ /* skip shared, RO and source-less disks */
if (disk->shared || disk->readonly || !disk->src) if (disk->shared || disk->readonly || !virDomainDiskGetSource(disk))
continue; continue;
VIR_FREE(diskAlias); VIR_FREE(diskAlias);
@ -1351,7 +1351,7 @@ error:
virDomainDiskDefPtr disk = vm->def->disks[--lastGood]; virDomainDiskDefPtr disk = vm->def->disks[--lastGood];
/* skip shared, RO disks */ /* skip shared, RO disks */
if (disk->shared || disk->readonly || !disk->src) if (disk->shared || disk->readonly || !virDomainDiskGetSource(disk))
continue; continue;
VIR_FREE(diskAlias); VIR_FREE(diskAlias);
@ -1414,7 +1414,7 @@ qemuMigrationCancelDriveMirror(qemuMigrationCookiePtr mig,
virDomainDiskDefPtr disk = vm->def->disks[i]; virDomainDiskDefPtr disk = vm->def->disks[i];
/* skip shared, RO and source-less disks */ /* skip shared, RO and source-less disks */
if (disk->shared || disk->readonly || !disk->src) if (disk->shared || disk->readonly || !virDomainDiskGetSource(disk))
continue; continue;
VIR_FREE(diskAlias); VIR_FREE(diskAlias);
@ -1523,21 +1523,22 @@ qemuMigrationIsSafe(virDomainDefPtr def)
for (i = 0; i < def->ndisks; i++) { for (i = 0; i < def->ndisks; i++) {
virDomainDiskDefPtr disk = def->disks[i]; virDomainDiskDefPtr disk = def->disks[i];
const char *src = virDomainDiskGetSource(disk);
/* Our code elsewhere guarantees shared disks are either readonly (in /* Our code elsewhere guarantees shared disks are either readonly (in
* which case cache mode doesn't matter) or used with cache=none */ * which case cache mode doesn't matter) or used with cache=none */
if (disk->src && if (src &&
!disk->shared && !disk->shared &&
!disk->readonly && !disk->readonly &&
disk->cachemode != VIR_DOMAIN_DISK_CACHE_DISABLE) { disk->cachemode != VIR_DOMAIN_DISK_CACHE_DISABLE) {
int rc; int rc;
if (disk->type == VIR_DOMAIN_DISK_TYPE_FILE) { if (virDomainDiskGetType(disk) == VIR_DOMAIN_DISK_TYPE_FILE) {
if ((rc = virStorageFileIsSharedFS(disk->src)) < 0) if ((rc = virStorageFileIsSharedFS(src)) < 0)
return false; return false;
else if (rc == 0) else if (rc == 0)
continue; continue;
if ((rc = virStorageFileIsClusterFS(disk->src)) < 0) if ((rc = virStorageFileIsClusterFS(src)) < 0)
return false; return false;
else if (rc == 1) else if (rc == 1)
continue; continue;

11
src/qemu/qemu_process.c
View File

@ -448,7 +448,8 @@ qemuProcessGetVolumeQcowPassphrase(virConnectPtr conn,
enc->secrets[0]->type != enc->secrets[0]->type !=
VIR_STORAGE_ENCRYPTION_SECRET_TYPE_PASSPHRASE) { VIR_STORAGE_ENCRYPTION_SECRET_TYPE_PASSPHRASE) {
virReportError(VIR_ERR_XML_ERROR, virReportError(VIR_ERR_XML_ERROR,
_("invalid <encryption> for volume %s"), disk->src); _("invalid <encryption> for volume %s"),
virDomainDiskGetSource(disk));
goto cleanup; goto cleanup;
} }
@ -467,7 +468,7 @@ qemuProcessGetVolumeQcowPassphrase(virConnectPtr conn,
VIR_FREE(data); VIR_FREE(data);
virReportError(VIR_ERR_XML_ERROR, virReportError(VIR_ERR_XML_ERROR,
_("format='qcow' passphrase for %s must not contain a " _("format='qcow' passphrase for %s must not contain a "
"'\\0'"), disk->src); "'\\0'"), virDomainDiskGetSource(disk));
goto cleanup; goto cleanup;
} }
@ -958,7 +959,7 @@ qemuProcessHandleIOError(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
disk = qemuProcessFindDomainDiskByAlias(vm, diskAlias); disk = qemuProcessFindDomainDiskByAlias(vm, diskAlias);
if (disk) { if (disk) {
srcPath = disk->src; srcPath = virDomainDiskGetSource(disk);
devAlias = disk->info.alias; devAlias = disk->info.alias;
} else { } else {
srcPath = ""; srcPath = "";
@ -1015,7 +1016,7 @@ qemuProcessHandleBlockJob(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
disk = qemuProcessFindDomainDiskByAlias(vm, diskAlias); disk = qemuProcessFindDomainDiskByAlias(vm, diskAlias);
if (disk) { if (disk) {
path = disk->src; path = virDomainDiskGetSource(disk);
event = virDomainEventBlockJobNewFromObj(vm, path, type, status); event = virDomainEventBlockJobNewFromObj(vm, path, type, status);
/* XXX If we completed a block pull or commit, then recompute /* XXX If we completed a block pull or commit, then recompute
* the cached backing chain to match. Better would be storing * the cached backing chain to match. Better would be storing
@ -2222,7 +2223,7 @@ qemuProcessInitPasswords(virConnectPtr conn,
const char *alias; const char *alias;
if (!vm->def->disks[i]->encryption || if (!vm->def->disks[i]->encryption ||
!vm->def->disks[i]->src) !virDomainDiskGetSource(vm->def->disks[i]))
continue; continue;
if (qemuProcessGetVolumeQcowPassphrase(conn, if (qemuProcessGetVolumeQcowPassphrase(conn,