IRQ offloading for vDPA
Subsystems (9)
v5 cover IRQ offloading for vDPA
This series intends to implement IRQ offloading for vhost_vdpa.
By the feat of irq forwarding facilities like posted interrupt on X86, irq bypass can help deliver interrupts to vCPU directly.
vDPA devices have dedicated hardware backends like VFIO pass-throughed devices. So it would be possible to setup irq offloading(irq bypass) for vDPA devices and gain performance improvements.
In my testing, with this feature, we can save 0.1ms
in a ping between two VFs on average.
changes from V4:
(1)in vhost_vdpa, setup irq offloading after config_ops->set_status. (2)minor improvements
changes from V3:
(1)removed vDPA irq allocate/free helpers in vDPA core. (2)add a new function get_vq_irq() in struct vdpa_config_ops, upper layer driver can use this function to: A. query the irq numbner of a vq. B. detect whether a vq is enabled. (3)implement get_vq_irq() in ifcvf driver.
(4)in vhost_vdpa, set_status() will setup irq offloading when setting DRIVER_OK, and unsetup when receive !DRIVER_OK. (5)minor improvements.
changes from V2:
(1)rename struct vhost_call_ctx to vhost_vring_call
(2)add kvm_arch_end_assignment() in del_producer()
code path
(3)rename vDPA helpers to vdpa_devm_request_irq()
and vdpa_devm_free_irq(). Add better comments
for them.
(4)better comments for setup_vq_irq() andunsetup_vq_irq()
(5)In vDPA VHOST_SET_VRING_CALL, will call vhost_vdpa_update_vq_irq() without checking producer.irq, move this check into vhost_vdpa_update_vq_irq(), so that get advantage of the spinlock. (6)Add a function vhost_vdpa_clean_irq(), this function will unregister the producer of vqs when vhost_vdpa_release(). This is safe for control vq.
(7) minor improvements
changes from V1:
(1)dropped vfio changes.
(3)removed KVM_HVAE_IRQ_BYPASS checks
(4)locking fixes
(5)simplified vhost_vdpa_updat
Zhu Lingshan (6):
vhost: introduce vhost_vring_call
kvm: detect assigned device via irqbypass manager
vDPA: add get_vq_irq() in vdpa_config_ops
vhost_vdpa: implement IRQ offloading in vhost_vdpa
ifcvf: implement vdpa_config_ops.get_vq_irq()
irqbypass: do not start cons/prod when failed connect
arch/x86/kvm/x86.c | 12 ++++- drivers/vdpa/ifcvf/ifcvf_main.c | 18 ++++++- drivers/vhost/Kconfig | 1 + drivers/vhost/vdpa.c | 83 +++++++++++++++++++++++++++++++-- drivers/vhost/vhost.c | 22 ++++++--- drivers/vhost/vhost.h | 9 +++- include/linux/vdpa.h | 6 +++ virt/lib/irqbypass.c | 16 ++++--- 8 files changed, 147 insertions(+), 20 deletions(-)
Signature · 1 line
2.18.4
PATCH v5 1/6 vhost: introduce vhost_vring_call
This commit introduces struct vhost_vring_call which replaced raw struct eventfd_ctx *call_ctx in struct vhost_virtqueue. Besides eventfd_ctx, it contains a spin lock and an irq_bypass_producer in its structure.
--- drivers/vhost/vdpa.c | 4 ++-- drivers/vhost/vhost.c | 22 ++++++++++++++++------ drivers/vhost/vhost.h | 9 ++++++++- 3 files changed, 26 insertions(+), 9 deletions(-)
drivers/vhost/vdpa.c +2 -2
@@ -96,7 +96,7 @@ static void handle_vq_kick(struct vhost_work *work)static irqreturn_t vhost_vdpa_virtqueue_cb (void *private) {struct vhost_virtqueue *vq = private; -struct eventfd_ctx *call_ctx = vq->call_ctx; +struct eventfd_ctx *call_ctx = vq->call_ctx.ctx;if (call_ctx)eventfd_signal (call_ctx,1 );
@@ -382,7 +382,7 @@ static long vhost_vdpa_vring_ioctl(struct vhost_vdpa *v, unsigned int cmd,break ;case VHOST_SET_VRING_CALL : -if (vq->call_ctx) { +if (vq->call_ctx.ctx) { cb.callback = vhost_vdpa_virtqueue_cb; cb.private = vq; }else {
drivers/vhost/vhost.c +16 -6
@@ -298,6 +298,13 @@ static void vhost_vq_meta_reset(struct vhost_dev *d)__vhost_vq_meta_reset (d->vqs[i]); } +static void vhost_vring_call_reset (struct vhost_vring_call *call_ctx) +{ + call_ctx->ctx =NULL ; +memset (&call_ctx->producer,0x0 ,sizeof (struct irq_bypass_producer )); +spin_lock_init (&call_ctx->ctx_lock); +} +static void vhost_vq_reset (struct vhost_dev *dev,struct vhost_virtqueue *vq) {
@@ -319,13 +326,13 @@ static void vhost_vq_reset(struct vhost_dev *dev, vq->log_base =NULL ; vq->error_ctx =NULL ; vq->kick =NULL ; - vq->call_ctx =NULL ; vq->log_ctx =NULL ;vhost_reset_is_le (vq);vhost_disable_cross_endian (vq); vq->busyloop_timeout =0 ; vq->umem =NULL ; vq->iotlb =NULL ; +vhost_vring_call_reset (&vq->call_ctx);__vhost_vq_meta_reset (vq); }
@@ -685,8 +692,8 @@ void vhost_dev_cleanup(struct vhost_dev *dev)eventfd_ctx_put (dev->vqs[i]->error_ctx);if (dev->vqs[i]->kick)fput (dev->vqs[i]->kick); -if (dev->vqs[i]->call_ctx) -eventfd_ctx_put (dev->vqs[i]->call_ctx); +if (dev->vqs[i]->call_ctx.ctx) +eventfd_ctx_put (dev->vqs[i]->call_ctx.ctx);vhost_vq_reset (dev, dev->vqs[i]); }vhost_dev_free_iovecs (dev);
@@ -1629,7 +1636,10 @@ long vhost_vring_ioctl(struct vhost_dev *d, unsigned int ioctl, void __user *arg r =PTR_ERR (ctx);break ; } -swap (ctx, vq->call_ctx); + +spin_lock (&vq->call_ctx.ctx_lock); +swap (ctx, vq->call_ctx.ctx); +spin_unlock (&vq->call_ctx.ctx_lock);break ;case VHOST_SET_VRING_ERR :if (copy_from_user (&f, argp,sizeof f)) {
@@ -2440,8 +2450,8 @@ static bool vhost_notify(struct vhost_dev *dev, struct vhost_virtqueue *vq)void vhost_signal (struct vhost_dev *dev,struct vhost_virtqueue *vq) {/* Signal the Guest tell them we used something up. */ -if (vq->call_ctx &&vhost_notify (dev, vq)) -eventfd_signal (vq->call_ctx,1 ); +if (vq->call_ctx.ctx &&vhost_notify (dev, vq)) +eventfd_signal (vq->call_ctx.ctx,1 ); }EXPORT_SYMBOL_GPL (vhost_signal);
drivers/vhost/vhost.h +8 -1
@@ -13,6 +13,7 @@#include <linux/virtio_ring.h> #include <linux/atomic.h> #include <linux/vhost_iotlb.h> +#include <linux/irqbypass.h> struct vhost_work ;typedef void (*vhost_work_fn_t )(struct vhost_work *work);
@@ -60,6 +61,12 @@ enum vhost_uaddr_type { VHOST_NUM_ADDRS = 3, }; +struct vhost_vring_call { +struct eventfd_ctx *ctx; +struct irq_bypass_producer producer; +spinlock_t ctx_lock; +}; +/* The virtqueue structure describes a queue attached to a device. */ struct vhost_virtqueue {struct vhost_dev *dev;
@@ -72,7 +79,7 @@ struct vhost_virtqueue {vring_used_t __user *used;const struct vhost_iotlb_map *meta_iotlb[VHOST_NUM_ADDRS ];struct file *kick; -struct eventfd_ctx *call_ctx; +struct vhost_vring_call call_ctx;struct eventfd_ctx *error_ctx;struct eventfd_ctx *log_ctx;
Signature · 1 line
2.18.4
Re: [PATCH V5 1/6] vhost: introduce vhost_vring_call
Quoted 115 lines · Zhu Lingshan
This commit introduces struct
vhost_vring_callwhich replaced raw structeventfd_ctx*call_ctxin structvhost_virtqueue. Besideseventfd_ctx, it contains a spin lock and anirq_bypass_producerin its structure.Signed-off-by Zhu Lingshan <[email protected]>Suggested-by Jason Wang <[email protected]>--- drivers/vhost/vdpa.c | 4 ++-- drivers/vhost/vhost.c | 22 ++++++++++++++++------ drivers/vhost/vhost.h | 9 ++++++++- 3 files changed, 26 insertions(+), 9 deletions(-)drivers/vhost/vdpa.c +2
-2@@ -96,7 +96,7 @@ static void handle_vq_kick(struct vhost_work *work)static irqreturn_t vhost_vdpa_virtqueue_cb (void *private) {struct vhost_virtqueue *vq = private; -struct eventfd_ctx *call_ctx = vq->call_ctx; +struct eventfd_ctx *call_ctx = vq->call_ctx.ctx;if (call_ctx)eventfd_signal (call_ctx,1 );@@ -382,7 +382,7 @@ static long vhost_vdpa_vring_ioctl(struct vhost_vdpa *v, unsigned int cmd,break ;case VHOST_SET_VRING_CALL : -if (vq->call_ctx) { +if (vq->call_ctx.ctx) { cb.callback = vhost_vdpa_virtqueue_cb; cb.private = vq; }else {drivers/vhost/vhost.c +16
-6@@ -298,6 +298,13 @@ static void vhost_vq_meta_reset(struct vhost_dev *d)__vhost_vq_meta_reset (d->vqs[i]); } +static void vhost_vring_call_reset (struct vhost_vring_call *call_ctx) +{ + call_ctx->ctx =NULL ; +memset (&call_ctx->producer,0x0 ,sizeof (struct irq_bypass_producer )); +spin_lock_init (&call_ctx->ctx_lock); +} +static void vhost_vq_reset (struct vhost_dev *dev,struct vhost_virtqueue *vq) {@@ -319,13 +326,13 @@ static void vhost_vq_reset(struct vhost_dev *dev, vq->log_base =NULL ; vq->error_ctx =NULL ; vq->kick =NULL ; - vq->call_ctx =NULL ; vq->log_ctx =NULL ;vhost_reset_is_le (vq);vhost_disable_cross_endian (vq); vq->busyloop_timeout =0 ; vq->umem =NULL ; vq->iotlb =NULL ; +vhost_vring_call_reset (&vq->call_ctx);__vhost_vq_meta_reset (vq); }@@ -685,8 +692,8 @@ void vhost_dev_cleanup(struct vhost_dev *dev)eventfd_ctx_put (dev->vqs[i]->error_ctx);if (dev->vqs[i]->kick)fput (dev->vqs[i]->kick); -if (dev->vqs[i]->call_ctx) -eventfd_ctx_put (dev->vqs[i]->call_ctx); +if (dev->vqs[i]->call_ctx.ctx) +eventfd_ctx_put (dev->vqs[i]->call_ctx.ctx);vhost_vq_reset (dev, dev->vqs[i]); }vhost_dev_free_iovecs (dev);@@ -1629,7 +1636,10 @@ long vhost_vring_ioctl(struct vhost_dev *d, unsigned int ioctl, void __user *arg r =PTR_ERR (ctx);break ; } -swap (ctx, vq->call_ctx); + +spin_lock (&vq->call_ctx.ctx_lock); +swap (ctx, vq->call_ctx.ctx); +spin_unlock (&vq->call_ctx.ctx_lock);break ;case VHOST_SET_VRING_ERR :if (copy_from_user (&f, argp,sizeof f)) {@@ -2440,8 +2450,8 @@ static bool vhost_notify(struct vhost_dev *dev, struct vhost_virtqueue *vq)void vhost_signal (struct vhost_dev *dev,struct vhost_virtqueue *vq) {/* Signal the Guest tell them we used something up. */ -if (vq->call_ctx &&vhost_notify (dev, vq)) -eventfd_signal (vq->call_ctx,1 ); +if (vq->call_ctx.ctx &&vhost_notify (dev, vq)) +eventfd_signal (vq->call_ctx.ctx,1 ); }EXPORT_SYMBOL_GPL (vhost_signal);drivers/vhost/vhost.h +1
-0@@ -13,6 +13,7 @@#include <linux/virtio_ring.h> #include <linux/atomic.h> #include <linux/vhost_iotlb.h> +#include <linux/irqbypass.h> struct vhost_work ;typedef void (*vhost_work_fn_t )(struct vhost_work *work);
drivers/vhost/vhost.h enum vhost_uaddr_type { · line 67
Quoted 7 lines
drivers/vhost/vhost.h +4
-0@@ -60,6 +61,12 @@ enum vhost_uaddr_type { VHOST_NUM_ADDRS = 3, }; +struct vhost_vring_call { +struct eventfd_ctx *ctx; +struct irq_bypass_producer producer; +spinlock_t ctx_lock;
It's not clear to me why we need ctx_lock here.
Thanks
Quoted 14 lines
drivers/vhost/vhost.h +3
-1+}; +/* The virtqueue structure describes a queue attached to a device. */ struct vhost_virtqueue {struct vhost_dev *dev;@@ -72,7 +79,7 @@ struct vhost_virtqueue {vring_used_t __user *used;const struct vhost_iotlb_map *meta_iotlb[VHOST_NUM_ADDRS ];struct file *kick; -struct eventfd_ctx *call_ctx; +struct vhost_vring_call call_ctx;struct eventfd_ctx *error_ctx;struct eventfd_ctx *log_ctx;
A message that is not in the archive (sent off-list or not yet received): [email protected]
Re: [PATCH V5 1/6] vhost: introduce vhost_vring_call
Quoted 129 lines · Lingshan
Quoted 126 lines · Jason Wang
Quoted 114 lines · Zhu Lingshan
This commit introduces struct
vhost_vring_callwhich replaced raw structeventfd_ctx*call_ctxin structvhost_virtqueue. Besideseventfd_ctx, it contains a spin lock and anirq_bypass_producerin its structure.Signed-off-by Zhu Lingshan <[email protected]>Suggested-by Jason Wang <[email protected]>---
drivers/vhost/vdpa.c | 4 ++--drivers/vhost/vhost.c| 22 ++++++++++++++++------drivers/vhost/vhost.h| 9 ++++++++-3 files changed, 26 insertions(+), 9 deletions(-)drivers/vhost/vdpa.c +1
-1@@ -96,7 +96,7 @@ static void handle_vq_kick(struct vhost_work *work) static irqreturn_t vhost_vdpa_virtqueue_cb(void *private) { struct vhost_virtqueue *vq = private; - struct eventfd_ctx *call_ctx = vq->call_ctx; + struct eventfd_ctx *call_ctx = vq->call_ctx.ctx; if (call_ctx) eventfd_signal(call_ctx, 1);@@ -382,7 +382,7 @@ static long vhost_vdpa_vring_ioctl(struct vhost_vdpa *v, unsigned int cmd, break;case
VHOST_SET_VRING_CALL:
- if (vq->call_ctx) {
+ if (vq->call_ctx.ctx) {
cb.callback =vhost_vdpa_virtqueue_cb; cb.private = vq;
} else {drivers/vhost/vhost.c +6
-0@@ -298,6 +298,13 @@ static void vhost_vq_meta_reset(struct vhost_dev *d) __vhost_vq_meta_reset(d->vqs[i]); } +static void vhost_vring_call_reset(struct vhost_vring_call *call_ctx) +{ + call_ctx->ctx = NULL; + memset(&call_ctx->producer, 0x0, sizeof(structirq_bypass_producer )); + spin_lock_init(&call_ctx->ctx_lock); +} + static void vhost_vq_reset(struct vhost_dev *dev,struct
vhost_virtqueue*vq)
{drivers/vhost/vhost.c +1
-1@@ -319,13 +326,13 @@ static void vhost_vq_reset(struct vhost_dev *dev, vq->log_base = NULL; vq->error_ctx = NULL; vq->kick = NULL; - vq->call_ctx = NULL; vq->log_ctx = NULL; vhost_reset_is_le(vq); vhost_disable_cross_endian(vq); vq->busyloop_timeout = 0; vq->umem = NULL; vq->iotlb = NULL; + vhost_vring_call_reset(&vq->call_ctx); __vhost_vq_meta_reset(vq); } @@ -685,8 +692,8 @@ void vhost_dev_cleanup(struct vhost_dev *dev)
eventfd_ctx_put(dev->vqs[i]->error_ctx);
if (dev->vqs[i]->kick)
fput(dev->vqs[i]->kick);
- if (dev->vqs[i]->call_ctx)
-eventfd_ctx_put(dev->vqs[i]->call_ctx);
+ if (dev->vqs[i]->call_ctx.ctx)
+eventfd_ctx_put(dev->vqs[i]->call_ctx.ctx);
vhost_vq_reset(dev, dev->vqs[i]);
}
vhost_dev_free_iovecs(dev);drivers/vhost/vhost.c +0
-0@@ -1629,7 +1636,10 @@ long vhost_vring_ioctl(struct vhost_dev *d,unsigned int ioctl, void
__user*arg
r =PTR_ERR(ctx);
break;
}
-swap(ctx, vq->call_ctx);
+
+spin_lock(&vq->call_ctx.ctx_lock); +swap(ctx, vq->call_ctx.ctx);
+spin_unlock(&vq->call_ctx.ctx_lock); break;
caseVHOST_SET_VRING_ERR:
if (copy_from_user(&f, argp, sizeof f)) {drivers/vhost/vhost.c +2
-2@@ -2440,8 +2450,8 @@ static bool vhost_notify(struct vhost_dev *dev, struct vhost_virtqueue *vq) void vhost_signal(struct vhost_dev *dev, struct vhost_virtqueue *vq) { /* Signal the Guest tell them we used something up. */ - if (vq->call_ctx && vhost_notify(dev, vq)) - eventfd_signal(vq->call_ctx, 1); + if (vq->call_ctx.ctx && vhost_notify(dev, vq)) + eventfd_signal(vq->call_ctx.ctx, 1); } EXPORT_SYMBOL_GPL(vhost_signal);diff --git
a/drivers/vhost/vhost.hb/drivers/vhost/vhost.hindexc8e96a095d3b..38eb1aa3b68d100644drivers/vhost/vhost.h +1
-0@@ -13,6 +13,7 @@ #include <linux/virtio_ring.h> #include <linux/atomic.h> #include <linux/vhost_iotlb.h> +#include <linux/irqbypass.h> struct vhost_work; typedef void (*vhost_work_fn_t)(struct vhost_work *work);drivers/vhost/vhost.h enum vhost_uaddr_type { · line 66
Quoted 6 lines
drivers/vhost/vhost.h +3
-0@@ -60,6 +61,12 @@ enum vhost_uaddr_type { VHOST_NUM_ADDRS = 3, }; +struct vhost_vring_call { + struct eventfd_ctx *ctx; + struct irq_bypass_producer producer; + spinlock_t ctx_lock;It's not clear to me why we need
ctx_lockhere.
Quoted 4 lines
Quoted 1 line
Thanks
Hi Jason,
we use this lock to protect the
eventfd_ctxand irq from race conditions,
We don't support irq notification from vDPA device driver in this version, do we still have race condition?
Thanks
Quoted 19 lines
are you suggesting a better name?
Thanks
Quoted 16 lines
Quoted 15 lines
drivers/vhost/vhost.h +3
-1+}; + /* The virtqueue structure describes a queue attached to a device. */ struct vhost_virtqueue { struct vhost_dev *dev;@@ -72,7 +79,7 @@ struct vhost_virtqueue { vring_used_t __user *used; const struct vhost_iotlb_map *meta_iotlb[VHOST_NUM_ADDRS]; struct file *kick; - struct eventfd_ctx *call_ctx; + struct vhost_vring_call call_ctx; struct eventfd_ctx *error_ctx; struct eventfd_ctx *log_ctx;
Michael S. Tsirkin
maintainerRe: [PATCH V5 1/6] vhost: introduce vhost_vring_call
Quoted 135 lines · Jason Wang
Quoted 133 lines · Lingshan
Quoted 127 lines · Jason Wang
Quoted 115 lines · Zhu Lingshan
This commit introduces struct
vhost_vring_callwhich replaced raw structeventfd_ctx*call_ctxin structvhost_virtqueue. Besideseventfd_ctx, it contains a spin lock and anirq_bypass_producerin its structure.Signed-off-by Zhu Lingshan <[email protected]>Suggested-by Jason Wang <[email protected]>---
drivers/vhost/vdpa.c | 4 ++--drivers/vhost/vhost.c| 22 ++++++++++++++++------drivers/vhost/vhost.h| 9 ++++++++-3 files changed, 26 insertions(+), 9 deletions(-)drivers/vhost/vdpa.c +1
-1@@ -96,7 +96,7 @@ static void handle_vq_kick(struct vhost_work *work) static irqreturn_t vhost_vdpa_virtqueue_cb(void *private) { struct vhost_virtqueue *vq = private; - struct eventfd_ctx *call_ctx = vq->call_ctx; + struct eventfd_ctx *call_ctx = vq->call_ctx.ctx; if (call_ctx) eventfd_signal(call_ctx, 1);@@ -382,7 +382,7 @@ static long vhost_vdpa_vring_ioctl(struct vhost_vdpa *v, unsigned int cmd, break;case
VHOST_SET_VRING_CALL:
- if (vq->call_ctx) {
+ if (vq->call_ctx.ctx) {
cb.callback =vhost_vdpa_virtqueue_cb; cb.private = vq;
} else {drivers/vhost/vhost.c +0
-0@@ -298,6 +298,13 @@ static void vhost_vq_meta_reset(struct vhost_dev *d) __vhost_vq_meta_reset(d->vqs[i]); }+static void
vhost_vring_call_reset(struct vhost_vring_call *call_ctx)
+{
+call_ctx->ctx= NULL;
+memset(&call_ctx->producer, 0x0, sizeof(struct irq_bypass_producer));
+spin_lock_init(&call_ctx->ctx_lock);drivers/vhost/vhost.c +2
-0+} +static void
vhost_vq_reset(struct vhost_dev *dev, struct vhost_virtqueue *vq){drivers/vhost/vhost.c +1
-1@@ -319,13 +326,13 @@ static void vhost_vq_reset(struct vhost_dev *dev, vq->log_base = NULL; vq->error_ctx = NULL; vq->kick = NULL; - vq->call_ctx = NULL; vq->log_ctx = NULL; vhost_reset_is_le(vq); vhost_disable_cross_endian(vq); vq->busyloop_timeout = 0; vq->umem = NULL; vq->iotlb = NULL; + vhost_vring_call_reset(&vq->call_ctx); __vhost_vq_meta_reset(vq); } @@ -685,8 +692,8 @@ void vhost_dev_cleanup(struct vhost_dev *dev)
eventfd_ctx_put(dev->vqs[i]->error_ctx);
if (dev->vqs[i]->kick)
fput(dev->vqs[i]->kick);
- if (dev->vqs[i]->call_ctx)
-eventfd_ctx_put(dev->vqs[i]->call_ctx);
+ if (dev->vqs[i]->call_ctx.ctx)
+eventfd_ctx_put(dev->vqs[i]->call_ctx.ctx);
vhost_vq_reset(dev, dev->vqs[i]);
}
vhost_dev_free_iovecs(dev);drivers/vhost/vhost.c +4
-1@@ -1629,7 +1636,10 @@ long vhost_vring_ioctl(struct vhost_dev *d, unsigned int ioctl, void __user *arg r = PTR_ERR(ctx); break; } - swap(ctx, vq->call_ctx); + + spin_lock(&vq->call_ctx.ctx_lock); + swap(ctx, vq->call_ctx.ctx); + spin_unlock(&vq->call_ctx.ctx_lock); break;case
VHOST_SET_VRING_ERR:
if (copy_from_user(&f, argp, sizeof f)) {drivers/vhost/vhost.c +2
-2@@ -2440,8 +2450,8 @@ static bool vhost_notify(struct vhost_dev *dev, struct vhost_virtqueue *vq) void vhost_signal(struct vhost_dev *dev, struct vhost_virtqueue *vq) { /* Signal the Guest tell them we used something up. */ - if (vq->call_ctx && vhost_notify(dev, vq)) - eventfd_signal(vq->call_ctx, 1); + if (vq->call_ctx.ctx && vhost_notify(dev, vq)) + eventfd_signal(vq->call_ctx.ctx, 1); } EXPORT_SYMBOL_GPL(vhost_signal);diff --git
a/drivers/vhost/vhost.hb/drivers/vhost/vhost.hindexc8e96a095d3b..38eb1aa3b68d100644drivers/vhost/vhost.h +1
-0@@ -13,6 +13,7 @@ #include <linux/virtio_ring.h> #include <linux/atomic.h> #include <linux/vhost_iotlb.h> +#include <linux/irqbypass.h> struct vhost_work; typedef void (*vhost_work_fn_t)(struct vhost_work *work);drivers/vhost/vhost.h enum vhost_uaddr_type { · line 66
Quoted 6 lines
drivers/vhost/vhost.h +3
-0@@ -60,6 +61,12 @@ enum vhost_uaddr_type { VHOST_NUM_ADDRS = 3, }; +struct vhost_vring_call { + struct eventfd_ctx *ctx; + struct irq_bypass_producer producer; + spinlock_t ctx_lock;It's not clear to me why we need
ctx_lockhere.Quoted 1 line
Thanks
Hi Jason,
Quoted 7 lines
Quoted 1 line
we use this lock to protect the
eventfd_ctxand irq from race conditions,We don't support irq notification from vDPA device driver in this version, do we still have race condition?
Thanks
Jason I'm not sure what you are trying to say here.
Quoted 20 lines
Quoted 20 lines
are you suggesting a better name?
Thanks
Quoted 16 lines
Quoted 15 lines
drivers/vhost/vhost.h +3
-1+}; + /* The virtqueue structure describes a queue attached to a device. */ struct vhost_virtqueue { struct vhost_dev *dev;@@ -72,7 +79,7 @@ struct vhost_virtqueue { vring_used_t __user *used; const struct vhost_iotlb_map *meta_iotlb[VHOST_NUM_ADDRS]; struct file *kick; - struct eventfd_ctx *call_ctx; + struct vhost_vring_call call_ctx; struct eventfd_ctx *error_ctx; struct eventfd_ctx *log_ctx;
Re: [PATCH V5 1/6] vhost: introduce vhost_vring_call
Quoted 7 lines · Michael S. Tsirkin
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 4 lines
+struct
vhost_vring_call{
+ structeventfd_ctx*ctx;
+ structirq_bypass_producerproducer;
+spinlock_tctx_lock;It's not clear to me why we need
ctx_lockhere.Thanks
Quoted 8 lines
Quoted 7 lines
Quoted 3 lines
Hi Jason,
we use this lock to protect the
eventfd_ctxand irq from race conditions,We don't support irq notification from vDPA device driver in this version, do we still have race condition?
Thanks
Jason I'm not sure what you are trying to say here.
I meant we change the API from V4 so driver won't notify us if irq is changed.
Then it looks to me there's no need for the ctx_lock, everyhing could be synchronized with vq mutex.
Thanks
Quoted 2 lines
A message that is not in the archive (sent off-list or not yet received): [email protected]
Re: [PATCH V5 1/6] vhost: introduce vhost_vring_call
Quoted 22 lines · Lingshan
Quoted 19 lines · Jason Wang
Quoted 15 lines · Michael S. Tsirkin
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 4 lines
+struct
vhost_vring_call{
+ structeventfd_ctx*ctx;
+ structirq_bypass_producerproducer;
+spinlock_tctx_lock;It's not clear to me why we need
ctx_lockhere.Quoted 8 lines
Quoted 4 lines
Quoted 1 line
Thanks
Hi Jason,
we use this lock to protect the
eventfd_ctxand irq from race conditions,We don't support irq notification from vDPA device driver in this version, do we still have race condition?
Thanks
Jason I'm not sure what you are trying to say here.
Quoted 7 lines
Quoted 5 lines
I meant we change the API from V4 so driver won't notify us if irq is changed.
Then it looks to me there's no need for the
ctx_lock, everyhing could be synchronized with vq mutex.Thanks
from V4 to V5, there are only some minor improvements and bug fix,
get_vq_irq()almost stays untouched, mutex can work for this, however I see the vq mutex is used in many scenarios. We only use this lock to protect the producer information, can this help to get less coupling, defensive code for less bugs?
I think not, vq mutex is used to protect all vq related data structure, introducing another one will increase the complexity.
Thanks
Quoted 6 lines
Thanks
Quoted 4 lines
Quoted 3 lines
Michael S. Tsirkin
maintainerRe: [PATCH V5 1/6] vhost: introduce vhost_vring_call
In reply to Jason WangQuoted 19 lines · Jason Wang
Quoted 7 lines · Michael S. Tsirkin
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 4 lines
+struct
vhost_vring_call{
+ structeventfd_ctx*ctx;
+ structirq_bypass_producerproducer;
+spinlock_tctx_lock;It's not clear to me why we need
ctx_lockhere.Thanks
Quoted 8 lines
Quoted 7 lines
Quoted 3 lines
Hi Jason,
we use this lock to protect the
eventfd_ctxand irq from race conditions,We don't support irq notification from vDPA device driver in this version, do we still have race condition?
Thanks
Jason I'm not sure what you are trying to say here.
Quoted 7 lines
I meant we change the API from V4 so driver won't notify us if irq is changed.
Then it looks to me there's no need for the
ctx_lock, everyhing could be synchronized with vq mutex.Thanks
Jason do you want to post a cleanup patch simplifying code along these lines?
Thanks,
Quoted 2 lines
Quoted 2 lines
Re: [PATCH V5 1/6] vhost: introduce vhost_vring_call
Quoted 21 lines · Michael S. Tsirkin
Quoted 20 lines · Jason Wang
Quoted 7 lines · Michael S. Tsirkin
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 4 lines
+struct
vhost_vring_call{
+ structeventfd_ctx*ctx;
+ structirq_bypass_producerproducer;
+spinlock_tctx_lock;It's not clear to me why we need
ctx_lockhere.Thanks
Quoted 8 lines
Quoted 7 lines
Quoted 3 lines
Hi Jason,
we use this lock to protect the
eventfd_ctxand irq from race conditions,We don't support irq notification from vDPA device driver in this version, do we still have race condition?
Thanks
Jason I'm not sure what you are trying to say here.
I meant we change the API from V4 so driver won't notify us if irq is changed.
Quoted 6 lines
Quoted 4 lines
Then it looks to me there's no need for the
ctx_lock, everyhing could be synchronized with vq mutex.Thanks
Jason do you want to post a cleanup patch simplifying code along these lines?
Ling Shan promised to post a patch to fix this.
Thanks
Quoted 5 lines
Thanks,
Quoted 1 line
Quoted 1 line
A message that is not in the archive (sent off-list or not yet received): [email protected]
Re: [PATCH V5 1/6] vhost: introduce vhost_vring_call
Quoted 11 lines · Lingshan
Quoted 6 lines
Quoted 3 lines
Hi Jason,
we use this lock to protect the
eventfd_ctxand irq from race conditions,We don't support irq notification from vDPA device driver in this version, do we still have race condition?
as we discussed before:
(1)if vendor change IRQ afterDRIVER_OK, through they should not do this, but they can. (2)if user space changes ctx.Thanks
Yes, but then everything happens in context of syscall (ioctl), so vq mutex is sufficient I guess?
Thanks
PATCH v5 2/6 kvm: detect assigned device via irqbypass manager
In reply to Zhu LingshanvDPA devices has dedicated backed hardware like passthrough-ed devices. Then it is possible to setup irq offloading to vCPU for vDPA devices. Thus this patch tries to manipulated assigned device counters by kvm_arch_start/end_assignment() in irqbypass manager, so that assigned devices could be detected in update_pi_irte()
We will increase/decrease the assigned device counter in kvm/x86. Both vDPA and VFIO would go through this code path.
Only X86 uses these counters and kvm_arch_start/end_assignment(), so this code path only affect x86 for now.
--- arch/x86/kvm/x86.c | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-)
arch/x86/kvm/x86.c +10 -2
@@ -10630,11 +10630,17 @@ int kvm_arch_irq_bypass_add_producer(struct irq_bypass_consumer *cons, {struct kvm_kernel_irqfd *irqfd = container_of(cons, struct kvm_kernel_irqfd, consumer); +int ret; irqfd->producer = prod; +kvm_arch_start_assignment (irqfd->kvm); + ret = kvm_x86_ops.update_pi_irte (irqfd->kvm, + prod->irq, irqfd->gsi,1 ); + +if (ret) +kvm_arch_end_assignment (irqfd->kvm); -return kvm_x86_ops.update_pi_irte (irqfd->kvm, - prod->irq, irqfd->gsi,1 ); +return ret; } void kvm_arch_irq_bypass_del_producer(struct irq_bypass_consumer *cons,
@@ -10657,6 +10663,8 @@ void kvm_arch_irq_bypass_del_producer(struct irq_bypass_consumer *cons,if (ret)printk (KERN_INFO "irq bypass consumer (token %p) unregistration" " fails: %d\n" , irqfd->consumer.token, ret); + +kvm_arch_end_assignment (irqfd->kvm); } int kvm_arch_update_irqfd_routing(struct kvm *kvm, unsigned int host_irq,
Signature · 1 line
2.18.4
PATCH v5 3/6 vDPA: add get_vq_irq() in vdpa_config_ops
In reply to Zhu LingshanThis commit adds a new function get_vq_irq() in struct vdpa_config_ops, which will return the irq number of a virtqueue.
--- include/linux/vdpa.h | 6 ++++++ 1 file changed, 6 insertions(+)
include/linux/vdpa.h +6 -0
@@ -87,6 +87,11 @@ struct vdpa_device {* @vdev: vdpa device * @idx: virtqueue index * Returns the notifcation area +* @get_vq_irq: Get the irq number of a virtqueue +* @vdev: vdpa device +* @idx: virtqueue index +* Returns int: irq number of a virtqueue, +* negative number if no irq assigned. * @get_vq_align: Get the virtqueue align requirement * for the device * @vdev: vdpa device
@@ -178,6 +183,7 @@ struct vdpa_config_ops {u64 (*get_vq_state)(struct vdpa_device *vdev,u16 idx);struct vdpa_notification_area (*get_vq_notification)(struct vdpa_device *vdev,u16 idx); +int (*get_vq_irq)(struct vdpa_device *vdv,u16 idx);/* Device ops */ u32 (*get_vq_align)(struct vdpa_device *vdev);
Signature · 1 line
2.18.4
PATCH v5 4/6 vhost_vdpa: implement IRQ offloading in vhost_vdpa
In reply to Zhu LingshanThis patch introduce a set of functions for setup/unsetup and update irq offloading respectively by register/unregister and re-register the irq_bypass_producer.
With these functions, this commit can setup/unsetup irq offloading through setting DRIVER_OK/!DRIVER_OK, and update irq offloading through SET_VRING_CALL.
--- drivers/vhost/Kconfig | 1 + drivers/vhost/vdpa.c | 79 ++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 79 insertions(+), 1 deletion(-)
drivers/vhost/Kconfig +1 -0
@@ -65,6 +65,7 @@ config VHOST_VDPA tristate "Vhost driver for vDPA-based backend" depends on EVENTFD select VHOST + select IRQ_BYPASS_MANAGER depends on VDPA help This kernel module can be loaded in host kernel to accelerate
drivers/vhost/vdpa.c +78 -1
125 lines not on this page · raw message
Signature · 1 line
2.18.4
Re: [PATCH V5 4/6] vhost_vdpa: implement IRQ offloading in vhost_vdpa
Quoted 51 lines · Zhu Lingshan
This patch introduce a set of functions for setup/unsetup and update irq offloading respectively by register/unregister and re-register the
irq_bypass_producer.With these functions, this commit can setup/unsetup irq offloading through setting DRIVER_OK/!DRIVER_OK, and update irq offloading through
SET_VRING_CALL.Signed-off-by Zhu Lingshan <[email protected]>Suggested-by Jason Wang <[email protected]>--- drivers/vhost/Kconfig | 1 + drivers/vhost/vdpa.c | 79 ++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 79 insertions(+), 1 deletion(-)drivers/vhost/Kconfig +1
-0@@ -65,6 +65,7 @@ config VHOST_VDPA tristate "Vhost driver for vDPA-based backend" depends on EVENTFD select VHOST + select IRQ_BYPASS_MANAGER depends on VDPA help This kernel module can be loaded in host kernel to acceleratedrivers/vhost/vdpa.c +16
-0@@ -115,6 +115,55 @@ static irqreturn_t vhost_vdpa_config_cb(void *private)return IRQ_HANDLED ; } +static void vhost_vdpa_setup_vq_irq (struct vhost_vdpa *v,u16 qid) +{ +struct vhost_virtqueue *vq = &v->vqs[qid]; +const struct vdpa_config_ops *ops = v->vdpa->config; +struct vdpa_device *vdpa = v->vdpa; +int ret, irq; + +spin_lock (&vq->call_ctx.ctx_lock); + irq = ops->get_vq_irq (vdpa, qid); +if (!vq->call_ctx.ctx || irq <0 ) { +spin_unlock (&vq->call_ctx.ctx_lock); +return ; + } + + vq->call_ctx.producer.token = vq->call_ctx.ctx; + vq->call_ctx.producer.irq = irq;
drivers/vhost/vdpa.c static irqreturn_t vhost_vdpa_config_cb(void *private) · line 143
Quoted 10 lines
drivers/vhost/vdpa.c +10
-0+ ret =irq_bypass_register_producer (&vq->call_ctx.producer); +spin_unlock (&vq->call_ctx.ctx_lock); +} + +static void vhost_vdpa_unsetup_vq_irq (struct vhost_vdpa *v,u16 qid) +{ +struct vhost_virtqueue *vq = &v->vqs[qid]; + +spin_lock (&vq->call_ctx.ctx_lock); +irq_bypass_unregister_producer (&vq->call_ctx.producer);
Any reason for not checking vq->call_ctx.producer.irq as below here?
Quoted 12 lines
drivers/vhost/vdpa.c +12
-0+spin_unlock (&vq->call_ctx.ctx_lock); +} + +static void vhost_vdpa_update_vq_irq (struct vhost_virtqueue *vq) +{ +spin_lock (&vq->call_ctx.ctx_lock); +/* +* if it has a non-zero irq, means there is a +* previsouly registered irq_bypass_producer, +* we should update it when ctx (its token) +* changes. +*/
drivers/vhost/vdpa.c static irqreturn_t vhost_vdpa_config_cb(void *private) · line 165
Quoted 10 lines
drivers/vhost/vdpa.c +10
-0+if (!vq->call_ctx.producer.irq) { +spin_unlock (&vq->call_ctx.ctx_lock); +return ; + } + +irq_bypass_unregister_producer (&vq->call_ctx.producer); + vq->call_ctx.producer.token = vq->call_ctx.ctx; +irq_bypass_register_producer (&vq->call_ctx.producer); +spin_unlock (&vq->call_ctx.ctx_lock); +}
I think setup_irq() and update_irq() could be unified with the following logic:
irq_bypass_unregister_producer(&vq->call_ctx.producer); irq = ops->get_vq_irq(vdpa, qid);
if (!vq->call_ctx.ctx || irq < 0) { spin_unlock(&vq->call_ctx.ctx_lock); return;
}
vq->call_ctx.producer.token = vq->call_ctx.ctx; vq->call_ctx.producer.irq = irq;
ret = irq_bypass_register_producer(&vq->call_ctx.producer);
Quoted 22 lines
drivers/vhost/vdpa.c +6
-1+static void vhost_vdpa_reset (struct vhost_vdpa *v) {struct vdpa_device *vdpa = v->vdpa;@@ -155,11 +204,15 @@ static long vhost_vdpa_set_status(struct vhost_vdpa *v, u8 __user *statusp) {struct vdpa_device *vdpa = v->vdpa;const struct vdpa_config_ops *ops = vdpa->config; -u8 status; +u8 status, status_old; +int nvqs = v->nvqs; +u16 i;if (copy_from_user (&status, statusp,sizeof (status)))return -EFAULT ; + status_old = ops->get_status (vdpa); +/* * Userspace shouldn't remove status bits unless reset the * status to 0.
drivers/vhost/vdpa.c static long vhost_vdpa_set_status(struct vhost_vdpa *v, u8 __user *statusp) · line 225
Quoted 4 lines
drivers/vhost/vdpa.c +1
-0@@ -169,6 +222,15 @@ static long vhost_vdpa_set_status(struct vhost_vdpa *v, u8 __user *statusp) ops->set_status (vdpa, status); +/* vq irq is not expected to be changed once DRIVER_OK is set */
Let's move this comment to the get_vq_irq bus operation.
Quoted 32 lines
drivers/vhost/vdpa.c +11
-0+if ((status &VIRTIO_CONFIG_S_DRIVER_OK ) && !(status_old &VIRTIO_CONFIG_S_DRIVER_OK )) +for (i =0 ; i < nvqs; i++) +vhost_vdpa_setup_vq_irq (v, i); + +if ((status_old &VIRTIO_CONFIG_S_DRIVER_OK ) && !(status &VIRTIO_CONFIG_S_DRIVER_OK )) +for (i =0 ; i < nvqs; i++) +vhost_vdpa_unsetup_vq_irq (v, i); +return 0 ; }@@ -332,6 +394,7 @@ static long vhost_vdpa_set_config_call(struct vhost_vdpa *v, u32 __user *argp)return 0 ; } +static long vhost_vdpa_vring_ioctl (struct vhost_vdpa *v,unsigned int cmd,void __user *argp) {@@ -390,6 +453,7 @@ static long vhost_vdpa_vring_ioctl(struct vhost_vdpa *v, unsigned int cmd, cb.private =NULL ; } ops->set_vq_cb (vdpa, idx, &cb); +vhost_vdpa_update_vq_irq (vq);break ;case VHOST_SET_VRING_NUM :@@ -765,6 +829,18 @@ static int vhost_vdpa_open(struct inode *inode, struct file *filep)return r; } +static void vhost_vdpa_clean_irq (struct vhost_vdpa *v)
drivers/vhost/vdpa.c static int vhost_vdpa_open(struct inode *inode, struct file *filep) · line 842
Quoted 10 lines
drivers/vhost/vdpa.c +10
-0+{ +struct vhost_virtqueue *vq; +int i; + +for (i =0 ; i < v->nvqs; i++) { + vq = &v->vqs[i]; +if (vq->call_ctx.producer.irq) +irq_bypass_unregister_producer (&vq->call_ctx.producer); + } +}
Why not using vhost_vdpa_unsetup_vq_irq()?
Thanks
Quoted 12 lines
drivers/vhost/vdpa.c +2
-0+static int vhost_vdpa_release (struct inode *inode,struct file *filep) {struct vhost_vdpa *v = filep->private_data;@@ -777,6 +853,7 @@ static int vhost_vdpa_release(struct inode *inode, struct file *filep)vhost_vdpa_iotlb_free (v);vhost_vdpa_free_domain (v);vhost_vdpa_config_put (v); +vhost_vdpa_clean_irq (v);vhost_dev_cleanup (&v->vdev);kfree (v->vdev.vqs);mutex_unlock (&d->mutex);
A message that is not in the archive (sent off-list or not yet received): [email protected]
Michael S. Tsirkin
maintainerRe: [PATCH V5 4/6] vhost_vdpa: implement IRQ offloading in vhost_vdpa
Quoted 151 lines · Lingshan
On 8/4/2020 4:51 PM, Jason Wang wrote:
On 2020/7/31 下午2:55, Zhu Lingshan wrote: This patch introduce a set of functions for setup/unsetup and update irq offloading respectively by register/unregister and re-register the irq_bypass_producer. With these functions, this commit can setup/unsetup irq offloading through setting DRIVER_OK/!DRIVER_OK, and update irq offloading through SET_VRING_CALL. Signed-off-by: Zhu Lingshan <[email protected]> Suggested-by: Jason Wang <[email protected]> --- drivers/vhost/Kconfig | 1 + drivers/vhost/vdpa.c | 79 ++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 79 insertions(+), 1 deletion(-) diff --git a/drivers/vhost/Kconfig b/drivers/vhost/Kconfig index d3688c6afb87..587fbae06182 100644 --- a/drivers/vhost/Kconfig +++ b/drivers/vhost/Kconfig @@ -65,6 +65,7 @@ config VHOST_VDPA tristate "Vhost driver for vDPA-based backend" depends on EVENTFD select VHOST + select IRQ_BYPASS_MANAGER depends on VDPA help This kernel module can be loaded in host kernel to accelerate diff --git a/drivers/vhost/vdpa.c b/drivers/vhost/vdpa.c index df3cf386b0cd..278ea2f00172 100644 --- a/drivers/vhost/vdpa.c +++ b/drivers/vhost/vdpa.c @@ -115,6 +115,55 @@ static irqreturn_t vhost_vdpa_config_cb(void *private) return IRQ_HANDLED; } +static void vhost_vdpa_setup_vq_irq(struct vhost_vdpa *v, u16 qid) +{ + struct vhost_virtqueue *vq = &v->vqs[qid]; + const struct vdpa_config_ops *ops = v->vdpa->config; + struct vdpa_device *vdpa = v->vdpa; + int ret, irq; + + spin_lock(&vq->call_ctx.ctx_lock); + irq = ops->get_vq_irq(vdpa, qid); + if (!vq->call_ctx.ctx || irq < 0) { + spin_unlock(&vq->call_ctx.ctx_lock); + return; + } + + vq->call_ctx.producer.token = vq->call_ctx.ctx; + vq->call_ctx.producer.irq = irq; + ret = irq_bypass_register_producer(&vq->call_ctx.producer); + spin_unlock(&vq->call_ctx.ctx_lock); +} + +static void vhost_vdpa_unsetup_vq_irq(struct vhost_vdpa *v, u16 qid) +{ + struct vhost_virtqueue *vq = &v->vqs[qid]; + + spin_lock(&vq->call_ctx.ctx_lock); + irq_bypass_unregister_producer(&vq->call_ctx.producer); Any reason for not checking vq->call_ctx.producer.irq as below here?we only need ctx as a token to unregister vq from irq bypass manager, if
vq->call_ctx.producer.irqis 0, means it is a unused or disabled vq, no harm if we perform an unregister on it.+ spin_unlock(&vq->call_ctx.ctx_lock); +} + +static void vhost_vdpa_update_vq_irq(struct vhost_virtqueue *vq) +{ + spin_lock(&vq->call_ctx.ctx_lock); + /* + * if it has a non-zero irq, means there is a + * previsouly registered irq_bypass_producer, + * we should update it when ctx (its token) + * changes. + */ + if (!vq->call_ctx.producer.irq) { + spin_unlock(&vq->call_ctx.ctx_lock); + return; + } + + irq_bypass_unregister_producer(&vq->call_ctx.producer); + vq->call_ctx.producer.token = vq->call_ctx.ctx; + irq_bypass_register_producer(&vq->call_ctx.producer); + spin_unlock(&vq->call_ctx.ctx_lock); +} I think setup_irq() and update_irq() could be unified with the following logic: irq_bypass_unregister_producer(&vq->call_ctx.producer); irq = ops->get_vq_irq(vdpa, qid); if (!vq->call_ctx.ctx || irq < 0) { spin_unlock(&vq->call_ctx.ctx_lock); return; } vq->call_ctx.producer.token = vq->call_ctx.ctx; vq->call_ctx.producer.irq = irq; ret = irq_bypass_register_producer(&vq->call_ctx.producer);Yes, this code piece can do both register and update. Though it's rare to call
undate_irq(), howeversetup_irq()is very likely to be called for every vq, so this may cause several rounds of uselessirq_bypass_unregister_producer(). is it worth for simplify the code?+ static void vhost_vdpa_reset(struct vhost_vdpa *v) { struct vdpa_device *vdpa = v->vdpa; @@ -155,11 +204,15 @@ static long vhost_vdpa_set_status(struct vhost_vdpa *v, u8 __user *statusp) { struct vdpa_device *vdpa = v->vdpa; const struct vdpa_config_ops *ops = vdpa->config; - u8 status; + u8 status, status_old; + int nvqs = v->nvqs; + u16 i; if (copy_from_user(&status, statusp, sizeof(status))) return -EFAULT; + status_old = ops->get_status(vdpa); + /* * Userspace shouldn't remove status bits unless reset the * status to 0. @@ -169,6 +222,15 @@ static long vhost_vdpa_set_status(struct vhost_vdpa *v, u8 __user *statusp) ops->set_status(vdpa, status); + /* vq irq is not expected to be changed once DRIVER_OK is set */ Let's move this comment to the get_vq_irq bus operation.
Quoted 3 lines
OK, can do!
Patch on top pls, these are in my tree now.
Quoted 76 lines
+ if ((status & VIRTIO_CONFIG_S_DRIVER_OK) && !(status_old & VIRTIO_CONFIG_S_DRIVER_OK)) + for (i = 0; i < nvqs; i++) + vhost_vdpa_setup_vq_irq(v, i); + + if ((status_old & VIRTIO_CONFIG_S_DRIVER_OK) && !(status & VIRTIO_CONFIG_S_DRIVER_OK)) + for (i = 0; i < nvqs; i++) + vhost_vdpa_unsetup_vq_irq(v, i); + return 0; } @@ -332,6 +394,7 @@ static long vhost_vdpa_set_config_call(struct vhost_vdpa *v, u32 __user *argp) return 0; } + static long vhost_vdpa_vring_ioctl(struct vhost_vdpa *v, unsigned int cmd, void __user *argp) { @@ -390,6 +453,7 @@ static long vhost_vdpa_vring_ioctl(struct vhost_vdpa *v, unsigned int cmd, cb.private = NULL; } ops->set_vq_cb(vdpa, idx, &cb); + vhost_vdpa_update_vq_irq(vq); break; case VHOST_SET_VRING_NUM: @@ -765,6 +829,18 @@ static int vhost_vdpa_open(struct inode *inode, struct file *filep) return r; } +static void vhost_vdpa_clean_irq(struct vhost_vdpa *v) +{ + struct vhost_virtqueue *vq; + int i; + + for (i = 0; i < v->nvqs; i++) { + vq = &v->vqs[i]; + if (vq->call_ctx.producer.irq) + irq_bypass_unregister_producer(&vq->call_ctx.producer); + } +} Why not using vhost_vdpa_unsetup_vq_irq()?IMHO, in this cleanup phase, the device is almost dead, user space won't change ctx anymore, so I think we don't need to check ctx or irq, can just unregister it.
Thanks!
Thanks + static int vhost_vdpa_release(struct inode *inode, struct file *filep) { struct vhost_vdpa *v = filep->private_data; @@ -777,6 +853,7 @@ static int vhost_vdpa_release(struct inode *inode, struct file *filep) vhost_vdpa_iotlb_free(v); vhost_vdpa_free_domain(v); vhost_vdpa_config_put(v); + vhost_vdpa_clean_irq(v); vhost_dev_cleanup(&v->vdev); kfree(v->vdev.vqs); mutex_unlock(&d->mutex);
Re: [PATCH V5 4/6] vhost_vdpa: implement IRQ offloading in vhost_vdpa
In reply to a message not in the archiveQuoted 70 lines · Lingshan
Quoted 59 lines · Jason Wang
Quoted 57 lines · Zhu Lingshan
This patch introduce a set of functions for setup/unsetup and update irq offloading respectively by register/unregister and re-register the
irq_bypass_producer.With these functions, this commit can setup/unsetup irq offloading through setting DRIVER_OK/!DRIVER_OK, and update irq offloading through
SET_VRING_CALL.Signed-off-by Zhu Lingshan <[email protected]>Suggested-by Jason Wang <[email protected]>---
drivers/vhost/Kconfig| 1 +
drivers/vhost/vdpa.c | 79
++++++++++++++++++++++++++++++++++++++++++-2 files changed, 79 insertions(+), 1 deletion(-)drivers/vhost/Kconfig +0
-0@@ -65,6 +65,7 @@ config VHOST_VDPAtristate "Vhost driver for vDPA-based backend" depends on EVENTFD
select VHOST
+ selectIRQ_BYPASS_MANAGER
depends on VDPA
help
This kernel module can be loaded in host kernel to acceleratedrivers/vhost/vdpa.c +20
-0@@ -115,6 +115,55 @@ static irqreturn_t vhost_vdpa_config_cb(void *private) return IRQ_HANDLED; } +static void vhost_vdpa_setup_vq_irq(struct vhost_vdpa *v, u16 qid) +{ + struct vhost_virtqueue *vq = &v->vqs[qid]; + const struct vdpa_config_ops *ops = v->vdpa->config; + struct vdpa_device *vdpa = v->vdpa; + int ret, irq; + + spin_lock(&vq->call_ctx.ctx_lock); + irq = ops->get_vq_irq(vdpa, qid); + if (!vq->call_ctx.ctx || irq < 0) { + spin_unlock(&vq->call_ctx.ctx_lock); + return; + } + + vq->call_ctx.producer.token = vq->call_ctx.ctx; + vq->call_ctx.producer.irq = irq; + ret = irq_bypass_register_producer(&vq->call_ctx.producer); + spin_unlock(&vq->call_ctx.ctx_lock); +} + +static void vhost_vdpa_unsetup_vq_irq (struct vhost_vdpa *v,u16 qid)Quoted 8 lines
drivers/vhost/vdpa.c static irqreturn_t vhost_vdpa_config_cb(void *private) · line 143
Quoted 5 lines
drivers/vhost/vdpa.c +5
-0+{ + struct vhost_virtqueue *vq = &v->vqs[qid]; + + spin_lock(&vq->call_ctx.ctx_lock); +irq_bypass_unregister_producer (&vq->call_ctx.producer);Any reason for not checking
vq->call_ctx.producer.irqas below here?
Quoted 1 line
we only need ctx as a token to unregister vq from irq bypass manager, if
vq->call_ctx.producer.irqis 0, means it is a unused or disabled vq,
This is not how the code is wrote? See above you only check whether irq is negative, irq 0 seems acceptable.
+ spin_lock(&vq->call_ctx.ctx_lock);
+ irq = ops->get_vq_irq(vdpa, qid);
+ if (!vq->call_ctx.ctx || irq < 0) {
+ spin_unlock(&vq->call_ctx.ctx_lock);
+ return;
+ }
+
+ vq->call_ctx.producer.token = vq->call_ctx.ctx;
+ vq->call_ctx.producer.irq = irq;
+ ret = irq_bypass_register_producer(&vq->call_ctx.producer); + spin_unlock(&vq->call_ctx.ctx_lock);
Quoted 37 lines
no harm if we
perform an unregister on it.Quoted 35 lines
Quoted 14 lines
drivers/vhost/vdpa.c +12
-0+spin_unlock (&vq->call_ctx.ctx_lock); +} + +static void vhost_vdpa_update_vq_irq (struct vhost_virtqueue *vq) +{ + spin_lock(&vq->call_ctx.ctx_lock); + /* +* if it has a non-zero irq, means there is a +* previsouly registered irq_bypass_producer, +* we should update it when ctx (its token) +* changes. +*/ drivers/vhost/vdpa.c static irqreturn_t vhost_vdpa_config_cb(void *private) · line 165
Quoted 10 lines
drivers/vhost/vdpa.c +10
-0+ if (!vq->call_ctx.producer.irq) { + spin_unlock(&vq->call_ctx.ctx_lock); + return; + } + +irq_bypass_unregister_producer (&vq->call_ctx.producer); + vq->call_ctx.producer.token = vq->call_ctx.ctx; +irq_bypass_register_producer (&vq->call_ctx.producer); + spin_unlock(&vq->call_ctx.ctx_lock); +}I think
setup_irq()andupdate_irq()could be unified with the following logic:
irq_bypass_unregister_producer(&vq->call_ctx.producer); irq =ops->get_vq_irq(vdpa, qid);
if (!vq->call_ctx.ctx || irq < 0) {spin_unlock(&vq->call_ctx.ctx_lock); return;
}
Quoted 5 lines
Quoted 3 lines
vq->call_ctx.producer.token=vq->call_ctx.ctx;vq->call_ctx.producer.irq= irq;
ret =irq_bypass_register_producer(&vq->call_ctx.producer);Yes, this code piece can do both register and update. Though it's rare to call
undate_irq(), howeversetup_irq()is very likely to be called for every vq, so this may cause several rounds of uselessirq_bypass_unregister_producer().
I'm not sure I get this but do you have a case for this?
Quoted 1 line
is it worth for simplify the code?
Less code(bug).
Quoted 76 lines
Quoted 20 lines
Quoted 20 lines
drivers/vhost/vdpa.c +1
-0+ static void vhost_vdpa_reset(struct vhost_vdpa *v) {struct
vdpa_device*vdpa =v->vdpa;drivers/vhost/vdpa.c +4
-1@@ -155,11 +204,15 @@ static long vhost_vdpa_set_status(struct vhost_vdpa *v, u8 __user *statusp) { struct vdpa_device *vdpa = v->vdpa; const struct vdpa_config_ops *ops = vdpa->config; - u8 status; + u8 status, status_old; + int nvqs = v->nvqs; + u16 i; if (copy_from_user(&status, statusp, sizeof(status))) return -EFAULT; + status_old = ops->get_status(vdpa); + /** Userspace shouldn't remove status bits unless reset the Quoted 8 lines
Quoted 5 lines
drivers/vhost/vdpa.c +0
-0* status to 0.@@ -169,6 +222,15 @@ static long vhost_vdpa_set_status(struct vhost_vdpa *v, u8 __user *statusp) ops->set_status(vdpa, status);+ /* vq irq is not expected to be changed once
DRIVER_OKis set */Let's move this comment to the
get_vq_irqbus operation.OK, can do!
Quoted 39 lines
Quoted 39 lines
+ if ((status &
VIRTIO_CONFIG_S_DRIVER_OK) && !(status_old &VIRTIO_CONFIG_S_DRIVER_OK))
+ for (i = 0; i < nvqs; i++)
+vhost_vdpa_setup_vq_irq(v, i);
+
+ if ((status_old&VIRTIO_CONFIG_S_DRIVER_OK) && !(status &VIRTIO_CONFIG_S_DRIVER_OK))
+ for (i = 0; i < nvqs; i++)
+vhost_vdpa_unsetup_vq_irq(v, i);
+
return 0;
}
@@ -332,6 +394,7 @@ static longvhost_vdpa_set_config_call(struct vhost_vdpa *v, u32 __user *argp)return 0;
}
+
static long vhost_vdpa_vring_ioctl(structvhost_vdpa*v, unsigned int cmd,
void__user*argp)
{drivers/vhost/vdpa.c +1
-0@@ -390,6 +453,7 @@ static long vhost_vdpa_vring_ioctl(struct vhost_vdpa *v, unsigned int cmd, cb.private = NULL; } ops->set_vq_cb(vdpa, idx, &cb); + vhost_vdpa_update_vq_irq(vq); break;case
VHOST_SET_VRING_NUM:drivers/vhost/vdpa.c +5
-0@@ -765,6 +829,18 @@ static int vhost_vdpa_open(struct inode *inode, struct file *filep) return r; } +static void vhost_vdpa_clean_irq(struct vhost_vdpa *v) +{ + struct vhost_virtqueue *vq; + int i; + + for (i = 0; i < v->nvqs; i++) {Quoted 8 lines
drivers/vhost/vdpa.c static int vhost_vdpa_open(struct inode *inode, struct file *filep) · line 842
Quoted 5 lines
drivers/vhost/vdpa.c +5
-0+ vq = &v->vqs[i]; + if (vq->call_ctx.producer.irq) +irq_bypass_unregister_producer (&vq->call_ctx.producer); + } +}Why not using
vhost_vdpa_unsetup_vq_irq()?
Quoted 1 line
IMHO, in this cleanup phase, the device is almost dead, user space won't change ctx anymore, so I think we don't need to check ctx or irq,
But you check irq here? For ctx, irq_bypass_unregister_producer() can do the check instead of us.
Thanks
Quoted 21 lines
can just unregister it.
Thanks!
Quoted 18 lines
Thanks
Quoted 13 lines
drivers/vhost/vdpa.c +1
-0+ static int vhost_vdpa_release(struct inode *inode, struct file *filep) {struct
vhost_vdpa*v =filep->private_data;drivers/vhost/vdpa.c +1
-0@@ -777,6 +853,7 @@ static int vhost_vdpa_release(struct inode *inode, struct file *filep) vhost_vdpa_iotlb_free(v); vhost_vdpa_free_domain(v); vhost_vdpa_config_put(v); + vhost_vdpa_clean_irq(v); vhost_dev_cleanup(&v->vdev); kfree(v->vdev.vqs);
mutex_unlock(&d->mutex);
A message that is not in the archive (sent off-list or not yet received): [email protected]
Re: [PATCH V5 4/6] vhost_vdpa: implement IRQ offloading in vhost_vdpa
Quoted 134 lines · Lingshan
Quoted 72 lines · Jason Wang
Quoted 70 lines · Lingshan
Quoted 67 lines · Jason Wang
Quoted 52 lines · Zhu Lingshan
This patch introduce a set of functions for setup/unsetup and update irq offloading respectively by register/unregister and re-register the
irq_bypass_producer.With these functions, this commit can setup/unsetup irq offloading through setting DRIVER_OK/!DRIVER_OK, and update irq offloading through
SET_VRING_CALL.Signed-off-by Zhu Lingshan <[email protected]>Suggested-by Jason Wang <[email protected]>---
drivers/vhost/Kconfig| 1 +
drivers/vhost/vdpa.c | 79
++++++++++++++++++++++++++++++++++++++++++-2 files changed, 79 insertions(+), 1 deletion(-)drivers/vhost/Kconfig +0
-0@@ -65,6 +65,7 @@ config VHOST_VDPAtristate "Vhost driver for vDPA-based backend" depends on EVENTFD
select VHOST
+ selectIRQ_BYPASS_MANAGER
depends on VDPA
help
This kernel module can be loaded in host kernel to acceleratedrivers/vhost/vdpa.c +15
-0@@ -115,6 +115,55 @@ static irqreturn_t vhost_vdpa_config_cb(void *private) return IRQ_HANDLED; } +static void vhost_vdpa_setup_vq_irq(struct vhost_vdpa *v, u16 qid) +{ + struct vhost_virtqueue *vq = &v->vqs[qid]; + const struct vdpa_config_ops *ops = v->vdpa->config; + struct vdpa_device *vdpa = v->vdpa; + int ret, irq; + + spin_lock(&vq->call_ctx.ctx_lock); + irq = ops->get_vq_irq(vdpa, qid); + if (!vq->call_ctx.ctx || irq < 0) { +spin_unlock (&vq->call_ctx.ctx_lock); + return; + } + + vq->call_ctx.producer.token = vq->call_ctx.ctx; + vq->call_ctx.producer.irq = irq;drivers/vhost/vdpa.c static irqreturn_t vhost_vdpa_config_cb(void · line 143
Quoted 10 lines
drivers/vhost/vdpa.c +10
-0+ ret = irq_bypass_register_producer(&vq->call_ctx.producer); + spin_unlock(&vq->call_ctx.ctx_lock); +} + +static void vhost_vdpa_unsetup_vq_irq (struct vhost_vdpa *v,u16 qid) +{ + struct vhost_virtqueue *vq = &v->vqs[qid]; + + spin_lock(&vq->call_ctx.ctx_lock); +irq_bypass_unregister_producer (&vq->call_ctx.producer);Any reason for not checking
vq->call_ctx.producer.irqas below here?Quoted 4 lines
Quoted 1 line
we only need ctx as a token to unregister vq from irq bypass manager, if
vq->call_ctx.producer.irqis 0, means it is a unused or disabled vq,This is not how the code is wrote? See above you only check whether irq is negative, irq 0 seems acceptable.
Yes, IRQ 0 is valid, so we check whether it is < 0.
Quoted 54 lines
+
spin_lock(&vq->call_ctx.ctx_lock);
+ irq =ops->get_vq_irq(vdpa, qid);
+ if (!vq->call_ctx.ctx || irq < 0) {
+spin_unlock(&vq->call_ctx.ctx_lock);
+ return;
+ }
+
+vq->call_ctx.producer.token=vq->call_ctx.ctx;
+vq->call_ctx.producer.irq= irq;
+ ret =irq_bypass_register_producer(&vq->call_ctx.producer); +spin_unlock(&vq->call_ctx.ctx_lock);Quoted 40 lines
no harm if we
perform an unregister on it.Quoted 38 lines
Quoted 14 lines
drivers/vhost/vdpa.c +12
-0+spin_unlock (&vq->call_ctx.ctx_lock); +} + +static void vhost_vdpa_update_vq_irq (struct vhost_virtqueue *vq) +{ + spin_lock(&vq->call_ctx.ctx_lock); + /* +* if it has a non-zero irq, means there is a +* previsouly registered irq_bypass_producer, +* we should update it when ctx (its token) +* changes. +*/ drivers/vhost/vdpa.c static irqreturn_t vhost_vdpa_config_cb(void *private) · line 165
Quoted 10 lines
drivers/vhost/vdpa.c +10
-0+ if (!vq->call_ctx.producer.irq) { +spin_unlock (&vq->call_ctx.ctx_lock); + return; + } + +irq_bypass_unregister_producer (&vq->call_ctx.producer); + vq->call_ctx.producer.token = vq->call_ctx.ctx; +irq_bypass_register_producer (&vq->call_ctx.producer); + spin_unlock(&vq->call_ctx.ctx_lock); +}I think
setup_irq()andupdate_irq()could be unified with the following logic:
irq_bypass_unregister_producer(&vq->call_ctx.producer); irq =ops->get_vq_irq(vdpa, qid);
if (!vq->call_ctx.ctx || irq < 0) {spin_unlock(&vq->call_ctx.ctx_lock); return;
}
vq->call_ctx.producer.token=vq->call_ctx.ctx;vq->call_ctx.producer.irq= irq;
ret =irq_bypass_register_producer(&vq->call_ctx.producer);
Quoted 6 lines
Quoted 5 lines
Quoted 2 lines
Yes, this code piece can do both register and update. Though it's rare to call
undate_irq(), howeversetup_irq()is very likely to be called for every vq, so this may cause several rounds of uselessirq_bypass_unregister_producer().I'm not sure I get this but do you have a case for this?
I mean if we use this routine to setup irq offloading, it is very likely to do a unregister producer for every vq first, but for nothing.
Does it really harm? See vfio_msi_set_vector_signal()
Quoted 8 lines
Quoted 6 lines
Quoted 3 lines
is it worth for simplify the code?
Less code(bug).
I can do this if we are chasing for perfection, however I believe bug number has positive correlation with the complexity in the logic than code lines, if we only merge lines, this may not help.
Quoted 1 line
Well, reduce code duplication is always good and it helps for reviewers.
Quoted 77 lines
Quoted 77 lines
Quoted 77 lines
Quoted 21 lines
Quoted 21 lines
drivers/vhost/vdpa.c +1
-0+ static void vhost_vdpa_reset(struct vhost_vdpa *v) {struct
vdpa_device*vdpa =v->vdpa;drivers/vhost/vdpa.c +4
-1@@ -155,11 +204,15 @@ static long vhost_vdpa_set_status(struct vhost_vdpa *v, u8 __user *statusp) { struct vdpa_device *vdpa = v->vdpa; const struct vdpa_config_ops *ops = vdpa->config; - u8 status; + u8 status, status_old; + int nvqs = v->nvqs; + u16 i; if (copy_from_user(&status, statusp, sizeof(status))) return -EFAULT; + status_old = ops->get_status(vdpa); + /** Userspace shouldn't remove status bits unless reset the Quoted 8 lines
Quoted 5 lines
drivers/vhost/vdpa.c +0
-0* status to 0.@@ -169,6 +222,15 @@ static long vhost_vdpa_set_status(struct vhost_vdpa *v, u8 __user *statusp) ops->set_status(vdpa, status);+ /* vq irq is not expected to be changed once
DRIVER_OKis set */Let's move this comment to the
get_vq_irqbus operation.OK, can do!
Quoted 47 lines
Quoted 34 lines
+ if ((status &
VIRTIO_CONFIG_S_DRIVER_OK) && !(status_old &VIRTIO_CONFIG_S_DRIVER_OK))
+ for (i = 0; i < nvqs; i++)
+vhost_vdpa_setup_vq_irq(v, i);
+
+ if ((status_old&VIRTIO_CONFIG_S_DRIVER_OK) && !(status &VIRTIO_CONFIG_S_DRIVER_OK))
+ for (i = 0; i < nvqs; i++)
+vhost_vdpa_unsetup_vq_irq(v, i);
+
return 0;
}
@@ -332,6 +394,7 @@ static longvhost_vdpa_set_config_call(struct vhost_vdpa *v, u32 __user *argp)return 0;
}
+
static long vhost_vdpa_vring_ioctl(structvhost_vdpa*v, unsigned int cmd,
void__user*argp)
{drivers/vhost/vdpa.c +1
-0@@ -390,6 +453,7 @@ static long vhost_vdpa_vring_ioctl(struct vhost_vdpa *v, unsigned int cmd, cb.private = NULL; } ops->set_vq_cb(vdpa, idx, &cb); + vhost_vdpa_update_vq_irq(vq); break;case
VHOST_SET_VRING_NUM:drivers/vhost/vdpa.c +0
-0@@ -765,6 +829,18 @@ static int vhost_vdpa_open(struct inode *inode, struct file *filep) return r; } +static void vhost_vdpa_clean_irq(struct vhost_vdpa *v)drivers/vhost/vdpa.c static int vhost_vdpa_open(struct inode · line 842
Quoted 10 lines
drivers/vhost/vdpa.c +10
-0+{ + struct vhost_virtqueue *vq; + int i; + + for (i = 0; i < v->nvqs; i++) { + vq = &v->vqs[i]; + if (vq->call_ctx.producer.irq) +irq_bypass_unregister_producer (&vq->call_ctx.producer); + } +}Why not using
vhost_vdpa_unsetup_vq_irq()?
Quoted 7 lines
Quoted 4 lines
Quoted 1 line
IMHO, in this cleanup phase, the device is almost dead, user space won't change ctx anymore, so I think we don't need to check ctx or irq,
But you check irq here? For ctx,
irq_bypass_unregister_producer()can do the check instead of us.IMHO, maybe irq does not matter, (1)if the vq not registered to irq bypass manager, producer.irq is not valid, token == NULL,
irq_bypass_unregisterwould no nothing. (2)if the vq registered to irq bypass manager, producer.irq is valid,irq_bypass_unregisterwill do its work based on the token.
so maybe we can say irq is relative to the token, we may don't need to check irq here.
So you agree to use vhost_vdpa_unsetup_vq_irq()?
Thanks
Quoted 28 lines
Thanks!
Quoted 26 lines
Thanks
Quoted 21 lines
can just unregister it.
Thanks!
Quoted 18 lines
Thanks
Quoted 13 lines
drivers/vhost/vdpa.c +1
-0+ static int vhost_vdpa_release(struct inode *inode, struct file *filep) {struct
vhost_vdpa*v =filep->private_data;drivers/vhost/vdpa.c +1
-0@@ -777,6 +853,7 @@ static int vhost_vdpa_release(struct inode *inode, struct file *filep) vhost_vdpa_iotlb_free(v); vhost_vdpa_free_domain(v); vhost_vdpa_config_put(v); + vhost_vdpa_clean_irq(v); vhost_dev_cleanup(&v->vdev); kfree(v->vdev.vqs);
mutex_unlock(&d->mutex);
Re: [PATCH V5 4/6] vhost_vdpa: implement IRQ offloading in vhost_vdpa
In reply to Zhu Lingshandrivers/vhost/vdpa.c static irqreturn_t vhost_vdpa_config_cb(void *private) · line 126
Quoted 9 lines · Zhu Lingshan
drivers/vhost/vdpa.c +9
-0+static void vhost_vdpa_setup_vq_irq (struct vhost_vdpa *v,u16 qid) +{ +struct vhost_virtqueue *vq = &v->vqs[qid]; +const struct vdpa_config_ops *ops = v->vdpa->config; +struct vdpa_device *vdpa = v->vdpa; +int ret, irq; + +spin_lock (&vq->call_ctx.ctx_lock); + irq = ops->get_vq_irq (vdpa, qid);
Btw, this assumes that get_vq_irq is mandatory. This looks wrong since there's no guarantee that the vDPA device driver can see irq. And this break vdpa simulator.
Let's add a check and make it optional by document this assumption in the vdpa.h.
Thanks
drivers/vhost/vdpa.c static irqreturn_t vhost_vdpa_config_cb(void *private) · line 131
Quoted 5 lines
drivers/vhost/vdpa.c +5
-0+if (!vq->call_ctx.ctx || irq <0 ) { +spin_unlock (&vq->call_ctx.ctx_lock); +return ; + } +
_______________________________________________
Virtualization mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/virtualization
Re: [PATCH V5 4/6] vhost_vdpa: implement IRQ offloading in vhost_vdpa
Quoted 15 lines · Jason Wang
drivers/vhost/vdpa.c static irqreturn_t vhost_vdpa_config_cb(void *private) · line 126
Quoted 9 lines · Zhu Lingshan
drivers/vhost/vdpa.c +9
-0+static void vhost_vdpa_setup_vq_irq (struct vhost_vdpa *v,u16 qid) +{ + struct vhost_virtqueue *vq = &v->vqs[qid]; + const struct vdpa_config_ops *ops = v->vdpa->config; + struct vdpa_device *vdpa = v->vdpa; + int ret, irq; + + spin_lock(&vq->call_ctx.ctx_lock); + irq = ops->get_vq_irq(vdpa, qid);Btw, this assumes that
get_vq_irqis mandatory. This looks wrong since there's no guarantee that the vDPA device driver can see irq. And this break vdpa simulator.
Quoted 1 line
Let's add a check and make it optional by document this assumption in the
vdpa.h.
fix soon. Thanks!
Quoted 10 lines
Thanks
Quoted 5 lines
+ if (!vq->call_ctx.ctx || irq < 0) {
+spin_unlock(&vq->call_ctx.ctx_lock);
+ return;
+ }
+
PATCH v5 5/6 ifcvf: implement vdpa_config_ops.get_vq_irq()
In reply to Zhu LingshanThis commit implemented vdpa_config_ops.get_vq_irq() in ifcvf, and initialized vq irq to -EINVAL. So that ifcvf can report irq number of a vq, or -EINVAL if the vq is not assigned an irq number.
--- drivers/vdpa/ifcvf/ifcvf_main.c | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-)
drivers/vdpa/ifcvf/ifcvf_main.c +16 -2
@@ -50,8 +50,10 @@ static void ifcvf_free_irq(struct ifcvf_adapter *adapter, int queues)int i; -for (i =0 ; i < queues; i++) +for (i =0 ; i < queues; i++) {devm_free_irq (&pdev->dev, vf->vring[i].irq, &vf->vring[i]); + vf->vring[i].irq = -EINVAL ; + }ifcvf_free_irq_vectors (pdev); }
@@ -352,6 +354,14 @@ static void ifcvf_vdpa_set_config_cb(struct vdpa_device *vdpa_dev, vf->config_cb.private = cb->private; } +static int ifcvf_vdpa_get_vq_irq (struct vdpa_device *vdpa_dev, +u16 qid) +{ +struct ifcvf_hw *vf =vdpa_to_vf (vdpa_dev); + +return vf->vring[qid].irq; +} +/* * IFCVF currently does't have on-chip IOMMU, so not * implemented set_map()/dma_map()/dma_unmap()
@@ -369,6 +379,7 @@ static const struct vdpa_config_ops ifc_vdpa_ops = { .get_vq_ready = ifcvf_vdpa_get_vq_ready, .set_vq_num = ifcvf_vdpa_set_vq_num, .set_vq_address = ifcvf_vdpa_set_vq_address, + .get_vq_irq = ifcvf_vdpa_get_vq_irq, .kick_vq = ifcvf_vdpa_kick_vq, .get_generation = ifcvf_vdpa_get_generation, .get_device_id = ifcvf_vdpa_get_device_id,
@@ -384,7 +395,7 @@ static int ifcvf_probe(struct pci_dev *pdev, const struct pci_device_id *id)struct device *dev = &pdev->dev;struct ifcvf_adapter *adapter;struct ifcvf_hw *vf; -int ret; +int ret, i; ret =pcim_enable_device (pdev);if (ret) {
@@ -441,6 +452,9 @@ static int ifcvf_probe(struct pci_dev *pdev, const struct pci_device_id *id) goto err; } +for (i =0 ; i <IFCVF_MAX_QUEUE_PAIRS *2 ; i++) + vf->vring[i].irq = -EINVAL ; + ret =vdpa_register_device (&adapter->vdpa);if (ret) {IFCVF_ERR (pdev,"Failed to register ifcvf to vdpa bus" );
Signature · 1 line
2.18.4
PATCH v5 6/6 irqbypass: do not start cons/prod when failed connect
In reply to Zhu LingshanIf failed to connect, there is no need to start consumer nor producer.
--- virt/lib/irqbypass.c | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-)
virt/lib/irqbypass.c +10 -6
@@ -40,17 +40,21 @@ static int __connect(struct irq_bypass_producer *prod,if (prod->add_consumer) ret = prod->add_consumer (prod, cons); -if (!ret) { - ret = cons->add_producer (cons, prod); -if (ret && prod->del_consumer) - prod->del_consumer (prod, cons); - } +if (ret) + goto err_add_consumer; + + ret = cons->add_producer (cons, prod); +if (ret) + goto err_add_producer;if (cons->start) cons->start (cons);if (prod->start) prod->start (prod); - +err_add_producer: +if (prod->del_consumer) + prod->del_consumer (prod, cons); +err_add_consumer:return ret; }
Signature · 1 line
2.18.4