l3_forward.rst revision 7b53c036
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 compile 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 where cores 0-7 and 16-23 appear on socket 0, while cores 8-15 and 24-31 appear on socket 1.
133Let'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,
134and the programmer wants to use two cores from each processor socket to do the packet processing.
135
136To enable L3 forwarding between two ports, using two cores, cores 1 and 2, from each processor,
137while also taking advantage of local memory access by optimizing around NUMA, the programmer must enable two queues from each port,
138pin to the appropriate cores and allocate memory from the appropriate NUMA node. This is achieved using the following command:
139
140.. code-block:: console
141
142    ./build/l3fwd -c 606 -n 4 -- -p 0x3 --config="(0,0,1),(0,1,2),(1,0,9),(1,1,10)"
143
144In this command:
145
146*   The -c option enables cores 0, 1, 2, 3
147
148*   The -p option enables ports 0 and 1
149
150*   The --config option enables two queues on each port and maps each (port,queue) pair to a specific core.
151    Logic to enable multiple RX queues using RSS and to allocate memory from the correct NUMA nodes
152    is included in the application and is done transparently.
153    The following table shows the mapping in this example:
154
155+----------+-----------+-----------+-------------------------------------+
156| **Port** | **Queue** | **lcore** | **Description**                     |
157|          |           |           |                                     |
158+----------+-----------+-----------+-------------------------------------+
159| 0        | 0         | 0         | Map queue 0 from port 0 to lcore 0. |
160|          |           |           |                                     |
161+----------+-----------+-----------+-------------------------------------+
162| 0        | 1         | 2         | Map queue 1 from port 0 to lcore 2. |
163|          |           |           |                                     |
164+----------+-----------+-----------+-------------------------------------+
165| 1        | 0         | 1         | Map queue 0 from port 1 to lcore 1. |
166|          |           |           |                                     |
167+----------+-----------+-----------+-------------------------------------+
168| 1        | 1         | 3         | Map queue 1 from port 1 to lcore 3. |
169|          |           |           |                                     |
170+----------+-----------+-----------+-------------------------------------+
171
172Refer to the *DPDK Getting Started Guide* for general information on running applications and
173the Environment Abstraction Layer (EAL) options.
174
175.. _l3_fwd_explanation:
176
177Explanation
178-----------
179
180The following sections provide some explanation of the sample application code. As mentioned in the overview section,
181the initialization and run-time paths are very similar to those of the :doc:`l2_forward_real_virtual`.
182The following sections describe aspects that are specific to the L3 Forwarding sample application.
183
184Hash Initialization
185~~~~~~~~~~~~~~~~~~~
186
187The hash object is created and loaded with the pre-configured entries read from a global array,
188and then generate the expected 5-tuple as key to keep consistence with those of real flow
189for the convenience to execute hash performance test on 4M/8M/16M flows.
190
191.. note::
192
193    The Hash initialization will setup both ipv4 and ipv6 hash table,
194    and populate the either table depending on the value of variable ipv6.
195    To support the hash performance test with up to 8M single direction flows/16M bi-direction flows,
196    populate_ipv4_many_flow_into_table() function will populate the hash table with specified hash table entry number(default 4M).
197
198.. note::
199
200    Value of global variable ipv6 can be specified with --ipv6 in the command line.
201    Value of global variable hash_entry_number,
202    which is used to specify the total hash entry number for all used ports in hash performance test,
203    can be specified with --hash-entry-num VALUE in command line, being its default value 4.
204
205.. code-block:: c
206
207    #if (APP_LOOKUP_METHOD == APP_LOOKUP_EXACT_MATCH)
208
209        static void
210        setup_hash(int socketid)
211        {
212            // ...
213
214            if (hash_entry_number != HASH_ENTRY_NUMBER_DEFAULT) {
215                if (ipv6 == 0) {
216                    /* populate the ipv4 hash */
217                    populate_ipv4_many_flow_into_table(ipv4_l3fwd_lookup_struct[socketid], hash_entry_number);
218                } else {
219                    /* populate the ipv6 hash */
220                    populate_ipv6_many_flow_into_table( ipv6_l3fwd_lookup_struct[socketid], hash_entry_number);
221                }
222            } else
223                if (ipv6 == 0) {
224                    /* populate the ipv4 hash */
225                    populate_ipv4_few_flow_into_table(ipv4_l3fwd_lookup_struct[socketid]);
226                } else {
227                    /* populate the ipv6 hash */
228                    populate_ipv6_few_flow_into_table(ipv6_l3fwd_lookup_struct[socketid]);
229                }
230            }
231        }
232    #endif
233
234LPM Initialization
235~~~~~~~~~~~~~~~~~~
236
237The LPM object is created and loaded with the pre-configured entries read from a global array.
238
239.. code-block:: c
240
241    #if (APP_LOOKUP_METHOD == APP_LOOKUP_LPM)
242
243    static void
244    setup_lpm(int socketid)
245    {
246        unsigned i;
247        int ret;
248        char s[64];
249
250        /* create the LPM table */
251
252        snprintf(s, sizeof(s), "IPV4_L3FWD_LPM_%d", socketid);
253
254        ipv4_l3fwd_lookup_struct[socketid] = rte_lpm_create(s, socketid, IPV4_L3FWD_LPM_MAX_RULES, 0);
255
256        if (ipv4_l3fwd_lookup_struct[socketid] == NULL)
257            rte_exit(EXIT_FAILURE, "Unable to create the l3fwd LPM table"
258                " on socket %d\n", socketid);
259
260        /* populate the LPM table */
261
262        for (i = 0; i < IPV4_L3FWD_NUM_ROUTES; i++) {
263            /* skip unused ports */
264
265            if ((1 << ipv4_l3fwd_route_array[i].if_out & enabled_port_mask) == 0)
266                continue;
267
268            ret = rte_lpm_add(ipv4_l3fwd_lookup_struct[socketid], ipv4_l3fwd_route_array[i].ip,
269           	                    ipv4_l3fwd_route_array[i].depth, ipv4_l3fwd_route_array[i].if_out);
270
271            if (ret < 0) {
272                rte_exit(EXIT_FAILURE, "Unable to add entry %u to the "
273                        "l3fwd LPM table on socket %d\n", i, socketid);
274            }
275
276            printf("LPM: Adding route 0x%08x / %d (%d)\n",
277                (unsigned)ipv4_l3fwd_route_array[i].ip, ipv4_l3fwd_route_array[i].depth, ipv4_l3fwd_route_array[i].if_out);
278        }
279    }
280    #endif
281
282Packet Forwarding for Hash-based Lookups
283~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
284
285For each input packet, the packet forwarding operation is done by the l3fwd_simple_forward()
286or simple_ipv4_fwd_4pkts() function for IPv4 packets or the simple_ipv6_fwd_4pkts() function for IPv6 packets.
287The l3fwd_simple_forward() function provides the basic functionality for both IPv4 and IPv6 packet forwarding
288for any number of burst packets received,
289and the packet forwarding decision (that is, the identification of the output interface for the packet)
290for hash-based lookups is done by the  get_ipv4_dst_port() or get_ipv6_dst_port() function.
291The get_ipv4_dst_port() function is shown below:
292
293.. code-block:: c
294
295    static inline uint8_t
296    get_ipv4_dst_port(void *ipv4_hdr, uint8_t portid, lookup_struct_t *ipv4_l3fwd_lookup_struct)
297    {
298        int ret = 0;
299        union ipv4_5tuple_host key;
300
301        ipv4_hdr = (uint8_t *)ipv4_hdr + offsetof(struct ipv4_hdr, time_to_live);
302
303        m128i data = _mm_loadu_si128(( m128i*)(ipv4_hdr));
304
305        /* Get 5 tuple: dst port, src port, dst IP address, src IP address and protocol */
306
307        key.xmm = _mm_and_si128(data, mask0);
308
309        /* Find destination port */
310
311        ret = rte_hash_lookup(ipv4_l3fwd_lookup_struct, (const void *)&key);
312
313        return (uint8_t)((ret < 0)? portid : ipv4_l3fwd_out_if[ret]);
314    }
315
316The get_ipv6_dst_port() function is similar to the get_ipv4_dst_port() function.
317
318The simple_ipv4_fwd_4pkts() and simple_ipv6_fwd_4pkts() function are optimized for continuous 4 valid ipv4 and ipv6 packets,
319they leverage the multiple buffer optimization to boost the performance of forwarding packets with the exact match on hash table.
320The key code snippet of simple_ipv4_fwd_4pkts() is shown below:
321
322.. code-block:: c
323
324    static inline void
325    simple_ipv4_fwd_4pkts(struct rte_mbuf* m[4], uint8_t portid, struct lcore_conf *qconf)
326    {
327        // ...
328
329        data[0] = _mm_loadu_si128(( m128i*)(rte_pktmbuf_mtod(m[0], unsigned char *) + sizeof(struct ether_hdr) + offsetof(struct ipv4_hdr, time_to_live)));
330        data[1] = _mm_loadu_si128(( m128i*)(rte_pktmbuf_mtod(m[1], unsigned char *) + sizeof(struct ether_hdr) + offsetof(struct ipv4_hdr, time_to_live)));
331        data[2] = _mm_loadu_si128(( m128i*)(rte_pktmbuf_mtod(m[2], unsigned char *) + sizeof(struct ether_hdr) + offsetof(struct ipv4_hdr, time_to_live)));
332        data[3] = _mm_loadu_si128(( m128i*)(rte_pktmbuf_mtod(m[3], unsigned char *) + sizeof(struct ether_hdr) + offsetof(struct ipv4_hdr, time_to_live)));
333
334        key[0].xmm = _mm_and_si128(data[0], mask0);
335        key[1].xmm = _mm_and_si128(data[1], mask0);
336        key[2].xmm = _mm_and_si128(data[2], mask0);
337        key[3].xmm = _mm_and_si128(data[3], mask0);
338
339        const void *key_array[4] = {&key[0], &key[1], &key[2],&key[3]};
340
341        rte_hash_lookup_bulk(qconf->ipv4_lookup_struct, &key_array[0], 4, ret);
342
343        dst_port[0] = (ret[0] < 0)? portid:ipv4_l3fwd_out_if[ret[0]];
344        dst_port[1] = (ret[1] < 0)? portid:ipv4_l3fwd_out_if[ret[1]];
345        dst_port[2] = (ret[2] < 0)? portid:ipv4_l3fwd_out_if[ret[2]];
346        dst_port[3] = (ret[3] < 0)? portid:ipv4_l3fwd_out_if[ret[3]];
347
348        // ...
349    }
350
351The simple_ipv6_fwd_4pkts() function is similar to the simple_ipv4_fwd_4pkts() function.
352
353Known issue: IP packets with extensions or IP packets which are not TCP/UDP cannot work well at this mode.
354
355Packet Forwarding for LPM-based Lookups
356~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
357
358For each input packet, the packet forwarding operation is done by the l3fwd_simple_forward() function,
359but the packet forwarding decision (that is, the identification of the output interface for the packet)
360for LPM-based lookups is done by the get_ipv4_dst_port() function below:
361
362.. code-block:: c
363
364    static inline uint8_t
365    get_ipv4_dst_port(struct ipv4_hdr *ipv4_hdr, uint8_t portid, lookup_struct_t *ipv4_l3fwd_lookup_struct)
366    {
367        uint8_t next_hop;
368
369        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);
370    }
371