net: rename Ethernet header fields

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>

diff --git a/app/test-pmd/5tswap.c b/app/test-pmd/5tswap.c
index e8cef96..629d3e0 100644 (file)
--- a/app/test-pmd/5tswap.c
+++ b/app/test-pmd/5tswap.c
@@ -27,9 +27,9 @@ swap_mac(struct rte_ether_hdr *eth_hdr)
        struct rte_ether_addr addr;
 
        /* Swap dest and src mac addresses. */
-       rte_ether_addr_copy(&eth_hdr->d_addr, &addr);
-       rte_ether_addr_copy(&eth_hdr->s_addr, &eth_hdr->d_addr);
-       rte_ether_addr_copy(&addr, &eth_hdr->s_addr);
+       rte_ether_addr_copy(&eth_hdr->dst_addr, &addr);
+       rte_ether_addr_copy(&eth_hdr->src_addr, &eth_hdr->dst_addr);
+       rte_ether_addr_copy(&addr, &eth_hdr->src_addr);
 }
 
 static inline void

diff --git a/app/test-pmd/csumonly.c b/app/test-pmd/csumonly.c
index 38cc256..0907973 100644 (file)
--- a/app/test-pmd/csumonly.c
+++ b/app/test-pmd/csumonly.c
@@ -873,9 +873,9 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 
                eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
                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,
-                               &eth_hdr->s_addr);
+                               &eth_hdr->src_addr);
                parse_ethernet(eth_hdr, &info);
                l3_hdr = (char *)eth_hdr + info.l2_len;
 

diff --git a/app/test-pmd/flowgen.c b/app/test-pmd/flowgen.c
index 0d3664a..a96169e 100644 (file)
--- a/app/test-pmd/flowgen.c
+++ b/app/test-pmd/flowgen.c
@@ -122,8 +122,8 @@ pkt_burst_flow_gen(struct fwd_stream *fs)
 
                        /* Initialize Ethernet header. */
                        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_src, &eth_hdr->s_addr);
+                       rte_ether_addr_copy(&cfg_ether_dst, &eth_hdr->dst_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);
 
                        /* Initialize IP header. */

diff --git a/app/test-pmd/icmpecho.c b/app/test-pmd/icmpecho.c
index 8948f28..8f1d68a 100644 (file)
--- a/app/test-pmd/icmpecho.c
+++ b/app/test-pmd/icmpecho.c
@@ -319,8 +319,8 @@ reply_to_icmp_echo_rqsts(struct fwd_stream *fs)
                if (verbose_level > 0) {
                        printf("\nPort %d pkt-len=%u nb-segs=%u\n",
                               fs->rx_port, pkt->pkt_len, pkt->nb_segs);
-                       ether_addr_dump("  ETH:  src=", &eth_h->s_addr);
-                       ether_addr_dump(" dst=", &eth_h->d_addr);
+                       ether_addr_dump("  ETH:  src=", &eth_h->src_addr);
+                       ether_addr_dump(" dst=", &eth_h->dst_addr);
                }
                if (eth_type == RTE_ETHER_TYPE_VLAN) {
                        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. */
-                       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 */
                        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);
                        rte_ether_addr_copy(&arp_h->arp_data.arp_tha,
                                        &eth_addr);
                        rte_ether_addr_copy(&arp_h->arp_data.arp_sha,
                                        &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);
 
                        /* 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
                 * echo request and not verified.
                 */
-               rte_ether_addr_copy(&eth_h->s_addr, &eth_addr);
-               rte_ether_addr_copy(&eth_h->d_addr, &eth_h->s_addr);
-               rte_ether_addr_copy(&eth_addr, &eth_h->d_addr);
+               rte_ether_addr_copy(&eth_h->src_addr, &eth_addr);
+               rte_ether_addr_copy(&eth_h->dst_addr, &eth_h->src_addr);
+               rte_ether_addr_copy(&eth_addr, &eth_h->dst_addr);
                ip_addr = ip_h->src_addr;
                if (is_multicast_ipv4_addr(ip_h->dst_addr)) {
                        uint32_t ip_src;

diff --git a/app/test-pmd/ieee1588fwd.c b/app/test-pmd/ieee1588fwd.c
index 034f238..9cf10c1 100644 (file)
--- a/app/test-pmd/ieee1588fwd.c
+++ b/app/test-pmd/ieee1588fwd.c
@@ -178,9 +178,9 @@ ieee1588_packet_fwd(struct fwd_stream *fs)
        port_ieee1588_rx_timestamp_check(fs->rx_port, timesync_index);
 
        /* Swap dest and src mac addresses. */
-       rte_ether_addr_copy(&eth_hdr->d_addr, &addr);
-       rte_ether_addr_copy(&eth_hdr->s_addr, &eth_hdr->d_addr);
-       rte_ether_addr_copy(&addr, &eth_hdr->s_addr);
+       rte_ether_addr_copy(&eth_hdr->dst_addr, &addr);
+       rte_ether_addr_copy(&eth_hdr->src_addr, &eth_hdr->dst_addr);
+       rte_ether_addr_copy(&addr, &eth_hdr->src_addr);
 
        /* Forward PTP packet with hardware TX timestamp */
        mb->ol_flags |= PKT_TX_IEEE1588_TMST;

diff --git a/app/test-pmd/macfwd.c b/app/test-pmd/macfwd.c
index 0568ea7..ee76df7 100644 (file)
--- a/app/test-pmd/macfwd.c
+++ b/app/test-pmd/macfwd.c
@@ -85,9 +85,9 @@ pkt_burst_mac_forward(struct fwd_stream *fs)
                mb = pkts_burst[i];
                eth_hdr = rte_pktmbuf_mtod(mb, struct rte_ether_hdr *);
                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,
-                               &eth_hdr->s_addr);
+                               &eth_hdr->src_addr);
                mb->ol_flags &= IND_ATTACHED_MBUF | EXT_ATTACHED_MBUF;
                mb->ol_flags |= ol_flags;
                mb->l2_len = sizeof(struct rte_ether_hdr);

diff --git a/app/test-pmd/macswap.h b/app/test-pmd/macswap.h
index 0138441..29c252b 100644 (file)
--- a/app/test-pmd/macswap.h
+++ b/app/test-pmd/macswap.h
@@ -29,9 +29,9 @@ do_macswap(struct rte_mbuf *pkts[], uint16_t nb,
                eth_hdr = rte_pktmbuf_mtod(mb, struct rte_ether_hdr *);
 
                /* Swap dest and src mac addresses. */
-               rte_ether_addr_copy(&eth_hdr->d_addr, &addr);
-               rte_ether_addr_copy(&eth_hdr->s_addr, &eth_hdr->d_addr);
-               rte_ether_addr_copy(&addr, &eth_hdr->s_addr);
+               rte_ether_addr_copy(&eth_hdr->dst_addr, &addr);
+               rte_ether_addr_copy(&eth_hdr->src_addr, &eth_hdr->dst_addr);
+               rte_ether_addr_copy(&addr, &eth_hdr->src_addr);
 
                mbuf_field_set(mb, ol_flags);
        }

diff --git a/app/test-pmd/txonly.c b/app/test-pmd/txonly.c
index aed820f..4065580 100644 (file)
--- a/app/test-pmd/txonly.c
+++ b/app/test-pmd/txonly.c
@@ -362,8 +362,8 @@ pkt_burst_transmit(struct fwd_stream *fs)
        /*
         * Initialize Ethernet header.
         */
-       rte_ether_addr_copy(&peer_eth_addrs[fs->peer_addr], &eth_hdr.d_addr);
-       rte_ether_addr_copy(&ports[fs->tx_port].eth_addr, &eth_hdr.s_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.src_addr);
        eth_hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
 
        if (rte_mempool_get_bulk(mbp, (void **)pkts_burst,

diff --git a/app/test-pmd/util.c b/app/test-pmd/util.c
index 14a9a25..51506e4 100644 (file)
--- a/app/test-pmd/util.c
+++ b/app/test-pmd/util.c
@@ -142,9 +142,9 @@ dump_pkt_burst(uint16_t port_id, uint16_t queue, struct rte_mbuf *pkts[],
                                          " - no miss group");
                        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_ether_addr(" - dst=", &eth_hdr->d_addr,
+               print_ether_addr(" - dst=", &eth_hdr->dst_addr,
                                 print_buf, buf_size, &cur_len);
                MKDUMPSTR(print_buf, buf_size, cur_len,
                          " - type=0x%04x - length=%u - nb_segs=%d",

diff --git a/app/test/packet_burst_generator.c b/app/test/packet_burst_generator.c
index 0fd7290..8ac2457 100644 (file)
--- a/app/test/packet_burst_generator.c
+++ b/app/test/packet_burst_generator.c
@@ -56,8 +56,8 @@ initialize_eth_header(struct rte_ether_hdr *eth_hdr,
                struct rte_ether_addr *dst_mac, uint16_t ether_type,
                uint8_t vlan_enabled, uint16_t van_id)
 {
-       rte_ether_addr_copy(dst_mac, &eth_hdr->d_addr);
-       rte_ether_addr_copy(src_mac, &eth_hdr->s_addr);
+       rte_ether_addr_copy(dst_mac, &eth_hdr->dst_addr);
+       rte_ether_addr_copy(src_mac, &eth_hdr->src_addr);
 
        if (vlan_enabled) {
                struct rte_vlan_hdr *vhdr = (struct rte_vlan_hdr *)(

diff --git a/app/test/test_bpf.c b/app/test/test_bpf.c
index 527c06b..8118a18 100644 (file)
--- a/app/test/test_bpf.c
+++ b/app/test/test_bpf.c
@@ -1008,9 +1008,9 @@ test_jump2_prepare(void *arg)
         * Initialize ether header.
         */
        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,
-                           &dn->eth_hdr.s_addr);
+                           &dn->eth_hdr.src_addr);
        dn->eth_hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
 
        /*

diff --git a/app/test/test_link_bonding_mode4.c b/app/test/test_link_bonding_mode4.c
index 2c835fa..f120b2e 100644 (file)
--- a/app/test/test_link_bonding_mode4.c
+++ b/app/test/test_link_bonding_mode4.c
@@ -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 *);
 
        /* Change source address to partner address */
-       rte_ether_addr_copy(&parnter_mac_default, &slow_hdr->eth_hdr.s_addr);
-       slow_hdr->eth_hdr.s_addr.addr_bytes[RTE_ETHER_ADDR_LEN - 1] =
+       rte_ether_addr_copy(&parnter_mac_default, &slow_hdr->eth_hdr.src_addr);
+       slow_hdr->eth_hdr.src_addr.addr_bytes[RTE_ETHER_ADDR_LEN - 1] =
                slave->port_id;
 
        lacp = (struct lacpdu *) &slow_hdr->slow_protocol;
@@ -870,7 +870,7 @@ test_mode4_rx(void)
 
                for (i = 0; i < expected_pkts_cnt; i++) {
                        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)]++;
                }
 
@@ -918,7 +918,7 @@ test_mode4_rx(void)
 
                for (i = 0; i < expected_pkts_cnt; i++) {
                        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);
                }
 
@@ -1163,11 +1163,12 @@ init_marker(struct rte_mbuf *pkt, struct slave_conf *slave)
 
        /* Copy multicast destination address */
        rte_ether_addr_copy(&slow_protocol_mac_addr,
-                       &marker_hdr->eth_hdr.d_addr);
+                       &marker_hdr->eth_hdr.dst_addr);
 
        /* Init source address */
-       rte_ether_addr_copy(&parnter_mac_default, &marker_hdr->eth_hdr.s_addr);
-       marker_hdr->eth_hdr.s_addr.addr_bytes[RTE_ETHER_ADDR_LEN - 1] =
+       rte_ether_addr_copy(&parnter_mac_default,
+                       &marker_hdr->eth_hdr.src_addr);
+       marker_hdr->eth_hdr.src_addr.addr_bytes[RTE_ETHER_ADDR_LEN - 1] =
                slave->port_id;
 
        marker_hdr->eth_hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_SLOW);

diff --git a/doc/guides/rel_notes/deprecation.rst b/doc/guides/rel_notes/deprecation.rst
index a2fe766..6530c6f 100644 (file)
--- a/doc/guides/rel_notes/deprecation.rst
+++ b/doc/guides/rel_notes/deprecation.rst
@@ -164,9 +164,6 @@ Deprecation Notices
   consistent with existing outer header checksum status flag naming, which
   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.
   The first union is for existing ``version_ihl`` byte
   and new bitfield for version and IHL.

diff --git a/doc/guides/rel_notes/release_21_11.rst b/doc/guides/rel_notes/release_21_11.rst
index efeffe3..c0a7f75 100644 (file)
--- a/doc/guides/rel_notes/release_21_11.rst
+++ b/doc/guides/rel_notes/release_21_11.rst
@@ -178,6 +178,9 @@ API Changes
   removed. Its usages have been replaced by a new function
   ``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
   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.

diff --git a/drivers/net/avp/avp_ethdev.c b/drivers/net/avp/avp_ethdev.c
index 623fa5e..b5fafd3 100644 (file)
--- a/drivers/net/avp/avp_ethdev.c
+++ b/drivers/net/avp/avp_ethdev.c
@@ -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 *);
 
-       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 */
                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 */
                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 */
                return 0;
        }

diff --git a/drivers/net/bnx2x/bnx2x.c b/drivers/net/bnx2x/bnx2x.c
index 9163b8b..083deff 100644 (file)
--- a/drivers/net/bnx2x/bnx2x.c
+++ b/drivers/net/bnx2x/bnx2x.c
@@ -2233,8 +2233,8 @@ int bnx2x_tx_encap(struct bnx2x_tx_queue *txq, struct rte_mbuf *m0)
 
                tx_parse_bd =
                    &txq->tx_ring[TX_BD(bd_prod, txq)].parse_bd_e2;
-               if (rte_is_multicast_ether_addr(&eh->d_addr)) {
-                       if (rte_is_broadcast_ether_addr(&eh->d_addr))
+               if (rte_is_multicast_ether_addr(&eh->dst_addr)) {
+                       if (rte_is_broadcast_ether_addr(&eh->dst_addr))
                                mac_type = BROADCAST_ADDRESS;
                        else
                                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);
 
                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,
-                          &eh->d_addr.addr_bytes[2], 2);
+                          &eh->dst_addr.addr_bytes[2], 2);
                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,
-                          &eh->s_addr.addr_bytes[0], 2);
+                          &eh->src_addr.addr_bytes[0], 2);
                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,
-                          &eh->s_addr.addr_bytes[4], 2);
+                          &eh->src_addr.addr_bytes[4], 2);
 
                tx_parse_bd->data.mac_addr.dst_hi =
                    rte_cpu_to_be_16(tx_parse_bd->data.mac_addr.dst_hi);

diff --git a/drivers/net/bonding/rte_eth_bond_8023ad.c b/drivers/net/bonding/rte_eth_bond_8023ad.c
index 8b5b32f..3558644 100644 (file)
--- a/drivers/net/bonding/rte_eth_bond_8023ad.c
+++ b/drivers/net/bonding/rte_eth_bond_8023ad.c
@@ -587,8 +587,8 @@ tx_machine(struct bond_dev_private *internals, uint16_t slave_id)
        hdr = rte_pktmbuf_mtod(lacp_pkt, struct lacpdu_header *);
 
        /* Source and destination MAC */
-       rte_ether_addr_copy(&lacp_mac_addr, &hdr->eth_hdr.d_addr);
-       rte_eth_macaddr_get(slave_id, &hdr->eth_hdr.s_addr);
+       rte_ether_addr_copy(&lacp_mac_addr, &hdr->eth_hdr.dst_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);
 
        lacpdu = &hdr->lacpdu;
@@ -1346,7 +1346,7 @@ bond_mode_8023ad_handle_slow_pkt(struct bond_dev_private *internals,
                } while (unlikely(retval == 0));
 
                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 (rte_ring_enqueue(port->tx_ring, pkt) != 0) {

diff --git a/drivers/net/bonding/rte_eth_bond_alb.c b/drivers/net/bonding/rte_eth_bond_alb.c
index 1d36a4a..86335a7 100644 (file)
--- a/drivers/net/bonding/rte_eth_bond_alb.c
+++ b/drivers/net/bonding/rte_eth_bond_alb.c
@@ -213,8 +213,8 @@ bond_mode_alb_arp_upd(struct client_data *client_info,
        rte_spinlock_lock(&internals->mode6.lock);
        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->cli_mac, &eth_h->d_addr);
+       rte_ether_addr_copy(&client_info->app_mac, &eth_h->src_addr);
+       rte_ether_addr_copy(&client_info->cli_mac, &eth_h->dst_addr);
        if (client_info->vlan_count > 0)
                eth_h->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
        else

diff --git a/drivers/net/bonding/rte_eth_bond_pmd.c b/drivers/net/bonding/rte_eth_bond_pmd.c
index 54987d9..6831fcb 100644 (file)
--- a/drivers/net/bonding/rte_eth_bond_pmd.c
+++ b/drivers/net/bonding/rte_eth_bond_pmd.c
@@ -342,11 +342,11 @@ rx_burst_8023ad(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts,
                                                 bufs[j])) ||
                                !collecting ||
                                (!promisc &&
-                                ((rte_is_unicast_ether_addr(&hdr->d_addr) &&
+                                ((rte_is_unicast_ether_addr(&hdr->dst_addr) &&
                                   !rte_is_same_ether_addr(bond_mac,
-                                                      &hdr->d_addr)) ||
+                                                      &hdr->dst_addr)) ||
                                  (!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) {
                                        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", \
                info,                                                   \
                port,                                                   \
-               RTE_ETHER_ADDR_BYTES(&eth_h->s_addr),                  \
+               RTE_ETHER_ADDR_BYTES(&eth_h->src_addr),                  \
                src_ip,                                                 \
-               RTE_ETHER_ADDR_BYTES(&eth_h->d_addr),                  \
+               RTE_ETHER_ADDR_BYTES(&eth_h->dst_addr),                  \
                dst_ip,                                                 \
                arp_op, ++burstnumber)
 #endif
@@ -643,9 +643,9 @@ static inline uint16_t
 ether_hash(struct rte_ether_hdr *eth_hdr)
 {
        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 *)eth_hdr->d_addr.addr_bytes;
+               (unaligned_uint16_t *)eth_hdr->dst_addr.addr_bytes;
 
        return (word_src_addr[0] ^ word_dst_addr[0]) ^
                        (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],
                                                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))
                                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)
                                        mode6_debug("TX IPv4:", ether_hdr, slaves[i], &burstnumberTX);
 #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);
 
                        /* 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 */
                        slave_bufs[slave_idx][slave_bufs_pkts[slave_idx]] = bufs[i];

diff --git a/drivers/net/enic/enic_flow.c b/drivers/net/enic/enic_flow.c
index cdfdc90..3314716 100644 (file)
--- a/drivers/net/enic/enic_flow.c
+++ b/drivers/net/enic/enic_flow.c
@@ -656,14 +656,14 @@ enic_copy_item_eth_v2(struct copy_item_args *arg)
        if (!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);
-       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);
 
-       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);
-       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);
        enic_spec.ether_type = spec->type;
        enic_mask.ether_type = mask->type;

diff --git a/drivers/net/mlx5/mlx5_txpp.c b/drivers/net/mlx5/mlx5_txpp.c
index 4f6da9f..2be7e71 100644 (file)
--- a/drivers/net/mlx5/mlx5_txpp.c
+++ b/drivers/net/mlx5/mlx5_txpp.c
@@ -333,8 +333,8 @@ mlx5_txpp_fill_wqe_clock_queue(struct mlx5_dev_ctx_shared *sh)
                /* Build test packet L2 header (Ethernet). */
                dst = (uint8_t *)&es->inline_data;
                eth_hdr = (struct rte_ether_hdr *)dst;
-               rte_eth_random_addr(&eth_hdr->d_addr.addr_bytes[0]);
-               rte_eth_random_addr(&eth_hdr->s_addr.addr_bytes[0]);
+               rte_eth_random_addr(&eth_hdr->dst_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);
                /* Build test packet L3 header (IP v4). */
                dst += sizeof(struct rte_ether_hdr);

diff --git a/examples/bond/main.c b/examples/bond/main.c
index a63ca70..7adaa93 100644 (file)
--- a/examples/bond/main.c
+++ b/examples/bond/main.c
@@ -358,7 +358,7 @@ struct global_flag_stru_t *global_flag_stru_p = &global_flag_stru;
 static int lcore_main(__rte_unused void *arg1)
 {
        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_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)) {
                                                arp_hdr->arp_opcode = rte_cpu_to_be_16(RTE_ARP_OP_REPLY);
                                                /* 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(&bond_mac_addr, &eth_hdr->s_addr);
+                                               rte_ether_addr_copy(&eth_hdr->src_addr, &eth_hdr->dst_addr);
+                                               rte_ether_addr_copy(&bond_mac_addr, &eth_hdr->src_addr);
                                                rte_ether_addr_copy(&arp_hdr->arp_data.arp_sha,
                                                                &arp_hdr->arp_data.arp_tha);
                                                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(&d_addr, &arp_hdr->arp_data.arp_sha);
+                                               rte_ether_addr_copy(&bond_mac_addr, &dst_addr);
+                                               rte_ether_addr_copy(&dst_addr, &arp_hdr->arp_data.arp_sha);
                                                arp_hdr->arp_data.arp_sip = bond_ip;
                                                rte_eth_tx_burst(BOND_PORT, 0, &pkts[i], 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);
                                if (ipv4_hdr->dst_addr == bond_ip) {
-                                       rte_ether_addr_copy(&eth_hdr->s_addr, &eth_hdr->d_addr);
-                                       rte_ether_addr_copy(&bond_mac_addr, &eth_hdr->s_addr);
+                                       rte_ether_addr_copy(&eth_hdr->src_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->src_addr = bond_ip;
                                        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;
 
        eth_hdr = rte_pktmbuf_mtod(created_pkt, struct rte_ether_hdr *);
-       rte_ether_addr_copy(&bond_mac_addr, &eth_hdr->s_addr);
-       memset(&eth_hdr->d_addr, 0xFF, RTE_ETHER_ADDR_LEN);
+       rte_ether_addr_copy(&bond_mac_addr, &eth_hdr->src_addr);
+       memset(&eth_hdr->dst_addr, 0xFF, RTE_ETHER_ADDR_LEN);
        eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_ARP);
 
        arp_hdr = (struct rte_arp_hdr *)(

diff --git a/examples/ethtool/ethtool-app/main.c b/examples/ethtool/ethtool-app/main.c
index 21ed85c..1bc6759 100644 (file)
--- a/examples/ethtool/ethtool-app/main.c
+++ b/examples/ethtool/ethtool-app/main.c
@@ -172,8 +172,8 @@ static void process_frame(struct app_port *ptr_port,
        struct rte_ether_hdr *ptr_mac_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_port->mac_addr, &ptr_mac_hdr->s_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->src_addr);
 }
 
 static int worker_main(__rte_unused void *ptr_data)

diff --git a/examples/eventdev_pipeline/pipeline_common.h b/examples/eventdev_pipeline/pipeline_common.h
index 6a42876..b12eb28 100644 (file)
--- a/examples/eventdev_pipeline/pipeline_common.h
+++ b/examples/eventdev_pipeline/pipeline_common.h
@@ -104,8 +104,8 @@ exchange_mac(struct rte_mbuf *m)
 
        /* change mac addresses on packet (to use mbuf data) */
        eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
-       rte_ether_addr_copy(&eth->d_addr, &addr);
-       rte_ether_addr_copy(&addr, &eth->d_addr);
+       rte_ether_addr_copy(&eth->dst_addr, &addr);
+       rte_ether_addr_copy(&addr, &eth->dst_addr);
 }
 
 static __rte_always_inline void

diff --git a/examples/flow_filtering/main.c b/examples/flow_filtering/main.c
index 29fb4b3..dd8a33d 100644 (file)
--- a/examples/flow_filtering/main.c
+++ b/examples/flow_filtering/main.c
@@ -75,9 +75,9 @@ main_loop(void)
                                        eth_hdr = rte_pktmbuf_mtod(m,
                                                        struct rte_ether_hdr *);
                                        print_ether_addr("src=",
-                                                       &eth_hdr->s_addr);
+                                                       &eth_hdr->src_addr);
                                        print_ether_addr(" - dst=",
-                                                       &eth_hdr->d_addr);
+                                                       &eth_hdr->dst_addr);
                                        printf(" - queue=0x%x",
                                                        (unsigned int)i);
                                        printf("\n");

diff --git a/examples/ioat/ioatfwd.c b/examples/ioat/ioatfwd.c
index b3977a8..ff36aa7 100644 (file)
--- a/examples/ioat/ioatfwd.c
+++ b/examples/ioat/ioatfwd.c
@@ -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
         * 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);
 
        /* 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< */

diff --git a/examples/ip_fragmentation/main.c b/examples/ip_fragmentation/main.c
index f245369..a7f4097 100644 (file)
--- a/examples/ip_fragmentation/main.c
+++ b/examples/ip_fragmentation/main.c
@@ -362,13 +362,13 @@ l3fwd_simple_forward(struct rte_mbuf *m, struct lcore_queue_conf *qconf,
                m->l2_len = sizeof(struct rte_ether_hdr);
 
                /* 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)port_out << 40);
 
                /* src addr */
                rte_ether_addr_copy(&ports_eth_addr[port_out],
-                               &eth_hdr->s_addr);
+                               &eth_hdr->src_addr);
                eth_hdr->ether_type = ether_type;
        }
 

diff --git a/examples/ip_reassembly/main.c b/examples/ip_reassembly/main.c
index 8645ac7..d611c7d 100644 (file)
--- a/examples/ip_reassembly/main.c
+++ b/examples/ip_reassembly/main.c
@@ -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 */
 
        /* 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);
 
        /* 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);
 }

diff --git a/examples/ipsec-secgw/ipsec-secgw.c b/examples/ipsec-secgw/ipsec-secgw.c
index 7ad94cb..7b01872 100644 (file)
--- a/examples/ipsec-secgw/ipsec-secgw.c
+++ b/examples/ipsec-secgw/ipsec-secgw.c
@@ -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);
        }
 
-       memcpy(&ethhdr->s_addr, &ethaddr_tbl[port].src,
+       memcpy(&ethhdr->src_addr, &ethaddr_tbl[port].src,
                        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));
 }
 

diff --git a/examples/ipsec-secgw/ipsec_worker.c b/examples/ipsec-secgw/ipsec_worker.c
index c545497..61cf9f5 100644 (file)
--- a/examples/ipsec-secgw/ipsec_worker.c
+++ b/examples/ipsec-secgw/ipsec_worker.c
@@ -49,8 +49,8 @@ update_mac_addrs(struct rte_mbuf *pkt, uint16_t portid)
        struct rte_ether_hdr *ethhdr;
 
        ethhdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
-       memcpy(&ethhdr->s_addr, &ethaddr_tbl[portid].src, RTE_ETHER_ADDR_LEN);
-       memcpy(&ethhdr->d_addr, &ethaddr_tbl[portid].dst, RTE_ETHER_ADDR_LEN);
+       memcpy(&ethhdr->src_addr, &ethaddr_tbl[portid].src, RTE_ETHER_ADDR_LEN);
+       memcpy(&ethhdr->dst_addr, &ethaddr_tbl[portid].dst, RTE_ETHER_ADDR_LEN);
 }
 
 static inline void

diff --git a/examples/ipv4_multicast/main.c b/examples/ipv4_multicast/main.c
index cc527d7..d10de30 100644 (file)
--- a/examples/ipv4_multicast/main.c
+++ b/examples/ipv4_multicast/main.c
@@ -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_ASSERT(ethdr != NULL);
 
-       rte_ether_addr_copy(dest_addr, &ethdr->d_addr);
-       rte_ether_addr_copy(&ports_eth_addr[port], &ethdr->s_addr);
+       rte_ether_addr_copy(dest_addr, &ethdr->dst_addr);
+       rte_ether_addr_copy(&ports_eth_addr[port], &ethdr->src_addr);
        ethdr->ether_type = rte_be_to_cpu_16(RTE_ETHER_TYPE_IPV4);
 
        /* Put new packet into the output queue */

diff --git a/examples/l2fwd-crypto/main.c b/examples/l2fwd-crypto/main.c
index 66d1491..c2ffbdd 100644 (file)
--- a/examples/l2fwd-crypto/main.c
+++ b/examples/l2fwd-crypto/main.c
@@ -617,11 +617,11 @@ l2fwd_mac_updating(struct rte_mbuf *m, uint16_t dest_portid)
        eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        /* 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);
 
        /* 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

diff --git a/examples/l2fwd-event/l2fwd_common.h b/examples/l2fwd-event/l2fwd_common.h
index 939221d..cecbd9b 100644 (file)
--- a/examples/l2fwd-event/l2fwd_common.h
+++ b/examples/l2fwd-event/l2fwd_common.h
@@ -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 *);
 
        /* 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);
 
        /* 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 *

diff --git a/examples/l2fwd-jobstats/main.c b/examples/l2fwd-jobstats/main.c
index afe7fe6..0628032 100644 (file)
--- a/examples/l2fwd-jobstats/main.c
+++ b/examples/l2fwd-jobstats/main.c
@@ -351,11 +351,11 @@ l2fwd_simple_forward(struct rte_mbuf *m, unsigned portid)
        eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        /* 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);
 
        /* 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];
        sent = rte_eth_tx_buffer(dst_port, 0, buffer, m);

diff --git a/examples/l2fwd-keepalive/main.c b/examples/l2fwd-keepalive/main.c
index d0d979f..07271af 100644 (file)
--- a/examples/l2fwd-keepalive/main.c
+++ b/examples/l2fwd-keepalive/main.c
@@ -177,11 +177,11 @@ l2fwd_simple_forward(struct rte_mbuf *m, unsigned portid)
        eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        /* 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);
 
        /* 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];
        sent = rte_eth_tx_buffer(dst_port, 0, buffer, m);

diff --git a/examples/l2fwd/main.c b/examples/l2fwd/main.c
index 0553255..f3deeba 100644 (file)
--- a/examples/l2fwd/main.c
+++ b/examples/l2fwd/main.c
@@ -170,11 +170,11 @@ l2fwd_mac_updating(struct rte_mbuf *m, unsigned dest_portid)
        eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        /* 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);
 
        /* 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< */

diff --git a/examples/l3fwd-acl/main.c b/examples/l3fwd-acl/main.c
index a1f457b..60545f3 100644 (file)
--- a/examples/l3fwd-acl/main.c
+++ b/examples/l3fwd-acl/main.c
@@ -1375,7 +1375,8 @@ send_single_packet(struct rte_mbuf *m, uint16_t port)
 
        /* update src and dst mac*/
        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];
        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("
                        RTE_STR(RTE_MAX_ETHPORTS) ")";
 
-       if (cmdline_parse_etheraddr(NULL, port_end, &port_l2hdr[portid].d_addr,
-                       sizeof(port_l2hdr[portid].d_addr)) < 0)
+       if (cmdline_parse_etheraddr(NULL, port_end,
+                       &port_l2hdr[portid].dst_addr,
+                       sizeof(port_l2hdr[portid].dst_addr)) < 0)
                return "Invalid ethernet address";
        return NULL;
 }
@@ -2002,8 +2004,9 @@ set_default_dest_mac(void)
        uint32_t 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].d_addr.addr_bytes[5] = i;
+               port_l2hdr[i].dst_addr.addr_bytes[0] =
+                               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",
                                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)
                        rte_exit(EXIT_FAILURE,
                                "rte_eth_macaddr_get: err=%d, port=%d\n",
                                ret, portid);
 
-               print_ethaddr("Dst MAC:", &port_l2hdr[portid].d_addr);
-               print_ethaddr(", Src MAC:", &port_l2hdr[portid].s_addr);
+               print_ethaddr("Dst MAC:", &port_l2hdr[portid].dst_addr);
+               print_ethaddr(", Src MAC:", &port_l2hdr[portid].src_addr);
                printf(", ");
 
                /* init memory */

diff --git a/examples/l3fwd-power/main.c b/examples/l3fwd-power/main.c
index aa7b8db..73a3ab5 100644 (file)
--- a/examples/l3fwd-power/main.c
+++ b/examples/l3fwd-power/main.c
@@ -717,7 +717,7 @@ l3fwd_simple_forward(struct rte_mbuf *m, uint16_t portid,
                        dst_port = portid;
 
                /* 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);
 
@@ -729,7 +729,7 @@ l3fwd_simple_forward(struct rte_mbuf *m, uint16_t portid,
 
                /* src addr */
                rte_ether_addr_copy(&ports_eth_addr[dst_port],
-                               &eth_hdr->s_addr);
+                               &eth_hdr->src_addr);
 
                send_single_packet(m, dst_port);
        } 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;
 
                /* 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);
 
                /* src addr */
                rte_ether_addr_copy(&ports_eth_addr[dst_port],
-                               &eth_hdr->s_addr);
+                               &eth_hdr->src_addr);
 
                send_single_packet(m, dst_port);
 #else

diff --git a/examples/l3fwd/l3fwd_em.h b/examples/l3fwd/l3fwd_em.h
index b992a21..e67f5f3 100644 (file)
--- a/examples/l3fwd/l3fwd_em.h
+++ b/examples/l3fwd/l3fwd_em.h
@@ -36,11 +36,11 @@ l3fwd_em_handle_ipv4(struct rte_mbuf *m, uint16_t portid,
        ++(ipv4_hdr->hdr_checksum);
 #endif
        /* 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 */
        rte_ether_addr_copy(&ports_eth_addr[dst_port],
-                       &eth_hdr->s_addr);
+                       &eth_hdr->src_addr);
 
        return dst_port;
 }
@@ -64,11 +64,11 @@ l3fwd_em_handle_ipv6(struct rte_mbuf *m, uint16_t portid,
                dst_port = portid;
 
        /* 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 */
        rte_ether_addr_copy(&ports_eth_addr[dst_port],
-                       &eth_hdr->s_addr);
+                       &eth_hdr->src_addr);
 
        return dst_port;
 }

diff --git a/examples/l3fwd/l3fwd_fib.c b/examples/l3fwd/l3fwd_fib.c
index f8d6a3a..7fd7c1d 100644 (file)
--- a/examples/l3fwd/l3fwd_fib.c
+++ b/examples/l3fwd/l3fwd_fib.c
@@ -92,9 +92,9 @@ fib_send_single(int nb_tx, struct lcore_conf *qconf,
                /* Set MAC addresses. */
                eth_hdr = rte_pktmbuf_mtod(pkts_burst[j],
                                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]],
-                               &eth_hdr->s_addr);
+                               &eth_hdr->src_addr);
 
                /* Send single packet. */
                send_single_packet(qconf, pkts_burst[j], hops[j]);

diff --git a/examples/l3fwd/l3fwd_lpm.c b/examples/l3fwd/l3fwd_lpm.c
index 7200160..232b606 100644 (file)
--- a/examples/l3fwd/l3fwd_lpm.c
+++ b/examples/l3fwd/l3fwd_lpm.c
@@ -256,11 +256,11 @@ lpm_process_event_pkt(const struct lcore_conf *lconf, struct rte_mbuf *mbuf)
        }
 #endif
        /* 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 */
        rte_ether_addr_copy(&ports_eth_addr[mbuf->port],
-                       &eth_hdr->s_addr);
+                       &eth_hdr->src_addr);
 #endif
        return mbuf->port;
 }

diff --git a/examples/l3fwd/l3fwd_lpm.h b/examples/l3fwd/l3fwd_lpm.h
index d730d72..c61b969 100644 (file)
--- a/examples/l3fwd/l3fwd_lpm.h
+++ b/examples/l3fwd/l3fwd_lpm.h
@@ -40,11 +40,11 @@ l3fwd_lpm_simple_forward(struct rte_mbuf *m, uint16_t portid,
                ++(ipv4_hdr->hdr_checksum);
 #endif
                /* 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 */
                rte_ether_addr_copy(&ports_eth_addr[dst_port],
-                               &eth_hdr->s_addr);
+                               &eth_hdr->src_addr);
 
                send_single_packet(qconf, m, dst_port);
        } 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 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 */
                rte_ether_addr_copy(&ports_eth_addr[dst_port],
-                               &eth_hdr->s_addr);
+                               &eth_hdr->src_addr);
 
                send_single_packet(qconf, m, dst_port);
        } else {

diff --git a/examples/link_status_interrupt/main.c b/examples/link_status_interrupt/main.c
index a0bc1e5..e4542df 100644 (file)
--- a/examples/link_status_interrupt/main.c
+++ b/examples/link_status_interrupt/main.c
@@ -182,11 +182,11 @@ lsi_simple_forward(struct rte_mbuf *m, unsigned portid)
        eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        /* 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);
 
        /* 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];
        sent = rte_eth_tx_buffer(dst_port, 0, buffer, m);

diff --git a/examples/performance-thread/l3fwd-thread/main.c b/examples/performance-thread/l3fwd-thread/main.c
index 2f593ab..2905199 100644 (file)
--- a/examples/performance-thread/l3fwd-thread/main.c
+++ b/examples/performance-thread/l3fwd-thread/main.c
@@ -1068,24 +1068,24 @@ simple_ipv4_fwd_8pkts(struct rte_mbuf *m[8], uint16_t portid)
 #endif
 
        /* dst addr */
-       *(uint64_t *)&eth_hdr[0]->d_addr = dest_eth_addr[dst_port[0]];
-       *(uint64_t *)&eth_hdr[1]->d_addr = dest_eth_addr[dst_port[1]];
-       *(uint64_t *)&eth_hdr[2]->d_addr = dest_eth_addr[dst_port[2]];
-       *(uint64_t *)&eth_hdr[3]->d_addr = dest_eth_addr[dst_port[3]];
-       *(uint64_t *)&eth_hdr[4]->d_addr = dest_eth_addr[dst_port[4]];
-       *(uint64_t *)&eth_hdr[5]->d_addr = dest_eth_addr[dst_port[5]];
-       *(uint64_t *)&eth_hdr[6]->d_addr = dest_eth_addr[dst_port[6]];
-       *(uint64_t *)&eth_hdr[7]->d_addr = dest_eth_addr[dst_port[7]];
+       *(uint64_t *)&eth_hdr[0]->dst_addr = dest_eth_addr[dst_port[0]];
+       *(uint64_t *)&eth_hdr[1]->dst_addr = dest_eth_addr[dst_port[1]];
+       *(uint64_t *)&eth_hdr[2]->dst_addr = dest_eth_addr[dst_port[2]];
+       *(uint64_t *)&eth_hdr[3]->dst_addr = dest_eth_addr[dst_port[3]];
+       *(uint64_t *)&eth_hdr[4]->dst_addr = dest_eth_addr[dst_port[4]];
+       *(uint64_t *)&eth_hdr[5]->dst_addr = dest_eth_addr[dst_port[5]];
+       *(uint64_t *)&eth_hdr[6]->dst_addr = dest_eth_addr[dst_port[6]];
+       *(uint64_t *)&eth_hdr[7]->dst_addr = dest_eth_addr[dst_port[7]];
 
        /* 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[1]], &eth_hdr[1]->s_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[3]], &eth_hdr[3]->s_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[5]], &eth_hdr[5]->s_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[7]], &eth_hdr[7]->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]->src_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]->src_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]->src_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]->src_addr);
 
        send_single_packet(m[0], (uint8_t)dst_port[0]);
        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 addr */
-       *(uint64_t *)&eth_hdr[0]->d_addr = dest_eth_addr[dst_port[0]];
-       *(uint64_t *)&eth_hdr[1]->d_addr = dest_eth_addr[dst_port[1]];
-       *(uint64_t *)&eth_hdr[2]->d_addr = dest_eth_addr[dst_port[2]];
-       *(uint64_t *)&eth_hdr[3]->d_addr = dest_eth_addr[dst_port[3]];
-       *(uint64_t *)&eth_hdr[4]->d_addr = dest_eth_addr[dst_port[4]];
-       *(uint64_t *)&eth_hdr[5]->d_addr = dest_eth_addr[dst_port[5]];
-       *(uint64_t *)&eth_hdr[6]->d_addr = dest_eth_addr[dst_port[6]];
-       *(uint64_t *)&eth_hdr[7]->d_addr = dest_eth_addr[dst_port[7]];
+       *(uint64_t *)&eth_hdr[0]->dst_addr = dest_eth_addr[dst_port[0]];
+       *(uint64_t *)&eth_hdr[1]->dst_addr = dest_eth_addr[dst_port[1]];
+       *(uint64_t *)&eth_hdr[2]->dst_addr = dest_eth_addr[dst_port[2]];
+       *(uint64_t *)&eth_hdr[3]->dst_addr = dest_eth_addr[dst_port[3]];
+       *(uint64_t *)&eth_hdr[4]->dst_addr = dest_eth_addr[dst_port[4]];
+       *(uint64_t *)&eth_hdr[5]->dst_addr = dest_eth_addr[dst_port[5]];
+       *(uint64_t *)&eth_hdr[6]->dst_addr = dest_eth_addr[dst_port[6]];
+       *(uint64_t *)&eth_hdr[7]->dst_addr = dest_eth_addr[dst_port[7]];
 
        /* 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[1]], &eth_hdr[1]->s_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[3]], &eth_hdr[3]->s_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[5]], &eth_hdr[5]->s_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[7]], &eth_hdr[7]->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]->src_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]->src_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]->src_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]->src_addr);
 
        send_single_packet(m[0], dst_port[0]);
        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);
 #endif
                /* 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 */
                rte_ether_addr_copy(&ports_eth_addr[dst_port],
-                               &eth_hdr->s_addr);
+                               &eth_hdr->src_addr);
 
                send_single_packet(m, dst_port);
        } 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 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 */
                rte_ether_addr_copy(&ports_eth_addr[dst_port],
-                               &eth_hdr->s_addr);
+                               &eth_hdr->src_addr);
 
                send_single_packet(m, dst_port);
        } else

diff --git a/examples/ptpclient/ptpclient.c b/examples/ptpclient/ptpclient.c
index 4f32ade..61e4ee0 100644 (file)
--- a/examples/ptpclient/ptpclient.c
+++ b/examples/ptpclient/ptpclient.c
@@ -426,10 +426,10 @@ parse_fup(struct ptpv2_data_slave_ordinary *ptp_data)
                created_pkt->data_len = pkt_size;
                created_pkt->pkt_len = pkt_size;
                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. */
-               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);
                ptp_msg = (struct ptp_message *)
@@ -449,14 +449,14 @@ parse_fup(struct ptpv2_data_slave_ordinary *ptp_data)
                client_clkid =
                        &ptp_msg->delay_req.hdr.source_port_id.clock_id;
 
-               client_clkid->id[0] = eth_hdr->s_addr.addr_bytes[0];
-               client_clkid->id[1] = eth_hdr->s_addr.addr_bytes[1];
-               client_clkid->id[2] = eth_hdr->s_addr.addr_bytes[2];
+               client_clkid->id[0] = eth_hdr->src_addr.addr_bytes[0];
+               client_clkid->id[1] = eth_hdr->src_addr.addr_bytes[1];
+               client_clkid->id[2] = eth_hdr->src_addr.addr_bytes[2];
                client_clkid->id[3] = 0xFF;
                client_clkid->id[4] = 0xFE;
-               client_clkid->id[5] = eth_hdr->s_addr.addr_bytes[3];
-               client_clkid->id[6] = eth_hdr->s_addr.addr_bytes[4];
-               client_clkid->id[7] = eth_hdr->s_addr.addr_bytes[5];
+               client_clkid->id[5] = eth_hdr->src_addr.addr_bytes[3];
+               client_clkid->id[6] = eth_hdr->src_addr.addr_bytes[4];
+               client_clkid->id[7] = eth_hdr->src_addr.addr_bytes[5];
 
                rte_memcpy(&ptp_data->client_clock_id,
                           client_clkid,

diff --git a/examples/vhost/main.c b/examples/vhost/main.c
index d0bf1f3..b24fd82 100644 (file)
--- a/examples/vhost/main.c
+++ b/examples/vhost/main.c
@@ -757,7 +757,7 @@ link_vmdq(struct vhost_dev *vdev, struct rte_mbuf *m)
        /* Learn MAC address of guest device from packet */
        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,
                        "(%d) device is using a registered MAC!\n",
                        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++)
-               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. */
        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();
        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)
                return -1;
 
@@ -993,7 +994,7 @@ find_local_dest(struct vhost_dev *vdev, struct rte_mbuf *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)
                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 *);
-       if (unlikely(rte_is_broadcast_ether_addr(&nh->d_addr))) {
+       if (unlikely(rte_is_broadcast_ether_addr(&nh->dst_addr))) {
                struct vhost_dev *vdev2;
 
                TAILQ_FOREACH(vdev2, &vhost_dev_list, global_vdev_entry) {

diff --git a/examples/vmdq/main.c b/examples/vmdq/main.c
index 755dcaf..ee7f432 100644 (file)
--- a/examples/vmdq/main.c
+++ b/examples/vmdq/main.c
@@ -461,11 +461,11 @@ update_mac_address(struct rte_mbuf *m, unsigned dst_port)
        eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        /* 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);
 
        /* 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 */

diff --git a/examples/vmdq_dcb/main.c b/examples/vmdq_dcb/main.c
index 6d3c918..14c20e6 100644 (file)
--- a/examples/vmdq_dcb/main.c
+++ b/examples/vmdq_dcb/main.c
@@ -512,11 +512,11 @@ update_mac_address(struct rte_mbuf *m, unsigned dst_port)
        eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        /* 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);
 
        /* 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 */

diff --git a/lib/ethdev/rte_flow.h b/lib/ethdev/rte_flow.h
index 7b1ed7f..a899450 100644 (file)
--- a/lib/ethdev/rte_flow.h
+++ b/lib/ethdev/rte_flow.h
@@ -785,8 +785,8 @@ struct rte_flow_item_eth {
 /** Default mask for RTE_FLOW_ITEM_TYPE_ETH. */
 #ifndef __cplusplus
 static const struct rte_flow_item_eth rte_flow_item_eth_mask = {
-       .hdr.d_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff",
-       .hdr.s_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff",
+       .hdr.dst_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),
 };
 #endif

diff --git a/lib/gro/gro_tcp4.c b/lib/gro/gro_tcp4.c
index feb5855..aff2217 100644 (file)
--- a/lib/gro/gro_tcp4.c
+++ b/lib/gro/gro_tcp4.c
@@ -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);
        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->d_addr), &(key.eth_daddr));
+       rte_ether_addr_copy(&(eth_hdr->src_addr), &(key.eth_saddr));
+       rte_ether_addr_copy(&(eth_hdr->dst_addr), &(key.eth_daddr));
        key.ip_src_addr = ipv4_hdr->src_addr;
        key.ip_dst_addr = ipv4_hdr->dst_addr;
        key.src_port = tcp_hdr->src_port;

diff --git a/lib/gro/gro_udp4.c b/lib/gro/gro_udp4.c
index b830129..e78dda7 100644 (file)
--- a/lib/gro/gro_udp4.c
+++ b/lib/gro/gro_udp4.c
@@ -238,8 +238,8 @@ gro_udp4_reassemble(struct rte_mbuf *pkt,
        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;
 
-       rte_ether_addr_copy(&(eth_hdr->s_addr), &(key.eth_saddr));
-       rte_ether_addr_copy(&(eth_hdr->d_addr), &(key.eth_daddr));
+       rte_ether_addr_copy(&(eth_hdr->src_addr), &(key.eth_saddr));
+       rte_ether_addr_copy(&(eth_hdr->dst_addr), &(key.eth_daddr));
        key.ip_src_addr = ipv4_hdr->src_addr;
        key.ip_dst_addr = ipv4_hdr->dst_addr;
        key.ip_id = ip_id;

diff --git a/lib/gro/gro_vxlan_tcp4.c b/lib/gro/gro_vxlan_tcp4.c
index f3b6e60..2005899 100644 (file)
--- a/lib/gro/gro_vxlan_tcp4.c
+++ b/lib/gro/gro_vxlan_tcp4.c
@@ -358,8 +358,8 @@ gro_vxlan_tcp4_reassemble(struct rte_mbuf *pkt,
 
        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->d_addr), &(key.inner_key.eth_daddr));
+       rte_ether_addr_copy(&(eth_hdr->src_addr), &(key.inner_key.eth_saddr));
+       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_dst_addr = ipv4_hdr->dst_addr;
        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_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->d_addr), &(key.outer_eth_daddr));
+       rte_ether_addr_copy(&(outer_eth_hdr->src_addr), &(key.outer_eth_saddr));
+       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_dst_addr = outer_ipv4_hdr->dst_addr;
        key.outer_src_port = udp_hdr->src_port;

diff --git a/lib/gro/gro_vxlan_udp4.c b/lib/gro/gro_vxlan_udp4.c
index 3747636..4767c91 100644 (file)
--- a/lib/gro/gro_vxlan_udp4.c
+++ b/lib/gro/gro_vxlan_udp4.c
@@ -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;
        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->d_addr), &(key.inner_key.eth_daddr));
+       rte_ether_addr_copy(&(eth_hdr->src_addr), &(key.inner_key.eth_saddr));
+       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_dst_addr = ipv4_hdr->dst_addr;
        key.inner_key.ip_id = ip_id;
 
        key.vxlan_hdr.vx_flags = vxlan_hdr->vx_flags;
        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->d_addr), &(key.outer_eth_daddr));
+       rte_ether_addr_copy(&(outer_eth_hdr->src_addr), &(key.outer_eth_saddr));
+       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_dst_addr = outer_ipv4_hdr->dst_addr;
        /* Note: It is unnecessary to save outer_src_port here because it can

diff --git a/lib/net/rte_arp.c b/lib/net/rte_arp.c
index 5c1e27b..9f7eb6b 100644 (file)
--- a/lib/net/rte_arp.c
+++ b/lib/net/rte_arp.c
@@ -29,8 +29,8 @@ rte_net_make_rarp_packet(struct rte_mempool *mpool,
        }
 
        /* Ethernet header. */
-       memset(eth_hdr->d_addr.addr_bytes, 0xff, RTE_ETHER_ADDR_LEN);
-       rte_ether_addr_copy(mac, &eth_hdr->s_addr);
+       memset(eth_hdr->dst_addr.addr_bytes, 0xff, RTE_ETHER_ADDR_LEN);
+       rte_ether_addr_copy(mac, &eth_hdr->src_addr);
        eth_hdr->ether_type = RTE_BE16(RTE_ETHER_TYPE_RARP);
 
        /* RARP header. */

diff --git a/lib/net/rte_ether.h b/lib/net/rte_ether.h
index 5f38b41..b83e0d3 100644 (file)
--- a/lib/net/rte_ether.h
+++ b/lib/net/rte_ether.h
@@ -266,34 +266,16 @@ rte_ether_format_addr(char *buf, uint16_t size,
 int
 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
  * and frame type.
  */
 struct rte_ether_hdr {
-       struct rte_ether_addr d_addr; /**< Destination address. */
-       RTE_STD_C11
-       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.*/
-       };
+       struct rte_ether_addr dst_addr; /**< Destination address. */
+       struct rte_ether_addr src_addr; /**< Source address. */
        rte_be16_t ether_type; /**< Frame type. */
 } __rte_aligned(2);
 
-#pragma pop_macro("s_addr")
-
 /**
  * Ethernet VLAN Header.
  * Contains the 16-bit VLAN Tag Control Identifier and the Ethernet type

diff --git a/lib/pipeline/rte_table_action.c b/lib/pipeline/rte_table_action.c
index ad7904c..4b0316b 100644 (file)
--- a/lib/pipeline/rte_table_action.c
+++ b/lib/pipeline/rte_table_action.c
@@ -615,8 +615,8 @@ encap_ether_apply(void *data,
                RTE_ETHER_TYPE_IPV6;
 
        /* Ethernet */
-       rte_ether_addr_copy(&p->ether.ether.da, &d->ether.d_addr);
-       rte_ether_addr_copy(&p->ether.ether.sa, &d->ether.s_addr);
+       rte_ether_addr_copy(&p->ether.ether.da, &d->ether.dst_addr);
+       rte_ether_addr_copy(&p->ether.ether.sa, &d->ether.src_addr);
        d->ether.ether_type = rte_htons(ethertype);
 
        return 0;
@@ -633,8 +633,8 @@ encap_vlan_apply(void *data,
                RTE_ETHER_TYPE_IPV6;
 
        /* Ethernet */
-       rte_ether_addr_copy(&p->vlan.ether.da, &d->ether.d_addr);
-       rte_ether_addr_copy(&p->vlan.ether.sa, &d->ether.s_addr);
+       rte_ether_addr_copy(&p->vlan.ether.da, &d->ether.dst_addr);
+       rte_ether_addr_copy(&p->vlan.ether.sa, &d->ether.src_addr);
        d->ether.ether_type = rte_htons(RTE_ETHER_TYPE_VLAN);
 
        /* VLAN */
@@ -657,8 +657,8 @@ encap_qinq_apply(void *data,
                RTE_ETHER_TYPE_IPV6;
 
        /* Ethernet */
-       rte_ether_addr_copy(&p->qinq.ether.da, &d->ether.d_addr);
-       rte_ether_addr_copy(&p->qinq.ether.sa, &d->ether.s_addr);
+       rte_ether_addr_copy(&p->qinq.ether.da, &d->ether.dst_addr);
+       rte_ether_addr_copy(&p->qinq.ether.sa, &d->ether.src_addr);
        d->ether.ether_type = rte_htons(RTE_ETHER_TYPE_QINQ);
 
        /* SVLAN */
@@ -683,8 +683,8 @@ encap_qinq_pppoe_apply(void *data,
        struct encap_qinq_pppoe_data *d = data;
 
        /* Ethernet */
-       rte_ether_addr_copy(&p->qinq.ether.da, &d->ether.d_addr);
-       rte_ether_addr_copy(&p->qinq.ether.sa, &d->ether.s_addr);
+       rte_ether_addr_copy(&p->qinq.ether.da, &d->ether.dst_addr);
+       rte_ether_addr_copy(&p->qinq.ether.sa, &d->ether.src_addr);
        d->ether.ether_type = rte_htons(RTE_ETHER_TYPE_VLAN);
 
        /* SVLAN */
@@ -719,8 +719,8 @@ encap_mpls_apply(void *data,
        uint32_t i;
 
        /* Ethernet */
-       rte_ether_addr_copy(&p->mpls.ether.da, &d->ether.d_addr);
-       rte_ether_addr_copy(&p->mpls.ether.sa, &d->ether.s_addr);
+       rte_ether_addr_copy(&p->mpls.ether.da, &d->ether.dst_addr);
+       rte_ether_addr_copy(&p->mpls.ether.sa, &d->ether.src_addr);
        d->ether.ether_type = rte_htons(ethertype);
 
        /* MPLS */
@@ -746,8 +746,8 @@ encap_pppoe_apply(void *data,
        struct encap_pppoe_data *d = data;
 
        /* Ethernet */
-       rte_ether_addr_copy(&p->pppoe.ether.da, &d->ether.d_addr);
-       rte_ether_addr_copy(&p->pppoe.ether.sa, &d->ether.s_addr);
+       rte_ether_addr_copy(&p->pppoe.ether.da, &d->ether.dst_addr);
+       rte_ether_addr_copy(&p->pppoe.ether.sa, &d->ether.src_addr);
        d->ether.ether_type = rte_htons(RTE_ETHER_TYPE_PPPOE_SESSION);
 
        /* PPPoE and PPP*/
@@ -777,9 +777,9 @@ encap_vxlan_apply(void *data,
 
                        /* Ethernet */
                        rte_ether_addr_copy(&p->vxlan.ether.da,
-                                       &d->ether.d_addr);
+                                       &d->ether.dst_addr);
                        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);
 
                        /* VLAN */
@@ -818,9 +818,9 @@ encap_vxlan_apply(void *data,
 
                        /* Ethernet */
                        rte_ether_addr_copy(&p->vxlan.ether.da,
-                                       &d->ether.d_addr);
+                                       &d->ether.dst_addr);
                        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);
 
                        /* IPv4*/
@@ -855,9 +855,9 @@ encap_vxlan_apply(void *data,
 
                        /* Ethernet */
                        rte_ether_addr_copy(&p->vxlan.ether.da,
-                                       &d->ether.d_addr);
+                                       &d->ether.dst_addr);
                        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);
 
                        /* VLAN */
@@ -896,9 +896,9 @@ encap_vxlan_apply(void *data,
 
                        /* Ethernet */
                        rte_ether_addr_copy(&p->vxlan.ether.da,
-                                       &d->ether.d_addr);
+                                       &d->ether.dst_addr);
                        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);
 
                        /* IPv6*/