1.. BSD LICENSE 2 Copyright(c) 2010-2014 Intel Corporation. All rights reserved. 3 All rights reserved. 4 5 Redistribution and use in source and binary forms, with or without 6 modification, are permitted provided that the following conditions 7 are met: 8 9 * Redistributions of source code must retain the above copyright 10 notice, this list of conditions and the following disclaimer. 11 * Redistributions in binary form must reproduce the above copyright 12 notice, this list of conditions and the following disclaimer in 13 the documentation and/or other materials provided with the 14 distribution. 15 * Neither the name of Intel Corporation nor the names of its 16 contributors may be used to endorse or promote products derived 17 from this software without specific prior written permission. 18 19 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 31L3 Forwarding Sample Application 32================================ 33 34The L3 Forwarding application is a simple example of packet processing using the DPDK. 35The application performs L3 forwarding. 36 37Overview 38-------- 39 40The application demonstrates the use of the hash and LPM libraries in the DPDK to implement packet forwarding. 41The initialization and run-time paths are very similar to those of the :doc:`l2_forward_real_virtual`. 42The main difference from the L2 Forwarding sample application is that the forwarding decision 43is made based on information read from the input packet. 44 45The lookup method is either hash-based or LPM-based and is selected at run time. When the selected lookup method is hash-based, 46a hash object is used to emulate the flow classification stage. 47The hash object is used in correlation with a flow table to map each input packet to its flow at runtime. 48 49The hash lookup key is represented by a DiffServ 5-tuple composed of the following fields read from the input packet: 50Source IP Address, Destination IP Address, Protocol, Source Port and Destination Port. 51The ID of the output interface for the input packet is read from the identified flow table entry. 52The set of flows used by the application is statically configured and loaded into the hash at initialization time. 53When the selected lookup method is LPM based, an LPM object is used to emulate the forwarding stage for IPv4 packets. 54The LPM object is used as the routing table to identify the next hop for each input packet at runtime. 55 56The LPM lookup key is represented by the Destination IP Address field read from the input packet. 57The ID of the output interface for the input packet is the next hop returned by the LPM lookup. 58The set of LPM rules used by the application is statically configured and loaded into the LPM object at initialization time. 59 60In the sample application, hash-based forwarding supports IPv4 and IPv6. LPM-based forwarding supports IPv4 only. 61 62Compiling the Application 63------------------------- 64 65To compile the application: 66 67#. Go to the sample application directory: 68 69 .. code-block:: console 70 71 export RTE_SDK=/path/to/rte_sdk 72 cd ${RTE_SDK}/examples/l3fwd 73 74#. Set the target (a default target is used if not specified). For example: 75 76 .. code-block:: console 77 78 export RTE_TARGET=x86_64-native-linuxapp-gcc 79 80 See the *DPDK Getting Started Guide* for possible RTE_TARGET values. 81 82#. Build the application: 83 84 .. code-block:: console 85 86 make 87 88Running the Application 89----------------------- 90 91The application has a number of command line options:: 92 93 ./l3fwd [EAL options] -- -p PORTMASK 94 [-P] 95 [-E] 96 [-L] 97 --config(port,queue,lcore)[,(port,queue,lcore)] 98 [--eth-dest=X,MM:MM:MM:MM:MM:MM] 99 [--enable-jumbo [--max-pkt-len PKTLEN]] 100 [--no-numa] 101 [--hash-entry-num] 102 [--ipv6] 103 [--parse-ptype] 104 105Where, 106 107* ``-p PORTMASK:`` Hexadecimal bitmask of ports to configure 108 109* ``-P:`` Optional, sets all ports to promiscuous mode so that packets are accepted regardless of the packet's Ethernet MAC destination address. 110 Without this option, only packets with the Ethernet MAC destination address set to the Ethernet address of the port are accepted. 111 112* ``-E:`` Optional, enable exact match. 113 114* ``-L:`` Optional, enable longest prefix match. 115 116* ``--config (port,queue,lcore)[,(port,queue,lcore)]:`` Determines which queues from which ports are mapped to which cores. 117 118* ``--eth-dest=X,MM:MM:MM:MM:MM:MM:`` Optional, ethernet destination for port X. 119 120* ``--enable-jumbo:`` Optional, enables jumbo frames. 121 122* ``--max-pkt-len:`` Optional, under the premise of enabling jumbo, maximum packet length in decimal (64-9600). 123 124* ``--no-numa:`` Optional, disables numa awareness. 125 126* ``--hash-entry-num:`` Optional, specifies the hash entry number in hexadecimal to be setup. 127 128* ``--ipv6:`` Optional, set if running ipv6 packets. 129 130* ``--parse-ptype:`` Optional, set to use software to analyze packet type. Without this option, hardware will check the packet type. 131 132For example, consider a dual processor socket platform with 8 physical cores, where cores 0-7 and 16-23 appear on socket 0, 133while cores 8-15 and 24-31 appear on socket 1. 134 135To enable L3 forwarding between two ports, assuming that both ports are in the same socket, using two cores, cores 1 and 2, 136(which are in the same socket too), use the following command: 137 138.. code-block:: console 139 140 ./build/l3fwd -l 1,2 -n 4 -- -p 0x3 --config="(0,0,1),(1,0,2)" 141 142In this command: 143 144* The -l option enables cores 1, 2 145 146* The -p option enables ports 0 and 1 147 148* The --config option enables one queue on each port and maps each (port,queue) pair to a specific core. 149 The following table shows the mapping in this example: 150 151+----------+-----------+-----------+-------------------------------------+ 152| **Port** | **Queue** | **lcore** | **Description** | 153| | | | | 154+----------+-----------+-----------+-------------------------------------+ 155| 0 | 0 | 1 | Map queue 0 from port 0 to lcore 1. | 156| | | | | 157+----------+-----------+-----------+-------------------------------------+ 158| 1 | 0 | 2 | Map queue 0 from port 1 to lcore 2. | 159| | | | | 160+----------+-----------+-----------+-------------------------------------+ 161 162Refer to the *DPDK Getting Started Guide* for general information on running applications and 163the Environment Abstraction Layer (EAL) options. 164 165.. _l3_fwd_explanation: 166 167Explanation 168----------- 169 170The following sections provide some explanation of the sample application code. As mentioned in the overview section, 171the initialization and run-time paths are very similar to those of the :doc:`l2_forward_real_virtual`. 172The following sections describe aspects that are specific to the L3 Forwarding sample application. 173 174Hash Initialization 175~~~~~~~~~~~~~~~~~~~ 176 177The hash object is created and loaded with the pre-configured entries read from a global array, 178and then generate the expected 5-tuple as key to keep consistence with those of real flow 179for the convenience to execute hash performance test on 4M/8M/16M flows. 180 181.. note:: 182 183 The Hash initialization will setup both ipv4 and ipv6 hash table, 184 and populate the either table depending on the value of variable ipv6. 185 To support the hash performance test with up to 8M single direction flows/16M bi-direction flows, 186 populate_ipv4_many_flow_into_table() function will populate the hash table with specified hash table entry number(default 4M). 187 188.. note:: 189 190 Value of global variable ipv6 can be specified with --ipv6 in the command line. 191 Value of global variable hash_entry_number, 192 which is used to specify the total hash entry number for all used ports in hash performance test, 193 can be specified with --hash-entry-num VALUE in command line, being its default value 4. 194 195.. code-block:: c 196 197 #if (APP_LOOKUP_METHOD == APP_LOOKUP_EXACT_MATCH) 198 199 static void 200 setup_hash(int socketid) 201 { 202 // ... 203 204 if (hash_entry_number != HASH_ENTRY_NUMBER_DEFAULT) { 205 if (ipv6 == 0) { 206 /* populate the ipv4 hash */ 207 populate_ipv4_many_flow_into_table(ipv4_l3fwd_lookup_struct[socketid], hash_entry_number); 208 } else { 209 /* populate the ipv6 hash */ 210 populate_ipv6_many_flow_into_table( ipv6_l3fwd_lookup_struct[socketid], hash_entry_number); 211 } 212 } else 213 if (ipv6 == 0) { 214 /* populate the ipv4 hash */ 215 populate_ipv4_few_flow_into_table(ipv4_l3fwd_lookup_struct[socketid]); 216 } else { 217 /* populate the ipv6 hash */ 218 populate_ipv6_few_flow_into_table(ipv6_l3fwd_lookup_struct[socketid]); 219 } 220 } 221 } 222 #endif 223 224LPM Initialization 225~~~~~~~~~~~~~~~~~~ 226 227The LPM object is created and loaded with the pre-configured entries read from a global array. 228 229.. code-block:: c 230 231 #if (APP_LOOKUP_METHOD == APP_LOOKUP_LPM) 232 233 static void 234 setup_lpm(int socketid) 235 { 236 unsigned i; 237 int ret; 238 char s[64]; 239 240 /* create the LPM table */ 241 242 snprintf(s, sizeof(s), "IPV4_L3FWD_LPM_%d", socketid); 243 244 ipv4_l3fwd_lookup_struct[socketid] = rte_lpm_create(s, socketid, IPV4_L3FWD_LPM_MAX_RULES, 0); 245 246 if (ipv4_l3fwd_lookup_struct[socketid] == NULL) 247 rte_exit(EXIT_FAILURE, "Unable to create the l3fwd LPM table" 248 " on socket %d\n", socketid); 249 250 /* populate the LPM table */ 251 252 for (i = 0; i < IPV4_L3FWD_NUM_ROUTES; i++) { 253 /* skip unused ports */ 254 255 if ((1 << ipv4_l3fwd_route_array[i].if_out & enabled_port_mask) == 0) 256 continue; 257 258 ret = rte_lpm_add(ipv4_l3fwd_lookup_struct[socketid], ipv4_l3fwd_route_array[i].ip, 259 ipv4_l3fwd_route_array[i].depth, ipv4_l3fwd_route_array[i].if_out); 260 261 if (ret < 0) { 262 rte_exit(EXIT_FAILURE, "Unable to add entry %u to the " 263 "l3fwd LPM table on socket %d\n", i, socketid); 264 } 265 266 printf("LPM: Adding route 0x%08x / %d (%d)\n", 267 (unsigned)ipv4_l3fwd_route_array[i].ip, ipv4_l3fwd_route_array[i].depth, ipv4_l3fwd_route_array[i].if_out); 268 } 269 } 270 #endif 271 272Packet Forwarding for Hash-based Lookups 273~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 274 275For each input packet, the packet forwarding operation is done by the l3fwd_simple_forward() 276or simple_ipv4_fwd_4pkts() function for IPv4 packets or the simple_ipv6_fwd_4pkts() function for IPv6 packets. 277The l3fwd_simple_forward() function provides the basic functionality for both IPv4 and IPv6 packet forwarding 278for any number of burst packets received, 279and the packet forwarding decision (that is, the identification of the output interface for the packet) 280for hash-based lookups is done by the get_ipv4_dst_port() or get_ipv6_dst_port() function. 281The get_ipv4_dst_port() function is shown below: 282 283.. code-block:: c 284 285 static inline uint8_t 286 get_ipv4_dst_port(void *ipv4_hdr, uint8_t portid, lookup_struct_t *ipv4_l3fwd_lookup_struct) 287 { 288 int ret = 0; 289 union ipv4_5tuple_host key; 290 291 ipv4_hdr = (uint8_t *)ipv4_hdr + offsetof(struct ipv4_hdr, time_to_live); 292 293 m128i data = _mm_loadu_si128(( m128i*)(ipv4_hdr)); 294 295 /* Get 5 tuple: dst port, src port, dst IP address, src IP address and protocol */ 296 297 key.xmm = _mm_and_si128(data, mask0); 298 299 /* Find destination port */ 300 301 ret = rte_hash_lookup(ipv4_l3fwd_lookup_struct, (const void *)&key); 302 303 return (uint8_t)((ret < 0)? portid : ipv4_l3fwd_out_if[ret]); 304 } 305 306The get_ipv6_dst_port() function is similar to the get_ipv4_dst_port() function. 307 308The simple_ipv4_fwd_4pkts() and simple_ipv6_fwd_4pkts() function are optimized for continuous 4 valid ipv4 and ipv6 packets, 309they leverage the multiple buffer optimization to boost the performance of forwarding packets with the exact match on hash table. 310The key code snippet of simple_ipv4_fwd_4pkts() is shown below: 311 312.. code-block:: c 313 314 static inline void 315 simple_ipv4_fwd_4pkts(struct rte_mbuf* m[4], uint8_t portid, struct lcore_conf *qconf) 316 { 317 // ... 318 319 data[0] = _mm_loadu_si128(( m128i*)(rte_pktmbuf_mtod(m[0], unsigned char *) + sizeof(struct ether_hdr) + offsetof(struct ipv4_hdr, time_to_live))); 320 data[1] = _mm_loadu_si128(( m128i*)(rte_pktmbuf_mtod(m[1], unsigned char *) + sizeof(struct ether_hdr) + offsetof(struct ipv4_hdr, time_to_live))); 321 data[2] = _mm_loadu_si128(( m128i*)(rte_pktmbuf_mtod(m[2], unsigned char *) + sizeof(struct ether_hdr) + offsetof(struct ipv4_hdr, time_to_live))); 322 data[3] = _mm_loadu_si128(( m128i*)(rte_pktmbuf_mtod(m[3], unsigned char *) + sizeof(struct ether_hdr) + offsetof(struct ipv4_hdr, time_to_live))); 323 324 key[0].xmm = _mm_and_si128(data[0], mask0); 325 key[1].xmm = _mm_and_si128(data[1], mask0); 326 key[2].xmm = _mm_and_si128(data[2], mask0); 327 key[3].xmm = _mm_and_si128(data[3], mask0); 328 329 const void *key_array[4] = {&key[0], &key[1], &key[2],&key[3]}; 330 331 rte_hash_lookup_bulk(qconf->ipv4_lookup_struct, &key_array[0], 4, ret); 332 333 dst_port[0] = (ret[0] < 0)? portid:ipv4_l3fwd_out_if[ret[0]]; 334 dst_port[1] = (ret[1] < 0)? portid:ipv4_l3fwd_out_if[ret[1]]; 335 dst_port[2] = (ret[2] < 0)? portid:ipv4_l3fwd_out_if[ret[2]]; 336 dst_port[3] = (ret[3] < 0)? portid:ipv4_l3fwd_out_if[ret[3]]; 337 338 // ... 339 } 340 341The simple_ipv6_fwd_4pkts() function is similar to the simple_ipv4_fwd_4pkts() function. 342 343Known issue: IP packets with extensions or IP packets which are not TCP/UDP cannot work well at this mode. 344 345Packet Forwarding for LPM-based Lookups 346~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 347 348For each input packet, the packet forwarding operation is done by the l3fwd_simple_forward() function, 349but the packet forwarding decision (that is, the identification of the output interface for the packet) 350for LPM-based lookups is done by the get_ipv4_dst_port() function below: 351 352.. code-block:: c 353 354 static inline uint8_t 355 get_ipv4_dst_port(struct ipv4_hdr *ipv4_hdr, uint8_t portid, lookup_struct_t *ipv4_l3fwd_lookup_struct) 356 { 357 uint8_t next_hop; 358 359 return (uint8_t) ((rte_lpm_lookup(ipv4_l3fwd_lookup_struct, rte_be_to_cpu_32(ipv4_hdr->dst_addr), &next_hop) == 0)? next_hop : portid); 360 } 361