diff --git a/libvirt-0.6.4-svirt-sound.patch b/libvirt-0.6.4-svirt-sound.patch
index 68cbf4d..5c209b4 100644
--- a/libvirt-0.6.4-svirt-sound.patch
+++ b/libvirt-0.6.4-svirt-sound.patch
@@ -1,4 +1,4 @@
-From f9355301cf4dda452308b616e8c00e59be5aec0a Mon Sep 17 00:00:00 2001
+From 1e99b2edee0eb3ca1c600e5bd5c55741cb95a29a Mon Sep 17 00:00:00 2001
From: Daniel P. Berrange <berrange@redhat.com>
Date: Mon, 17 Aug 2009 08:32:08 +0100
Subject: [PATCH] Disable sound cards when running sVirt
diff --git a/libvirt-add-pci-hostdev-hotplug-support.patch b/libvirt-add-pci-hostdev-hotplug-support.patch
new file mode 100644
index 0000000..203d3eb
--- /dev/null
+++ b/libvirt-add-pci-hostdev-hotplug-support.patch
@@ -0,0 +1,465 @@
+From 332979bb680d833529ab9cecac6828c6ce54d731 Mon Sep 17 00:00:00 2001
+From: Mark McLoughlin <markmc@redhat.com>
+Date: Fri, 14 Aug 2009 08:31:10 +0100
+Subject: [PATCH] Add host PCI device hotplug support
+
+Attaching a host PCI device to a qemu guest is done with a
+straightforward 'pci_add pci_addr auto host host=XX:XX.X' command.
+
+Like with NIC and disk hotplug, we need to retain the guest PCI address
+assigned by qemu so that we can use it for hot-unplug.
+
+Identifying a device for detach is done using the host PCI address.
+
+Managed mode is handled by detaching/resetting the device before
+attaching it to the guest and re-attaching it after detaching it from
+the guest.
+
+(cherry picked from commit 7636ef4630fc15c3d559eceb5b5c4fb1524b7c5a)
+(cherry picked from commit 0c5b7b93a3cdb197c55d79c2605e9e19e3af43f5)
+(cherry picked from commit 60ff07585ca8f7e639fed477e2e2cf79ce1c5c21)
+(cherry picked from commit 4e12af5623e4a962a6bb911af06fa29aa85befba)
+(cherry picked from commit 4dbecff9fbd5b5d1154bc7a41a5d4dd00533b359)
+(cherry picked from commit 12edef9a6aca5bd9a2ea18b73ca862f615684d84)
+(cherry picked from commit 457e05062863a35c7efb35470886b9b83a49d04d)
+(cherry picked from commit e8ad33931296c67de0538e78d12e21706a826d37)
+
+Fedora-patch: libvirt-add-pci-hostdev-hotplug-support.patch
+---
+ src/domain_conf.c | 33 +++++-
+ src/domain_conf.h | 13 +++
+ src/libvirt_private.syms | 2 +
+ src/qemu_driver.c | 266 ++++++++++++++++++++++++++++++++++++++++++++--
+ 4 files changed, 300 insertions(+), 14 deletions(-)
+
+diff --git a/src/domain_conf.c b/src/domain_conf.c
+index 2301a96..bad53f7 100644
+--- a/src/domain_conf.c
++++ b/src/domain_conf.c
+@@ -1977,7 +1977,8 @@ out:
+ static int
+ virDomainHostdevSubsysPciDefParseXML(virConnectPtr conn,
+ const xmlNodePtr node,
+- virDomainHostdevDefPtr def) {
++ virDomainHostdevDefPtr def,
++ int flags) {
+
+ int ret = -1;
+ xmlNodePtr cur;
+@@ -2049,6 +2050,20 @@ virDomainHostdevSubsysPciDefParseXML(virConnectPtr conn,
+ _("pci address needs function id"));
+ goto out;
+ }
++ } else if ((flags & VIR_DOMAIN_XML_INTERNAL_STATUS) &&
++ xmlStrEqual(cur->name, BAD_CAST "state")) {
++ char *devaddr = virXMLPropString(cur, "devaddr");
++ if (devaddr &&
++ sscanf(devaddr, "%x:%x:%x",
++ &def->source.subsys.u.pci.guest_addr.domain,
++ &def->source.subsys.u.pci.guest_addr.bus,
++ &def->source.subsys.u.pci.guest_addr.slot) < 3) {
++ virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
++ _("Unable to parse devaddr parameter '%s'"),
++ devaddr);
++ VIR_FREE(devaddr);
++ goto out;
++ }
+ } else {
+ virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
+ _("unknown pci source type '%s'"),
+@@ -2123,7 +2138,7 @@ virDomainHostdevDefParseXML(virConnectPtr conn,
+ }
+ if (def->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
+ def->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) {
+- if (virDomainHostdevSubsysPciDefParseXML(conn, cur, def) < 0)
++ if (virDomainHostdevSubsysPciDefParseXML(conn, cur, def, flags) < 0)
+ goto error;
+ }
+ } else {
+@@ -3937,7 +3952,8 @@ virDomainGraphicsDefFormat(virConnectPtr conn,
+ static int
+ virDomainHostdevDefFormat(virConnectPtr conn,
+ virBufferPtr buf,
+- virDomainHostdevDefPtr def)
++ virDomainHostdevDefPtr def,
++ int flags)
+ {
+ const char *mode = virDomainHostdevModeTypeToString(def->mode);
+ const char *type;
+@@ -3978,6 +3994,15 @@ virDomainHostdevDefFormat(virConnectPtr conn,
+ def->source.subsys.u.pci.bus,
+ def->source.subsys.u.pci.slot,
+ def->source.subsys.u.pci.function);
++ if (flags & VIR_DOMAIN_XML_INTERNAL_STATUS) {
++ virBufferAddLit(buf, " <state");
++ if (virHostdevHasValidGuestAddr(def))
++ virBufferVSprintf(buf, " devaddr='%.4x:%.2x:%.2x'",
++ def->source.subsys.u.pci.guest_addr.domain,
++ def->source.subsys.u.pci.guest_addr.bus,
++ def->source.subsys.u.pci.guest_addr.slot);
++ virBufferAddLit(buf, "/>\n");
++ }
+ }
+
+ virBufferAddLit(buf, " </source>\n");
+@@ -4192,7 +4217,7 @@ char *virDomainDefFormat(virConnectPtr conn,
+ goto cleanup;
+
+ for (n = 0 ; n < def->nhostdevs ; n++)
+- if (virDomainHostdevDefFormat(conn, &buf, def->hostdevs[n]) < 0)
++ if (virDomainHostdevDefFormat(conn, &buf, def->hostdevs[n], flags) < 0)
+ goto cleanup;
+
+ virBufferAddLit(&buf, " </devices>\n");
+diff --git a/src/domain_conf.h b/src/domain_conf.h
+index 63fca76..44302be 100644
+--- a/src/domain_conf.h
++++ b/src/domain_conf.h
+@@ -391,6 +391,11 @@ struct _virDomainHostdevDef {
+ unsigned bus;
+ unsigned slot;
+ unsigned function;
++ struct {
++ unsigned domain;
++ unsigned bus;
++ unsigned slot;
++ } guest_addr;
+ } pci;
+ } u;
+ } subsys;
+@@ -404,6 +409,14 @@ struct _virDomainHostdevDef {
+ char* target;
+ };
+
++static inline int
++virHostdevHasValidGuestAddr(virDomainHostdevDefPtr def)
++{
++ return def->source.subsys.u.pci.guest_addr.domain ||
++ def->source.subsys.u.pci.guest_addr.bus ||
++ def->source.subsys.u.pci.guest_addr.slot;
++}
++
+ /* Flags for the 'type' field in next struct */
+ enum virDomainDeviceType {
+ VIR_DOMAIN_DEVICE_DISK,
+diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
+index 4f1b01f..22131c4 100644
+--- a/src/libvirt_private.syms
++++ b/src/libvirt_private.syms
+@@ -88,6 +88,8 @@ virDomainGetRootFilesystem;
+ virDomainGraphicsTypeFromString;
+ virDomainGraphicsDefFree;
+ virDomainHostdevDefFree;
++virDomainHostdevModeTypeToString;
++virDomainHostdevSubsysTypeToString;
+ virDomainInputDefFree;
+ virDomainLifecycleTypeFromString;
+ virDomainLifecycleTypeToString;
+diff --git a/src/qemu_driver.c b/src/qemu_driver.c
+index cbc27c4..99dac52 100644
+--- a/src/qemu_driver.c
++++ b/src/qemu_driver.c
+@@ -5258,9 +5258,91 @@ cleanup:
+ return -1;
+ }
+
+-static int qemudDomainAttachHostDevice(virConnectPtr conn,
+- virDomainObjPtr vm,
+- virDomainDeviceDefPtr dev)
++static int qemudDomainAttachHostPciDevice(virConnectPtr conn,
++ struct qemud_driver *driver,
++ virDomainObjPtr vm,
++ virDomainDeviceDefPtr dev)
++{
++ virDomainHostdevDefPtr hostdev = dev->data.hostdev;
++ char *cmd, *reply;
++ unsigned domain, bus, slot;
++ pciDevice *pci;
++
++ if (VIR_REALLOC_N(vm->def->hostdevs, vm->def->nhostdevs+1) < 0) {
++ virReportOOMError(conn);
++ return -1;
++ }
++
++ pci = pciGetDevice(conn,
++ hostdev->source.subsys.u.pci.domain,
++ hostdev->source.subsys.u.pci.bus,
++ hostdev->source.subsys.u.pci.slot,
++ hostdev->source.subsys.u.pci.function);
++ if (!dev)
++ return -1;
++
++ if ((hostdev->managed && pciDettachDevice(conn, pci) < 0) ||
++ pciResetDevice(conn, pci, driver->activePciHostdevs) < 0) {
++ pciFreeDevice(conn, pci);
++ return -1;
++ }
++
++ if (pciDeviceListAdd(conn, driver->activePciHostdevs, pci) < 0) {
++ pciFreeDevice(conn, pci);
++ return -1;
++ }
++
++ cmd = reply = NULL;
++
++ if (virAsprintf(&cmd, "pci_add pci_addr=auto host host=%.2x:%.2x.%.1x",
++ hostdev->source.subsys.u.pci.bus,
++ hostdev->source.subsys.u.pci.slot,
++ hostdev->source.subsys.u.pci.function) < 0) {
++ virReportOOMError(conn);
++ goto error;
++ }
++
++ if (qemudMonitorCommand(vm, cmd, &reply) < 0) {
++ qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
++ "%s", _("cannot attach host pci device"));
++ goto error;
++ }
++
++ if (strstr(reply, "invalid type: host")) {
++ qemudReportError(conn, dom, NULL, VIR_ERR_NO_SUPPORT, "%s",
++ _("PCI device assignment is not supported by this version of qemu"));
++ goto error;
++ }
++
++ if (qemudParsePciAddReply(vm, reply, &domain, &bus, &slot) < 0) {
++ qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
++ _("parsing pci_add reply failed: %s"), reply);
++ goto error;
++ }
++
++ hostdev->source.subsys.u.pci.guest_addr.domain = domain;
++ hostdev->source.subsys.u.pci.guest_addr.bus = bus;
++ hostdev->source.subsys.u.pci.guest_addr.slot = slot;
++
++ vm->def->hostdevs[vm->def->nhostdevs++] = hostdev;
++
++ VIR_FREE(reply);
++ VIR_FREE(cmd);
++
++ return 0;
++
++error:
++ pciDeviceListDel(conn, driver->activePciHostdevs, pci);
++
++ VIR_FREE(reply);
++ VIR_FREE(cmd);
++
++ return -1;
++}
++
++static int qemudDomainAttachHostUsbDevice(virConnectPtr conn,
++ virDomainObjPtr vm,
++ virDomainDeviceDefPtr dev)
+ {
+ int ret;
+ char *cmd, *reply;
+@@ -5310,6 +5392,36 @@ static int qemudDomainAttachHostDevice(virConnectPtr conn,
+ return 0;
+ }
+
++static int qemudDomainAttachHostDevice(virConnectPtr conn,
++ struct qemud_driver *driver,
++ virDomainObjPtr vm,
++ virDomainDeviceDefPtr dev)
++{
++ virDomainHostdevDefPtr hostdev = dev->data.hostdev;
++
++ if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
++ qemudReportError(conn, dom, NULL, VIR_ERR_NO_SUPPORT,
++ _("hostdev mode '%s' not supported"),
++ virDomainHostdevModeTypeToString(hostdev->mode));
++ return -1;
++ }
++
++ if (qemuDomainSetDeviceOwnership(conn, driver, dev, 0) < 0)
++ return -1;
++
++ switch (hostdev->source.subsys.type) {
++ case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI:
++ return qemudDomainAttachHostPciDevice(conn, driver, vm, dev);
++ case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB:
++ return qemudDomainAttachHostUsbDevice(conn, vm, dev);
++ default:
++ qemudReportError(conn, dom, NULL, VIR_ERR_NO_SUPPORT,
++ _("hostdev subsys type '%s' not supported"),
++ virDomainHostdevSubsysTypeToString(hostdev->source.subsys.type));
++ return -1;
++ }
++}
++
+ static int qemudDomainAttachDevice(virDomainPtr dom,
+ const char *xml) {
+ struct qemud_driver *driver = dom->conn->privateData;
+@@ -5411,13 +5523,8 @@ static int qemudDomainAttachDevice(virDomainPtr dom,
+ }
+ } else if (dev->type == VIR_DOMAIN_DEVICE_NET) {
+ ret = qemudDomainAttachNetDevice(dom->conn, driver, vm, dev, qemuCmdFlags);
+- } else if (dev->type == VIR_DOMAIN_DEVICE_HOSTDEV &&
+- dev->data.hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
+- dev->data.hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB) {
+- if (qemuDomainSetDeviceOwnership(dom->conn, driver, dev, 0) < 0)
+- goto cleanup;
+-
+- ret = qemudDomainAttachHostDevice(dom->conn, vm, dev);
++ } else if (dev->type == VIR_DOMAIN_DEVICE_HOSTDEV) {
++ ret = qemudDomainAttachHostDevice(dom->conn, driver, vm, dev);
+ } else {
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
+ _("device type '%s' cannot be attached"),
+@@ -5630,6 +5737,143 @@ cleanup:
+ return ret;
+ }
+
++static int qemudDomainDetachHostPciDevice(virConnectPtr conn,
++ struct qemud_driver *driver,
++ virDomainObjPtr vm,
++ virDomainDeviceDefPtr dev)
++{
++ virDomainHostdevDefPtr detach;
++ char *cmd, *reply;
++ int i, ret;
++ pciDevice *pci;
++
++ for (i = 0 ; i < vm->def->nhostdevs ; i++) {
++ 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) {
++ qemudReportError(conn, NULL, NULL, 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;
++ }
++
++ if (!virHostdevHasValidGuestAddr(detach)) {
++ qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
++ "%s", _("hostdev cannot be detached - device state missing"));
++ return -1;
++ }
++
++ if (virAsprintf(&cmd, "pci_del pci_addr=%.4x:%.2x:%.2x",
++ detach->source.subsys.u.pci.guest_addr.domain,
++ detach->source.subsys.u.pci.guest_addr.bus,
++ detach->source.subsys.u.pci.guest_addr.slot) < 0) {
++ virReportOOMError(conn);
++ return -1;
++ }
++
++ if (qemudMonitorCommand(vm, cmd, &reply) < 0) {
++ qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
++ "%s", _("cannot detach host pci device"));
++ VIR_FREE(cmd);
++ return -1;
++ }
++
++ DEBUG("%s: pci_del reply: %s", vm->def->name, reply);
++
++ /* If the command fails due to a wrong PCI address qemu prints
++ * 'invalid pci address'; nothing is printed on success */
++ if (strstr(reply, "Invalid pci address")) {
++ qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
++ _("failed to detach host pci device: invalid PCI address %.4x:%.2x:%.2x: %s"),
++ detach->source.subsys.u.pci.guest_addr.domain,
++ detach->source.subsys.u.pci.guest_addr.bus,
++ detach->source.subsys.u.pci.guest_addr.slot,
++ reply);
++ VIR_FREE(reply);
++ VIR_FREE(cmd);
++ return -1;
++ }
++
++ VIR_FREE(reply);
++ VIR_FREE(cmd);
++
++ ret = 0;
++
++ pci = pciGetDevice(conn,
++ 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 {
++ pciDeviceListDel(conn, driver->activePciHostdevs, pci);
++ if (pciResetDevice(conn, pci, driver->activePciHostdevs) < 0)
++ ret = -1;
++ if (detach->managed && pciReAttachDevice(conn, pci) < 0)
++ ret = -1;
++ pciFreeDevice(conn, pci);
++ }
++
++ if (i != --vm->def->nhostdevs)
++ memmove(&vm->def->hostdevs[i],
++ &vm->def->hostdevs[i+1],
++ sizeof(*vm->def->hostdevs) * (vm->def->nhostdevs-i));
++ if (VIR_REALLOC_N(vm->def->hostdevs, vm->def->nhostdevs) < 0) {
++ virReportOOMError(conn);
++ ret = -1;
++ }
++
++ return ret;
++}
++
++static int qemudDomainDetachHostDevice(virConnectPtr conn,
++ struct qemud_driver *driver,
++ virDomainObjPtr vm,
++ virDomainDeviceDefPtr dev)
++{
++ virDomainHostdevDefPtr hostdev = dev->data.hostdev;
++ int ret;
++
++ if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
++ qemudReportError(conn, dom, NULL, VIR_ERR_NO_SUPPORT,
++ _("hostdev mode '%s' not supported"),
++ virDomainHostdevModeTypeToString(hostdev->mode));
++ return -1;
++ }
++
++ switch (hostdev->source.subsys.type) {
++ case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI:
++ ret = qemudDomainDetachHostPciDevice(conn, driver, vm, dev);
++ break;
++ default:
++ qemudReportError(conn, dom, NULL, VIR_ERR_NO_SUPPORT,
++ _("hostdev subsys type '%s' not supported"),
++ virDomainHostdevSubsysTypeToString(hostdev->source.subsys.type));
++ return -1;
++ }
++
++ if (qemuDomainSetDeviceOwnership(conn, driver, dev, 1) < 0)
++ VIR_WARN0("Fail to restore disk device ownership");
++
++ return ret;
++}
++
+ static int qemudDomainDetachDevice(virDomainPtr dom,
+ const char *xml) {
+ struct qemud_driver *driver = dom->conn->privateData;
+@@ -5670,6 +5914,8 @@ static int qemudDomainDetachDevice(virDomainPtr dom,
+ VIR_WARN0("Fail to restore disk device ownership");
+ } else if (dev->type == VIR_DOMAIN_DEVICE_NET) {
+ ret = qemudDomainDetachNetDevice(dom->conn, vm, dev);
++ } else if (dev->type == VIR_DOMAIN_DEVICE_HOSTDEV) {
++ ret = qemudDomainDetachHostDevice(dom->conn, driver, vm, dev);
+ } else
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
+ "%s", _("only SCSI or virtio disk device can be detached dynamically"));
+--
+1.6.2.5
+
diff --git a/libvirt-add-space-to-nodedev-list-tree.patch b/libvirt-add-space-to-nodedev-list-tree.patch
new file mode 100644
index 0000000..fe88198
--- /dev/null
+++ b/libvirt-add-space-to-nodedev-list-tree.patch
@@ -0,0 +1,43 @@
+From 100eb35a80932cd9a162c38ecd2ab8b01894fb61 Mon Sep 17 00:00:00 2001
+From: Mark McLoughlin <markmc@redhat.com>
+Date: Mon, 17 Aug 2009 15:05:22 +0100
+Subject: [PATCH] Cosmetic change to 'virsh nodedev-list --tree' output
+
+Maybe it's just me, but I try to select an item from the tree using
+double-click and get annoyed when "+-" gets included in the selection.
+
+* src/virsh.c: add a space between "+-" and the node device name
+ in 'virsh nodedev-list --tree'
+
+(cherry picked from commit 097c818bf00b3777778ffc32fea3a6ed1e741e2b)
+
+Fedora-patch: libvirt-add-space-to-nodedev-list-tree.patch
+---
+ src/virsh.c | 4 +++-
+ 1 files changed, 3 insertions(+), 1 deletions(-)
+
+diff --git a/src/virsh.c b/src/virsh.c
+index 94c3c4e..2d0cf81 100644
+--- a/src/virsh.c
++++ b/src/virsh.c
+@@ -5370,6 +5370,8 @@ cmdNodeListDevicesPrint(vshControl *ctl,
+ if (depth && depth < MAX_DEPTH) {
+ indentBuf[indentIdx] = '+';
+ indentBuf[indentIdx+1] = '-';
++ indentBuf[indentIdx+2] = ' ';
++ indentBuf[indentIdx+3] = '\0';
+ }
+
+ /* Print this device */
+@@ -5398,7 +5400,7 @@ cmdNodeListDevicesPrint(vshControl *ctl,
+ /* If there is a child device, then print another blank line */
+ if (nextlastdev != -1) {
+ vshPrint(ctl, "%s", indentBuf);
+- vshPrint(ctl, " |\n");
++ vshPrint(ctl, " |\n");
+ }
+
+ /* Finally print all children */
+--
+1.6.2.5
+
diff --git a/libvirt-allow-pci-hostdev-reset-to-reset-other-devices.patch b/libvirt-allow-pci-hostdev-reset-to-reset-other-devices.patch
new file mode 100644
index 0000000..1e633b9
--- /dev/null
+++ b/libvirt-allow-pci-hostdev-reset-to-reset-other-devices.patch
@@ -0,0 +1,812 @@
+From 89eefbd116ae74c3a5cfcfc74a31a40b83c726c3 Mon Sep 17 00:00:00 2001
+From: Mark McLoughlin <markmc@redhat.com>
+Date: Mon, 17 Aug 2009 15:05:23 +0100
+Subject: [PATCH] Maintain a list of active PCI hostdevs and use it in pciResetDevice()
+
+https://bugzilla.redhat.com/499678
+
+First we add a pciDeviceList type and add a qemuGetPciHostDeviceList()
+function to build a list from a domain definition. Use this in
+prepare/re-attach to simplify things and eliminate the multiple
+pciGetDevice() calls.
+
+Then, as we start/shutdown guests we can add or delete devices as
+appropriate from a list of active devices.
+
+Finally, in pciReset(), we can use this to determine whether its safe to
+reset a device as a side effect of resetting another device.
+
+(cherry picked from commit 78675b228b76a83f83d64856bfb63b9e14c103a0)
+(cherry picked from commit e8ad33931296c67de0538e78d12e21706a826d37)
+
+Fedora-patch: libvirt-allow-pci-hostdev-reset-to-reset-other-devices.patch
+---
+ src/libvirt_private.syms | 7 +-
+ src/pci.c | 211 +++++++++++++++++++++++++++++++++--------
+ src/pci.h | 23 +++++-
+ src/qemu_conf.h | 3 +
+ src/qemu_driver.c | 237 +++++++++++++++++++++++++++-------------------
+ src/xen_unified.c | 2 +-
+ 6 files changed, 339 insertions(+), 144 deletions(-)
+
+diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
+index bd63692..4f1b01f 100644
+--- a/src/libvirt_private.syms
++++ b/src/libvirt_private.syms
+@@ -278,7 +278,12 @@ pciFreeDevice;
+ pciDettachDevice;
+ pciReAttachDevice;
+ pciResetDevice;
+-
++pciDeviceSetManaged;
++pciDeviceGetManaged;
++pciDeviceListNew;
++pciDeviceListFree;
++pciDeviceListAdd;
++pciDeviceListDel;
+
+ # qparams.h
+ qparam_get_query;
+diff --git a/src/pci.c b/src/pci.c
+index 74f7ef0..96e5d6d 100644
+--- a/src/pci.c
++++ b/src/pci.c
+@@ -63,6 +63,7 @@ struct _pciDevice {
+ unsigned pci_pm_cap_pos;
+ unsigned has_flr : 1;
+ unsigned has_pm_reset : 1;
++ unsigned managed : 1;
+ };
+
+ /* For virReportOOMError() and virReportSystemError() */
+@@ -225,7 +226,7 @@ pciWrite32(pciDevice *dev, unsigned pos, uint32_t val)
+ pciWrite(dev, pos, &buf[0], sizeof(buf));
+ }
+
+-typedef int (*pciIterPredicate)(pciDevice *, pciDevice *);
++typedef int (*pciIterPredicate)(pciDevice *, pciDevice *, void *);
+
+ /* Iterate over available PCI devices calling @predicate
+ * to compare each one to @dev.
+@@ -236,7 +237,8 @@ static int
+ pciIterDevices(virConnectPtr conn,
+ pciIterPredicate predicate,
+ pciDevice *dev,
+- pciDevice **matched)
++ pciDevice **matched,
++ void *data)
+ {
+ DIR *dir;
+ struct dirent *entry;
+@@ -254,7 +256,7 @@ pciIterDevices(virConnectPtr conn,
+
+ while ((entry = readdir(dir))) {
+ unsigned domain, bus, slot, function;
+- pciDevice *try;
++ pciDevice *check;
+
+ /* Ignore '.' and '..' */
+ if (entry->d_name[0] == '.')
+@@ -266,18 +268,18 @@ pciIterDevices(virConnectPtr conn,
+ continue;
+ }
+
+- try = pciGetDevice(conn, domain, bus, slot, function);
+- if (!try) {
++ check = pciGetDevice(conn, domain, bus, slot, function);
++ if (!check) {
+ ret = -1;
+ break;
+ }
+
+- if (predicate(try, dev)) {
+- VIR_DEBUG("%s %s: iter matched on %s", dev->id, dev->name, try->name);
+- *matched = try;
++ if (predicate(dev, check, data)) {
++ VIR_DEBUG("%s %s: iter matched on %s", dev->id, dev->name, check->name);
++ *matched = check;
+ break;
+ }
+- pciFreeDevice(conn, try);
++ pciFreeDevice(conn, check);
+ }
+ closedir(dir);
+ return ret;
+@@ -379,63 +381,70 @@ pciDetectPowerManagementReset(pciDevice *dev)
+ return 0;
+ }
+
+-/* Any devices other than the one supplied on the same domain/bus ? */
++/* Any active devices other than the one supplied on the same domain/bus ? */
+ static int
+-pciSharesBus(pciDevice *a, pciDevice *b)
++pciSharesBusWithActive(pciDevice *dev, pciDevice *check, void *data)
+ {
+- return
+- a->domain == b->domain &&
+- a->bus == b->bus &&
+- (a->slot != b->slot ||
+- a->function != b->function);
+-}
++ pciDeviceList *activeDevs = data;
+
+-static int
+-pciBusContainsOtherDevices(virConnectPtr conn, pciDevice *dev)
+-{
+- pciDevice *matched = NULL;
+- if (pciIterDevices(conn, pciSharesBus, dev, &matched) < 0)
+- return 1;
+- if (!matched)
++ if (dev->domain != check->domain ||
++ dev->bus != check->bus ||
++ (check->slot == check->slot &&
++ check->function == check->function))
++ return 0;
++
++ if (activeDevs && !pciDeviceListFind(activeDevs, check))
+ return 0;
+- pciFreeDevice(conn, matched);
++
+ return 1;
+ }
+
+-/* Is @a the parent of @b ? */
++static pciDevice *
++pciBusContainsActiveDevices(virConnectPtr conn,
++ pciDevice *dev,
++ pciDeviceList *activeDevs)
++{
++ pciDevice *active = NULL;
++ if (pciIterDevices(conn, pciSharesBusWithActive,
++ dev, &active, activeDevs) < 0)
++ return NULL;
++ return active;
++}
++
++/* Is @check the parent of @dev ? */
+ static int
+-pciIsParent(pciDevice *a, pciDevice *b)
++pciIsParent(pciDevice *dev, pciDevice *check, void *data ATTRIBUTE_UNUSED)
+ {
+ uint16_t device_class;
+ uint8_t header_type, secondary, subordinate;
+
+- if (a->domain != b->domain)
++ if (dev->domain != check->domain)
+ return 0;
+
+ /* Is it a bridge? */
+- device_class = pciRead16(a, PCI_CLASS_DEVICE);
++ device_class = pciRead16(check, PCI_CLASS_DEVICE);
+ if (device_class != PCI_CLASS_BRIDGE_PCI)
+ return 0;
+
+ /* Is it a plane? */
+- header_type = pciRead8(a, PCI_HEADER_TYPE);
++ header_type = pciRead8(check, PCI_HEADER_TYPE);
+ if ((header_type & PCI_HEADER_TYPE_MASK) != PCI_HEADER_TYPE_BRIDGE)
+ return 0;
+
+- secondary = pciRead8(a, PCI_SECONDARY_BUS);
+- subordinate = pciRead8(a, PCI_SUBORDINATE_BUS);
++ secondary = pciRead8(check, PCI_SECONDARY_BUS);
++ subordinate = pciRead8(check, PCI_SUBORDINATE_BUS);
+
+- VIR_DEBUG("%s %s: found parent device %s\n", b->id, b->name, a->name);
++ VIR_DEBUG("%s %s: found parent device %s\n", dev->id, dev->name, check->name);
+
+ /* No, it's superman! */
+- return (b->bus >= secondary && b->bus <= subordinate);
++ return (dev->bus >= secondary && dev->bus <= subordinate);
+ }
+
+ static pciDevice *
+ pciGetParentDevice(virConnectPtr conn, pciDevice *dev)
+ {
+ pciDevice *parent = NULL;
+- pciIterDevices(conn, pciIsParent, dev, &parent);
++ pciIterDevices(conn, pciIsParent, dev, &parent, NULL);
+ return parent;
+ }
+
+@@ -443,9 +452,11 @@ pciGetParentDevice(virConnectPtr conn, pciDevice *dev)
+ * devices behind a bus.
+ */
+ static int
+-pciTrySecondaryBusReset(virConnectPtr conn, pciDevice *dev)
++pciTrySecondaryBusReset(virConnectPtr conn,
++ pciDevice *dev,
++ pciDeviceList *activeDevs)
+ {
+- pciDevice *parent;
++ pciDevice *parent, *conflict;
+ uint8_t config_space[PCI_CONF_LEN];
+ uint16_t ctl;
+ int ret = -1;
+@@ -455,10 +466,10 @@ pciTrySecondaryBusReset(virConnectPtr conn, pciDevice *dev)
+ * In future, we could allow it so long as those devices
+ * are not in use by the host or other guests.
+ */
+- if (pciBusContainsOtherDevices(conn, dev)) {
++ if ((conflict = pciBusContainsActiveDevices(conn, dev, activeDevs))) {
+ pciReportError(conn, VIR_ERR_NO_SUPPORT,
+- _("Other devices on bus with %s, not doing bus reset"),
+- dev->name);
++ _("Active %s devices on bus with %s, not doing bus reset"),
++ conflict->name, dev->name);
+ return -1;
+ }
+
+@@ -572,10 +583,18 @@ pciInitDevice(virConnectPtr conn, pciDevice *dev)
+ }
+
+ int
+-pciResetDevice(virConnectPtr conn, pciDevice *dev)
++pciResetDevice(virConnectPtr conn,
++ pciDevice *dev,
++ pciDeviceList *activeDevs)
+ {
+ int ret = -1;
+
++ if (activeDevs && pciDeviceListFind(activeDevs, dev)) {
++ pciReportError(conn, VIR_ERR_INTERNAL_ERROR,
++ _("Not resetting active device %s"), dev->name);
++ return -1;
++ }
++
+ if (!dev->initted && pciInitDevice(conn, dev) < 0)
+ return -1;
+
+@@ -594,7 +613,7 @@ pciResetDevice(virConnectPtr conn, pciDevice *dev)
+
+ /* Bus reset is not an option with the root bus */
+ if (ret < 0 && dev->bus != 0)
+- ret = pciTrySecondaryBusReset(conn, dev);
++ ret = pciTrySecondaryBusReset(conn, dev, activeDevs);
+
+ if (ret < 0) {
+ virErrorPtr err = virGetLastError();
+@@ -890,8 +909,116 @@ pciGetDevice(virConnectPtr conn,
+ void
+ pciFreeDevice(virConnectPtr conn ATTRIBUTE_UNUSED, pciDevice *dev)
+ {
++ if (!dev)
++ return;
+ VIR_DEBUG("%s %s: freeing", dev->id, dev->name);
+ if (dev->fd >= 0)
+ close(dev->fd);
+ VIR_FREE(dev);
+ }
++
++void pciDeviceSetManaged(pciDevice *dev, unsigned managed)
++{
++ dev->managed = !!managed;
++}
++
++unsigned pciDeviceGetManaged(pciDevice *dev)
++{
++ return dev->managed;
++}
++
++pciDeviceList *
++pciDeviceListNew(virConnectPtr conn)
++{
++ pciDeviceList *list;
++
++ if (VIR_ALLOC(list) < 0) {
++ virReportOOMError(conn);
++ return NULL;
++ }
++
++ return list;
++}
++
++void
++pciDeviceListFree(virConnectPtr conn,
++ pciDeviceList *list)
++{
++ int i;
++
++ if (!list)
++ return;
++
++ for (i = 0; i < list->count; i++) {
++ pciFreeDevice(conn, list->devs[i]);
++ list->devs[i] = NULL;
++ }
++
++ list->count = 0;
++ VIR_FREE(list->devs);
++ VIR_FREE(list);
++}
++
++int
++pciDeviceListAdd(virConnectPtr conn,
++ pciDeviceList *list,
++ pciDevice *dev)
++{
++ if (pciDeviceListFind(list, dev)) {
++ pciReportError(conn, VIR_ERR_INTERNAL_ERROR,
++ _("Device %s is already in use"), dev->name);
++ return -1;
++ }
++
++ if (VIR_REALLOC_N(list->devs, list->count+1) < 0) {
++ virReportOOMError(conn);
++ return -1;
++ }
++
++ list->devs[list->count++] = dev;
++
++ return 0;
++}
++
++void
++pciDeviceListDel(virConnectPtr conn ATTRIBUTE_UNUSED,
++ pciDeviceList *list,
++ pciDevice *dev)
++{
++ int i;
++
++ for (i = 0; i < list->count; i++) {
++ if (list->devs[i]->domain != dev->domain ||
++ list->devs[i]->bus != dev->bus ||
++ list->devs[i]->slot != dev->slot ||
++ list->devs[i]->function != dev->function)
++ continue;
++
++ pciFreeDevice(conn, list->devs[i]);
++
++ if (i != --list->count)
++ memmove(&list->devs[i],
++ &list->devs[i+1],
++ sizeof(*list->devs) * (list->count-i));
++
++ if (VIR_REALLOC_N(list->devs, list->count) < 0) {
++ ; /* not fatal */
++ }
++
++ break;
++ }
++}
++
++pciDevice *
++pciDeviceListFind(pciDeviceList *list, pciDevice *dev)
++{
++ int i;
++
++ for (i = 0; i < list->count; i++)
++ if (list->devs[i]->domain == dev->domain &&
++ list->devs[i]->bus == dev->bus &&
++ list->devs[i]->slot == dev->slot &&
++ list->devs[i]->function == dev->function)
++ return list->devs[i];
++ return NULL;
++}
+diff --git a/src/pci.h b/src/pci.h
+index 47882ef..685b0af 100644
+--- a/src/pci.h
++++ b/src/pci.h
+@@ -27,6 +27,11 @@
+
+ typedef struct _pciDevice pciDevice;
+
++typedef struct {
++ unsigned count;
++ pciDevice **devs;
++} pciDeviceList;
++
+ pciDevice *pciGetDevice (virConnectPtr conn,
+ unsigned domain,
+ unsigned bus,
+@@ -39,6 +44,22 @@ int pciDettachDevice (virConnectPtr conn,
+ int pciReAttachDevice (virConnectPtr conn,
+ pciDevice *dev);
+ int pciResetDevice (virConnectPtr conn,
+- pciDevice *dev);
++ pciDevice *dev,
++ pciDeviceList *activeDevs);
++void pciDeviceSetManaged(pciDevice *dev,
++ unsigned managed);
++unsigned pciDeviceGetManaged(pciDevice *dev);
++
++pciDeviceList *pciDeviceListNew (virConnectPtr conn);
++void pciDeviceListFree (virConnectPtr conn,
++ pciDeviceList *list);
++int pciDeviceListAdd (virConnectPtr conn,
++ pciDeviceList *list,
++ pciDevice *dev);
++void pciDeviceListDel (virConnectPtr conn,
++ pciDeviceList *list,
++ pciDevice *dev);
++pciDevice * pciDeviceListFind (pciDeviceList *list,
++ pciDevice *dev);
+
+ #endif /* __VIR_PCI_H__ */
+diff --git a/src/qemu_conf.h b/src/qemu_conf.h
+index 517626a..ab9d5e1 100644
+--- a/src/qemu_conf.h
++++ b/src/qemu_conf.h
+@@ -35,6 +35,7 @@
+ #include "threads.h"
+ #include "security.h"
+ #include "cgroup.h"
++#include "pci.h"
+
+ #define qemudDebug(fmt, ...) do {} while(0)
+
+@@ -107,6 +108,8 @@ struct qemud_driver {
+
+ char *securityDriverName;
+ virSecurityDriverPtr securityDriver;
++
++ pciDeviceList *activePciHostdevs;
+ };
+
+
+diff --git a/src/qemu_driver.c b/src/qemu_driver.c
+index fd39fc2..cbc27c4 100644
+--- a/src/qemu_driver.c
++++ b/src/qemu_driver.c
+@@ -128,6 +128,9 @@ static int qemudDomainSetMemoryBalloon(virConnectPtr conn,
+ static int qemudDetectVcpuPIDs(virConnectPtr conn,
+ virDomainObjPtr vm);
+
++static int qemuUpdateActivePciHostdevs(struct qemud_driver *driver,
++ virDomainDefPtr def);
++
+ static struct qemud_driver *qemu_driver = NULL;
+
+ static int qemuCgroupControllerActive(struct qemud_driver *driver,
+@@ -320,6 +323,10 @@ qemuReconnectDomain(struct qemud_driver *driver,
+ goto error;
+ }
+
++ if (qemuUpdateActivePciHostdevs(driver, obj->def) < 0) {
++ goto error;
++ }
++
+ if (obj->def->seclabel.type == VIR_DOMAIN_SECLABEL_DYNAMIC &&
+ driver->securityDriver &&
+ driver->securityDriver->domainReserveSecurityLabel &&
+@@ -524,6 +531,9 @@ qemudStartup(int privileged) {
+ if ((qemu_driver->caps = qemudCapsInit(NULL)) == NULL)
+ goto out_of_memory;
+
++ if ((qemu_driver->activePciHostdevs = pciDeviceListNew(NULL)) == NULL)
++ goto error;
++
+ if (qemudLoadDriverConfig(qemu_driver, driverConf) < 0) {
+ goto error;
+ }
+@@ -648,6 +658,7 @@ qemudShutdown(void) {
+ return -1;
+
+ qemuDriverLock(qemu_driver);
++ pciDeviceListFree(NULL, qemu_driver->activePciHostdevs);
+ virCapabilitiesFree(qemu_driver->caps);
+
+ virDomainObjListFree(&qemu_driver->domains);
+@@ -1329,48 +1340,16 @@ static int qemudNextFreeVNCPort(struct qemud_driver *driver ATTRIBUTE_UNUSED) {
+ return -1;
+ }
+
+-static int qemuPrepareHostDevices(virConnectPtr conn,
+- virDomainDefPtr def) {
++static pciDeviceList *
++qemuGetPciHostDeviceList(virConnectPtr conn,
++ virDomainDefPtr def)
++{
++ pciDeviceList *list;
+ int i;
+
+- /* We have to use 2 loops here. *All* devices must
+- * be detached before we reset any of them, because
+- * in some cases you have to reset the whole PCI,
+- * which impacts all devices on it
+- */
+-
+- for (i = 0 ; i < def->nhostdevs ; i++) {
+- virDomainHostdevDefPtr hostdev = def->hostdevs[i];
+-
+- if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS)
+- continue;
+- if (hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI)
+- continue;
+-
+- if (hostdev->managed) {
+- pciDevice *dev = pciGetDevice(conn,
+- hostdev->source.subsys.u.pci.domain,
+- hostdev->source.subsys.u.pci.bus,
+- hostdev->source.subsys.u.pci.slot,
+- hostdev->source.subsys.u.pci.function);
+- if (!dev)
+- goto error;
+-
+- if (pciDettachDevice(conn, dev) < 0) {
+- pciFreeDevice(conn, dev);
+- goto error;
+- }
+-
+- pciFreeDevice(conn, dev);
+- } /* else {
+- XXX validate that non-managed device isn't in use, eg
+- by checking that device is either un-bound, or bound
+- to pci-stub.ko
+- } */
+- }
++ if (!(list = pciDeviceListNew(conn)))
++ return NULL;
+
+- /* Now that all the PCI hostdevs have be dettached, we can safely
+- * reset them */
+ for (i = 0 ; i < def->nhostdevs ; i++) {
+ virDomainHostdevDefPtr hostdev = def->hostdevs[i];
+ pciDevice *dev;
+@@ -1385,95 +1364,151 @@ static int qemuPrepareHostDevices(virConnectPtr conn,
+ hostdev->source.subsys.u.pci.bus,
+ hostdev->source.subsys.u.pci.slot,
+ hostdev->source.subsys.u.pci.function);
+- if (!dev)
+- goto error;
++ if (!dev) {
++ pciDeviceListFree(conn, list);
++ return NULL;
++ }
+
+- if (pciResetDevice(conn, dev) < 0) {
++ if (pciDeviceListAdd(conn, list, dev) < 0) {
+ pciFreeDevice(conn, dev);
+- goto error;
++ pciDeviceListFree(conn, list);
++ return NULL;
+ }
+
+- pciFreeDevice(conn, dev);
++ pciDeviceSetManaged(dev, hostdev->managed);
+ }
+
+- return 0;
++ return list;
++}
+
+-error:
+- return -1;
++static int
++qemuUpdateActivePciHostdevs(struct qemud_driver *driver,
++ virDomainDefPtr def)
++{
++ pciDeviceList *pcidevs;
++ int i, ret;
++
++ if (!def->nhostdevs)
++ return 0;
++
++ if (!(pcidevs = qemuGetPciHostDeviceList(NULL, def)))
++ return -1;
++
++ ret = 0;
++
++ for (i = 0; i < pcidevs->count; i++) {
++ if (pciDeviceListAdd(NULL,
++ driver->activePciHostdevs,
++ pcidevs->devs[i]) < 0) {
++ ret = -1;
++ break;
++ }
++ pcidevs->devs[i] = NULL;
++ }
++
++ pciDeviceListFree(NULL, pcidevs);
++ return ret;
+ }
+
+-static void
+-qemuDomainReAttachHostDevices(virConnectPtr conn, virDomainDefPtr def)
++static int
++qemuPrepareHostDevices(virConnectPtr conn,
++ struct qemud_driver *driver,
++ virDomainDefPtr def)
+ {
++ pciDeviceList *pcidevs;
+ int i;
+
+- /* Again 2 loops; reset all the devices before re-attach */
++ if (!def->nhostdevs)
++ return 0;
+
+- for (i = 0 ; i < def->nhostdevs ; i++) {
+- virDomainHostdevDefPtr hostdev = def->hostdevs[i];
+- pciDevice *dev;
++ if (!(pcidevs = qemuGetPciHostDeviceList(conn, def)))
++ return -1;
+
+- if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS)
+- continue;
+- if (hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI)
+- continue;
++ /* We have to use 3 loops here. *All* devices must
++ * be detached before we reset any of them, because
++ * in some cases you have to reset the whole PCI,
++ * which impacts all devices on it. Also, all devices
++ * must be reset before being marked as active.
++ */
+
+- dev = pciGetDevice(conn,
+- hostdev->source.subsys.u.pci.domain,
+- hostdev->source.subsys.u.pci.bus,
+- hostdev->source.subsys.u.pci.slot,
+- hostdev->source.subsys.u.pci.function);
+- if (!dev) {
+- virErrorPtr err = virGetLastError();
+- VIR_ERROR(_("Failed to allocate pciDevice: %s\n"),
+- err ? err->message : "");
+- virResetError(err);
+- continue;
+- }
++ /* XXX validate that non-managed device isn't in use, eg
++ * by checking that device is either un-bound, or bound
++ * to pci-stub.ko
++ */
+
+- if (pciResetDevice(conn, dev) < 0) {
+- virErrorPtr err = virGetLastError();
+- VIR_ERROR(_("Failed to reset PCI device: %s\n"),
+- err ? err->message : "");
+- virResetError(err);
+- }
++ for (i = 0; i < pcidevs->count; i++)
++ if (pciDeviceGetManaged(pcidevs->devs[i]) &&
++ pciDettachDevice(conn, pcidevs->devs[i]) < 0)
++ goto error;
++
++ /* Now that all the PCI hostdevs have be dettached, we can safely
++ * reset them */
++ for (i = 0; i < pcidevs->count; i++)
++ if (pciResetDevice(conn, pcidevs->devs[i],
++ driver->activePciHostdevs) < 0)
++ goto error;
+
+- pciFreeDevice(conn, dev);
++ /* Now mark all the devices as active */
++ for (i = 0; i < pcidevs->count; i++) {
++ if (pciDeviceListAdd(conn,
++ driver->activePciHostdevs,
++ pcidevs->devs[i]) < 0)
++ goto error;
++ pcidevs->devs[i] = NULL;
+ }
+
+- for (i = 0 ; i < def->nhostdevs ; i++) {
+- virDomainHostdevDefPtr hostdev = def->hostdevs[i];
+- pciDevice *dev;
++ pciDeviceListFree(conn, pcidevs);
++ return 0;
+
+- if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS)
+- continue;
+- if (hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI)
+- continue;
+- if (!hostdev->managed)
+- continue;
++error:
++ pciDeviceListFree(conn, pcidevs);
++ return -1;
++}
+
+- dev = pciGetDevice(conn,
+- hostdev->source.subsys.u.pci.domain,
+- hostdev->source.subsys.u.pci.bus,
+- hostdev->source.subsys.u.pci.slot,
+- hostdev->source.subsys.u.pci.function);
+- if (!dev) {
++static void
++qemuDomainReAttachHostDevices(virConnectPtr conn,
++ struct qemud_driver *driver,
++ virDomainDefPtr def)
++{
++ pciDeviceList *pcidevs;
++ int i;
++
++ if (!def->nhostdevs)
++ return;
++
++ if (!(pcidevs = qemuGetPciHostDeviceList(conn, def))) {
++ virErrorPtr err = virGetLastError();
++ VIR_ERROR(_("Failed to allocate pciDeviceList: %s\n"),
++ err ? err->message : "");
++ virResetError(err);
++ return;
++ }
++
++ /* Again 3 loops; mark all devices as inactive before reset
++ * them and reset all the devices before re-attach */
++
++ for (i = 0; i < pcidevs->count; i++)
++ pciDeviceListDel(conn, driver->activePciHostdevs, pcidevs->devs[i]);
++
++ for (i = 0; i < pcidevs->count; i++)
++ if (pciResetDevice(conn, pcidevs->devs[i],
++ driver->activePciHostdevs) < 0) {
+ virErrorPtr err = virGetLastError();
+- VIR_ERROR(_("Failed to allocate pciDevice: %s\n"),
++ VIR_ERROR(_("Failed to reset PCI device: %s\n"),
+ err ? err->message : "");
+ virResetError(err);
+- continue;
+ }
+
+- if (pciReAttachDevice(conn, dev) < 0) {
++ for (i = 0; i < pcidevs->count; i++)
++ if (pciDeviceGetManaged(pcidevs->devs[i]) &&
++ pciReAttachDevice(conn, pcidevs->devs[i]) < 0) {
+ virErrorPtr err = virGetLastError();
+ VIR_ERROR(_("Failed to re-attach PCI device: %s\n"),
+ err ? err->message : "");
+ virResetError(err);
+ }
+
+- pciFreeDevice(conn, dev);
+- }
++ pciDeviceListFree(conn, pcidevs);
+ }
+
+ static const char *const defaultDeviceACL[] = {
+@@ -2001,7 +2036,7 @@ static int qemudStartVMDaemon(virConnectPtr conn,
+ if (qemuSetupCgroup(conn, driver, vm) < 0)
+ goto cleanup;
+
+- if (qemuPrepareHostDevices(conn, vm->def) < 0)
++ if (qemuPrepareHostDevices(conn, driver, vm->def) < 0)
+ goto cleanup;
+
+ if (VIR_ALLOC(vm->monitor_chr) < 0) {
+@@ -2183,7 +2218,7 @@ static void qemudShutdownVMDaemon(virConnectPtr conn,
+ VIR_WARN("Failed to restore all device ownership for %s",
+ vm->def->name);
+
+- qemuDomainReAttachHostDevices(conn, vm->def);
++ qemuDomainReAttachHostDevices(conn, driver, vm->def);
+
+ retry:
+ if ((ret = qemuRemoveCgroup(conn, driver, vm)) < 0) {
+@@ -6791,6 +6826,7 @@ out:
+ static int
+ qemudNodeDeviceReset (virNodeDevicePtr dev)
+ {
++ struct qemud_driver *driver = dev->conn->privateData;
+ pciDevice *pci;
+ unsigned domain, bus, slot, function;
+ int ret = -1;
+@@ -6802,11 +6838,14 @@ qemudNodeDeviceReset (virNodeDevicePtr dev)
+ if (!pci)
+ return -1;
+
+- if (pciResetDevice(dev->conn, pci) < 0)
++ qemuDriverLock(driver);
++
++ if (pciResetDevice(dev->conn, pci, driver->activePciHostdevs) < 0)
+ goto out;
+
+ ret = 0;
+ out:
++ qemuDriverUnlock(driver);
+ pciFreeDevice(dev->conn, pci);
+ return ret;
+ }
+diff --git a/src/xen_unified.c b/src/xen_unified.c
+index f2ffc25..dfa9ca5 100644
+--- a/src/xen_unified.c
++++ b/src/xen_unified.c
+@@ -1641,7 +1641,7 @@ xenUnifiedNodeDeviceReset (virNodeDevicePtr dev)
+ if (!pci)
+ return -1;
+
+- if (pciResetDevice(dev->conn, pci) < 0)
++ if (pciResetDevice(dev->conn, pci, NULL) < 0)
+ goto out;
+
+ ret = 0;
+--
+1.6.2.5
+
diff --git a/libvirt-allow-pm-reset-on-multi-function-pci-devices.patch b/libvirt-allow-pm-reset-on-multi-function-pci-devices.patch
new file mode 100644
index 0000000..601165d
--- /dev/null
+++ b/libvirt-allow-pm-reset-on-multi-function-pci-devices.patch
@@ -0,0 +1,121 @@
+From 5aad00b08cadc4d9da8bffd3d255ffaac98d36dd Mon Sep 17 00:00:00 2001
+From: Mark McLoughlin <markmc@redhat.com>
+Date: Fri, 14 Aug 2009 08:31:11 +0100
+Subject: [PATCH] Allow PM reset on multi-function PCI devices
+
+https://bugzilla.redhat.com/515689
+
+It turns out that a PCI Power Management reset only affects individual
+functions, and not the whole device.
+
+The PCI Power Management spec talks about resetting the 'device' rather
+than the 'function', but Intel's Dexuan Cui informs me that it is
+actually a per-function reset.
+
+Also, Yu Zhao has added pci_pm_reset() to the kernel, and it doesn't
+reject multi-function devices, so it must be true! :-)
+
+(A side issue is that we could defer the PM reset to the kernel if we
+could detect that the kernel has PM reset support, but barring version
+number checks we don't have a way to detect that support)
+
+* src/pci.c: remove the pciDeviceContainsOtherFunctions() check from
+ pciTryPowerManagementReset() and prefer PM reset over bus reset
+ where both are available
+
+Cc: Cui, Dexuan <dexuan.cui@intel.com>
+Cc: Yu Zhao <yu.zhao@intel.com>
+
+(cherry picked from commit 64a6682b93a2a8aa38067a43979c9eaf993d2b41)
+
+Fedora-patch: libvirt-allow-pm-reset-on-multi-function-pci-devices.patch
+---
+ src/pci.c | 48 +++++++++---------------------------------------
+ 1 files changed, 9 insertions(+), 39 deletions(-)
+
+diff --git a/src/pci.c b/src/pci.c
+index 2dc2e1c..11b3e8b 100644
+--- a/src/pci.c
++++ b/src/pci.c
+@@ -402,29 +402,6 @@ pciBusContainsOtherDevices(virConnectPtr conn, pciDevice *dev)
+ return 1;
+ }
+
+-/* Any other functions on this device ? */
+-static int
+-pciSharesDevice(pciDevice *a, pciDevice *b)
+-{
+- return
+- a->domain == b->domain &&
+- a->bus == b->bus &&
+- a->slot == b->slot &&
+- a->function != b->function;
+-}
+-
+-static int
+-pciDeviceContainsOtherFunctions(virConnectPtr conn, pciDevice *dev)
+-{
+- pciDevice *matched = NULL;
+- if (pciIterDevices(conn, pciSharesDevice, dev, &matched) < 0)
+- return 1;
+- if (!matched)
+- return 0;
+- pciFreeDevice(conn, matched);
+- return 1;
+-}
+-
+ /* Is @a the parent of @b ? */
+ static int
+ pciIsParent(pciDevice *a, pciDevice *b)
+@@ -529,7 +506,7 @@ out:
+ * above we require the device supports a full internal reset.
+ */
+ static int
+-pciTryPowerManagementReset(virConnectPtr conn, pciDevice *dev)
++pciTryPowerManagementReset(virConnectPtr conn ATTRIBUTE_UNUSED, pciDevice *dev)
+ {
+ uint8_t config_space[PCI_CONF_LEN];
+ uint32_t ctl;
+@@ -537,16 +514,6 @@ pciTryPowerManagementReset(virConnectPtr conn, pciDevice *dev)
+ if (!dev->pci_pm_cap_pos)
+ return -1;
+
+- /* For now, we just refuse to do a power management reset
+- * if there are other functions on this device.
+- * In future, we could allow it so long as those functions
+- * are not in use by the host or other guests.
+- */
+- if (pciDeviceContainsOtherFunctions(conn, dev)) {
+- VIR_WARN("%s contains other functions, not resetting", dev->name);
+- return -1;
+- }
+-
+ /* Save and restore the device's config space. */
+ if (pciRead(dev, 0, &config_space[0], PCI_CONF_LEN) < 0) {
+ VIR_WARN("Failed to save PCI config space for %s", dev->name);
+@@ -604,14 +571,17 @@ pciResetDevice(virConnectPtr conn, pciDevice *dev)
+ if (dev->has_flr)
+ return 0;
+
++ /* If the device supports PCI power management reset,
++ * that's the next best thing because it only resets
++ * the function, not the whole device.
++ */
++ if (dev->has_pm_reset)
++ ret = pciTryPowerManagementReset(conn, dev);
++
+ /* Bus reset is not an option with the root bus */
+- if (dev->bus != 0)
++ if (ret < 0 && dev->bus != 0)
+ ret = pciTrySecondaryBusReset(conn, dev);
+
+- /* Next best option is a PCI power management reset */
+- if (ret < 0 && dev->has_pm_reset)
+- ret = pciTryPowerManagementReset(conn, dev);
+-
+ if (ret < 0)
+ pciReportError(conn, VIR_ERR_NO_SUPPORT,
+ _("No PCI reset capability available for %s"),
+--
+1.6.2.5
+
diff --git a/libvirt-fix-device-list-update-after-detach.patch b/libvirt-fix-device-list-update-after-detach.patch
new file mode 100644
index 0000000..76598d6
--- /dev/null
+++ b/libvirt-fix-device-list-update-after-detach.patch
@@ -0,0 +1,79 @@
+From 165fb333c9d954fec636dc0f1917ba50417478c0 Mon Sep 17 00:00:00 2001
+From: Mark McLoughlin <markmc@redhat.com>
+Date: Sat, 15 Aug 2009 19:38:15 +0100
+Subject: [PATCH] Fix list updating after disk/network hot-unplug
+
+The current code makes a poor effort at updating the device arrays after
+hot-unplug. Fix that and combine the two code paths into one.
+
+* src/qemu_driver.c: fix list updating in qemudDomainDetachNetDevice() and
+ qemudDomainDetachPciDiskDevice()
+
+(cherry picked from commit 4e12af5623e4a962a6bb911af06fa29aa85befba)
+
+Fedora-patch: libvirt-fix-device-list-update-after-detach.patch
+---
+ src/qemu_driver.c | 38 ++++++++++++++++++--------------------
+ 1 files changed, 18 insertions(+), 20 deletions(-)
+
+diff --git a/src/qemu_driver.c b/src/qemu_driver.c
+index bd58435..2c4fd6f 100644
+--- a/src/qemu_driver.c
++++ b/src/qemu_driver.c
+@@ -5404,18 +5404,17 @@ try_command:
+ goto cleanup;
+ }
+
+- if (vm->def->ndisks > 1) {
+- vm->def->disks[i] = vm->def->disks[--vm->def->ndisks];
+- if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks) < 0) {
+- virReportOOMError(conn);
+- goto cleanup;
+- }
+- qsort(vm->def->disks, vm->def->ndisks, sizeof(*vm->def->disks),
+- virDomainDiskQSort);
+- } else {
+- VIR_FREE(vm->def->disks[0]);
+- vm->def->ndisks = 0;
++ if (i != --vm->def->ndisks)
++ memmove(&vm->def->disks[i],
++ &vm->def->disks[i+1],
++ sizeof(*vm->def->disks) * (vm->def->ndisks-i));
++ if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks) < 0) {
++ virReportOOMError(conn);
++ goto cleanup;
+ }
++ qsort(vm->def->disks, vm->def->ndisks, sizeof(*vm->def->disks),
++ virDomainDiskQSort);
++
+ ret = 0;
+
+ cleanup:
+@@ -5503,16 +5502,15 @@ qemudDomainDetachNetDevice(virConnectPtr conn,
+
+ DEBUG("%s: host_net_remove reply: %s", vm->def->name, reply);
+
+- if (vm->def->nnets > 1) {
+- vm->def->nets[i] = vm->def->nets[--vm->def->nnets];
+- if (VIR_REALLOC_N(vm->def->nets, vm->def->nnets) < 0) {
+- virReportOOMError(conn);
+- goto cleanup;
+- }
+- } else {
+- VIR_FREE(vm->def->nets[0]);
+- vm->def->nnets = 0;
++ if (i != --vm->def->nnets)
++ memmove(&vm->def->nets[i],
++ &vm->def->nets[i+1],
++ sizeof(*vm->def->nets) * (vm->def->nnets-i));
++ if (VIR_REALLOC_N(vm->def->nets, vm->def->nnets) < 0) {
++ virReportOOMError(conn);
++ goto cleanup;
+ }
++
+ ret = 0;
+
+ cleanup:
+--
+1.6.2.5
+
diff --git a/libvirt-improve-pci-hostdev-reset-error-message.patch b/libvirt-improve-pci-hostdev-reset-error-message.patch
new file mode 100644
index 0000000..bda054b
--- /dev/null
+++ b/libvirt-improve-pci-hostdev-reset-error-message.patch
@@ -0,0 +1,141 @@
+From c8a9dbe131713de83bdc67c563c4ab149e32c489 Mon Sep 17 00:00:00 2001
+From: Mark McLoughlin <markmc@redhat.com>
+Date: Fri, 14 Aug 2009 08:31:11 +0100
+Subject: [PATCH] Improve PCI host device reset error message
+
+https://bugzilla.redhat.com/499678
+
+Currently, if we are unable to reset a PCI device we return a fairly
+generic 'No PCI reset capability available' error message.
+
+Fix that by returning an error from the individual reset messages and
+using that error to construct the higher level error mesage.
+
+* src/pci.c: set errors in pciTryPowerManagementReset() and
+ pciTrySecondaryBusReset() on failure; use those error messages
+ in pciResetDevice(), or explain that no reset support is available
+
+(cherry picked from commit ebea34185612c3b96d7d3bbd8b7c2ce6c9f4fe6f)
+
+Fedora-patch: libvirt-improve-pci-hostdev-reset-error-message.patch
+---
+ src/pci.c | 44 +++++++++++++++++++++++++++++++-------------
+ src/qemu_driver.c | 4 ++--
+ 2 files changed, 33 insertions(+), 15 deletions(-)
+
+diff --git a/src/pci.c b/src/pci.c
+index 11b3e8b..74f7ef0 100644
+--- a/src/pci.c
++++ b/src/pci.c
+@@ -456,15 +456,18 @@ pciTrySecondaryBusReset(virConnectPtr conn, pciDevice *dev)
+ * are not in use by the host or other guests.
+ */
+ if (pciBusContainsOtherDevices(conn, dev)) {
+- VIR_WARN("Other devices on bus with %s, not doing bus reset",
+- dev->name);
++ pciReportError(conn, VIR_ERR_NO_SUPPORT,
++ _("Other devices on bus with %s, not doing bus reset"),
++ dev->name);
+ return -1;
+ }
+
+ /* Find the parent bus */
+ parent = pciGetParentDevice(conn, dev);
+ if (!parent) {
+- VIR_WARN("Failed to find parent device for %s", dev->name);
++ pciReportError(conn, VIR_ERR_NO_SUPPORT,
++ _("Failed to find parent device for %s"),
++ dev->name);
+ return -1;
+ }
+
+@@ -475,7 +478,9 @@ pciTrySecondaryBusReset(virConnectPtr conn, pciDevice *dev)
+ * are multiple devices/functions
+ */
+ if (pciRead(dev, 0, config_space, PCI_CONF_LEN) < 0) {
+- VIR_WARN("Failed to save PCI config space for %s", dev->name);
++ pciReportError(conn, VIR_ERR_NO_SUPPORT,
++ _("Failed to save PCI config space for %s"),
++ dev->name);
+ goto out;
+ }
+
+@@ -492,9 +497,12 @@ pciTrySecondaryBusReset(virConnectPtr conn, pciDevice *dev)
+
+ usleep(200 * 1000); /* sleep 200ms */
+
+- if (pciWrite(dev, 0, config_space, PCI_CONF_LEN) < 0)
+- VIR_WARN("Failed to restore PCI config space for %s", dev->name);
+-
++ if (pciWrite(dev, 0, config_space, PCI_CONF_LEN) < 0) {
++ pciReportError(conn, VIR_ERR_NO_SUPPORT,
++ _("Failed to restore PCI config space for %s"),
++ dev->name);
++ goto out;
++ }
+ ret = 0;
+ out:
+ pciFreeDevice(conn, parent);
+@@ -516,7 +524,9 @@ pciTryPowerManagementReset(virConnectPtr conn ATTRIBUTE_UNUSED, pciDevice *dev)
+
+ /* Save and restore the device's config space. */
+ if (pciRead(dev, 0, &config_space[0], PCI_CONF_LEN) < 0) {
+- VIR_WARN("Failed to save PCI config space for %s", dev->name);
++ pciReportError(conn, VIR_ERR_NO_SUPPORT,
++ _("Failed to save PCI config space for %s"),
++ dev->name);
+ return -1;
+ }
+
+@@ -533,8 +543,12 @@ pciTryPowerManagementReset(virConnectPtr conn ATTRIBUTE_UNUSED, pciDevice *dev)
+
+ usleep(10 * 1000); /* sleep 10ms */
+
+- if (pciWrite(dev, 0, &config_space[0], PCI_CONF_LEN) < 0)
+- VIR_WARN("Failed to restore PCI config space for %s", dev->name);
++ if (pciWrite(dev, 0, &config_space[0], PCI_CONF_LEN) < 0) {
++ pciReportError(conn, VIR_ERR_NO_SUPPORT,
++ _("Failed to restore PCI config space for %s"),
++ dev->name);
++ return -1;
++ }
+
+ return 0;
+ }
+@@ -582,10 +596,14 @@ pciResetDevice(virConnectPtr conn, pciDevice *dev)
+ if (ret < 0 && dev->bus != 0)
+ ret = pciTrySecondaryBusReset(conn, dev);
+
+- if (ret < 0)
++ if (ret < 0) {
++ virErrorPtr err = virGetLastError();
+ pciReportError(conn, VIR_ERR_NO_SUPPORT,
+- _("No PCI reset capability available for %s"),
+- dev->name);
++ _("Unable to reset PCI device %s: %s"),
++ dev->name,
++ err ? err->message : _("no FLR, PM reset or bus reset available"));
++ }
++
+ return ret;
+ }
+
+diff --git a/src/qemu_driver.c b/src/qemu_driver.c
+index 4ce7a54..fd39fc2 100644
+--- a/src/qemu_driver.c
++++ b/src/qemu_driver.c
+@@ -1465,9 +1465,9 @@ qemuDomainReAttachHostDevices(virConnectPtr conn, virDomainDefPtr def)
+ continue;
+ }
+
+- if (pciDettachDevice(conn, dev) < 0) {
++ if (pciReAttachDevice(conn, dev) < 0) {
+ virErrorPtr err = virGetLastError();
+- VIR_ERROR(_("Failed to reset PCI device: %s\n"),
++ VIR_ERROR(_("Failed to re-attach PCI device: %s\n"),
+ err ? err->message : "");
+ virResetError(err);
+ }
+--
+1.6.2.5
+
diff --git a/libvirt-reattach-pci-hostdevs-after-guest-shutdown.patch b/libvirt-reattach-pci-hostdevs-after-guest-shutdown.patch
new file mode 100644
index 0000000..2c79a8c
--- /dev/null
+++ b/libvirt-reattach-pci-hostdevs-after-guest-shutdown.patch
@@ -0,0 +1,124 @@
+From 8f26acc66ca90eea67fd5e84be5a76e3b8aa7fbf Mon Sep 17 00:00:00 2001
+From: Mark McLoughlin <markmc@redhat.com>
+Date: Fri, 14 Aug 2009 08:31:11 +0100
+Subject: [PATCH] Reset and re-attach PCI host devices on guest shutdown
+
+https://bugzilla.redhat.com/499561
+
+When the guest shuts down, we should attempt to restore all PCI host
+devices to a sane state.
+
+In the case of managed hostdevs, we should reset and re-attach the
+devices. In the case of unmanaged hostdevs, we should just reset them.
+
+Note, KVM will already reset assigned devices when the guest shuts
+down using whatever means it can, so we are only doing it to cover the
+cases the kernel can't handle.
+
+* src/qemu_driver.c: add qemuDomainReAttachHostDevices() and call
+ it from qemudShutdownVMDaemon()
+
+(cherry picked from commit 4035152a8767e72fd4e26a91cb4d5afa75b72e61)
+
+Fedora-patch: libvirt-reattach-pci-hostdevs-after-guest-shutdown.patch
+---
+ src/qemu_driver.c | 76 +++++++++++++++++++++++++++++++++++++++++++++++++++++
+ 1 files changed, 76 insertions(+), 0 deletions(-)
+
+diff --git a/src/qemu_driver.c b/src/qemu_driver.c
+index 2c4fd6f..4ce7a54 100644
+--- a/src/qemu_driver.c
++++ b/src/qemu_driver.c
+@@ -1402,6 +1402,80 @@ error:
+ return -1;
+ }
+
++static void
++qemuDomainReAttachHostDevices(virConnectPtr conn, virDomainDefPtr def)
++{
++ int i;
++
++ /* Again 2 loops; reset all the devices before re-attach */
++
++ for (i = 0 ; i < def->nhostdevs ; i++) {
++ virDomainHostdevDefPtr hostdev = def->hostdevs[i];
++ pciDevice *dev;
++
++ if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS)
++ continue;
++ if (hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI)
++ continue;
++
++ dev = pciGetDevice(conn,
++ hostdev->source.subsys.u.pci.domain,
++ hostdev->source.subsys.u.pci.bus,
++ hostdev->source.subsys.u.pci.slot,
++ hostdev->source.subsys.u.pci.function);
++ if (!dev) {
++ virErrorPtr err = virGetLastError();
++ VIR_ERROR(_("Failed to allocate pciDevice: %s\n"),
++ err ? err->message : "");
++ virResetError(err);
++ continue;
++ }
++
++ if (pciResetDevice(conn, dev) < 0) {
++ virErrorPtr err = virGetLastError();
++ VIR_ERROR(_("Failed to reset PCI device: %s\n"),
++ err ? err->message : "");
++ virResetError(err);
++ }
++
++ pciFreeDevice(conn, dev);
++ }
++
++ for (i = 0 ; i < def->nhostdevs ; i++) {
++ virDomainHostdevDefPtr hostdev = def->hostdevs[i];
++ pciDevice *dev;
++
++ if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS)
++ continue;
++ if (hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI)
++ continue;
++ if (!hostdev->managed)
++ continue;
++
++ dev = pciGetDevice(conn,
++ hostdev->source.subsys.u.pci.domain,
++ hostdev->source.subsys.u.pci.bus,
++ hostdev->source.subsys.u.pci.slot,
++ hostdev->source.subsys.u.pci.function);
++ if (!dev) {
++ virErrorPtr err = virGetLastError();
++ VIR_ERROR(_("Failed to allocate pciDevice: %s\n"),
++ err ? err->message : "");
++ virResetError(err);
++ continue;
++ }
++
++ if (pciDettachDevice(conn, dev) < 0) {
++ virErrorPtr err = virGetLastError();
++ VIR_ERROR(_("Failed to reset PCI device: %s\n"),
++ err ? err->message : "");
++ virResetError(err);
++ }
++
++ pciFreeDevice(conn, dev);
++ }
++}
++
+ static const char *const defaultDeviceACL[] = {
+ "/dev/null", "/dev/full", "/dev/zero",
+ "/dev/random", "/dev/urandom",
+@@ -2109,6 +2183,8 @@ static void qemudShutdownVMDaemon(virConnectPtr conn,
+ VIR_WARN("Failed to restore all device ownership for %s",
+ vm->def->name);
+
++ qemuDomainReAttachHostDevices(conn, vm->def);
++
+ retry:
+ if ((ret = qemuRemoveCgroup(conn, driver, vm)) < 0) {
+ if (ret == -EBUSY && (retries++ < 5)) {
+--
+1.6.2.5
+
diff --git a/libvirt.spec b/libvirt.spec
index 56aa8dd..2df152d 100644
--- a/libvirt.spec
+++ b/libvirt.spec
@@ -96,6 +96,27 @@ Patch03: libvirt-0.7.0-policy-kit-rewrite.patch
# Log and ignore NUMA topology problems (rhbz #506590)
Patch04: libvirt-0.7.0-numa-ignore-fail.patch
+# Minor 'virsh nodedev-list --tree' annoyance, fix from upstream
+Patch05: libvirt-add-space-to-nodedev-list-tree.patch
+
+# Fixes list corruption after disk hot-unplug
+Patch06: libvirt-fix-device-list-update-after-detach.patch
+
+# Re-attach PCI host devices after guest shuts down (bug #499561)
+Patch07: libvirt-reattach-pci-hostdevs-after-guest-shutdown.patch
+
+# Allow PM reset on multi-function PCI devices (bug #515689)
+Patch08: libvirt-allow-pm-reset-on-multi-function-pci-devices.patch
+
+# Fix stupid PCI reset error message (#499678)
+Patch09: libvirt-improve-pci-hostdev-reset-error-message.patch
+
+# Allow PCI bus reset to reset other devices (#499678)
+Patch10: libvirt-allow-pci-hostdev-reset-to-reset-other-devices.patch
+
+# Add PCI host device hotplug support
+Patch11: libvirt-add-pci-hostdev-hotplug-support.patch
+
# Temporary hack till PulseAudio autostart problems are sorted
# out when SELinux enforcing (bz 486112)
Patch200: libvirt-0.6.4-svirt-sound.patch
@@ -281,6 +302,13 @@ of recent versions of Linux (and other OSes).
%patch02 -p1
%patch03 -p1
%patch04 -p1
+%patch05 -p1
+%patch06 -p1
+%patch07 -p1
+%patch08 -p1
+%patch09 -p1
+%patch10 -p1
+%patch11 -p1
%patch200 -p1
@@ -649,6 +677,15 @@ fi
%endif
%changelog
+* Wed Aug 19 2009 Mark McLoughlin <markmc@redhat.com> - 0.7.0-5
+- Add PCI host device hotplug support
+- Allow PCI bus reset to reset other devices (#499678)
+- Fix stupid PCI reset error message (bug #499678)
+- Allow PM reset on multi-function PCI devices (bug #515689)
+- Re-attach PCI host devices after guest shuts down (bug #499561)
+- Fix list corruption after disk hot-unplug
+- Fix minor 'virsh nodedev-list --tree' annoyance
+
* Thu Aug 13 2009 Daniel P. Berrange <berrange@redhat.com> - 0.7.0-4
- Rewrite policykit support (rhbz #499970)
- Log and ignore NUMA topology problems (rhbz #506590)