[PATCH v1 0/2] vhost: add unsafe API to get DMA inflight packets

[PATCH v1 0/2] vhost: add unsafe API to get DMA inflight packets

[xuan.ding]

From: Xuan Ding <xuan.ding@intel.com>

This patchset introduces an unsafe API to get the number of inflight
packets in DMA engine. It should be only used within the vhost ops
which already holds the lock. Like vring state changes or device is
destroyed. Compared with rte_vhost_async_get_inflight(), this is a
lock free version.

RFC v1->v1:
* refine the doc and commit log

Xuan Ding (2):
  vhost: add unsafe API to check inflight packets
  examples/vhost: use API to check inflight packets

 doc/guides/prog_guide/vhost_lib.rst    |  6 ++++++
 doc/guides/rel_notes/release_22_07.rst |  4 ++++
 examples/vhost/main.c                  | 28 ++++++++++++++------------
 examples/vhost/main.h                  |  1 -
 lib/vhost/rte_vhost_async.h            | 17 ++++++++++++++++
 lib/vhost/version.map                  |  4 ++++
 lib/vhost/vhost.c                      | 26 ++++++++++++++++++++++++
 7 files changed, 72 insertions(+), 14 deletions(-)

-- 
2.17.1

[PATCH v1 1/2] vhost: add unsafe API to check inflight packets

[xuan.ding]

From: Xuan Ding <xuan.ding@intel.com>

In async data path, when vring state changes or device is destroyed,
it is necessary to know the number of inflight packets in DMA engine.
This patch provides a thread unsafe API to return the number of
inflight packets for a vhost queue without using any lock.

Signed-off-by: Xuan Ding <xuan.ding@intel.com>
---
 doc/guides/prog_guide/vhost_lib.rst    |  6 ++++++
 doc/guides/rel_notes/release_22_07.rst |  4 ++++
 lib/vhost/rte_vhost_async.h            | 17 +++++++++++++++++
 lib/vhost/version.map                  |  4 ++++
 lib/vhost/vhost.c                      | 26 ++++++++++++++++++++++++++
 5 files changed, 57 insertions(+)

diff --git a/doc/guides/prog_guide/vhost_lib.rst b/doc/guides/prog_guide/vhost_lib.rst
index 886f8f5e72..f287b76ebf 100644
--- a/doc/guides/prog_guide/vhost_lib.rst
+++ b/doc/guides/prog_guide/vhost_lib.rst
@@ -271,6 +271,12 @@ The following is an overview of some key Vhost API functions:
   This function returns the amount of in-flight packets for the vhost
   queue using async acceleration.
 
+ * ``rte_vhost_async_get_inflight_thread_unsafe(vid, queue_id)``
+
+  Get the number of inflight packets for a vhost queue without performing
+  any locking. It should only be used within the vhost ops, which already
+  holds the lock.
+
 * ``rte_vhost_clear_queue_thread_unsafe(vid, queue_id, **pkts, count, dma_id, vchan_id)``
 
   Clear inflight packets which are submitted to DMA engine in vhost async data
diff --git a/doc/guides/rel_notes/release_22_07.rst b/doc/guides/rel_notes/release_22_07.rst
index 42a5f2d990..a0c5d9459b 100644
--- a/doc/guides/rel_notes/release_22_07.rst
+++ b/doc/guides/rel_notes/release_22_07.rst
@@ -55,6 +55,10 @@ New Features
      Also, make sure to start the actual text at the margin.
      =======================================================
 
+* **Added vhost API to get the number of inflight packets.**
+
+  Added an API which can get the number of inflight packets in
+  vhost async data path without using lock.
 
 Removed Items
 -------------
diff --git a/lib/vhost/rte_vhost_async.h b/lib/vhost/rte_vhost_async.h
index f1293c6a9d..70234debf9 100644
--- a/lib/vhost/rte_vhost_async.h
+++ b/lib/vhost/rte_vhost_async.h
@@ -139,6 +139,23 @@ uint16_t rte_vhost_poll_enqueue_completed(int vid, uint16_t queue_id,
 __rte_experimental
 int rte_vhost_async_get_inflight(int vid, uint16_t queue_id);
 
+/**
+ * This function is lock-free version to return the amount of in-flight
+ * packets for the vhost queue which uses async channel acceleration.
+ *
+ * @note This function does not perform any locking, it should only be
+ * used within the vhost ops, which already holds the lock.
+ *
+ * @param vid
+ * id of vhost device to enqueue data
+ * @param queue_id
+ * queue id to enqueue data
+ * @return
+ * the amount of in-flight packets on success; -1 on failure
+ */
+__rte_experimental
+int rte_vhost_async_get_inflight_thread_unsafe(int vid, uint16_t queue_id);
+
 /**
  * This function checks async completion status and clear packets for
  * a specific vhost device queue. Packets which are inflight will be
diff --git a/lib/vhost/version.map b/lib/vhost/version.map
index 0a66c5840c..5841315386 100644
--- a/lib/vhost/version.map
+++ b/lib/vhost/version.map
@@ -87,6 +87,10 @@ EXPERIMENTAL {
 
 	# added in 22.03
 	rte_vhost_async_dma_configure;
+
+	# added in 22.07
+	rte_vhost_async_get_inflight_thread_unsafe;
+
 };
 
 INTERNAL {
diff --git a/lib/vhost/vhost.c b/lib/vhost/vhost.c
index 2f96a28dac..df0bb9d043 100644
--- a/lib/vhost/vhost.c
+++ b/lib/vhost/vhost.c
@@ -1907,6 +1907,32 @@ rte_vhost_async_get_inflight(int vid, uint16_t queue_id)
 	return ret;
 }
 
+int
+rte_vhost_async_get_inflight_thread_unsafe(int vid, uint16_t queue_id)
+{
+	struct vhost_virtqueue *vq;
+	struct virtio_net *dev = get_device(vid);
+	int ret = -1;
+
+	if (dev == NULL)
+		return ret;
+
+	if (queue_id >= VHOST_MAX_VRING)
+		return ret;
+
+	vq = dev->virtqueue[queue_id];
+
+	if (vq == NULL)
+		return ret;
+
+	if (!vq->async)
+		return ret;
+
+	ret = vq->async->pkts_inflight_n;
+
+	return ret;
+}
+
 int
 rte_vhost_get_monitor_addr(int vid, uint16_t queue_id,
 		struct rte_vhost_power_monitor_cond *pmc)
-- 
2.17.1

[PATCH v1 2/2] examples/vhost: use API to check inflight packets

[xuan.ding]

From: Xuan Ding <xuan.ding@intel.com>

In async data path, call rte_vhost_async_get_inflight_thread_unsafe()
API to directly return the number of inflight packets instead of
maintaining a local variable.

Signed-off-by: Xuan Ding <xuan.ding@intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
---
 examples/vhost/main.c | 28 +++++++++++++++-------------
 examples/vhost/main.h |  1 -
 2 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/examples/vhost/main.c b/examples/vhost/main.c
index d94fabb060..c4d46de1c5 100644
--- a/examples/vhost/main.c
+++ b/examples/vhost/main.c
@@ -994,10 +994,8 @@ complete_async_pkts(struct vhost_dev *vdev)
 
 	complete_count = rte_vhost_poll_enqueue_completed(vdev->vid,
 					VIRTIO_RXQ, p_cpl, MAX_PKT_BURST, dma_id, 0);
-	if (complete_count) {
+	if (complete_count)
 		free_pkts(p_cpl, complete_count);
-		__atomic_sub_fetch(&vdev->pkts_inflight, complete_count, __ATOMIC_SEQ_CST);
-	}
 
 }
 
@@ -1039,7 +1037,6 @@ drain_vhost(struct vhost_dev *vdev)
 
 		complete_async_pkts(vdev);
 		ret = rte_vhost_submit_enqueue_burst(vdev->vid, VIRTIO_RXQ, m, nr_xmit, dma_id, 0);
-		__atomic_add_fetch(&vdev->pkts_inflight, ret, __ATOMIC_SEQ_CST);
 
 		enqueue_fail = nr_xmit - ret;
 		if (enqueue_fail)
@@ -1368,7 +1365,6 @@ drain_eth_rx(struct vhost_dev *vdev)
 		complete_async_pkts(vdev);
 		enqueue_count = rte_vhost_submit_enqueue_burst(vdev->vid,
 					VIRTIO_RXQ, pkts, rx_count, dma_id, 0);
-		__atomic_add_fetch(&vdev->pkts_inflight, enqueue_count, __ATOMIC_SEQ_CST);
 
 		enqueue_fail = rx_count - enqueue_count;
 		if (enqueue_fail)
@@ -1540,14 +1536,17 @@ destroy_device(int vid)
 
 	if (dma_bind[vid].dmas[VIRTIO_RXQ].async_enabled) {
 		uint16_t n_pkt = 0;
+		int pkts_inflight;
 		int16_t dma_id = dma_bind[vid].dmas[VIRTIO_RXQ].dev_id;
-		struct rte_mbuf *m_cpl[vdev->pkts_inflight];
+		pkts_inflight = rte_vhost_async_get_inflight_thread_unsafe(vid, VIRTIO_RXQ);
+		struct rte_mbuf *m_cpl[pkts_inflight];
 
-		while (vdev->pkts_inflight) {
+		while (pkts_inflight) {
 			n_pkt = rte_vhost_clear_queue_thread_unsafe(vid, VIRTIO_RXQ,
-						m_cpl, vdev->pkts_inflight, dma_id, 0);
+						m_cpl, pkts_inflight, dma_id, 0);
 			free_pkts(m_cpl, n_pkt);
-			__atomic_sub_fetch(&vdev->pkts_inflight, n_pkt, __ATOMIC_SEQ_CST);
+			pkts_inflight = rte_vhost_async_get_inflight_thread_unsafe(vid,
+										VIRTIO_RXQ);
 		}
 
 		rte_vhost_async_channel_unregister(vid, VIRTIO_RXQ);
@@ -1651,14 +1650,17 @@ vring_state_changed(int vid, uint16_t queue_id, int enable)
 	if (dma_bind[vid].dmas[queue_id].async_enabled) {
 		if (!enable) {
 			uint16_t n_pkt = 0;
+			int pkts_inflight;
+			pkts_inflight = rte_vhost_async_get_inflight_thread_unsafe(vid, queue_id);
 			int16_t dma_id = dma_bind[vid].dmas[VIRTIO_RXQ].dev_id;
-			struct rte_mbuf *m_cpl[vdev->pkts_inflight];
+			struct rte_mbuf *m_cpl[pkts_inflight];
 
-			while (vdev->pkts_inflight) {
+			while (pkts_inflight) {
 				n_pkt = rte_vhost_clear_queue_thread_unsafe(vid, queue_id,
-							m_cpl, vdev->pkts_inflight, dma_id, 0);
+							m_cpl, pkts_inflight, dma_id, 0);
 				free_pkts(m_cpl, n_pkt);
-				__atomic_sub_fetch(&vdev->pkts_inflight, n_pkt, __ATOMIC_SEQ_CST);
+				pkts_inflight = rte_vhost_async_get_inflight_thread_unsafe(vid,
+											queue_id);
 			}
 		}
 	}
diff --git a/examples/vhost/main.h b/examples/vhost/main.h
index b4a453e77e..e7f395c3c9 100644
--- a/examples/vhost/main.h
+++ b/examples/vhost/main.h
@@ -52,7 +52,6 @@ struct vhost_dev {
 	uint64_t features;
 	size_t hdr_len;
 	uint16_t nr_vrings;
-	uint16_t pkts_inflight;
 	struct rte_vhost_memory *mem;
 	struct device_statistics stats;
 	TAILQ_ENTRY(vhost_dev) global_vdev_entry;
-- 
2.17.1

Re: [PATCH v1 1/2] vhost: add unsafe API to check inflight packets

[Maxime Coquelin]

On 4/8/22 12:22, xuan.ding@intel.com wrote:
> From: Xuan Ding <xuan.ding@intel.com>
> 
> In async data path, when vring state changes or device is destroyed,
> it is necessary to know the number of inflight packets in DMA engine.
> This patch provides a thread unsafe API to return the number of
> inflight packets for a vhost queue without using any lock.
> 
> Signed-off-by: Xuan Ding <xuan.ding@intel.com>
> ---
>   doc/guides/prog_guide/vhost_lib.rst    |  6 ++++++
>   doc/guides/rel_notes/release_22_07.rst |  4 ++++
>   lib/vhost/rte_vhost_async.h            | 17 +++++++++++++++++
>   lib/vhost/version.map                  |  4 ++++
>   lib/vhost/vhost.c                      | 26 ++++++++++++++++++++++++++
>   5 files changed, 57 insertions(+)
> 
> diff --git a/doc/guides/prog_guide/vhost_lib.rst b/doc/guides/prog_guide/vhost_lib.rst
> index 886f8f5e72..f287b76ebf 100644
> --- a/doc/guides/prog_guide/vhost_lib.rst
> +++ b/doc/guides/prog_guide/vhost_lib.rst
> @@ -271,6 +271,12 @@ The following is an overview of some key Vhost API functions:
>     This function returns the amount of in-flight packets for the vhost
>     queue using async acceleration.
>   
> + * ``rte_vhost_async_get_inflight_thread_unsafe(vid, queue_id)``
> +
> +  Get the number of inflight packets for a vhost queue without performing
> +  any locking. It should only be used within the vhost ops, which already
> +  holds the lock.
> +
>   * ``rte_vhost_clear_queue_thread_unsafe(vid, queue_id, **pkts, count, dma_id, vchan_id)``
>   
>     Clear inflight packets which are submitted to DMA engine in vhost async data
> diff --git a/doc/guides/rel_notes/release_22_07.rst b/doc/guides/rel_notes/release_22_07.rst
> index 42a5f2d990..a0c5d9459b 100644
> --- a/doc/guides/rel_notes/release_22_07.rst
> +++ b/doc/guides/rel_notes/release_22_07.rst
> @@ -55,6 +55,10 @@ New Features
>        Also, make sure to start the actual text at the margin.
>        =======================================================
>   
> +* **Added vhost API to get the number of inflight packets.**
> +
> +  Added an API which can get the number of inflight packets in
> +  vhost async data path without using lock.
>   
>   Removed Items
>   -------------
> diff --git a/lib/vhost/rte_vhost_async.h b/lib/vhost/rte_vhost_async.h
> index f1293c6a9d..70234debf9 100644
> --- a/lib/vhost/rte_vhost_async.h
> +++ b/lib/vhost/rte_vhost_async.h
> @@ -139,6 +139,23 @@ uint16_t rte_vhost_poll_enqueue_completed(int vid, uint16_t queue_id,
>   __rte_experimental
>   int rte_vhost_async_get_inflight(int vid, uint16_t queue_id);
>   
> +/**
> + * This function is lock-free version to return the amount of in-flight
> + * packets for the vhost queue which uses async channel acceleration.
> + *
> + * @note This function does not perform any locking, it should only be
> + * used within the vhost ops, which already holds the lock.
> + *
> + * @param vid
> + * id of vhost device to enqueue data
> + * @param queue_id
> + * queue id to enqueue data
> + * @return
> + * the amount of in-flight packets on success; -1 on failure
> + */
> +__rte_experimental
> +int rte_vhost_async_get_inflight_thread_unsafe(int vid, uint16_t queue_id);
> +
>   /**
>    * This function checks async completion status and clear packets for
>    * a specific vhost device queue. Packets which are inflight will be
> diff --git a/lib/vhost/version.map b/lib/vhost/version.map
> index 0a66c5840c..5841315386 100644
> --- a/lib/vhost/version.map
> +++ b/lib/vhost/version.map
> @@ -87,6 +87,10 @@ EXPERIMENTAL {
>   
>   	# added in 22.03
>   	rte_vhost_async_dma_configure;
> +
> +	# added in 22.07
> +	rte_vhost_async_get_inflight_thread_unsafe;
> +
>   };
>   
>   INTERNAL {
> diff --git a/lib/vhost/vhost.c b/lib/vhost/vhost.c
> index 2f96a28dac..df0bb9d043 100644
> --- a/lib/vhost/vhost.c
> +++ b/lib/vhost/vhost.c
> @@ -1907,6 +1907,32 @@ rte_vhost_async_get_inflight(int vid, uint16_t queue_id)
>   	return ret;
>   }
>   
> +int
> +rte_vhost_async_get_inflight_thread_unsafe(int vid, uint16_t queue_id)
> +{
> +	struct vhost_virtqueue *vq;
> +	struct virtio_net *dev = get_device(vid);
> +	int ret = -1;
> +
> +	if (dev == NULL)
> +		return ret;
> +
> +	if (queue_id >= VHOST_MAX_VRING)
> +		return ret;
> +
> +	vq = dev->virtqueue[queue_id];
> +
> +	if (vq == NULL)
> +		return ret;

FYI, I'm going to post a patch that adds a call to
rte_spinlock_is_locked() to catch possible misuses of the API.

> +	if (!vq->async)
> +		return ret;
> +
> +	ret = vq->async->pkts_inflight_n;
> +
> +	return ret;
> +}
> +
>   int
>   rte_vhost_get_monitor_addr(int vid, uint16_t queue_id,
>   		struct rte_vhost_power_monitor_cond *pmc)
> 

Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>

Thanks,
Maxime

Re: [PATCH v1 0/2] vhost: add unsafe API to get DMA inflight packets

[Maxime Coquelin]

On 4/8/22 12:22, xuan.ding@intel.com wrote:
 > This patchset introduces an unsafe API to get the number of inflight
 > packets in DMA engine. It should be only used within the vhost ops
 > which already holds the lock. Like vring state changes or device is
 > destroyed. Compared with rte_vhost_async_get_inflight(), this is a
 > lock free version.
 >
 > RFC v1->v1:
 > * refine the doc and commit log
 >
 > Xuan Ding (2):
 >   vhost: add unsafe API to check inflight packets
 >   examples/vhost: use API to check inflight packets
 >
 >  doc/guides/prog_guide/vhost_lib.rst    |  6 ++++++
 >  doc/guides/rel_notes/release_22_07.rst |  4 ++++
 >  examples/vhost/main.c                  | 28 ++++++++++++++------------
 >  examples/vhost/main.h                  |  1 -
 >  lib/vhost/rte_vhost_async.h            | 17 ++++++++++++++++
 >  lib/vhost/version.map                  |  4 ++++
 >  lib/vhost/vhost.c                      | 26 ++++++++++++++++++++++++
 >  7 files changed, 72 insertions(+), 14 deletions(-)


Applied to dpdk-next-virtio/main.

Thanks,
Maxime

RE: [PATCH v1 1/2] vhost: add unsafe API to check inflight packets

[Ding, Xuan]

Hi Maxime,

> -----Original Message-----
> From: Maxime Coquelin <maxime.coquelin@redhat.com>
> Sent: Friday, May 6, 2022 3:21 AM
> To: Ding, Xuan <xuan.ding@intel.com>; Xia, Chenbo <chenbo.xia@intel.com>
> Cc: dev@dpdk.org; Hu, Jiayu <jiayu.hu@intel.com>; Jiang, Cheng1
> <cheng1.jiang@intel.com>; Pai G, Sunil <sunil.pai.g@intel.com>
> Subject: Re: [PATCH v1 1/2] vhost: add unsafe API to check inflight packets
> 
> 
> 
> On 4/8/22 12:22, xuan.ding@intel.com wrote:
> > From: Xuan Ding <xuan.ding@intel.com>
> >
> > In async data path, when vring state changes or device is destroyed,
> > it is necessary to know the number of inflight packets in DMA engine.
> > This patch provides a thread unsafe API to return the number of
> > inflight packets for a vhost queue without using any lock.
> >
> > Signed-off-by: Xuan Ding <xuan.ding@intel.com>
> > ---
> >   doc/guides/prog_guide/vhost_lib.rst    |  6 ++++++
> >   doc/guides/rel_notes/release_22_07.rst |  4 ++++
> >   lib/vhost/rte_vhost_async.h            | 17 +++++++++++++++++
> >   lib/vhost/version.map                  |  4 ++++
> >   lib/vhost/vhost.c                      | 26 ++++++++++++++++++++++++++
> >   5 files changed, 57 insertions(+)
> >
> > diff --git a/doc/guides/prog_guide/vhost_lib.rst
> > b/doc/guides/prog_guide/vhost_lib.rst
> > index 886f8f5e72..f287b76ebf 100644
> > --- a/doc/guides/prog_guide/vhost_lib.rst
> > +++ b/doc/guides/prog_guide/vhost_lib.rst
> > @@ -271,6 +271,12 @@ The following is an overview of some key Vhost
> API functions:
> >     This function returns the amount of in-flight packets for the vhost
> >     queue using async acceleration.
> >
> > + * ``rte_vhost_async_get_inflight_thread_unsafe(vid, queue_id)``
> > +
> > +  Get the number of inflight packets for a vhost queue without
> > + performing  any locking. It should only be used within the vhost
> > + ops, which already  holds the lock.
> > +
> >   * ``rte_vhost_clear_queue_thread_unsafe(vid, queue_id, **pkts,
> > count, dma_id, vchan_id)``
> >
> >     Clear inflight packets which are submitted to DMA engine in vhost
> > async data diff --git a/doc/guides/rel_notes/release_22_07.rst
> > b/doc/guides/rel_notes/release_22_07.rst
> > index 42a5f2d990..a0c5d9459b 100644
> > --- a/doc/guides/rel_notes/release_22_07.rst
> > +++ b/doc/guides/rel_notes/release_22_07.rst
> > @@ -55,6 +55,10 @@ New Features
> >        Also, make sure to start the actual text at the margin.
> >        =======================================================
> >
> > +* **Added vhost API to get the number of inflight packets.**
> > +
> > +  Added an API which can get the number of inflight packets in  vhost
> > + async data path without using lock.
> >
> >   Removed Items
> >   -------------
> > diff --git a/lib/vhost/rte_vhost_async.h b/lib/vhost/rte_vhost_async.h
> > index f1293c6a9d..70234debf9 100644
> > --- a/lib/vhost/rte_vhost_async.h
> > +++ b/lib/vhost/rte_vhost_async.h
> > @@ -139,6 +139,23 @@ uint16_t rte_vhost_poll_enqueue_completed(int
> vid, uint16_t queue_id,
> >   __rte_experimental
> >   int rte_vhost_async_get_inflight(int vid, uint16_t queue_id);
> >
> > +/**
> > + * This function is lock-free version to return the amount of
> > +in-flight
> > + * packets for the vhost queue which uses async channel acceleration.
> > + *
> > + * @note This function does not perform any locking, it should only
> > +be
> > + * used within the vhost ops, which already holds the lock.
> > + *
> > + * @param vid
> > + * id of vhost device to enqueue data
> > + * @param queue_id
> > + * queue id to enqueue data
> > + * @return
> > + * the amount of in-flight packets on success; -1 on failure  */
> > +__rte_experimental int rte_vhost_async_get_inflight_thread_unsafe(int
> > +vid, uint16_t queue_id);
> > +
> >   /**
> >    * This function checks async completion status and clear packets for
> >    * a specific vhost device queue. Packets which are inflight will be
> > diff --git a/lib/vhost/version.map b/lib/vhost/version.map index
> > 0a66c5840c..5841315386 100644
> > --- a/lib/vhost/version.map
> > +++ b/lib/vhost/version.map
> > @@ -87,6 +87,10 @@ EXPERIMENTAL {
> >
> >   	# added in 22.03
> >   	rte_vhost_async_dma_configure;
> > +
> > +	# added in 22.07
> > +	rte_vhost_async_get_inflight_thread_unsafe;
> > +
> >   };
> >
> >   INTERNAL {
> > diff --git a/lib/vhost/vhost.c b/lib/vhost/vhost.c index
> > 2f96a28dac..df0bb9d043 100644
> > --- a/lib/vhost/vhost.c
> > +++ b/lib/vhost/vhost.c
> > @@ -1907,6 +1907,32 @@ rte_vhost_async_get_inflight(int vid, uint16_t
> queue_id)
> >   	return ret;
> >   }
> >
> > +int
> > +rte_vhost_async_get_inflight_thread_unsafe(int vid, uint16_t
> > +queue_id) {
> > +	struct vhost_virtqueue *vq;
> > +	struct virtio_net *dev = get_device(vid);
> > +	int ret = -1;
> > +
> > +	if (dev == NULL)
> > +		return ret;
> > +
> > +	if (queue_id >= VHOST_MAX_VRING)
> > +		return ret;
> > +
> > +	vq = dev->virtqueue[queue_id];
> > +
> > +	if (vq == NULL)
> > +		return ret;
> 
> FYI, I'm going to post a patch that adds a call to
> rte_spinlock_is_locked() to catch possible misuses of the API.

Thanks for your reminder, I can help to review this patch if necessary.

Regards,
Xuan

> 
> > +	if (!vq->async)
> > +		return ret;
> > +
> > +	ret = vq->async->pkts_inflight_n;
> > +
> > +	return ret;
> > +}
> > +
> >   int
> >   rte_vhost_get_monitor_addr(int vid, uint16_t queue_id,
> >   		struct rte_vhost_power_monitor_cond *pmc)
> >
> 
> Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
> 
> Thanks,
> Maxime