doc: add cryptodev sample code
[dpdk.git] / doc / guides / sample_app_ug / l3_forward.rst
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
31 L3 Forwarding Sample Application
32 ================================
33
34 The L3 Forwarding application is a simple example of packet processing using the DPDK.
35 The application performs L3 forwarding.
36
37 Overview
38 --------
39
40 The application demonstrates the use of the hash and LPM libraries in the DPDK to implement packet forwarding.
41 The initialization and run-time paths are very similar to those of the :doc:`l2_forward_real_virtual`.
42 The main difference from the L2 Forwarding sample application is that the forwarding decision
43 is made based on information read from the input packet.
44
45 The lookup method is either hash-based or LPM-based and is selected at run time. When the selected lookup method is hash-based,
46 a hash object is used to emulate the flow classification stage.
47 The hash object is used in correlation with a flow table to map each input packet to its flow at runtime.
48
49 The hash lookup key is represented by a DiffServ 5-tuple composed of the following fields read from the input packet:
50 Source IP Address, Destination IP Address, Protocol, Source Port and Destination Port.
51 The ID of the output interface for the input packet is read from the identified flow table entry.
52 The set of flows used by the application is statically configured and loaded into the hash at initialization time.
53 When the selected lookup method is LPM based, an LPM object is used to emulate the forwarding stage for IPv4 packets.
54 The LPM object is used as the routing table to identify the next hop for each input packet at runtime.
55
56 The LPM lookup key is represented by the Destination IP Address field read from the input packet.
57 The ID of the output interface for the input packet is the next hop returned by the LPM lookup.
58 The set of LPM rules used by the application is statically configured and loaded into the LPM object at initialization time.
59
60 In the sample application, hash-based forwarding supports IPv4 and IPv6. LPM-based forwarding supports IPv4 only.
61
62 Compiling the Application
63 -------------------------
64
65 To 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
88 Running the Application
89 -----------------------
90
91 The 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
105 Where,
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
132 For example, consider a dual processor socket platform with 8 physical cores, where cores 0-7 and 16-23 appear on socket 0,
133 while cores 8-15 and 24-31 appear on socket 1.
134
135 To 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
142 In 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
162 Refer to the *DPDK Getting Started Guide* for general information on running applications and
163 the Environment Abstraction Layer (EAL) options.
164
165 .. _l3_fwd_explanation:
166
167 Explanation
168 -----------
169
170 The following sections provide some explanation of the sample application code. As mentioned in the overview section,
171 the initialization and run-time paths are very similar to those of the :doc:`l2_forward_real_virtual`.
172 The following sections describe aspects that are specific to the L3 Forwarding sample application.
173
174 Hash Initialization
175 ~~~~~~~~~~~~~~~~~~~
176
177 The hash object is created and loaded with the pre-configured entries read from a global array,
178 and then generate the expected 5-tuple as key to keep consistence with those of real flow
179 for 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
224 LPM Initialization
225 ~~~~~~~~~~~~~~~~~~
226
227 The 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
272 Packet Forwarding for Hash-based Lookups
273 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
274
275 For each input packet, the packet forwarding operation is done by the l3fwd_simple_forward()
276 or simple_ipv4_fwd_4pkts() function for IPv4 packets or the simple_ipv6_fwd_4pkts() function for IPv6 packets.
277 The l3fwd_simple_forward() function provides the basic functionality for both IPv4 and IPv6 packet forwarding
278 for any number of burst packets received,
279 and the packet forwarding decision (that is, the identification of the output interface for the packet)
280 for hash-based lookups is done by the  get_ipv4_dst_port() or get_ipv6_dst_port() function.
281 The 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
306 The get_ipv6_dst_port() function is similar to the get_ipv4_dst_port() function.
307
308 The simple_ipv4_fwd_4pkts() and simple_ipv6_fwd_4pkts() function are optimized for continuous 4 valid ipv4 and ipv6 packets,
309 they leverage the multiple buffer optimization to boost the performance of forwarding packets with the exact match on hash table.
310 The 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
341 The simple_ipv6_fwd_4pkts() function is similar to the simple_ipv4_fwd_4pkts() function.
342
343 Known issue: IP packets with extensions or IP packets which are not TCP/UDP cannot work well at this mode.
344
345 Packet Forwarding for LPM-based Lookups
346 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
347
348 For each input packet, the packet forwarding operation is done by the l3fwd_simple_forward() function,
349 but the packet forwarding decision (that is, the identification of the output interface for the packet)
350 for 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     }