]>
git.proxmox.com Git - ceph.git/blob - ceph/src/seastar/dpdk/test/test/packet_burst_generator.c
4 * Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * * Neither the name of Intel Corporation nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 #include <rte_byteorder.h>
37 #include "packet_burst_generator.h"
39 #define UDP_SRC_PORT 1024
40 #define UDP_DST_PORT 1024
43 #define IP_DEFTTL 64 /* from RFC 1340. */
44 #define IP_VERSION 0x40
45 #define IP_HDRLEN 0x05 /* default IP header length == five 32-bits words. */
46 #define IP_VHL_DEF (IP_VERSION | IP_HDRLEN)
49 copy_buf_to_pkt_segs(void *buf
, unsigned len
, struct rte_mbuf
*pkt
,
57 while (offset
>= seg
->data_len
) {
58 offset
-= seg
->data_len
;
61 copy_len
= seg
->data_len
- offset
;
62 seg_buf
= rte_pktmbuf_mtod_offset(seg
, char *, offset
);
63 while (len
> copy_len
) {
64 rte_memcpy(seg_buf
, buf
, (size_t) copy_len
);
66 buf
= ((char *) buf
+ copy_len
);
68 seg_buf
= rte_pktmbuf_mtod(seg
, void *);
70 rte_memcpy(seg_buf
, buf
, (size_t) len
);
74 copy_buf_to_pkt(void *buf
, unsigned len
, struct rte_mbuf
*pkt
, unsigned offset
)
76 if (offset
+ len
<= pkt
->data_len
) {
77 rte_memcpy(rte_pktmbuf_mtod_offset(pkt
, char *, offset
), buf
,
81 copy_buf_to_pkt_segs(buf
, len
, pkt
, offset
);
85 initialize_eth_header(struct ether_hdr
*eth_hdr
, struct ether_addr
*src_mac
,
86 struct ether_addr
*dst_mac
, uint16_t ether_type
,
87 uint8_t vlan_enabled
, uint16_t van_id
)
89 ether_addr_copy(dst_mac
, ð_hdr
->d_addr
);
90 ether_addr_copy(src_mac
, ð_hdr
->s_addr
);
93 struct vlan_hdr
*vhdr
= (struct vlan_hdr
*)((uint8_t *)eth_hdr
+
94 sizeof(struct ether_hdr
));
96 eth_hdr
->ether_type
= rte_cpu_to_be_16(ETHER_TYPE_VLAN
);
98 vhdr
->eth_proto
= rte_cpu_to_be_16(ether_type
);
99 vhdr
->vlan_tci
= van_id
;
101 eth_hdr
->ether_type
= rte_cpu_to_be_16(ether_type
);
106 initialize_arp_header(struct arp_hdr
*arp_hdr
, struct ether_addr
*src_mac
,
107 struct ether_addr
*dst_mac
, uint32_t src_ip
, uint32_t dst_ip
,
110 arp_hdr
->arp_hrd
= rte_cpu_to_be_16(ARP_HRD_ETHER
);
111 arp_hdr
->arp_pro
= rte_cpu_to_be_16(ETHER_TYPE_IPv4
);
112 arp_hdr
->arp_hln
= ETHER_ADDR_LEN
;
113 arp_hdr
->arp_pln
= sizeof(uint32_t);
114 arp_hdr
->arp_op
= rte_cpu_to_be_16(opcode
);
115 ether_addr_copy(src_mac
, &arp_hdr
->arp_data
.arp_sha
);
116 arp_hdr
->arp_data
.arp_sip
= src_ip
;
117 ether_addr_copy(dst_mac
, &arp_hdr
->arp_data
.arp_tha
);
118 arp_hdr
->arp_data
.arp_tip
= dst_ip
;
122 initialize_udp_header(struct udp_hdr
*udp_hdr
, uint16_t src_port
,
123 uint16_t dst_port
, uint16_t pkt_data_len
)
127 pkt_len
= (uint16_t) (pkt_data_len
+ sizeof(struct udp_hdr
));
129 udp_hdr
->src_port
= rte_cpu_to_be_16(src_port
);
130 udp_hdr
->dst_port
= rte_cpu_to_be_16(dst_port
);
131 udp_hdr
->dgram_len
= rte_cpu_to_be_16(pkt_len
);
132 udp_hdr
->dgram_cksum
= 0; /* No UDP checksum. */
139 initialize_ipv6_header(struct ipv6_hdr
*ip_hdr
, uint8_t *src_addr
,
140 uint8_t *dst_addr
, uint16_t pkt_data_len
)
142 ip_hdr
->vtc_flow
= 0;
143 ip_hdr
->payload_len
= pkt_data_len
;
144 ip_hdr
->proto
= IPPROTO_UDP
;
145 ip_hdr
->hop_limits
= IP_DEFTTL
;
147 rte_memcpy(ip_hdr
->src_addr
, src_addr
, sizeof(ip_hdr
->src_addr
));
148 rte_memcpy(ip_hdr
->dst_addr
, dst_addr
, sizeof(ip_hdr
->dst_addr
));
150 return (uint16_t) (pkt_data_len
+ sizeof(struct ipv6_hdr
));
154 initialize_ipv4_header(struct ipv4_hdr
*ip_hdr
, uint32_t src_addr
,
155 uint32_t dst_addr
, uint16_t pkt_data_len
)
158 unaligned_uint16_t
*ptr16
;
162 * Initialize IP header.
164 pkt_len
= (uint16_t) (pkt_data_len
+ sizeof(struct ipv4_hdr
));
166 ip_hdr
->version_ihl
= IP_VHL_DEF
;
167 ip_hdr
->type_of_service
= 0;
168 ip_hdr
->fragment_offset
= 0;
169 ip_hdr
->time_to_live
= IP_DEFTTL
;
170 ip_hdr
->next_proto_id
= IPPROTO_UDP
;
171 ip_hdr
->packet_id
= 0;
172 ip_hdr
->total_length
= rte_cpu_to_be_16(pkt_len
);
173 ip_hdr
->src_addr
= rte_cpu_to_be_32(src_addr
);
174 ip_hdr
->dst_addr
= rte_cpu_to_be_32(dst_addr
);
177 * Compute IP header checksum.
179 ptr16
= (unaligned_uint16_t
*)ip_hdr
;
181 ip_cksum
+= ptr16
[0]; ip_cksum
+= ptr16
[1];
182 ip_cksum
+= ptr16
[2]; ip_cksum
+= ptr16
[3];
183 ip_cksum
+= ptr16
[4];
184 ip_cksum
+= ptr16
[6]; ip_cksum
+= ptr16
[7];
185 ip_cksum
+= ptr16
[8]; ip_cksum
+= ptr16
[9];
188 * Reduce 32 bit checksum to 16 bits and complement it.
190 ip_cksum
= ((ip_cksum
& 0xFFFF0000) >> 16) +
191 (ip_cksum
& 0x0000FFFF);
193 ip_cksum
= (~ip_cksum
) & 0x0000FFFF;
196 ip_hdr
->hdr_checksum
= (uint16_t) ip_cksum
;
204 * The maximum number of segments per packet is used when creating
205 * scattered transmit packets composed of a list of mbufs.
207 #define RTE_MAX_SEGS_PER_PKT 255 /**< pkt.nb_segs is a 8-bit unsigned char. */
211 generate_packet_burst(struct rte_mempool
*mp
, struct rte_mbuf
**pkts_burst
,
212 struct ether_hdr
*eth_hdr
, uint8_t vlan_enabled
, void *ip_hdr
,
213 uint8_t ipv4
, struct udp_hdr
*udp_hdr
, int nb_pkt_per_burst
,
214 uint8_t pkt_len
, uint8_t nb_pkt_segs
)
219 struct rte_mbuf
*pkt_seg
;
220 struct rte_mbuf
*pkt
;
222 for (nb_pkt
= 0; nb_pkt
< nb_pkt_per_burst
; nb_pkt
++) {
223 pkt
= rte_pktmbuf_alloc(mp
);
231 pkt
->data_len
= pkt_len
;
233 for (i
= 1; i
< nb_pkt_segs
; i
++) {
234 pkt_seg
->next
= rte_pktmbuf_alloc(mp
);
235 if (pkt_seg
->next
== NULL
) {
237 rte_pktmbuf_free(pkt
);
240 pkt_seg
= pkt_seg
->next
;
241 pkt_seg
->data_len
= pkt_len
;
243 pkt_seg
->next
= NULL
; /* Last segment of packet. */
246 * Copy headers in first packet segment(s).
249 eth_hdr_size
= sizeof(struct ether_hdr
) + sizeof(struct vlan_hdr
);
251 eth_hdr_size
= sizeof(struct ether_hdr
);
253 copy_buf_to_pkt(eth_hdr
, eth_hdr_size
, pkt
, 0);
256 copy_buf_to_pkt(ip_hdr
, sizeof(struct ipv4_hdr
), pkt
, eth_hdr_size
);
257 copy_buf_to_pkt(udp_hdr
, sizeof(*udp_hdr
), pkt
, eth_hdr_size
+
258 sizeof(struct ipv4_hdr
));
260 copy_buf_to_pkt(ip_hdr
, sizeof(struct ipv6_hdr
), pkt
, eth_hdr_size
);
261 copy_buf_to_pkt(udp_hdr
, sizeof(*udp_hdr
), pkt
, eth_hdr_size
+
262 sizeof(struct ipv6_hdr
));
266 * Complete first mbuf of packet and append it to the
267 * burst of packets to be transmitted.
269 pkt
->nb_segs
= nb_pkt_segs
;
270 pkt
->pkt_len
= pkt_len
;
271 pkt
->l2_len
= eth_hdr_size
;
274 pkt
->vlan_tci
= ETHER_TYPE_IPv4
;
275 pkt
->l3_len
= sizeof(struct ipv4_hdr
);
277 pkt
->vlan_tci
= ETHER_TYPE_IPv6
;
278 pkt
->l3_len
= sizeof(struct ipv6_hdr
);
281 pkts_burst
[nb_pkt
] = pkt
;