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 Intel® DPDK. 35The application performs L3 forwarding. 36 37Overview 38-------- 39 40The application demonstrates the use of the hash and LPM libraries in the Intel® DPDK to implement packet forwarding. 41The initialization and run-time paths are very similar to those of the L2 forwarding application 42(see Chapter 9 "L2 Forwarding Sample Application (in Real and Virtualized Environments)" for more information). 43The main difference from the L2 Forwarding sample application is that the forwarding decision 44is made based on information read from the input packet. 45 46The lookup method is either hash-based or LPM-based and is selected at compile time. When the selected lookup method is hash-based, 47a hash object is used to emulate the flow classification stage. 48The hash object is used in correlation with a flow table to map each input packet to its flow at runtime. 49 50The hash lookup key is represented by a DiffServ 5-tuple composed of the following fields read from the input packet: 51Source IP Address, Destination IP Address, Protocol, Source Port and Destination Port. 52The ID of the output interface for the input packet is read from the identified flow table entry. 53The set of flows used by the application is statically configured and loaded into the hash at initialization time. 54When the selected lookup method is LPM based, an LPM object is used to emulate the forwarding stage for IPv4 packets. 55The LPM object is used as the routing table to identify the next hop for each input packet at runtime. 56 57The LPM lookup key is represented by the Destination IP Address field read from the input packet. 58The ID of the output interface for the input packet is the next hop returned by the LPM lookup. 59The set of LPM rules used by the application is statically configured and loaded into the LPM object at initialization time. 60 61In the sample application, hash-based forwarding supports IPv4 and IPv6. LPM-based forwarding supports IPv4 only. 62 63Compiling the Application 64------------------------- 65 66To compile the application: 67 68#. Go to the sample application directory: 69 70 .. code-block:: console 71 72 export RTE_SDK=/path/to/rte_sdk 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 *Intel® 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.. code-block:: console 94 95 ./build/l3fwd [EAL options] -- -p PORTMASK [-P] --config(port,queue,lcore)[,(port,queue,lcore)] [--enable-jumbo [--max-pkt-len PKTLEN]] [--no-numa][--hash-entry-num][--ipv6] 96 97where, 98 99* -p PORTMASK: Hexadecimal bitmask of ports to configure 100 101* -P: optional, sets all ports to promiscuous mode so that packets are accepted regardless of the packet's Ethernet MAC destination address. 102 Without this option, only packets with the Ethernet MAC destination address set to the Ethernet address of the port are accepted. 103 104* --config (port,queue,lcore)[,(port,queue,lcore)]: determines which queues from which ports are mapped to which cores 105 106* --enable-jumbo: optional, enables jumbo frames 107 108* --max-pkt-len: optional, maximum packet length in decimal (64-9600) 109 110* --no-numa: optional, disables numa awareness 111 112* --hash-entry-num: optional, specifies the hash entry number in hexadecimal to be setup 113 114* --ipv6: optional, set it if running ipv6 packets 115 116For example, consider a dual processor socket platform where cores 0-7 and 16-23 appear on socket 0, while cores 8-15 and 24-31 appear on socket 1. 117Let's say that the programmer wants to use memory from both NUMA nodes, the platform has only two ports, one connected to each NUMA node, 118and the programmer wants to use two cores from each processor socket to do the packet processing. 119 120To enable L3 forwarding between two ports, using two cores, cores 1 and 2, from each processor, 121while also taking advantage of local memory access by optimizing around NUMA, the programmer must enable two queues from each port, 122pin to the appropriate cores and allocate memory from the appropriate NUMA node. This is achieved using the following command: 123 124.. code-block:: console 125 126 ./build/l3fwd -c 606 -n 4 -- -p 0x3 --config="(0,0,1),(0,1,2),(1,0,9),(1,1,10)" 127 128In this command: 129 130* The -c option enables cores 0, 1, 2, 3 131 132* The -p option enables ports 0 and 1 133 134* The --config option enables two queues on each port and maps each (port,queue) pair to a specific core. 135 Logic to enable multiple RX queues using RSS and to allocate memory from the correct NUMA nodes 136 is included in the application and is done transparently. 137 The following table shows the mapping in this example: 138 139+----------+-----------+-----------+-------------------------------------+ 140| **Port** | **Queue** | **lcore** | **Description** | 141| | | | | 142+----------+-----------+-----------+-------------------------------------+ 143| 0 | 0 | 0 | Map queue 0 from port 0 to lcore 0. | 144| | | | | 145+----------+-----------+-----------+-------------------------------------+ 146| 0 | 1 | 2 | Map queue 1 from port 0 to lcore 2. | 147| | | | | 148+----------+-----------+-----------+-------------------------------------+ 149| 1 | 0 | 1 | Map queue 0 from port 1 to lcore 1. | 150| | | | | 151+----------+-----------+-----------+-------------------------------------+ 152| 1 | 1 | 3 | Map queue 1 from port 1 to lcore 3. | 153| | | | | 154+----------+-----------+-----------+-------------------------------------+ 155 156Refer to the *Intel® DPDK Getting Started Guide* for general information on running applications and 157the Environment Abstraction Layer (EAL) options. 158 159Explanation 160----------- 161 162The following sections provide some explanation of the sample application code. As mentioned in the overview section, 163the initialization and run-time paths are very similar to those of the L2 forwarding application 164(see Chapter 9 "L2 Forwarding Sample Application (in Real and Virtualized Environments)" for more information). 165The following sections describe aspects that are specific to the L3 Forwarding sample application. 166 167Hash Initialization 168~~~~~~~~~~~~~~~~~~~ 169 170The hash object is created and loaded with the pre-configured entries read from a global array, 171and then generate the expected 5-tuple as key to keep consistence with those of real flow 172for the convenience to execute hash performance test on 4M/8M/16M flows. 173 174.. note:: 175 176 The Hash initialization will setup both ipv4 and ipv6 hash table, 177 and populate the either table depending on the value of variable ipv6. 178 To support the hash performance test with up to 8M single direction flows/16M bi-direction flows, 179 populate_ipv4_many_flow_into_table() function will populate the hash table with specified hash table entry number(default 4M). 180 181.. note:: 182 183 Value of global variable ipv6 can be specified with --ipv6 in the command line. 184 Value of global variable hash_entry_number, 185 which is used to specify the total hash entry number for all used ports in hash performance test, 186 can be specified with --hash-entry-num VALUE in command line, being its default value 4. 187 188.. code-block:: c 189 190 #if (APP_LOOKUP_METHOD == APP_LOOKUP_EXACT_MATCH) 191 192 static void 193 setup_hash(int socketid) 194 { 195 // ... 196 197 if (hash_entry_number != HASH_ENTRY_NUMBER_DEFAULT) { 198 if (ipv6 == 0) { 199 /* populate the ipv4 hash */ 200 populate_ipv4_many_flow_into_table(ipv4_l3fwd_lookup_struct[socketid], hash_entry_number); 201 } else { 202 /* populate the ipv6 hash */ 203 populate_ipv6_many_flow_into_table( ipv6_l3fwd_lookup_struct[socketid], hash_entry_number); 204 } 205 } else 206 if (ipv6 == 0) { 207 /* populate the ipv4 hash */ 208 populate_ipv4_few_flow_into_table(ipv4_l3fwd_lookup_struct[socketid]); 209 } else { 210 /* populate the ipv6 hash */ 211 populate_ipv6_few_flow_into_table(ipv6_l3fwd_lookup_struct[socketid]); 212 } 213 } 214 } 215 #endif 216 217LPM Initialization 218~~~~~~~~~~~~~~~~~~ 219 220The LPM object is created and loaded with the pre-configured entries read from a global array. 221 222.. code-block:: c 223 224 #if (APP_LOOKUP_METHOD == APP_LOOKUP_LPM) 225 226 static void 227 setup_lpm(int socketid) 228 { 229 unsigned i; 230 int ret; 231 char s[64]; 232 233 /* create the LPM table */ 234 235 rte_snprintf(s, sizeof(s), "IPV4_L3FWD_LPM_%d", socketid); 236 237 ipv4_l3fwd_lookup_struct[socketid] = rte_lpm_create(s, socketid, IPV4_L3FWD_LPM_MAX_RULES, 0); 238 239 if (ipv4_l3fwd_lookup_struct[socketid] == NULL) 240 rte_exit(EXIT_FAILURE, "Unable to create the l3fwd LPM table" 241 " on socket %d\n", socketid); 242 243 /* populate the LPM table */ 244 245 for (i = 0; i < IPV4_L3FWD_NUM_ROUTES; i++) { 246 /* skip unused ports */ 247 248 if ((1 << ipv4_l3fwd_route_array[i].if_out & enabled_port_mask) == 0) 249 continue; 250 251 ret = rte_lpm_add(ipv4_l3fwd_lookup_struct[socketid], ipv4_l3fwd_route_array[i].ip, 252 ipv4_l3fwd_route_array[i].depth, ipv4_l3fwd_route_array[i].if_out); 253 254 if (ret < 0) { 255 rte_exit(EXIT_FAILURE, "Unable to add entry %u to the " 256 "l3fwd LPM table on socket %d\n", i, socketid); 257 } 258 259 printf("LPM: Adding route 0x%08x / %d (%d)\n", 260 (unsigned)ipv4_l3fwd_route_array[i].ip, ipv4_l3fwd_route_array[i].depth, ipv4_l3fwd_route_array[i].if_out); 261 } 262 } 263 #endif 264 265Packet Forwarding for Hash-based Lookups 266~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 267 268For each input packet, the packet forwarding operation is done by the l3fwd_simple_forward() 269or simple_ipv4_fwd_4pkts() function for IPv4 packets or the simple_ipv6_fwd_4pkts() function for IPv6 packets. 270The l3fwd_simple_forward() function provides the basic functionality for both IPv4 and IPv6 packet forwarding 271for any number of burst packets received, 272and the packet forwarding decision (that is, the identification of the output interface for the packet) 273for hash-based lookups is done by the get_ipv4_dst_port() or get_ipv6_dst_port() function. 274The get_ipv4_dst_port() function is shown below: 275 276.. code-block:: c 277 278 static inline uint8_t 279 get_ipv4_dst_port(void *ipv4_hdr, uint8_t portid, lookup_struct_t *ipv4_l3fwd_lookup_struct) 280 { 281 int ret = 0; 282 union ipv4_5tuple_host key; 283 284 ipv4_hdr = (uint8_t \*)ipv4_hdr + offsetof(struct ipv4_hdr, time_to_live); 285 286 m128i data = _mm_loadu_si128(( m128i*)(ipv4_hdr)); 287 288 /* Get 5 tuple: dst port, src port, dst IP address, src IP address and protocol */ 289 290 key.xmm = _mm_and_si128(data, mask0); 291 292 /* Find destination port */ 293 294 ret = rte_hash_lookup(ipv4_l3fwd_lookup_struct, (const void *)&key); 295 296 return (uint8_t)((ret < 0)? portid : ipv4_l3fwd_out_if[ret]); 297 } 298 299The get_ipv6_dst_port() function is similar to the get_ipv4_dst_port() function. 300 301The simple_ipv4_fwd_4pkts() and simple_ipv6_fwd_4pkts() function are optimized for continuous 4 valid ipv4 and ipv6 packets, 302they leverage the multiple buffer optimization to boost the performance of forwarding packets with the exact match on hash table. 303The key code snippet of simple_ipv4_fwd_4pkts() is shown below: 304 305.. code-block:: c 306 307 static inline void 308 simple_ipv4_fwd_4pkts(struct rte_mbuf* m[4], uint8_t portid, struct lcore_conf *qconf) 309 { 310 // ... 311 312 data[0] = _mm_loadu_si128(( m128i*)(rte_pktmbuf_mtod(m[0], unsigned char *) + sizeof(struct ether_hdr) + offsetof(struct ipv4_hdr, time_to_live))); 313 data[1] = _mm_loadu_si128(( m128i*)(rte_pktmbuf_mtod(m[1], unsigned char *) + sizeof(struct ether_hdr) + offsetof(struct ipv4_hdr, time_to_live))); 314 data[2] = _mm_loadu_si128(( m128i*)(rte_pktmbuf_mtod(m[2], unsigned char *) + sizeof(struct ether_hdr) + offsetof(struct ipv4_hdr, time_to_live))); 315 data[3] = _mm_loadu_si128(( m128i*)(rte_pktmbuf_mtod(m[3], unsigned char *) + sizeof(struct ether_hdr) + offsetof(struct ipv4_hdr, time_to_live))); 316 317 key[0].xmm = _mm_and_si128(data[0], mask0); 318 key[1].xmm = _mm_and_si128(data[1], mask0); 319 key[2].xmm = _mm_and_si128(data[2], mask0); 320 key[3].xmm = _mm_and_si128(data[3], mask0); 321 322 const void *key_array[4] = {&key[0], &key[1], &key[2],&key[3]}; 323 324 rte_hash_lookup_multi(qconf->ipv4_lookup_struct, &key_array[0], 4, ret); 325 326 dst_port[0] = (ret[0] < 0)? portid:ipv4_l3fwd_out_if[ret[0]]; 327 dst_port[1] = (ret[1] < 0)? portid:ipv4_l3fwd_out_if[ret[1]]; 328 dst_port[2] = (ret[2] < 0)? portid:ipv4_l3fwd_out_if[ret[2]]; 329 dst_port[3] = (ret[3] < 0)? portid:ipv4_l3fwd_out_if[ret[3]]; 330 331 // ... 332 } 333 334The simple_ipv6_fwd_4pkts() function is similar to the simple_ipv4_fwd_4pkts() function. 335 336Packet Forwarding for LPM-based Lookups 337~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 338 339For each input packet, the packet forwarding operation is done by the l3fwd_simple_forward() function, 340but the packet forwarding decision (that is, the identification of the output interface for the packet) 341for LPM-based lookups is done by the get_ipv4_dst_port() function below: 342 343.. code-block:: c 344 345 static inline uint8_t 346 get_ipv4_dst_port(struct ipv4_hdr *ipv4_hdr, uint8_t portid, lookup_struct_t *ipv4_l3fwd_lookup_struct) 347 { 348 uint8_t next_hop; 349 350 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); 351 } 352