[PATCH 2/2] QEMU-AER: Qemu changes to support AER for VFIO-PCI devices

[PATCH 2/2] QEMU-AER: Qemu changes to support AER for VFIO-PCI devices

[Pandarathil, Vijaymohan R]

	- Create eventfd per vfio device assigned to a guest and register an
          event handler

	- This fd is passed to the vfio_pci driver through a new ioctl

	- When the device encounters an error, the eventfd is signaled
          and the qemu eventfd handler gets invoked.

	- In the handler decide what action to take. Current action taken
          is to terminate the guest.

Signed-off-by: Vijay Mohan Pandarathil <vijaymohan.pandarathil@hp.com>
---
 hw/vfio_pci.c              | 56 ++++++++++++++++++++++++++++++++++++++++++++++
 linux-headers/linux/vfio.h |  9 ++++++++
 2 files changed, 65 insertions(+)

diff --git a/hw/vfio_pci.c b/hw/vfio_pci.c
index 28c8303..9c3c28b 100644
--- a/hw/vfio_pci.c
+++ b/hw/vfio_pci.c
@@ -38,6 +38,7 @@
 #include "qemu/error-report.h"
 #include "qemu/queue.h"
 #include "qemu/range.h"
+#include "sysemu/sysemu.h"
 
 /* #define DEBUG_VFIO */
 #ifdef DEBUG_VFIO
@@ -130,6 +131,8 @@ typedef struct VFIODevice {
     QLIST_ENTRY(VFIODevice) next;
     struct VFIOGroup *group;
     bool reset_works;
+    EventNotifier errfd;
+    __u32 dev_info_flags;
 } VFIODevice;
 
 typedef struct VFIOGroup {
@@ -1805,6 +1808,8 @@ static int vfio_get_device(VFIOGroup *group, const char *name, VFIODevice *vdev)
     DPRINTF("Device %s flags: %u, regions: %u, irgs: %u\n", name,
             dev_info.flags, dev_info.num_regions, dev_info.num_irqs);
 
+    vdev->dev_info_flags = dev_info.flags;
+
     if (!(dev_info.flags & VFIO_DEVICE_FLAGS_PCI)) {
         error_report("vfio: Um, this isn't a PCI device\n");
         goto error;
@@ -1900,6 +1905,55 @@ static void vfio_put_device(VFIODevice *vdev)
     }
 }
 
+static void vfio_errfd_handler(void *opaque)
+{
+    VFIODevice *vdev = opaque;
+
+    if (!event_notifier_test_and_clear(&vdev->errfd)) {
+        return;
+    }
+
+    /*
+     * TBD. Retrieve the error details and decide what action
+     * needs to be taken. One of the actions could be to pass
+     * the error to the guest and have the guest driver recover
+     * the error. This requires that PCIe capabilities be
+     * exposed to the guest. At present, we just terminate the
+     * guest to contain the error.
+     */
+    error_report("%s(%04x:%02x:%02x.%x) "
+        "Unrecoverable error detected... Terminating guest\n",
+        __func__, vdev->host.domain, vdev->host.bus, vdev->host.slot,
+        vdev->host.function);
+
+    qemu_system_shutdown_request();
+    return;
+}
+
+static void vfio_register_errfd(VFIODevice *vdev)
+{
+    int32_t pfd;
+    int ret;
+
+    if (!(vdev->dev_info_flags & VFIO_DEVICE_FLAGS_AER_NOTIFY)) {
+        error_report("vfio: Warning: Error notification not supported for the device\n");
+        return;
+    }
+    if (event_notifier_init(&vdev->errfd, 0)) {
+        error_report("vfio: Warning: Unable to init event notifier for error detection\n");
+        return;
+    }
+    pfd = event_notifier_get_fd(&vdev->errfd);
+    qemu_set_fd_handler(pfd, vfio_errfd_handler, NULL, vdev);
+
+    ret = ioctl(vdev->fd, VFIO_DEVICE_SET_ERRFD, pfd);
+    if (ret) {
+        error_report("vfio: Warning: Failed to setup error fd: %d\n", ret);
+        qemu_set_fd_handler(pfd, NULL, NULL, vdev);
+        event_notifier_cleanup(&vdev->errfd);
+    }
+    return;
+}
 static int vfio_initfn(PCIDevice *pdev)
 {
     VFIODevice *pvdev, *vdev = DO_UPCAST(VFIODevice, pdev, pdev);
@@ -2010,6 +2064,8 @@ static int vfio_initfn(PCIDevice *pdev)
         }
     }
 
+    vfio_register_errfd(vdev);
+
     return 0;
 
 out_teardown:
diff --git a/linux-headers/linux/vfio.h b/linux-headers/linux/vfio.h
index 4758d1b..0ca4eeb 100644
--- a/linux-headers/linux/vfio.h
+++ b/linux-headers/linux/vfio.h
@@ -147,6 +147,7 @@ struct vfio_device_info {
 	__u32	flags;
 #define VFIO_DEVICE_FLAGS_RESET	(1 << 0)	/* Device supports reset */
 #define VFIO_DEVICE_FLAGS_PCI	(1 << 1)	/* vfio-pci device */
+#define VFIO_DEVICE_FLAGS_AER_NOTIFY (1 << 2)   /* Supports aer notification */
 	__u32	num_regions;	/* Max region index + 1 */
 	__u32	num_irqs;	/* Max IRQ index + 1 */
 };
@@ -288,6 +289,14 @@ struct vfio_irq_set {
  */
 #define VFIO_DEVICE_RESET		_IO(VFIO_TYPE, VFIO_BASE + 11)
 
+/**
+ * VFIO_DEVICE_SET_ERRFD - _IO(VFIO_TYPE, VFIO_BASE + 12)
+ *
+ * Pass the eventfd to the vfio-pci driver for signalling any device
+ * error notifications
+ */
+#define VFIO_DEVICE_SET_ERRFD           _IO(VFIO_TYPE, VFIO_BASE + 12)
+
 /*
  * The VFIO-PCI bus driver makes use of the following fixed region and
  * IRQ index mapping.  Unimplemented regions return a size of zero.
-- 
1.7.11.3

Re: [PATCH 2/2] QEMU-AER: Qemu changes to support AER for VFIO-PCI devices

[Alex Williamson]

On Wed, 2013-01-09 at 06:26 +0000, Pandarathil, Vijaymohan R wrote:
> 	- Create eventfd per vfio device assigned to a guest and register an
>           event handler
> 
> 	- This fd is passed to the vfio_pci driver through a new ioctl
> 
> 	- When the device encounters an error, the eventfd is signaled
>           and the qemu eventfd handler gets invoked.
> 
> 	- In the handler decide what action to take. Current action taken
>           is to terminate the guest.
> 
> Signed-off-by: Vijay Mohan Pandarathil <vijaymohan.pandarathil@hp.com>
> ---
>  hw/vfio_pci.c              | 56 ++++++++++++++++++++++++++++++++++++++++++++++
>  linux-headers/linux/vfio.h |  9 ++++++++
>  2 files changed, 65 insertions(+)
> 
> diff --git a/hw/vfio_pci.c b/hw/vfio_pci.c
> index 28c8303..9c3c28b 100644
> --- a/hw/vfio_pci.c
> +++ b/hw/vfio_pci.c
> @@ -38,6 +38,7 @@
>  #include "qemu/error-report.h"
>  #include "qemu/queue.h"
>  #include "qemu/range.h"
> +#include "sysemu/sysemu.h"
>  
>  /* #define DEBUG_VFIO */
>  #ifdef DEBUG_VFIO
> @@ -130,6 +131,8 @@ typedef struct VFIODevice {
>      QLIST_ENTRY(VFIODevice) next;
>      struct VFIOGroup *group;
>      bool reset_works;
> +    EventNotifier errfd;

Misleading name, it's an EventNotifier not an fd.

> +    __u32 dev_info_flags;
>  } VFIODevice;
>  
>  typedef struct VFIOGroup {
> @@ -1805,6 +1808,8 @@ static int vfio_get_device(VFIOGroup *group, const char *name, VFIODevice *vdev)
>      DPRINTF("Device %s flags: %u, regions: %u, irgs: %u\n", name,
>              dev_info.flags, dev_info.num_regions, dev_info.num_irqs);
>  
> +    vdev->dev_info_flags = dev_info.flags;
> +

We test the VFIO_DEVICE_FLAGS_RESET elsewhere by caching the bit into a
variable, why not do that here too?

>      if (!(dev_info.flags & VFIO_DEVICE_FLAGS_PCI)) {
>          error_report("vfio: Um, this isn't a PCI device\n");
>          goto error;
> @@ -1900,6 +1905,55 @@ static void vfio_put_device(VFIODevice *vdev)
>      }
>  }
>  
> +static void vfio_errfd_handler(void *opaque)
> +{
> +    VFIODevice *vdev = opaque;
> +
> +    if (!event_notifier_test_and_clear(&vdev->errfd)) {
> +        return;
> +    }
> +
> +    /*
> +     * TBD. Retrieve the error details and decide what action
> +     * needs to be taken. One of the actions could be to pass
> +     * the error to the guest and have the guest driver recover
> +     * the error. This requires that PCIe capabilities be
> +     * exposed to the guest. At present, we just terminate the
> +     * guest to contain the error.
> +     */
> +    error_report("%s(%04x:%02x:%02x.%x) "
> +        "Unrecoverable error detected... Terminating guest\n",
> +        __func__, vdev->host.domain, vdev->host.bus, vdev->host.slot,
> +        vdev->host.function);
> +
> +    qemu_system_shutdown_request();

I would have figured hw_error

> +    return;
> +}
> +
> +static void vfio_register_errfd(VFIODevice *vdev)
> +{
> +    int32_t pfd;

"pfd" is used elsewhere in vfio as "Pointer to FD", this is just a fd.

> +    int ret;
> +
> +    if (!(vdev->dev_info_flags & VFIO_DEVICE_FLAGS_AER_NOTIFY)) {
> +        error_report("vfio: Warning: Error notification not supported for the device\n");

This should probably just be a debug print.

> +        return;
> +    }
> +    if (event_notifier_init(&vdev->errfd, 0)) {
> +        error_report("vfio: Warning: Unable to init event notifier for error detection\n");
> +        return;
> +    }
> +    pfd = event_notifier_get_fd(&vdev->errfd);
> +    qemu_set_fd_handler(pfd, vfio_errfd_handler, NULL, vdev);
> +
> +    ret = ioctl(vdev->fd, VFIO_DEVICE_SET_ERRFD, pfd);
> +    if (ret) {
> +        error_report("vfio: Warning: Failed to setup error fd: %d\n", ret);
> +        qemu_set_fd_handler(pfd, NULL, NULL, vdev);
> +        event_notifier_cleanup(&vdev->errfd);
> +    }
> +    return;
> +}
>  static int vfio_initfn(PCIDevice *pdev)
>  {
>      VFIODevice *pvdev, *vdev = DO_UPCAST(VFIODevice, pdev, pdev);
> @@ -2010,6 +2064,8 @@ static int vfio_initfn(PCIDevice *pdev)
>          }
>      }
>  
> +    vfio_register_errfd(vdev);
> +

No cleanup in exitfn?!  Thanks,

Alex

>      return 0;
>  
>  out_teardown:
> diff --git a/linux-headers/linux/vfio.h b/linux-headers/linux/vfio.h
> index 4758d1b..0ca4eeb 100644
> --- a/linux-headers/linux/vfio.h
> +++ b/linux-headers/linux/vfio.h
> @@ -147,6 +147,7 @@ struct vfio_device_info {
>  	__u32	flags;
>  #define VFIO_DEVICE_FLAGS_RESET	(1 << 0)	/* Device supports reset */
>  #define VFIO_DEVICE_FLAGS_PCI	(1 << 1)	/* vfio-pci device */
> +#define VFIO_DEVICE_FLAGS_AER_NOTIFY (1 << 2)   /* Supports aer notification */
>  	__u32	num_regions;	/* Max region index + 1 */
>  	__u32	num_irqs;	/* Max IRQ index + 1 */
>  };
> @@ -288,6 +289,14 @@ struct vfio_irq_set {
>   */
>  #define VFIO_DEVICE_RESET		_IO(VFIO_TYPE, VFIO_BASE + 11)
>  
> +/**
> + * VFIO_DEVICE_SET_ERRFD - _IO(VFIO_TYPE, VFIO_BASE + 12)
> + *
> + * Pass the eventfd to the vfio-pci driver for signalling any device
> + * error notifications
> + */
> +#define VFIO_DEVICE_SET_ERRFD           _IO(VFIO_TYPE, VFIO_BASE + 12)
> +
>  /*
>   * The VFIO-PCI bus driver makes use of the following fixed region and
>   * IRQ index mapping.  Unimplemented regions return a size of zero.

Re: [Qemu-devel] [PATCH 2/2] QEMU-AER: Qemu changes to support AER for VFIO-PCI devices

[Blue Swirl]

On Wed, Jan 9, 2013 at 6:26 AM, Pandarathil, Vijaymohan R
<vijaymohan.pandarathil@hp.com> wrote:
>         - Create eventfd per vfio device assigned to a guest and register an
>           event handler
>
>         - This fd is passed to the vfio_pci driver through a new ioctl
>
>         - When the device encounters an error, the eventfd is signaled
>           and the qemu eventfd handler gets invoked.
>
>         - In the handler decide what action to take. Current action taken
>           is to terminate the guest.
>
> Signed-off-by: Vijay Mohan Pandarathil <vijaymohan.pandarathil@hp.com>
> ---
>  hw/vfio_pci.c              | 56 ++++++++++++++++++++++++++++++++++++++++++++++
>  linux-headers/linux/vfio.h |  9 ++++++++
>  2 files changed, 65 insertions(+)
>
> diff --git a/hw/vfio_pci.c b/hw/vfio_pci.c
> index 28c8303..9c3c28b 100644
> --- a/hw/vfio_pci.c
> +++ b/hw/vfio_pci.c
> @@ -38,6 +38,7 @@
>  #include "qemu/error-report.h"
>  #include "qemu/queue.h"
>  #include "qemu/range.h"
> +#include "sysemu/sysemu.h"
>
>  /* #define DEBUG_VFIO */
>  #ifdef DEBUG_VFIO
> @@ -130,6 +131,8 @@ typedef struct VFIODevice {
>      QLIST_ENTRY(VFIODevice) next;
>      struct VFIOGroup *group;
>      bool reset_works;
> +    EventNotifier errfd;
> +    __u32 dev_info_flags;

QEMU is not kernel code, please use uint32_t.

>  } VFIODevice;
>
>  typedef struct VFIOGroup {
> @@ -1805,6 +1808,8 @@ static int vfio_get_device(VFIOGroup *group, const char *name, VFIODevice *vdev)
>      DPRINTF("Device %s flags: %u, regions: %u, irgs: %u\n", name,
>              dev_info.flags, dev_info.num_regions, dev_info.num_irqs);
>
> +    vdev->dev_info_flags = dev_info.flags;
> +
>      if (!(dev_info.flags & VFIO_DEVICE_FLAGS_PCI)) {
>          error_report("vfio: Um, this isn't a PCI device\n");
>          goto error;
> @@ -1900,6 +1905,55 @@ static void vfio_put_device(VFIODevice *vdev)
>      }
>  }
>
> +static void vfio_errfd_handler(void *opaque)
> +{
> +    VFIODevice *vdev = opaque;
> +
> +    if (!event_notifier_test_and_clear(&vdev->errfd)) {
> +        return;
> +    }
> +
> +    /*
> +     * TBD. Retrieve the error details and decide what action
> +     * needs to be taken. One of the actions could be to pass
> +     * the error to the guest and have the guest driver recover
> +     * the error. This requires that PCIe capabilities be
> +     * exposed to the guest. At present, we just terminate the
> +     * guest to contain the error.
> +     */
> +    error_report("%s(%04x:%02x:%02x.%x) "
> +        "Unrecoverable error detected... Terminating guest\n",
> +        __func__, vdev->host.domain, vdev->host.bus, vdev->host.slot,
> +        vdev->host.function);
> +
> +    qemu_system_shutdown_request();
> +    return;
> +}
> +
> +static void vfio_register_errfd(VFIODevice *vdev)
> +{
> +    int32_t pfd;
> +    int ret;
> +
> +    if (!(vdev->dev_info_flags & VFIO_DEVICE_FLAGS_AER_NOTIFY)) {
> +        error_report("vfio: Warning: Error notification not supported for the device\n");
> +        return;
> +    }
> +    if (event_notifier_init(&vdev->errfd, 0)) {
> +        error_report("vfio: Warning: Unable to init event notifier for error detection\n");
> +        return;
> +    }
> +    pfd = event_notifier_get_fd(&vdev->errfd);
> +    qemu_set_fd_handler(pfd, vfio_errfd_handler, NULL, vdev);
> +
> +    ret = ioctl(vdev->fd, VFIO_DEVICE_SET_ERRFD, pfd);
> +    if (ret) {
> +        error_report("vfio: Warning: Failed to setup error fd: %d\n", ret);
> +        qemu_set_fd_handler(pfd, NULL, NULL, vdev);
> +        event_notifier_cleanup(&vdev->errfd);
> +    }
> +    return;
> +}
>  static int vfio_initfn(PCIDevice *pdev)
>  {
>      VFIODevice *pvdev, *vdev = DO_UPCAST(VFIODevice, pdev, pdev);
> @@ -2010,6 +2064,8 @@ static int vfio_initfn(PCIDevice *pdev)
>          }
>      }
>
> +    vfio_register_errfd(vdev);
> +
>      return 0;
>
>  out_teardown:
> diff --git a/linux-headers/linux/vfio.h b/linux-headers/linux/vfio.h
> index 4758d1b..0ca4eeb 100644
> --- a/linux-headers/linux/vfio.h
> +++ b/linux-headers/linux/vfio.h
> @@ -147,6 +147,7 @@ struct vfio_device_info {
>         __u32   flags;
>  #define VFIO_DEVICE_FLAGS_RESET        (1 << 0)        /* Device supports reset */
>  #define VFIO_DEVICE_FLAGS_PCI  (1 << 1)        /* vfio-pci device */
> +#define VFIO_DEVICE_FLAGS_AER_NOTIFY (1 << 2)   /* Supports aer notification */
>         __u32   num_regions;    /* Max region index + 1 */
>         __u32   num_irqs;       /* Max IRQ index + 1 */

These are verbatim copies of kernel headers so it's OK here.

>  };
> @@ -288,6 +289,14 @@ struct vfio_irq_set {
>   */
>  #define VFIO_DEVICE_RESET              _IO(VFIO_TYPE, VFIO_BASE + 11)
>
> +/**
> + * VFIO_DEVICE_SET_ERRFD - _IO(VFIO_TYPE, VFIO_BASE + 12)
> + *
> + * Pass the eventfd to the vfio-pci driver for signalling any device
> + * error notifications
> + */
> +#define VFIO_DEVICE_SET_ERRFD           _IO(VFIO_TYPE, VFIO_BASE + 12)
> +
>  /*
>   * The VFIO-PCI bus driver makes use of the following fixed region and
>   * IRQ index mapping.  Unimplemented regions return a size of zero.
> --
> 1.7.11.3
>
>

RE: [PATCH 2/2] QEMU-AER: Qemu changes to support AER for VFIO-PCI devices

[Pandarathil, Vijaymohan R]
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RE: [Qemu-devel] [PATCH 2/2] QEMU-AER: Qemu changes to support AER for VFIO-PCI devices

[Pandarathil, Vijaymohan R]

DQoNCj4gLS0tLS1PcmlnaW5hbCBNZXNzYWdlLS0tLS0NCj4gRnJvbTogQmx1ZSBTd2lybCBbbWFp
bHRvOmJsYXV3aXJiZWxAZ21haWwuY29tXQ0KPiBTZW50OiBXZWRuZXNkYXksIEphbnVhcnkgMDks
IDIwMTMgMToyMyBQTQ0KPiBUbzogUGFuZGFyYXRoaWwsIFZpamF5bW9oYW4gUg0KPiBDYzogQWxl
eCBXaWxsaWFtc29uOyBCam9ybiBIZWxnYWFzOyBHbGViIE5hdGFwb3Y7IGxpbnV4LQ0KPiBwY2lA
dmdlci5rZXJuZWwub3JnOyBxZW11LWRldmVsQG5vbmdudS5vcmc7IGt2bUB2Z2VyLmtlcm5lbC5v
cmc7IGxpbnV4LQ0KPiBrZXJuZWxAdmdlci5rZXJuZWwub3JnDQo+IFN1YmplY3Q6IFJlOiBbUWVt
dS1kZXZlbF0gW1BBVENIIDIvMl0gUUVNVS1BRVI6IFFlbXUgY2hhbmdlcyB0byBzdXBwb3J0IEFF
Ug0KPiBmb3IgVkZJTy1QQ0kgZGV2aWNlcw0KPiANCj4gT24gV2VkLCBKYW4gOSwgMjAxMyBhdCA2
OjI2IEFNLCBQYW5kYXJhdGhpbCwgVmlqYXltb2hhbiBSDQo+IDx2aWpheW1vaGFuLnBhbmRhcmF0
aGlsQGhwLmNvbT4gd3JvdGU6DQo+ID4gICAgICAgICAtIENyZWF0ZSBldmVudGZkIHBlciB2Zmlv
IGRldmljZSBhc3NpZ25lZCB0byBhIGd1ZXN0IGFuZCByZWdpc3Rlcg0KPiBhbg0KPiA+ICAgICAg
ICAgICBldmVudCBoYW5kbGVyDQo+ID4NCj4gPiAgICAgICAgIC0gVGhpcyBmZCBpcyBwYXNzZWQg
dG8gdGhlIHZmaW9fcGNpIGRyaXZlciB0aHJvdWdoIGEgbmV3IGlvY3RsDQo+ID4NCj4gPiAgICAg
ICAgIC0gV2hlbiB0aGUgZGV2aWNlIGVuY291bnRlcnMgYW4gZXJyb3IsIHRoZSBldmVudGZkIGlz
IHNpZ25hbGVkDQo+ID4gICAgICAgICAgIGFuZCB0aGUgcWVtdSBldmVudGZkIGhhbmRsZXIgZ2V0
cyBpbnZva2VkLg0KPiA+DQo+ID4gICAgICAgICAtIEluIHRoZSBoYW5kbGVyIGRlY2lkZSB3aGF0
IGFjdGlvbiB0byB0YWtlLiBDdXJyZW50IGFjdGlvbiB0YWtlbg0KPiA+ICAgICAgICAgICBpcyB0
byB0ZXJtaW5hdGUgdGhlIGd1ZXN0Lg0KPiA+DQo+ID4gU2lnbmVkLW9mZi1ieTogVmlqYXkgTW9o
YW4gUGFuZGFyYXRoaWwgPHZpamF5bW9oYW4ucGFuZGFyYXRoaWxAaHAuY29tPg0KPiA+IC0tLQ0K
PiA+ICBody92ZmlvX3BjaS5jICAgICAgICAgICAgICB8IDU2DQo+ICsrKysrKysrKysrKysrKysr
KysrKysrKysrKysrKysrKysrKysrKysrKysrKysNCj4gPiAgbGludXgtaGVhZGVycy9saW51eC92
ZmlvLmggfCAgOSArKysrKysrKw0KPiA+ICAyIGZpbGVzIGNoYW5nZWQsIDY1IGluc2VydGlvbnMo
KykNCj4gPg0KPiA+IGRpZmYgLS1naXQgYS9ody92ZmlvX3BjaS5jIGIvaHcvdmZpb19wY2kuYw0K
PiA+IGluZGV4IDI4YzgzMDMuLjljM2MyOGIgMTAwNjQ0DQo+ID4gLS0tIGEvaHcvdmZpb19wY2ku
Yw0KPiA+ICsrKyBiL2h3L3ZmaW9fcGNpLmMNCj4gPiBAQCAtMzgsNiArMzgsNyBAQA0KPiA+ICAj
aW5jbHVkZSAicWVtdS9lcnJvci1yZXBvcnQuaCINCj4gPiAgI2luY2x1ZGUgInFlbXUvcXVldWUu
aCINCj4gPiAgI2luY2x1ZGUgInFlbXUvcmFuZ2UuaCINCj4gPiArI2luY2x1ZGUgInN5c2VtdS9z
eXNlbXUuaCINCj4gPg0KPiA+ICAvKiAjZGVmaW5lIERFQlVHX1ZGSU8gKi8NCj4gPiAgI2lmZGVm
IERFQlVHX1ZGSU8NCj4gPiBAQCAtMTMwLDYgKzEzMSw4IEBAIHR5cGVkZWYgc3RydWN0IFZGSU9E
ZXZpY2Ugew0KPiA+ICAgICAgUUxJU1RfRU5UUlkoVkZJT0RldmljZSkgbmV4dDsNCj4gPiAgICAg
IHN0cnVjdCBWRklPR3JvdXAgKmdyb3VwOw0KPiA+ICAgICAgYm9vbCByZXNldF93b3JrczsNCj4g
PiArICAgIEV2ZW50Tm90aWZpZXIgZXJyZmQ7DQo+ID4gKyAgICBfX3UzMiBkZXZfaW5mb19mbGFn
czsNCj4gDQo+IFFFTVUgaXMgbm90IGtlcm5lbCBjb2RlLCBwbGVhc2UgdXNlIHVpbnQzMl90Lg0K
DQpBcyB5b3Ugc2F3IGxhdGVyIGluIHRoZSBjb2RlLCBJIHdhcyB1c2luZyB0aGUgc2FtZSB0eXBl
IGluIHRoZSBzdHJ1Y3R1cmUgDQpjb3BpZWQgZnJvbSB0aGUga2VybmVsLiBXaWxsIGNoYW5nZSB0
aGlzIHRvIHVpbnQzMl90Lg0KDQpUaGFua3MNCg0KVmlqYXkNCg0KPiANCj4gPiAgfSBWRklPRGV2
aWNlOw0KPiA+DQo+ID4gIHR5cGVkZWYgc3RydWN0IFZGSU9Hcm91cCB7DQo+ID4gQEAgLTE4MDUs
NiArMTgwOCw4IEBAIHN0YXRpYyBpbnQgdmZpb19nZXRfZGV2aWNlKFZGSU9Hcm91cCAqZ3JvdXAs
IGNvbnN0DQo+IGNoYXIgKm5hbWUsIFZGSU9EZXZpY2UgKnZkZXYpDQo+ID4gICAgICBEUFJJTlRG
KCJEZXZpY2UgJXMgZmxhZ3M6ICV1LCByZWdpb25zOiAldSwgaXJnczogJXVcbiIsIG5hbWUsDQo+
ID4gICAgICAgICAgICAgIGRldl9pbmZvLmZsYWdzLCBkZXZfaW5mby5udW1fcmVnaW9ucywgZGV2
X2luZm8ubnVtX2lycXMpOw0KPiA+DQo+ID4gKyAgICB2ZGV2LT5kZXZfaW5mb19mbGFncyA9IGRl
dl9pbmZvLmZsYWdzOw0KPiA+ICsNCj4gPiAgICAgIGlmICghKGRldl9pbmZvLmZsYWdzICYgVkZJ
T19ERVZJQ0VfRkxBR1NfUENJKSkgew0KPiA+ICAgICAgICAgIGVycm9yX3JlcG9ydCgidmZpbzog
VW0sIHRoaXMgaXNuJ3QgYSBQQ0kgZGV2aWNlXG4iKTsNCj4gPiAgICAgICAgICBnb3RvIGVycm9y
Ow0KPiA+IEBAIC0xOTAwLDYgKzE5MDUsNTUgQEAgc3RhdGljIHZvaWQgdmZpb19wdXRfZGV2aWNl
KFZGSU9EZXZpY2UgKnZkZXYpDQo+ID4gICAgICB9DQo+ID4gIH0NCj4gPg0KPiA+ICtzdGF0aWMg
dm9pZCB2ZmlvX2VycmZkX2hhbmRsZXIodm9pZCAqb3BhcXVlKQ0KPiA+ICt7DQo+ID4gKyAgICBW
RklPRGV2aWNlICp2ZGV2ID0gb3BhcXVlOw0KPiA+ICsNCj4gPiArICAgIGlmICghZXZlbnRfbm90
aWZpZXJfdGVzdF9hbmRfY2xlYXIoJnZkZXYtPmVycmZkKSkgew0KPiA+ICsgICAgICAgIHJldHVy
bjsNCj4gPiArICAgIH0NCj4gPiArDQo+ID4gKyAgICAvKg0KPiA+ICsgICAgICogVEJELiBSZXRy
aWV2ZSB0aGUgZXJyb3IgZGV0YWlscyBhbmQgZGVjaWRlIHdoYXQgYWN0aW9uDQo+ID4gKyAgICAg
KiBuZWVkcyB0byBiZSB0YWtlbi4gT25lIG9mIHRoZSBhY3Rpb25zIGNvdWxkIGJlIHRvIHBhc3MN
Cj4gPiArICAgICAqIHRoZSBlcnJvciB0byB0aGUgZ3Vlc3QgYW5kIGhhdmUgdGhlIGd1ZXN0IGRy
aXZlciByZWNvdmVyDQo+ID4gKyAgICAgKiB0aGUgZXJyb3IuIFRoaXMgcmVxdWlyZXMgdGhhdCBQ
Q0llIGNhcGFiaWxpdGllcyBiZQ0KPiA+ICsgICAgICogZXhwb3NlZCB0byB0aGUgZ3Vlc3QuIEF0
IHByZXNlbnQsIHdlIGp1c3QgdGVybWluYXRlIHRoZQ0KPiA+ICsgICAgICogZ3Vlc3QgdG8gY29u
dGFpbiB0aGUgZXJyb3IuDQo+ID4gKyAgICAgKi8NCj4gPiArICAgIGVycm9yX3JlcG9ydCgiJXMo
JTA0eDolMDJ4OiUwMnguJXgpICINCj4gPiArICAgICAgICAiVW5yZWNvdmVyYWJsZSBlcnJvciBk
ZXRlY3RlZC4uLiBUZXJtaW5hdGluZyBndWVzdFxuIiwNCj4gPiArICAgICAgICBfX2Z1bmNfXywg
dmRldi0+aG9zdC5kb21haW4sIHZkZXYtPmhvc3QuYnVzLCB2ZGV2LT5ob3N0LnNsb3QsDQo+ID4g
KyAgICAgICAgdmRldi0+aG9zdC5mdW5jdGlvbik7DQo+ID4gKw0KPiA+ICsgICAgcWVtdV9zeXN0
ZW1fc2h1dGRvd25fcmVxdWVzdCgpOw0KPiA+ICsgICAgcmV0dXJuOw0KPiA+ICt9DQo+ID4gKw0K
PiA+ICtzdGF0aWMgdm9pZCB2ZmlvX3JlZ2lzdGVyX2VycmZkKFZGSU9EZXZpY2UgKnZkZXYpDQo+
ID4gK3sNCj4gPiArICAgIGludDMyX3QgcGZkOw0KPiA+ICsgICAgaW50IHJldDsNCj4gPiArDQo+
ID4gKyAgICBpZiAoISh2ZGV2LT5kZXZfaW5mb19mbGFncyAmIFZGSU9fREVWSUNFX0ZMQUdTX0FF
Ul9OT1RJRlkpKSB7DQo+ID4gKyAgICAgICAgZXJyb3JfcmVwb3J0KCJ2ZmlvOiBXYXJuaW5nOiBF
cnJvciBub3RpZmljYXRpb24gbm90IHN1cHBvcnRlZA0KPiBmb3IgdGhlIGRldmljZVxuIik7DQo+
ID4gKyAgICAgICAgcmV0dXJuOw0KPiA+ICsgICAgfQ0KPiA+ICsgICAgaWYgKGV2ZW50X25vdGlm
aWVyX2luaXQoJnZkZXYtPmVycmZkLCAwKSkgew0KPiA+ICsgICAgICAgIGVycm9yX3JlcG9ydCgi
dmZpbzogV2FybmluZzogVW5hYmxlIHRvIGluaXQgZXZlbnQgbm90aWZpZXIgZm9yDQo+IGVycm9y
IGRldGVjdGlvblxuIik7DQo+ID4gKyAgICAgICAgcmV0dXJuOw0KPiA+ICsgICAgfQ0KPiA+ICsg
ICAgcGZkID0gZXZlbnRfbm90aWZpZXJfZ2V0X2ZkKCZ2ZGV2LT5lcnJmZCk7DQo+ID4gKyAgICBx
ZW11X3NldF9mZF9oYW5kbGVyKHBmZCwgdmZpb19lcnJmZF9oYW5kbGVyLCBOVUxMLCB2ZGV2KTsN
Cj4gPiArDQo+ID4gKyAgICByZXQgPSBpb2N0bCh2ZGV2LT5mZCwgVkZJT19ERVZJQ0VfU0VUX0VS
UkZELCBwZmQpOw0KPiA+ICsgICAgaWYgKHJldCkgew0KPiA+ICsgICAgICAgIGVycm9yX3JlcG9y
dCgidmZpbzogV2FybmluZzogRmFpbGVkIHRvIHNldHVwIGVycm9yIGZkOiAlZFxuIiwNCj4gcmV0
KTsNCj4gPiArICAgICAgICBxZW11X3NldF9mZF9oYW5kbGVyKHBmZCwgTlVMTCwgTlVMTCwgdmRl
dik7DQo+ID4gKyAgICAgICAgZXZlbnRfbm90aWZpZXJfY2xlYW51cCgmdmRldi0+ZXJyZmQpOw0K
PiA+ICsgICAgfQ0KPiA+ICsgICAgcmV0dXJuOw0KPiA+ICt9DQo+ID4gIHN0YXRpYyBpbnQgdmZp
b19pbml0Zm4oUENJRGV2aWNlICpwZGV2KQ0KPiA+ICB7DQo+ID4gICAgICBWRklPRGV2aWNlICpw
dmRldiwgKnZkZXYgPSBET19VUENBU1QoVkZJT0RldmljZSwgcGRldiwgcGRldik7DQo+ID4gQEAg
LTIwMTAsNiArMjA2NCw4IEBAIHN0YXRpYyBpbnQgdmZpb19pbml0Zm4oUENJRGV2aWNlICpwZGV2
KQ0KPiA+ICAgICAgICAgIH0NCj4gPiAgICAgIH0NCj4gPg0KPiA+ICsgICAgdmZpb19yZWdpc3Rl
cl9lcnJmZCh2ZGV2KTsNCj4gPiArDQo+ID4gICAgICByZXR1cm4gMDsNCj4gPg0KPiA+ICBvdXRf
dGVhcmRvd246DQo+ID4gZGlmZiAtLWdpdCBhL2xpbnV4LWhlYWRlcnMvbGludXgvdmZpby5oIGIv
bGludXgtaGVhZGVycy9saW51eC92ZmlvLmgNCj4gPiBpbmRleCA0NzU4ZDFiLi4wY2E0ZWViIDEw
MDY0NA0KPiA+IC0tLSBhL2xpbnV4LWhlYWRlcnMvbGludXgvdmZpby5oDQo+ID4gKysrIGIvbGlu
dXgtaGVhZGVycy9saW51eC92ZmlvLmgNCj4gPiBAQCAtMTQ3LDYgKzE0Nyw3IEBAIHN0cnVjdCB2
ZmlvX2RldmljZV9pbmZvIHsNCj4gPiAgICAgICAgIF9fdTMyICAgZmxhZ3M7DQo+ID4gICNkZWZp
bmUgVkZJT19ERVZJQ0VfRkxBR1NfUkVTRVQgICAgICAgICgxIDw8IDApICAgICAgICAvKiBEZXZp
Y2UNCj4gc3VwcG9ydHMgcmVzZXQgKi8NCj4gPiAgI2RlZmluZSBWRklPX0RFVklDRV9GTEFHU19Q
Q0kgICgxIDw8IDEpICAgICAgICAvKiB2ZmlvLXBjaSBkZXZpY2UgKi8NCj4gPiArI2RlZmluZSBW
RklPX0RFVklDRV9GTEFHU19BRVJfTk9USUZZICgxIDw8IDIpICAgLyogU3VwcG9ydHMgYWVyDQo+
IG5vdGlmaWNhdGlvbiAqLw0KPiA+ICAgICAgICAgX191MzIgICBudW1fcmVnaW9uczsgICAgLyog
TWF4IHJlZ2lvbiBpbmRleCArIDEgKi8NCj4gPiAgICAgICAgIF9fdTMyICAgbnVtX2lycXM7ICAg
ICAgIC8qIE1heCBJUlEgaW5kZXggKyAxICovDQo+IA0KPiBUaGVzZSBhcmUgdmVyYmF0aW0gY29w
aWVzIG9mIGtlcm5lbCBoZWFkZXJzIHNvIGl0J3MgT0sgaGVyZS4NCj4gDQo+ID4gIH07DQo+ID4g
QEAgLTI4OCw2ICsyODksMTQgQEAgc3RydWN0IHZmaW9faXJxX3NldCB7DQo+ID4gICAqLw0KPiA+
ICAjZGVmaW5lIFZGSU9fREVWSUNFX1JFU0VUICAgICAgICAgICAgICBfSU8oVkZJT19UWVBFLCBW
RklPX0JBU0UgKyAxMSkNCj4gPg0KPiA+ICsvKioNCj4gPiArICogVkZJT19ERVZJQ0VfU0VUX0VS
UkZEIC0gX0lPKFZGSU9fVFlQRSwgVkZJT19CQVNFICsgMTIpDQo+ID4gKyAqDQo+ID4gKyAqIFBh
c3MgdGhlIGV2ZW50ZmQgdG8gdGhlIHZmaW8tcGNpIGRyaXZlciBmb3Igc2lnbmFsbGluZyBhbnkg
ZGV2aWNlDQo+ID4gKyAqIGVycm9yIG5vdGlmaWNhdGlvbnMNCj4gPiArICovDQo+ID4gKyNkZWZp
bmUgVkZJT19ERVZJQ0VfU0VUX0VSUkZEICAgICAgICAgICBfSU8oVkZJT19UWVBFLCBWRklPX0JB
U0UgKyAxMikNCj4gPiArDQo+ID4gIC8qDQo+ID4gICAqIFRoZSBWRklPLVBDSSBidXMgZHJpdmVy
IG1ha2VzIHVzZSBvZiB0aGUgZm9sbG93aW5nIGZpeGVkIHJlZ2lvbiBhbmQNCj4gPiAgICogSVJR
IGluZGV4IG1hcHBpbmcuICBVbmltcGxlbWVudGVkIHJlZ2lvbnMgcmV0dXJuIGEgc2l6ZSBvZiB6
ZXJvLg0KPiA+IC0tDQo+ID4gMS43LjExLjMNCj4gPg0KPiA+DQo=

Re: [PATCH 2/2] QEMU-AER: Qemu changes to support AER for VFIO-PCI devices

[Alex Williamson]

On Fri, 2013-01-11 at 08:53 +0000, Pandarathil, Vijaymohan R wrote:
> 
> > -----Original Message-----
> > From: Alex Williamson [mailto:alex.williamson@redhat.com]
> > Sent: Wednesday, January 09, 2013 10:08 AM
> > To: Pandarathil, Vijaymohan R
> > Cc: Bjorn Helgaas; Gleb Natapov; kvm@vger.kernel.org; qemu-
> > devel@nongnu.org; linux-pci@vger.kernel.org; linux-kernel@vger.kernel.org
> > Subject: Re: [PATCH 2/2] QEMU-AER: Qemu changes to support AER for VFIO-PCI
> > devices
> > 
> > On Wed, 2013-01-09 at 06:26 +0000, Pandarathil, Vijaymohan R wrote:
> > > 	- Create eventfd per vfio device assigned to a guest and register an
> > >           event handler
> > >
> > > 	- This fd is passed to the vfio_pci driver through a new ioctl
> > >
> > > 	- When the device encounters an error, the eventfd is signaled
> > >           and the qemu eventfd handler gets invoked.
> > >
> > > 	- In the handler decide what action to take. Current action taken
> > >           is to terminate the guest.
> > >
> > > Signed-off-by: Vijay Mohan Pandarathil <vijaymohan.pandarathil@hp.com>
> > > ---
> > >  hw/vfio_pci.c              | 56
> > ++++++++++++++++++++++++++++++++++++++++++++++
> > >  linux-headers/linux/vfio.h |  9 ++++++++
> > >  2 files changed, 65 insertions(+)
> > >
> > > diff --git a/hw/vfio_pci.c b/hw/vfio_pci.c
> > > index 28c8303..9c3c28b 100644
> > > --- a/hw/vfio_pci.c
> > > +++ b/hw/vfio_pci.c
> > > @@ -38,6 +38,7 @@
> > >  #include "qemu/error-report.h"
> > >  #include "qemu/queue.h"
> > >  #include "qemu/range.h"
> > > +#include "sysemu/sysemu.h"
> > >
> > >  /* #define DEBUG_VFIO */
> > >  #ifdef DEBUG_VFIO
> > > @@ -130,6 +131,8 @@ typedef struct VFIODevice {
> > >      QLIST_ENTRY(VFIODevice) next;
> > >      struct VFIOGroup *group;
> > >      bool reset_works;
> > > +    EventNotifier errfd;
> > 
> > Misleading name, it's an EventNotifier not an fd.
> 
> Will make the change.
> 
> > 
> > > +    __u32 dev_info_flags;
> > >  } VFIODevice;
> > >
> > >  typedef struct VFIOGroup {
> > > @@ -1805,6 +1808,8 @@ static int vfio_get_device(VFIOGroup *group, const
> > char *name, VFIODevice *vdev)
> > >      DPRINTF("Device %s flags: %u, regions: %u, irgs: %u\n", name,
> > >              dev_info.flags, dev_info.num_regions, dev_info.num_irqs);
> > >
> > > +    vdev->dev_info_flags = dev_info.flags;
> > > +
> > 
> > We test the VFIO_DEVICE_FLAGS_RESET elsewhere by caching the bit into a
> > variable, why not do that here too?
> 
> I was wondering if there was any specific reason to cache the bit into
> a separate variable. Wouldn't a flags field which can contain the
> specific bit be more apt ?

Then we have to mask it out ever time we want to reference it.  Qemu
doesn't seem to like macros or inlines for that, so using a new variable
keeps things neat.  Caching two fields to bools is still more space
efficient than saving the whole thing and we can easily switch to named
bits if we get enough to start caring about the space.  Thanks,

Alex
 
> > >      if (!(dev_info.flags & VFIO_DEVICE_FLAGS_PCI)) {
> > >          error_report("vfio: Um, this isn't a PCI device\n");
> > >          goto error;
> > > @@ -1900,6 +1905,55 @@ static void vfio_put_device(VFIODevice *vdev)
> > >      }
> > >  }
> > >
> > > +static void vfio_errfd_handler(void *opaque)
> > > +{
> > > +    VFIODevice *vdev = opaque;
> > > +
> > > +    if (!event_notifier_test_and_clear(&vdev->errfd)) {
> > > +        return;
> > > +    }
> > > +
> > > +    /*
> > > +     * TBD. Retrieve the error details and decide what action
> > > +     * needs to be taken. One of the actions could be to pass
> > > +     * the error to the guest and have the guest driver recover
> > > +     * the error. This requires that PCIe capabilities be
> > > +     * exposed to the guest. At present, we just terminate the
> > > +     * guest to contain the error.
> > > +     */
> > > +    error_report("%s(%04x:%02x:%02x.%x) "
> > > +        "Unrecoverable error detected... Terminating guest\n",
> > > +        __func__, vdev->host.domain, vdev->host.bus, vdev->host.slot,
> > > +        vdev->host.function);
> > > +
> > > +    qemu_system_shutdown_request();
> > 
> > I would have figured hw_error
> 
> Hw_error() is probably more appropriate. Will make the change.
> 
> > 
> > > +    return;
> > > +}
> > > +
> > > +static void vfio_register_errfd(VFIODevice *vdev)
> > > +{
> > > +    int32_t pfd;
> > 
> > "pfd" is used elsewhere in vfio as "Pointer to FD", this is just a fd.
> 
> Will change.
> 
> > 
> > > +    int ret;
> > > +
> > > +    if (!(vdev->dev_info_flags & VFIO_DEVICE_FLAGS_AER_NOTIFY)) {
> > > +        error_report("vfio: Warning: Error notification not supported
> > for the device\n");
> > 
> > This should probably just be a debug print.
> 
> Okay.
> 
> > 
> > > +        return;
> > > +    }
> > > +    if (event_notifier_init(&vdev->errfd, 0)) {
> > > +        error_report("vfio: Warning: Unable to init event notifier for
> > error detection\n");
> > > +        return;
> > > +    }
> > > +    pfd = event_notifier_get_fd(&vdev->errfd);
> > > +    qemu_set_fd_handler(pfd, vfio_errfd_handler, NULL, vdev);
> > > +
> > > +    ret = ioctl(vdev->fd, VFIO_DEVICE_SET_ERRFD, pfd);
> > > +    if (ret) {
> > > +        error_report("vfio: Warning: Failed to setup error fd: %d\n",
> > ret);
> > > +        qemu_set_fd_handler(pfd, NULL, NULL, vdev);
> > > +        event_notifier_cleanup(&vdev->errfd);
> > > +    }
> > > +    return;
> > > +}
> > >  static int vfio_initfn(PCIDevice *pdev)
> > >  {
> > >      VFIODevice *pvdev, *vdev = DO_UPCAST(VFIODevice, pdev, pdev);
> > > @@ -2010,6 +2064,8 @@ static int vfio_initfn(PCIDevice *pdev)
> > >          }
> > >      }
> > >
> > > +    vfio_register_errfd(vdev);
> > > +
> > 
> > No cleanup in exitfn?!  Thanks,
> 
> Missed that. Will fix.
> 
> Vijay
> 
> > 
> > Alex
> > 
> > >      return 0;
> > >
> > >  out_teardown:
> > > diff --git a/linux-headers/linux/vfio.h b/linux-headers/linux/vfio.h
> > > index 4758d1b..0ca4eeb 100644
> > > --- a/linux-headers/linux/vfio.h
> > > +++ b/linux-headers/linux/vfio.h
> > > @@ -147,6 +147,7 @@ struct vfio_device_info {
> > >  	__u32	flags;
> > >  #define VFIO_DEVICE_FLAGS_RESET	(1 << 0)	/* Device supports reset */
> > >  #define VFIO_DEVICE_FLAGS_PCI	(1 << 1)	/* vfio-pci device */
> > > +#define VFIO_DEVICE_FLAGS_AER_NOTIFY (1 << 2)   /* Supports aer
> > notification */
> > >  	__u32	num_regions;	/* Max region index + 1 */
> > >  	__u32	num_irqs;	/* Max IRQ index + 1 */
> > >  };
> > > @@ -288,6 +289,14 @@ struct vfio_irq_set {
> > >   */
> > >  #define VFIO_DEVICE_RESET		_IO(VFIO_TYPE, VFIO_BASE + 11)
> > >
> > > +/**
> > > + * VFIO_DEVICE_SET_ERRFD - _IO(VFIO_TYPE, VFIO_BASE + 12)
> > > + *
> > > + * Pass the eventfd to the vfio-pci driver for signalling any device
> > > + * error notifications
> > > + */
> > > +#define VFIO_DEVICE_SET_ERRFD           _IO(VFIO_TYPE, VFIO_BASE + 12)
> > > +
> > >  /*
> > >   * The VFIO-PCI bus driver makes use of the following fixed region and
> > >   * IRQ index mapping.  Unimplemented regions return a size of zero.
> > 
> > 
>