1.. SPDX-License-Identifier: BSD-3-Clause 2 Copyright(c) 2010-2014 Intel Corporation. 3 4L3 Forwarding Sample Application 5================================ 6 7The L3 Forwarding application is a simple example of packet processing using 8DPDK to demonstrate usage of poll and event mode packet I/O mechanism. 9The application performs L3 forwarding. 10 11Overview 12-------- 13 14The application demonstrates the use of the hash and LPM libraries in the DPDK 15to implement packet forwarding using poll or event mode PMDs for packet I/O. 16The initialization and run-time paths are very similar to those of the 17:doc:`l2_forward_real_virtual` and :doc:`l2_forward_event`. 18The main difference from the L2 Forwarding sample application is that optionally 19packet can be Rx/Tx from/to eventdev instead of port directly and forwarding 20decision is made based on information read from the input packet. 21 22Eventdev can optionally use S/W or H/W (if supported by platform) scheduler 23implementation for packet I/O based on run time parameters. 24 25The lookup method is either hash-based or LPM-based and is selected at run time. When the selected lookup method is hash-based, 26a hash object is used to emulate the flow classification stage. 27The hash object is used in correlation with a flow table to map each input packet to its flow at runtime. 28 29The hash lookup key is represented by a DiffServ 5-tuple composed of the following fields read from the input packet: 30Source IP Address, Destination IP Address, Protocol, Source Port and Destination Port. 31The ID of the output interface for the input packet is read from the identified flow table entry. 32The set of flows used by the application is statically configured and loaded into the hash at initialization time. 33When the selected lookup method is LPM based, an LPM object is used to emulate the forwarding stage for IPv4 packets. 34The LPM object is used as the routing table to identify the next hop for each input packet at runtime. 35 36The LPM lookup key is represented by the Destination IP Address field read from the input packet. 37The ID of the output interface for the input packet is the next hop returned by the LPM lookup. 38The set of LPM rules used by the application is statically configured and loaded into the LPM object at initialization time. 39 40In the sample application, hash-based forwarding supports IPv4 and IPv6. LPM-based forwarding supports IPv4 only. 41 42Compiling the Application 43------------------------- 44 45To compile the sample application see :doc:`compiling`. 46 47The application is located in the ``l3fwd`` sub-directory. 48 49Running the Application 50----------------------- 51 52The application has a number of command line options:: 53 54 ./dpdk-l3fwd [EAL options] -- -p PORTMASK 55 [-P] 56 [-E] 57 [-L] 58 --config(port,queue,lcore)[,(port,queue,lcore)] 59 [--eth-dest=X,MM:MM:MM:MM:MM:MM] 60 [--enable-jumbo [--max-pkt-len PKTLEN]] 61 [--no-numa] 62 [--hash-entry-num] 63 [--ipv6] 64 [--parse-ptype] 65 [--per-port-pool] 66 [--mode] 67 [--eventq-sched] 68 [--event-eth-rxqs] 69 70Where, 71 72* ``-p PORTMASK:`` Hexadecimal bitmask of ports to configure 73 74* ``-P:`` Optional, sets all ports to promiscuous mode so that packets are accepted regardless of the packet's Ethernet MAC destination address. 75 Without this option, only packets with the Ethernet MAC destination address set to the Ethernet address of the port are accepted. 76 77* ``-E:`` Optional, enable exact match. 78 79* ``-L:`` Optional, enable longest prefix match. 80 81* ``--config (port,queue,lcore)[,(port,queue,lcore)]:`` Determines which queues from which ports are mapped to which cores. 82 83* ``--eth-dest=X,MM:MM:MM:MM:MM:MM:`` Optional, ethernet destination for port X. 84 85* ``--enable-jumbo:`` Optional, enables jumbo frames. 86 87* ``--max-pkt-len:`` Optional, under the premise of enabling jumbo, maximum packet length in decimal (64-9600). 88 89* ``--no-numa:`` Optional, disables numa awareness. 90 91* ``--hash-entry-num:`` Optional, specifies the hash entry number in hexadecimal to be setup. 92 93* ``--ipv6:`` Optional, set if running ipv6 packets. 94 95* ``--parse-ptype:`` Optional, set to use software to analyze packet type. Without this option, hardware will check the packet type. 96 97* ``--per-port-pool:`` Optional, set to use independent buffer pools per port. Without this option, single buffer pool is used for all ports. 98 99* ``--mode:`` Optional, Packet transfer mode for I/O, poll or eventdev. 100 101* ``--eventq-sched:`` Optional, Event queue synchronization method, Ordered, Atomic or Parallel. Only valid if --mode=eventdev. 102 103* ``--event-eth-rxqs:`` Optional, Number of ethernet RX queues per device. Only valid if --mode=eventdev. 104 105 106For example, consider a dual processor socket platform with 8 physical cores, where cores 0-7 and 16-23 appear on socket 0, 107while cores 8-15 and 24-31 appear on socket 1. 108 109To enable L3 forwarding between two ports, assuming that both ports are in the same socket, using two cores, cores 1 and 2, 110(which are in the same socket too), use the following command: 111 112.. code-block:: console 113 114 ./<build_dir>/examples/dpdk-l3fwd -l 1,2 -n 4 -- -p 0x3 --config="(0,0,1),(1,0,2)" 115 116In this command: 117 118* The -l option enables cores 1, 2 119 120* The -p option enables ports 0 and 1 121 122* The --config option enables one queue on each port and maps each (port,queue) pair to a specific core. 123 The following table shows the mapping in this example: 124 125+----------+-----------+-----------+-------------------------------------+ 126| **Port** | **Queue** | **lcore** | **Description** | 127| | | | | 128+----------+-----------+-----------+-------------------------------------+ 129| 0 | 0 | 1 | Map queue 0 from port 0 to lcore 1. | 130| | | | | 131+----------+-----------+-----------+-------------------------------------+ 132| 1 | 0 | 2 | Map queue 0 from port 1 to lcore 2. | 133| | | | | 134+----------+-----------+-----------+-------------------------------------+ 135 136To use eventdev mode with sync method **ordered** on above mentioned environment, 137Following is the sample command: 138 139.. code-block:: console 140 141 ./<build_dir>/examples/dpdk-l3fwd -l 0-3 -n 4 -a <event device> -- -p 0x3 --eventq-sched=ordered 142 143or 144 145.. code-block:: console 146 147 ./<build_dir>/examples/dpdk-l3fwd -l 0-3 -n 4 -a <event device> \ 148 -- -p 0x03 --mode=eventdev --eventq-sched=ordered 149 150In this command: 151 152* -a option allows the event device supported by platform. 153 The syntax used to indicate this device may vary based on platform. 154 155* The --mode option defines PMD to be used for packet I/O. 156 157* The --eventq-sched option enables synchronization menthod of event queue so that packets will be scheduled accordingly. 158 159If application uses S/W scheduler, it uses following DPDK services: 160 161* Software scheduler 162* Rx adapter service function 163* Tx adapter service function 164 165Application needs service cores to run above mentioned services. Service cores 166must be provided as EAL parameters along with the --vdev=event_sw0 to enable S/W 167scheduler. Following is the sample command: 168 169.. code-block:: console 170 171 ./<build_dir>/examples/dpdk-l3fwd -l 0-7 -s 0xf0000 -n 4 --vdev event_sw0 -- -p 0x3 --mode=eventdev --eventq-sched=ordered 172 173In case of eventdev mode, *--config* option is not used for ethernet port 174configuration. Instead each ethernet port will be configured with mentioned 175setup: 176 177* Single Rx/Tx queue 178 179* Each Rx queue will be connected to event queue via Rx adapter. 180 181* Each Tx queue will be connected via Tx adapter. 182 183Refer to the *DPDK Getting Started Guide* for general information on running applications and 184the Environment Abstraction Layer (EAL) options. 185 186.. _l3_fwd_explanation: 187 188Explanation 189----------- 190 191The following sections provide some explanation of the sample application code. As mentioned in the overview section, 192the initialization and run-time paths are very similar to those of the :doc:`l2_forward_real_virtual` and :doc:`l2_forward_event`. 193The following sections describe aspects that are specific to the L3 Forwarding sample application. 194 195Hash Initialization 196~~~~~~~~~~~~~~~~~~~ 197 198The hash object is created and loaded with the pre-configured entries read from a global array, 199and then generate the expected 5-tuple as key to keep consistence with those of real flow 200for the convenience to execute hash performance test on 4M/8M/16M flows. 201 202.. note:: 203 204 The Hash initialization will setup both ipv4 and ipv6 hash table, 205 and populate the either table depending on the value of variable ipv6. 206 To support the hash performance test with up to 8M single direction flows/16M bi-direction flows, 207 populate_ipv4_many_flow_into_table() function will populate the hash table with specified hash table entry number(default 4M). 208 209.. note:: 210 211 Value of global variable ipv6 can be specified with --ipv6 in the command line. 212 Value of global variable hash_entry_number, 213 which is used to specify the total hash entry number for all used ports in hash performance test, 214 can be specified with --hash-entry-num VALUE in command line, being its default value 4. 215 216.. code-block:: c 217 218 #if (APP_LOOKUP_METHOD == APP_LOOKUP_EXACT_MATCH) 219 220 static void 221 setup_hash(int socketid) 222 { 223 // ... 224 225 if (hash_entry_number != HASH_ENTRY_NUMBER_DEFAULT) { 226 if (ipv6 == 0) { 227 /* populate the ipv4 hash */ 228 populate_ipv4_many_flow_into_table(ipv4_l3fwd_lookup_struct[socketid], hash_entry_number); 229 } else { 230 /* populate the ipv6 hash */ 231 populate_ipv6_many_flow_into_table( ipv6_l3fwd_lookup_struct[socketid], hash_entry_number); 232 } 233 } else 234 if (ipv6 == 0) { 235 /* populate the ipv4 hash */ 236 populate_ipv4_few_flow_into_table(ipv4_l3fwd_lookup_struct[socketid]); 237 } else { 238 /* populate the ipv6 hash */ 239 populate_ipv6_few_flow_into_table(ipv6_l3fwd_lookup_struct[socketid]); 240 } 241 } 242 } 243 #endif 244 245LPM Initialization 246~~~~~~~~~~~~~~~~~~ 247 248The LPM object is created and loaded with the pre-configured entries read from a global array. 249 250.. code-block:: c 251 252 #if (APP_LOOKUP_METHOD == APP_LOOKUP_LPM) 253 254 static void 255 setup_lpm(int socketid) 256 { 257 unsigned i; 258 int ret; 259 char s[64]; 260 261 /* create the LPM table */ 262 263 snprintf(s, sizeof(s), "IPV4_L3FWD_LPM_%d", socketid); 264 265 ipv4_l3fwd_lookup_struct[socketid] = rte_lpm_create(s, socketid, IPV4_L3FWD_LPM_MAX_RULES, 0); 266 267 if (ipv4_l3fwd_lookup_struct[socketid] == NULL) 268 rte_exit(EXIT_FAILURE, "Unable to create the l3fwd LPM table" 269 " on socket %d\n", socketid); 270 271 /* populate the LPM table */ 272 273 for (i = 0; i < IPV4_L3FWD_NUM_ROUTES; i++) { 274 /* skip unused ports */ 275 276 if ((1 << ipv4_l3fwd_route_array[i].if_out & enabled_port_mask) == 0) 277 continue; 278 279 ret = rte_lpm_add(ipv4_l3fwd_lookup_struct[socketid], ipv4_l3fwd_route_array[i].ip, 280 ipv4_l3fwd_route_array[i].depth, ipv4_l3fwd_route_array[i].if_out); 281 282 if (ret < 0) { 283 rte_exit(EXIT_FAILURE, "Unable to add entry %u to the " 284 "l3fwd LPM table on socket %d\n", i, socketid); 285 } 286 287 printf("LPM: Adding route 0x%08x / %d (%d)\n", 288 (unsigned)ipv4_l3fwd_route_array[i].ip, ipv4_l3fwd_route_array[i].depth, ipv4_l3fwd_route_array[i].if_out); 289 } 290 } 291 #endif 292 293Packet Forwarding for Hash-based Lookups 294~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 295 296For each input packet, the packet forwarding operation is done by the l3fwd_simple_forward() 297or simple_ipv4_fwd_4pkts() function for IPv4 packets or the simple_ipv6_fwd_4pkts() function for IPv6 packets. 298The l3fwd_simple_forward() function provides the basic functionality for both IPv4 and IPv6 packet forwarding 299for any number of burst packets received, 300and the packet forwarding decision (that is, the identification of the output interface for the packet) 301for hash-based lookups is done by the get_ipv4_dst_port() or get_ipv6_dst_port() function. 302The get_ipv4_dst_port() function is shown below: 303 304.. code-block:: c 305 306 static inline uint8_t 307 get_ipv4_dst_port(void *ipv4_hdr, uint16_t portid, lookup_struct_t *ipv4_l3fwd_lookup_struct) 308 { 309 int ret = 0; 310 union ipv4_5tuple_host key; 311 312 ipv4_hdr = (uint8_t *)ipv4_hdr + offsetof(struct rte_ipv4_hdr, time_to_live); 313 314 m128i data = _mm_loadu_si128(( m128i*)(ipv4_hdr)); 315 316 /* Get 5 tuple: dst port, src port, dst IP address, src IP address and protocol */ 317 318 key.xmm = _mm_and_si128(data, mask0); 319 320 /* Find destination port */ 321 322 ret = rte_hash_lookup(ipv4_l3fwd_lookup_struct, (const void *)&key); 323 324 return (uint8_t)((ret < 0)? portid : ipv4_l3fwd_out_if[ret]); 325 } 326 327The get_ipv6_dst_port() function is similar to the get_ipv4_dst_port() function. 328 329The simple_ipv4_fwd_4pkts() and simple_ipv6_fwd_4pkts() function are optimized for continuous 4 valid ipv4 and ipv6 packets, 330they leverage the multiple buffer optimization to boost the performance of forwarding packets with the exact match on hash table. 331The key code snippet of simple_ipv4_fwd_4pkts() is shown below: 332 333.. code-block:: c 334 335 static inline void 336 simple_ipv4_fwd_4pkts(struct rte_mbuf* m[4], uint16_t portid, struct lcore_conf *qconf) 337 { 338 // ... 339 340 data[0] = _mm_loadu_si128(( m128i*)(rte_pktmbuf_mtod(m[0], unsigned char *) + sizeof(struct rte_ether_hdr) + offsetof(struct rte_ipv4_hdr, time_to_live))); 341 data[1] = _mm_loadu_si128(( m128i*)(rte_pktmbuf_mtod(m[1], unsigned char *) + sizeof(struct rte_ether_hdr) + offsetof(struct rte_ipv4_hdr, time_to_live))); 342 data[2] = _mm_loadu_si128(( m128i*)(rte_pktmbuf_mtod(m[2], unsigned char *) + sizeof(struct rte_ether_hdr) + offsetof(struct rte_ipv4_hdr, time_to_live))); 343 data[3] = _mm_loadu_si128(( m128i*)(rte_pktmbuf_mtod(m[3], unsigned char *) + sizeof(struct rte_ether_hdr) + offsetof(struct rte_ipv4_hdr, time_to_live))); 344 345 key[0].xmm = _mm_and_si128(data[0], mask0); 346 key[1].xmm = _mm_and_si128(data[1], mask0); 347 key[2].xmm = _mm_and_si128(data[2], mask0); 348 key[3].xmm = _mm_and_si128(data[3], mask0); 349 350 const void *key_array[4] = {&key[0], &key[1], &key[2],&key[3]}; 351 352 rte_hash_lookup_bulk(qconf->ipv4_lookup_struct, &key_array[0], 4, ret); 353 354 dst_port[0] = (ret[0] < 0)? portid:ipv4_l3fwd_out_if[ret[0]]; 355 dst_port[1] = (ret[1] < 0)? portid:ipv4_l3fwd_out_if[ret[1]]; 356 dst_port[2] = (ret[2] < 0)? portid:ipv4_l3fwd_out_if[ret[2]]; 357 dst_port[3] = (ret[3] < 0)? portid:ipv4_l3fwd_out_if[ret[3]]; 358 359 // ... 360 } 361 362The simple_ipv6_fwd_4pkts() function is similar to the simple_ipv4_fwd_4pkts() function. 363 364Known issue: IP packets with extensions or IP packets which are not TCP/UDP cannot work well at this mode. 365 366Packet Forwarding for LPM-based Lookups 367~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 368 369For each input packet, the packet forwarding operation is done by the l3fwd_simple_forward() function, 370but the packet forwarding decision (that is, the identification of the output interface for the packet) 371for LPM-based lookups is done by the get_ipv4_dst_port() function below: 372 373.. code-block:: c 374 375 static inline uint16_t 376 get_ipv4_dst_port(struct rte_ipv4_hdr *ipv4_hdr, uint16_t portid, lookup_struct_t *ipv4_l3fwd_lookup_struct) 377 { 378 uint8_t next_hop; 379 380 return ((rte_lpm_lookup(ipv4_l3fwd_lookup_struct, rte_be_to_cpu_32(ipv4_hdr->dst_addr), &next_hop) == 0)? next_hop : portid); 381 } 382 383Eventdev Driver Initialization 384~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 385Eventdev driver initialization is same as L2 forwarding eventdev application. 386Refer :doc:`l2_forward_event` for more details. 387