i40evf: fix MAC deletion when stopping
[dpdk.git] / examples / vmdq_dcb / main.c
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 #include <stdint.h>
35 #include <sys/queue.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <stdio.h>
39 #include <assert.h>
40 #include <errno.h>
41 #include <signal.h>
42 #include <stdarg.h>
43 #include <inttypes.h>
44 #include <getopt.h>
45
46 #include <rte_common.h>
47 #include <rte_log.h>
48 #include <rte_memory.h>
49 #include <rte_memcpy.h>
50 #include <rte_memzone.h>
51 #include <rte_eal.h>
52 #include <rte_per_lcore.h>
53 #include <rte_launch.h>
54 #include <rte_atomic.h>
55 #include <rte_cycles.h>
56 #include <rte_prefetch.h>
57 #include <rte_lcore.h>
58 #include <rte_per_lcore.h>
59 #include <rte_branch_prediction.h>
60 #include <rte_interrupts.h>
61 #include <rte_pci.h>
62 #include <rte_random.h>
63 #include <rte_debug.h>
64 #include <rte_ether.h>
65 #include <rte_ethdev.h>
66 #include <rte_ring.h>
67 #include <rte_log.h>
68 #include <rte_mempool.h>
69 #include <rte_mbuf.h>
70 #include <rte_memcpy.h>
71
72 /* basic constants used in application */
73 #define NUM_QUEUES 128
74
75 #define NUM_MBUFS 64*1024
76 #define MBUF_CACHE_SIZE 64
77
78 #define INVALID_PORT_ID 0xFF
79
80 /* mask of enabled ports */
81 static uint32_t enabled_port_mask = 0;
82
83 /* number of pools (if user does not specify any, 16 by default */
84 static enum rte_eth_nb_pools num_pools = ETH_16_POOLS;
85
86 /* empty vmdq+dcb configuration structure. Filled in programatically */
87 static const struct rte_eth_conf vmdq_dcb_conf_default = {
88         .rxmode = {
89                 .mq_mode        = ETH_MQ_RX_VMDQ_DCB,
90                 .split_hdr_size = 0,
91                 .header_split   = 0, /**< Header Split disabled */
92                 .hw_ip_checksum = 0, /**< IP checksum offload disabled */
93                 .hw_vlan_filter = 0, /**< VLAN filtering disabled */
94                 .jumbo_frame    = 0, /**< Jumbo Frame Support disabled */
95         },
96         .txmode = {
97                 .mq_mode = ETH_MQ_TX_NONE,
98         },
99         .rx_adv_conf = {
100                 /*
101                  * should be overridden separately in code with
102                  * appropriate values
103                  */
104                 .vmdq_dcb_conf = {
105                         .nb_queue_pools = ETH_16_POOLS,
106                         .enable_default_pool = 0,
107                         .default_pool = 0,
108                         .nb_pool_maps = 0,
109                         .pool_map = {{0, 0},},
110                         .dcb_tc = {0},
111                 },
112         },
113 };
114
115 static uint8_t ports[RTE_MAX_ETHPORTS];
116 static unsigned num_ports = 0;
117
118 /* array used for printing out statistics */
119 volatile unsigned long rxPackets[ NUM_QUEUES ] = {0};
120
121 const uint16_t vlan_tags[] = {
122         0,  1,  2,  3,  4,  5,  6,  7,
123         8,  9, 10, 11,  12, 13, 14, 15,
124         16, 17, 18, 19, 20, 21, 22, 23,
125         24, 25, 26, 27, 28, 29, 30, 31
126 };
127
128 /* Builds up the correct configuration for vmdq+dcb based on the vlan tags array
129  * given above, and the number of traffic classes available for use. */
130 static inline int
131 get_eth_conf(struct rte_eth_conf *eth_conf, enum rte_eth_nb_pools num_pools)
132 {
133         struct rte_eth_vmdq_dcb_conf conf;
134         unsigned i;
135
136         if (num_pools != ETH_16_POOLS && num_pools != ETH_32_POOLS ) return -1;
137
138         conf.nb_queue_pools = num_pools;
139         conf.enable_default_pool = 0;
140         conf.default_pool = 0; /* set explicit value, even if not used */
141         conf.nb_pool_maps = sizeof( vlan_tags )/sizeof( vlan_tags[ 0 ]);
142         for (i = 0; i < conf.nb_pool_maps; i++){
143                 conf.pool_map[i].vlan_id = vlan_tags[ i ];
144                 conf.pool_map[i].pools = 1 << (i % num_pools);
145         }
146         for (i = 0; i < ETH_DCB_NUM_USER_PRIORITIES; i++){
147                 conf.dcb_tc[i] = (uint8_t)(i % (NUM_QUEUES/num_pools));
148         }
149         (void)(rte_memcpy(eth_conf, &vmdq_dcb_conf_default, sizeof(*eth_conf)));
150         (void)(rte_memcpy(&eth_conf->rx_adv_conf.vmdq_dcb_conf, &conf,
151                    sizeof(eth_conf->rx_adv_conf.vmdq_dcb_conf)));
152         return 0;
153 }
154
155 /*
156  * Initialises a given port using global settings and with the rx buffers
157  * coming from the mbuf_pool passed as parameter
158  */
159 static inline int
160 port_init(uint8_t port, struct rte_mempool *mbuf_pool)
161 {
162         struct rte_eth_conf port_conf;
163         const uint16_t rxRings = ETH_VMDQ_DCB_NUM_QUEUES,
164                 txRings = (uint16_t)rte_lcore_count();
165         const uint16_t rxRingSize = 128, txRingSize = 512;
166         int retval;
167         uint16_t q;
168
169         retval = get_eth_conf(&port_conf, num_pools);
170         if (retval < 0)
171                 return retval;
172
173         if (port >= rte_eth_dev_count()) return -1;
174
175         retval = rte_eth_dev_configure(port, rxRings, txRings, &port_conf);
176         if (retval != 0)
177                 return retval;
178
179         for (q = 0; q < rxRings; q ++) {
180                 retval = rte_eth_rx_queue_setup(port, q, rxRingSize,
181                                                 rte_eth_dev_socket_id(port),
182                                                 NULL,
183                                                 mbuf_pool);
184                 if (retval < 0)
185                         return retval;
186         }
187
188         for (q = 0; q < txRings; q ++) {
189                 retval = rte_eth_tx_queue_setup(port, q, txRingSize,
190                                                 rte_eth_dev_socket_id(port),
191                                                 NULL);
192                 if (retval < 0)
193                         return retval;
194         }
195
196         retval  = rte_eth_dev_start(port);
197         if (retval < 0)
198                 return retval;
199
200         struct ether_addr addr;
201         rte_eth_macaddr_get(port, &addr);
202         printf("Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8
203                         " %02"PRIx8" %02"PRIx8" %02"PRIx8"\n",
204                         (unsigned)port,
205                         addr.addr_bytes[0], addr.addr_bytes[1], addr.addr_bytes[2],
206                         addr.addr_bytes[3], addr.addr_bytes[4], addr.addr_bytes[5]);
207
208         return 0;
209 }
210
211 /* Check num_pools parameter and set it if OK*/
212 static int
213 vmdq_parse_num_pools(const char *q_arg)
214 {
215         char *end = NULL;
216         int n;
217
218         /* parse number string */
219         n = strtol(q_arg, &end, 10);
220         if ((q_arg[0] == '\0') || (end == NULL) || (*end != '\0'))
221                 return -1;
222         if (n != 16 && n != 32)
223                 return -1;
224         if (n == 16)
225                 num_pools = ETH_16_POOLS;
226         else
227                 num_pools = ETH_32_POOLS;
228
229         return 0;
230 }
231
232 static int
233 parse_portmask(const char *portmask)
234 {
235         char *end = NULL;
236         unsigned long pm;
237
238         /* parse hexadecimal string */
239         pm = strtoul(portmask, &end, 16);
240         if ((portmask[0] == '\0') || (end == NULL) || (*end != '\0'))
241                 return -1;
242
243         if (pm == 0)
244                 return -1;
245
246         return pm;
247 }
248
249 /* Display usage */
250 static void
251 vmdq_usage(const char *prgname)
252 {
253         printf("%s [EAL options] -- -p PORTMASK]\n"
254                "  --nb-pools NP: number of pools (16 default, 32)\n",
255                prgname);
256 }
257
258 /*  Parse the argument (num_pools) given in the command line of the application */
259 static int
260 vmdq_parse_args(int argc, char **argv)
261 {
262         int opt;
263         int option_index;
264         unsigned i;
265         const char *prgname = argv[0];
266         static struct option long_option[] = {
267                 {"nb-pools", required_argument, NULL, 0},
268                 {NULL, 0, 0, 0}
269         };
270
271         /* Parse command line */
272         while ((opt = getopt_long(argc, argv, "p:",long_option,&option_index)) != EOF) {
273                 switch (opt) {
274                 /* portmask */
275                 case 'p':
276                         enabled_port_mask = parse_portmask(optarg);
277                         if (enabled_port_mask == 0) {
278                                 printf("invalid portmask\n");
279                                 vmdq_usage(prgname);
280                                 return -1;
281                         }
282                         break;
283                 case 0:
284                         if (vmdq_parse_num_pools(optarg) == -1){
285                                 printf("invalid number of pools\n");
286                                 vmdq_usage(prgname);
287                                 return -1;
288                         }
289                         break;
290                 default:
291                         vmdq_usage(prgname);
292                         return -1;
293                 }
294         }
295
296         for(i = 0; i < RTE_MAX_ETHPORTS; i++)
297         {
298                 if (enabled_port_mask & (1 << i))
299                         ports[num_ports++] = (uint8_t)i;
300         }
301
302         if (num_ports < 2 || num_ports % 2) {
303                 printf("Current enabled port number is %u,"
304                         "but it should be even and at least 2\n",num_ports);
305                 return -1;
306         }
307
308         return 0;
309 }
310
311
312 /* When we receive a HUP signal, print out our stats */
313 static void
314 sighup_handler(int signum)
315 {
316         unsigned q;
317         for (q = 0; q < NUM_QUEUES; q ++) {
318                 if (q % (NUM_QUEUES/num_pools) == 0)
319                         printf("\nPool %u: ", q/(NUM_QUEUES/num_pools));
320                 printf("%lu ", rxPackets[ q ]);
321         }
322         printf("\nFinished handling signal %d\n", signum);
323 }
324
325 /*
326  * Main thread that does the work, reading from INPUT_PORT
327  * and writing to OUTPUT_PORT
328  */
329 static  __attribute__((noreturn)) int
330 lcore_main(void *arg)
331 {
332         const uintptr_t core_num = (uintptr_t)arg;
333         const unsigned num_cores = rte_lcore_count();
334         uint16_t startQueue = (uint16_t)(core_num * (NUM_QUEUES/num_cores));
335         uint16_t endQueue = (uint16_t)(startQueue + (NUM_QUEUES/num_cores));
336         uint16_t q, i, p;
337
338         printf("Core %u(lcore %u) reading queues %i-%i\n", (unsigned)core_num,
339                rte_lcore_id(), startQueue, endQueue - 1);
340
341         for (;;) {
342                 struct rte_mbuf *buf[32];
343                 const uint16_t buf_size = sizeof(buf) / sizeof(buf[0]);
344                 for (p = 0; p < num_ports; p++) {
345                         const uint8_t src = ports[p];
346                         const uint8_t dst = ports[p ^ 1]; /* 0 <-> 1, 2 <-> 3 etc */
347
348                         if ((src == INVALID_PORT_ID) || (dst == INVALID_PORT_ID))
349                                 continue;
350
351                         for (q = startQueue; q < endQueue; q++) {
352                                 const uint16_t rxCount = rte_eth_rx_burst(src,
353                                         q, buf, buf_size);
354                                 if (rxCount == 0)
355                                         continue;
356                                 rxPackets[q] += rxCount;
357
358                                 const uint16_t txCount = rte_eth_tx_burst(dst,
359                                         (uint16_t)core_num, buf, rxCount);
360                                 if (txCount != rxCount) {
361                                         for (i = txCount; i < rxCount; i++)
362                                                 rte_pktmbuf_free(buf[i]);
363                                 }
364                         }
365                 }
366         }
367 }
368
369 /*
370  * Update the global var NUM_PORTS and array PORTS according to system ports number
371  * and return valid ports number
372  */
373 static unsigned check_ports_num(unsigned nb_ports)
374 {
375         unsigned valid_num_ports = num_ports;
376         unsigned portid;
377
378         if (num_ports > nb_ports) {
379                 printf("\nSpecified port number(%u) exceeds total system port number(%u)\n",
380                         num_ports, nb_ports);
381                 num_ports = nb_ports;
382         }
383
384         for (portid = 0; portid < num_ports; portid ++) {
385                 if (ports[portid] >= nb_ports) {
386                         printf("\nSpecified port ID(%u) exceeds max system port ID(%u)\n",
387                                 ports[portid], (nb_ports - 1));
388                         ports[portid] = INVALID_PORT_ID;
389                         valid_num_ports --;
390                 }
391         }
392         return valid_num_ports;
393 }
394
395
396 /* Main function, does initialisation and calls the per-lcore functions */
397 int
398 main(int argc, char *argv[])
399 {
400         unsigned cores;
401         struct rte_mempool *mbuf_pool;
402         unsigned lcore_id;
403         uintptr_t i;
404         int ret;
405         unsigned nb_ports, valid_num_ports;
406         uint8_t portid;
407
408         signal(SIGHUP, sighup_handler);
409
410         /* init EAL */
411         ret = rte_eal_init(argc, argv);
412         if (ret < 0)
413                 rte_exit(EXIT_FAILURE, "Error with EAL initialization\n");
414         argc -= ret;
415         argv += ret;
416
417         /* parse app arguments */
418         ret = vmdq_parse_args(argc, argv);
419         if (ret < 0)
420                 rte_exit(EXIT_FAILURE, "Invalid VMDQ argument\n");
421
422         cores = rte_lcore_count();
423         if ((cores & (cores - 1)) != 0 || cores > 128) {
424                 rte_exit(EXIT_FAILURE,"This program can only run on an even"
425                                 "number of cores(1-128)\n\n");
426         }
427
428         nb_ports = rte_eth_dev_count();
429         if (nb_ports > RTE_MAX_ETHPORTS)
430                 nb_ports = RTE_MAX_ETHPORTS;
431
432         /*
433          * Update the global var NUM_PORTS and global array PORTS
434          * and get value of var VALID_NUM_PORTS according to system ports number
435          */
436         valid_num_ports = check_ports_num(nb_ports);
437
438         if (valid_num_ports < 2 || valid_num_ports % 2) {
439                 printf("Current valid ports number is %u\n", valid_num_ports);
440                 rte_exit(EXIT_FAILURE, "Error with valid ports number is not even or less than 2\n");
441         }
442
443         mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL", NUM_MBUFS * nb_ports,
444                 MBUF_CACHE_SIZE, 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
445         if (mbuf_pool == NULL)
446                 rte_exit(EXIT_FAILURE, "Cannot create mbuf pool\n");
447
448         /* initialize all ports */
449         for (portid = 0; portid < nb_ports; portid++) {
450                 /* skip ports that are not enabled */
451                 if ((enabled_port_mask & (1 << portid)) == 0) {
452                         printf("\nSkipping disabled port %d\n", portid);
453                         continue;
454                 }
455                 if (port_init(portid, mbuf_pool) != 0)
456                         rte_exit(EXIT_FAILURE, "Cannot initialize network ports\n");
457         }
458
459         /* call lcore_main() on every slave lcore */
460         i = 0;
461         RTE_LCORE_FOREACH_SLAVE(lcore_id) {
462                 rte_eal_remote_launch(lcore_main, (void*)i++, lcore_id);
463         }
464         /* call on master too */
465         (void) lcore_main((void*)i);
466
467         return 0;
468 }