examples/ip_pipeline/main.h

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
   5  *   All rights reserved.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following conditions
   9  *   are met:
  10  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of Intel Corporation nor the names of its
  18  *       contributors may be used to endorse or promote products derived
  19  *       from this software without specific prior written permission.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #ifndef _MAIN_H_
  35 #define _MAIN_H_
  36
  37 #include <stdint.h>
  38
  39 #include <rte_mempool.h>
  40 #include <rte_mbuf.h>
  41 #include <rte_ring.h>
  42 #include <rte_ethdev.h>
  43
  44 #ifdef RTE_LIBRTE_ACL
  45 #include <rte_table_acl.h>
  46 #endif
  47
  48 struct app_flow_key {
  49         union {
  50                 struct {
  51                         uint8_t ttl; /* needs to be set to 0 */
  52                         uint8_t proto;
  53                         uint16_t header_checksum; /* needs to be set to 0 */
  54                         uint32_t ip_src;
  55                 };
  56                 uint64_t slab0;
  57         };
  58
  59         union {
  60                 struct {
  61                         uint32_t ip_dst;
  62                         uint16_t port_src;
  63                         uint16_t port_dst;
  64                 };
  65                 uint64_t slab1;
  66         };
  67 } __attribute__((__packed__));
  68
  69 struct app_arp_key {
  70         uint32_t nh_ip;
  71         uint32_t nh_iface;
  72 } __attribute__((__packed__));
  73
  74 struct app_pkt_metadata {
  75         uint32_t signature;
  76         uint8_t reserved1[28];
  77
  78         struct app_flow_key flow_key;
  79
  80         struct app_arp_key arp_key;
  81         struct ether_addr nh_arp;
  82
  83         uint8_t reserved3[2];
  84 } __attribute__((__packed__));
  85
  86 #ifndef APP_MBUF_ARRAY_SIZE
  87 #define APP_MBUF_ARRAY_SIZE            256
  88 #endif
  89
  90 struct app_mbuf_array {
  91         struct rte_mbuf *array[APP_MBUF_ARRAY_SIZE];
  92         uint32_t n_mbufs;
  93 };
  94
  95 #ifndef APP_MAX_PORTS
  96 #define APP_MAX_PORTS                  4
  97 #endif
  98
  99 #ifndef APP_MAX_SWQ_PER_CORE
 100 #define APP_MAX_SWQ_PER_CORE           8
 101 #endif
 102
 103 #define APP_SWQ_INVALID                ((uint32_t)(-1))
 104
 105 #define APP_SWQ_IN_REQ                 (APP_MAX_SWQ_PER_CORE - 1)
 106
 107 #define APP_SWQ_OUT_RESP               (APP_MAX_SWQ_PER_CORE - 1)
 108
 109 enum app_core_type {
 110         APP_CORE_NONE = 0, /* Unused */
 111         APP_CORE_MASTER,   /* Management */
 112         APP_CORE_RX,       /* Reception */
 113         APP_CORE_TX,       /* Transmission */
 114         APP_CORE_PT,       /* Pass-through */
 115         APP_CORE_FC,       /* Flow Classification */
 116         APP_CORE_FW,       /* Firewall */
 117         APP_CORE_RT,       /* Routing */
 118         APP_CORE_TM,       /* Traffic Management */
 119         APP_CORE_IPV4_FRAG,/* IPv4 Fragmentation */
 120         APP_CORE_IPV4_RAS, /* IPv4 Reassembly */
 121 };
 122
 123 struct app_core_params {
 124         uint32_t core_id;
 125         enum app_core_type core_type;
 126
 127         /* SWQ map */
 128         uint32_t swq_in[APP_MAX_SWQ_PER_CORE];
 129         uint32_t swq_out[APP_MAX_SWQ_PER_CORE];
 130 } __rte_cache_aligned;
 131
 132 struct app_params {
 133         /* CPU cores */
 134         struct app_core_params cores[RTE_MAX_LCORE];
 135         uint32_t n_cores;
 136
 137         /* Ports*/
 138         uint32_t ports[APP_MAX_PORTS];
 139         uint32_t n_ports;
 140         uint32_t rsz_hwq_rx;
 141         uint32_t rsz_hwq_tx;
 142         uint32_t bsz_hwq_rd;
 143         uint32_t bsz_hwq_wr;
 144         struct rte_eth_conf port_conf;
 145         struct rte_eth_rxconf rx_conf;
 146         struct rte_eth_txconf tx_conf;
 147
 148         /* SW Queues (SWQs) */
 149         struct rte_ring **rings;
 150         uint32_t rsz_swq;
 151         uint32_t bsz_swq_rd;
 152         uint32_t bsz_swq_wr;
 153
 154         /* Buffer pool */
 155         struct rte_mempool *pool;
 156         struct rte_mempool *indirect_pool;
 157         uint32_t pool_buffer_size;
 158         uint32_t pool_size;
 159         uint32_t pool_cache_size;
 160
 161         /* Message buffer pool */
 162         struct rte_mempool *msg_pool;
 163         uint32_t msg_pool_buffer_size;
 164         uint32_t msg_pool_size;
 165         uint32_t msg_pool_cache_size;
 166
 167         /* Rule tables */
 168         uint32_t max_arp_rules;
 169         uint32_t max_routing_rules;
 170         uint32_t max_firewall_rules;
 171         uint32_t max_flow_rules;
 172
 173         /* Processing */
 174         uint32_t ether_hdr_pop_push;
 175 } __rte_cache_aligned;
 176
 177 extern struct app_params app;
 178
 179 const char *app_core_type_id_to_string(enum app_core_type id);
 180 int app_core_type_string_to_id(const char *string, enum app_core_type *id);
 181 void app_cores_config_print(void);
 182
 183 void app_check_core_params(void);
 184 struct app_core_params *app_get_core_params(uint32_t core_id);
 185 uint32_t app_get_first_core_id(enum app_core_type core_type);
 186 struct rte_ring *app_get_ring_req(uint32_t core_id);
 187 struct rte_ring *app_get_ring_resp(uint32_t core_id);
 188
 189 int app_parse_args(int argc, char **argv);
 190 void app_print_usage(char *prgname);
 191 void app_init(void);
 192 void app_ping(void);
 193 int app_lcore_main_loop(void *arg);
 194
 195 /* Hash functions */
 196 uint64_t test_hash(void *key, uint32_t key_size, uint64_t seed);
 197 uint32_t rte_jhash2_16(uint32_t *k, uint32_t initval);
 198 #if defined(__x86_64__)
 199 uint32_t rte_aeshash_16(uint64_t *k, uint64_t seed);
 200 uint32_t rte_crchash_16(uint64_t *k, uint64_t seed);
 201 #endif
 202
 203 /* I/O with no pipeline */
 204 void app_main_loop_rx(void);
 205 void app_main_loop_tx(void);
 206 void app_main_loop_passthrough(void);
 207
 208 /* Pipeline */
 209 void app_main_loop_pipeline_rx(void);
 210 void app_main_loop_pipeline_rx_frag(void);
 211 void app_main_loop_pipeline_tx(void);
 212 void app_main_loop_pipeline_tx_ras(void);
 213 void app_main_loop_pipeline_flow_classification(void);
 214 void app_main_loop_pipeline_firewall(void);
 215 void app_main_loop_pipeline_routing(void);
 216 void app_main_loop_pipeline_passthrough(void);
 217 void app_main_loop_pipeline_ipv4_frag(void);
 218 void app_main_loop_pipeline_ipv4_ras(void);
 219
 220 /* Command Line Interface (CLI) */
 221 void app_main_loop_cmdline(void);
 222
 223 /* Messages */
 224 enum app_msg_req_type {
 225         APP_MSG_REQ_PING,
 226         APP_MSG_REQ_FC_ADD,
 227         APP_MSG_REQ_FC_DEL,
 228         APP_MSG_REQ_FC_ADD_ALL,
 229         APP_MSG_REQ_FW_ADD,
 230         APP_MSG_REQ_FW_DEL,
 231         APP_MSG_REQ_RT_ADD,
 232         APP_MSG_REQ_RT_DEL,
 233         APP_MSG_REQ_ARP_ADD,
 234         APP_MSG_REQ_ARP_DEL,
 235         APP_MSG_REQ_RX_PORT_ENABLE,
 236         APP_MSG_REQ_RX_PORT_DISABLE,
 237 };
 238
 239 struct app_msg_req {
 240         enum app_msg_req_type type;
 241         union {
 242                 struct {
 243                         uint32_t ip;
 244                         uint8_t depth;
 245                         uint8_t port;
 246                         uint32_t nh_ip;
 247                 } routing_add;
 248                 struct {
 249                         uint32_t ip;
 250                         uint8_t depth;
 251                 } routing_del;
 252                 struct {
 253                         uint8_t out_iface;
 254                         uint32_t nh_ip;
 255                         struct ether_addr nh_arp;
 256                 } arp_add;
 257                 struct {
 258                         uint8_t out_iface;
 259                         uint32_t nh_ip;
 260                 } arp_del;
 261                 struct {
 262                         union {
 263                                 uint8_t key_raw[16];
 264                                 struct app_flow_key key;
 265                         };
 266                         uint8_t port;
 267                 } flow_classif_add;
 268                 struct {
 269                         union {
 270                                 uint8_t key_raw[16];
 271                                 struct app_flow_key key;
 272                         };
 273                 } flow_classif_del;
 274 #ifdef RTE_LIBRTE_ACL
 275                 struct {
 276                         struct rte_table_acl_rule_add_params add_params;
 277                         uint8_t port;
 278                 } firewall_add;
 279                 struct {
 280                         struct rte_table_acl_rule_delete_params delete_params;
 281                 } firewall_del;
 282 #endif
 283                 struct {
 284                         uint8_t port;
 285                 } rx_up;
 286                 struct {
 287                         uint8_t port;
 288                 } rx_down;
 289         };
 290 };
 291
 292 struct app_msg_resp {
 293         int result;
 294 };
 295
 296 #define APP_FLUSH 0xFF
 297
 298 #ifdef RTE_EXEC_ENV_BAREMETAL
 299 #define MAIN _main
 300 #else
 301 #define MAIN main
 302 #endif
 303
 304 int MAIN(int argc, char **argv);
 305
 306 #endif /* _MAIN_H_ */