增加vwire规则的初始化。feature-adapt-to-ethdev-graph

2 files changed, 187 insertions, 76 deletions

diff --git a/service/include/sc_node.h b/service/include/sc_node.h
index 77ffed3..d541721 100644
--- a/service/include/sc_node.h
+++ b/service/include/sc_node.h
@@ -42,6 +42,11 @@ struct node_manager_main
 
 struct node_mbuf_shared_ctx
 {
+    struct {
+        uint64_t port_ingress_is_shmdev : 1;
+        uint64_t port_egress_is_shmdev : 1;
+    };
+
     uint16_t port_ingress;
     uint16_t port_egress;
 };
diff --git a/service/src/node_vwire.c b/service/src/node_vwire.c
index b23ebb6..598524d 100644
--- a/service/src/node_vwire.c
+++ b/service/src/node_vwire.c
@@ -5,6 +5,7 @@
 #include <rte_graph_worker.h>
 #include <rte_mbuf.h>
 
+#include <MESA_prof_load.h>
 #include <sc_node.h>
 #include <sc_vdev.h>
 
@@ -32,20 +33,57 @@ struct vwire_egress_node_elem
     struct vwire_egress_node_ctx ctx;
 };
 
-struct vwire_ingress_node_main
+#define VWIRE_FORWARD_TAG_LEN 16
+#define VWIRE_NR_FORWARD_RULES_MAX 256
+
+enum vwire_forward_rule_dev_type
+{
+    VWIRE_FORWARD_TYPE_PHYDEV,
+    VWIRE_FORWARD_TYPE_SHMDEV,
+    VWIRE_FORWARD_TYPE_TAG,
+};
+
+struct vwire_forward_rule
+{
+    enum vwire_forward_rule_dev_type int_type;
+    enum vwire_forward_rule_dev_type ext_type;
+
+    union {
+        struct phydev * int_phydev;
+        struct vdev * int_shmdev;
+        void * int_dev;
+        uint8_t int_tag[VWIRE_FORWARD_TAG_LEN];
+    };
+
+    union {
+        struct phydev * ext_phydev;
+        struct vdev * ext_phydev;
+        void * ext_dev;
+        uint8_t ext_tag[VWIRE_FORWARD_TAG_LEN];
+    };
+
+    port_id_t int_dev_port_id;
+    port_id_t ext_dev_port_id;
+};
+
+struct vwire_map_result
 {
-    TAILQ_HEAD(vwire_ingress_elem_head, vwire_ingress_node_elem) elems_head;
+    struct vwire_forward_rule * rule_object;
+    port_id_t egress_port_id;
+    unsigned int is_ext_to_int_dir;
 };
 
-struct vwire_egress_node_main
+struct vwire_node_main
 {
-    TAILQ_HEAD(vwire_egress_node_elem_head, vwire_egress_node_elem) elems_head;
+    struct vwire_map_result phydev_vwire_map[RTE_MAX_ETHPORTS];
+    struct vwire_map_result shmdev_vwire_map[RTE_MAX_ETHPORTS];
+
+    struct vwire_forward_rule * forward_rules[VWIRE_NR_FORWARD_RULES_MAX];
+    unsigned int nr_forward_rules;
 };
 
-static struct vwire_ingress_node_main __vwire_ingress_node_main;
-static struct vwire_egress_node_main __vwire_egress_node_main;
-static struct vwire_ingress_node_main * p_vwire_ingress_node_main = &__vwire_ingress_node_main;
-static struct vwire_egress_node_main * p_vwire_egress_node_main = &__vwire_egress_node_main;
+static struct vwire_node_main __vwire_node_main;
+static struct vwire_node_main * p_vwire_node_main = &__vwire_node_main;
 
 static_assert(sizeof(struct vwire_ingress_node_ctx) <= RTE_NODE_CTX_SZ,
               "vwire_ingress_node_ctx size must smaller than RTE_NODE_CTX_SZ");
@@ -53,64 +91,25 @@ static_assert(sizeof(struct vwire_egress_node_ctx) <= RTE_NODE_CTX_SZ,
               "vwire_egress_node_ctx size must smaller than RTE_NODE_CTX_SZ");
 
 static __rte_always_inline uint16_t vwire_ingress_node_process(struct rte_graph * graph, struct rte_node * node,
-                                                           void ** objs, uint16_t cnt)
+                                                               void ** objs, uint16_t cnt)
 {
-    struct vwire_ingress_node_ctx * ctx = (struct vwire_ingress_node_ctx *)node->ctx;
-
-    RTE_SET_USED(objs);
-    RTE_SET_USED(cnt);
-
-    unsigned int rx_nr_mbufs =
-        vdev_collect(ctx->vdev, graph->id, (struct rte_mbuf **)node->objs, RTE_GRAPH_BURST_SIZE, 0);
-
-    if (rx_nr_mbufs == 0)
-    {
-        return 0;
-    }
-
     rte_node_next_stream_move(graph, node, 0);
-    return rx_nr_mbufs;
+    return 0;
 }
 
 static __rte_always_inline uint16_t vwire_egress_node_process(struct rte_graph * graph, struct rte_node * node,
-                                                           void ** objs, uint16_t cnt)
+                                                              void ** objs, uint16_t cnt)
 {
-    struct vwire_egress_node_ctx * ctx = (struct vwire_egress_node_ctx *)node->ctx;
-    struct rte_mbuf ** mbufs = (struct rte_mbuf **)objs;
-
-    vdev_dispatch(ctx->vdev, graph->id, mbufs, cnt, 0);
     return cnt;
 }
 
 static int vwire_ingress_node_init(const struct rte_graph * graph, struct rte_node * node)
 {
-    struct vwire_ingress_node_ctx * ctx = (struct vwire_ingress_node_ctx *)node->ctx;
-    struct vwire_ingress_node_elem * elem_iter = NULL;
-
-    TAILQ_FOREACH(elem_iter, &p_vwire_ingress_node_main->elems_head, entries)
-    {
-        if (elem_iter->nid != node->id)
-            continue;
-
-        *ctx = (elem_iter->ctx);
-    }
-
     return 0;
 }
 
 static int vwire_egress_node_init(const struct rte_graph * graph, struct rte_node * node)
 {
-    struct vwire_egress_node_ctx * ctx = (struct vwire_egress_node_ctx *)node->ctx;
-    struct vwire_egress_node_elem * elem_iter = NULL;
-
-    TAILQ_FOREACH(elem_iter, &p_vwire_egress_node_main->elems_head, entries)
-    {
-        if (elem_iter->nid != node->id)
-            continue;
-
-        *ctx = (elem_iter->ctx);
-    }
-
     return 0;
 }
 
@@ -135,46 +134,153 @@ static struct rte_node_register vwire_egress_node_base = {
 RTE_NODE_REGISTER(vwire_ingress_node_base);
 RTE_NODE_REGISTER(vwire_egress_node_base);
 
-int node_manager_shmdev_init(struct sc_main * sc, struct node_manager_main * node_mgr_main)
+static int vwire_forward_rule_add__DEV_TYPE(struct vwire_node_main * vwire_main, struct sc_main * sc,
+                                            const char * int_dev, const char * ext_dev)
 {
-    unsigned int vdev_iter_helper = 0;
-    struct vdev * vdev_iter = NULL;
+    struct vwire_forward_rule * fwd_rule = ZMALLOC(sizeof(struct vwire_forward_rule));
+    MR_VERIFY_MALLOC(fwd_rule);
 
-    TAILQ_INIT(&p_vwire_ingress_node_main->elems_head);
-    TAILQ_INIT(&p_vwire_egress_node_main->elems_head);
+    /* internal device/tag */
+    struct phydev * phydev_object = phydev_lookup(sc->phydev_main, int_dev);
+    struct vdev * shmdev_object = vdev_lookup(sc->vdev_main, int_dev);
+    struct vwire_map_result * int_to_ext_map = NULL;
+    struct vwire_map_result * ext_to_int_map = NULL;
 
-    unsigned int nr_vdevs = 0;
+    if (phydev_object != NULL)
+    {
+        fwd_rule->int_dev = phydev_object;
+        fwd_rule->int_dev_port_id = phydev_object->port_id;
+        fwd_rule->int_type = VWIRE_FORWARD_TYPE_PHYDEV;
+        int_to_ext_map = &vwire_main->phydev_vwire_map;
+    }
+    else if (shmdev_object != NULL)
+    {
+        fwd_rule->int_dev = shmdev_object;
+        fwd_rule->int_dev_port_id = shmdev_object->port_id;
+        fwd_rule->int_type = VWIRE_FORWARD_TYPE_SHMDEV;
+        int_to_ext_map = &vwire_main->shmdev_vwire_map;
+    }
+    else
+    {
+        MR_ERROR("Internal Device %s is not existed, cannot create virtual-wire rule.", int_dev);
+        goto errout;
+    }
+
+    /* external device/tag */
+    phydev_object = phydev_lookup(sc->phydev_main, ext_dev);
+    shmdev_object = vdev_lookup(sc->vdev_main, ext_dev);
+
+    if (phydev_object != NULL)
+    {
+        fwd_rule->ext_dev = phydev_object;
+        fwd_rule->ext_dev_port_id = phydev_object->port_id;
+        fwd_rule->ext_type = VWIRE_FORWARD_TYPE_PHYDEV;
+        ext_to_int_map = &vwire_main->phydev_vwire_map;
+    }
+    else if (shmdev_object != NULL)
+    {
+        fwd_rule->ext_dev = shmdev_object;
+        fwd_rule->ext_dev_port_id = shmdev_object->port_id;
+        fwd_rule->ext_type = VWIRE_FORWARD_TYPE_SHMDEV;
+        ext_to_int_map = &vwire_main->shmdev_vwire_map;
+    }
+    else
+    {
+        MR_ERROR("External Device %s is not existed, cannot create virtual-wire rule.", ext_dev);
+        goto errout;
+    }
 
-    /* each vdev has one shmdev-rx and shmdev-tx node */
-    while (vdev_iterate(sc->vdev_main, &vdev_iter, &vdev_iter_helper) >= 0)
+    /* construct the forward lookup map, internal->external */
+    struct vwire_map_result * int_to_ext_map_result = &int_to_ext_map[fwd_rule->int_dev_port_id];
+    if (int_to_ext_map_result->rule_object != NULL)
     {
-        /* rx nodes */
-        struct vwire_ingress_node_elem * rx_node_elem = ZMALLOC(sizeof(struct vwire_ingress_node_elem));
-        MR_VERIFY_MALLOC(rx_node_elem);
+        MR_ERROR("Internal Device %s has already be a member of virtual-wire group, rejected.", int_dev);
+        goto errout;
+    }
+
+    /* external->internal */
+    struct vwire_map_result * ext_to_int_map_result = &ext_to_int_map[fwd_rule->ext_dev_port_id];
+    if (ext_to_int_map_result->rule_object != NULL)
+    {
+        MR_ERROR("External Device %s has already be a member of virtual-wire group, rejected.", ext_dev);
+        goto errout;
+    }
 
-        rte_node_t rx_node_id = rte_node_clone(vwire_ingress_node_base.id, vdev_iter->symbol);
-        MR_VERIFY(rx_node_id != RTE_NODE_ID_INVALID);
+    int_to_ext_map_result->rule_object = fwd_rule;
+    int_to_ext_map_result->egress_port_id = fwd_rule->ext_dev_port_id;
+    int_to_ext_map_result->is_ext_to_int_dir = 0;
 
-        rx_node_elem->nid = rx_node_id;
-        rx_node_elem->ctx.vdev = vdev_iter;
-        TAILQ_INSERT_TAIL(&p_vwire_ingress_node_main->elems_head, rx_node_elem, entries);
+    ext_to_int_map_result->rule_object = fwd_rule;
+    ext_to_int_map_result->egress_port_id = fwd_rule->int_dev_port_id;
+    ext_to_int_map_result->is_ext_to_int_dir = 1;
 
-        /* tx nodes */
-        struct vwire_egress_node_elem * tx_node_elem = ZMALLOC(sizeof(struct vwire_egress_node_elem));
-        MR_VERIFY_MALLOC(tx_node_elem);
+    /* write result */
+    vwire_main->forward_rules[vwire_main->nr_forward_rules++] = fwd_rule;
+    return RT_SUCCESS;
 
-        rte_node_t tx_node_id = rte_node_clone(vwire_egress_node_base.id, vdev_iter->symbol);
-        MR_VERIFY(tx_node_id != RTE_NODE_ID_INVALID);
+errout:
+    if (fwd_rule != NULL)
+    {
+        FREE(fwd_rule);
+    }
+
+    return RT_ERR;
+}
+
+static int vwire_forward_rule_add__TAG_TYPE(struct vwire_node_main * vwire_main, const uint8_t * int_tag,
+                                            const uint8_t * ext_tag)
+{
+    /* TODO */
+    return 0;
+}
 
-        tx_node_elem->nid = tx_node_id;
-        tx_node_elem->ctx.vdev = vdev_iter;
-        TAILQ_INSERT_TAIL(&p_vwire_egress_node_main->elems_head, tx_node_elem, entries);
+int node_manager_vwire_config(struct sc_main * sc, struct node_manager_main * node_mgr_main)
+{
+    int ret = 0;
+    struct vwire_node_main * vwire_main = p_vwire_node_main;
 
-        nr_vdevs++;
+    /* load vwire rules */
+    for (unsigned int i = 0; i < VWIRE_NR_FORWARD_RULES_MAX; i++)
+    {
+        char sec_symbol[MR_SYMBOL_MAX] = {0};
+        snprintf(sec_symbol, sizeof(sec_symbol) - 1, "vwire_group:%u", i);
+
+        char str_int_dev[MR_SYMBOL_MAX] = {0};
+
+        ret = MESA_load_profile_string_nodef(sc->local_cfgfile, sec_symbol, "interface_int", str_int_dev,
+                                             sizeof(str_int_dev) - 1);
+
+        if (ret < 0)
+        {
+            MR_DEBUG("interface_int is not existed in section %s, ignore this section", sec_symbol);
+            continue;
+        }
+
+        char str_ext_dev[MR_SYMBOL_MAX] = {0};
+        ret = MESA_load_profile_string_nodef(sc->local_cfgfile, sec_symbol, "interface_ext", str_ext_dev,
+                                             sizeof(str_ext_dev) - 1);
+
+        if (ret < 0)
+        {
+            MR_DEBUG("interface_ext is not existed in section %s, ignore this section", sec_symbol);
+            continue;
+        }
+
+        vwire_forward_rule_add__DEV_TYPE(p_vwire_node_main, str_int_dev, str_ext_dev);
     }
 
+    return 0;
+}
+
+int node_manager_vwire_init(struct sc_main * sc, struct node_manager_main * node_mgr_main)
+{
+    unsigned int vdev_iter_helper = 0;
+    struct vdev * vdev_iter = NULL;
+
+    unsigned int nr_vdevs = 0;
+
     /* join all rx/tx nodes to all workers */
-    if(nr_vdevs > 0)
+    if (nr_vdevs > 0)
     {
         node_setup_desc_add_for_all_workers(node_mgr_main, "vwire_ingress-*");
         node_setup_desc_add_for_all_workers(node_mgr_main, "vwire_egress-*");