2010-12-16 16:10:54 +00:00
|
|
|
/*
|
|
|
|
* qemu_hotplug.h: QEMU device hotplug management
|
|
|
|
*
|
domain_conf: split source data out from ChrDef
This opens up the possibility of reusing the smaller ChrSourceDef
for both qemu monitor and a passthrough smartcard device.
* src/conf/domain_conf.h (_virDomainChrDef): Factor host
details...
(_virDomainChrSourceDef): ...into new struct.
(virDomainChrSourceDefFree): New prototype.
* src/conf/domain_conf.c (virDomainChrDefFree)
(virDomainChrDefParseXML, virDomainChrDefFormat): Split...
(virDomainChrSourceDefClear, virDomainChrSourceDefFree)
(virDomainChrSourceDefParseXML, virDomainChrSourceDefFormat):
...into new functions.
(virDomainChrDefParseTargetXML): Update clients to reflect type
split.
* src/vmx/vmx.c (virVMXParseSerial, virVMXParseParallel)
(virVMXFormatSerial, virVMXFormatParallel): Likewise.
* src/xen/xen_driver.c (xenUnifiedDomainOpenConsole): Likewise.
* src/xen/xend_internal.c (xenDaemonParseSxprChar)
(xenDaemonFormatSxprChr): Likewise.
* src/vbox/vbox_tmpl.c (vboxDomainDumpXML, vboxAttachSerial)
(vboxAttachParallel): Likewise.
* src/security/security_dac.c (virSecurityDACSetChardevLabel)
(virSecurityDACSetChardevCallback)
(virSecurityDACRestoreChardevLabel)
(virSecurityDACRestoreChardevCallback): Likewise.
* src/security/security_selinux.c (SELinuxSetSecurityChardevLabel)
(SELinuxSetSecurityChardevCallback)
(SELinuxRestoreSecurityChardevLabel)
(SELinuxSetSecurityChardevCallback): Likewise.
* src/security/virt-aa-helper.c (get_files): Likewise.
* src/lxc/lxc_driver.c (lxcVmStart, lxcDomainOpenConsole):
Likewise.
* src/uml/uml_conf.c (umlBuildCommandLineChr): Likewise.
* src/uml/uml_driver.c (umlIdentifyOneChrPTY, umlIdentifyChrPTY)
(umlDomainOpenConsole): Likewise.
* src/qemu/qemu_command.c (qemuBuildChrChardevStr)
(qemuBuildChrArgStr, qemuBuildCommandLine)
(qemuParseCommandLineChr): Likewise.
* src/qemu/qemu_domain.c (qemuDomainObjPrivateXMLFormat)
(qemuDomainObjPrivateXMLParse): Likewise.
* src/qemu/qemu_cgroup.c (qemuSetupChardevCgroup): Likewise.
* src/qemu/qemu_hotplug.c (qemuDomainAttachNetDevice): Likewise.
* src/qemu/qemu_driver.c (qemudFindCharDevicePTYsMonitor)
(qemudFindCharDevicePTYs, qemuPrepareChardevDevice)
(qemuPrepareMonitorChr, qemudShutdownVMDaemon)
(qemuDomainOpenConsole): Likewise.
* src/qemu/qemu_command.h (qemuBuildChrChardevStr)
(qemuBuildChrArgStr): Delete, now that they are static.
* src/libvirt_private.syms (domain_conf.h): New exports.
* cfg.mk (useless_free_options): Update list.
* tests/qemuxml2argvtest.c (testCompareXMLToArgvFiles): Update
tests.
2011-01-07 22:45:01 +00:00
|
|
|
* Copyright (C) 2006-2011 Red Hat, Inc.
|
2010-12-16 16:10:54 +00:00
|
|
|
* Copyright (C) 2006 Daniel P. Berrange
|
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
* License along with this library; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*
|
|
|
|
* Author: Daniel P. Berrange <berrange@redhat.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
#include <config.h>
|
|
|
|
|
|
|
|
#include "qemu_hotplug.h"
|
|
|
|
#include "qemu_capabilities.h"
|
|
|
|
#include "qemu_domain.h"
|
|
|
|
#include "qemu_command.h"
|
|
|
|
#include "qemu_bridge_filter.h"
|
|
|
|
#include "qemu_hostdev.h"
|
Move qemu_audit.h helpers into shared code
The LXC and UML drivers can both make use of auditing. Move
the qemu_audit.{c,h} files to src/conf/domain_audit.{c,h}
* src/conf/domain_audit.c: Rename from src/qemu/qemu_audit.c
* src/conf/domain_audit.h: Rename from src/qemu/qemu_audit.h
* src/Makefile.am: Remove qemu_audit.{c,h}, add domain_audit.{c,h}
* src/qemu/qemu_audit.h, src/qemu/qemu_cgroup.c,
src/qemu/qemu_command.c, src/qemu/qemu_driver.c,
src/qemu/qemu_hotplug.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c: Update for changed audit API names
2011-07-04 10:56:13 +00:00
|
|
|
#include "domain_audit.h"
|
2010-12-16 16:10:54 +00:00
|
|
|
#include "domain_nwfilter.h"
|
|
|
|
#include "logging.h"
|
|
|
|
#include "virterror_internal.h"
|
|
|
|
#include "memory.h"
|
|
|
|
#include "pci.h"
|
2011-07-19 18:32:58 +00:00
|
|
|
#include "virfile.h"
|
2010-12-16 16:10:54 +00:00
|
|
|
#include "qemu_cgroup.h"
|
2010-10-26 14:04:46 +00:00
|
|
|
#include "locking/domain_lock.h"
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
#define VIR_FROM_THIS VIR_FROM_QEMU
|
|
|
|
|
|
|
|
int qemuDomainChangeEjectableMedia(struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
virDomainDiskDefPtr disk,
|
|
|
|
bool force)
|
|
|
|
{
|
|
|
|
virDomainDiskDefPtr origdisk = NULL;
|
|
|
|
int i;
|
|
|
|
int ret;
|
|
|
|
char *driveAlias = NULL;
|
2011-05-04 12:09:09 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
for (i = 0 ; i < vm->def->ndisks ; i++) {
|
|
|
|
if (vm->def->disks[i]->bus == disk->bus &&
|
|
|
|
STREQ(vm->def->disks[i]->dst, disk->dst)) {
|
|
|
|
origdisk = vm->def->disks[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!origdisk) {
|
|
|
|
qemuReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("No device with bus '%s' and target '%s'"),
|
|
|
|
virDomainDiskBusTypeToString(disk->bus),
|
|
|
|
disk->dst);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!origdisk->info.alias) {
|
|
|
|
qemuReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("missing disk device alias name for %s"), origdisk->dst);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (origdisk->device != VIR_DOMAIN_DISK_DEVICE_FLOPPY &&
|
|
|
|
origdisk->device != VIR_DOMAIN_DISK_DEVICE_CDROM) {
|
|
|
|
qemuReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Removable media not supported for %s device"),
|
|
|
|
virDomainDiskDeviceTypeToString(disk->device));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2010-10-26 14:04:46 +00:00
|
|
|
if (virDomainLockDiskAttach(driver->lockManager, vm, disk) < 0)
|
|
|
|
return -1;
|
|
|
|
|
Refactor the security drivers to simplify usage
The current security driver usage requires horrible code like
if (driver->securityDriver &&
driver->securityDriver->domainSetSecurityHostdevLabel &&
driver->securityDriver->domainSetSecurityHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
This pair of checks for NULL clutters up the code, making the driver
calls 2 lines longer than they really need to be. The goal of the
patchset is to change the calling convention to simply
if (virSecurityManagerSetHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
The first check for 'driver->securityDriver' being NULL is removed
by introducing a 'no op' security driver that will always be present
if no real driver is enabled. This guarentees driver->securityDriver
!= NULL.
The second check for 'driver->securityDriver->domainSetSecurityHostdevLabel'
being non-NULL is hidden in a new abstraction called virSecurityManager.
This separates the driver callbacks, from main internal API. The addition
of a virSecurityManager object, that is separate from the virSecurityDriver
struct also allows for security drivers to carry state / configuration
information directly. Thus the DAC/Stack drivers from src/qemu which
used to pull config from 'struct qemud_driver' can now be moved into
the 'src/security' directory and store their config directly.
* src/qemu/qemu_conf.h, src/qemu/qemu_driver.c: Update to
use new virSecurityManager APIs
* src/qemu/qemu_security_dac.c, src/qemu/qemu_security_dac.h
src/qemu/qemu_security_stacked.c, src/qemu/qemu_security_stacked.h:
Move into src/security directory
* src/security/security_stack.c, src/security/security_stack.h,
src/security/security_dac.c, src/security/security_dac.h: Generic
versions of previous QEMU specific drivers
* src/security/security_apparmor.c, src/security/security_apparmor.h,
src/security/security_driver.c, src/security/security_driver.h,
src/security/security_selinux.c, src/security/security_selinux.h:
Update to take virSecurityManagerPtr object as the first param
in all callbacks
* src/security/security_nop.c, src/security/security_nop.h: Stub
implementation of all security driver APIs.
* src/security/security_manager.h, src/security/security_manager.c:
New internal API for invoking security drivers
* src/libvirt.c: Add missing debug for security APIs
2010-11-17 20:26:30 +00:00
|
|
|
if (virSecurityManagerSetImageLabel(driver->securityManager,
|
2010-10-26 14:04:46 +00:00
|
|
|
vm, disk) < 0) {
|
|
|
|
if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0)
|
|
|
|
VIR_WARN("Unable to release lock on %s", disk->src);
|
2010-12-16 16:10:54 +00:00
|
|
|
return -1;
|
2010-10-26 14:04:46 +00:00
|
|
|
}
|
2010-12-16 16:10:54 +00:00
|
|
|
|
2011-05-04 12:09:09 +00:00
|
|
|
if (!(driveAlias = qemuDeviceDriveHostAlias(origdisk, priv->qemuCaps)))
|
2010-12-16 16:10:54 +00:00
|
|
|
goto error;
|
|
|
|
|
2011-06-30 09:23:50 +00:00
|
|
|
ignore_value(qemuDomainObjEnterMonitorWithDriver(driver, vm));
|
2010-12-16 16:10:54 +00:00
|
|
|
if (disk->src) {
|
|
|
|
const char *format = NULL;
|
|
|
|
if (disk->type != VIR_DOMAIN_DISK_TYPE_DIR) {
|
|
|
|
if (disk->driverType)
|
|
|
|
format = disk->driverType;
|
|
|
|
else if (origdisk->driverType)
|
|
|
|
format = origdisk->driverType;
|
|
|
|
}
|
|
|
|
ret = qemuMonitorChangeMedia(priv->mon,
|
|
|
|
driveAlias,
|
|
|
|
disk->src, format);
|
|
|
|
} else {
|
|
|
|
ret = qemuMonitorEjectMedia(priv->mon, driveAlias, force);
|
|
|
|
}
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
|
Move qemu_audit.h helpers into shared code
The LXC and UML drivers can both make use of auditing. Move
the qemu_audit.{c,h} files to src/conf/domain_audit.{c,h}
* src/conf/domain_audit.c: Rename from src/qemu/qemu_audit.c
* src/conf/domain_audit.h: Rename from src/qemu/qemu_audit.h
* src/Makefile.am: Remove qemu_audit.{c,h}, add domain_audit.{c,h}
* src/qemu/qemu_audit.h, src/qemu/qemu_cgroup.c,
src/qemu/qemu_command.c, src/qemu/qemu_driver.c,
src/qemu/qemu_hotplug.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c: Update for changed audit API names
2011-07-04 10:56:13 +00:00
|
|
|
virDomainAuditDisk(vm, origdisk, disk, "update", ret >= 0);
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
|
Refactor the security drivers to simplify usage
The current security driver usage requires horrible code like
if (driver->securityDriver &&
driver->securityDriver->domainSetSecurityHostdevLabel &&
driver->securityDriver->domainSetSecurityHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
This pair of checks for NULL clutters up the code, making the driver
calls 2 lines longer than they really need to be. The goal of the
patchset is to change the calling convention to simply
if (virSecurityManagerSetHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
The first check for 'driver->securityDriver' being NULL is removed
by introducing a 'no op' security driver that will always be present
if no real driver is enabled. This guarentees driver->securityDriver
!= NULL.
The second check for 'driver->securityDriver->domainSetSecurityHostdevLabel'
being non-NULL is hidden in a new abstraction called virSecurityManager.
This separates the driver callbacks, from main internal API. The addition
of a virSecurityManager object, that is separate from the virSecurityDriver
struct also allows for security drivers to carry state / configuration
information directly. Thus the DAC/Stack drivers from src/qemu which
used to pull config from 'struct qemud_driver' can now be moved into
the 'src/security' directory and store their config directly.
* src/qemu/qemu_conf.h, src/qemu/qemu_driver.c: Update to
use new virSecurityManager APIs
* src/qemu/qemu_security_dac.c, src/qemu/qemu_security_dac.h
src/qemu/qemu_security_stacked.c, src/qemu/qemu_security_stacked.h:
Move into src/security directory
* src/security/security_stack.c, src/security/security_stack.h,
src/security/security_dac.c, src/security/security_dac.h: Generic
versions of previous QEMU specific drivers
* src/security/security_apparmor.c, src/security/security_apparmor.h,
src/security/security_driver.c, src/security/security_driver.h,
src/security/security_selinux.c, src/security/security_selinux.h:
Update to take virSecurityManagerPtr object as the first param
in all callbacks
* src/security/security_nop.c, src/security/security_nop.h: Stub
implementation of all security driver APIs.
* src/security/security_manager.h, src/security/security_manager.c:
New internal API for invoking security drivers
* src/libvirt.c: Add missing debug for security APIs
2010-11-17 20:26:30 +00:00
|
|
|
if (virSecurityManagerRestoreImageLabel(driver->securityManager,
|
|
|
|
vm, origdisk) < 0)
|
2010-12-16 16:10:54 +00:00
|
|
|
VIR_WARN("Unable to restore security label on ejected image %s", origdisk->src);
|
|
|
|
|
2010-10-26 14:04:46 +00:00
|
|
|
if (virDomainLockDiskDetach(driver->lockManager, vm, origdisk) < 0)
|
|
|
|
VIR_WARN("Unable to release lock on disk %s", origdisk->src);
|
|
|
|
|
2010-12-16 16:10:54 +00:00
|
|
|
VIR_FREE(origdisk->src);
|
|
|
|
origdisk->src = disk->src;
|
|
|
|
disk->src = NULL;
|
|
|
|
origdisk->type = disk->type;
|
|
|
|
|
|
|
|
VIR_FREE(driveAlias);
|
|
|
|
|
|
|
|
virDomainDiskDefFree(disk);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
error:
|
|
|
|
VIR_FREE(driveAlias);
|
2010-10-26 14:04:46 +00:00
|
|
|
|
Refactor the security drivers to simplify usage
The current security driver usage requires horrible code like
if (driver->securityDriver &&
driver->securityDriver->domainSetSecurityHostdevLabel &&
driver->securityDriver->domainSetSecurityHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
This pair of checks for NULL clutters up the code, making the driver
calls 2 lines longer than they really need to be. The goal of the
patchset is to change the calling convention to simply
if (virSecurityManagerSetHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
The first check for 'driver->securityDriver' being NULL is removed
by introducing a 'no op' security driver that will always be present
if no real driver is enabled. This guarentees driver->securityDriver
!= NULL.
The second check for 'driver->securityDriver->domainSetSecurityHostdevLabel'
being non-NULL is hidden in a new abstraction called virSecurityManager.
This separates the driver callbacks, from main internal API. The addition
of a virSecurityManager object, that is separate from the virSecurityDriver
struct also allows for security drivers to carry state / configuration
information directly. Thus the DAC/Stack drivers from src/qemu which
used to pull config from 'struct qemud_driver' can now be moved into
the 'src/security' directory and store their config directly.
* src/qemu/qemu_conf.h, src/qemu/qemu_driver.c: Update to
use new virSecurityManager APIs
* src/qemu/qemu_security_dac.c, src/qemu/qemu_security_dac.h
src/qemu/qemu_security_stacked.c, src/qemu/qemu_security_stacked.h:
Move into src/security directory
* src/security/security_stack.c, src/security/security_stack.h,
src/security/security_dac.c, src/security/security_dac.h: Generic
versions of previous QEMU specific drivers
* src/security/security_apparmor.c, src/security/security_apparmor.h,
src/security/security_driver.c, src/security/security_driver.h,
src/security/security_selinux.c, src/security/security_selinux.h:
Update to take virSecurityManagerPtr object as the first param
in all callbacks
* src/security/security_nop.c, src/security/security_nop.h: Stub
implementation of all security driver APIs.
* src/security/security_manager.h, src/security/security_manager.c:
New internal API for invoking security drivers
* src/libvirt.c: Add missing debug for security APIs
2010-11-17 20:26:30 +00:00
|
|
|
if (virSecurityManagerRestoreImageLabel(driver->securityManager,
|
|
|
|
vm, disk) < 0)
|
2010-12-16 16:10:54 +00:00
|
|
|
VIR_WARN("Unable to restore security label on new media %s", disk->src);
|
2010-10-26 14:04:46 +00:00
|
|
|
|
|
|
|
if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0)
|
|
|
|
VIR_WARN("Unable to release lock on %s", disk->src);
|
|
|
|
|
2010-12-16 16:10:54 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int qemuDomainAttachPciDiskDevice(struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
2011-05-04 12:09:09 +00:00
|
|
|
virDomainDiskDefPtr disk)
|
2010-12-16 16:10:54 +00:00
|
|
|
{
|
|
|
|
int i, ret;
|
|
|
|
const char* type = virDomainDiskBusTypeToString(disk->bus);
|
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
|
|
|
char *devstr = NULL;
|
|
|
|
char *drivestr = NULL;
|
2011-04-26 03:40:01 +00:00
|
|
|
bool releaseaddr = false;
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
for (i = 0 ; i < vm->def->ndisks ; i++) {
|
|
|
|
if (STREQ(vm->def->disks[i]->dst, disk->dst)) {
|
|
|
|
qemuReportError(VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("target %s already exists"), disk->dst);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-10-26 14:04:46 +00:00
|
|
|
if (virDomainLockDiskAttach(driver->lockManager, vm, disk) < 0)
|
|
|
|
return -1;
|
|
|
|
|
Refactor the security drivers to simplify usage
The current security driver usage requires horrible code like
if (driver->securityDriver &&
driver->securityDriver->domainSetSecurityHostdevLabel &&
driver->securityDriver->domainSetSecurityHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
This pair of checks for NULL clutters up the code, making the driver
calls 2 lines longer than they really need to be. The goal of the
patchset is to change the calling convention to simply
if (virSecurityManagerSetHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
The first check for 'driver->securityDriver' being NULL is removed
by introducing a 'no op' security driver that will always be present
if no real driver is enabled. This guarentees driver->securityDriver
!= NULL.
The second check for 'driver->securityDriver->domainSetSecurityHostdevLabel'
being non-NULL is hidden in a new abstraction called virSecurityManager.
This separates the driver callbacks, from main internal API. The addition
of a virSecurityManager object, that is separate from the virSecurityDriver
struct also allows for security drivers to carry state / configuration
information directly. Thus the DAC/Stack drivers from src/qemu which
used to pull config from 'struct qemud_driver' can now be moved into
the 'src/security' directory and store their config directly.
* src/qemu/qemu_conf.h, src/qemu/qemu_driver.c: Update to
use new virSecurityManager APIs
* src/qemu/qemu_security_dac.c, src/qemu/qemu_security_dac.h
src/qemu/qemu_security_stacked.c, src/qemu/qemu_security_stacked.h:
Move into src/security directory
* src/security/security_stack.c, src/security/security_stack.h,
src/security/security_dac.c, src/security/security_dac.h: Generic
versions of previous QEMU specific drivers
* src/security/security_apparmor.c, src/security/security_apparmor.h,
src/security/security_driver.c, src/security/security_driver.h,
src/security/security_selinux.c, src/security/security_selinux.h:
Update to take virSecurityManagerPtr object as the first param
in all callbacks
* src/security/security_nop.c, src/security/security_nop.h: Stub
implementation of all security driver APIs.
* src/security/security_manager.h, src/security/security_manager.c:
New internal API for invoking security drivers
* src/libvirt.c: Add missing debug for security APIs
2010-11-17 20:26:30 +00:00
|
|
|
if (virSecurityManagerSetImageLabel(driver->securityManager,
|
2010-10-26 14:04:46 +00:00
|
|
|
vm, disk) < 0) {
|
|
|
|
if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0)
|
|
|
|
VIR_WARN("Unable to release lock on %s", disk->src);
|
2010-12-16 16:10:54 +00:00
|
|
|
return -1;
|
2010-10-26 14:04:46 +00:00
|
|
|
}
|
2010-12-16 16:10:54 +00:00
|
|
|
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
2010-12-16 16:10:54 +00:00
|
|
|
if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &disk->info) < 0)
|
|
|
|
goto error;
|
2011-04-26 03:40:01 +00:00
|
|
|
releaseaddr = true;
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuAssignDeviceDiskAlias(disk, priv->qemuCaps) < 0)
|
2010-12-16 16:10:54 +00:00
|
|
|
goto error;
|
|
|
|
|
2011-05-26 14:15:01 +00:00
|
|
|
if (!(drivestr = qemuBuildDriveStr(disk, false, priv->qemuCaps)))
|
2010-12-16 16:10:54 +00:00
|
|
|
goto error;
|
|
|
|
|
2011-05-26 14:15:01 +00:00
|
|
|
if (!(devstr = qemuBuildDriveDevStr(disk, 0, priv->qemuCaps)))
|
2010-12-16 16:10:54 +00:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks+1) < 0) {
|
|
|
|
virReportOOMError();
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2011-06-30 09:23:50 +00:00
|
|
|
ignore_value(qemuDomainObjEnterMonitorWithDriver(driver, vm));
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
2010-12-16 16:10:54 +00:00
|
|
|
ret = qemuMonitorAddDrive(priv->mon, drivestr);
|
|
|
|
if (ret == 0) {
|
|
|
|
ret = qemuMonitorAddDevice(priv->mon, devstr);
|
|
|
|
if (ret < 0) {
|
|
|
|
VIR_WARN("qemuMonitorAddDevice failed on %s (%s)",
|
|
|
|
drivestr, devstr);
|
|
|
|
/* XXX should call 'drive_del' on error but this does not
|
|
|
|
exist yet */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
virDomainDevicePCIAddress guestAddr;
|
|
|
|
ret = qemuMonitorAddPCIDisk(priv->mon,
|
|
|
|
disk->src,
|
|
|
|
type,
|
|
|
|
&guestAddr);
|
|
|
|
if (ret == 0) {
|
|
|
|
disk->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
|
|
|
|
memcpy(&disk->info.addr.pci, &guestAddr, sizeof(guestAddr));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
|
Move qemu_audit.h helpers into shared code
The LXC and UML drivers can both make use of auditing. Move
the qemu_audit.{c,h} files to src/conf/domain_audit.{c,h}
* src/conf/domain_audit.c: Rename from src/qemu/qemu_audit.c
* src/conf/domain_audit.h: Rename from src/qemu/qemu_audit.h
* src/Makefile.am: Remove qemu_audit.{c,h}, add domain_audit.{c,h}
* src/qemu/qemu_audit.h, src/qemu/qemu_cgroup.c,
src/qemu/qemu_command.c, src/qemu/qemu_driver.c,
src/qemu/qemu_hotplug.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c: Update for changed audit API names
2011-07-04 10:56:13 +00:00
|
|
|
virDomainAuditDisk(vm, NULL, disk, "attach", ret >= 0);
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
virDomainDiskInsertPreAlloced(vm->def, disk);
|
|
|
|
|
|
|
|
VIR_FREE(devstr);
|
|
|
|
VIR_FREE(drivestr);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
|
|
|
VIR_FREE(devstr);
|
|
|
|
VIR_FREE(drivestr);
|
|
|
|
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
|
2010-12-16 16:10:54 +00:00
|
|
|
(disk->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
|
2011-04-26 03:40:01 +00:00
|
|
|
releaseaddr &&
|
2011-05-23 07:43:35 +00:00
|
|
|
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
|
|
|
|
disk->info.addr.pci.slot) < 0)
|
2010-12-16 16:10:54 +00:00
|
|
|
VIR_WARN("Unable to release PCI address on %s", disk->src);
|
|
|
|
|
Refactor the security drivers to simplify usage
The current security driver usage requires horrible code like
if (driver->securityDriver &&
driver->securityDriver->domainSetSecurityHostdevLabel &&
driver->securityDriver->domainSetSecurityHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
This pair of checks for NULL clutters up the code, making the driver
calls 2 lines longer than they really need to be. The goal of the
patchset is to change the calling convention to simply
if (virSecurityManagerSetHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
The first check for 'driver->securityDriver' being NULL is removed
by introducing a 'no op' security driver that will always be present
if no real driver is enabled. This guarentees driver->securityDriver
!= NULL.
The second check for 'driver->securityDriver->domainSetSecurityHostdevLabel'
being non-NULL is hidden in a new abstraction called virSecurityManager.
This separates the driver callbacks, from main internal API. The addition
of a virSecurityManager object, that is separate from the virSecurityDriver
struct also allows for security drivers to carry state / configuration
information directly. Thus the DAC/Stack drivers from src/qemu which
used to pull config from 'struct qemud_driver' can now be moved into
the 'src/security' directory and store their config directly.
* src/qemu/qemu_conf.h, src/qemu/qemu_driver.c: Update to
use new virSecurityManager APIs
* src/qemu/qemu_security_dac.c, src/qemu/qemu_security_dac.h
src/qemu/qemu_security_stacked.c, src/qemu/qemu_security_stacked.h:
Move into src/security directory
* src/security/security_stack.c, src/security/security_stack.h,
src/security/security_dac.c, src/security/security_dac.h: Generic
versions of previous QEMU specific drivers
* src/security/security_apparmor.c, src/security/security_apparmor.h,
src/security/security_driver.c, src/security/security_driver.h,
src/security/security_selinux.c, src/security/security_selinux.h:
Update to take virSecurityManagerPtr object as the first param
in all callbacks
* src/security/security_nop.c, src/security/security_nop.h: Stub
implementation of all security driver APIs.
* src/security/security_manager.h, src/security/security_manager.c:
New internal API for invoking security drivers
* src/libvirt.c: Add missing debug for security APIs
2010-11-17 20:26:30 +00:00
|
|
|
if (virSecurityManagerRestoreImageLabel(driver->securityManager,
|
|
|
|
vm, disk) < 0)
|
2010-12-16 16:10:54 +00:00
|
|
|
VIR_WARN("Unable to restore security label on %s", disk->src);
|
|
|
|
|
2010-10-26 14:04:46 +00:00
|
|
|
if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0)
|
|
|
|
VIR_WARN("Unable to release lock on %s", disk->src);
|
|
|
|
|
2010-12-16 16:10:54 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int qemuDomainAttachPciControllerDevice(struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
2011-05-04 12:09:09 +00:00
|
|
|
virDomainControllerDefPtr controller)
|
2010-12-16 16:10:54 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int ret = -1;
|
|
|
|
const char* type = virDomainControllerTypeToString(controller->type);
|
|
|
|
char *devstr = NULL;
|
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2011-04-26 03:40:01 +00:00
|
|
|
bool releaseaddr = false;
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
for (i = 0 ; i < vm->def->ncontrollers ; i++) {
|
|
|
|
if ((vm->def->controllers[i]->type == controller->type) &&
|
|
|
|
(vm->def->controllers[i]->idx == controller->idx)) {
|
|
|
|
qemuReportError(VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("target %s:%d already exists"),
|
|
|
|
type, controller->idx);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
2010-12-16 16:10:54 +00:00
|
|
|
if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &controller->info) < 0)
|
|
|
|
goto cleanup;
|
2011-04-26 03:40:01 +00:00
|
|
|
releaseaddr = true;
|
2010-12-16 16:10:54 +00:00
|
|
|
if (qemuAssignDeviceControllerAlias(controller) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
2011-05-04 12:09:09 +00:00
|
|
|
if (!(devstr = qemuBuildControllerDevStr(controller, priv->qemuCaps))) {
|
2010-12-16 16:10:54 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (VIR_REALLOC_N(vm->def->controllers, vm->def->ncontrollers+1) < 0) {
|
|
|
|
virReportOOMError();
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2011-06-30 09:23:50 +00:00
|
|
|
ignore_value(qemuDomainObjEnterMonitorWithDriver(driver, vm));
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
2010-12-16 16:10:54 +00:00
|
|
|
ret = qemuMonitorAddDevice(priv->mon, devstr);
|
|
|
|
} else {
|
|
|
|
ret = qemuMonitorAttachPCIDiskController(priv->mon,
|
|
|
|
type,
|
|
|
|
&controller->info.addr.pci);
|
|
|
|
}
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
|
|
|
|
if (ret == 0) {
|
|
|
|
controller->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
|
|
|
|
virDomainControllerInsertPreAlloced(vm->def, controller);
|
|
|
|
}
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
if ((ret != 0) &&
|
2011-05-04 12:09:09 +00:00
|
|
|
qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
|
2010-12-16 16:10:54 +00:00
|
|
|
(controller->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
|
2011-04-26 03:40:01 +00:00
|
|
|
releaseaddr &&
|
2011-05-23 07:43:35 +00:00
|
|
|
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
|
|
|
|
controller->info.addr.pci.slot) < 0)
|
2011-05-09 09:24:09 +00:00
|
|
|
VIR_WARN("Unable to release PCI address on controller");
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
VIR_FREE(devstr);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static virDomainControllerDefPtr
|
|
|
|
qemuDomainFindOrCreateSCSIDiskController(struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
2011-05-04 12:09:09 +00:00
|
|
|
int controller)
|
2010-12-16 16:10:54 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
virDomainControllerDefPtr cont;
|
2011-05-04 12:09:09 +00:00
|
|
|
|
2010-12-16 16:10:54 +00:00
|
|
|
for (i = 0 ; i < vm->def->ncontrollers ; i++) {
|
|
|
|
cont = vm->def->controllers[i];
|
|
|
|
|
|
|
|
if (cont->type != VIR_DOMAIN_CONTROLLER_TYPE_SCSI)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (cont->idx == controller)
|
|
|
|
return cont;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* No SCSI controller present, for backward compatibility we
|
|
|
|
* now hotplug a controller */
|
|
|
|
if (VIR_ALLOC(cont) < 0) {
|
|
|
|
virReportOOMError();
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
cont->type = VIR_DOMAIN_CONTROLLER_TYPE_SCSI;
|
2011-01-31 07:55:40 +00:00
|
|
|
cont->idx = controller;
|
2010-12-16 16:10:54 +00:00
|
|
|
cont->model = -1;
|
|
|
|
|
2011-05-09 09:24:09 +00:00
|
|
|
VIR_INFO("No SCSI controller present, hotplugging one");
|
2010-12-16 16:10:54 +00:00
|
|
|
if (qemuDomainAttachPciControllerDevice(driver,
|
2011-05-04 12:09:09 +00:00
|
|
|
vm, cont) < 0) {
|
2010-12-16 16:10:54 +00:00
|
|
|
VIR_FREE(cont);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!virDomainObjIsActive(vm)) {
|
|
|
|
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
|
|
|
|
_("guest unexpectedly quit"));
|
|
|
|
/* cont doesn't need freeing here, since the reference
|
|
|
|
* now held in def->controllers */
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return cont;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int qemuDomainAttachSCSIDisk(struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
2011-05-04 12:09:09 +00:00
|
|
|
virDomainDiskDefPtr disk)
|
2010-12-16 16:10:54 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
|
|
|
virDomainControllerDefPtr cont = NULL;
|
|
|
|
char *drivestr = NULL;
|
|
|
|
char *devstr = NULL;
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
for (i = 0 ; i < vm->def->ndisks ; i++) {
|
|
|
|
if (STREQ(vm->def->disks[i]->dst, disk->dst)) {
|
|
|
|
qemuReportError(VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("target %s already exists"), disk->dst);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-10-26 14:04:46 +00:00
|
|
|
if (virDomainLockDiskAttach(driver->lockManager, vm, disk) < 0)
|
|
|
|
return -1;
|
2010-12-16 16:10:54 +00:00
|
|
|
|
Refactor the security drivers to simplify usage
The current security driver usage requires horrible code like
if (driver->securityDriver &&
driver->securityDriver->domainSetSecurityHostdevLabel &&
driver->securityDriver->domainSetSecurityHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
This pair of checks for NULL clutters up the code, making the driver
calls 2 lines longer than they really need to be. The goal of the
patchset is to change the calling convention to simply
if (virSecurityManagerSetHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
The first check for 'driver->securityDriver' being NULL is removed
by introducing a 'no op' security driver that will always be present
if no real driver is enabled. This guarentees driver->securityDriver
!= NULL.
The second check for 'driver->securityDriver->domainSetSecurityHostdevLabel'
being non-NULL is hidden in a new abstraction called virSecurityManager.
This separates the driver callbacks, from main internal API. The addition
of a virSecurityManager object, that is separate from the virSecurityDriver
struct also allows for security drivers to carry state / configuration
information directly. Thus the DAC/Stack drivers from src/qemu which
used to pull config from 'struct qemud_driver' can now be moved into
the 'src/security' directory and store their config directly.
* src/qemu/qemu_conf.h, src/qemu/qemu_driver.c: Update to
use new virSecurityManager APIs
* src/qemu/qemu_security_dac.c, src/qemu/qemu_security_dac.h
src/qemu/qemu_security_stacked.c, src/qemu/qemu_security_stacked.h:
Move into src/security directory
* src/security/security_stack.c, src/security/security_stack.h,
src/security/security_dac.c, src/security/security_dac.h: Generic
versions of previous QEMU specific drivers
* src/security/security_apparmor.c, src/security/security_apparmor.h,
src/security/security_driver.c, src/security/security_driver.h,
src/security/security_selinux.c, src/security/security_selinux.h:
Update to take virSecurityManagerPtr object as the first param
in all callbacks
* src/security/security_nop.c, src/security/security_nop.h: Stub
implementation of all security driver APIs.
* src/security/security_manager.h, src/security/security_manager.c:
New internal API for invoking security drivers
* src/libvirt.c: Add missing debug for security APIs
2010-11-17 20:26:30 +00:00
|
|
|
if (virSecurityManagerSetImageLabel(driver->securityManager,
|
2010-10-26 14:04:46 +00:00
|
|
|
vm, disk) < 0) {
|
|
|
|
if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0)
|
|
|
|
VIR_WARN("Unable to release lock on %s", disk->src);
|
2010-12-16 16:10:54 +00:00
|
|
|
return -1;
|
2010-10-26 14:04:46 +00:00
|
|
|
}
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
/* We should have an address already, so make sure */
|
|
|
|
if (disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE) {
|
|
|
|
qemuReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("unexpected disk address type %s"),
|
|
|
|
virDomainDeviceAddressTypeToString(disk->info.type));
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
|
|
|
if (qemuAssignDeviceDiskAlias(disk, priv->qemuCaps) < 0)
|
2010-12-16 16:10:54 +00:00
|
|
|
goto error;
|
2011-05-26 14:15:01 +00:00
|
|
|
if (!(devstr = qemuBuildDriveDevStr(disk, 0, priv->qemuCaps)))
|
2010-12-16 16:10:54 +00:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2011-05-26 14:15:01 +00:00
|
|
|
if (!(drivestr = qemuBuildDriveStr(disk, false, priv->qemuCaps)))
|
2010-12-16 16:10:54 +00:00
|
|
|
goto error;
|
|
|
|
|
|
|
|
for (i = 0 ; i <= disk->info.addr.drive.controller ; i++) {
|
2011-05-04 12:09:09 +00:00
|
|
|
cont = qemuDomainFindOrCreateSCSIDiskController(driver, vm, i);
|
2010-12-16 16:10:54 +00:00
|
|
|
if (!cont)
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Tell clang that "cont" is non-NULL.
|
|
|
|
This is because disk->info.addr.driver.controller is unsigned,
|
|
|
|
and hence the above loop must iterate at least once. */
|
|
|
|
sa_assert (cont);
|
|
|
|
|
|
|
|
if (cont->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
|
|
|
|
qemuReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("SCSI controller %d was missing its PCI address"), cont->idx);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks+1) < 0) {
|
|
|
|
virReportOOMError();
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2011-06-30 09:23:50 +00:00
|
|
|
ignore_value(qemuDomainObjEnterMonitorWithDriver(driver, vm));
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
2010-12-16 16:10:54 +00:00
|
|
|
ret = qemuMonitorAddDrive(priv->mon, drivestr);
|
|
|
|
if (ret == 0) {
|
|
|
|
ret = qemuMonitorAddDevice(priv->mon, devstr);
|
|
|
|
if (ret < 0) {
|
|
|
|
VIR_WARN("qemuMonitorAddDevice failed on %s (%s)",
|
|
|
|
drivestr, devstr);
|
|
|
|
/* XXX should call 'drive_del' on error but this does not
|
|
|
|
exist yet */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
virDomainDeviceDriveAddress driveAddr;
|
|
|
|
ret = qemuMonitorAttachDrive(priv->mon,
|
|
|
|
drivestr,
|
|
|
|
&cont->info.addr.pci,
|
|
|
|
&driveAddr);
|
|
|
|
if (ret == 0) {
|
|
|
|
/* XXX we should probably validate that the addr matches
|
|
|
|
* our existing defined addr instead of overwriting */
|
|
|
|
disk->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE;
|
|
|
|
memcpy(&disk->info.addr.drive, &driveAddr, sizeof(driveAddr));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
|
Move qemu_audit.h helpers into shared code
The LXC and UML drivers can both make use of auditing. Move
the qemu_audit.{c,h} files to src/conf/domain_audit.{c,h}
* src/conf/domain_audit.c: Rename from src/qemu/qemu_audit.c
* src/conf/domain_audit.h: Rename from src/qemu/qemu_audit.h
* src/Makefile.am: Remove qemu_audit.{c,h}, add domain_audit.{c,h}
* src/qemu/qemu_audit.h, src/qemu/qemu_cgroup.c,
src/qemu/qemu_command.c, src/qemu/qemu_driver.c,
src/qemu/qemu_hotplug.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c: Update for changed audit API names
2011-07-04 10:56:13 +00:00
|
|
|
virDomainAuditDisk(vm, NULL, disk, "attach", ret >= 0);
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
virDomainDiskInsertPreAlloced(vm->def, disk);
|
|
|
|
|
|
|
|
VIR_FREE(devstr);
|
|
|
|
VIR_FREE(drivestr);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
|
|
|
VIR_FREE(devstr);
|
|
|
|
VIR_FREE(drivestr);
|
|
|
|
|
Refactor the security drivers to simplify usage
The current security driver usage requires horrible code like
if (driver->securityDriver &&
driver->securityDriver->domainSetSecurityHostdevLabel &&
driver->securityDriver->domainSetSecurityHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
This pair of checks for NULL clutters up the code, making the driver
calls 2 lines longer than they really need to be. The goal of the
patchset is to change the calling convention to simply
if (virSecurityManagerSetHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
The first check for 'driver->securityDriver' being NULL is removed
by introducing a 'no op' security driver that will always be present
if no real driver is enabled. This guarentees driver->securityDriver
!= NULL.
The second check for 'driver->securityDriver->domainSetSecurityHostdevLabel'
being non-NULL is hidden in a new abstraction called virSecurityManager.
This separates the driver callbacks, from main internal API. The addition
of a virSecurityManager object, that is separate from the virSecurityDriver
struct also allows for security drivers to carry state / configuration
information directly. Thus the DAC/Stack drivers from src/qemu which
used to pull config from 'struct qemud_driver' can now be moved into
the 'src/security' directory and store their config directly.
* src/qemu/qemu_conf.h, src/qemu/qemu_driver.c: Update to
use new virSecurityManager APIs
* src/qemu/qemu_security_dac.c, src/qemu/qemu_security_dac.h
src/qemu/qemu_security_stacked.c, src/qemu/qemu_security_stacked.h:
Move into src/security directory
* src/security/security_stack.c, src/security/security_stack.h,
src/security/security_dac.c, src/security/security_dac.h: Generic
versions of previous QEMU specific drivers
* src/security/security_apparmor.c, src/security/security_apparmor.h,
src/security/security_driver.c, src/security/security_driver.h,
src/security/security_selinux.c, src/security/security_selinux.h:
Update to take virSecurityManagerPtr object as the first param
in all callbacks
* src/security/security_nop.c, src/security/security_nop.h: Stub
implementation of all security driver APIs.
* src/security/security_manager.h, src/security/security_manager.c:
New internal API for invoking security drivers
* src/libvirt.c: Add missing debug for security APIs
2010-11-17 20:26:30 +00:00
|
|
|
if (virSecurityManagerRestoreImageLabel(driver->securityManager,
|
|
|
|
vm, disk) < 0)
|
2010-12-16 16:10:54 +00:00
|
|
|
VIR_WARN("Unable to restore security label on %s", disk->src);
|
|
|
|
|
2010-10-26 14:04:46 +00:00
|
|
|
if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0)
|
|
|
|
VIR_WARN("Unable to release lock on %s", disk->src);
|
|
|
|
|
2010-12-16 16:10:54 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int qemuDomainAttachUsbMassstorageDevice(struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
2011-05-04 12:09:09 +00:00
|
|
|
virDomainDiskDefPtr disk)
|
2010-12-16 16:10:54 +00:00
|
|
|
{
|
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
|
|
|
int i, ret;
|
|
|
|
char *drivestr = NULL;
|
|
|
|
char *devstr = NULL;
|
|
|
|
|
|
|
|
for (i = 0 ; i < vm->def->ndisks ; i++) {
|
|
|
|
if (STREQ(vm->def->disks[i]->dst, disk->dst)) {
|
|
|
|
qemuReportError(VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("target %s already exists"), disk->dst);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-10-26 14:04:46 +00:00
|
|
|
if (virDomainLockDiskAttach(driver->lockManager, vm, disk) < 0)
|
|
|
|
return -1;
|
|
|
|
|
Refactor the security drivers to simplify usage
The current security driver usage requires horrible code like
if (driver->securityDriver &&
driver->securityDriver->domainSetSecurityHostdevLabel &&
driver->securityDriver->domainSetSecurityHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
This pair of checks for NULL clutters up the code, making the driver
calls 2 lines longer than they really need to be. The goal of the
patchset is to change the calling convention to simply
if (virSecurityManagerSetHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
The first check for 'driver->securityDriver' being NULL is removed
by introducing a 'no op' security driver that will always be present
if no real driver is enabled. This guarentees driver->securityDriver
!= NULL.
The second check for 'driver->securityDriver->domainSetSecurityHostdevLabel'
being non-NULL is hidden in a new abstraction called virSecurityManager.
This separates the driver callbacks, from main internal API. The addition
of a virSecurityManager object, that is separate from the virSecurityDriver
struct also allows for security drivers to carry state / configuration
information directly. Thus the DAC/Stack drivers from src/qemu which
used to pull config from 'struct qemud_driver' can now be moved into
the 'src/security' directory and store their config directly.
* src/qemu/qemu_conf.h, src/qemu/qemu_driver.c: Update to
use new virSecurityManager APIs
* src/qemu/qemu_security_dac.c, src/qemu/qemu_security_dac.h
src/qemu/qemu_security_stacked.c, src/qemu/qemu_security_stacked.h:
Move into src/security directory
* src/security/security_stack.c, src/security/security_stack.h,
src/security/security_dac.c, src/security/security_dac.h: Generic
versions of previous QEMU specific drivers
* src/security/security_apparmor.c, src/security/security_apparmor.h,
src/security/security_driver.c, src/security/security_driver.h,
src/security/security_selinux.c, src/security/security_selinux.h:
Update to take virSecurityManagerPtr object as the first param
in all callbacks
* src/security/security_nop.c, src/security/security_nop.h: Stub
implementation of all security driver APIs.
* src/security/security_manager.h, src/security/security_manager.c:
New internal API for invoking security drivers
* src/libvirt.c: Add missing debug for security APIs
2010-11-17 20:26:30 +00:00
|
|
|
if (virSecurityManagerSetImageLabel(driver->securityManager,
|
2010-10-26 14:04:46 +00:00
|
|
|
vm, disk) < 0) {
|
|
|
|
if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0)
|
|
|
|
VIR_WARN("Unable to release lock on %s", disk->src);
|
2010-12-16 16:10:54 +00:00
|
|
|
return -1;
|
2010-10-26 14:04:46 +00:00
|
|
|
}
|
2010-12-16 16:10:54 +00:00
|
|
|
|
2010-10-26 14:04:46 +00:00
|
|
|
/* XXX not correct once we allow attaching a USB CDROM */
|
2010-12-16 16:10:54 +00:00
|
|
|
if (!disk->src) {
|
|
|
|
qemuReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("disk source path is missing"));
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
|
|
|
if (qemuAssignDeviceDiskAlias(disk, priv->qemuCaps) < 0)
|
2010-12-16 16:10:54 +00:00
|
|
|
goto error;
|
2011-05-26 14:15:01 +00:00
|
|
|
if (!(drivestr = qemuBuildDriveStr(disk, false, priv->qemuCaps)))
|
2010-12-16 16:10:54 +00:00
|
|
|
goto error;
|
2011-05-26 14:15:01 +00:00
|
|
|
if (!(devstr = qemuBuildDriveDevStr(disk, 0, priv->qemuCaps)))
|
2010-12-16 16:10:54 +00:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks+1) < 0) {
|
|
|
|
virReportOOMError();
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2011-06-30 09:23:50 +00:00
|
|
|
ignore_value(qemuDomainObjEnterMonitorWithDriver(driver, vm));
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
2010-12-16 16:10:54 +00:00
|
|
|
ret = qemuMonitorAddDrive(priv->mon, drivestr);
|
|
|
|
if (ret == 0) {
|
|
|
|
ret = qemuMonitorAddDevice(priv->mon, devstr);
|
|
|
|
if (ret < 0) {
|
|
|
|
VIR_WARN("qemuMonitorAddDevice failed on %s (%s)",
|
|
|
|
drivestr, devstr);
|
|
|
|
/* XXX should call 'drive_del' on error but this does not
|
|
|
|
exist yet */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ret = qemuMonitorAddUSBDisk(priv->mon, disk->src);
|
|
|
|
}
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
|
Move qemu_audit.h helpers into shared code
The LXC and UML drivers can both make use of auditing. Move
the qemu_audit.{c,h} files to src/conf/domain_audit.{c,h}
* src/conf/domain_audit.c: Rename from src/qemu/qemu_audit.c
* src/conf/domain_audit.h: Rename from src/qemu/qemu_audit.h
* src/Makefile.am: Remove qemu_audit.{c,h}, add domain_audit.{c,h}
* src/qemu/qemu_audit.h, src/qemu/qemu_cgroup.c,
src/qemu/qemu_command.c, src/qemu/qemu_driver.c,
src/qemu/qemu_hotplug.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c: Update for changed audit API names
2011-07-04 10:56:13 +00:00
|
|
|
virDomainAuditDisk(vm, NULL, disk, "attach", ret >= 0);
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
virDomainDiskInsertPreAlloced(vm->def, disk);
|
|
|
|
|
|
|
|
VIR_FREE(devstr);
|
|
|
|
VIR_FREE(drivestr);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
|
|
|
VIR_FREE(devstr);
|
|
|
|
VIR_FREE(drivestr);
|
|
|
|
|
Refactor the security drivers to simplify usage
The current security driver usage requires horrible code like
if (driver->securityDriver &&
driver->securityDriver->domainSetSecurityHostdevLabel &&
driver->securityDriver->domainSetSecurityHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
This pair of checks for NULL clutters up the code, making the driver
calls 2 lines longer than they really need to be. The goal of the
patchset is to change the calling convention to simply
if (virSecurityManagerSetHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
The first check for 'driver->securityDriver' being NULL is removed
by introducing a 'no op' security driver that will always be present
if no real driver is enabled. This guarentees driver->securityDriver
!= NULL.
The second check for 'driver->securityDriver->domainSetSecurityHostdevLabel'
being non-NULL is hidden in a new abstraction called virSecurityManager.
This separates the driver callbacks, from main internal API. The addition
of a virSecurityManager object, that is separate from the virSecurityDriver
struct also allows for security drivers to carry state / configuration
information directly. Thus the DAC/Stack drivers from src/qemu which
used to pull config from 'struct qemud_driver' can now be moved into
the 'src/security' directory and store their config directly.
* src/qemu/qemu_conf.h, src/qemu/qemu_driver.c: Update to
use new virSecurityManager APIs
* src/qemu/qemu_security_dac.c, src/qemu/qemu_security_dac.h
src/qemu/qemu_security_stacked.c, src/qemu/qemu_security_stacked.h:
Move into src/security directory
* src/security/security_stack.c, src/security/security_stack.h,
src/security/security_dac.c, src/security/security_dac.h: Generic
versions of previous QEMU specific drivers
* src/security/security_apparmor.c, src/security/security_apparmor.h,
src/security/security_driver.c, src/security/security_driver.h,
src/security/security_selinux.c, src/security/security_selinux.h:
Update to take virSecurityManagerPtr object as the first param
in all callbacks
* src/security/security_nop.c, src/security/security_nop.h: Stub
implementation of all security driver APIs.
* src/security/security_manager.h, src/security/security_manager.c:
New internal API for invoking security drivers
* src/libvirt.c: Add missing debug for security APIs
2010-11-17 20:26:30 +00:00
|
|
|
if (virSecurityManagerRestoreImageLabel(driver->securityManager,
|
|
|
|
vm, disk) < 0)
|
2010-12-16 16:10:54 +00:00
|
|
|
VIR_WARN("Unable to restore security label on %s", disk->src);
|
|
|
|
|
2010-10-26 14:04:46 +00:00
|
|
|
if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0)
|
|
|
|
VIR_WARN("Unable to release lock on %s", disk->src);
|
|
|
|
|
2010-12-16 16:10:54 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* XXX conn required for network -> bridge resolution */
|
|
|
|
int qemuDomainAttachNetDevice(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
2011-05-04 12:09:09 +00:00
|
|
|
virDomainNetDefPtr net)
|
2010-12-16 16:10:54 +00:00
|
|
|
{
|
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
|
|
|
char *tapfd_name = NULL;
|
|
|
|
int tapfd = -1;
|
2011-03-09 04:43:33 +00:00
|
|
|
char *vhostfd_name = NULL;
|
|
|
|
int vhostfd = -1;
|
2010-12-16 16:10:54 +00:00
|
|
|
char *nicstr = NULL;
|
|
|
|
char *netstr = NULL;
|
|
|
|
int ret = -1;
|
|
|
|
virDomainDevicePCIAddress guestAddr;
|
|
|
|
int vlan;
|
2011-04-26 03:40:01 +00:00
|
|
|
bool releaseaddr = false;
|
2010-12-16 16:10:54 +00:00
|
|
|
|
2011-05-04 12:09:09 +00:00
|
|
|
if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_HOST_NET_ADD)) {
|
2010-12-16 16:10:54 +00:00
|
|
|
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
|
|
|
|
_("installed qemu version does not support host_net_add"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (net->type == VIR_DOMAIN_NET_TYPE_BRIDGE ||
|
|
|
|
net->type == VIR_DOMAIN_NET_TYPE_NETWORK) {
|
audit: audit use of /dev/net/tun, /dev/tapN, /dev/vhost-net
Opening raw network devices with the intent of passing those fds to
qemu is worth an audit point. This makes a multi-part audit: first,
we audit the device(s) that libvirt opens on behalf of the MAC address
of a to-be-created interface (which can independently succeed or
fail), then we audit whether qemu actually started the network device
with the same MAC (so searching backwards for successful audits with
the same MAC will show which fd(s) qemu is actually using). Note that
it is possible for the fd to be successfully opened but no attempt
made to pass the fd to qemu (for example, because intermediate
nwfilter operations failed) - no interface start audit will occur in
that case; so the audit for a successful opened fd does not imply
rights given to qemu unless there is a followup audit about the
attempt to start a new interface.
Likewise, when a network device is hot-unplugged, there is only one
audit message about the MAC being discontinued; again, searching back
to the earlier device open audits will show which fds that qemu quits
using (and yes, I checked via /proc/<qemu-pid>/fd that qemu _does_
close out the fds associated with an interface on hot-unplug). The
code would require much more refactoring to be able to definitively
state which device(s) were discontinued at that point, since we
currently don't record anywhere in the XML whether /dev/vhost-net was
opened for a given interface.
* src/qemu/qemu_audit.h (qemuAuditNetDevice): New prototype.
* src/qemu/qemu_audit.c (qemuAuditNetDevice): New function.
* src/qemu/qemu_command.h (qemuNetworkIfaceConnect)
(qemuPhysIfaceConnect, qemuOpenVhostNet): Adjust prototype.
* src/qemu/qemu_command.c (qemuNetworkIfaceConnect)
(qemuPhysIfaceConnect, qemuOpenVhostNet): Add audit points and
adjust parameters.
(qemuBuildCommandLine): Adjust caller.
* src/qemu/qemu_hotplug.c (qemuDomainAttachNetDevice): Likewise.
2011-03-08 18:00:59 +00:00
|
|
|
if ((tapfd = qemuNetworkIfaceConnect(vm->def, conn, driver, net,
|
2011-05-04 12:09:09 +00:00
|
|
|
priv->qemuCaps)) < 0)
|
2010-12-16 16:10:54 +00:00
|
|
|
return -1;
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuOpenVhostNet(vm->def, net, priv->qemuCaps, &vhostfd) < 0)
|
2011-03-09 04:43:33 +00:00
|
|
|
goto cleanup;
|
2010-12-16 16:10:54 +00:00
|
|
|
} else if (net->type == VIR_DOMAIN_NET_TYPE_DIRECT) {
|
audit: audit use of /dev/net/tun, /dev/tapN, /dev/vhost-net
Opening raw network devices with the intent of passing those fds to
qemu is worth an audit point. This makes a multi-part audit: first,
we audit the device(s) that libvirt opens on behalf of the MAC address
of a to-be-created interface (which can independently succeed or
fail), then we audit whether qemu actually started the network device
with the same MAC (so searching backwards for successful audits with
the same MAC will show which fd(s) qemu is actually using). Note that
it is possible for the fd to be successfully opened but no attempt
made to pass the fd to qemu (for example, because intermediate
nwfilter operations failed) - no interface start audit will occur in
that case; so the audit for a successful opened fd does not imply
rights given to qemu unless there is a followup audit about the
attempt to start a new interface.
Likewise, when a network device is hot-unplugged, there is only one
audit message about the MAC being discontinued; again, searching back
to the earlier device open audits will show which fds that qemu quits
using (and yes, I checked via /proc/<qemu-pid>/fd that qemu _does_
close out the fds associated with an interface on hot-unplug). The
code would require much more refactoring to be able to definitively
state which device(s) were discontinued at that point, since we
currently don't record anywhere in the XML whether /dev/vhost-net was
opened for a given interface.
* src/qemu/qemu_audit.h (qemuAuditNetDevice): New prototype.
* src/qemu/qemu_audit.c (qemuAuditNetDevice): New function.
* src/qemu/qemu_command.h (qemuNetworkIfaceConnect)
(qemuPhysIfaceConnect, qemuOpenVhostNet): Adjust prototype.
* src/qemu/qemu_command.c (qemuNetworkIfaceConnect)
(qemuPhysIfaceConnect, qemuOpenVhostNet): Add audit points and
adjust parameters.
(qemuBuildCommandLine): Adjust caller.
* src/qemu/qemu_hotplug.c (qemuDomainAttachNetDevice): Likewise.
2011-03-08 18:00:59 +00:00
|
|
|
if ((tapfd = qemuPhysIfaceConnect(vm->def, conn, driver, net,
|
2011-05-04 12:09:09 +00:00
|
|
|
priv->qemuCaps,
|
2010-12-16 16:10:54 +00:00
|
|
|
VIR_VM_OP_CREATE)) < 0)
|
|
|
|
return -1;
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuOpenVhostNet(vm->def, net, priv->qemuCaps, &vhostfd) < 0)
|
2011-03-09 04:43:33 +00:00
|
|
|
goto cleanup;
|
2010-12-16 16:10:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (VIR_REALLOC_N(vm->def->nets, vm->def->nnets+1) < 0)
|
|
|
|
goto no_memory;
|
|
|
|
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NET_NAME) ||
|
|
|
|
qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
2010-12-16 16:10:54 +00:00
|
|
|
if (qemuAssignDeviceNetAlias(vm->def, net, -1) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
|
2010-12-16 16:10:54 +00:00
|
|
|
qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &net->info) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
2011-04-26 03:40:01 +00:00
|
|
|
releaseaddr = true;
|
|
|
|
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
|
|
|
|
qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
2010-12-16 16:10:54 +00:00
|
|
|
vlan = -1;
|
|
|
|
} else {
|
|
|
|
vlan = qemuDomainNetVLAN(net);
|
|
|
|
|
|
|
|
if (vlan < 0) {
|
|
|
|
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
|
|
|
|
_("Unable to attach network devices without vlan"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tapfd != -1) {
|
|
|
|
if (virAsprintf(&tapfd_name, "fd-%s", net->info.alias) < 0)
|
|
|
|
goto no_memory;
|
|
|
|
}
|
|
|
|
|
2011-03-09 04:43:33 +00:00
|
|
|
if (vhostfd != -1) {
|
|
|
|
if (virAsprintf(&vhostfd_name, "vhostfd-%s", net->info.alias) < 0)
|
|
|
|
goto no_memory;
|
|
|
|
}
|
|
|
|
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
|
|
|
|
qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
2010-12-16 16:10:54 +00:00
|
|
|
if (!(netstr = qemuBuildHostNetStr(net, ',',
|
2011-03-09 04:43:33 +00:00
|
|
|
-1, tapfd_name, vhostfd_name)))
|
2011-03-16 02:21:45 +00:00
|
|
|
goto cleanup;
|
2010-12-16 16:10:54 +00:00
|
|
|
} else {
|
|
|
|
if (!(netstr = qemuBuildHostNetStr(net, ' ',
|
2011-03-09 04:43:33 +00:00
|
|
|
vlan, tapfd_name, vhostfd_name)))
|
2011-03-16 02:21:45 +00:00
|
|
|
goto cleanup;
|
2010-12-16 16:10:54 +00:00
|
|
|
}
|
|
|
|
|
2011-06-30 09:23:50 +00:00
|
|
|
ignore_value(qemuDomainObjEnterMonitorWithDriver(driver, vm));
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
|
|
|
|
qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
2011-03-16 02:21:45 +00:00
|
|
|
if (qemuMonitorAddNetdev(priv->mon, netstr, tapfd, tapfd_name,
|
|
|
|
vhostfd, vhostfd_name) < 0) {
|
2010-12-16 16:10:54 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
Move qemu_audit.h helpers into shared code
The LXC and UML drivers can both make use of auditing. Move
the qemu_audit.{c,h} files to src/conf/domain_audit.{c,h}
* src/conf/domain_audit.c: Rename from src/qemu/qemu_audit.c
* src/conf/domain_audit.h: Rename from src/qemu/qemu_audit.h
* src/Makefile.am: Remove qemu_audit.{c,h}, add domain_audit.{c,h}
* src/qemu/qemu_audit.h, src/qemu/qemu_cgroup.c,
src/qemu/qemu_command.c, src/qemu/qemu_driver.c,
src/qemu/qemu_hotplug.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c: Update for changed audit API names
2011-07-04 10:56:13 +00:00
|
|
|
virDomainAuditNet(vm, NULL, net, "attach", false);
|
2011-03-16 02:21:45 +00:00
|
|
|
goto cleanup;
|
2010-12-16 16:10:54 +00:00
|
|
|
}
|
|
|
|
} else {
|
2011-03-16 02:21:45 +00:00
|
|
|
if (qemuMonitorAddHostNetwork(priv->mon, netstr, tapfd, tapfd_name,
|
|
|
|
vhostfd, vhostfd_name) < 0) {
|
2010-12-16 16:10:54 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
Move qemu_audit.h helpers into shared code
The LXC and UML drivers can both make use of auditing. Move
the qemu_audit.{c,h} files to src/conf/domain_audit.{c,h}
* src/conf/domain_audit.c: Rename from src/qemu/qemu_audit.c
* src/conf/domain_audit.h: Rename from src/qemu/qemu_audit.h
* src/Makefile.am: Remove qemu_audit.{c,h}, add domain_audit.{c,h}
* src/qemu/qemu_audit.h, src/qemu/qemu_cgroup.c,
src/qemu/qemu_command.c, src/qemu/qemu_driver.c,
src/qemu/qemu_hotplug.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c: Update for changed audit API names
2011-07-04 10:56:13 +00:00
|
|
|
virDomainAuditNet(vm, NULL, net, "attach", false);
|
2011-03-16 02:21:45 +00:00
|
|
|
goto cleanup;
|
2010-12-16 16:10:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
|
|
|
|
VIR_FORCE_CLOSE(tapfd);
|
2011-03-09 04:43:33 +00:00
|
|
|
VIR_FORCE_CLOSE(vhostfd);
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
if (!virDomainObjIsActive(vm)) {
|
|
|
|
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
|
|
|
|
_("guest unexpectedly quit"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
2011-05-26 14:15:01 +00:00
|
|
|
if (!(nicstr = qemuBuildNicDevStr(net, vlan, 0, priv->qemuCaps)))
|
2010-12-16 16:10:54 +00:00
|
|
|
goto try_remove;
|
|
|
|
} else {
|
|
|
|
if (!(nicstr = qemuBuildNicStr(net, NULL, vlan)))
|
|
|
|
goto try_remove;
|
|
|
|
}
|
|
|
|
|
2011-06-30 09:23:50 +00:00
|
|
|
ignore_value(qemuDomainObjEnterMonitorWithDriver(driver, vm));
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
2010-12-16 16:10:54 +00:00
|
|
|
if (qemuMonitorAddDevice(priv->mon, nicstr) < 0) {
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
Move qemu_audit.h helpers into shared code
The LXC and UML drivers can both make use of auditing. Move
the qemu_audit.{c,h} files to src/conf/domain_audit.{c,h}
* src/conf/domain_audit.c: Rename from src/qemu/qemu_audit.c
* src/conf/domain_audit.h: Rename from src/qemu/qemu_audit.h
* src/Makefile.am: Remove qemu_audit.{c,h}, add domain_audit.{c,h}
* src/qemu/qemu_audit.h, src/qemu/qemu_cgroup.c,
src/qemu/qemu_command.c, src/qemu/qemu_driver.c,
src/qemu/qemu_hotplug.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c: Update for changed audit API names
2011-07-04 10:56:13 +00:00
|
|
|
virDomainAuditNet(vm, NULL, net, "attach", false);
|
2010-12-16 16:10:54 +00:00
|
|
|
goto try_remove;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (qemuMonitorAddPCINetwork(priv->mon, nicstr,
|
|
|
|
&guestAddr) < 0) {
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
Move qemu_audit.h helpers into shared code
The LXC and UML drivers can both make use of auditing. Move
the qemu_audit.{c,h} files to src/conf/domain_audit.{c,h}
* src/conf/domain_audit.c: Rename from src/qemu/qemu_audit.c
* src/conf/domain_audit.h: Rename from src/qemu/qemu_audit.h
* src/Makefile.am: Remove qemu_audit.{c,h}, add domain_audit.{c,h}
* src/qemu/qemu_audit.h, src/qemu/qemu_cgroup.c,
src/qemu/qemu_command.c, src/qemu/qemu_driver.c,
src/qemu/qemu_hotplug.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c: Update for changed audit API names
2011-07-04 10:56:13 +00:00
|
|
|
virDomainAuditNet(vm, NULL, net, "attach", false);
|
2010-12-16 16:10:54 +00:00
|
|
|
goto try_remove;
|
|
|
|
}
|
|
|
|
net->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
|
|
|
|
memcpy(&net->info.addr.pci, &guestAddr, sizeof(guestAddr));
|
|
|
|
}
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
|
Move qemu_audit.h helpers into shared code
The LXC and UML drivers can both make use of auditing. Move
the qemu_audit.{c,h} files to src/conf/domain_audit.{c,h}
* src/conf/domain_audit.c: Rename from src/qemu/qemu_audit.c
* src/conf/domain_audit.h: Rename from src/qemu/qemu_audit.h
* src/Makefile.am: Remove qemu_audit.{c,h}, add domain_audit.{c,h}
* src/qemu/qemu_audit.h, src/qemu/qemu_cgroup.c,
src/qemu/qemu_command.c, src/qemu/qemu_driver.c,
src/qemu/qemu_hotplug.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c: Update for changed audit API names
2011-07-04 10:56:13 +00:00
|
|
|
virDomainAuditNet(vm, NULL, net, "attach", true);
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
vm->def->nets[vm->def->nnets++] = net;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
if ((ret != 0) &&
|
2011-05-04 12:09:09 +00:00
|
|
|
qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
|
2010-12-16 16:10:54 +00:00
|
|
|
(net->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
|
2011-04-26 03:40:01 +00:00
|
|
|
releaseaddr &&
|
2011-05-23 07:43:35 +00:00
|
|
|
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
|
|
|
|
net->info.addr.pci.slot) < 0)
|
2011-05-09 09:24:09 +00:00
|
|
|
VIR_WARN("Unable to release PCI address on NIC");
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
if (ret != 0)
|
|
|
|
virDomainConfNWFilterTeardown(net);
|
|
|
|
|
|
|
|
VIR_FREE(nicstr);
|
|
|
|
VIR_FREE(netstr);
|
|
|
|
VIR_FREE(tapfd_name);
|
|
|
|
VIR_FORCE_CLOSE(tapfd);
|
2011-03-09 04:43:33 +00:00
|
|
|
VIR_FREE(vhostfd_name);
|
|
|
|
VIR_FORCE_CLOSE(vhostfd);
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
try_remove:
|
|
|
|
if (!virDomainObjIsActive(vm))
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
if (vlan < 0) {
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
|
|
|
|
qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
2010-12-16 16:10:54 +00:00
|
|
|
char *netdev_name;
|
|
|
|
if (virAsprintf(&netdev_name, "host%s", net->info.alias) < 0)
|
|
|
|
goto no_memory;
|
2011-06-30 09:23:50 +00:00
|
|
|
ignore_value(qemuDomainObjEnterMonitorWithDriver(driver, vm));
|
2010-12-16 16:10:54 +00:00
|
|
|
if (qemuMonitorRemoveNetdev(priv->mon, netdev_name) < 0)
|
|
|
|
VIR_WARN("Failed to remove network backend for netdev %s",
|
|
|
|
netdev_name);
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
VIR_FREE(netdev_name);
|
|
|
|
} else {
|
2011-05-09 09:24:09 +00:00
|
|
|
VIR_WARN("Unable to remove network backend");
|
2010-12-16 16:10:54 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
char *hostnet_name;
|
|
|
|
if (virAsprintf(&hostnet_name, "host%s", net->info.alias) < 0)
|
|
|
|
goto no_memory;
|
2011-06-30 09:23:50 +00:00
|
|
|
ignore_value(qemuDomainObjEnterMonitorWithDriver(driver, vm));
|
2010-12-16 16:10:54 +00:00
|
|
|
if (qemuMonitorRemoveHostNetwork(priv->mon, vlan, hostnet_name) < 0)
|
|
|
|
VIR_WARN("Failed to remove network backend for vlan %d, net %s",
|
|
|
|
vlan, hostnet_name);
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
VIR_FREE(hostnet_name);
|
|
|
|
}
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
no_memory:
|
|
|
|
virReportOOMError();
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int qemuDomainAttachHostPciDevice(struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
2011-05-04 12:09:09 +00:00
|
|
|
virDomainHostdevDefPtr hostdev)
|
2010-12-16 16:10:54 +00:00
|
|
|
{
|
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
|
|
|
int ret;
|
|
|
|
char *devstr = NULL;
|
|
|
|
int configfd = -1;
|
|
|
|
char *configfd_name = NULL;
|
2011-04-26 03:40:01 +00:00
|
|
|
bool releaseaddr = false;
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
if (VIR_REALLOC_N(vm->def->hostdevs, vm->def->nhostdevs+1) < 0) {
|
|
|
|
virReportOOMError();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (qemuPrepareHostdevPCIDevices(driver, &hostdev, 1) < 0)
|
|
|
|
return -1;
|
|
|
|
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
2010-12-16 16:10:54 +00:00
|
|
|
if (qemuAssignDeviceHostdevAlias(vm->def, hostdev, -1) < 0)
|
|
|
|
goto error;
|
|
|
|
if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &hostdev->info) < 0)
|
|
|
|
goto error;
|
2011-04-26 03:40:01 +00:00
|
|
|
releaseaddr = true;
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_PCI_CONFIGFD)) {
|
2010-12-16 16:10:54 +00:00
|
|
|
configfd = qemuOpenPCIConfig(hostdev);
|
|
|
|
if (configfd >= 0) {
|
|
|
|
if (virAsprintf(&configfd_name, "fd-%s",
|
|
|
|
hostdev->info.alias) < 0) {
|
|
|
|
virReportOOMError();
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!virDomainObjIsActive(vm)) {
|
|
|
|
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
|
|
|
|
_("guest unexpectedly quit during hotplug"));
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2011-02-01 16:22:01 +00:00
|
|
|
if (!(devstr = qemuBuildPCIHostdevDevStr(hostdev, configfd_name,
|
2011-05-04 12:09:09 +00:00
|
|
|
priv->qemuCaps)))
|
2010-12-16 16:10:54 +00:00
|
|
|
goto error;
|
|
|
|
|
2011-06-30 09:23:50 +00:00
|
|
|
ignore_value(qemuDomainObjEnterMonitorWithDriver(driver, vm));
|
2011-03-15 23:10:16 +00:00
|
|
|
ret = qemuMonitorAddDeviceWithFd(priv->mon, devstr,
|
|
|
|
configfd, configfd_name);
|
2010-12-16 16:10:54 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
} else {
|
|
|
|
virDomainDevicePCIAddress guestAddr;
|
|
|
|
|
2011-06-30 09:23:50 +00:00
|
|
|
ignore_value(qemuDomainObjEnterMonitorWithDriver(driver, vm));
|
2010-12-16 16:10:54 +00:00
|
|
|
ret = qemuMonitorAddPCIHostDevice(priv->mon,
|
|
|
|
&hostdev->source.subsys.u.pci,
|
|
|
|
&guestAddr);
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
|
|
|
|
hostdev->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
|
|
|
|
memcpy(&hostdev->info.addr.pci, &guestAddr, sizeof(guestAddr));
|
|
|
|
}
|
Move qemu_audit.h helpers into shared code
The LXC and UML drivers can both make use of auditing. Move
the qemu_audit.{c,h} files to src/conf/domain_audit.{c,h}
* src/conf/domain_audit.c: Rename from src/qemu/qemu_audit.c
* src/conf/domain_audit.h: Rename from src/qemu/qemu_audit.h
* src/Makefile.am: Remove qemu_audit.{c,h}, add domain_audit.{c,h}
* src/qemu/qemu_audit.h, src/qemu/qemu_cgroup.c,
src/qemu/qemu_command.c, src/qemu/qemu_driver.c,
src/qemu/qemu_hotplug.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c: Update for changed audit API names
2011-07-04 10:56:13 +00:00
|
|
|
virDomainAuditHostdev(vm, hostdev, "attach", ret == 0);
|
2010-12-16 16:10:54 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
vm->def->hostdevs[vm->def->nhostdevs++] = hostdev;
|
|
|
|
|
|
|
|
VIR_FREE(devstr);
|
|
|
|
VIR_FREE(configfd_name);
|
|
|
|
VIR_FORCE_CLOSE(configfd);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
|
2010-12-16 16:10:54 +00:00
|
|
|
(hostdev->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
|
2011-04-26 03:40:01 +00:00
|
|
|
releaseaddr &&
|
2011-05-23 07:43:35 +00:00
|
|
|
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
|
|
|
|
hostdev->info.addr.pci.slot) < 0)
|
2011-05-09 09:24:09 +00:00
|
|
|
VIR_WARN("Unable to release PCI address on host device");
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
qemuDomainReAttachHostdevDevices(driver, &hostdev, 1);
|
|
|
|
|
|
|
|
VIR_FREE(devstr);
|
|
|
|
VIR_FREE(configfd_name);
|
|
|
|
VIR_FORCE_CLOSE(configfd);
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int qemuDomainAttachHostUsbDevice(struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
2011-05-04 12:09:09 +00:00
|
|
|
virDomainHostdevDefPtr hostdev)
|
2010-12-16 16:10:54 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
|
|
|
char *devstr = NULL;
|
|
|
|
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
2010-12-16 16:10:54 +00:00
|
|
|
if (qemuAssignDeviceHostdevAlias(vm->def, hostdev, -1) < 0)
|
|
|
|
goto error;
|
|
|
|
if (!(devstr = qemuBuildUSBHostdevDevStr(hostdev)))
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (VIR_REALLOC_N(vm->def->hostdevs, vm->def->nhostdevs+1) < 0) {
|
|
|
|
virReportOOMError();
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_DEVICES)) {
|
|
|
|
virCgroupPtr cgroup = NULL;
|
|
|
|
usbDevice *usb;
|
2011-03-23 02:02:15 +00:00
|
|
|
qemuCgroupData data;
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
if (virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 0) !=0 ) {
|
|
|
|
qemuReportError(VIR_ERR_INTERNAL_ERROR,
|
2011-01-28 03:39:44 +00:00
|
|
|
_("Unable to find cgroup for %s"),
|
2010-12-16 16:10:54 +00:00
|
|
|
vm->def->name);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((usb = usbGetDevice(hostdev->source.subsys.u.usb.bus,
|
|
|
|
hostdev->source.subsys.u.usb.device)) == NULL)
|
|
|
|
goto error;
|
|
|
|
|
2011-03-23 02:02:15 +00:00
|
|
|
data.vm = vm;
|
|
|
|
data.cgroup = cgroup;
|
2011-02-16 02:18:40 +00:00
|
|
|
if (usbDeviceFileIterate(usb, qemuSetupHostUsbDeviceCgroup, &data) < 0)
|
2010-12-16 16:10:54 +00:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2011-06-30 09:23:50 +00:00
|
|
|
ignore_value(qemuDomainObjEnterMonitorWithDriver(driver, vm));
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE))
|
2010-12-16 16:10:54 +00:00
|
|
|
ret = qemuMonitorAddDevice(priv->mon, devstr);
|
|
|
|
else
|
|
|
|
ret = qemuMonitorAddUSBDeviceExact(priv->mon,
|
|
|
|
hostdev->source.subsys.u.usb.bus,
|
|
|
|
hostdev->source.subsys.u.usb.device);
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
Move qemu_audit.h helpers into shared code
The LXC and UML drivers can both make use of auditing. Move
the qemu_audit.{c,h} files to src/conf/domain_audit.{c,h}
* src/conf/domain_audit.c: Rename from src/qemu/qemu_audit.c
* src/conf/domain_audit.h: Rename from src/qemu/qemu_audit.h
* src/Makefile.am: Remove qemu_audit.{c,h}, add domain_audit.{c,h}
* src/qemu/qemu_audit.h, src/qemu/qemu_cgroup.c,
src/qemu/qemu_command.c, src/qemu/qemu_driver.c,
src/qemu/qemu_hotplug.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c: Update for changed audit API names
2011-07-04 10:56:13 +00:00
|
|
|
virDomainAuditHostdev(vm, hostdev, "attach", ret == 0);
|
2010-12-16 16:10:54 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
vm->def->hostdevs[vm->def->nhostdevs++] = hostdev;
|
|
|
|
|
|
|
|
VIR_FREE(devstr);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
|
|
|
VIR_FREE(devstr);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int qemuDomainAttachHostDevice(struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
2011-05-04 12:09:09 +00:00
|
|
|
virDomainHostdevDefPtr hostdev)
|
2010-12-16 16:10:54 +00:00
|
|
|
{
|
|
|
|
if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
|
|
|
|
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
|
|
|
|
_("hostdev mode '%s' not supported"),
|
|
|
|
virDomainHostdevModeTypeToString(hostdev->mode));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Resolve USB product/vendor to bus/device */
|
|
|
|
if (hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB &&
|
|
|
|
hostdev->source.subsys.u.usb.vendor) {
|
|
|
|
usbDevice *usb
|
|
|
|
= usbFindDevice(hostdev->source.subsys.u.usb.vendor,
|
|
|
|
hostdev->source.subsys.u.usb.product);
|
|
|
|
|
|
|
|
if (!usb)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
hostdev->source.subsys.u.usb.bus = usbDeviceGetBus(usb);
|
|
|
|
hostdev->source.subsys.u.usb.device = usbDeviceGetDevno(usb);
|
|
|
|
|
|
|
|
usbFreeDevice(usb);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
Refactor the security drivers to simplify usage
The current security driver usage requires horrible code like
if (driver->securityDriver &&
driver->securityDriver->domainSetSecurityHostdevLabel &&
driver->securityDriver->domainSetSecurityHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
This pair of checks for NULL clutters up the code, making the driver
calls 2 lines longer than they really need to be. The goal of the
patchset is to change the calling convention to simply
if (virSecurityManagerSetHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
The first check for 'driver->securityDriver' being NULL is removed
by introducing a 'no op' security driver that will always be present
if no real driver is enabled. This guarentees driver->securityDriver
!= NULL.
The second check for 'driver->securityDriver->domainSetSecurityHostdevLabel'
being non-NULL is hidden in a new abstraction called virSecurityManager.
This separates the driver callbacks, from main internal API. The addition
of a virSecurityManager object, that is separate from the virSecurityDriver
struct also allows for security drivers to carry state / configuration
information directly. Thus the DAC/Stack drivers from src/qemu which
used to pull config from 'struct qemud_driver' can now be moved into
the 'src/security' directory and store their config directly.
* src/qemu/qemu_conf.h, src/qemu/qemu_driver.c: Update to
use new virSecurityManager APIs
* src/qemu/qemu_security_dac.c, src/qemu/qemu_security_dac.h
src/qemu/qemu_security_stacked.c, src/qemu/qemu_security_stacked.h:
Move into src/security directory
* src/security/security_stack.c, src/security/security_stack.h,
src/security/security_dac.c, src/security/security_dac.h: Generic
versions of previous QEMU specific drivers
* src/security/security_apparmor.c, src/security/security_apparmor.h,
src/security/security_driver.c, src/security/security_driver.h,
src/security/security_selinux.c, src/security/security_selinux.h:
Update to take virSecurityManagerPtr object as the first param
in all callbacks
* src/security/security_nop.c, src/security/security_nop.h: Stub
implementation of all security driver APIs.
* src/security/security_manager.h, src/security/security_manager.c:
New internal API for invoking security drivers
* src/libvirt.c: Add missing debug for security APIs
2010-11-17 20:26:30 +00:00
|
|
|
if (virSecurityManagerSetHostdevLabel(driver->securityManager,
|
|
|
|
vm, hostdev) < 0)
|
2010-12-16 16:10:54 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
switch (hostdev->source.subsys.type) {
|
|
|
|
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI:
|
|
|
|
if (qemuDomainAttachHostPciDevice(driver, vm,
|
2011-05-04 12:09:09 +00:00
|
|
|
hostdev) < 0)
|
2010-12-16 16:10:54 +00:00
|
|
|
goto error;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB:
|
|
|
|
if (qemuDomainAttachHostUsbDevice(driver, vm,
|
2011-05-04 12:09:09 +00:00
|
|
|
hostdev) < 0)
|
2010-12-16 16:10:54 +00:00
|
|
|
goto error;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
|
|
|
|
_("hostdev subsys type '%s' not supported"),
|
|
|
|
virDomainHostdevSubsysTypeToString(hostdev->source.subsys.type));
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
Refactor the security drivers to simplify usage
The current security driver usage requires horrible code like
if (driver->securityDriver &&
driver->securityDriver->domainSetSecurityHostdevLabel &&
driver->securityDriver->domainSetSecurityHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
This pair of checks for NULL clutters up the code, making the driver
calls 2 lines longer than they really need to be. The goal of the
patchset is to change the calling convention to simply
if (virSecurityManagerSetHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
The first check for 'driver->securityDriver' being NULL is removed
by introducing a 'no op' security driver that will always be present
if no real driver is enabled. This guarentees driver->securityDriver
!= NULL.
The second check for 'driver->securityDriver->domainSetSecurityHostdevLabel'
being non-NULL is hidden in a new abstraction called virSecurityManager.
This separates the driver callbacks, from main internal API. The addition
of a virSecurityManager object, that is separate from the virSecurityDriver
struct also allows for security drivers to carry state / configuration
information directly. Thus the DAC/Stack drivers from src/qemu which
used to pull config from 'struct qemud_driver' can now be moved into
the 'src/security' directory and store their config directly.
* src/qemu/qemu_conf.h, src/qemu/qemu_driver.c: Update to
use new virSecurityManager APIs
* src/qemu/qemu_security_dac.c, src/qemu/qemu_security_dac.h
src/qemu/qemu_security_stacked.c, src/qemu/qemu_security_stacked.h:
Move into src/security directory
* src/security/security_stack.c, src/security/security_stack.h,
src/security/security_dac.c, src/security/security_dac.h: Generic
versions of previous QEMU specific drivers
* src/security/security_apparmor.c, src/security/security_apparmor.h,
src/security/security_driver.c, src/security/security_driver.h,
src/security/security_selinux.c, src/security/security_selinux.h:
Update to take virSecurityManagerPtr object as the first param
in all callbacks
* src/security/security_nop.c, src/security/security_nop.h: Stub
implementation of all security driver APIs.
* src/security/security_manager.h, src/security/security_manager.c:
New internal API for invoking security drivers
* src/libvirt.c: Add missing debug for security APIs
2010-11-17 20:26:30 +00:00
|
|
|
if (virSecurityManagerRestoreHostdevLabel(driver->securityManager,
|
|
|
|
vm, hostdev) < 0)
|
2011-05-09 09:24:09 +00:00
|
|
|
VIR_WARN("Unable to restore host device labelling on hotplug fail");
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static virDomainGraphicsDefPtr qemuDomainFindGraphics(virDomainObjPtr vm,
|
|
|
|
virDomainGraphicsDefPtr dev)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0 ; i < vm->def->ngraphics ; i++) {
|
|
|
|
if (vm->def->graphics[i]->type == dev->type)
|
|
|
|
return vm->def->graphics[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
qemuDomainChangeGraphics(struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
virDomainGraphicsDefPtr dev)
|
|
|
|
{
|
|
|
|
virDomainGraphicsDefPtr olddev = qemuDomainFindGraphics(vm, dev);
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
if (!olddev) {
|
|
|
|
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
|
|
|
|
_("cannot find existing graphics device to modify"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (dev->type) {
|
|
|
|
case VIR_DOMAIN_GRAPHICS_TYPE_VNC:
|
|
|
|
if ((olddev->data.vnc.autoport != dev->data.vnc.autoport) ||
|
2011-06-06 19:35:41 +00:00
|
|
|
(!dev->data.vnc.autoport &&
|
|
|
|
(olddev->data.vnc.port != dev->data.vnc.port))) {
|
2010-12-16 16:10:54 +00:00
|
|
|
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
|
|
|
|
_("cannot change port settings on vnc graphics"));
|
|
|
|
return -1;
|
|
|
|
}
|
2011-06-06 19:35:41 +00:00
|
|
|
if (STRNEQ_NULLABLE(olddev->data.vnc.listenAddr,
|
|
|
|
dev->data.vnc.listenAddr)) {
|
2010-12-16 16:10:54 +00:00
|
|
|
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
|
|
|
|
_("cannot change listen address setting on vnc graphics"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (STRNEQ_NULLABLE(olddev->data.vnc.keymap, dev->data.vnc.keymap)) {
|
|
|
|
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
|
|
|
|
_("cannot change keymap setting on vnc graphics"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2011-05-26 14:15:54 +00:00
|
|
|
/* If a password lifetime was, or is set, or action if connected has
|
|
|
|
* changed, then we must always run, even if new password matches
|
|
|
|
* old password */
|
Use the new set_password monitor command to set password.
We try to use that command first when setting a VNC/SPICE password. If
that doesn't work we fallback to the legacy VNC only password
Allow an expiry time to be set, if that doesn't work, throw an error
if they try to use SPICE.
Change since v1:
- moved qemuInitGraphicsPasswords to qemu_hotplug, renamed
to qemuDomainChangeGraphicsPasswords.
- updated what looks like a typo (that appears to work anyway) in
initial patch from Daniel:
- ret = qemuInitGraphicsPasswords(driver, vm,
- VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
- &vm->def->graphics[0]->data.vnc.auth,
- driver->vncPassword);
+ ret = qemuInitGraphicsPasswords(driver, vm,
+ VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
+ &vm->def->graphics[0]->data.spice.auth,
+ driver->spicePassword);
Based on patch by Daniel P. Berrange <berrange@redhat.com>.
2011-01-10 11:12:33 +00:00
|
|
|
if (olddev->data.vnc.auth.expires ||
|
|
|
|
dev->data.vnc.auth.expires ||
|
2011-05-26 14:15:54 +00:00
|
|
|
olddev->data.vnc.auth.connected != dev->data.vnc.auth.connected ||
|
2011-06-06 19:35:41 +00:00
|
|
|
STRNEQ_NULLABLE(olddev->data.vnc.auth.passwd,
|
|
|
|
dev->data.vnc.auth.passwd)) {
|
|
|
|
VIR_DEBUG("Updating password on VNC server %p %p",
|
|
|
|
dev->data.vnc.auth.passwd, driver->vncPassword);
|
|
|
|
ret = qemuDomainChangeGraphicsPasswords(driver, vm,
|
|
|
|
VIR_DOMAIN_GRAPHICS_TYPE_VNC,
|
|
|
|
&dev->data.vnc.auth,
|
|
|
|
driver->vncPassword);
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
/* Steal the new dev's char * reference */
|
|
|
|
VIR_FREE(olddev->data.vnc.auth.passwd);
|
|
|
|
olddev->data.vnc.auth.passwd = dev->data.vnc.auth.passwd;
|
|
|
|
dev->data.vnc.auth.passwd = NULL;
|
Use the new set_password monitor command to set password.
We try to use that command first when setting a VNC/SPICE password. If
that doesn't work we fallback to the legacy VNC only password
Allow an expiry time to be set, if that doesn't work, throw an error
if they try to use SPICE.
Change since v1:
- moved qemuInitGraphicsPasswords to qemu_hotplug, renamed
to qemuDomainChangeGraphicsPasswords.
- updated what looks like a typo (that appears to work anyway) in
initial patch from Daniel:
- ret = qemuInitGraphicsPasswords(driver, vm,
- VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
- &vm->def->graphics[0]->data.vnc.auth,
- driver->vncPassword);
+ ret = qemuInitGraphicsPasswords(driver, vm,
+ VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
+ &vm->def->graphics[0]->data.spice.auth,
+ driver->spicePassword);
Based on patch by Daniel P. Berrange <berrange@redhat.com>.
2011-01-10 11:12:33 +00:00
|
|
|
olddev->data.vnc.auth.validTo = dev->data.vnc.auth.validTo;
|
|
|
|
olddev->data.vnc.auth.expires = dev->data.vnc.auth.expires;
|
2011-05-26 14:15:54 +00:00
|
|
|
olddev->data.vnc.auth.connected = dev->data.vnc.auth.connected;
|
2010-12-16 16:10:54 +00:00
|
|
|
} else {
|
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
Use the new set_password monitor command to set password.
We try to use that command first when setting a VNC/SPICE password. If
that doesn't work we fallback to the legacy VNC only password
Allow an expiry time to be set, if that doesn't work, throw an error
if they try to use SPICE.
Change since v1:
- moved qemuInitGraphicsPasswords to qemu_hotplug, renamed
to qemuDomainChangeGraphicsPasswords.
- updated what looks like a typo (that appears to work anyway) in
initial patch from Daniel:
- ret = qemuInitGraphicsPasswords(driver, vm,
- VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
- &vm->def->graphics[0]->data.vnc.auth,
- driver->vncPassword);
+ ret = qemuInitGraphicsPasswords(driver, vm,
+ VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
+ &vm->def->graphics[0]->data.spice.auth,
+ driver->spicePassword);
Based on patch by Daniel P. Berrange <berrange@redhat.com>.
2011-01-10 11:12:33 +00:00
|
|
|
case VIR_DOMAIN_GRAPHICS_TYPE_SPICE:
|
|
|
|
if ((olddev->data.spice.autoport != dev->data.spice.autoport) ||
|
2011-06-06 19:35:41 +00:00
|
|
|
(!dev->data.spice.autoport &&
|
|
|
|
(olddev->data.spice.port != dev->data.spice.port)) ||
|
|
|
|
(!dev->data.spice.autoport &&
|
|
|
|
(olddev->data.spice.tlsPort != dev->data.spice.tlsPort))) {
|
Use the new set_password monitor command to set password.
We try to use that command first when setting a VNC/SPICE password. If
that doesn't work we fallback to the legacy VNC only password
Allow an expiry time to be set, if that doesn't work, throw an error
if they try to use SPICE.
Change since v1:
- moved qemuInitGraphicsPasswords to qemu_hotplug, renamed
to qemuDomainChangeGraphicsPasswords.
- updated what looks like a typo (that appears to work anyway) in
initial patch from Daniel:
- ret = qemuInitGraphicsPasswords(driver, vm,
- VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
- &vm->def->graphics[0]->data.vnc.auth,
- driver->vncPassword);
+ ret = qemuInitGraphicsPasswords(driver, vm,
+ VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
+ &vm->def->graphics[0]->data.spice.auth,
+ driver->spicePassword);
Based on patch by Daniel P. Berrange <berrange@redhat.com>.
2011-01-10 11:12:33 +00:00
|
|
|
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
|
|
|
|
_("cannot change port settings on spice graphics"));
|
|
|
|
return -1;
|
|
|
|
}
|
2011-06-06 19:35:41 +00:00
|
|
|
if (STRNEQ_NULLABLE(olddev->data.spice.listenAddr,
|
|
|
|
dev->data.spice.listenAddr)) {
|
Use the new set_password monitor command to set password.
We try to use that command first when setting a VNC/SPICE password. If
that doesn't work we fallback to the legacy VNC only password
Allow an expiry time to be set, if that doesn't work, throw an error
if they try to use SPICE.
Change since v1:
- moved qemuInitGraphicsPasswords to qemu_hotplug, renamed
to qemuDomainChangeGraphicsPasswords.
- updated what looks like a typo (that appears to work anyway) in
initial patch from Daniel:
- ret = qemuInitGraphicsPasswords(driver, vm,
- VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
- &vm->def->graphics[0]->data.vnc.auth,
- driver->vncPassword);
+ ret = qemuInitGraphicsPasswords(driver, vm,
+ VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
+ &vm->def->graphics[0]->data.spice.auth,
+ driver->spicePassword);
Based on patch by Daniel P. Berrange <berrange@redhat.com>.
2011-01-10 11:12:33 +00:00
|
|
|
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
|
|
|
|
_("cannot change listen address setting on spice graphics"));
|
|
|
|
return -1;
|
|
|
|
}
|
2011-06-06 19:35:41 +00:00
|
|
|
if (STRNEQ_NULLABLE(olddev->data.spice.keymap,
|
|
|
|
dev->data.spice.keymap)) {
|
Use the new set_password monitor command to set password.
We try to use that command first when setting a VNC/SPICE password. If
that doesn't work we fallback to the legacy VNC only password
Allow an expiry time to be set, if that doesn't work, throw an error
if they try to use SPICE.
Change since v1:
- moved qemuInitGraphicsPasswords to qemu_hotplug, renamed
to qemuDomainChangeGraphicsPasswords.
- updated what looks like a typo (that appears to work anyway) in
initial patch from Daniel:
- ret = qemuInitGraphicsPasswords(driver, vm,
- VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
- &vm->def->graphics[0]->data.vnc.auth,
- driver->vncPassword);
+ ret = qemuInitGraphicsPasswords(driver, vm,
+ VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
+ &vm->def->graphics[0]->data.spice.auth,
+ driver->spicePassword);
Based on patch by Daniel P. Berrange <berrange@redhat.com>.
2011-01-10 11:12:33 +00:00
|
|
|
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
|
|
|
|
_("cannot change keymap setting on spice graphics"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If a password lifetime was, or is set, then we must always run,
|
|
|
|
* even if new password matches old password */
|
|
|
|
if (olddev->data.spice.auth.expires ||
|
|
|
|
dev->data.spice.auth.expires ||
|
2011-05-26 14:15:54 +00:00
|
|
|
olddev->data.spice.auth.connected != dev->data.spice.auth.connected ||
|
2011-06-06 19:35:41 +00:00
|
|
|
STRNEQ_NULLABLE(olddev->data.spice.auth.passwd,
|
|
|
|
dev->data.spice.auth.passwd)) {
|
|
|
|
VIR_DEBUG("Updating password on SPICE server %p %p",
|
|
|
|
dev->data.spice.auth.passwd, driver->spicePassword);
|
|
|
|
ret = qemuDomainChangeGraphicsPasswords(driver, vm,
|
|
|
|
VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
|
|
|
|
&dev->data.spice.auth,
|
|
|
|
driver->spicePassword);
|
|
|
|
|
|
|
|
/* Steal the new dev's char * reference */
|
Use the new set_password monitor command to set password.
We try to use that command first when setting a VNC/SPICE password. If
that doesn't work we fallback to the legacy VNC only password
Allow an expiry time to be set, if that doesn't work, throw an error
if they try to use SPICE.
Change since v1:
- moved qemuInitGraphicsPasswords to qemu_hotplug, renamed
to qemuDomainChangeGraphicsPasswords.
- updated what looks like a typo (that appears to work anyway) in
initial patch from Daniel:
- ret = qemuInitGraphicsPasswords(driver, vm,
- VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
- &vm->def->graphics[0]->data.vnc.auth,
- driver->vncPassword);
+ ret = qemuInitGraphicsPasswords(driver, vm,
+ VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
+ &vm->def->graphics[0]->data.spice.auth,
+ driver->spicePassword);
Based on patch by Daniel P. Berrange <berrange@redhat.com>.
2011-01-10 11:12:33 +00:00
|
|
|
VIR_FREE(olddev->data.spice.auth.passwd);
|
|
|
|
olddev->data.spice.auth.passwd = dev->data.spice.auth.passwd;
|
|
|
|
dev->data.spice.auth.passwd = NULL;
|
|
|
|
olddev->data.spice.auth.validTo = dev->data.spice.auth.validTo;
|
|
|
|
olddev->data.spice.auth.expires = dev->data.spice.auth.expires;
|
2011-05-26 14:15:54 +00:00
|
|
|
olddev->data.spice.auth.connected = dev->data.spice.auth.connected;
|
Use the new set_password monitor command to set password.
We try to use that command first when setting a VNC/SPICE password. If
that doesn't work we fallback to the legacy VNC only password
Allow an expiry time to be set, if that doesn't work, throw an error
if they try to use SPICE.
Change since v1:
- moved qemuInitGraphicsPasswords to qemu_hotplug, renamed
to qemuDomainChangeGraphicsPasswords.
- updated what looks like a typo (that appears to work anyway) in
initial patch from Daniel:
- ret = qemuInitGraphicsPasswords(driver, vm,
- VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
- &vm->def->graphics[0]->data.vnc.auth,
- driver->vncPassword);
+ ret = qemuInitGraphicsPasswords(driver, vm,
+ VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
+ &vm->def->graphics[0]->data.spice.auth,
+ driver->spicePassword);
Based on patch by Daniel P. Berrange <berrange@redhat.com>.
2011-01-10 11:12:33 +00:00
|
|
|
} else {
|
2011-05-09 09:24:09 +00:00
|
|
|
VIR_DEBUG("Not updating since password didn't change");
|
Use the new set_password monitor command to set password.
We try to use that command first when setting a VNC/SPICE password. If
that doesn't work we fallback to the legacy VNC only password
Allow an expiry time to be set, if that doesn't work, throw an error
if they try to use SPICE.
Change since v1:
- moved qemuInitGraphicsPasswords to qemu_hotplug, renamed
to qemuDomainChangeGraphicsPasswords.
- updated what looks like a typo (that appears to work anyway) in
initial patch from Daniel:
- ret = qemuInitGraphicsPasswords(driver, vm,
- VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
- &vm->def->graphics[0]->data.vnc.auth,
- driver->vncPassword);
+ ret = qemuInitGraphicsPasswords(driver, vm,
+ VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
+ &vm->def->graphics[0]->data.spice.auth,
+ driver->spicePassword);
Based on patch by Daniel P. Berrange <berrange@redhat.com>.
2011-01-10 11:12:33 +00:00
|
|
|
ret = 0;
|
|
|
|
}
|
2011-06-06 19:30:52 +00:00
|
|
|
break;
|
Use the new set_password monitor command to set password.
We try to use that command first when setting a VNC/SPICE password. If
that doesn't work we fallback to the legacy VNC only password
Allow an expiry time to be set, if that doesn't work, throw an error
if they try to use SPICE.
Change since v1:
- moved qemuInitGraphicsPasswords to qemu_hotplug, renamed
to qemuDomainChangeGraphicsPasswords.
- updated what looks like a typo (that appears to work anyway) in
initial patch from Daniel:
- ret = qemuInitGraphicsPasswords(driver, vm,
- VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
- &vm->def->graphics[0]->data.vnc.auth,
- driver->vncPassword);
+ ret = qemuInitGraphicsPasswords(driver, vm,
+ VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
+ &vm->def->graphics[0]->data.spice.auth,
+ driver->spicePassword);
Based on patch by Daniel P. Berrange <berrange@redhat.com>.
2011-01-10 11:12:33 +00:00
|
|
|
|
2010-12-16 16:10:54 +00:00
|
|
|
default:
|
|
|
|
qemuReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("unable to change config on '%s' graphics type"),
|
|
|
|
virDomainGraphicsTypeToString(dev->type));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static inline int qemuFindDisk(virDomainDefPtr def, const char *dst)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0 ; i < def->ndisks ; i++) {
|
|
|
|
if (STREQ(def->disks[i]->dst, dst)) {
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2011-05-09 06:59:16 +00:00
|
|
|
static int qemuComparePCIDevice(virDomainDefPtr def ATTRIBUTE_UNUSED,
|
|
|
|
virDomainDeviceInfoPtr dev1,
|
|
|
|
void *opaque)
|
|
|
|
{
|
|
|
|
virDomainDeviceInfoPtr dev2 = opaque;
|
|
|
|
|
|
|
|
if (dev1->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI ||
|
|
|
|
dev2->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (dev1->addr.pci.slot == dev2->addr.pci.slot &&
|
|
|
|
dev1->addr.pci.function != dev2->addr.pci.function)
|
|
|
|
return -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool qemuIsMultiFunctionDevice(virDomainDefPtr def,
|
|
|
|
virDomainDeviceInfoPtr dev)
|
|
|
|
{
|
|
|
|
if (virDomainDeviceInfoIterate(def, qemuComparePCIDevice, dev) < 0)
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
int qemuDomainDetachPciDiskDevice(struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
2011-05-04 12:09:09 +00:00
|
|
|
virDomainDeviceDefPtr dev)
|
2010-12-16 16:10:54 +00:00
|
|
|
{
|
|
|
|
int i, ret = -1;
|
|
|
|
virDomainDiskDefPtr detach = NULL;
|
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
|
|
|
virCgroupPtr cgroup = NULL;
|
|
|
|
char *drivestr = NULL;
|
|
|
|
|
|
|
|
i = qemuFindDisk(vm->def, dev->data.disk->dst);
|
|
|
|
|
|
|
|
if (i < 0) {
|
|
|
|
qemuReportError(VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("disk %s not found"), dev->data.disk->dst);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
detach = vm->def->disks[i];
|
|
|
|
|
2011-05-09 06:59:16 +00:00
|
|
|
if (qemuIsMultiFunctionDevice(vm->def, &detach->info)) {
|
|
|
|
qemuReportError(VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("cannot hot unplug multifunction PCI device: %s"),
|
|
|
|
dev->data.disk->dst);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2010-12-16 16:10:54 +00:00
|
|
|
if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_DEVICES)) {
|
|
|
|
if (virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 0) != 0) {
|
|
|
|
qemuReportError(VIR_ERR_INTERNAL_ERROR,
|
2011-01-28 03:39:44 +00:00
|
|
|
_("Unable to find cgroup for %s"),
|
2010-12-16 16:10:54 +00:00
|
|
|
vm->def->name);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!virDomainDeviceAddressIsValid(&detach->info,
|
|
|
|
VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)) {
|
|
|
|
qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
|
|
|
|
_("device cannot be detached without a PCI address"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* build the actual drive id string as the disk->info.alias doesn't
|
|
|
|
* contain the QEMU_DRIVE_HOST_PREFIX that is passed to qemu */
|
|
|
|
if (virAsprintf(&drivestr, "%s%s",
|
|
|
|
QEMU_DRIVE_HOST_PREFIX, detach->info.alias) < 0) {
|
|
|
|
virReportOOMError();
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2011-06-30 09:23:50 +00:00
|
|
|
ignore_value(qemuDomainObjEnterMonitorWithDriver(driver, vm));
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
2010-12-16 16:10:54 +00:00
|
|
|
if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
|
2011-07-04 14:35:03 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
Move qemu_audit.h helpers into shared code
The LXC and UML drivers can both make use of auditing. Move
the qemu_audit.{c,h} files to src/conf/domain_audit.{c,h}
* src/conf/domain_audit.c: Rename from src/qemu/qemu_audit.c
* src/conf/domain_audit.h: Rename from src/qemu/qemu_audit.h
* src/Makefile.am: Remove qemu_audit.{c,h}, add domain_audit.{c,h}
* src/qemu/qemu_audit.h, src/qemu/qemu_cgroup.c,
src/qemu/qemu_command.c, src/qemu/qemu_driver.c,
src/qemu/qemu_hotplug.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c: Update for changed audit API names
2011-07-04 10:56:13 +00:00
|
|
|
virDomainAuditDisk(vm, detach, NULL, "detach", false);
|
2010-12-16 16:10:54 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (qemuMonitorRemovePCIDevice(priv->mon,
|
|
|
|
&detach->info.addr.pci) < 0) {
|
2011-07-04 14:35:03 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
Move qemu_audit.h helpers into shared code
The LXC and UML drivers can both make use of auditing. Move
the qemu_audit.{c,h} files to src/conf/domain_audit.{c,h}
* src/conf/domain_audit.c: Rename from src/qemu/qemu_audit.c
* src/conf/domain_audit.h: Rename from src/qemu/qemu_audit.h
* src/Makefile.am: Remove qemu_audit.{c,h}, add domain_audit.{c,h}
* src/qemu/qemu_audit.h, src/qemu/qemu_cgroup.c,
src/qemu/qemu_command.c, src/qemu/qemu_driver.c,
src/qemu/qemu_hotplug.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c: Update for changed audit API names
2011-07-04 10:56:13 +00:00
|
|
|
virDomainAuditDisk(vm, detach, NULL, "detach", false);
|
2010-12-16 16:10:54 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* disconnect guest from host device */
|
|
|
|
qemuMonitorDriveDel(priv->mon, drivestr);
|
|
|
|
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
|
Move qemu_audit.h helpers into shared code
The LXC and UML drivers can both make use of auditing. Move
the qemu_audit.{c,h} files to src/conf/domain_audit.{c,h}
* src/conf/domain_audit.c: Rename from src/qemu/qemu_audit.c
* src/conf/domain_audit.h: Rename from src/qemu/qemu_audit.h
* src/Makefile.am: Remove qemu_audit.{c,h}, add domain_audit.{c,h}
* src/qemu/qemu_audit.h, src/qemu/qemu_cgroup.c,
src/qemu/qemu_command.c, src/qemu/qemu_driver.c,
src/qemu/qemu_hotplug.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c: Update for changed audit API names
2011-07-04 10:56:13 +00:00
|
|
|
virDomainAuditDisk(vm, detach, NULL, "detach", true);
|
2010-12-16 16:10:54 +00:00
|
|
|
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
|
2011-05-23 07:43:35 +00:00
|
|
|
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
|
|
|
|
detach->info.addr.pci.slot) < 0)
|
2010-12-16 16:10:54 +00:00
|
|
|
VIR_WARN("Unable to release PCI address on %s", dev->data.disk->src);
|
|
|
|
|
|
|
|
virDomainDiskRemove(vm->def, i);
|
|
|
|
|
|
|
|
virDomainDiskDefFree(detach);
|
|
|
|
|
Refactor the security drivers to simplify usage
The current security driver usage requires horrible code like
if (driver->securityDriver &&
driver->securityDriver->domainSetSecurityHostdevLabel &&
driver->securityDriver->domainSetSecurityHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
This pair of checks for NULL clutters up the code, making the driver
calls 2 lines longer than they really need to be. The goal of the
patchset is to change the calling convention to simply
if (virSecurityManagerSetHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
The first check for 'driver->securityDriver' being NULL is removed
by introducing a 'no op' security driver that will always be present
if no real driver is enabled. This guarentees driver->securityDriver
!= NULL.
The second check for 'driver->securityDriver->domainSetSecurityHostdevLabel'
being non-NULL is hidden in a new abstraction called virSecurityManager.
This separates the driver callbacks, from main internal API. The addition
of a virSecurityManager object, that is separate from the virSecurityDriver
struct also allows for security drivers to carry state / configuration
information directly. Thus the DAC/Stack drivers from src/qemu which
used to pull config from 'struct qemud_driver' can now be moved into
the 'src/security' directory and store their config directly.
* src/qemu/qemu_conf.h, src/qemu/qemu_driver.c: Update to
use new virSecurityManager APIs
* src/qemu/qemu_security_dac.c, src/qemu/qemu_security_dac.h
src/qemu/qemu_security_stacked.c, src/qemu/qemu_security_stacked.h:
Move into src/security directory
* src/security/security_stack.c, src/security/security_stack.h,
src/security/security_dac.c, src/security/security_dac.h: Generic
versions of previous QEMU specific drivers
* src/security/security_apparmor.c, src/security/security_apparmor.h,
src/security/security_driver.c, src/security/security_driver.h,
src/security/security_selinux.c, src/security/security_selinux.h:
Update to take virSecurityManagerPtr object as the first param
in all callbacks
* src/security/security_nop.c, src/security/security_nop.h: Stub
implementation of all security driver APIs.
* src/security/security_manager.h, src/security/security_manager.c:
New internal API for invoking security drivers
* src/libvirt.c: Add missing debug for security APIs
2010-11-17 20:26:30 +00:00
|
|
|
if (virSecurityManagerRestoreImageLabel(driver->securityManager,
|
|
|
|
vm, dev->data.disk) < 0)
|
2010-12-16 16:10:54 +00:00
|
|
|
VIR_WARN("Unable to restore security label on %s", dev->data.disk->src);
|
|
|
|
|
|
|
|
if (cgroup != NULL) {
|
2011-02-16 02:18:40 +00:00
|
|
|
if (qemuTeardownDiskCgroup(driver, vm, cgroup, dev->data.disk) < 0)
|
2010-12-16 16:10:54 +00:00
|
|
|
VIR_WARN("Failed to teardown cgroup for disk path %s",
|
|
|
|
NULLSTR(dev->data.disk->src));
|
|
|
|
}
|
|
|
|
|
2010-10-26 14:04:46 +00:00
|
|
|
if (virDomainLockDiskDetach(driver->lockManager, vm, dev->data.disk) < 0)
|
|
|
|
VIR_WARN("Unable to release lock on %s", dev->data.disk->src);
|
|
|
|
|
2010-12-16 16:10:54 +00:00
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
VIR_FREE(drivestr);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-03-07 03:31:48 +00:00
|
|
|
int qemuDomainDetachDiskDevice(struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
2011-05-04 12:09:09 +00:00
|
|
|
virDomainDeviceDefPtr dev)
|
2010-12-16 16:10:54 +00:00
|
|
|
{
|
|
|
|
int i, ret = -1;
|
|
|
|
virDomainDiskDefPtr detach = NULL;
|
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
|
|
|
virCgroupPtr cgroup = NULL;
|
|
|
|
char *drivestr = NULL;
|
|
|
|
|
|
|
|
i = qemuFindDisk(vm->def, dev->data.disk->dst);
|
|
|
|
|
|
|
|
if (i < 0) {
|
|
|
|
qemuReportError(VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("disk %s not found"), dev->data.disk->dst);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2011-05-04 12:09:09 +00:00
|
|
|
if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
2011-03-07 03:31:48 +00:00
|
|
|
qemuReportError(VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("Underlying qemu does not support %s disk removal"),
|
|
|
|
virDomainDiskBusTypeToString(dev->data.disk->bus));
|
2010-12-16 16:10:54 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
detach = vm->def->disks[i];
|
|
|
|
|
|
|
|
if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_DEVICES)) {
|
|
|
|
if (virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 0) != 0) {
|
|
|
|
qemuReportError(VIR_ERR_INTERNAL_ERROR,
|
2011-01-28 03:39:44 +00:00
|
|
|
_("Unable to find cgroup for %s"),
|
2010-12-16 16:10:54 +00:00
|
|
|
vm->def->name);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* build the actual drive id string as the disk->info.alias doesn't
|
|
|
|
* contain the QEMU_DRIVE_HOST_PREFIX that is passed to qemu */
|
|
|
|
if (virAsprintf(&drivestr, "%s%s",
|
|
|
|
QEMU_DRIVE_HOST_PREFIX, detach->info.alias) < 0) {
|
|
|
|
virReportOOMError();
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2011-06-30 09:23:50 +00:00
|
|
|
ignore_value(qemuDomainObjEnterMonitorWithDriver(driver, vm));
|
2010-12-16 16:10:54 +00:00
|
|
|
if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
|
2011-07-04 14:35:03 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
Move qemu_audit.h helpers into shared code
The LXC and UML drivers can both make use of auditing. Move
the qemu_audit.{c,h} files to src/conf/domain_audit.{c,h}
* src/conf/domain_audit.c: Rename from src/qemu/qemu_audit.c
* src/conf/domain_audit.h: Rename from src/qemu/qemu_audit.h
* src/Makefile.am: Remove qemu_audit.{c,h}, add domain_audit.{c,h}
* src/qemu/qemu_audit.h, src/qemu/qemu_cgroup.c,
src/qemu/qemu_command.c, src/qemu/qemu_driver.c,
src/qemu/qemu_hotplug.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c: Update for changed audit API names
2011-07-04 10:56:13 +00:00
|
|
|
virDomainAuditDisk(vm, detach, NULL, "detach", false);
|
2010-12-16 16:10:54 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* disconnect guest from host device */
|
|
|
|
qemuMonitorDriveDel(priv->mon, drivestr);
|
|
|
|
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
|
Move qemu_audit.h helpers into shared code
The LXC and UML drivers can both make use of auditing. Move
the qemu_audit.{c,h} files to src/conf/domain_audit.{c,h}
* src/conf/domain_audit.c: Rename from src/qemu/qemu_audit.c
* src/conf/domain_audit.h: Rename from src/qemu/qemu_audit.h
* src/Makefile.am: Remove qemu_audit.{c,h}, add domain_audit.{c,h}
* src/qemu/qemu_audit.h, src/qemu/qemu_cgroup.c,
src/qemu/qemu_command.c, src/qemu/qemu_driver.c,
src/qemu/qemu_hotplug.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c: Update for changed audit API names
2011-07-04 10:56:13 +00:00
|
|
|
virDomainAuditDisk(vm, detach, NULL, "detach", true);
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
virDomainDiskRemove(vm->def, i);
|
|
|
|
|
|
|
|
virDomainDiskDefFree(detach);
|
|
|
|
|
Refactor the security drivers to simplify usage
The current security driver usage requires horrible code like
if (driver->securityDriver &&
driver->securityDriver->domainSetSecurityHostdevLabel &&
driver->securityDriver->domainSetSecurityHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
This pair of checks for NULL clutters up the code, making the driver
calls 2 lines longer than they really need to be. The goal of the
patchset is to change the calling convention to simply
if (virSecurityManagerSetHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
The first check for 'driver->securityDriver' being NULL is removed
by introducing a 'no op' security driver that will always be present
if no real driver is enabled. This guarentees driver->securityDriver
!= NULL.
The second check for 'driver->securityDriver->domainSetSecurityHostdevLabel'
being non-NULL is hidden in a new abstraction called virSecurityManager.
This separates the driver callbacks, from main internal API. The addition
of a virSecurityManager object, that is separate from the virSecurityDriver
struct also allows for security drivers to carry state / configuration
information directly. Thus the DAC/Stack drivers from src/qemu which
used to pull config from 'struct qemud_driver' can now be moved into
the 'src/security' directory and store their config directly.
* src/qemu/qemu_conf.h, src/qemu/qemu_driver.c: Update to
use new virSecurityManager APIs
* src/qemu/qemu_security_dac.c, src/qemu/qemu_security_dac.h
src/qemu/qemu_security_stacked.c, src/qemu/qemu_security_stacked.h:
Move into src/security directory
* src/security/security_stack.c, src/security/security_stack.h,
src/security/security_dac.c, src/security/security_dac.h: Generic
versions of previous QEMU specific drivers
* src/security/security_apparmor.c, src/security/security_apparmor.h,
src/security/security_driver.c, src/security/security_driver.h,
src/security/security_selinux.c, src/security/security_selinux.h:
Update to take virSecurityManagerPtr object as the first param
in all callbacks
* src/security/security_nop.c, src/security/security_nop.h: Stub
implementation of all security driver APIs.
* src/security/security_manager.h, src/security/security_manager.c:
New internal API for invoking security drivers
* src/libvirt.c: Add missing debug for security APIs
2010-11-17 20:26:30 +00:00
|
|
|
if (virSecurityManagerRestoreImageLabel(driver->securityManager,
|
|
|
|
vm, dev->data.disk) < 0)
|
2010-12-16 16:10:54 +00:00
|
|
|
VIR_WARN("Unable to restore security label on %s", dev->data.disk->src);
|
|
|
|
|
|
|
|
if (cgroup != NULL) {
|
2011-02-16 02:18:40 +00:00
|
|
|
if (qemuTeardownDiskCgroup(driver, vm, cgroup, dev->data.disk) < 0)
|
2010-12-16 16:10:54 +00:00
|
|
|
VIR_WARN("Failed to teardown cgroup for disk path %s",
|
|
|
|
NULLSTR(dev->data.disk->src));
|
|
|
|
}
|
|
|
|
|
2010-10-26 14:04:46 +00:00
|
|
|
if (virDomainLockDiskDetach(driver->lockManager, vm, dev->data.disk) < 0)
|
|
|
|
VIR_WARN("Unable to release lock on disk %s", dev->data.disk->src);
|
|
|
|
|
2010-12-16 16:10:54 +00:00
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
VIR_FREE(drivestr);
|
|
|
|
virCgroupFree(&cgroup);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-02-21 07:35:52 +00:00
|
|
|
static bool qemuDomainDiskControllerIsBusy(virDomainObjPtr vm,
|
|
|
|
virDomainControllerDefPtr detach)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
virDomainDiskDefPtr disk;
|
|
|
|
|
|
|
|
for (i = 0; i < vm->def->ndisks; i++) {
|
|
|
|
disk = vm->def->disks[i];
|
|
|
|
if (disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE)
|
|
|
|
/* the disk does not use disk controller */
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* check whether the disk uses this type controller */
|
|
|
|
if (disk->bus == VIR_DOMAIN_DISK_BUS_IDE &&
|
|
|
|
detach->type != VIR_DOMAIN_CONTROLLER_TYPE_IDE)
|
|
|
|
continue;
|
|
|
|
if (disk->bus == VIR_DOMAIN_DISK_BUS_FDC &&
|
|
|
|
detach->type != VIR_DOMAIN_CONTROLLER_TYPE_FDC)
|
|
|
|
continue;
|
|
|
|
if (disk->bus == VIR_DOMAIN_DISK_BUS_SCSI &&
|
|
|
|
detach->type != VIR_DOMAIN_CONTROLLER_TYPE_SCSI)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (disk->info.addr.drive.controller == detach->idx)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool qemuDomainControllerIsBusy(virDomainObjPtr vm,
|
|
|
|
virDomainControllerDefPtr detach)
|
|
|
|
{
|
|
|
|
switch (detach->type) {
|
|
|
|
case VIR_DOMAIN_CONTROLLER_TYPE_IDE:
|
|
|
|
case VIR_DOMAIN_CONTROLLER_TYPE_FDC:
|
|
|
|
case VIR_DOMAIN_CONTROLLER_TYPE_SCSI:
|
|
|
|
return qemuDomainDiskControllerIsBusy(vm, detach);
|
|
|
|
|
|
|
|
case VIR_DOMAIN_CONTROLLER_TYPE_SATA:
|
|
|
|
case VIR_DOMAIN_CONTROLLER_TYPE_VIRTIO_SERIAL:
|
|
|
|
case VIR_DOMAIN_CONTROLLER_TYPE_CCID:
|
|
|
|
default:
|
|
|
|
/* libvirt does not support sata controller, and does not support to
|
|
|
|
* detach virtio and smart card controller.
|
|
|
|
*/
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-12-16 16:10:54 +00:00
|
|
|
int qemuDomainDetachPciControllerDevice(struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
2011-05-04 12:09:09 +00:00
|
|
|
virDomainDeviceDefPtr dev)
|
2010-12-16 16:10:54 +00:00
|
|
|
{
|
|
|
|
int i, ret = -1;
|
|
|
|
virDomainControllerDefPtr detach = NULL;
|
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
|
|
|
|
|
|
|
for (i = 0 ; i < vm->def->ncontrollers ; i++) {
|
|
|
|
if ((vm->def->controllers[i]->type == dev->data.controller->type) &&
|
|
|
|
(vm->def->controllers[i]->idx == dev->data.controller->idx)) {
|
|
|
|
detach = vm->def->controllers[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!detach) {
|
|
|
|
qemuReportError(VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("disk controller %s:%d not found"),
|
|
|
|
virDomainControllerTypeToString(dev->data.controller->type),
|
|
|
|
dev->data.controller->idx);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!virDomainDeviceAddressIsValid(&detach->info,
|
|
|
|
VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)) {
|
|
|
|
qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
|
|
|
|
_("device cannot be detached without a PCI address"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2011-05-09 06:59:16 +00:00
|
|
|
if (qemuIsMultiFunctionDevice(vm->def, &detach->info)) {
|
|
|
|
qemuReportError(VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("cannot hot unplug multifunction PCI device: %s"),
|
|
|
|
dev->data.disk->dst);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2011-02-21 07:35:52 +00:00
|
|
|
if (qemuDomainControllerIsBusy(vm, detach)) {
|
|
|
|
qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
|
|
|
|
_("device cannot be detached: device is busy"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
2010-12-16 16:10:54 +00:00
|
|
|
if (qemuAssignDeviceControllerAlias(detach) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2011-06-30 09:23:50 +00:00
|
|
|
ignore_value(qemuDomainObjEnterMonitorWithDriver(driver, vm));
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
2010-12-16 16:10:54 +00:00
|
|
|
if (qemuMonitorDelDevice(priv->mon, detach->info.alias)) {
|
2011-07-04 14:35:03 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2010-12-16 16:10:54 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (qemuMonitorRemovePCIDevice(priv->mon,
|
|
|
|
&detach->info.addr.pci) < 0) {
|
2011-07-04 14:35:03 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2010-12-16 16:10:54 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
|
|
|
|
if (vm->def->ncontrollers > 1) {
|
|
|
|
memmove(vm->def->controllers + i,
|
|
|
|
vm->def->controllers + i + 1,
|
|
|
|
sizeof(*vm->def->controllers) *
|
|
|
|
(vm->def->ncontrollers - (i + 1)));
|
|
|
|
vm->def->ncontrollers--;
|
|
|
|
if (VIR_REALLOC_N(vm->def->controllers, vm->def->ncontrollers) < 0) {
|
|
|
|
/* ignore, harmless */
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
VIR_FREE(vm->def->controllers);
|
|
|
|
vm->def->ncontrollers = 0;
|
|
|
|
}
|
|
|
|
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
|
2011-05-23 07:43:35 +00:00
|
|
|
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
|
|
|
|
detach->info.addr.pci.slot) < 0)
|
2011-05-09 09:24:09 +00:00
|
|
|
VIR_WARN("Unable to release PCI address on controller");
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
virDomainControllerDefFree(detach);
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int qemuDomainDetachNetDevice(struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
2011-05-04 12:09:09 +00:00
|
|
|
virDomainDeviceDefPtr dev)
|
2010-12-16 16:10:54 +00:00
|
|
|
{
|
|
|
|
int i, ret = -1;
|
|
|
|
virDomainNetDefPtr detach = NULL;
|
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
|
|
|
int vlan;
|
|
|
|
char *hostnet_name = NULL;
|
|
|
|
|
|
|
|
for (i = 0 ; i < vm->def->nnets ; i++) {
|
|
|
|
virDomainNetDefPtr net = vm->def->nets[i];
|
|
|
|
|
|
|
|
if (!memcmp(net->mac, dev->data.net->mac, sizeof(net->mac))) {
|
|
|
|
detach = net;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!detach) {
|
|
|
|
qemuReportError(VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("network device %02x:%02x:%02x:%02x:%02x:%02x not found"),
|
|
|
|
dev->data.net->mac[0], dev->data.net->mac[1],
|
|
|
|
dev->data.net->mac[2], dev->data.net->mac[3],
|
|
|
|
dev->data.net->mac[4], dev->data.net->mac[5]);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!virDomainDeviceAddressIsValid(&detach->info,
|
|
|
|
VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)) {
|
|
|
|
qemuReportError(VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("device cannot be detached without a PCI address"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2011-05-09 06:59:16 +00:00
|
|
|
if (qemuIsMultiFunctionDevice(vm->def, &detach->info)) {
|
|
|
|
qemuReportError(VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("cannot hot unplug multifunction PCI device :%s"),
|
|
|
|
dev->data.disk->dst);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2010-12-16 16:10:54 +00:00
|
|
|
if ((vlan = qemuDomainNetVLAN(detach)) < 0) {
|
|
|
|
qemuReportError(VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("unable to determine original VLAN"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (virAsprintf(&hostnet_name, "host%s", detach->info.alias) < 0) {
|
|
|
|
virReportOOMError();
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2011-06-30 09:23:50 +00:00
|
|
|
ignore_value(qemuDomainObjEnterMonitorWithDriver(driver, vm));
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
2010-12-16 16:10:54 +00:00
|
|
|
if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
|
2011-07-04 14:35:03 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
Move qemu_audit.h helpers into shared code
The LXC and UML drivers can both make use of auditing. Move
the qemu_audit.{c,h} files to src/conf/domain_audit.{c,h}
* src/conf/domain_audit.c: Rename from src/qemu/qemu_audit.c
* src/conf/domain_audit.h: Rename from src/qemu/qemu_audit.h
* src/Makefile.am: Remove qemu_audit.{c,h}, add domain_audit.{c,h}
* src/qemu/qemu_audit.h, src/qemu/qemu_cgroup.c,
src/qemu/qemu_command.c, src/qemu/qemu_driver.c,
src/qemu/qemu_hotplug.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c: Update for changed audit API names
2011-07-04 10:56:13 +00:00
|
|
|
virDomainAuditNet(vm, detach, NULL, "detach", false);
|
2010-12-16 16:10:54 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (qemuMonitorRemovePCIDevice(priv->mon,
|
|
|
|
&detach->info.addr.pci) < 0) {
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
Move qemu_audit.h helpers into shared code
The LXC and UML drivers can both make use of auditing. Move
the qemu_audit.{c,h} files to src/conf/domain_audit.{c,h}
* src/conf/domain_audit.c: Rename from src/qemu/qemu_audit.c
* src/conf/domain_audit.h: Rename from src/qemu/qemu_audit.h
* src/Makefile.am: Remove qemu_audit.{c,h}, add domain_audit.{c,h}
* src/qemu/qemu_audit.h, src/qemu/qemu_cgroup.c,
src/qemu/qemu_command.c, src/qemu/qemu_driver.c,
src/qemu/qemu_hotplug.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c: Update for changed audit API names
2011-07-04 10:56:13 +00:00
|
|
|
virDomainAuditNet(vm, detach, NULL, "detach", false);
|
2010-12-16 16:10:54 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
|
|
|
|
qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
2010-12-16 16:10:54 +00:00
|
|
|
if (qemuMonitorRemoveNetdev(priv->mon, hostnet_name) < 0) {
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
Move qemu_audit.h helpers into shared code
The LXC and UML drivers can both make use of auditing. Move
the qemu_audit.{c,h} files to src/conf/domain_audit.{c,h}
* src/conf/domain_audit.c: Rename from src/qemu/qemu_audit.c
* src/conf/domain_audit.h: Rename from src/qemu/qemu_audit.h
* src/Makefile.am: Remove qemu_audit.{c,h}, add domain_audit.{c,h}
* src/qemu/qemu_audit.h, src/qemu/qemu_cgroup.c,
src/qemu/qemu_command.c, src/qemu/qemu_driver.c,
src/qemu/qemu_hotplug.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c: Update for changed audit API names
2011-07-04 10:56:13 +00:00
|
|
|
virDomainAuditNet(vm, detach, NULL, "detach", false);
|
2010-12-16 16:10:54 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (qemuMonitorRemoveHostNetwork(priv->mon, vlan, hostnet_name) < 0) {
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
Move qemu_audit.h helpers into shared code
The LXC and UML drivers can both make use of auditing. Move
the qemu_audit.{c,h} files to src/conf/domain_audit.{c,h}
* src/conf/domain_audit.c: Rename from src/qemu/qemu_audit.c
* src/conf/domain_audit.h: Rename from src/qemu/qemu_audit.h
* src/Makefile.am: Remove qemu_audit.{c,h}, add domain_audit.{c,h}
* src/qemu/qemu_audit.h, src/qemu/qemu_cgroup.c,
src/qemu/qemu_command.c, src/qemu/qemu_driver.c,
src/qemu/qemu_hotplug.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c: Update for changed audit API names
2011-07-04 10:56:13 +00:00
|
|
|
virDomainAuditNet(vm, detach, NULL, "detach", false);
|
2010-12-16 16:10:54 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
|
Move qemu_audit.h helpers into shared code
The LXC and UML drivers can both make use of auditing. Move
the qemu_audit.{c,h} files to src/conf/domain_audit.{c,h}
* src/conf/domain_audit.c: Rename from src/qemu/qemu_audit.c
* src/conf/domain_audit.h: Rename from src/qemu/qemu_audit.h
* src/Makefile.am: Remove qemu_audit.{c,h}, add domain_audit.{c,h}
* src/qemu/qemu_audit.h, src/qemu/qemu_cgroup.c,
src/qemu/qemu_command.c, src/qemu/qemu_driver.c,
src/qemu/qemu_hotplug.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c: Update for changed audit API names
2011-07-04 10:56:13 +00:00
|
|
|
virDomainAuditNet(vm, detach, NULL, "detach", true);
|
2010-12-16 16:10:54 +00:00
|
|
|
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
|
2011-05-23 07:43:35 +00:00
|
|
|
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
|
|
|
|
detach->info.addr.pci.slot) < 0)
|
2011-05-09 09:24:09 +00:00
|
|
|
VIR_WARN("Unable to release PCI address on NIC");
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
virDomainConfNWFilterTeardown(detach);
|
|
|
|
|
|
|
|
#if WITH_MACVTAP
|
|
|
|
if (detach->type == VIR_DOMAIN_NET_TYPE_DIRECT) {
|
|
|
|
delMacvtap(detach->ifname, detach->mac, detach->data.direct.linkdev,
|
2011-06-21 15:49:40 +00:00
|
|
|
detach->data.direct.mode,
|
2011-07-18 22:44:38 +00:00
|
|
|
detach->data.direct.virtPortProfile,
|
2011-06-21 15:49:40 +00:00
|
|
|
driver->stateDir);
|
2010-12-16 16:10:54 +00:00
|
|
|
VIR_FREE(detach->ifname);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if ((driver->macFilter) && (detach->ifname != NULL)) {
|
|
|
|
if ((errno = networkDisallowMacOnPort(driver,
|
|
|
|
detach->ifname,
|
|
|
|
detach->mac))) {
|
|
|
|
virReportSystemError(errno,
|
|
|
|
_("failed to remove ebtables rule on '%s'"),
|
|
|
|
detach->ifname);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (vm->def->nnets > 1) {
|
|
|
|
memmove(vm->def->nets + i,
|
|
|
|
vm->def->nets + i + 1,
|
|
|
|
sizeof(*vm->def->nets) *
|
|
|
|
(vm->def->nnets - (i + 1)));
|
|
|
|
vm->def->nnets--;
|
|
|
|
if (VIR_REALLOC_N(vm->def->nets, vm->def->nnets) < 0) {
|
|
|
|
/* ignore, harmless */
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
VIR_FREE(vm->def->nets);
|
|
|
|
vm->def->nnets = 0;
|
|
|
|
}
|
|
|
|
virDomainNetDefFree(detach);
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
VIR_FREE(hostnet_name);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int qemuDomainDetachHostPciDevice(struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
2011-05-04 12:09:09 +00:00
|
|
|
virDomainDeviceDefPtr dev)
|
2010-12-16 16:10:54 +00:00
|
|
|
{
|
|
|
|
virDomainHostdevDefPtr detach = NULL;
|
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
|
|
|
int i, ret;
|
|
|
|
pciDevice *pci;
|
|
|
|
|
|
|
|
for (i = 0 ; i < vm->def->nhostdevs ; i++) {
|
|
|
|
if (vm->def->hostdevs[i]->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS ||
|
|
|
|
vm->def->hostdevs[i]->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
unsigned domain = vm->def->hostdevs[i]->source.subsys.u.pci.domain;
|
|
|
|
unsigned bus = vm->def->hostdevs[i]->source.subsys.u.pci.bus;
|
|
|
|
unsigned slot = vm->def->hostdevs[i]->source.subsys.u.pci.slot;
|
|
|
|
unsigned function = vm->def->hostdevs[i]->source.subsys.u.pci.function;
|
|
|
|
|
|
|
|
if (dev->data.hostdev->source.subsys.u.pci.domain == domain &&
|
|
|
|
dev->data.hostdev->source.subsys.u.pci.bus == bus &&
|
|
|
|
dev->data.hostdev->source.subsys.u.pci.slot == slot &&
|
|
|
|
dev->data.hostdev->source.subsys.u.pci.function == function) {
|
|
|
|
detach = vm->def->hostdevs[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!detach) {
|
|
|
|
qemuReportError(VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("host pci device %.4x:%.2x:%.2x.%.1x not found"),
|
|
|
|
dev->data.hostdev->source.subsys.u.pci.domain,
|
|
|
|
dev->data.hostdev->source.subsys.u.pci.bus,
|
|
|
|
dev->data.hostdev->source.subsys.u.pci.slot,
|
|
|
|
dev->data.hostdev->source.subsys.u.pci.function);
|
|
|
|
return -1;
|
2011-05-09 06:59:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (qemuIsMultiFunctionDevice(vm->def, &detach->info)) {
|
|
|
|
qemuReportError(VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("cannot hot unplug multifunction PCI device: %s"),
|
|
|
|
dev->data.disk->dst);
|
|
|
|
return -1;
|
2010-12-16 16:10:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!virDomainDeviceAddressIsValid(&detach->info,
|
|
|
|
VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)) {
|
|
|
|
qemuReportError(VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("device cannot be detached without a PCI address"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2011-06-30 09:23:50 +00:00
|
|
|
ignore_value(qemuDomainObjEnterMonitorWithDriver(driver, vm));
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
2011-02-23 23:15:23 +00:00
|
|
|
ret = qemuMonitorDelDevice(priv->mon, detach->info.alias);
|
2010-12-16 16:10:54 +00:00
|
|
|
} else {
|
2011-02-23 23:15:23 +00:00
|
|
|
ret = qemuMonitorRemovePCIDevice(priv->mon, &detach->info.addr.pci);
|
2010-12-16 16:10:54 +00:00
|
|
|
}
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
Move qemu_audit.h helpers into shared code
The LXC and UML drivers can both make use of auditing. Move
the qemu_audit.{c,h} files to src/conf/domain_audit.{c,h}
* src/conf/domain_audit.c: Rename from src/qemu/qemu_audit.c
* src/conf/domain_audit.h: Rename from src/qemu/qemu_audit.h
* src/Makefile.am: Remove qemu_audit.{c,h}, add domain_audit.{c,h}
* src/qemu/qemu_audit.h, src/qemu/qemu_cgroup.c,
src/qemu/qemu_command.c, src/qemu/qemu_driver.c,
src/qemu/qemu_hotplug.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c: Update for changed audit API names
2011-07-04 10:56:13 +00:00
|
|
|
virDomainAuditHostdev(vm, detach, "detach", ret == 0);
|
2011-02-23 23:15:23 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return -1;
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
pci = pciGetDevice(detach->source.subsys.u.pci.domain,
|
|
|
|
detach->source.subsys.u.pci.bus,
|
|
|
|
detach->source.subsys.u.pci.slot,
|
|
|
|
detach->source.subsys.u.pci.function);
|
|
|
|
if (!pci)
|
|
|
|
ret = -1;
|
|
|
|
else {
|
|
|
|
pciDeviceSetManaged(pci, detach->managed);
|
|
|
|
pciDeviceListDel(driver->activePciHostdevs, pci);
|
|
|
|
if (pciResetDevice(pci, driver->activePciHostdevs, NULL) < 0)
|
|
|
|
ret = -1;
|
|
|
|
qemuReattachPciDevice(pci, driver);
|
|
|
|
pciFreeDevice(pci);
|
|
|
|
}
|
|
|
|
|
2011-05-04 12:09:09 +00:00
|
|
|
if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
|
2011-05-23 07:43:35 +00:00
|
|
|
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
|
|
|
|
detach->info.addr.pci.slot) < 0)
|
2011-05-09 09:24:09 +00:00
|
|
|
VIR_WARN("Unable to release PCI address on host device");
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
if (vm->def->nhostdevs > 1) {
|
|
|
|
memmove(vm->def->hostdevs + i,
|
|
|
|
vm->def->hostdevs + i + 1,
|
|
|
|
sizeof(*vm->def->hostdevs) *
|
|
|
|
(vm->def->nhostdevs - (i + 1)));
|
|
|
|
vm->def->nhostdevs--;
|
|
|
|
if (VIR_REALLOC_N(vm->def->hostdevs, vm->def->nhostdevs) < 0) {
|
|
|
|
/* ignore, harmless */
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
VIR_FREE(vm->def->hostdevs);
|
|
|
|
vm->def->nhostdevs = 0;
|
|
|
|
}
|
|
|
|
virDomainHostdevDefFree(detach);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int qemuDomainDetachHostUsbDevice(struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
2011-05-04 12:09:09 +00:00
|
|
|
virDomainDeviceDefPtr dev)
|
2010-12-16 16:10:54 +00:00
|
|
|
{
|
|
|
|
virDomainHostdevDefPtr detach = NULL;
|
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
|
|
|
int i, ret;
|
|
|
|
|
|
|
|
for (i = 0 ; i < vm->def->nhostdevs ; i++) {
|
|
|
|
if (vm->def->hostdevs[i]->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS ||
|
|
|
|
vm->def->hostdevs[i]->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
unsigned bus = vm->def->hostdevs[i]->source.subsys.u.usb.bus;
|
|
|
|
unsigned device = vm->def->hostdevs[i]->source.subsys.u.usb.device;
|
|
|
|
unsigned product = vm->def->hostdevs[i]->source.subsys.u.usb.product;
|
|
|
|
unsigned vendor = vm->def->hostdevs[i]->source.subsys.u.usb.vendor;
|
|
|
|
|
|
|
|
if (dev->data.hostdev->source.subsys.u.usb.bus &&
|
|
|
|
dev->data.hostdev->source.subsys.u.usb.device) {
|
|
|
|
if (dev->data.hostdev->source.subsys.u.usb.bus == bus &&
|
|
|
|
dev->data.hostdev->source.subsys.u.usb.device == device) {
|
|
|
|
detach = vm->def->hostdevs[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (dev->data.hostdev->source.subsys.u.usb.product == product &&
|
|
|
|
dev->data.hostdev->source.subsys.u.usb.vendor == vendor) {
|
|
|
|
detach = vm->def->hostdevs[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!detach) {
|
|
|
|
qemuReportError(VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("host usb device %03d.%03d not found"),
|
|
|
|
dev->data.hostdev->source.subsys.u.usb.bus,
|
|
|
|
dev->data.hostdev->source.subsys.u.usb.device);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!detach->info.alias) {
|
|
|
|
qemuReportError(VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("device cannot be detached without a device alias"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2011-05-04 12:09:09 +00:00
|
|
|
if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
|
2010-12-16 16:10:54 +00:00
|
|
|
qemuReportError(VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("device cannot be detached with this QEMU version"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2011-06-30 09:23:50 +00:00
|
|
|
ignore_value(qemuDomainObjEnterMonitorWithDriver(driver, vm));
|
2011-02-23 23:15:23 +00:00
|
|
|
ret = qemuMonitorDelDevice(priv->mon, detach->info.alias);
|
2010-12-16 16:10:54 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
Move qemu_audit.h helpers into shared code
The LXC and UML drivers can both make use of auditing. Move
the qemu_audit.{c,h} files to src/conf/domain_audit.{c,h}
* src/conf/domain_audit.c: Rename from src/qemu/qemu_audit.c
* src/conf/domain_audit.h: Rename from src/qemu/qemu_audit.h
* src/Makefile.am: Remove qemu_audit.{c,h}, add domain_audit.{c,h}
* src/qemu/qemu_audit.h, src/qemu/qemu_cgroup.c,
src/qemu/qemu_command.c, src/qemu/qemu_driver.c,
src/qemu/qemu_hotplug.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c: Update for changed audit API names
2011-07-04 10:56:13 +00:00
|
|
|
virDomainAuditHostdev(vm, detach, "detach", ret == 0);
|
2011-02-23 23:15:23 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return -1;
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
if (vm->def->nhostdevs > 1) {
|
|
|
|
memmove(vm->def->hostdevs + i,
|
|
|
|
vm->def->hostdevs + i + 1,
|
|
|
|
sizeof(*vm->def->hostdevs) *
|
|
|
|
(vm->def->nhostdevs - (i + 1)));
|
|
|
|
vm->def->nhostdevs--;
|
|
|
|
if (VIR_REALLOC_N(vm->def->hostdevs, vm->def->nhostdevs) < 0) {
|
|
|
|
/* ignore, harmless */
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
VIR_FREE(vm->def->hostdevs);
|
|
|
|
vm->def->nhostdevs = 0;
|
|
|
|
}
|
|
|
|
virDomainHostdevDefFree(detach);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int qemuDomainDetachHostDevice(struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
2011-05-04 12:09:09 +00:00
|
|
|
virDomainDeviceDefPtr dev)
|
2010-12-16 16:10:54 +00:00
|
|
|
{
|
|
|
|
virDomainHostdevDefPtr hostdev = dev->data.hostdev;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
|
|
|
|
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
|
|
|
|
_("hostdev mode '%s' not supported"),
|
|
|
|
virDomainHostdevModeTypeToString(hostdev->mode));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (hostdev->source.subsys.type) {
|
|
|
|
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI:
|
2011-05-04 12:09:09 +00:00
|
|
|
ret = qemuDomainDetachHostPciDevice(driver, vm, dev);
|
2010-12-16 16:10:54 +00:00
|
|
|
break;
|
|
|
|
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB:
|
2011-05-04 12:09:09 +00:00
|
|
|
ret = qemuDomainDetachHostUsbDevice(driver, vm, dev);
|
2010-12-16 16:10:54 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
|
|
|
|
_("hostdev subsys type '%s' not supported"),
|
|
|
|
virDomainHostdevSubsysTypeToString(hostdev->source.subsys.type));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
Refactor the security drivers to simplify usage
The current security driver usage requires horrible code like
if (driver->securityDriver &&
driver->securityDriver->domainSetSecurityHostdevLabel &&
driver->securityDriver->domainSetSecurityHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
This pair of checks for NULL clutters up the code, making the driver
calls 2 lines longer than they really need to be. The goal of the
patchset is to change the calling convention to simply
if (virSecurityManagerSetHostdevLabel(driver->securityDriver,
vm, hostdev) < 0)
The first check for 'driver->securityDriver' being NULL is removed
by introducing a 'no op' security driver that will always be present
if no real driver is enabled. This guarentees driver->securityDriver
!= NULL.
The second check for 'driver->securityDriver->domainSetSecurityHostdevLabel'
being non-NULL is hidden in a new abstraction called virSecurityManager.
This separates the driver callbacks, from main internal API. The addition
of a virSecurityManager object, that is separate from the virSecurityDriver
struct also allows for security drivers to carry state / configuration
information directly. Thus the DAC/Stack drivers from src/qemu which
used to pull config from 'struct qemud_driver' can now be moved into
the 'src/security' directory and store their config directly.
* src/qemu/qemu_conf.h, src/qemu/qemu_driver.c: Update to
use new virSecurityManager APIs
* src/qemu/qemu_security_dac.c, src/qemu/qemu_security_dac.h
src/qemu/qemu_security_stacked.c, src/qemu/qemu_security_stacked.h:
Move into src/security directory
* src/security/security_stack.c, src/security/security_stack.h,
src/security/security_dac.c, src/security/security_dac.h: Generic
versions of previous QEMU specific drivers
* src/security/security_apparmor.c, src/security/security_apparmor.h,
src/security/security_driver.c, src/security/security_driver.h,
src/security/security_selinux.c, src/security/security_selinux.h:
Update to take virSecurityManagerPtr object as the first param
in all callbacks
* src/security/security_nop.c, src/security/security_nop.h: Stub
implementation of all security driver APIs.
* src/security/security_manager.h, src/security/security_manager.c:
New internal API for invoking security drivers
* src/libvirt.c: Add missing debug for security APIs
2010-11-17 20:26:30 +00:00
|
|
|
if (virSecurityManagerRestoreHostdevLabel(driver->securityManager,
|
|
|
|
vm, dev->data.hostdev) < 0)
|
2011-05-09 09:24:09 +00:00
|
|
|
VIR_WARN("Failed to restore host device labelling");
|
2010-12-16 16:10:54 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
Use the new set_password monitor command to set password.
We try to use that command first when setting a VNC/SPICE password. If
that doesn't work we fallback to the legacy VNC only password
Allow an expiry time to be set, if that doesn't work, throw an error
if they try to use SPICE.
Change since v1:
- moved qemuInitGraphicsPasswords to qemu_hotplug, renamed
to qemuDomainChangeGraphicsPasswords.
- updated what looks like a typo (that appears to work anyway) in
initial patch from Daniel:
- ret = qemuInitGraphicsPasswords(driver, vm,
- VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
- &vm->def->graphics[0]->data.vnc.auth,
- driver->vncPassword);
+ ret = qemuInitGraphicsPasswords(driver, vm,
+ VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
+ &vm->def->graphics[0]->data.spice.auth,
+ driver->spicePassword);
Based on patch by Daniel P. Berrange <berrange@redhat.com>.
2011-01-10 11:12:33 +00:00
|
|
|
|
|
|
|
int
|
|
|
|
qemuDomainChangeGraphicsPasswords(struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
int type,
|
|
|
|
virDomainGraphicsAuthDefPtr auth,
|
|
|
|
const char *defaultPasswd)
|
|
|
|
{
|
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
|
|
|
time_t now = time(NULL);
|
|
|
|
char expire_time [64];
|
2011-05-26 14:15:54 +00:00
|
|
|
const char *connected = NULL;
|
Use the new set_password monitor command to set password.
We try to use that command first when setting a VNC/SPICE password. If
that doesn't work we fallback to the legacy VNC only password
Allow an expiry time to be set, if that doesn't work, throw an error
if they try to use SPICE.
Change since v1:
- moved qemuInitGraphicsPasswords to qemu_hotplug, renamed
to qemuDomainChangeGraphicsPasswords.
- updated what looks like a typo (that appears to work anyway) in
initial patch from Daniel:
- ret = qemuInitGraphicsPasswords(driver, vm,
- VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
- &vm->def->graphics[0]->data.vnc.auth,
- driver->vncPassword);
+ ret = qemuInitGraphicsPasswords(driver, vm,
+ VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
+ &vm->def->graphics[0]->data.spice.auth,
+ driver->spicePassword);
Based on patch by Daniel P. Berrange <berrange@redhat.com>.
2011-01-10 11:12:33 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!auth->passwd && !driver->vncPassword)
|
|
|
|
return 0;
|
|
|
|
|
2011-05-26 14:15:54 +00:00
|
|
|
if (auth->connected)
|
|
|
|
connected = virDomainGraphicsAuthConnectedTypeToString(auth->connected);
|
|
|
|
|
2011-06-30 09:23:50 +00:00
|
|
|
ignore_value(qemuDomainObjEnterMonitorWithDriver(driver, vm));
|
Use the new set_password monitor command to set password.
We try to use that command first when setting a VNC/SPICE password. If
that doesn't work we fallback to the legacy VNC only password
Allow an expiry time to be set, if that doesn't work, throw an error
if they try to use SPICE.
Change since v1:
- moved qemuInitGraphicsPasswords to qemu_hotplug, renamed
to qemuDomainChangeGraphicsPasswords.
- updated what looks like a typo (that appears to work anyway) in
initial patch from Daniel:
- ret = qemuInitGraphicsPasswords(driver, vm,
- VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
- &vm->def->graphics[0]->data.vnc.auth,
- driver->vncPassword);
+ ret = qemuInitGraphicsPasswords(driver, vm,
+ VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
+ &vm->def->graphics[0]->data.spice.auth,
+ driver->spicePassword);
Based on patch by Daniel P. Berrange <berrange@redhat.com>.
2011-01-10 11:12:33 +00:00
|
|
|
ret = qemuMonitorSetPassword(priv->mon,
|
|
|
|
type,
|
|
|
|
auth->passwd ? auth->passwd : defaultPasswd,
|
2011-05-26 14:15:54 +00:00
|
|
|
connected);
|
Use the new set_password monitor command to set password.
We try to use that command first when setting a VNC/SPICE password. If
that doesn't work we fallback to the legacy VNC only password
Allow an expiry time to be set, if that doesn't work, throw an error
if they try to use SPICE.
Change since v1:
- moved qemuInitGraphicsPasswords to qemu_hotplug, renamed
to qemuDomainChangeGraphicsPasswords.
- updated what looks like a typo (that appears to work anyway) in
initial patch from Daniel:
- ret = qemuInitGraphicsPasswords(driver, vm,
- VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
- &vm->def->graphics[0]->data.vnc.auth,
- driver->vncPassword);
+ ret = qemuInitGraphicsPasswords(driver, vm,
+ VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
+ &vm->def->graphics[0]->data.spice.auth,
+ driver->spicePassword);
Based on patch by Daniel P. Berrange <berrange@redhat.com>.
2011-01-10 11:12:33 +00:00
|
|
|
|
|
|
|
if (ret == -2) {
|
|
|
|
if (type != VIR_DOMAIN_GRAPHICS_TYPE_VNC) {
|
|
|
|
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
|
2011-03-07 18:09:35 +00:00
|
|
|
_("Graphics password only supported for VNC"));
|
Use the new set_password monitor command to set password.
We try to use that command first when setting a VNC/SPICE password. If
that doesn't work we fallback to the legacy VNC only password
Allow an expiry time to be set, if that doesn't work, throw an error
if they try to use SPICE.
Change since v1:
- moved qemuInitGraphicsPasswords to qemu_hotplug, renamed
to qemuDomainChangeGraphicsPasswords.
- updated what looks like a typo (that appears to work anyway) in
initial patch from Daniel:
- ret = qemuInitGraphicsPasswords(driver, vm,
- VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
- &vm->def->graphics[0]->data.vnc.auth,
- driver->vncPassword);
+ ret = qemuInitGraphicsPasswords(driver, vm,
+ VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
+ &vm->def->graphics[0]->data.spice.auth,
+ driver->spicePassword);
Based on patch by Daniel P. Berrange <berrange@redhat.com>.
2011-01-10 11:12:33 +00:00
|
|
|
ret = -1;
|
|
|
|
} else {
|
|
|
|
ret = qemuMonitorSetVNCPassword(priv->mon,
|
|
|
|
auth->passwd ? auth->passwd : defaultPasswd);
|
|
|
|
}
|
|
|
|
}
|
2011-01-18 18:37:45 +00:00
|
|
|
if (ret != 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
Use the new set_password monitor command to set password.
We try to use that command first when setting a VNC/SPICE password. If
that doesn't work we fallback to the legacy VNC only password
Allow an expiry time to be set, if that doesn't work, throw an error
if they try to use SPICE.
Change since v1:
- moved qemuInitGraphicsPasswords to qemu_hotplug, renamed
to qemuDomainChangeGraphicsPasswords.
- updated what looks like a typo (that appears to work anyway) in
initial patch from Daniel:
- ret = qemuInitGraphicsPasswords(driver, vm,
- VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
- &vm->def->graphics[0]->data.vnc.auth,
- driver->vncPassword);
+ ret = qemuInitGraphicsPasswords(driver, vm,
+ VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
+ &vm->def->graphics[0]->data.spice.auth,
+ driver->spicePassword);
Based on patch by Daniel P. Berrange <berrange@redhat.com>.
2011-01-10 11:12:33 +00:00
|
|
|
if (auth->expires) {
|
|
|
|
time_t lifetime = auth->validTo - now;
|
|
|
|
if (lifetime <= 0)
|
|
|
|
snprintf(expire_time, sizeof (expire_time), "now");
|
|
|
|
else
|
|
|
|
snprintf(expire_time, sizeof (expire_time), "%lu", (long unsigned)auth->validTo);
|
|
|
|
} else {
|
|
|
|
snprintf(expire_time, sizeof (expire_time), "never");
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = qemuMonitorExpirePassword(priv->mon, type, expire_time);
|
|
|
|
|
|
|
|
if (ret == -2) {
|
|
|
|
/* XXX we could fake this with a timer */
|
|
|
|
if (auth->expires) {
|
|
|
|
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
|
|
|
|
_("Expiry of passwords is not supported"));
|
|
|
|
ret = -1;
|
2011-01-18 18:37:45 +00:00
|
|
|
} else {
|
|
|
|
ret = 0;
|
Use the new set_password monitor command to set password.
We try to use that command first when setting a VNC/SPICE password. If
that doesn't work we fallback to the legacy VNC only password
Allow an expiry time to be set, if that doesn't work, throw an error
if they try to use SPICE.
Change since v1:
- moved qemuInitGraphicsPasswords to qemu_hotplug, renamed
to qemuDomainChangeGraphicsPasswords.
- updated what looks like a typo (that appears to work anyway) in
initial patch from Daniel:
- ret = qemuInitGraphicsPasswords(driver, vm,
- VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
- &vm->def->graphics[0]->data.vnc.auth,
- driver->vncPassword);
+ ret = qemuInitGraphicsPasswords(driver, vm,
+ VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
+ &vm->def->graphics[0]->data.spice.auth,
+ driver->spicePassword);
Based on patch by Daniel P. Berrange <berrange@redhat.com>.
2011-01-10 11:12:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-01-18 18:37:45 +00:00
|
|
|
cleanup:
|
Use the new set_password monitor command to set password.
We try to use that command first when setting a VNC/SPICE password. If
that doesn't work we fallback to the legacy VNC only password
Allow an expiry time to be set, if that doesn't work, throw an error
if they try to use SPICE.
Change since v1:
- moved qemuInitGraphicsPasswords to qemu_hotplug, renamed
to qemuDomainChangeGraphicsPasswords.
- updated what looks like a typo (that appears to work anyway) in
initial patch from Daniel:
- ret = qemuInitGraphicsPasswords(driver, vm,
- VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
- &vm->def->graphics[0]->data.vnc.auth,
- driver->vncPassword);
+ ret = qemuInitGraphicsPasswords(driver, vm,
+ VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
+ &vm->def->graphics[0]->data.spice.auth,
+ driver->spicePassword);
Based on patch by Daniel P. Berrange <berrange@redhat.com>.
2011-01-10 11:12:33 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2011-05-18 16:20:53 +00:00
|
|
|
|
|
|
|
int qemuDomainAttachLease(struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
virDomainLeaseDefPtr lease)
|
|
|
|
{
|
|
|
|
if (virDomainLeaseInsertPreAlloc(vm->def) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (virDomainLockLeaseAttach(driver->lockManager, vm, lease) < 0) {
|
|
|
|
virDomainLeaseInsertPreAlloced(vm->def, NULL);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
virDomainLeaseInsertPreAlloced(vm->def, lease);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int qemuDomainDetachLease(struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
virDomainLeaseDefPtr lease)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if ((i = virDomainLeaseIndex(vm->def, lease)) < 0) {
|
|
|
|
qemuReportError(VIR_ERR_INVALID_ARG,
|
|
|
|
_("Lease %s in lockspace %s does not exist"),
|
|
|
|
lease->key, NULLSTR(lease->lockspace));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (virDomainLockLeaseDetach(driver->lockManager, vm, lease) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
virDomainLeaseRemoveAt(vm->def, i);
|
|
|
|
return 0;
|
|
|
|
}
|