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