X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=lib%2Flibrte_vhost%2Fvdpa.c;h=99a926a7725cefb274ae437d061ff2ac2bcfb58c;hb=10b8c36af0abb654907d97738641d6a643408b99;hp=87334c88c0a53fe63e4aca701c6ff48180f29101;hpb=38f8ab0bbc8d14066ebafec2b70583092328a5ab;p=dpdk.git

diff --git a/lib/librte_vhost/vdpa.c b/lib/librte_vhost/vdpa.c
index 87334c88c0..99a926a772 100644
--- a/lib/librte_vhost/vdpa.c
+++ b/lib/librte_vhost/vdpa.c
@@ -9,117 +9,124 @@
  */
 
 #include <stdbool.h>
+#include <sys/queue.h>
 
 #include <rte_class.h>
 #include <rte_malloc.h>
+#include <rte_spinlock.h>
+#include <rte_tailq.h>
+
 #include "rte_vdpa.h"
+#include "rte_vdpa_dev.h"
 #include "vhost.h"
 
-static struct rte_vdpa_device vdpa_devices[MAX_VHOST_DEVICE];
-static uint32_t vdpa_device_num;
+/** Double linked list of vDPA devices. */
+TAILQ_HEAD(vdpa_device_list, rte_vdpa_device);
 
-int
-rte_vdpa_register_device(struct rte_device *rte_dev,
-		struct rte_vdpa_dev_ops *ops)
-{
-	struct rte_vdpa_device *dev;
-	int i;
+static struct vdpa_device_list vdpa_device_list =
+		TAILQ_HEAD_INITIALIZER(vdpa_device_list);
+static rte_spinlock_t vdpa_device_list_lock = RTE_SPINLOCK_INITIALIZER;
 
-	if (vdpa_device_num >= MAX_VHOST_DEVICE || ops == NULL)
-		return -1;
 
-	for (i = 0; i < MAX_VHOST_DEVICE; i++) {
-		dev = &vdpa_devices[i];
-		if (dev->ops == NULL)
-			continue;
+/* Unsafe, needs to be called with vdpa_device_list_lock held */
+static struct rte_vdpa_device *
+__vdpa_find_device_by_name(const char *name)
+{
+	struct rte_vdpa_device *dev, *ret = NULL;
 
-		if (dev->device == rte_dev)
-			return -1;
-	}
+	if (name == NULL)
+		return NULL;
 
-	for (i = 0; i < MAX_VHOST_DEVICE; i++) {
-		if (vdpa_devices[i].ops == NULL)
+	TAILQ_FOREACH(dev, &vdpa_device_list, next) {
+		if (!strncmp(dev->device->name, name, RTE_DEV_NAME_MAX_LEN)) {
+			ret = dev;
 			break;
+		}
 	}
 
-	if (i == MAX_VHOST_DEVICE)
-		return -1;
-
-	dev = &vdpa_devices[i];
-	dev->device = rte_dev;
-	dev->ops = ops;
-	vdpa_device_num++;
-
-	return i;
+	return ret;
 }
 
-int
-rte_vdpa_unregister_device(int did)
+struct rte_vdpa_device *
+rte_vdpa_find_device_by_name(const char *name)
 {
-	if (did < 0 || did >= MAX_VHOST_DEVICE || vdpa_devices[did].ops == NULL)
-		return -1;
+	struct rte_vdpa_device *dev;
 
-	memset(&vdpa_devices[did], 0, sizeof(struct rte_vdpa_device));
-	vdpa_device_num--;
+	rte_spinlock_lock(&vdpa_device_list_lock);
+	dev = __vdpa_find_device_by_name(name);
+	rte_spinlock_unlock(&vdpa_device_list_lock);
 
-	return did;
+	return dev;
 }
 
-int
-rte_vdpa_find_device_id(struct rte_vdpa_device *dev)
+struct rte_device *
+rte_vdpa_get_rte_device(struct rte_vdpa_device *vdpa_dev)
 {
-	struct rte_vdpa_device *tmp_dev;
-	int i;
-
-	if (dev == NULL)
-		return -1;
-
-	for (i = 0; i < MAX_VHOST_DEVICE; ++i) {
-		tmp_dev = &vdpa_devices[i];
-		if (tmp_dev->ops == NULL)
-			continue;
-
-		if (tmp_dev == dev)
-			return i;
-	}
+	if (vdpa_dev == NULL)
+		return NULL;
 
-	return -1;
+	return vdpa_dev->device;
 }
 
-int
-rte_vdpa_find_device_id_by_name(const char *name)
+struct rte_vdpa_device *
+rte_vdpa_register_device(struct rte_device *rte_dev,
+		struct rte_vdpa_dev_ops *ops)
 {
 	struct rte_vdpa_device *dev;
-	int i;
 
-	if (name == NULL)
-		return -1;
+	if (ops == NULL)
+		return NULL;
 
-	for (i = 0; i < MAX_VHOST_DEVICE; ++i) {
-		dev = &vdpa_devices[i];
-		if (dev->ops == NULL)
-			continue;
+	/* Check mandatory ops are implemented */
+	if (!ops->get_queue_num || !ops->get_features ||
+			!ops->get_protocol_features || !ops->dev_conf ||
+			!ops->dev_close || !ops->set_vring_state ||
+			!ops->set_features) {
+		VHOST_LOG_CONFIG(ERR,
+				"Some mandatory vDPA ops aren't implemented\n");
+		return NULL;
+	}
 
-		if (strncmp(dev->device->name, name, RTE_DEV_NAME_MAX_LEN) == 0)
-			return i;
+	rte_spinlock_lock(&vdpa_device_list_lock);
+	/* Check the device hasn't been register already */
+	dev = __vdpa_find_device_by_name(rte_dev->name);
+	if (dev) {
+		dev = NULL;
+		goto out_unlock;
 	}
 
-	return -1;
-}
+	dev = rte_zmalloc(NULL, sizeof(*dev), 0);
+	if (!dev)
+		goto out_unlock;
 
-struct rte_vdpa_device *
-rte_vdpa_get_device(int did)
-{
-	if (did < 0 || did >= MAX_VHOST_DEVICE)
-		return NULL;
+	dev->device = rte_dev;
+	dev->ops = ops;
+	TAILQ_INSERT_TAIL(&vdpa_device_list, dev, next);
+out_unlock:
+	rte_spinlock_unlock(&vdpa_device_list_lock);
 
-	return &vdpa_devices[did];
+	return dev;
 }
 
 int
-rte_vdpa_get_device_num(void)
+rte_vdpa_unregister_device(struct rte_vdpa_device *dev)
 {
-	return vdpa_device_num;
+	struct rte_vdpa_device *cur_dev, *tmp_dev;
+	int ret = -1;
+
+	rte_spinlock_lock(&vdpa_device_list_lock);
+	TAILQ_FOREACH_SAFE(cur_dev, &vdpa_device_list, next, tmp_dev) {
+		if (dev != cur_dev)
+			continue;
+
+		TAILQ_REMOVE(&vdpa_device_list, dev, next);
+		rte_free(dev);
+		ret = 0;
+		break;
+	}
+	rte_spinlock_unlock(&vdpa_device_list_lock);
+
+	return ret;
 }
 
 int
@@ -210,8 +217,8 @@ rte_vdpa_relay_vring_used(int vid, uint16_t qid, void *vring_m)
 		idx++;
 	}
 
-	rte_smp_wmb();
-	vq->used->idx = idx_m;
+	/* used idx is the synchronization point for the split vring */
+	__atomic_store_n(&vq->used->idx, idx_m, __ATOMIC_RELEASE);
 
 	if (dev->features & (1ULL << VIRTIO_RING_F_EVENT_IDX))
 		vring_used_event(s_vring) = idx_m;
@@ -225,63 +232,67 @@ fail:
 }
 
 int
-rte_vdpa_get_stats_names(int did, struct rte_vdpa_stat_name *stats_names,
-			 unsigned int size)
+rte_vdpa_get_queue_num(struct rte_vdpa_device *dev, uint32_t *queue_num)
 {
-	struct rte_vdpa_device *vdpa_dev;
+	if (dev == NULL || dev->ops == NULL || dev->ops->get_queue_num == NULL)
+		return -1;
 
-	vdpa_dev = rte_vdpa_get_device(did);
-	if (!vdpa_dev)
-		return -ENODEV;
+	return dev->ops->get_queue_num(dev, queue_num);
+}
 
-	RTE_FUNC_PTR_OR_ERR_RET(vdpa_dev->ops->get_stats_names, -ENOTSUP);
+int
+rte_vdpa_get_features(struct rte_vdpa_device *dev, uint64_t *features)
+{
+	if (dev == NULL || dev->ops == NULL || dev->ops->get_features == NULL)
+		return -1;
 
-	return vdpa_dev->ops->get_stats_names(did, stats_names, size);
+	return dev->ops->get_features(dev, features);
 }
 
 int
-rte_vdpa_get_stats(int did, uint16_t qid, struct rte_vdpa_stat *stats,
-		   unsigned int n)
+rte_vdpa_get_protocol_features(struct rte_vdpa_device *dev, uint64_t *features)
 {
-	struct rte_vdpa_device *vdpa_dev;
+	if (dev == NULL || dev->ops == NULL ||
+			dev->ops->get_protocol_features == NULL)
+		return -1;
 
-	vdpa_dev = rte_vdpa_get_device(did);
-	if (!vdpa_dev)
-		return -ENODEV;
+	return dev->ops->get_protocol_features(dev, features);
+}
 
-	if (!stats || !n)
+int
+rte_vdpa_get_stats_names(struct rte_vdpa_device *dev,
+		struct rte_vdpa_stat_name *stats_names,
+		unsigned int size)
+{
+	if (!dev)
 		return -EINVAL;
 
-	RTE_FUNC_PTR_OR_ERR_RET(vdpa_dev->ops->get_stats, -ENOTSUP);
+	RTE_FUNC_PTR_OR_ERR_RET(dev->ops->get_stats_names, -ENOTSUP);
 
-	return vdpa_dev->ops->get_stats(did, qid, stats, n);
+	return dev->ops->get_stats_names(dev, stats_names, size);
 }
 
 int
-rte_vdpa_reset_stats(int did, uint16_t qid)
+rte_vdpa_get_stats(struct rte_vdpa_device *dev, uint16_t qid,
+		struct rte_vdpa_stat *stats, unsigned int n)
 {
-	struct rte_vdpa_device *vdpa_dev;
-
-	vdpa_dev = rte_vdpa_get_device(did);
-	if (!vdpa_dev)
-		return -ENODEV;
+	if (!dev || !stats || !n)
+		return -EINVAL;
 
-	RTE_FUNC_PTR_OR_ERR_RET(vdpa_dev->ops->reset_stats, -ENOTSUP);
+	RTE_FUNC_PTR_OR_ERR_RET(dev->ops->get_stats, -ENOTSUP);
 
-	return vdpa_dev->ops->reset_stats(did, qid);
+	return dev->ops->get_stats(dev, qid, stats, n);
 }
 
-static uint16_t
-vdpa_dev_to_id(const struct rte_vdpa_device *dev)
+int
+rte_vdpa_reset_stats(struct rte_vdpa_device *dev, uint16_t qid)
 {
-	if (dev == NULL)
-		return MAX_VHOST_DEVICE;
+	if (!dev)
+		return -EINVAL;
 
-	if (dev < &vdpa_devices[0] ||
-			dev >= &vdpa_devices[MAX_VHOST_DEVICE])
-		return MAX_VHOST_DEVICE;
+	RTE_FUNC_PTR_OR_ERR_RET(dev->ops->reset_stats, -ENOTSUP);
 
-	return (uint16_t)(dev - vdpa_devices);
+	return dev->ops->reset_stats(dev, qid);
 }
 
 static int
@@ -303,24 +314,22 @@ vdpa_find_device(const struct rte_vdpa_device *start, rte_vdpa_cmp_t cmp,
 		struct rte_device *rte_dev)
 {
 	struct rte_vdpa_device *dev;
-	uint16_t idx;
 
-	if (start != NULL)
-		idx = vdpa_dev_to_id(start) + 1;
+	rte_spinlock_lock(&vdpa_device_list_lock);
+	if (start == NULL)
+		dev = TAILQ_FIRST(&vdpa_device_list);
 	else
-		idx = 0;
-	for (; idx < MAX_VHOST_DEVICE; idx++) {
-		dev = &vdpa_devices[idx];
-		/*
-		 * ToDo: Certainly better to introduce a state field,
-		 * but rely on ops being set for now.
-		 */
-		if (dev->ops == NULL)
-			continue;
+		dev = TAILQ_NEXT(start, next);
+
+	while (dev != NULL) {
 		if (cmp(dev, rte_dev) == 0)
-			return dev;
+			break;
+
+		dev = TAILQ_NEXT(dev, next);
 	}
-	return NULL;
+	rte_spinlock_unlock(&vdpa_device_list_lock);
+
+	return dev;
 }
 
 static void *