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