d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

net: rename Ethernet header fields

Browse Source 
Definition of `rte_ether_addr` structure used a workaround allowing DPDK
and Windows SDK headers to be used in the same file, because Windows SDK
defines `s_addr` as a macro. Rename `s_addr` to `src_addr` and `d_addr`
to `dst_addr` to avoid the conflict and remove the workaround.
Deprecation notice:
https://mails.dpdk.org/archives/dev/2021-July/215270.html

Signed-off-by: Dmitry Kozlyuk <dmitry.kozliuk@gmail.com>
This commit is contained in:
Dmitry Kozlyuk 2021-10-08 01:07:49 +03:00 committed by Thomas Monjalon
parent 6be6690127
commit 04d43857ea
56 changed files with 234 additions and 245 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
app/test-pmd/5tswap.c
View File

@ -27,9 +27,9 @@ swap_mac(struct rte_ether_hdr *eth_hdr)
struct rte_ether_addr addr; struct rte_ether_addr addr;
/* Swap dest and src mac addresses. */ /* Swap dest and src mac addresses. */
rte_ether_addr_copy(&eth_hdr->d_addr, &addr); rte_ether_addr_copy(&eth_hdr->dst_addr, &addr);
rte_ether_addr_copy(&eth_hdr->s_addr, &eth_hdr->d_addr); rte_ether_addr_copy(&eth_hdr->src_addr, &eth_hdr->dst_addr);
rte_ether_addr_copy(&addr, &eth_hdr->s_addr); rte_ether_addr_copy(&addr, &eth_hdr->src_addr);
} }
static inline void static inline void

4
app/test-pmd/csumonly.c
View File

@ -873,9 +873,9 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *); eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
rte_ether_addr_copy(&peer_eth_addrs[fs->peer_addr], rte_ether_addr_copy(&peer_eth_addrs[fs->peer_addr],
&eth_hdr->d_addr); &eth_hdr->dst_addr);
rte_ether_addr_copy(&ports[fs->tx_port].eth_addr, rte_ether_addr_copy(&ports[fs->tx_port].eth_addr,
&eth_hdr->s_addr); &eth_hdr->src_addr);
parse_ethernet(eth_hdr, &info); parse_ethernet(eth_hdr, &info);
l3_hdr = (char *)eth_hdr + info.l2_len; l3_hdr = (char *)eth_hdr + info.l2_len;

4
app/test-pmd/flowgen.c
View File

@ -122,8 +122,8 @@ pkt_burst_flow_gen(struct fwd_stream *fs)
/* Initialize Ethernet header. */ /* Initialize Ethernet header. */
eth_hdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *); eth_hdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
rte_ether_addr_copy(&cfg_ether_dst, &eth_hdr->d_addr); rte_ether_addr_copy(&cfg_ether_dst, &eth_hdr->dst_addr);
rte_ether_addr_copy(&cfg_ether_src, &eth_hdr->s_addr); rte_ether_addr_copy(&cfg_ether_src, &eth_hdr->src_addr);
eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
/* Initialize IP header. */ /* Initialize IP header. */

16
app/test-pmd/icmpecho.c
View File

@ -319,8 +319,8 @@ reply_to_icmp_echo_rqsts(struct fwd_stream *fs)
if (verbose_level > 0) { if (verbose_level > 0) {
printf("\nPort %d pkt-len=%u nb-segs=%u\n", printf("\nPort %d pkt-len=%u nb-segs=%u\n",
fs->rx_port, pkt->pkt_len, pkt->nb_segs); fs->rx_port, pkt->pkt_len, pkt->nb_segs);
ether_addr_dump(" ETH: src=", &eth_h->s_addr); ether_addr_dump(" ETH: src=", &eth_h->src_addr);
ether_addr_dump(" dst=", &eth_h->d_addr); ether_addr_dump(" dst=", &eth_h->dst_addr);
} }
if (eth_type == RTE_ETHER_TYPE_VLAN) { if (eth_type == RTE_ETHER_TYPE_VLAN) {
vlan_h = (struct rte_vlan_hdr *) vlan_h = (struct rte_vlan_hdr *)
@ -385,17 +385,17 @@ reply_to_icmp_echo_rqsts(struct fwd_stream *fs)
*/ */
/* Use source MAC address as destination MAC address. */ /* Use source MAC address as destination MAC address. */
rte_ether_addr_copy(&eth_h->s_addr, &eth_h->d_addr); rte_ether_addr_copy(&eth_h->src_addr, &eth_h->dst_addr);
/* Set source MAC address with MAC address of TX port */ /* Set source MAC address with MAC address of TX port */
rte_ether_addr_copy(&ports[fs->tx_port].eth_addr, rte_ether_addr_copy(&ports[fs->tx_port].eth_addr,
&eth_h->s_addr); &eth_h->src_addr);
arp_h->arp_opcode = rte_cpu_to_be_16(RTE_ARP_OP_REPLY); arp_h->arp_opcode = rte_cpu_to_be_16(RTE_ARP_OP_REPLY);
rte_ether_addr_copy(&arp_h->arp_data.arp_tha, rte_ether_addr_copy(&arp_h->arp_data.arp_tha,
&eth_addr); &eth_addr);
rte_ether_addr_copy(&arp_h->arp_data.arp_sha, rte_ether_addr_copy(&arp_h->arp_data.arp_sha,
&arp_h->arp_data.arp_tha); &arp_h->arp_data.arp_tha);
rte_ether_addr_copy(&eth_h->s_addr, rte_ether_addr_copy(&eth_h->src_addr,
&arp_h->arp_data.arp_sha); &arp_h->arp_data.arp_sha);
/* Swap IP addresses in ARP payload */ /* Swap IP addresses in ARP payload */
@ -453,9 +453,9 @@ reply_to_icmp_echo_rqsts(struct fwd_stream *fs)
* ICMP checksum is computed by assuming it is valid in the * ICMP checksum is computed by assuming it is valid in the
* echo request and not verified. * echo request and not verified.
*/ */
rte_ether_addr_copy(&eth_h->s_addr, &eth_addr); rte_ether_addr_copy(&eth_h->src_addr, &eth_addr);
rte_ether_addr_copy(&eth_h->d_addr, &eth_h->s_addr); rte_ether_addr_copy(&eth_h->dst_addr, &eth_h->src_addr);
rte_ether_addr_copy(&eth_addr, &eth_h->d_addr); rte_ether_addr_copy(&eth_addr, &eth_h->dst_addr);
ip_addr = ip_h->src_addr; ip_addr = ip_h->src_addr;
if (is_multicast_ipv4_addr(ip_h->dst_addr)) { if (is_multicast_ipv4_addr(ip_h->dst_addr)) {
uint32_t ip_src; uint32_t ip_src;

6
app/test-pmd/ieee1588fwd.c
View File

@ -178,9 +178,9 @@ ieee1588_packet_fwd(struct fwd_stream *fs)
port_ieee1588_rx_timestamp_check(fs->rx_port, timesync_index); port_ieee1588_rx_timestamp_check(fs->rx_port, timesync_index);
/* Swap dest and src mac addresses. */ /* Swap dest and src mac addresses. */
rte_ether_addr_copy(&eth_hdr->d_addr, &addr); rte_ether_addr_copy(&eth_hdr->dst_addr, &addr);
rte_ether_addr_copy(&eth_hdr->s_addr, &eth_hdr->d_addr); rte_ether_addr_copy(&eth_hdr->src_addr, &eth_hdr->dst_addr);
rte_ether_addr_copy(&addr, &eth_hdr->s_addr); rte_ether_addr_copy(&addr, &eth_hdr->src_addr);
/* Forward PTP packet with hardware TX timestamp */ /* Forward PTP packet with hardware TX timestamp */
mb->ol_flags |= PKT_TX_IEEE1588_TMST; mb->ol_flags |= PKT_TX_IEEE1588_TMST;

4
app/test-pmd/macfwd.c
View File

@ -85,9 +85,9 @@ pkt_burst_mac_forward(struct fwd_stream *fs)
mb = pkts_burst[i]; mb = pkts_burst[i];
eth_hdr = rte_pktmbuf_mtod(mb, struct rte_ether_hdr *); eth_hdr = rte_pktmbuf_mtod(mb, struct rte_ether_hdr *);
rte_ether_addr_copy(&peer_eth_addrs[fs->peer_addr], rte_ether_addr_copy(&peer_eth_addrs[fs->peer_addr],
&eth_hdr->d_addr); &eth_hdr->dst_addr);
rte_ether_addr_copy(&ports[fs->tx_port].eth_addr, rte_ether_addr_copy(&ports[fs->tx_port].eth_addr,
&eth_hdr->s_addr); &eth_hdr->src_addr);
mb->ol_flags &= IND_ATTACHED_MBUF | EXT_ATTACHED_MBUF; mb->ol_flags &= IND_ATTACHED_MBUF | EXT_ATTACHED_MBUF;
mb->ol_flags |= ol_flags; mb->ol_flags |= ol_flags;
mb->l2_len = sizeof(struct rte_ether_hdr); mb->l2_len = sizeof(struct rte_ether_hdr);

6
app/test-pmd/macswap.h
View File

@ -29,9 +29,9 @@ do_macswap(struct rte_mbuf *pkts[], uint16_t nb,
eth_hdr = rte_pktmbuf_mtod(mb, struct rte_ether_hdr *); eth_hdr = rte_pktmbuf_mtod(mb, struct rte_ether_hdr *);
/* Swap dest and src mac addresses. */ /* Swap dest and src mac addresses. */
rte_ether_addr_copy(&eth_hdr->d_addr, &addr); rte_ether_addr_copy(&eth_hdr->dst_addr, &addr);
rte_ether_addr_copy(&eth_hdr->s_addr, &eth_hdr->d_addr); rte_ether_addr_copy(&eth_hdr->src_addr, &eth_hdr->dst_addr);
rte_ether_addr_copy(&addr, &eth_hdr->s_addr); rte_ether_addr_copy(&addr, &eth_hdr->src_addr);
mbuf_field_set(mb, ol_flags); mbuf_field_set(mb, ol_flags);
} }

4
app/test-pmd/txonly.c
View File

@ -362,8 +362,8 @@ pkt_burst_transmit(struct fwd_stream *fs)
/* /*
* Initialize Ethernet header. * Initialize Ethernet header.
*/ */
rte_ether_addr_copy(&peer_eth_addrs[fs->peer_addr], &eth_hdr.d_addr); rte_ether_addr_copy(&peer_eth_addrs[fs->peer_addr], &eth_hdr.dst_addr);
rte_ether_addr_copy(&ports[fs->tx_port].eth_addr, &eth_hdr.s_addr); rte_ether_addr_copy(&ports[fs->tx_port].eth_addr, &eth_hdr.src_addr);
eth_hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); eth_hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
if (rte_mempool_get_bulk(mbp, (void **)pkts_burst, if (rte_mempool_get_bulk(mbp, (void **)pkts_burst,

4
app/test-pmd/util.c
View File

@ -142,9 +142,9 @@ dump_pkt_burst(uint16_t port_id, uint16_t queue, struct rte_mbuf *pkts[],
" - no miss group"); " - no miss group");
MKDUMPSTR(print_buf, buf_size, cur_len, "\n"); MKDUMPSTR(print_buf, buf_size, cur_len, "\n");
} }
print_ether_addr(" src=", &eth_hdr->s_addr, print_ether_addr(" src=", &eth_hdr->src_addr,
print_buf, buf_size, &cur_len); print_buf, buf_size, &cur_len);
print_ether_addr(" - dst=", &eth_hdr->d_addr, print_ether_addr(" - dst=", &eth_hdr->dst_addr,
print_buf, buf_size, &cur_len); print_buf, buf_size, &cur_len);
MKDUMPSTR(print_buf, buf_size, cur_len, MKDUMPSTR(print_buf, buf_size, cur_len,
" - type=0x%04x - length=%u - nb_segs=%d", " - type=0x%04x - length=%u - nb_segs=%d",

4
app/test/packet_burst_generator.c
View File

@ -56,8 +56,8 @@ initialize_eth_header(struct rte_ether_hdr *eth_hdr,
struct rte_ether_addr *dst_mac, uint16_t ether_type, struct rte_ether_addr *dst_mac, uint16_t ether_type,
uint8_t vlan_enabled, uint16_t van_id) uint8_t vlan_enabled, uint16_t van_id)
{ {
rte_ether_addr_copy(dst_mac, &eth_hdr->d_addr); rte_ether_addr_copy(dst_mac, &eth_hdr->dst_addr);
rte_ether_addr_copy(src_mac, &eth_hdr->s_addr); rte_ether_addr_copy(src_mac, &eth_hdr->src_addr);
if (vlan_enabled) { if (vlan_enabled) {
struct rte_vlan_hdr *vhdr = (struct rte_vlan_hdr *)( struct rte_vlan_hdr *vhdr = (struct rte_vlan_hdr *)(

4
app/test/test_bpf.c
View File

@ -1008,9 +1008,9 @@ test_jump2_prepare(void *arg)
* Initialize ether header. * Initialize ether header.
*/ */
rte_ether_addr_copy((struct rte_ether_addr *)dst_mac, rte_ether_addr_copy((struct rte_ether_addr *)dst_mac,
&dn->eth_hdr.d_addr); &dn->eth_hdr.dst_addr);
rte_ether_addr_copy((struct rte_ether_addr *)src_mac, rte_ether_addr_copy((struct rte_ether_addr *)src_mac,
&dn->eth_hdr.s_addr); &dn->eth_hdr.src_addr);
dn->eth_hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN); dn->eth_hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
/* /*

15
app/test/test_link_bonding_mode4.c
View File

@ -502,8 +502,8 @@ make_lacp_reply(struct slave_conf *slave, struct rte_mbuf *pkt)
slow_hdr = rte_pktmbuf_mtod(pkt, struct slow_protocol_frame *); slow_hdr = rte_pktmbuf_mtod(pkt, struct slow_protocol_frame *);
/* Change source address to partner address */ /* Change source address to partner address */
rte_ether_addr_copy(&parnter_mac_default, &slow_hdr->eth_hdr.s_addr); rte_ether_addr_copy(&parnter_mac_default, &slow_hdr->eth_hdr.src_addr);
slow_hdr->eth_hdr.s_addr.addr_bytes[RTE_ETHER_ADDR_LEN - 1] = slow_hdr->eth_hdr.src_addr.addr_bytes[RTE_ETHER_ADDR_LEN - 1] =
slave->port_id; slave->port_id;
lacp = (struct lacpdu *) &slow_hdr->slow_protocol; lacp = (struct lacpdu *) &slow_hdr->slow_protocol;
@ -870,7 +870,7 @@ test_mode4_rx(void)
for (i = 0; i < expected_pkts_cnt; i++) { for (i = 0; i < expected_pkts_cnt; i++) {
hdr = rte_pktmbuf_mtod(pkts[i], struct rte_ether_hdr *); hdr = rte_pktmbuf_mtod(pkts[i], struct rte_ether_hdr *);
cnt[rte_is_same_ether_addr(&hdr->d_addr, cnt[rte_is_same_ether_addr(&hdr->dst_addr,
&bonded_mac)]++; &bonded_mac)]++;
} }
@ -918,7 +918,7 @@ test_mode4_rx(void)
for (i = 0; i < expected_pkts_cnt; i++) { for (i = 0; i < expected_pkts_cnt; i++) {
hdr = rte_pktmbuf_mtod(pkts[i], struct rte_ether_hdr *); hdr = rte_pktmbuf_mtod(pkts[i], struct rte_ether_hdr *);
eq_cnt += rte_is_same_ether_addr(&hdr->d_addr, eq_cnt += rte_is_same_ether_addr(&hdr->dst_addr,
&bonded_mac); &bonded_mac);
} }
@ -1163,11 +1163,12 @@ init_marker(struct rte_mbuf *pkt, struct slave_conf *slave)
/* Copy multicast destination address */ /* Copy multicast destination address */
rte_ether_addr_copy(&slow_protocol_mac_addr, rte_ether_addr_copy(&slow_protocol_mac_addr,
&marker_hdr->eth_hdr.d_addr); &marker_hdr->eth_hdr.dst_addr);
/* Init source address */ /* Init source address */
rte_ether_addr_copy(&parnter_mac_default, &marker_hdr->eth_hdr.s_addr); rte_ether_addr_copy(&parnter_mac_default,
marker_hdr->eth_hdr.s_addr.addr_bytes[RTE_ETHER_ADDR_LEN - 1] = &marker_hdr->eth_hdr.src_addr);
marker_hdr->eth_hdr.src_addr.addr_bytes[RTE_ETHER_ADDR_LEN - 1] =
slave->port_id; slave->port_id;
marker_hdr->eth_hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_SLOW); marker_hdr->eth_hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_SLOW);

3
doc/guides/rel_notes/deprecation.rst
View File

@ -164,9 +164,6 @@ Deprecation Notices
consistent with existing outer header checksum status flag naming, which consistent with existing outer header checksum status flag naming, which
should help in reducing confusion about its usage. should help in reducing confusion about its usage.
* net: ``s_addr`` and ``d_addr`` fields of ``rte_ether_hdr`` structure
will be renamed in DPDK 21.11 to avoid conflict with Windows Sockets headers.
* net: The structure ``rte_ipv4_hdr`` will have two unions. * net: The structure ``rte_ipv4_hdr`` will have two unions.
The first union is for existing ``version_ihl`` byte The first union is for existing ``version_ihl`` byte
and new bitfield for version and IHL. and new bitfield for version and IHL.

3
doc/guides/rel_notes/release_21_11.rst
View File

@ -178,6 +178,9 @@ API Changes
removed. Its usages have been replaced by a new function removed. Its usages have been replaced by a new function
``rte_kvargs_get_with_value()``. ``rte_kvargs_get_with_value()``.
* net: Renamed ``s_addr`` and ``d_addr`` fields of ``rte_ether_hdr`` structure
to ``src_addr`` and ``dst_addr``, respectively.
* cryptodev: The API rte_cryptodev_pmd_is_valid_dev is modified to * cryptodev: The API rte_cryptodev_pmd_is_valid_dev is modified to
rte_cryptodev_is_valid_dev as it can be used by the application as rte_cryptodev_is_valid_dev as it can be used by the application as
well as PMD to check whether the device is valid or not. well as PMD to check whether the device is valid or not.

6
drivers/net/avp/avp_ethdev.c
View File

@ -1205,17 +1205,17 @@ _avp_mac_filter(struct avp_dev *avp, struct rte_mbuf *m)
{ {
struct rte_ether_hdr *eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *); struct rte_ether_hdr *eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
if (likely(_avp_cmp_ether_addr(&avp->ethaddr, &eth->d_addr) == 0)) { if (likely(_avp_cmp_ether_addr(&avp->ethaddr, &eth->dst_addr) == 0)) {
/* allow all packets destined to our address */ /* allow all packets destined to our address */
return 0; return 0;
} }
if (likely(rte_is_broadcast_ether_addr(&eth->d_addr))) { if (likely(rte_is_broadcast_ether_addr(&eth->dst_addr))) {
/* allow all broadcast packets */ /* allow all broadcast packets */
return 0; return 0;
} }
if (likely(rte_is_multicast_ether_addr(&eth->d_addr))) { if (likely(rte_is_multicast_ether_addr(&eth->dst_addr))) {
/* allow all multicast packets */ /* allow all multicast packets */
return 0; return 0;
} }

16
drivers/net/bnx2x/bnx2x.c
View File

@ -2233,8 +2233,8 @@ int bnx2x_tx_encap(struct bnx2x_tx_queue *txq, struct rte_mbuf *m0)
tx_parse_bd = tx_parse_bd =
&txq->tx_ring[TX_BD(bd_prod, txq)].parse_bd_e2; &txq->tx_ring[TX_BD(bd_prod, txq)].parse_bd_e2;
if (rte_is_multicast_ether_addr(&eh->d_addr)) { if (rte_is_multicast_ether_addr(&eh->dst_addr)) {
if (rte_is_broadcast_ether_addr(&eh->d_addr)) if (rte_is_broadcast_ether_addr(&eh->dst_addr))
mac_type = BROADCAST_ADDRESS; mac_type = BROADCAST_ADDRESS;
else else
mac_type = MULTICAST_ADDRESS; mac_type = MULTICAST_ADDRESS;
@ -2243,17 +2243,17 @@ int bnx2x_tx_encap(struct bnx2x_tx_queue *txq, struct rte_mbuf *m0)
(mac_type << ETH_TX_PARSE_BD_E2_ETH_ADDR_TYPE_SHIFT); (mac_type << ETH_TX_PARSE_BD_E2_ETH_ADDR_TYPE_SHIFT);
rte_memcpy(&tx_parse_bd->data.mac_addr.dst_hi, rte_memcpy(&tx_parse_bd->data.mac_addr.dst_hi,
&eh->d_addr.addr_bytes[0], 2); &eh->dst_addr.addr_bytes[0], 2);
rte_memcpy(&tx_parse_bd->data.mac_addr.dst_mid, rte_memcpy(&tx_parse_bd->data.mac_addr.dst_mid,
&eh->d_addr.addr_bytes[2], 2); &eh->dst_addr.addr_bytes[2], 2);
rte_memcpy(&tx_parse_bd->data.mac_addr.dst_lo, rte_memcpy(&tx_parse_bd->data.mac_addr.dst_lo,
&eh->d_addr.addr_bytes[4], 2); &eh->dst_addr.addr_bytes[4], 2);
rte_memcpy(&tx_parse_bd->data.mac_addr.src_hi, rte_memcpy(&tx_parse_bd->data.mac_addr.src_hi,
&eh->s_addr.addr_bytes[0], 2); &eh->src_addr.addr_bytes[0], 2);
rte_memcpy(&tx_parse_bd->data.mac_addr.src_mid, rte_memcpy(&tx_parse_bd->data.mac_addr.src_mid,
&eh->s_addr.addr_bytes[2], 2); &eh->src_addr.addr_bytes[2], 2);
rte_memcpy(&tx_parse_bd->data.mac_addr.src_lo, rte_memcpy(&tx_parse_bd->data.mac_addr.src_lo,
&eh->s_addr.addr_bytes[4], 2); &eh->src_addr.addr_bytes[4], 2);
tx_parse_bd->data.mac_addr.dst_hi = tx_parse_bd->data.mac_addr.dst_hi =
rte_cpu_to_be_16(tx_parse_bd->data.mac_addr.dst_hi); rte_cpu_to_be_16(tx_parse_bd->data.mac_addr.dst_hi);

6
drivers/net/bonding/rte_eth_bond_8023ad.c
View File

@ -587,8 +587,8 @@ tx_machine(struct bond_dev_private *internals, uint16_t slave_id)
hdr = rte_pktmbuf_mtod(lacp_pkt, struct lacpdu_header *); hdr = rte_pktmbuf_mtod(lacp_pkt, struct lacpdu_header *);
/* Source and destination MAC */ /* Source and destination MAC */
rte_ether_addr_copy(&lacp_mac_addr, &hdr->eth_hdr.d_addr); rte_ether_addr_copy(&lacp_mac_addr, &hdr->eth_hdr.dst_addr);
rte_eth_macaddr_get(slave_id, &hdr->eth_hdr.s_addr); rte_eth_macaddr_get(slave_id, &hdr->eth_hdr.src_addr);
hdr->eth_hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_SLOW); hdr->eth_hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_SLOW);
lacpdu = &hdr->lacpdu; lacpdu = &hdr->lacpdu;
@ -1346,7 +1346,7 @@ bond_mode_8023ad_handle_slow_pkt(struct bond_dev_private *internals,
} while (unlikely(retval == 0)); } while (unlikely(retval == 0));
m_hdr->marker.tlv_type_marker = MARKER_TLV_TYPE_RESP; m_hdr->marker.tlv_type_marker = MARKER_TLV_TYPE_RESP;
rte_eth_macaddr_get(slave_id, &m_hdr->eth_hdr.s_addr); rte_eth_macaddr_get(slave_id, &m_hdr->eth_hdr.src_addr);
if (internals->mode4.dedicated_queues.enabled == 0) { if (internals->mode4.dedicated_queues.enabled == 0) {
if (rte_ring_enqueue(port->tx_ring, pkt) != 0) { if (rte_ring_enqueue(port->tx_ring, pkt) != 0) {

4
drivers/net/bonding/rte_eth_bond_alb.c
View File

@ -213,8 +213,8 @@ bond_mode_alb_arp_upd(struct client_data *client_info,
rte_spinlock_lock(&internals->mode6.lock); rte_spinlock_lock(&internals->mode6.lock);
eth_h = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *); eth_h = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
rte_ether_addr_copy(&client_info->app_mac, &eth_h->s_addr); rte_ether_addr_copy(&client_info->app_mac, &eth_h->src_addr);
rte_ether_addr_copy(&client_info->cli_mac, &eth_h->d_addr); rte_ether_addr_copy(&client_info->cli_mac, &eth_h->dst_addr);
if (client_info->vlan_count > 0) if (client_info->vlan_count > 0)
eth_h->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN); eth_h->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
else else

20
drivers/net/bonding/rte_eth_bond_pmd.c
View File

@ -342,11 +342,11 @@ rx_burst_8023ad(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts,
bufs[j])) || bufs[j])) ||
!collecting || !collecting ||
(!promisc && (!promisc &&
((rte_is_unicast_ether_addr(&hdr->d_addr) && ((rte_is_unicast_ether_addr(&hdr->dst_addr) &&
!rte_is_same_ether_addr(bond_mac, !rte_is_same_ether_addr(bond_mac,
&hdr->d_addr)) || &hdr->dst_addr)) ||
(!allmulti && (!allmulti &&
rte_is_multicast_ether_addr(&hdr->d_addr)))))) { rte_is_multicast_ether_addr(&hdr->dst_addr)))))) {
if (hdr->ether_type == ether_type_slow_be) { if (hdr->ether_type == ether_type_slow_be) {
bond_mode_8023ad_handle_slow_pkt( bond_mode_8023ad_handle_slow_pkt(
@ -477,9 +477,9 @@ update_client_stats(uint32_t addr, uint16_t port, uint32_t *TXorRXindicator)
"DstMAC:" RTE_ETHER_ADDR_PRT_FMT " DstIP:%s %s %d\n", \ "DstMAC:" RTE_ETHER_ADDR_PRT_FMT " DstIP:%s %s %d\n", \
info, \ info, \
port, \ port, \
RTE_ETHER_ADDR_BYTES(&eth_h->s_addr), \ RTE_ETHER_ADDR_BYTES(&eth_h->src_addr), \
src_ip, \ src_ip, \
RTE_ETHER_ADDR_BYTES(&eth_h->d_addr), \ RTE_ETHER_ADDR_BYTES(&eth_h->dst_addr), \
dst_ip, \ dst_ip, \
arp_op, ++burstnumber) arp_op, ++burstnumber)
#endif #endif
@ -643,9 +643,9 @@ static inline uint16_t
ether_hash(struct rte_ether_hdr *eth_hdr) ether_hash(struct rte_ether_hdr *eth_hdr)
{ {
unaligned_uint16_t *word_src_addr = unaligned_uint16_t *word_src_addr =
(unaligned_uint16_t *)eth_hdr->s_addr.addr_bytes; (unaligned_uint16_t *)eth_hdr->src_addr.addr_bytes;
unaligned_uint16_t *word_dst_addr = unaligned_uint16_t *word_dst_addr =
(unaligned_uint16_t *)eth_hdr->d_addr.addr_bytes; (unaligned_uint16_t *)eth_hdr->dst_addr.addr_bytes;
return (word_src_addr[0] ^ word_dst_addr[0]) ^ return (word_src_addr[0] ^ word_dst_addr[0]) ^
(word_src_addr[1] ^ word_dst_addr[1]) ^ (word_src_addr[1] ^ word_dst_addr[1]) ^
@ -942,10 +942,10 @@ bond_ethdev_tx_burst_tlb(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
ether_hdr = rte_pktmbuf_mtod(bufs[j], ether_hdr = rte_pktmbuf_mtod(bufs[j],
struct rte_ether_hdr *); struct rte_ether_hdr *);
if (rte_is_same_ether_addr(&ether_hdr->s_addr, if (rte_is_same_ether_addr(&ether_hdr->src_addr,
&primary_slave_addr)) &primary_slave_addr))
rte_ether_addr_copy(&active_slave_addr, rte_ether_addr_copy(&active_slave_addr,
&ether_hdr->s_addr); &ether_hdr->src_addr);
#if defined(RTE_LIBRTE_BOND_DEBUG_ALB) || defined(RTE_LIBRTE_BOND_DEBUG_ALB_L1) #if defined(RTE_LIBRTE_BOND_DEBUG_ALB) || defined(RTE_LIBRTE_BOND_DEBUG_ALB_L1)
mode6_debug("TX IPv4:", ether_hdr, slaves[i], &burstnumberTX); mode6_debug("TX IPv4:", ether_hdr, slaves[i], &burstnumberTX);
#endif #endif
@ -1017,7 +1017,7 @@ bond_ethdev_tx_burst_alb(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
slave_idx = bond_mode_alb_arp_xmit(eth_h, offset, internals); slave_idx = bond_mode_alb_arp_xmit(eth_h, offset, internals);
/* Change src mac in eth header */ /* Change src mac in eth header */
rte_eth_macaddr_get(slave_idx, &eth_h->s_addr); rte_eth_macaddr_get(slave_idx, &eth_h->src_addr);
/* Add packet to slave tx buffer */ /* Add packet to slave tx buffer */
slave_bufs[slave_idx][slave_bufs_pkts[slave_idx]] = bufs[i]; slave_bufs[slave_idx][slave_bufs_pkts[slave_idx]] = bufs[i];

8
drivers/net/enic/enic_flow.c
View File

@ -656,14 +656,14 @@ enic_copy_item_eth_v2(struct copy_item_args *arg)
if (!mask) if (!mask)
mask = &rte_flow_item_eth_mask; mask = &rte_flow_item_eth_mask;
memcpy(enic_spec.d_addr.addr_bytes, spec->dst.addr_bytes, memcpy(enic_spec.dst_addr.addr_bytes, spec->dst.addr_bytes,
RTE_ETHER_ADDR_LEN); RTE_ETHER_ADDR_LEN);
memcpy(enic_spec.s_addr.addr_bytes, spec->src.addr_bytes, memcpy(enic_spec.src_addr.addr_bytes, spec->src.addr_bytes,
RTE_ETHER_ADDR_LEN); RTE_ETHER_ADDR_LEN);
memcpy(enic_mask.d_addr.addr_bytes, mask->dst.addr_bytes, memcpy(enic_mask.dst_addr.addr_bytes, mask->dst.addr_bytes,
RTE_ETHER_ADDR_LEN); RTE_ETHER_ADDR_LEN);
memcpy(enic_mask.s_addr.addr_bytes, mask->src.addr_bytes, memcpy(enic_mask.src_addr.addr_bytes, mask->src.addr_bytes,
RTE_ETHER_ADDR_LEN); RTE_ETHER_ADDR_LEN);
enic_spec.ether_type = spec->type; enic_spec.ether_type = spec->type;
enic_mask.ether_type = mask->type; enic_mask.ether_type = mask->type;

4
drivers/net/mlx5/mlx5_txpp.c
View File

@ -333,8 +333,8 @@ mlx5_txpp_fill_wqe_clock_queue(struct mlx5_dev_ctx_shared *sh)
/* Build test packet L2 header (Ethernet). */ /* Build test packet L2 header (Ethernet). */
dst = (uint8_t *)&es->inline_data; dst = (uint8_t *)&es->inline_data;
eth_hdr = (struct rte_ether_hdr *)dst; eth_hdr = (struct rte_ether_hdr *)dst;
rte_eth_random_addr(&eth_hdr->d_addr.addr_bytes[0]); rte_eth_random_addr(&eth_hdr->dst_addr.addr_bytes[0]);
rte_eth_random_addr(&eth_hdr->s_addr.addr_bytes[0]); rte_eth_random_addr(&eth_hdr->src_addr.addr_bytes[0]);
eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
/* Build test packet L3 header (IP v4). */ /* Build test packet L3 header (IP v4). */
dst += sizeof(struct rte_ether_hdr); dst += sizeof(struct rte_ether_hdr);

20
examples/bond/main.c
View File

@ -358,7 +358,7 @@ struct global_flag_stru_t *global_flag_stru_p = &global_flag_stru;
static int lcore_main(__rte_unused void *arg1) static int lcore_main(__rte_unused void *arg1)
{ {
struct rte_mbuf *pkts[MAX_PKT_BURST] __rte_cache_aligned; struct rte_mbuf *pkts[MAX_PKT_BURST] __rte_cache_aligned;
struct rte_ether_addr d_addr; struct rte_ether_addr dst_addr;
struct rte_ether_addr bond_mac_addr; struct rte_ether_addr bond_mac_addr;
struct rte_ether_hdr *eth_hdr; struct rte_ether_hdr *eth_hdr;
@ -422,13 +422,13 @@ static int lcore_main(__rte_unused void *arg1)
if (arp_hdr->arp_opcode == rte_cpu_to_be_16(RTE_ARP_OP_REQUEST)) { if (arp_hdr->arp_opcode == rte_cpu_to_be_16(RTE_ARP_OP_REQUEST)) {
arp_hdr->arp_opcode = rte_cpu_to_be_16(RTE_ARP_OP_REPLY); arp_hdr->arp_opcode = rte_cpu_to_be_16(RTE_ARP_OP_REPLY);
/* Switch src and dst data and set bonding MAC */ /* Switch src and dst data and set bonding MAC */
rte_ether_addr_copy(&eth_hdr->s_addr, &eth_hdr->d_addr); rte_ether_addr_copy(&eth_hdr->src_addr, &eth_hdr->dst_addr);
rte_ether_addr_copy(&bond_mac_addr, &eth_hdr->s_addr); rte_ether_addr_copy(&bond_mac_addr, &eth_hdr->src_addr);
rte_ether_addr_copy(&arp_hdr->arp_data.arp_sha, rte_ether_addr_copy(&arp_hdr->arp_data.arp_sha,
&arp_hdr->arp_data.arp_tha); &arp_hdr->arp_data.arp_tha);
arp_hdr->arp_data.arp_tip = arp_hdr->arp_data.arp_sip; arp_hdr->arp_data.arp_tip = arp_hdr->arp_data.arp_sip;
rte_ether_addr_copy(&bond_mac_addr, &d_addr); rte_ether_addr_copy(&bond_mac_addr, &dst_addr);
rte_ether_addr_copy(&d_addr, &arp_hdr->arp_data.arp_sha); rte_ether_addr_copy(&dst_addr, &arp_hdr->arp_data.arp_sha);
arp_hdr->arp_data.arp_sip = bond_ip; arp_hdr->arp_data.arp_sip = bond_ip;
rte_eth_tx_burst(BOND_PORT, 0, &pkts[i], 1); rte_eth_tx_burst(BOND_PORT, 0, &pkts[i], 1);
is_free = 1; is_free = 1;
@ -443,8 +443,10 @@ static int lcore_main(__rte_unused void *arg1)
} }
ipv4_hdr = (struct rte_ipv4_hdr *)((char *)(eth_hdr + 1) + offset); ipv4_hdr = (struct rte_ipv4_hdr *)((char *)(eth_hdr + 1) + offset);
if (ipv4_hdr->dst_addr == bond_ip) { if (ipv4_hdr->dst_addr == bond_ip) {
rte_ether_addr_copy(&eth_hdr->s_addr, &eth_hdr->d_addr); rte_ether_addr_copy(&eth_hdr->src_addr,
rte_ether_addr_copy(&bond_mac_addr, &eth_hdr->s_addr); &eth_hdr->dst_addr);
rte_ether_addr_copy(&bond_mac_addr,
&eth_hdr->src_addr);
ipv4_hdr->dst_addr = ipv4_hdr->src_addr; ipv4_hdr->dst_addr = ipv4_hdr->src_addr;
ipv4_hdr->src_addr = bond_ip; ipv4_hdr->src_addr = bond_ip;
rte_eth_tx_burst(BOND_PORT, 0, &pkts[i], 1); rte_eth_tx_burst(BOND_PORT, 0, &pkts[i], 1);
@ -519,8 +521,8 @@ static void cmd_obj_send_parsed(void *parsed_result,
created_pkt->pkt_len = pkt_size; created_pkt->pkt_len = pkt_size;
eth_hdr = rte_pktmbuf_mtod(created_pkt, struct rte_ether_hdr *); eth_hdr = rte_pktmbuf_mtod(created_pkt, struct rte_ether_hdr *);
rte_ether_addr_copy(&bond_mac_addr, &eth_hdr->s_addr); rte_ether_addr_copy(&bond_mac_addr, &eth_hdr->src_addr);
memset(&eth_hdr->d_addr, 0xFF, RTE_ETHER_ADDR_LEN); memset(&eth_hdr->dst_addr, 0xFF, RTE_ETHER_ADDR_LEN);
eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_ARP); eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_ARP);
arp_hdr = (struct rte_arp_hdr *)( arp_hdr = (struct rte_arp_hdr *)(

4
examples/ethtool/ethtool-app/main.c
View File

@ -172,8 +172,8 @@ static void process_frame(struct app_port *ptr_port,
struct rte_ether_hdr *ptr_mac_hdr; struct rte_ether_hdr *ptr_mac_hdr;
ptr_mac_hdr = rte_pktmbuf_mtod(ptr_frame, struct rte_ether_hdr *); ptr_mac_hdr = rte_pktmbuf_mtod(ptr_frame, struct rte_ether_hdr *);
rte_ether_addr_copy(&ptr_mac_hdr->s_addr, &ptr_mac_hdr->d_addr); rte_ether_addr_copy(&ptr_mac_hdr->src_addr, &ptr_mac_hdr->dst_addr);
rte_ether_addr_copy(&ptr_port->mac_addr, &ptr_mac_hdr->s_addr); rte_ether_addr_copy(&ptr_port->mac_addr, &ptr_mac_hdr->src_addr);
} }
static int worker_main(__rte_unused void *ptr_data) static int worker_main(__rte_unused void *ptr_data)

4
examples/eventdev_pipeline/pipeline_common.h
View File

@ -104,8 +104,8 @@ exchange_mac(struct rte_mbuf *m)
/* change mac addresses on packet (to use mbuf data) */ /* change mac addresses on packet (to use mbuf data) */
eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *); eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
rte_ether_addr_copy(&eth->d_addr, &addr); rte_ether_addr_copy(&eth->dst_addr, &addr);
rte_ether_addr_copy(&addr, &eth->d_addr); rte_ether_addr_copy(&addr, &eth->dst_addr);
} }
static __rte_always_inline void static __rte_always_inline void

4
examples/flow_filtering/main.c
View File

@ -75,9 +75,9 @@ main_loop(void)
eth_hdr = rte_pktmbuf_mtod(m, eth_hdr = rte_pktmbuf_mtod(m,
struct rte_ether_hdr *); struct rte_ether_hdr *);
print_ether_addr("src=", print_ether_addr("src=",
&eth_hdr->s_addr); &eth_hdr->src_addr);
print_ether_addr(" - dst=", print_ether_addr(" - dst=",
&eth_hdr->d_addr); &eth_hdr->dst_addr);
printf(" - queue=0x%x", printf(" - queue=0x%x",
(unsigned int)i); (unsigned int)i);
printf("\n"); printf("\n");

4
examples/ioat/ioatfwd.c
View File

@ -322,11 +322,11 @@ update_mac_addrs(struct rte_mbuf *m, uint32_t dest_portid)
/* 02:00:00:00:00:xx - overwriting 2 bytes of source address but /* 02:00:00:00:00:xx - overwriting 2 bytes of source address but
* it's acceptable cause it gets overwritten by rte_ether_addr_copy * it's acceptable cause it gets overwritten by rte_ether_addr_copy
*/ */
tmp = &eth->d_addr.addr_bytes[0]; tmp = &eth->dst_addr.addr_bytes[0];
*((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dest_portid << 40); *((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dest_portid << 40);
/* src addr */ /* src addr */
rte_ether_addr_copy(&ioat_ports_eth_addr[dest_portid], &eth->s_addr); rte_ether_addr_copy(&ioat_ports_eth_addr[dest_portid], &eth->src_addr);
} }
/* Perform packet copy there is a user-defined function. 8< */ /* Perform packet copy there is a user-defined function. 8< */

4
examples/ip_fragmentation/main.c
View File

@ -362,13 +362,13 @@ l3fwd_simple_forward(struct rte_mbuf *m, struct lcore_queue_conf *qconf,
m->l2_len = sizeof(struct rte_ether_hdr); m->l2_len = sizeof(struct rte_ether_hdr);
/* 02:00:00:00:00:xx */ /* 02:00:00:00:00:xx */
d_addr_bytes = &eth_hdr->d_addr.addr_bytes[0]; d_addr_bytes = &eth_hdr->dst_addr.addr_bytes[0];
*((uint64_t *)d_addr_bytes) = 0x000000000002 + *((uint64_t *)d_addr_bytes) = 0x000000000002 +
((uint64_t)port_out << 40); ((uint64_t)port_out << 40);
/* src addr */ /* src addr */
rte_ether_addr_copy(&ports_eth_addr[port_out], rte_ether_addr_copy(&ports_eth_addr[port_out],
&eth_hdr->s_addr); &eth_hdr->src_addr);
eth_hdr->ether_type = ether_type; eth_hdr->ether_type = ether_type;
} }

4
examples/ip_reassembly/main.c
View File

@ -413,11 +413,11 @@ reassemble(struct rte_mbuf *m, uint16_t portid, uint32_t queue,
/* if packet wasn't IPv4 or IPv6, it's forwarded to the port it came from */ /* if packet wasn't IPv4 or IPv6, it's forwarded to the port it came from */
/* 02:00:00:00:00:xx */ /* 02:00:00:00:00:xx */
d_addr_bytes = &eth_hdr->d_addr.addr_bytes[0]; d_addr_bytes = &eth_hdr->dst_addr.addr_bytes[0];
*((uint64_t *)d_addr_bytes) = 0x000000000002 + ((uint64_t)dst_port << 40); *((uint64_t *)d_addr_bytes) = 0x000000000002 + ((uint64_t)dst_port << 40);
/* src addr */ /* src addr */
rte_ether_addr_copy(&ports_eth_addr[dst_port], &eth_hdr->s_addr); rte_ether_addr_copy(&ports_eth_addr[dst_port], &eth_hdr->src_addr);
send_single_packet(m, dst_port); send_single_packet(m, dst_port);
} }

4
examples/ipsec-secgw/ipsec-secgw.c
View File

@ -545,9 +545,9 @@ prepare_tx_pkt(struct rte_mbuf *pkt, uint16_t port,
ethhdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6); ethhdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6);
} }
memcpy(&ethhdr->s_addr, &ethaddr_tbl[port].src, memcpy(&ethhdr->src_addr, &ethaddr_tbl[port].src,
sizeof(struct rte_ether_addr)); sizeof(struct rte_ether_addr));
memcpy(&ethhdr->d_addr, &ethaddr_tbl[port].dst, memcpy(&ethhdr->dst_addr, &ethaddr_tbl[port].dst,
sizeof(struct rte_ether_addr)); sizeof(struct rte_ether_addr));
} }

4
examples/ipsec-secgw/ipsec_worker.c
View File

@ -49,8 +49,8 @@ update_mac_addrs(struct rte_mbuf *pkt, uint16_t portid)
struct rte_ether_hdr *ethhdr; struct rte_ether_hdr *ethhdr;
ethhdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *); ethhdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
memcpy(&ethhdr->s_addr, &ethaddr_tbl[portid].src, RTE_ETHER_ADDR_LEN); memcpy(&ethhdr->src_addr, &ethaddr_tbl[portid].src, RTE_ETHER_ADDR_LEN);
memcpy(&ethhdr->d_addr, &ethaddr_tbl[portid].dst, RTE_ETHER_ADDR_LEN); memcpy(&ethhdr->dst_addr, &ethaddr_tbl[portid].dst, RTE_ETHER_ADDR_LEN);
} }
static inline void static inline void

4
examples/ipv4_multicast/main.c
View File

@ -283,8 +283,8 @@ mcast_send_pkt(struct rte_mbuf *pkt, struct rte_ether_addr *dest_addr,
rte_pktmbuf_prepend(pkt, (uint16_t)sizeof(*ethdr)); rte_pktmbuf_prepend(pkt, (uint16_t)sizeof(*ethdr));
RTE_ASSERT(ethdr != NULL); RTE_ASSERT(ethdr != NULL);
rte_ether_addr_copy(dest_addr, &ethdr->d_addr); rte_ether_addr_copy(dest_addr, &ethdr->dst_addr);
rte_ether_addr_copy(&ports_eth_addr[port], &ethdr->s_addr); rte_ether_addr_copy(&ports_eth_addr[port], &ethdr->src_addr);
ethdr->ether_type = rte_be_to_cpu_16(RTE_ETHER_TYPE_IPV4); ethdr->ether_type = rte_be_to_cpu_16(RTE_ETHER_TYPE_IPV4);
/* Put new packet into the output queue */ /* Put new packet into the output queue */

4
examples/l2fwd-crypto/main.c
View File

@ -617,11 +617,11 @@ l2fwd_mac_updating(struct rte_mbuf *m, uint16_t dest_portid)
eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *); eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
/* 02:00:00:00:00:xx */ /* 02:00:00:00:00:xx */
tmp = &eth->d_addr.addr_bytes[0]; tmp = &eth->dst_addr.addr_bytes[0];
*((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dest_portid << 40); *((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dest_portid << 40);
/* src addr */ /* src addr */
rte_ether_addr_copy(&l2fwd_ports_eth_addr[dest_portid], &eth->s_addr); rte_ether_addr_copy(&l2fwd_ports_eth_addr[dest_portid], &eth->src_addr);
} }
static void static void

4
examples/l2fwd-event/l2fwd_common.h
View File

@ -92,11 +92,11 @@ l2fwd_mac_updating(struct rte_mbuf *m, uint32_t dest_port_id,
eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *); eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
/* 02:00:00:00:00:xx */ /* 02:00:00:00:00:xx */
tmp = &eth->d_addr.addr_bytes[0]; tmp = &eth->dst_addr.addr_bytes[0];
*((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dest_port_id << 40); *((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dest_port_id << 40);
/* src addr */ /* src addr */
rte_ether_addr_copy(addr, &eth->s_addr); rte_ether_addr_copy(addr, &eth->src_addr);
} }
static __rte_always_inline struct l2fwd_resources * static __rte_always_inline struct l2fwd_resources *

4
examples/l2fwd-jobstats/main.c
View File

@ -351,11 +351,11 @@ l2fwd_simple_forward(struct rte_mbuf *m, unsigned portid)
eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *); eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
/* 02:00:00:00:00:xx */ /* 02:00:00:00:00:xx */
tmp = &eth->d_addr.addr_bytes[0]; tmp = &eth->dst_addr.addr_bytes[0];
*((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dst_port << 40); *((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dst_port << 40);
/* src addr */ /* src addr */
rte_ether_addr_copy(&l2fwd_ports_eth_addr[dst_port], &eth->s_addr); rte_ether_addr_copy(&l2fwd_ports_eth_addr[dst_port], &eth->src_addr);
buffer = tx_buffer[dst_port]; buffer = tx_buffer[dst_port];
sent = rte_eth_tx_buffer(dst_port, 0, buffer, m); sent = rte_eth_tx_buffer(dst_port, 0, buffer, m);

4
examples/l2fwd-keepalive/main.c
View File

@ -177,11 +177,11 @@ l2fwd_simple_forward(struct rte_mbuf *m, unsigned portid)
eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *); eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
/* 02:00:00:00:00:xx */ /* 02:00:00:00:00:xx */
tmp = &eth->d_addr.addr_bytes[0]; tmp = &eth->dst_addr.addr_bytes[0];
*((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dst_port << 40); *((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dst_port << 40);
/* src addr */ /* src addr */
rte_ether_addr_copy(&l2fwd_ports_eth_addr[dst_port], &eth->s_addr); rte_ether_addr_copy(&l2fwd_ports_eth_addr[dst_port], &eth->src_addr);
buffer = tx_buffer[dst_port]; buffer = tx_buffer[dst_port];
sent = rte_eth_tx_buffer(dst_port, 0, buffer, m); sent = rte_eth_tx_buffer(dst_port, 0, buffer, m);

4
examples/l2fwd/main.c
View File

@ -170,11 +170,11 @@ l2fwd_mac_updating(struct rte_mbuf *m, unsigned dest_portid)
eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *); eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
/* 02:00:00:00:00:xx */ /* 02:00:00:00:00:xx */
tmp = &eth->d_addr.addr_bytes[0]; tmp = &eth->dst_addr.addr_bytes[0];
*((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dest_portid << 40); *((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dest_portid << 40);
/* src addr */ /* src addr */
rte_ether_addr_copy(&l2fwd_ports_eth_addr[dest_portid], &eth->s_addr); rte_ether_addr_copy(&l2fwd_ports_eth_addr[dest_portid], &eth->src_addr);
} }
/* Simple forward. 8< */ /* Simple forward. 8< */

19
examples/l3fwd-acl/main.c
View File

@ -1375,7 +1375,8 @@ send_single_packet(struct rte_mbuf *m, uint16_t port)
/* update src and dst mac*/ /* update src and dst mac*/
eh = rte_pktmbuf_mtod(m, struct rte_ether_hdr *); eh = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
memcpy(eh, &port_l2hdr[port], sizeof(eh->d_addr) + sizeof(eh->s_addr)); memcpy(eh, &port_l2hdr[port],
sizeof(eh->dst_addr) + sizeof(eh->src_addr));
qconf = &lcore_conf[lcore_id]; qconf = &lcore_conf[lcore_id];
rte_eth_tx_buffer(port, qconf->tx_queue_id[port], rte_eth_tx_buffer(port, qconf->tx_queue_id[port],
@ -1743,8 +1744,9 @@ parse_eth_dest(const char *optarg)
return "port value exceeds RTE_MAX_ETHPORTS(" return "port value exceeds RTE_MAX_ETHPORTS("
RTE_STR(RTE_MAX_ETHPORTS) ")"; RTE_STR(RTE_MAX_ETHPORTS) ")";
if (cmdline_parse_etheraddr(NULL, port_end, &port_l2hdr[portid].d_addr, if (cmdline_parse_etheraddr(NULL, port_end,
sizeof(port_l2hdr[portid].d_addr)) < 0) &port_l2hdr[portid].dst_addr,
sizeof(port_l2hdr[portid].dst_addr)) < 0)
return "Invalid ethernet address"; return "Invalid ethernet address";
return NULL; return NULL;
} }
@ -2002,8 +2004,9 @@ set_default_dest_mac(void)
uint32_t i; uint32_t i;
for (i = 0; i != RTE_DIM(port_l2hdr); i++) { for (i = 0; i != RTE_DIM(port_l2hdr); i++) {
port_l2hdr[i].d_addr.addr_bytes[0] = RTE_ETHER_LOCAL_ADMIN_ADDR; port_l2hdr[i].dst_addr.addr_bytes[0] =
port_l2hdr[i].d_addr.addr_bytes[5] = i; RTE_ETHER_LOCAL_ADMIN_ADDR;
port_l2hdr[i].dst_addr.addr_bytes[5] = i;
} }
} }
@ -2109,14 +2112,14 @@ main(int argc, char **argv)
"rte_eth_dev_adjust_nb_rx_tx_desc: err=%d, port=%d\n", "rte_eth_dev_adjust_nb_rx_tx_desc: err=%d, port=%d\n",
ret, portid); ret, portid);
ret = rte_eth_macaddr_get(portid, &port_l2hdr[portid].s_addr); ret = rte_eth_macaddr_get(portid, &port_l2hdr[portid].src_addr);
if (ret < 0) if (ret < 0)
rte_exit(EXIT_FAILURE, rte_exit(EXIT_FAILURE,
"rte_eth_macaddr_get: err=%d, port=%d\n", "rte_eth_macaddr_get: err=%d, port=%d\n",
ret, portid); ret, portid);
print_ethaddr("Dst MAC:", &port_l2hdr[portid].d_addr); print_ethaddr("Dst MAC:", &port_l2hdr[portid].dst_addr);
print_ethaddr(", Src MAC:", &port_l2hdr[portid].s_addr); print_ethaddr(", Src MAC:", &port_l2hdr[portid].src_addr);
printf(", "); printf(", ");
/* init memory */ /* init memory */

8
examples/l3fwd-power/main.c
View File

@ -717,7 +717,7 @@ l3fwd_simple_forward(struct rte_mbuf *m, uint16_t portid,
dst_port = portid; dst_port = portid;
/* 02:00:00:00:00:xx */ /* 02:00:00:00:00:xx */
d_addr_bytes = &eth_hdr->d_addr.addr_bytes[0]; d_addr_bytes = &eth_hdr->dst_addr.addr_bytes[0];
*((uint64_t *)d_addr_bytes) = *((uint64_t *)d_addr_bytes) =
0x000000000002 + ((uint64_t)dst_port << 40); 0x000000000002 + ((uint64_t)dst_port << 40);
@ -729,7 +729,7 @@ l3fwd_simple_forward(struct rte_mbuf *m, uint16_t portid,
/* src addr */ /* src addr */
rte_ether_addr_copy(&ports_eth_addr[dst_port], rte_ether_addr_copy(&ports_eth_addr[dst_port],
&eth_hdr->s_addr); &eth_hdr->src_addr);
send_single_packet(m, dst_port); send_single_packet(m, dst_port);
} else if (RTE_ETH_IS_IPV6_HDR(m->packet_type)) { } else if (RTE_ETH_IS_IPV6_HDR(m->packet_type)) {
@ -749,13 +749,13 @@ l3fwd_simple_forward(struct rte_mbuf *m, uint16_t portid,
dst_port = portid; dst_port = portid;
/* 02:00:00:00:00:xx */ /* 02:00:00:00:00:xx */
d_addr_bytes = &eth_hdr->d_addr.addr_bytes[0]; d_addr_bytes = &eth_hdr->dst_addr.addr_bytes[0];
*((uint64_t *)d_addr_bytes) = *((uint64_t *)d_addr_bytes) =
0x000000000002 + ((uint64_t)dst_port << 40); 0x000000000002 + ((uint64_t)dst_port << 40);
/* src addr */ /* src addr */
rte_ether_addr_copy(&ports_eth_addr[dst_port], rte_ether_addr_copy(&ports_eth_addr[dst_port],
&eth_hdr->s_addr); &eth_hdr->src_addr);
send_single_packet(m, dst_port); send_single_packet(m, dst_port);
#else #else

8
examples/l3fwd/l3fwd_em.h
View File

@ -36,11 +36,11 @@ l3fwd_em_handle_ipv4(struct rte_mbuf *m, uint16_t portid,
++(ipv4_hdr->hdr_checksum); ++(ipv4_hdr->hdr_checksum);
#endif #endif
/* dst addr */ /* dst addr */
*(uint64_t *)&eth_hdr->d_addr = dest_eth_addr[dst_port]; *(uint64_t *)&eth_hdr->dst_addr = dest_eth_addr[dst_port];
/* src addr */ /* src addr */
rte_ether_addr_copy(&ports_eth_addr[dst_port], rte_ether_addr_copy(&ports_eth_addr[dst_port],
&eth_hdr->s_addr); &eth_hdr->src_addr);
return dst_port; return dst_port;
} }
@ -64,11 +64,11 @@ l3fwd_em_handle_ipv6(struct rte_mbuf *m, uint16_t portid,
dst_port = portid; dst_port = portid;
/* dst addr */ /* dst addr */
*(uint64_t *)&eth_hdr->d_addr = dest_eth_addr[dst_port]; *(uint64_t *)&eth_hdr->dst_addr = dest_eth_addr[dst_port];
/* src addr */ /* src addr */
rte_ether_addr_copy(&ports_eth_addr[dst_port], rte_ether_addr_copy(&ports_eth_addr[dst_port],
&eth_hdr->s_addr); &eth_hdr->src_addr);
return dst_port; return dst_port;
} }

4
examples/l3fwd/l3fwd_fib.c
View File

@ -92,9 +92,9 @@ fib_send_single(int nb_tx, struct lcore_conf *qconf,
/* Set MAC addresses. */ /* Set MAC addresses. */
eth_hdr = rte_pktmbuf_mtod(pkts_burst[j], eth_hdr = rte_pktmbuf_mtod(pkts_burst[j],
struct rte_ether_hdr *); struct rte_ether_hdr *);
*(uint64_t *)&eth_hdr->d_addr = dest_eth_addr[hops[j]]; *(uint64_t *)&eth_hdr->dst_addr = dest_eth_addr[hops[j]];
rte_ether_addr_copy(&ports_eth_addr[hops[j]], rte_ether_addr_copy(&ports_eth_addr[hops[j]],
&eth_hdr->s_addr); &eth_hdr->src_addr);
/* Send single packet. */ /* Send single packet. */
send_single_packet(qconf, pkts_burst[j], hops[j]); send_single_packet(qconf, pkts_burst[j], hops[j]);

4
examples/l3fwd/l3fwd_lpm.c
View File

@ -256,11 +256,11 @@ lpm_process_event_pkt(const struct lcore_conf *lconf, struct rte_mbuf *mbuf)
} }
#endif #endif
/* dst addr */ /* dst addr */
*(uint64_t *)&eth_hdr->d_addr = dest_eth_addr[mbuf->port]; *(uint64_t *)&eth_hdr->dst_addr = dest_eth_addr[mbuf->port];
/* src addr */ /* src addr */
rte_ether_addr_copy(&ports_eth_addr[mbuf->port], rte_ether_addr_copy(&ports_eth_addr[mbuf->port],
&eth_hdr->s_addr); &eth_hdr->src_addr);
#endif #endif
return mbuf->port; return mbuf->port;
} }

8
examples/l3fwd/l3fwd_lpm.h
View File

@ -40,11 +40,11 @@ l3fwd_lpm_simple_forward(struct rte_mbuf *m, uint16_t portid,
++(ipv4_hdr->hdr_checksum); ++(ipv4_hdr->hdr_checksum);
#endif #endif
/* dst addr */ /* dst addr */
*(uint64_t *)&eth_hdr->d_addr = dest_eth_addr[dst_port]; *(uint64_t *)&eth_hdr->dst_addr = dest_eth_addr[dst_port];
/* src addr */ /* src addr */
rte_ether_addr_copy(&ports_eth_addr[dst_port], rte_ether_addr_copy(&ports_eth_addr[dst_port],
&eth_hdr->s_addr); &eth_hdr->src_addr);
send_single_packet(qconf, m, dst_port); send_single_packet(qconf, m, dst_port);
} else if (RTE_ETH_IS_IPV6_HDR(m->packet_type)) { } else if (RTE_ETH_IS_IPV6_HDR(m->packet_type)) {
@ -62,11 +62,11 @@ l3fwd_lpm_simple_forward(struct rte_mbuf *m, uint16_t portid,
dst_port = portid; dst_port = portid;
/* dst addr */ /* dst addr */
*(uint64_t *)&eth_hdr->d_addr = dest_eth_addr[dst_port]; *(uint64_t *)&eth_hdr->dst_addr = dest_eth_addr[dst_port];
/* src addr */ /* src addr */
rte_ether_addr_copy(&ports_eth_addr[dst_port], rte_ether_addr_copy(&ports_eth_addr[dst_port],
&eth_hdr->s_addr); &eth_hdr->src_addr);
send_single_packet(qconf, m, dst_port); send_single_packet(qconf, m, dst_port);
} else { } else {

4
examples/link_status_interrupt/main.c
View File

@ -182,11 +182,11 @@ lsi_simple_forward(struct rte_mbuf *m, unsigned portid)
eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *); eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
/* 02:00:00:00:00:xx */ /* 02:00:00:00:00:xx */
tmp = &eth->d_addr.addr_bytes[0]; tmp = &eth->dst_addr.addr_bytes[0];
*((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dst_port << 40); *((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dst_port << 40);
/* src addr */ /* src addr */
rte_ether_addr_copy(&lsi_ports_eth_addr[dst_port], &eth->s_addr); rte_ether_addr_copy(&lsi_ports_eth_addr[dst_port], &eth->src_addr);
buffer = tx_buffer[dst_port]; buffer = tx_buffer[dst_port];
sent = rte_eth_tx_buffer(dst_port, 0, buffer, m); sent = rte_eth_tx_buffer(dst_port, 0, buffer, m);

72
examples/performance-thread/l3fwd-thread/main.c
View File

@ -1068,24 +1068,24 @@ simple_ipv4_fwd_8pkts(struct rte_mbuf *m[8], uint16_t portid)
#endif #endif
/* dst addr */ /* dst addr */
*(uint64_t *)&eth_hdr[0]->d_addr = dest_eth_addr[dst_port[0]]; *(uint64_t *)&eth_hdr[0]->dst_addr = dest_eth_addr[dst_port[0]];
*(uint64_t *)&eth_hdr[1]->d_addr = dest_eth_addr[dst_port[1]]; *(uint64_t *)&eth_hdr[1]->dst_addr = dest_eth_addr[dst_port[1]];
*(uint64_t *)&eth_hdr[2]->d_addr = dest_eth_addr[dst_port[2]]; *(uint64_t *)&eth_hdr[2]->dst_addr = dest_eth_addr[dst_port[2]];
*(uint64_t *)&eth_hdr[3]->d_addr = dest_eth_addr[dst_port[3]]; *(uint64_t *)&eth_hdr[3]->dst_addr = dest_eth_addr[dst_port[3]];
*(uint64_t *)&eth_hdr[4]->d_addr = dest_eth_addr[dst_port[4]]; *(uint64_t *)&eth_hdr[4]->dst_addr = dest_eth_addr[dst_port[4]];
*(uint64_t *)&eth_hdr[5]->d_addr = dest_eth_addr[dst_port[5]]; *(uint64_t *)&eth_hdr[5]->dst_addr = dest_eth_addr[dst_port[5]];
*(uint64_t *)&eth_hdr[6]->d_addr = dest_eth_addr[dst_port[6]]; *(uint64_t *)&eth_hdr[6]->dst_addr = dest_eth_addr[dst_port[6]];
*(uint64_t *)&eth_hdr[7]->d_addr = dest_eth_addr[dst_port[7]]; *(uint64_t *)&eth_hdr[7]->dst_addr = dest_eth_addr[dst_port[7]];
/* src addr */ /* src addr */
rte_ether_addr_copy(&ports_eth_addr[dst_port[0]], &eth_hdr[0]->s_addr); rte_ether_addr_copy(&ports_eth_addr[dst_port[0]], &eth_hdr[0]->src_addr);
rte_ether_addr_copy(&ports_eth_addr[dst_port[1]], &eth_hdr[1]->s_addr); rte_ether_addr_copy(&ports_eth_addr[dst_port[1]], &eth_hdr[1]->src_addr);
rte_ether_addr_copy(&ports_eth_addr[dst_port[2]], &eth_hdr[2]->s_addr); rte_ether_addr_copy(&ports_eth_addr[dst_port[2]], &eth_hdr[2]->src_addr);
rte_ether_addr_copy(&ports_eth_addr[dst_port[3]], &eth_hdr[3]->s_addr); rte_ether_addr_copy(&ports_eth_addr[dst_port[3]], &eth_hdr[3]->src_addr);
rte_ether_addr_copy(&ports_eth_addr[dst_port[4]], &eth_hdr[4]->s_addr); rte_ether_addr_copy(&ports_eth_addr[dst_port[4]], &eth_hdr[4]->src_addr);
rte_ether_addr_copy(&ports_eth_addr[dst_port[5]], &eth_hdr[5]->s_addr); rte_ether_addr_copy(&ports_eth_addr[dst_port[5]], &eth_hdr[5]->src_addr);
rte_ether_addr_copy(&ports_eth_addr[dst_port[6]], &eth_hdr[6]->s_addr); rte_ether_addr_copy(&ports_eth_addr[dst_port[6]], &eth_hdr[6]->src_addr);
rte_ether_addr_copy(&ports_eth_addr[dst_port[7]], &eth_hdr[7]->s_addr); rte_ether_addr_copy(&ports_eth_addr[dst_port[7]], &eth_hdr[7]->src_addr);
send_single_packet(m[0], (uint8_t)dst_port[0]); send_single_packet(m[0], (uint8_t)dst_port[0]);
send_single_packet(m[1], (uint8_t)dst_port[1]); send_single_packet(m[1], (uint8_t)dst_port[1]);
@ -1203,24 +1203,24 @@ simple_ipv6_fwd_8pkts(struct rte_mbuf *m[8], uint16_t portid)
dst_port[7] = portid; dst_port[7] = portid;
/* dst addr */ /* dst addr */
*(uint64_t *)&eth_hdr[0]->d_addr = dest_eth_addr[dst_port[0]]; *(uint64_t *)&eth_hdr[0]->dst_addr = dest_eth_addr[dst_port[0]];
*(uint64_t *)&eth_hdr[1]->d_addr = dest_eth_addr[dst_port[1]]; *(uint64_t *)&eth_hdr[1]->dst_addr = dest_eth_addr[dst_port[1]];
*(uint64_t *)&eth_hdr[2]->d_addr = dest_eth_addr[dst_port[2]]; *(uint64_t *)&eth_hdr[2]->dst_addr = dest_eth_addr[dst_port[2]];
*(uint64_t *)&eth_hdr[3]->d_addr = dest_eth_addr[dst_port[3]]; *(uint64_t *)&eth_hdr[3]->dst_addr = dest_eth_addr[dst_port[3]];
*(uint64_t *)&eth_hdr[4]->d_addr = dest_eth_addr[dst_port[4]]; *(uint64_t *)&eth_hdr[4]->dst_addr = dest_eth_addr[dst_port[4]];
*(uint64_t *)&eth_hdr[5]->d_addr = dest_eth_addr[dst_port[5]]; *(uint64_t *)&eth_hdr[5]->dst_addr = dest_eth_addr[dst_port[5]];
*(uint64_t *)&eth_hdr[6]->d_addr = dest_eth_addr[dst_port[6]]; *(uint64_t *)&eth_hdr[6]->dst_addr = dest_eth_addr[dst_port[6]];
*(uint64_t *)&eth_hdr[7]->d_addr = dest_eth_addr[dst_port[7]]; *(uint64_t *)&eth_hdr[7]->dst_addr = dest_eth_addr[dst_port[7]];
/* src addr */ /* src addr */
rte_ether_addr_copy(&ports_eth_addr[dst_port[0]], &eth_hdr[0]->s_addr); rte_ether_addr_copy(&ports_eth_addr[dst_port[0]], &eth_hdr[0]->src_addr);
rte_ether_addr_copy(&ports_eth_addr[dst_port[1]], &eth_hdr[1]->s_addr); rte_ether_addr_copy(&ports_eth_addr[dst_port[1]], &eth_hdr[1]->src_addr);
rte_ether_addr_copy(&ports_eth_addr[dst_port[2]], &eth_hdr[2]->s_addr); rte_ether_addr_copy(&ports_eth_addr[dst_port[2]], &eth_hdr[2]->src_addr);
rte_ether_addr_copy(&ports_eth_addr[dst_port[3]], &eth_hdr[3]->s_addr); rte_ether_addr_copy(&ports_eth_addr[dst_port[3]], &eth_hdr[3]->src_addr);
rte_ether_addr_copy(&ports_eth_addr[dst_port[4]], &eth_hdr[4]->s_addr); rte_ether_addr_copy(&ports_eth_addr[dst_port[4]], &eth_hdr[4]->src_addr);
rte_ether_addr_copy(&ports_eth_addr[dst_port[5]], &eth_hdr[5]->s_addr); rte_ether_addr_copy(&ports_eth_addr[dst_port[5]], &eth_hdr[5]->src_addr);
rte_ether_addr_copy(&ports_eth_addr[dst_port[6]], &eth_hdr[6]->s_addr); rte_ether_addr_copy(&ports_eth_addr[dst_port[6]], &eth_hdr[6]->src_addr);
rte_ether_addr_copy(&ports_eth_addr[dst_port[7]], &eth_hdr[7]->s_addr); rte_ether_addr_copy(&ports_eth_addr[dst_port[7]], &eth_hdr[7]->src_addr);
send_single_packet(m[0], dst_port[0]); send_single_packet(m[0], dst_port[0]);
send_single_packet(m[1], dst_port[1]); send_single_packet(m[1], dst_port[1]);
@ -1268,11 +1268,11 @@ l3fwd_simple_forward(struct rte_mbuf *m, uint16_t portid)
++(ipv4_hdr->hdr_checksum); ++(ipv4_hdr->hdr_checksum);
#endif #endif
/* dst addr */ /* dst addr */
*(uint64_t *)&eth_hdr->d_addr = dest_eth_addr[dst_port]; *(uint64_t *)&eth_hdr->dst_addr = dest_eth_addr[dst_port];
/* src addr */ /* src addr */
rte_ether_addr_copy(&ports_eth_addr[dst_port], rte_ether_addr_copy(&ports_eth_addr[dst_port],
&eth_hdr->s_addr); &eth_hdr->src_addr);
send_single_packet(m, dst_port); send_single_packet(m, dst_port);
} else if (RTE_ETH_IS_IPV6_HDR(m->packet_type)) { } else if (RTE_ETH_IS_IPV6_HDR(m->packet_type)) {
@ -1290,11 +1290,11 @@ l3fwd_simple_forward(struct rte_mbuf *m, uint16_t portid)
dst_port = portid; dst_port = portid;
/* dst addr */ /* dst addr */
*(uint64_t *)&eth_hdr->d_addr = dest_eth_addr[dst_port]; *(uint64_t *)&eth_hdr->dst_addr = dest_eth_addr[dst_port];
/* src addr */ /* src addr */
rte_ether_addr_copy(&ports_eth_addr[dst_port], rte_ether_addr_copy(&ports_eth_addr[dst_port],
&eth_hdr->s_addr); &eth_hdr->src_addr);
send_single_packet(m, dst_port); send_single_packet(m, dst_port);
} else } else

16
examples/ptpclient/ptpclient.c
View File

@ -426,10 +426,10 @@ parse_fup(struct ptpv2_data_slave_ordinary *ptp_data)
created_pkt->data_len = pkt_size; created_pkt->data_len = pkt_size;
created_pkt->pkt_len = pkt_size; created_pkt->pkt_len = pkt_size;
eth_hdr = rte_pktmbuf_mtod(created_pkt, struct rte_ether_hdr *); eth_hdr = rte_pktmbuf_mtod(created_pkt, struct rte_ether_hdr *);
rte_ether_addr_copy(&eth_addr, &eth_hdr->s_addr); rte_ether_addr_copy(&eth_addr, &eth_hdr->src_addr);
/* Set multicast address 01-1B-19-00-00-00. */ /* Set multicast address 01-1B-19-00-00-00. */
rte_ether_addr_copy(&eth_multicast, &eth_hdr->d_addr); rte_ether_addr_copy(&eth_multicast, &eth_hdr->dst_addr);
eth_hdr->ether_type = htons(PTP_PROTOCOL); eth_hdr->ether_type = htons(PTP_PROTOCOL);
ptp_msg = (struct ptp_message *) ptp_msg = (struct ptp_message *)
@ -449,14 +449,14 @@ parse_fup(struct ptpv2_data_slave_ordinary *ptp_data)
client_clkid = client_clkid =
&ptp_msg->delay_req.hdr.source_port_id.clock_id; &ptp_msg->delay_req.hdr.source_port_id.clock_id;
client_clkid->id[0] = eth_hdr->s_addr.addr_bytes[0]; client_clkid->id[0] = eth_hdr->src_addr.addr_bytes[0];
client_clkid->id[1] = eth_hdr->s_addr.addr_bytes[1]; client_clkid->id[1] = eth_hdr->src_addr.addr_bytes[1];
client_clkid->id[2] = eth_hdr->s_addr.addr_bytes[2]; client_clkid->id[2] = eth_hdr->src_addr.addr_bytes[2];
client_clkid->id[3] = 0xFF; client_clkid->id[3] = 0xFF;
client_clkid->id[4] = 0xFE; client_clkid->id[4] = 0xFE;
client_clkid->id[5] = eth_hdr->s_addr.addr_bytes[3]; client_clkid->id[5] = eth_hdr->src_addr.addr_bytes[3];
client_clkid->id[6] = eth_hdr->s_addr.addr_bytes[4]; client_clkid->id[6] = eth_hdr->src_addr.addr_bytes[4];
client_clkid->id[7] = eth_hdr->s_addr.addr_bytes[5]; client_clkid->id[7] = eth_hdr->src_addr.addr_bytes[5];
rte_memcpy(&ptp_data->client_clock_id, rte_memcpy(&ptp_data->client_clock_id,
client_clkid, client_clkid,

11
examples/vhost/main.c
View File

@ -757,7 +757,7 @@ link_vmdq(struct vhost_dev *vdev, struct rte_mbuf *m)
/* Learn MAC address of guest device from packet */ /* Learn MAC address of guest device from packet */
pkt_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *); pkt_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
if (find_vhost_dev(&pkt_hdr->s_addr)) { if (find_vhost_dev(&pkt_hdr->src_addr)) {
RTE_LOG(ERR, VHOST_DATA, RTE_LOG(ERR, VHOST_DATA,
"(%d) device is using a registered MAC!\n", "(%d) device is using a registered MAC!\n",
vdev->vid); vdev->vid);
@ -765,7 +765,8 @@ link_vmdq(struct vhost_dev *vdev, struct rte_mbuf *m)
} }
for (i = 0; i < RTE_ETHER_ADDR_LEN; i++) for (i = 0; i < RTE_ETHER_ADDR_LEN; i++)
vdev->mac_address.addr_bytes[i] = pkt_hdr->s_addr.addr_bytes[i]; vdev->mac_address.addr_bytes[i] =
pkt_hdr->src_addr.addr_bytes[i];
/* vlan_tag currently uses the device_id. */ /* vlan_tag currently uses the device_id. */
vdev->vlan_tag = vlan_tags[vdev->vid]; vdev->vlan_tag = vlan_tags[vdev->vid];
@ -945,7 +946,7 @@ virtio_tx_local(struct vhost_dev *vdev, struct rte_mbuf *m)
uint16_t lcore_id = rte_lcore_id(); uint16_t lcore_id = rte_lcore_id();
pkt_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *); pkt_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
dst_vdev = find_vhost_dev(&pkt_hdr->d_addr); dst_vdev = find_vhost_dev(&pkt_hdr->dst_addr);
if (!dst_vdev) if (!dst_vdev)
return -1; return -1;
@ -993,7 +994,7 @@ find_local_dest(struct vhost_dev *vdev, struct rte_mbuf *m,
struct rte_ether_hdr *pkt_hdr = struct rte_ether_hdr *pkt_hdr =
rte_pktmbuf_mtod(m, struct rte_ether_hdr *); rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
dst_vdev = find_vhost_dev(&pkt_hdr->d_addr); dst_vdev = find_vhost_dev(&pkt_hdr->dst_addr);
if (!dst_vdev) if (!dst_vdev)
return 0; return 0;
@ -1076,7 +1077,7 @@ virtio_tx_route(struct vhost_dev *vdev, struct rte_mbuf *m, uint16_t vlan_tag)
nh = rte_pktmbuf_mtod(m, struct rte_ether_hdr *); nh = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
if (unlikely(rte_is_broadcast_ether_addr(&nh->d_addr))) { if (unlikely(rte_is_broadcast_ether_addr(&nh->dst_addr))) {
struct vhost_dev *vdev2; struct vhost_dev *vdev2;
TAILQ_FOREACH(vdev2, &vhost_dev_list, global_vdev_entry) { TAILQ_FOREACH(vdev2, &vhost_dev_list, global_vdev_entry) {

4
examples/vmdq/main.c
View File

@ -461,11 +461,11 @@ update_mac_address(struct rte_mbuf *m, unsigned dst_port)
eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *); eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
/* 02:00:00:00:00:xx */ /* 02:00:00:00:00:xx */
tmp = &eth->d_addr.addr_bytes[0]; tmp = &eth->dst_addr.addr_bytes[0];
*((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dst_port << 40); *((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dst_port << 40);
/* src addr */ /* src addr */
rte_ether_addr_copy(&vmdq_ports_eth_addr[dst_port], &eth->s_addr); rte_ether_addr_copy(&vmdq_ports_eth_addr[dst_port], &eth->src_addr);
} }
/* When we receive a HUP signal, print out our stats */ /* When we receive a HUP signal, print out our stats */

4
examples/vmdq_dcb/main.c
View File

@ -512,11 +512,11 @@ update_mac_address(struct rte_mbuf *m, unsigned dst_port)
eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *); eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
/* 02:00:00:00:00:xx */ /* 02:00:00:00:00:xx */
tmp = &eth->d_addr.addr_bytes[0]; tmp = &eth->dst_addr.addr_bytes[0];
*((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dst_port << 40); *((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dst_port << 40);
/* src addr */ /* src addr */
rte_ether_addr_copy(&vmdq_ports_eth_addr[dst_port], &eth->s_addr); rte_ether_addr_copy(&vmdq_ports_eth_addr[dst_port], &eth->src_addr);
} }
/* When we receive a HUP signal, print out our stats */ /* When we receive a HUP signal, print out our stats */

4
lib/ethdev/rte_flow.h
View File

@ -785,8 +785,8 @@ struct rte_flow_item_eth {
/** Default mask for RTE_FLOW_ITEM_TYPE_ETH. */ /** Default mask for RTE_FLOW_ITEM_TYPE_ETH. */
#ifndef __cplusplus #ifndef __cplusplus
static const struct rte_flow_item_eth rte_flow_item_eth_mask = { static const struct rte_flow_item_eth rte_flow_item_eth_mask = {
.hdr.d_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff", .hdr.dst_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff",
.hdr.s_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff", .hdr.src_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff",
.hdr.ether_type = RTE_BE16(0x0000), .hdr.ether_type = RTE_BE16(0x0000),
}; };
#endif #endif

4
lib/gro/gro_tcp4.c
View File

@ -243,8 +243,8 @@ gro_tcp4_reassemble(struct rte_mbuf *pkt,
ip_id = is_atomic ? 0 : rte_be_to_cpu_16(ipv4_hdr->packet_id); ip_id = is_atomic ? 0 : rte_be_to_cpu_16(ipv4_hdr->packet_id);
sent_seq = rte_be_to_cpu_32(tcp_hdr->sent_seq); sent_seq = rte_be_to_cpu_32(tcp_hdr->sent_seq);
rte_ether_addr_copy(&(eth_hdr->s_addr), &(key.eth_saddr)); rte_ether_addr_copy(&(eth_hdr->src_addr), &(key.eth_saddr));
rte_ether_addr_copy(&(eth_hdr->d_addr), &(key.eth_daddr)); rte_ether_addr_copy(&(eth_hdr->dst_addr), &(key.eth_daddr));
key.ip_src_addr = ipv4_hdr->src_addr; key.ip_src_addr = ipv4_hdr->src_addr;
key.ip_dst_addr = ipv4_hdr->dst_addr; key.ip_dst_addr = ipv4_hdr->dst_addr;
key.src_port = tcp_hdr->src_port; key.src_port = tcp_hdr->src_port;

4
lib/gro/gro_udp4.c
View File

@ -238,8 +238,8 @@ gro_udp4_reassemble(struct rte_mbuf *pkt,
is_last_frag = ((frag_offset & RTE_IPV4_HDR_MF_FLAG) == 0) ? 1 : 0; is_last_frag = ((frag_offset & RTE_IPV4_HDR_MF_FLAG) == 0) ? 1 : 0;
frag_offset = (uint16_t)(frag_offset & RTE_IPV4_HDR_OFFSET_MASK) << 3; frag_offset = (uint16_t)(frag_offset & RTE_IPV4_HDR_OFFSET_MASK) << 3;
rte_ether_addr_copy(&(eth_hdr->s_addr), &(key.eth_saddr)); rte_ether_addr_copy(&(eth_hdr->src_addr), &(key.eth_saddr));
rte_ether_addr_copy(&(eth_hdr->d_addr), &(key.eth_daddr)); rte_ether_addr_copy(&(eth_hdr->dst_addr), &(key.eth_daddr));
key.ip_src_addr = ipv4_hdr->src_addr; key.ip_src_addr = ipv4_hdr->src_addr;
key.ip_dst_addr = ipv4_hdr->dst_addr; key.ip_dst_addr = ipv4_hdr->dst_addr;
key.ip_id = ip_id; key.ip_id = ip_id;

8
lib/gro/gro_vxlan_tcp4.c
View File

@ -358,8 +358,8 @@ gro_vxlan_tcp4_reassemble(struct rte_mbuf *pkt,
sent_seq = rte_be_to_cpu_32(tcp_hdr->sent_seq); sent_seq = rte_be_to_cpu_32(tcp_hdr->sent_seq);
rte_ether_addr_copy(&(eth_hdr->s_addr), &(key.inner_key.eth_saddr)); rte_ether_addr_copy(&(eth_hdr->src_addr), &(key.inner_key.eth_saddr));
rte_ether_addr_copy(&(eth_hdr->d_addr), &(key.inner_key.eth_daddr)); rte_ether_addr_copy(&(eth_hdr->dst_addr), &(key.inner_key.eth_daddr));
key.inner_key.ip_src_addr = ipv4_hdr->src_addr; key.inner_key.ip_src_addr = ipv4_hdr->src_addr;
key.inner_key.ip_dst_addr = ipv4_hdr->dst_addr; key.inner_key.ip_dst_addr = ipv4_hdr->dst_addr;
key.inner_key.recv_ack = tcp_hdr->recv_ack; key.inner_key.recv_ack = tcp_hdr->recv_ack;
@ -368,8 +368,8 @@ gro_vxlan_tcp4_reassemble(struct rte_mbuf *pkt,
key.vxlan_hdr.vx_flags = vxlan_hdr->vx_flags; key.vxlan_hdr.vx_flags = vxlan_hdr->vx_flags;
key.vxlan_hdr.vx_vni = vxlan_hdr->vx_vni; key.vxlan_hdr.vx_vni = vxlan_hdr->vx_vni;
rte_ether_addr_copy(&(outer_eth_hdr->s_addr), &(key.outer_eth_saddr)); rte_ether_addr_copy(&(outer_eth_hdr->src_addr), &(key.outer_eth_saddr));
rte_ether_addr_copy(&(outer_eth_hdr->d_addr), &(key.outer_eth_daddr)); rte_ether_addr_copy(&(outer_eth_hdr->dst_addr), &(key.outer_eth_daddr));
key.outer_ip_src_addr = outer_ipv4_hdr->src_addr; key.outer_ip_src_addr = outer_ipv4_hdr->src_addr;
key.outer_ip_dst_addr = outer_ipv4_hdr->dst_addr; key.outer_ip_dst_addr = outer_ipv4_hdr->dst_addr;
key.outer_src_port = udp_hdr->src_port; key.outer_src_port = udp_hdr->src_port;

8
lib/gro/gro_vxlan_udp4.c
View File

@ -338,16 +338,16 @@ gro_vxlan_udp4_reassemble(struct rte_mbuf *pkt,
is_last_frag = ((frag_offset & RTE_IPV4_HDR_MF_FLAG) == 0) ? 1 : 0; is_last_frag = ((frag_offset & RTE_IPV4_HDR_MF_FLAG) == 0) ? 1 : 0;
frag_offset = (uint16_t)(frag_offset & RTE_IPV4_HDR_OFFSET_MASK) << 3; frag_offset = (uint16_t)(frag_offset & RTE_IPV4_HDR_OFFSET_MASK) << 3;
rte_ether_addr_copy(&(eth_hdr->s_addr), &(key.inner_key.eth_saddr)); rte_ether_addr_copy(&(eth_hdr->src_addr), &(key.inner_key.eth_saddr));
rte_ether_addr_copy(&(eth_hdr->d_addr), &(key.inner_key.eth_daddr)); rte_ether_addr_copy(&(eth_hdr->dst_addr), &(key.inner_key.eth_daddr));
key.inner_key.ip_src_addr = ipv4_hdr->src_addr; key.inner_key.ip_src_addr = ipv4_hdr->src_addr;
key.inner_key.ip_dst_addr = ipv4_hdr->dst_addr; key.inner_key.ip_dst_addr = ipv4_hdr->dst_addr;
key.inner_key.ip_id = ip_id; key.inner_key.ip_id = ip_id;
key.vxlan_hdr.vx_flags = vxlan_hdr->vx_flags; key.vxlan_hdr.vx_flags = vxlan_hdr->vx_flags;
key.vxlan_hdr.vx_vni = vxlan_hdr->vx_vni; key.vxlan_hdr.vx_vni = vxlan_hdr->vx_vni;
rte_ether_addr_copy(&(outer_eth_hdr->s_addr), &(key.outer_eth_saddr)); rte_ether_addr_copy(&(outer_eth_hdr->src_addr), &(key.outer_eth_saddr));
rte_ether_addr_copy(&(outer_eth_hdr->d_addr), &(key.outer_eth_daddr)); rte_ether_addr_copy(&(outer_eth_hdr->dst_addr), &(key.outer_eth_daddr));
key.outer_ip_src_addr = outer_ipv4_hdr->src_addr; key.outer_ip_src_addr = outer_ipv4_hdr->src_addr;
key.outer_ip_dst_addr = outer_ipv4_hdr->dst_addr; key.outer_ip_dst_addr = outer_ipv4_hdr->dst_addr;
/* Note: It is unnecessary to save outer_src_port here because it can /* Note: It is unnecessary to save outer_src_port here because it can

4
lib/net/rte_arp.c
View File

@ -29,8 +29,8 @@ rte_net_make_rarp_packet(struct rte_mempool *mpool,
} }
/* Ethernet header. */ /* Ethernet header. */
memset(eth_hdr->d_addr.addr_bytes, 0xff, RTE_ETHER_ADDR_LEN); memset(eth_hdr->dst_addr.addr_bytes, 0xff, RTE_ETHER_ADDR_LEN);
rte_ether_addr_copy(mac, &eth_hdr->s_addr); rte_ether_addr_copy(mac, &eth_hdr->src_addr);
eth_hdr->ether_type = RTE_BE16(RTE_ETHER_TYPE_RARP); eth_hdr->ether_type = RTE_BE16(RTE_ETHER_TYPE_RARP);
/* RARP header. */ /* RARP header. */

22
lib/net/rte_ether.h
View File

@ -266,34 +266,16 @@ rte_ether_format_addr(char *buf, uint16_t size,
int int
rte_ether_unformat_addr(const char *str, struct rte_ether_addr *eth_addr); rte_ether_unformat_addr(const char *str, struct rte_ether_addr *eth_addr);
/* Windows Sockets headers contain `#define s_addr S_un.S_addr`.
* Temporarily disable this macro to avoid conflict at definition.
* Place source MAC address in both `s_addr` and `S_un.S_addr` fields,
* so that access works either directly or through the macro.
*/
#pragma push_macro("s_addr")
#ifdef s_addr
#undef s_addr
#endif
/** /**
* Ethernet header: Contains the destination address, source address * Ethernet header: Contains the destination address, source address
* and frame type. * and frame type.
*/ */
struct rte_ether_hdr { struct rte_ether_hdr {
struct rte_ether_addr d_addr; /**< Destination address. */ struct rte_ether_addr dst_addr; /**< Destination address. */
RTE_STD_C11 struct rte_ether_addr src_addr; /**< Source address. */
union {
struct rte_ether_addr s_addr; /**< Source address. */
struct {
struct rte_ether_addr S_addr;
} S_un; /**< Do not use directly; use s_addr instead.*/
};
rte_be16_t ether_type; /**< Frame type. */ rte_be16_t ether_type; /**< Frame type. */
} __rte_aligned(2); } __rte_aligned(2);
#pragma pop_macro("s_addr")
/** /**
* Ethernet VLAN Header. * Ethernet VLAN Header.
* Contains the 16-bit VLAN Tag Control Identifier and the Ethernet type * Contains the 16-bit VLAN Tag Control Identifier and the Ethernet type

40
lib/pipeline/rte_table_action.c
View File

@ -615,8 +615,8 @@ encap_ether_apply(void *data,
RTE_ETHER_TYPE_IPV6; RTE_ETHER_TYPE_IPV6;
/* Ethernet */ /* Ethernet */
rte_ether_addr_copy(&p->ether.ether.da, &d->ether.d_addr); rte_ether_addr_copy(&p->ether.ether.da, &d->ether.dst_addr);
rte_ether_addr_copy(&p->ether.ether.sa, &d->ether.s_addr); rte_ether_addr_copy(&p->ether.ether.sa, &d->ether.src_addr);
d->ether.ether_type = rte_htons(ethertype); d->ether.ether_type = rte_htons(ethertype);
return 0; return 0;
@ -633,8 +633,8 @@ encap_vlan_apply(void *data,
RTE_ETHER_TYPE_IPV6; RTE_ETHER_TYPE_IPV6;
/* Ethernet */ /* Ethernet */
rte_ether_addr_copy(&p->vlan.ether.da, &d->ether.d_addr); rte_ether_addr_copy(&p->vlan.ether.da, &d->ether.dst_addr);
rte_ether_addr_copy(&p->vlan.ether.sa, &d->ether.s_addr); rte_ether_addr_copy(&p->vlan.ether.sa, &d->ether.src_addr);
d->ether.ether_type = rte_htons(RTE_ETHER_TYPE_VLAN); d->ether.ether_type = rte_htons(RTE_ETHER_TYPE_VLAN);
/* VLAN */ /* VLAN */
@ -657,8 +657,8 @@ encap_qinq_apply(void *data,
RTE_ETHER_TYPE_IPV6; RTE_ETHER_TYPE_IPV6;
/* Ethernet */ /* Ethernet */
rte_ether_addr_copy(&p->qinq.ether.da, &d->ether.d_addr); rte_ether_addr_copy(&p->qinq.ether.da, &d->ether.dst_addr);
rte_ether_addr_copy(&p->qinq.ether.sa, &d->ether.s_addr); rte_ether_addr_copy(&p->qinq.ether.sa, &d->ether.src_addr);
d->ether.ether_type = rte_htons(RTE_ETHER_TYPE_QINQ); d->ether.ether_type = rte_htons(RTE_ETHER_TYPE_QINQ);
/* SVLAN */ /* SVLAN */
@ -683,8 +683,8 @@ encap_qinq_pppoe_apply(void *data,
struct encap_qinq_pppoe_data *d = data; struct encap_qinq_pppoe_data *d = data;
/* Ethernet */ /* Ethernet */
rte_ether_addr_copy(&p->qinq.ether.da, &d->ether.d_addr); rte_ether_addr_copy(&p->qinq.ether.da, &d->ether.dst_addr);
rte_ether_addr_copy(&p->qinq.ether.sa, &d->ether.s_addr); rte_ether_addr_copy(&p->qinq.ether.sa, &d->ether.src_addr);
d->ether.ether_type = rte_htons(RTE_ETHER_TYPE_VLAN); d->ether.ether_type = rte_htons(RTE_ETHER_TYPE_VLAN);
/* SVLAN */ /* SVLAN */
@ -719,8 +719,8 @@ encap_mpls_apply(void *data,
uint32_t i; uint32_t i;
/* Ethernet */ /* Ethernet */
rte_ether_addr_copy(&p->mpls.ether.da, &d->ether.d_addr); rte_ether_addr_copy(&p->mpls.ether.da, &d->ether.dst_addr);
rte_ether_addr_copy(&p->mpls.ether.sa, &d->ether.s_addr); rte_ether_addr_copy(&p->mpls.ether.sa, &d->ether.src_addr);
d->ether.ether_type = rte_htons(ethertype); d->ether.ether_type = rte_htons(ethertype);
/* MPLS */ /* MPLS */
@ -746,8 +746,8 @@ encap_pppoe_apply(void *data,
struct encap_pppoe_data *d = data; struct encap_pppoe_data *d = data;
/* Ethernet */ /* Ethernet */
rte_ether_addr_copy(&p->pppoe.ether.da, &d->ether.d_addr); rte_ether_addr_copy(&p->pppoe.ether.da, &d->ether.dst_addr);
rte_ether_addr_copy(&p->pppoe.ether.sa, &d->ether.s_addr); rte_ether_addr_copy(&p->pppoe.ether.sa, &d->ether.src_addr);
d->ether.ether_type = rte_htons(RTE_ETHER_TYPE_PPPOE_SESSION); d->ether.ether_type = rte_htons(RTE_ETHER_TYPE_PPPOE_SESSION);
/* PPPoE and PPP*/ /* PPPoE and PPP*/
@ -777,9 +777,9 @@ encap_vxlan_apply(void *data,
/* Ethernet */ /* Ethernet */
rte_ether_addr_copy(&p->vxlan.ether.da, rte_ether_addr_copy(&p->vxlan.ether.da,
&d->ether.d_addr); &d->ether.dst_addr);
rte_ether_addr_copy(&p->vxlan.ether.sa, rte_ether_addr_copy(&p->vxlan.ether.sa,
&d->ether.s_addr); &d->ether.src_addr);
d->ether.ether_type = rte_htons(RTE_ETHER_TYPE_VLAN); d->ether.ether_type = rte_htons(RTE_ETHER_TYPE_VLAN);
/* VLAN */ /* VLAN */
@ -818,9 +818,9 @@ encap_vxlan_apply(void *data,
/* Ethernet */ /* Ethernet */
rte_ether_addr_copy(&p->vxlan.ether.da, rte_ether_addr_copy(&p->vxlan.ether.da,
&d->ether.d_addr); &d->ether.dst_addr);
rte_ether_addr_copy(&p->vxlan.ether.sa, rte_ether_addr_copy(&p->vxlan.ether.sa,
&d->ether.s_addr); &d->ether.src_addr);
d->ether.ether_type = rte_htons(RTE_ETHER_TYPE_IPV4); d->ether.ether_type = rte_htons(RTE_ETHER_TYPE_IPV4);
/* IPv4*/ /* IPv4*/
@ -855,9 +855,9 @@ encap_vxlan_apply(void *data,
/* Ethernet */ /* Ethernet */
rte_ether_addr_copy(&p->vxlan.ether.da, rte_ether_addr_copy(&p->vxlan.ether.da,
&d->ether.d_addr); &d->ether.dst_addr);
rte_ether_addr_copy(&p->vxlan.ether.sa, rte_ether_addr_copy(&p->vxlan.ether.sa,
&d->ether.s_addr); &d->ether.src_addr);
d->ether.ether_type = rte_htons(RTE_ETHER_TYPE_VLAN); d->ether.ether_type = rte_htons(RTE_ETHER_TYPE_VLAN);
/* VLAN */ /* VLAN */
@ -896,9 +896,9 @@ encap_vxlan_apply(void *data,
/* Ethernet */ /* Ethernet */
rte_ether_addr_copy(&p->vxlan.ether.da, rte_ether_addr_copy(&p->vxlan.ether.da,
&d->ether.d_addr); &d->ether.dst_addr);
rte_ether_addr_copy(&p->vxlan.ether.sa, rte_ether_addr_copy(&p->vxlan.ether.sa,
&d->ether.s_addr); &d->ether.src_addr);
d->ether.ether_type = rte_htons(RTE_ETHER_TYPE_IPV6); d->ether.ether_type = rte_htons(RTE_ETHER_TYPE_IPV6);
/* IPv6*/ /* IPv6*/