examples/ip_pipeline: add TAP port
[dpdk.git] / examples / ip_pipeline / app.h
index 93e96d0..564996e 100644 (file)
@@ -44,6 +44,9 @@
 #include <cmdline_parse.h>
 
 #include <rte_ethdev.h>
+#ifdef RTE_LIBRTE_KNI
+#include <rte_kni.h>
+#endif
 
 #include "cpu_core_map.h"
 #include "pipeline.h"
@@ -132,6 +135,22 @@ struct app_pktq_swq_params {
        uint32_t mempool_indirect_id;
 };
 
+struct app_pktq_kni_params {
+       char *name;
+       uint32_t parsed;
+
+       uint32_t socket_id;
+       uint32_t core_id;
+       uint32_t hyper_th_id;
+       uint32_t force_bind;
+
+       uint32_t mempool_id; /* Position in the app->mempool_params */
+       uint32_t burst_read;
+       uint32_t burst_write;
+       uint32_t dropless;
+       uint64_t n_retries;
+};
+
 #ifndef APP_FILE_NAME_SIZE
 #define APP_FILE_NAME_SIZE                       256
 #endif
@@ -158,19 +177,29 @@ struct app_pktq_tm_params {
        uint32_t burst_write;
 };
 
+struct app_pktq_tap_params {
+       char *name;
+       uint32_t parsed;
+       uint32_t burst_read;
+       uint32_t burst_write;
+       uint32_t dropless;
+       uint64_t n_retries;
+       uint32_t mempool_id; /* Position in the app->mempool_params */
+};
+
 struct app_pktq_source_params {
        char *name;
        uint32_t parsed;
        uint32_t mempool_id; /* Position in the app->mempool_params array */
        uint32_t burst;
-       char *file_name; /* Full path of PCAP file to be copied to mbufs */
+       const char *file_name; /* Full path of PCAP file to be copied to mbufs */
        uint32_t n_bytes_per_pkt;
 };
 
 struct app_pktq_sink_params {
        char *name;
        uint8_t parsed;
-       char *file_name; /* Full path of PCAP file to be copied to mbufs */
+       const char *file_name; /* Full path of PCAP file to be copied to mbufs */
        uint32_t n_pkts_to_dump;
 };
 
@@ -185,6 +214,8 @@ enum app_pktq_in_type {
        APP_PKTQ_IN_HWQ,
        APP_PKTQ_IN_SWQ,
        APP_PKTQ_IN_TM,
+       APP_PKTQ_IN_TAP,
+       APP_PKTQ_IN_KNI,
        APP_PKTQ_IN_SOURCE,
 };
 
@@ -197,6 +228,8 @@ enum app_pktq_out_type {
        APP_PKTQ_OUT_HWQ,
        APP_PKTQ_OUT_SWQ,
        APP_PKTQ_OUT_TM,
+       APP_PKTQ_OUT_TAP,
+       APP_PKTQ_OUT_KNI,
        APP_PKTQ_OUT_SINK,
 };
 
@@ -241,6 +274,22 @@ struct app_pipeline_params {
        uint32_t n_args;
 };
 
+struct app_params;
+
+typedef void (*app_link_op)(struct app_params *app,
+       uint32_t link_id,
+       uint32_t up,
+       void *arg);
+
+#ifndef APP_MAX_PIPELINES
+#define APP_MAX_PIPELINES                        64
+#endif
+
+struct app_link_data {
+       app_link_op f_link[APP_MAX_PIPELINES];
+       void *arg[APP_MAX_PIPELINES];
+};
+
 struct app_pipeline_data {
        void *be;
        void *fe;
@@ -284,7 +333,7 @@ struct app_thread_data {
        uint64_t headroom_time;
        uint64_t headroom_cycles;
        double headroom_ratio;
-};
+} __rte_cache_aligned;
 
 #ifndef APP_MAX_LINKS
 #define APP_MAX_LINKS                            16
@@ -404,6 +453,12 @@ struct app_eal_params {
 
 #define APP_MAX_PKTQ_TM                          APP_MAX_LINKS
 
+#ifndef APP_MAX_PKTQ_TAP
+#define APP_MAX_PKTQ_TAP                         APP_MAX_LINKS
+#endif
+
+#define APP_MAX_PKTQ_KNI                         APP_MAX_LINKS
+
 #ifndef APP_MAX_PKTQ_SOURCE
 #define APP_MAX_PKTQ_SOURCE                      64
 #endif
@@ -416,10 +471,6 @@ struct app_eal_params {
 #define APP_MAX_MSGQ                             256
 #endif
 
-#ifndef APP_MAX_PIPELINES
-#define APP_MAX_PIPELINES                        64
-#endif
-
 #ifndef APP_EAL_ARGC
 #define APP_EAL_ARGC                             64
 #endif
@@ -459,6 +510,8 @@ struct app_params {
        struct app_pktq_hwq_out_params hwq_out_params[APP_MAX_HWQ_OUT];
        struct app_pktq_swq_params swq_params[APP_MAX_PKTQ_SWQ];
        struct app_pktq_tm_params tm_params[APP_MAX_PKTQ_TM];
+       struct app_pktq_tap_params tap_params[APP_MAX_PKTQ_TAP];
+       struct app_pktq_kni_params kni_params[APP_MAX_PKTQ_KNI];
        struct app_pktq_source_params source_params[APP_MAX_PKTQ_SOURCE];
        struct app_pktq_sink_params sink_params[APP_MAX_PKTQ_SINK];
        struct app_msgq_params msgq_params[APP_MAX_MSGQ];
@@ -470,6 +523,8 @@ struct app_params {
        uint32_t n_pktq_hwq_out;
        uint32_t n_pktq_swq;
        uint32_t n_pktq_tm;
+       uint32_t n_pktq_tap;
+       uint32_t n_pktq_kni;
        uint32_t n_pktq_source;
        uint32_t n_pktq_sink;
        uint32_t n_msgq;
@@ -480,8 +535,13 @@ struct app_params {
        struct cpu_core_map *core_map;
        uint64_t core_mask;
        struct rte_mempool *mempool[APP_MAX_MEMPOOLS];
+       struct app_link_data link_data[APP_MAX_LINKS];
        struct rte_ring *swq[APP_MAX_PKTQ_SWQ];
        struct rte_sched_port *tm[APP_MAX_PKTQ_TM];
+       int tap[APP_MAX_PKTQ_TAP];
+#ifdef RTE_LIBRTE_KNI
+       struct rte_kni *kni[APP_MAX_PKTQ_KNI];
+#endif /* RTE_LIBRTE_KNI */
        struct rte_ring *msgq[APP_MAX_MSGQ];
        struct pipeline_type pipeline_type[APP_MAX_PIPELINE_TYPES];
        struct app_pipeline_data pipeline_data[APP_MAX_PIPELINES];
@@ -654,11 +714,11 @@ app_swq_get_reader(struct app_params *app,
        struct app_pktq_swq_params *swq,
        uint32_t *pktq_in_id)
 {
-       struct app_pipeline_params *reader;
+       struct app_pipeline_params *reader = NULL;
        uint32_t pos = swq - app->swq_params;
        uint32_t n_pipelines = RTE_MIN(app->n_pipelines,
                RTE_DIM(app->pipeline_params));
-       uint32_t n_readers = 0, id, i;
+       uint32_t n_readers = 0, id = 0, i;
 
        for (i = 0; i < n_pipelines; i++) {
                struct app_pipeline_params *p = &app->pipeline_params[i];
@@ -714,11 +774,11 @@ app_tm_get_reader(struct app_params *app,
        struct app_pktq_tm_params *tm,
        uint32_t *pktq_in_id)
 {
-       struct app_pipeline_params *reader;
+       struct app_pipeline_params *reader = NULL;
        uint32_t pos = tm - app->tm_params;
        uint32_t n_pipelines = RTE_MIN(app->n_pipelines,
                RTE_DIM(app->pipeline_params));
-       uint32_t n_readers = 0, id, i;
+       uint32_t n_readers = 0, id = 0, i;
 
        for (i = 0; i < n_pipelines; i++) {
                struct app_pipeline_params *p = &app->pipeline_params[i];
@@ -744,6 +804,126 @@ app_tm_get_reader(struct app_params *app,
        return reader;
 }
 
+static inline uint32_t
+app_tap_get_readers(struct app_params *app, struct app_pktq_tap_params *tap)
+{
+       uint32_t pos = tap - app->tap_params;
+       uint32_t n_pipelines = RTE_MIN(app->n_pipelines,
+               RTE_DIM(app->pipeline_params));
+       uint32_t n_readers = 0, i;
+
+       for (i = 0; i < n_pipelines; i++) {
+               struct app_pipeline_params *p = &app->pipeline_params[i];
+               uint32_t n_pktq_in = RTE_MIN(p->n_pktq_in, RTE_DIM(p->pktq_in));
+               uint32_t j;
+
+               for (j = 0; j < n_pktq_in; j++) {
+                       struct app_pktq_in_params *pktq = &p->pktq_in[j];
+
+                       if ((pktq->type == APP_PKTQ_IN_TAP) &&
+                               (pktq->id == pos))
+                               n_readers++;
+               }
+       }
+
+       return n_readers;
+}
+
+static inline struct app_pipeline_params *
+app_tap_get_reader(struct app_params *app,
+       struct app_pktq_tap_params *tap,
+       uint32_t *pktq_in_id)
+{
+       struct app_pipeline_params *reader = NULL;
+       uint32_t pos = tap - app->tap_params;
+       uint32_t n_pipelines = RTE_MIN(app->n_pipelines,
+               RTE_DIM(app->pipeline_params));
+       uint32_t n_readers = 0, id = 0, i;
+
+       for (i = 0; i < n_pipelines; i++) {
+               struct app_pipeline_params *p = &app->pipeline_params[i];
+               uint32_t n_pktq_in = RTE_MIN(p->n_pktq_in, RTE_DIM(p->pktq_in));
+               uint32_t j;
+
+               for (j = 0; j < n_pktq_in; j++) {
+                       struct app_pktq_in_params *pktq = &p->pktq_in[j];
+
+                       if ((pktq->type == APP_PKTQ_IN_TAP) &&
+                               (pktq->id == pos)) {
+                               n_readers++;
+                               reader = p;
+                               id = j;
+                       }
+               }
+       }
+
+       if (n_readers != 1)
+               return NULL;
+
+       *pktq_in_id = id;
+       return reader;
+}
+
+static inline uint32_t
+app_kni_get_readers(struct app_params *app, struct app_pktq_kni_params *kni)
+{
+       uint32_t pos = kni - app->kni_params;
+       uint32_t n_pipelines = RTE_MIN(app->n_pipelines,
+               RTE_DIM(app->pipeline_params));
+       uint32_t n_readers = 0, i;
+
+       for (i = 0; i < n_pipelines; i++) {
+               struct app_pipeline_params *p = &app->pipeline_params[i];
+               uint32_t n_pktq_in = RTE_MIN(p->n_pktq_in, RTE_DIM(p->pktq_in));
+               uint32_t j;
+
+               for (j = 0; j < n_pktq_in; j++) {
+                       struct app_pktq_in_params *pktq = &p->pktq_in[j];
+
+                       if ((pktq->type == APP_PKTQ_IN_KNI) &&
+                               (pktq->id == pos))
+                               n_readers++;
+               }
+       }
+
+       return n_readers;
+}
+
+static inline struct app_pipeline_params *
+app_kni_get_reader(struct app_params *app,
+                                 struct app_pktq_kni_params *kni,
+                                 uint32_t *pktq_in_id)
+{
+       struct app_pipeline_params *reader = NULL;
+       uint32_t pos = kni - app->kni_params;
+       uint32_t n_pipelines = RTE_MIN(app->n_pipelines,
+               RTE_DIM(app->pipeline_params));
+       uint32_t n_readers = 0, id = 0, i;
+
+       for (i = 0; i < n_pipelines; i++) {
+               struct app_pipeline_params *p = &app->pipeline_params[i];
+               uint32_t n_pktq_in = RTE_MIN(p->n_pktq_in, RTE_DIM(p->pktq_in));
+               uint32_t j;
+
+               for (j = 0; j < n_pktq_in; j++) {
+                       struct app_pktq_in_params *pktq = &p->pktq_in[j];
+
+                       if ((pktq->type == APP_PKTQ_IN_KNI) &&
+                               (pktq->id == pos)) {
+                               n_readers++;
+                               reader = p;
+                               id = j;
+                       }
+               }
+       }
+
+       if (n_readers != 1)
+               return NULL;
+
+       *pktq_in_id = id;
+       return reader;
+}
+
 static inline uint32_t
 app_source_get_readers(struct app_params *app,
 struct app_pktq_source_params *source)
@@ -848,11 +1028,11 @@ app_swq_get_writer(struct app_params *app,
        struct app_pktq_swq_params *swq,
        uint32_t *pktq_out_id)
 {
-       struct app_pipeline_params *writer;
+       struct app_pipeline_params *writer = NULL;
        uint32_t pos = swq - app->swq_params;
        uint32_t n_pipelines = RTE_MIN(app->n_pipelines,
                RTE_DIM(app->pipeline_params));
-       uint32_t n_writers = 0, id, i;
+       uint32_t n_writers = 0, id = 0, i;
 
        for (i = 0; i < n_pipelines; i++) {
                struct app_pipeline_params *p = &app->pipeline_params[i];
@@ -910,11 +1090,11 @@ app_tm_get_writer(struct app_params *app,
        struct app_pktq_tm_params *tm,
        uint32_t *pktq_out_id)
 {
-       struct app_pipeline_params *writer;
+       struct app_pipeline_params *writer = NULL;
        uint32_t pos = tm - app->tm_params;
        uint32_t n_pipelines = RTE_MIN(app->n_pipelines,
                RTE_DIM(app->pipeline_params));
-       uint32_t n_writers = 0, id, i;
+       uint32_t n_writers = 0, id = 0, i;
 
        for (i = 0; i < n_pipelines; i++) {
                struct app_pipeline_params *p = &app->pipeline_params[i];
@@ -926,6 +1106,68 @@ app_tm_get_writer(struct app_params *app,
                        struct app_pktq_out_params *pktq = &p->pktq_out[j];
 
                        if ((pktq->type == APP_PKTQ_OUT_TM) &&
+                               (pktq->id == pos)) {
+                               n_writers++;
+                               writer = p;
+                               id = j;
+                       }
+               }
+       }
+
+       if (n_writers != 1)
+               return NULL;
+
+       *pktq_out_id = id;
+       return writer;
+}
+
+static inline uint32_t
+app_tap_get_writers(struct app_params *app, struct app_pktq_tap_params *tap)
+{
+       uint32_t pos = tap - app->tap_params;
+       uint32_t n_pipelines = RTE_MIN(app->n_pipelines,
+               RTE_DIM(app->pipeline_params));
+       uint32_t n_writers = 0, i;
+
+       for (i = 0; i < n_pipelines; i++) {
+               struct app_pipeline_params *p = &app->pipeline_params[i];
+               uint32_t n_pktq_out = RTE_MIN(p->n_pktq_out,
+                       RTE_DIM(p->pktq_out));
+               uint32_t j;
+
+               for (j = 0; j < n_pktq_out; j++) {
+                       struct app_pktq_out_params *pktq = &p->pktq_out[j];
+
+               if ((pktq->type == APP_PKTQ_OUT_TAP) &&
+                       (pktq->id == pos))
+                       n_writers++;
+               }
+       }
+
+       return n_writers;
+}
+
+static inline struct app_pipeline_params *
+app_tap_get_writer(struct app_params *app,
+       struct app_pktq_tap_params *tap,
+       uint32_t *pktq_out_id)
+{
+       struct app_pipeline_params *writer;
+       uint32_t pos = tap - app->tap_params;
+       uint32_t n_pipelines = RTE_MIN(app->n_pipelines,
+               RTE_DIM(app->pipeline_params));
+       uint32_t n_writers = 0, id = 0, i;
+
+       for (i = 0; i < n_pipelines; i++) {
+               struct app_pipeline_params *p = &app->pipeline_params[i];
+               uint32_t n_pktq_out = RTE_MIN(p->n_pktq_out,
+                       RTE_DIM(p->pktq_out));
+               uint32_t j;
+
+               for (j = 0; j < n_pktq_out; j++) {
+                       struct app_pktq_out_params *pktq = &p->pktq_out[j];
+
+                       if ((pktq->type == APP_PKTQ_OUT_TAP) &&
                                (pktq->id == pos))
                                n_writers++;
                                writer = p;
@@ -940,6 +1182,68 @@ app_tm_get_writer(struct app_params *app,
        return writer;
 }
 
+static inline uint32_t
+app_kni_get_writers(struct app_params *app, struct app_pktq_kni_params *kni)
+{
+       uint32_t pos = kni - app->kni_params;
+       uint32_t n_pipelines = RTE_MIN(app->n_pipelines,
+               RTE_DIM(app->pipeline_params));
+       uint32_t n_writers = 0, i;
+
+       for (i = 0; i < n_pipelines; i++) {
+               struct app_pipeline_params *p = &app->pipeline_params[i];
+               uint32_t n_pktq_out = RTE_MIN(p->n_pktq_out,
+                       RTE_DIM(p->pktq_out));
+               uint32_t j;
+
+               for (j = 0; j < n_pktq_out; j++) {
+                       struct app_pktq_out_params *pktq = &p->pktq_out[j];
+
+                       if ((pktq->type == APP_PKTQ_OUT_KNI) &&
+                               (pktq->id == pos))
+                               n_writers++;
+               }
+       }
+
+       return n_writers;
+}
+
+static inline struct app_pipeline_params *
+app_kni_get_writer(struct app_params *app,
+                                 struct app_pktq_kni_params *kni,
+                                 uint32_t *pktq_out_id)
+{
+       struct app_pipeline_params *writer = NULL;
+       uint32_t pos = kni - app->kni_params;
+       uint32_t n_pipelines = RTE_MIN(app->n_pipelines,
+               RTE_DIM(app->pipeline_params));
+       uint32_t n_writers = 0, id = 0, i;
+
+       for (i = 0; i < n_pipelines; i++) {
+               struct app_pipeline_params *p = &app->pipeline_params[i];
+               uint32_t n_pktq_out = RTE_MIN(p->n_pktq_out,
+                       RTE_DIM(p->pktq_out));
+               uint32_t j;
+
+               for (j = 0; j < n_pktq_out; j++) {
+                       struct app_pktq_out_params *pktq = &p->pktq_out[j];
+
+                       if ((pktq->type == APP_PKTQ_OUT_KNI) &&
+                               (pktq->id == pos)) {
+                               n_writers++;
+                               writer = p;
+                               id = j;
+                       }
+               }
+       }
+
+       if (n_writers != 1)
+               return NULL;
+
+       *pktq_out_id = id;
+       return writer;
+}
+
 static inline uint32_t
 app_sink_get_writers(struct app_params *app, struct app_pktq_sink_params *sink)
 {
@@ -1038,6 +1342,22 @@ app_get_link_for_tm(struct app_params *app, struct app_pktq_tm_params *p_tm)
        return &app->link_params[link_param_idx];
 }
 
+static inline struct app_link_params *
+app_get_link_for_kni(struct app_params *app, struct app_pktq_kni_params *p_kni)
+{
+       char link_name[APP_PARAM_NAME_SIZE];
+       uint32_t link_id;
+       ssize_t link_param_idx;
+
+       sscanf(p_kni->name, "KNI%" PRIu32, &link_id);
+       sprintf(link_name, "LINK%" PRIu32, link_id);
+       link_param_idx = APP_PARAM_FIND(app->link_params, link_name);
+       APP_CHECK((link_param_idx >= 0),
+                         "Cannot find %s for %s", link_name, p_kni->name);
+
+       return &app->link_params[link_param_idx];
+}
+
 void app_pipeline_params_get(struct app_params *app,
        struct app_pipeline_params *p_in,
        struct pipeline_params *p_out);