net: add rte prefix to ether structures
authorOlivier Matz <olivier.matz@6wind.com>
Fri, 26 Oct 2018 07:03:49 +0000 (09:03 +0200)
committerOlivier Matz <olivier.matz@6wind.com>
Fri, 26 Oct 2018 07:03:49 +0000 (09:03 +0200)
Add 'rte_' prefix to structures:
- rename struct ether_addr as struct rte_ether_addr.
- rename struct ether_hdr as struct rte_ether_hdr.
- rename struct vlan_hdr as struct rte_vlan_hdr.
- rename struct vxlan_hdr as struct rte_vxlan_hdr.
- rename struct vxlan_gpe_hdr as struct rte_vxlan_gpe_hdr.

Additionally, adapt the command line library to use the rte
structures and defines.

Signed-off-by: Olivier Matz <olivier.matz@6wind.com>
246 files changed:
app/pdump/main.c
app/test-pmd/cmdline.c
app/test-pmd/cmdline_flow.c
app/test-pmd/config.c
app/test-pmd/csumonly.c
app/test-pmd/flowgen.c
app/test-pmd/icmpecho.c
app/test-pmd/ieee1588fwd.c
app/test-pmd/macfwd.c
app/test-pmd/macswap.c
app/test-pmd/testpmd.c
app/test-pmd/testpmd.h
app/test-pmd/txonly.c
app/test-pmd/util.c
doc/guides/prog_guide/bbdev.rst
doc/guides/sample_app_ug/flow_classify.rst
doc/guides/sample_app_ug/flow_filtering.rst
doc/guides/sample_app_ug/ipv4_multicast.rst
doc/guides/sample_app_ug/l2_forward_job_stats.rst
doc/guides/sample_app_ug/l2_forward_real_virtual.rst
doc/guides/sample_app_ug/l3_forward.rst
doc/guides/sample_app_ug/link_status_intr.rst
doc/guides/sample_app_ug/ptpclient.rst
doc/guides/sample_app_ug/rxtx_callbacks.rst
doc/guides/sample_app_ug/server_node_efd.rst
doc/guides/sample_app_ug/skeleton.rst
doc/guides/sample_app_ug/vmdq_dcb_forwarding.rst
drivers/bus/dpaa/include/fman.h
drivers/bus/dpaa/include/netcfg.h
drivers/net/af_packet/rte_eth_af_packet.c
drivers/net/ark/ark_ethdev.c
drivers/net/ark/ark_ext.h
drivers/net/ark/ark_global.h
drivers/net/atlantic/atl_ethdev.c
drivers/net/atlantic/hw_atl/hw_atl_utils.c
drivers/net/atlantic/hw_atl/hw_atl_utils_fw2x.c
drivers/net/avf/avf.h
drivers/net/avf/avf_ethdev.c
drivers/net/avf/avf_vchnl.c
drivers/net/avp/avp_ethdev.c
drivers/net/axgbe/axgbe_ethdev.h
drivers/net/bnx2x/bnx2x.c
drivers/net/bnx2x/bnx2x_ethdev.c
drivers/net/bnx2x/bnx2x_ethdev.h
drivers/net/bnx2x/bnx2x_vfpf.c
drivers/net/bnx2x/bnx2x_vfpf.h
drivers/net/bnxt/bnxt_ethdev.c
drivers/net/bnxt/bnxt_hwrm.c
drivers/net/bnxt/bnxt_hwrm.h
drivers/net/bnxt/rte_pmd_bnxt.c
drivers/net/bnxt/rte_pmd_bnxt.h
drivers/net/bonding/rte_eth_bond.h
drivers/net/bonding/rte_eth_bond_8023ad.c
drivers/net/bonding/rte_eth_bond_8023ad.h
drivers/net/bonding/rte_eth_bond_alb.c
drivers/net/bonding/rte_eth_bond_alb.h
drivers/net/bonding/rte_eth_bond_api.c
drivers/net/bonding/rte_eth_bond_args.c
drivers/net/bonding/rte_eth_bond_pmd.c
drivers/net/bonding/rte_eth_bond_private.h
drivers/net/cxgbe/base/adapter.h
drivers/net/cxgbe/cxgbe_ethdev.c
drivers/net/cxgbe/cxgbe_pfvf.h
drivers/net/dpaa/dpaa_ethdev.c
drivers/net/dpaa/dpaa_rxtx.c
drivers/net/dpaa2/dpaa2_ethdev.c
drivers/net/e1000/em_ethdev.c
drivers/net/e1000/igb_ethdev.c
drivers/net/e1000/igb_pf.c
drivers/net/ena/ena_ethdev.c
drivers/net/enetc/enetc_ethdev.c
drivers/net/enic/enic_ethdev.c
drivers/net/enic/enic_flow.c
drivers/net/enic/enic_main.c
drivers/net/failsafe/failsafe.c
drivers/net/failsafe/failsafe_args.c
drivers/net/failsafe/failsafe_ether.c
drivers/net/failsafe/failsafe_ops.c
drivers/net/failsafe/failsafe_private.h
drivers/net/fm10k/fm10k_ethdev.c
drivers/net/i40e/i40e_ethdev.c
drivers/net/i40e/i40e_ethdev.h
drivers/net/i40e/i40e_ethdev_vf.c
drivers/net/i40e/i40e_fdir.c
drivers/net/i40e/i40e_flow.c
drivers/net/i40e/i40e_pf.c
drivers/net/i40e/i40e_vf_representor.c
drivers/net/i40e/rte_pmd_i40e.c
drivers/net/i40e/rte_pmd_i40e.h
drivers/net/ixgbe/ixgbe_ethdev.c
drivers/net/ixgbe/ixgbe_pf.c
drivers/net/ixgbe/ixgbe_vf_representor.c
drivers/net/ixgbe/rte_pmd_ixgbe.c
drivers/net/ixgbe/rte_pmd_ixgbe.h
drivers/net/kni/rte_eth_kni.c
drivers/net/liquidio/lio_ethdev.c
drivers/net/mlx4/mlx4.c
drivers/net/mlx4/mlx4.h
drivers/net/mlx4/mlx4_ethdev.c
drivers/net/mlx4/mlx4_flow.c
drivers/net/mlx5/mlx5.c
drivers/net/mlx5/mlx5.h
drivers/net/mlx5/mlx5_flow_tcf.c
drivers/net/mlx5/mlx5_mac.c
drivers/net/mlx5/mlx5_nl.c
drivers/net/mlx5/mlx5_rxtx.h
drivers/net/mlx5/mlx5_trigger.c
drivers/net/mvneta/mvneta_ethdev.c
drivers/net/mvpp2/mrvl_ethdev.c
drivers/net/mvpp2/mrvl_flow.c
drivers/net/netvsc/hn_ethdev.c
drivers/net/netvsc/hn_rxtx.c
drivers/net/netvsc/hn_var.h
drivers/net/netvsc/hn_vf.c
drivers/net/nfp/nfp_net.c
drivers/net/null/rte_eth_null.c
drivers/net/octeontx/octeontx_ethdev.c
drivers/net/pcap/rte_eth_pcap.c
drivers/net/qede/qede_ethdev.c
drivers/net/qede/qede_ethdev.h
drivers/net/qede/qede_filter.c
drivers/net/qede/qede_if.h
drivers/net/qede/qede_rxtx.c
drivers/net/ring/rte_eth_ring.c
drivers/net/sfc/sfc.h
drivers/net/sfc/sfc_ethdev.c
drivers/net/sfc/sfc_port.c
drivers/net/softnic/parser.c
drivers/net/softnic/parser.h
drivers/net/softnic/rte_eth_softnic.c
drivers/net/szedata2/rte_eth_szedata2.c
drivers/net/tap/rte_eth_tap.c
drivers/net/tap/rte_eth_tap.h
drivers/net/tap/tap_bpf_program.c
drivers/net/thunderx/base/nicvf_mbox.c
drivers/net/thunderx/nicvf_ethdev.c
drivers/net/vdev_netvsc/vdev_netvsc.c
drivers/net/vhost/rte_eth_vhost.c
drivers/net/virtio/virtio_ethdev.c
drivers/net/virtio/virtio_rxtx.c
drivers/net/vmxnet3/vmxnet3_ethdev.c
drivers/net/vmxnet3/vmxnet3_rxtx.c
examples/bbdev_app/main.c
examples/bond/main.c
examples/distributor/main.c
examples/ethtool/ethtool-app/ethapp.c
examples/ethtool/ethtool-app/main.c
examples/ethtool/lib/rte_ethtool.c
examples/ethtool/lib/rte_ethtool.h
examples/eventdev_pipeline/main.c
examples/eventdev_pipeline/pipeline_common.h
examples/flow_classify/flow_classify.c
examples/flow_filtering/main.c
examples/ip_fragmentation/main.c
examples/ip_pipeline/cli.c
examples/ip_pipeline/parser.c
examples/ip_pipeline/parser.h
examples/ip_reassembly/main.c
examples/ipsec-secgw/ipsec-secgw.c
examples/ipv4_multicast/main.c
examples/kni/main.c
examples/l2fwd-cat/l2fwd-cat.c
examples/l2fwd-crypto/main.c
examples/l2fwd-jobstats/main.c
examples/l2fwd-keepalive/main.c
examples/l2fwd/main.c
examples/l3fwd-acl/main.c
examples/l3fwd-power/main.c
examples/l3fwd-vf/main.c
examples/l3fwd/l3fwd.h
examples/l3fwd/l3fwd_altivec.h
examples/l3fwd/l3fwd_em.c
examples/l3fwd/l3fwd_em.h
examples/l3fwd/l3fwd_em_hlm.h
examples/l3fwd/l3fwd_em_hlm_neon.h
examples/l3fwd/l3fwd_em_hlm_sse.h
examples/l3fwd/l3fwd_em_sequential.h
examples/l3fwd/l3fwd_lpm.c
examples/l3fwd/l3fwd_lpm.h
examples/l3fwd/l3fwd_lpm_altivec.h
examples/l3fwd/l3fwd_lpm_neon.h
examples/l3fwd/l3fwd_lpm_sse.h
examples/l3fwd/l3fwd_neon.h
examples/l3fwd/l3fwd_sse.h
examples/l3fwd/main.c
examples/link_status_interrupt/main.c
examples/load_balancer/runtime.c
examples/multi_process/client_server_mp/mp_server/main.c
examples/packet_ordering/main.c
examples/performance-thread/l3fwd-thread/main.c
examples/ptpclient/ptpclient.c
examples/qos_meter/main.c
examples/quota_watermark/qw/main.c
examples/rxtx_callbacks/main.c
examples/server_node_efd/node/node.c
examples/server_node_efd/server/main.c
examples/skeleton/basicfwd.c
examples/tep_termination/main.c
examples/tep_termination/main.h
examples/tep_termination/vxlan.c
examples/tep_termination/vxlan.h
examples/tep_termination/vxlan_setup.c
examples/tep_termination/vxlan_setup.h
examples/vhost/main.c
examples/vhost/main.h
examples/vm_power_manager/channel_monitor.c
examples/vm_power_manager/guest_cli/vm_power_cli_guest.c
examples/vm_power_manager/main.c
examples/vmdq/main.c
examples/vmdq_dcb/main.c
lib/librte_cmdline/cmdline_parse_etheraddr.c
lib/librte_ethdev/rte_eth_ctrl.h
lib/librte_ethdev/rte_ethdev.c
lib/librte_ethdev/rte_ethdev.h
lib/librte_ethdev/rte_ethdev_core.h
lib/librte_ethdev/rte_flow.h
lib/librte_eventdev/rte_event_eth_rx_adapter.c
lib/librte_gro/gro_tcp4.c
lib/librte_gro/gro_tcp4.h
lib/librte_gro/gro_vxlan_tcp4.c
lib/librte_gro/gro_vxlan_tcp4.h
lib/librte_gso/rte_gso.h
lib/librte_kni/rte_kni.c
lib/librte_net/rte_arp.c
lib/librte_net/rte_arp.h
lib/librte_net/rte_ether.h
lib/librte_net/rte_net.c
lib/librte_pipeline/rte_table_action.c
lib/librte_pipeline/rte_table_action.h
lib/librte_vhost/vhost.h
lib/librte_vhost/virtio_net.c
test/test-pipeline/pipeline_acl.c
test/test-pipeline/pipeline_hash.c
test/test/packet_burst_generator.c
test/test/packet_burst_generator.h
test/test/test_cmdline_etheraddr.c
test/test/test_event_eth_rx_adapter.c
test/test/test_event_eth_tx_adapter.c
test/test/test_flow_classify.c
test/test/test_link_bonding.c
test/test/test_link_bonding_mode4.c
test/test/test_link_bonding_rssconf.c
test/test/test_pmd_perf.c
test/test/test_sched.c
test/test/virtual_pmd.c
test/test/virtual_pmd.h

index ac22871..0635ac0 100644 (file)
@@ -527,7 +527,7 @@ signal_handler(int sig_num)
 static inline int
 configure_vdev(uint16_t port_id)
 {
-       struct ether_addr addr;
+       struct rte_ether_addr addr;
        const uint16_t rxRings = 0, txRings = 1;
        int ret;
        uint16_t q;
index 3b469ac..c866ffe 100644 (file)
@@ -5961,7 +5961,7 @@ struct cmd_set_bond_mac_addr_result {
        cmdline_fixed_string_t bonding;
        cmdline_fixed_string_t mac_addr;
        uint16_t port_num;
-       struct ether_addr address;
+       struct rte_ether_addr address;
 };
 
 static void cmd_set_bond_mac_addr_parsed(void *parsed_result,
@@ -7691,7 +7691,7 @@ struct cmd_mac_addr_result {
        cmdline_fixed_string_t mac_addr_cmd;
        cmdline_fixed_string_t what;
        uint16_t port_num;
-       struct ether_addr address;
+       struct rte_ether_addr address;
 };
 
 static void cmd_mac_addr_parsed(void *parsed_result,
@@ -7890,7 +7890,7 @@ struct cmd_set_uc_hash_table {
        cmdline_fixed_string_t port;
        portid_t port_id;
        cmdline_fixed_string_t what;
-       struct ether_addr address;
+       struct rte_ether_addr address;
        cmdline_fixed_string_t mode;
 };
 
@@ -8014,7 +8014,7 @@ struct cmd_set_vf_macvlan_filter {
        portid_t port_id;
        cmdline_fixed_string_t vf;
        uint8_t vf_id;
-       struct ether_addr address;
+       struct rte_ether_addr address;
        cmdline_fixed_string_t filter_type;
        cmdline_fixed_string_t mode;
 };
@@ -8273,7 +8273,7 @@ struct cmd_vf_mac_addr_result {
        uint16_t port_num;
        cmdline_fixed_string_t vf;
        uint8_t vf_num;
-       struct ether_addr address;
+       struct rte_ether_addr address;
 };
 
 static void cmd_vf_mac_addr_parsed(void *parsed_result,
@@ -8586,8 +8586,8 @@ struct cmd_tunnel_filter_result {
        cmdline_fixed_string_t cmd;
        cmdline_fixed_string_t what;
        portid_t port_id;
-       struct ether_addr outer_mac;
-       struct ether_addr inner_mac;
+       struct rte_ether_addr outer_mac;
+       struct rte_ether_addr inner_mac;
        cmdline_ipaddr_t ip_value;
        uint16_t inner_vlan;
        cmdline_fixed_string_t tunnel_type;
@@ -10373,7 +10373,7 @@ struct cmd_ethertype_filter_result {
        portid_t port_id;
        cmdline_fixed_string_t ops;
        cmdline_fixed_string_t mac;
-       struct ether_addr mac_addr;
+       struct rte_ether_addr mac_addr;
        cmdline_fixed_string_t ethertype;
        uint16_t ethertype_value;
        cmdline_fixed_string_t drop;
@@ -10433,7 +10433,7 @@ cmd_ethertype_filter_parsed(void *parsed_result,
        if (!strcmp(res->mac, "mac_addr")) {
                filter.flags |= RTE_ETHTYPE_FLAGS_MAC;
                rte_memcpy(&filter.mac_addr, &res->mac_addr,
-                       sizeof(struct ether_addr));
+                       sizeof(struct rte_ether_addr));
        }
        if (!strcmp(res->drop, "drop"))
                filter.flags |= RTE_ETHTYPE_FLAGS_DROP;
@@ -10512,7 +10512,7 @@ struct cmd_flow_director_result {
        cmdline_fixed_string_t fd_id;
        uint32_t  fd_id_value;
        cmdline_fixed_string_t mac;
-       struct ether_addr mac_addr;
+       struct rte_ether_addr mac_addr;
        cmdline_fixed_string_t tunnel;
        cmdline_fixed_string_t tunnel_type;
        cmdline_fixed_string_t tunnel_id;
@@ -10815,12 +10815,12 @@ cmd_flow_director_filter_parsed(void *parsed_result,
        if (fdir_conf.mode ==  RTE_FDIR_MODE_PERFECT_MAC_VLAN)
                rte_memcpy(&entry.input.flow.mac_vlan_flow.mac_addr,
                                 &res->mac_addr,
-                                sizeof(struct ether_addr));
+                                sizeof(struct rte_ether_addr));
 
        if (fdir_conf.mode ==  RTE_FDIR_MODE_PERFECT_TUNNEL) {
                rte_memcpy(&entry.input.flow.tunnel_flow.mac_addr,
                                 &res->mac_addr,
-                                sizeof(struct ether_addr));
+                                sizeof(struct rte_ether_addr));
                entry.input.flow.tunnel_flow.tunnel_type =
                        str2fdir_tunneltype(res->tunnel_type);
                entry.input.flow.tunnel_flow.tunnel_id =
@@ -12252,7 +12252,7 @@ struct cmd_mcast_addr_result {
        cmdline_fixed_string_t mcast_addr_cmd;
        cmdline_fixed_string_t what;
        uint16_t port_num;
-       struct ether_addr mc_addr;
+       struct rte_ether_addr mc_addr;
 };
 
 static void cmd_mcast_addr_parsed(void *parsed_result,
@@ -13671,7 +13671,7 @@ struct cmd_set_vf_mac_addr_result {
        cmdline_fixed_string_t addr;
        portid_t port_id;
        uint16_t vf_id;
-       struct ether_addr mac_addr;
+       struct rte_ether_addr mac_addr;
 
 };
 
@@ -13976,7 +13976,7 @@ struct cmd_macsec_sc_result {
        cmdline_fixed_string_t sc;
        cmdline_fixed_string_t tx_rx;
        portid_t port_id;
-       struct ether_addr mac;
+       struct rte_ether_addr mac;
        uint16_t pi;
 };
 
@@ -14975,8 +14975,8 @@ struct cmd_set_vxlan_result {
        cmdline_ipaddr_t ip_src;
        cmdline_ipaddr_t ip_dst;
        uint16_t tci;
-       struct ether_addr eth_src;
-       struct ether_addr eth_dst;
+       struct rte_ether_addr eth_src;
+       struct rte_ether_addr eth_dst;
 };
 
 cmdline_parse_token_string_t cmd_set_vxlan_set =
@@ -15144,8 +15144,8 @@ struct cmd_set_nvgre_result {
        cmdline_ipaddr_t ip_src;
        cmdline_ipaddr_t ip_dst;
        uint16_t tci;
-       struct ether_addr eth_src;
-       struct ether_addr eth_dst;
+       struct rte_ether_addr eth_src;
+       struct rte_ether_addr eth_dst;
 };
 
 cmdline_parse_token_string_t cmd_set_nvgre_set =
index a527b6b..6c5538d 100644 (file)
@@ -3831,7 +3831,7 @@ parse_mac_addr(struct context *ctx, const struct token *token,
               void *buf, unsigned int size)
 {
        const struct arg *arg = pop_args(ctx);
-       struct ether_addr tmp;
+       struct rte_ether_addr tmp;
        int ret;
 
        (void)token;
index 1696623..614719e 100644 (file)
@@ -104,7 +104,7 @@ const struct rss_type_info rss_type_table[] = {
 };
 
 static void
-print_ethaddr(const char *name, struct ether_addr *eth_addr)
+print_ethaddr(const char *name, struct rte_ether_addr *eth_addr)
 {
        char buf[ETHER_ADDR_FMT_SIZE];
        ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr);
@@ -387,7 +387,7 @@ void
 port_infos_display(portid_t port_id)
 {
        struct rte_port *port;
-       struct ether_addr mac_addr;
+       struct rte_ether_addr mac_addr;
        struct rte_eth_link link;
        struct rte_eth_dev_info dev_info;
        int vlan_offload;
@@ -534,7 +534,7 @@ port_summary_header_display(void)
 void
 port_summary_display(portid_t port_id)
 {
-       struct ether_addr mac_addr;
+       struct rte_ether_addr mac_addr;
        struct rte_eth_link link;
        struct rte_eth_dev_info dev_info;
        char name[RTE_ETH_NAME_MAX_LEN];
@@ -2508,7 +2508,7 @@ set_tx_pkt_segments(unsigned *seg_lengths, unsigned nb_segs)
         * Check that each segment length is greater or equal than
         * the mbuf data sise.
         * Check also that the total packet length is greater or equal than the
-        * size of an empty UDP/IP packet (sizeof(struct ether_hdr) + 20 + 8).
+        * size of an empty UDP/IP packet (sizeof(struct rte_ether_hdr) + 20 + 8).
         */
        tx_pkt_len = 0;
        for (i = 0; i < nb_segs; i++) {
@@ -2519,10 +2519,10 @@ set_tx_pkt_segments(unsigned *seg_lengths, unsigned nb_segs)
                }
                tx_pkt_len = (uint16_t)(tx_pkt_len + seg_lengths[i]);
        }
-       if (tx_pkt_len < (sizeof(struct ether_hdr) + 20 + 8)) {
+       if (tx_pkt_len < (sizeof(struct rte_ether_hdr) + 20 + 8)) {
                printf("total packet length=%u < %d - give up\n",
                                (unsigned) tx_pkt_len,
-                               (int)(sizeof(struct ether_hdr) + 20 + 8));
+                               (int)(sizeof(struct rte_ether_hdr) + 20 + 8));
                return;
        }
 
@@ -3448,7 +3448,7 @@ set_vf_rate_limit(portid_t port_id, uint16_t vf, uint16_t rate, uint64_t q_msk)
 static int
 mcast_addr_pool_extend(struct rte_port *port)
 {
-       struct ether_addr *mc_pool;
+       struct rte_ether_addr *mc_pool;
        size_t mc_pool_size;
 
        /*
@@ -3465,9 +3465,9 @@ mcast_addr_pool_extend(struct rte_port *port)
         * The previous test guarantees that port->mc_addr_nb is a multiple
         * of MCAST_POOL_INC.
         */
-       mc_pool_size = sizeof(struct ether_addr) * (port->mc_addr_nb +
+       mc_pool_size = sizeof(struct rte_ether_addr) * (port->mc_addr_nb +
                                                    MCAST_POOL_INC);
-       mc_pool = (struct ether_addr *) realloc(port->mc_addr_pool,
+       mc_pool = (struct rte_ether_addr *) realloc(port->mc_addr_pool,
                                                mc_pool_size);
        if (mc_pool == NULL) {
                printf("allocation of pool of %u multicast addresses failed\n",
@@ -3496,7 +3496,7 @@ mcast_addr_pool_remove(struct rte_port *port, uint32_t addr_idx)
        }
        memmove(&port->mc_addr_pool[addr_idx],
                &port->mc_addr_pool[addr_idx + 1],
-               sizeof(struct ether_addr) * (port->mc_addr_nb - addr_idx));
+               sizeof(struct rte_ether_addr) * (port->mc_addr_nb - addr_idx));
 }
 
 static void
@@ -3515,7 +3515,7 @@ eth_port_multicast_addr_list_set(portid_t port_id)
 }
 
 void
-mcast_addr_add(portid_t port_id, struct ether_addr *mc_addr)
+mcast_addr_add(portid_t port_id, struct rte_ether_addr *mc_addr)
 {
        struct rte_port *port;
        uint32_t i;
@@ -3543,7 +3543,7 @@ mcast_addr_add(portid_t port_id, struct ether_addr *mc_addr)
 }
 
 void
-mcast_addr_remove(portid_t port_id, struct ether_addr *mc_addr)
+mcast_addr_remove(portid_t port_id, struct rte_ether_addr *mc_addr)
 {
        struct rte_port *port;
        uint32_t i;
index dce4b9b..2c45869 100644 (file)
@@ -138,18 +138,18 @@ parse_ipv6(struct ipv6_hdr *ipv6_hdr, struct testpmd_offload_info *info)
  * header. The l4_len argument is only set in case of TCP (useful for TSO).
  */
 static void
-parse_ethernet(struct ether_hdr *eth_hdr, struct testpmd_offload_info *info)
+parse_ethernet(struct rte_ether_hdr *eth_hdr, struct testpmd_offload_info *info)
 {
        struct ipv4_hdr *ipv4_hdr;
        struct ipv6_hdr *ipv6_hdr;
 
-       info->l2_len = sizeof(struct ether_hdr);
+       info->l2_len = sizeof(struct rte_ether_hdr);
        info->ethertype = eth_hdr->ether_type;
 
        if (info->ethertype == _htons(ETHER_TYPE_VLAN)) {
-               struct vlan_hdr *vlan_hdr = (struct vlan_hdr *)(eth_hdr + 1);
+               struct rte_vlan_hdr *vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
 
-               info->l2_len  += sizeof(struct vlan_hdr);
+               info->l2_len  += sizeof(struct rte_vlan_hdr);
                info->ethertype = vlan_hdr->eth_proto;
        }
 
@@ -176,7 +176,7 @@ parse_vxlan(struct udp_hdr *udp_hdr,
            struct testpmd_offload_info *info,
            uint32_t pkt_type)
 {
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
 
        /* check udp destination port, 4789 is the default vxlan port
         * (rfc7348) or that the rx offload flag is set (i40e only
@@ -191,9 +191,9 @@ parse_vxlan(struct udp_hdr *udp_hdr,
        info->outer_l3_len = info->l3_len;
        info->outer_l4_proto = info->l4_proto;
 
-       eth_hdr = (struct ether_hdr *)((char *)udp_hdr +
+       eth_hdr = (struct rte_ether_hdr *)((char *)udp_hdr +
                sizeof(struct udp_hdr) +
-               sizeof(struct vxlan_hdr));
+               sizeof(struct rte_vxlan_hdr));
 
        parse_ethernet(eth_hdr, info);
        info->l2_len += ETHER_VXLAN_HLEN; /* add udp + vxlan */
@@ -204,17 +204,17 @@ static void
 parse_vxlan_gpe(struct udp_hdr *udp_hdr,
            struct testpmd_offload_info *info)
 {
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        struct ipv4_hdr *ipv4_hdr;
        struct ipv6_hdr *ipv6_hdr;
-       struct vxlan_gpe_hdr *vxlan_gpe_hdr;
+       struct rte_vxlan_gpe_hdr *vxlan_gpe_hdr;
        uint8_t vxlan_gpe_len = sizeof(*vxlan_gpe_hdr);
 
        /* Check udp destination port. */
        if (udp_hdr->dst_port != _htons(vxlan_gpe_udp_port))
                return;
 
-       vxlan_gpe_hdr = (struct vxlan_gpe_hdr *)((char *)udp_hdr +
+       vxlan_gpe_hdr = (struct rte_vxlan_gpe_hdr *)((char *)udp_hdr +
                                sizeof(struct udp_hdr));
 
        if (!vxlan_gpe_hdr->proto || vxlan_gpe_hdr->proto ==
@@ -253,7 +253,7 @@ parse_vxlan_gpe(struct udp_hdr *udp_hdr,
                info->outer_l3_len = info->l3_len;
                info->outer_l4_proto = info->l4_proto;
 
-               eth_hdr = (struct ether_hdr *)((char *)vxlan_gpe_hdr +
+               eth_hdr = (struct rte_ether_hdr *)((char *)vxlan_gpe_hdr +
                          vxlan_gpe_len);
 
                parse_ethernet(eth_hdr, info);
@@ -267,7 +267,7 @@ parse_vxlan_gpe(struct udp_hdr *udp_hdr,
 static void
 parse_gre(struct simple_gre_hdr *gre_hdr, struct testpmd_offload_info *info)
 {
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        struct ipv4_hdr *ipv4_hdr;
        struct ipv6_hdr *ipv6_hdr;
        uint8_t gre_len = 0;
@@ -314,7 +314,7 @@ parse_gre(struct simple_gre_hdr *gre_hdr, struct testpmd_offload_info *info)
                info->outer_l3_len = info->l3_len;
                info->outer_l4_proto = info->l4_proto;
 
-               eth_hdr = (struct ether_hdr *)((char *)gre_hdr + gre_len);
+               eth_hdr = (struct rte_ether_hdr *)((char *)gre_hdr + gre_len);
 
                parse_ethernet(eth_hdr, info);
        } else
@@ -687,7 +687,7 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
        struct rte_mbuf **tx_pkts_burst;
        struct rte_port *txp;
        struct rte_mbuf *m, *p;
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        void *l3_hdr = NULL, *outer_l3_hdr = NULL; /* can be IPv4 or IPv6 */
        void **gro_ctx;
        uint16_t gro_pkts_num;
@@ -761,7 +761,7 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
                /* step 1: dissect packet, parsing optional vlan, ip4/ip6, vxlan
                 * and inner headers */
 
-               eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+               eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
                ether_addr_copy(&peer_eth_addrs[fs->peer_addr],
                                &eth_hdr->d_addr);
                ether_addr_copy(&ports[fs->tx_port].eth_addr,
index 0531b5d..574162c 100644 (file)
@@ -76,9 +76,9 @@ static uint32_t cfg_ip_src    = IPv4(10, 254, 0, 0);
 static uint32_t cfg_ip_dst     = IPv4(10, 253, 0, 0);
 static uint16_t cfg_udp_src    = 1000;
 static uint16_t cfg_udp_dst    = 1001;
-static struct ether_addr cfg_ether_src =
+static struct rte_ether_addr cfg_ether_src     =
        {{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x00 }};
-static struct ether_addr cfg_ether_dst =
+static struct rte_ether_addr cfg_ether_dst     =
        {{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x01 }};
 
 #define IP_DEFTTL  64   /* from RFC 1340. */
@@ -119,7 +119,7 @@ pkt_burst_flow_gen(struct fwd_stream *fs)
        struct rte_mbuf  *pkts_burst[MAX_PKT_BURST];
        struct rte_mempool *mbp;
        struct rte_mbuf  *pkt;
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        struct ipv4_hdr *ip_hdr;
        struct udp_hdr *udp_hdr;
        uint16_t vlan_tci, vlan_tci_outer;
@@ -170,7 +170,7 @@ pkt_burst_flow_gen(struct fwd_stream *fs)
                pkt->next = NULL;
 
                /* Initialize Ethernet header. */
-               eth_hdr = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+               eth_hdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
                ether_addr_copy(&cfg_ether_dst, &eth_hdr->d_addr);
                ether_addr_copy(&cfg_ether_src, &eth_hdr->s_addr);
                eth_hdr->ether_type = rte_cpu_to_be_16(ETHER_TYPE_IPv4);
@@ -205,7 +205,7 @@ pkt_burst_flow_gen(struct fwd_stream *fs)
                pkt->ol_flags           = ol_flags;
                pkt->vlan_tci           = vlan_tci;
                pkt->vlan_tci_outer     = vlan_tci_outer;
-               pkt->l2_len             = sizeof(struct ether_hdr);
+               pkt->l2_len             = sizeof(struct rte_ether_hdr);
                pkt->l3_len             = sizeof(struct ipv4_hdr);
                pkts_burst[nb_pkt]      = pkt;
 
index 062e3ea..49720ad 100644 (file)
@@ -221,7 +221,7 @@ ipv4_addr_to_dot(uint32_t be_ipv4_addr, char *buf)
 }
 
 static void
-ether_addr_dump(const char *what, const struct ether_addr *ea)
+ether_addr_dump(const char *what, const struct rte_ether_addr *ea)
 {
        char buf[ETHER_ADDR_FMT_SIZE];
 
@@ -275,12 +275,12 @@ reply_to_icmp_echo_rqsts(struct fwd_stream *fs)
 {
        struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
        struct rte_mbuf *pkt;
-       struct ether_hdr *eth_h;
-       struct vlan_hdr *vlan_h;
+       struct rte_ether_hdr *eth_h;
+       struct rte_vlan_hdr *vlan_h;
        struct rte_arp_hdr  *arp_h;
        struct ipv4_hdr *ip_h;
        struct icmp_hdr *icmp_h;
-       struct ether_addr eth_addr;
+       struct rte_ether_addr eth_addr;
        uint32_t retry;
        uint32_t ip_addr;
        uint16_t nb_rx;
@@ -321,9 +321,9 @@ reply_to_icmp_echo_rqsts(struct fwd_stream *fs)
                        rte_prefetch0(rte_pktmbuf_mtod(pkts_burst[i + 1],
                                                       void *));
                pkt = pkts_burst[i];
-               eth_h = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+               eth_h = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
                eth_type = RTE_BE_TO_CPU_16(eth_h->ether_type);
-               l2_len = sizeof(struct ether_hdr);
+               l2_len = sizeof(struct rte_ether_hdr);
                if (verbose_level > 0) {
                        printf("\nPort %d pkt-len=%u nb-segs=%u\n",
                               fs->rx_port, pkt->pkt_len, pkt->nb_segs);
@@ -331,9 +331,9 @@ reply_to_icmp_echo_rqsts(struct fwd_stream *fs)
                        ether_addr_dump(" dst=", &eth_h->d_addr);
                }
                if (eth_type == ETHER_TYPE_VLAN) {
-                       vlan_h = (struct vlan_hdr *)
-                               ((char *)eth_h + sizeof(struct ether_hdr));
-                       l2_len  += sizeof(struct vlan_hdr);
+                       vlan_h = (struct rte_vlan_hdr *)
+                               ((char *)eth_h + sizeof(struct rte_ether_hdr));
+                       l2_len  += sizeof(struct rte_vlan_hdr);
                        eth_type = rte_be_to_cpu_16(vlan_h->eth_proto);
                        if (verbose_level > 0) {
                                vlan_id = rte_be_to_cpu_16(vlan_h->vlan_tci)
index 6ae802c..c6aa3c6 100644 (file)
@@ -93,8 +93,8 @@ static void
 ieee1588_packet_fwd(struct fwd_stream *fs)
 {
        struct rte_mbuf  *mb;
-       struct ether_hdr *eth_hdr;
-       struct ether_addr addr;
+       struct rte_ether_hdr *eth_hdr;
+       struct rte_ether_addr addr;
        struct ptpv2_msg *ptp_hdr;
        uint16_t eth_type;
        uint32_t timesync_index;
@@ -111,7 +111,7 @@ ieee1588_packet_fwd(struct fwd_stream *fs)
         * Check that the received packet is a PTP packet that was detected
         * by the hardware.
         */
-       eth_hdr = rte_pktmbuf_mtod(mb, struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(mb, struct rte_ether_hdr *);
        eth_type = rte_be_to_cpu_16(eth_hdr->ether_type);
 
        if (! (mb->ol_flags & PKT_RX_IEEE1588_PTP)) {
@@ -141,7 +141,7 @@ ieee1588_packet_fwd(struct fwd_stream *fs)
         * PTP_SYNC_MESSAGE.
         */
        ptp_hdr = (struct ptpv2_msg *) (rte_pktmbuf_mtod(mb, char *) +
-                                       sizeof(struct ether_hdr));
+                                       sizeof(struct rte_ether_hdr));
        if (ptp_hdr->version != 0x02) {
                printf("Port %u Received PTP V2 Ethernet frame with wrong PTP"
                       " protocol version 0x%x (should be 0x02)\n",
index 7cac757..631f86f 100644 (file)
@@ -49,7 +49,7 @@ pkt_burst_mac_forward(struct fwd_stream *fs)
        struct rte_mbuf  *pkts_burst[MAX_PKT_BURST];
        struct rte_port  *txp;
        struct rte_mbuf  *mb;
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        uint32_t retry;
        uint16_t nb_rx;
        uint16_t nb_tx;
@@ -91,14 +91,14 @@ pkt_burst_mac_forward(struct fwd_stream *fs)
                        rte_prefetch0(rte_pktmbuf_mtod(pkts_burst[i + 1],
                                                       void *));
                mb = pkts_burst[i];
-               eth_hdr = rte_pktmbuf_mtod(mb, struct ether_hdr *);
+               eth_hdr = rte_pktmbuf_mtod(mb, struct rte_ether_hdr *);
                ether_addr_copy(&peer_eth_addrs[fs->peer_addr],
                                &eth_hdr->d_addr);
                ether_addr_copy(&ports[fs->tx_port].eth_addr,
                                &eth_hdr->s_addr);
                mb->ol_flags &= IND_ATTACHED_MBUF | EXT_ATTACHED_MBUF;
                mb->ol_flags |= ol_flags;
-               mb->l2_len = sizeof(struct ether_hdr);
+               mb->l2_len = sizeof(struct rte_ether_hdr);
                mb->l3_len = sizeof(struct ipv4_hdr);
                mb->vlan_tci = txp->tx_vlan_id;
                mb->vlan_tci_outer = txp->tx_vlan_id_outer;
index a8384d5..36d3857 100644 (file)
@@ -77,8 +77,8 @@ pkt_burst_mac_swap(struct fwd_stream *fs)
        struct rte_mbuf  *pkts_burst[MAX_PKT_BURST];
        struct rte_port  *txp;
        struct rte_mbuf  *mb;
-       struct ether_hdr *eth_hdr;
-       struct ether_addr addr;
+       struct rte_ether_hdr *eth_hdr;
+       struct rte_ether_addr addr;
        uint16_t nb_rx;
        uint16_t nb_tx;
        uint16_t i;
@@ -120,7 +120,7 @@ pkt_burst_mac_swap(struct fwd_stream *fs)
                        rte_prefetch0(rte_pktmbuf_mtod(pkts_burst[i + 1],
                                                       void *));
                mb = pkts_burst[i];
-               eth_hdr = rte_pktmbuf_mtod(mb, struct ether_hdr *);
+               eth_hdr = rte_pktmbuf_mtod(mb, struct rte_ether_hdr *);
 
                /* Swap dest and src mac addresses. */
                ether_addr_copy(&eth_hdr->d_addr, &addr);
@@ -129,7 +129,7 @@ pkt_burst_mac_swap(struct fwd_stream *fs)
 
                mb->ol_flags &= IND_ATTACHED_MBUF | EXT_ATTACHED_MBUF;
                mb->ol_flags |= ol_flags;
-               mb->l2_len = sizeof(struct ether_hdr);
+               mb->l2_len = sizeof(struct rte_ether_hdr);
                mb->l3_len = sizeof(struct ipv4_hdr);
                mb->vlan_tci = txp->tx_vlan_id;
                mb->vlan_tci_outer = txp->tx_vlan_id_outer;
index b057365..b8a9906 100644 (file)
@@ -137,7 +137,7 @@ uint8_t txring_numa[RTE_MAX_ETHPORTS];
  * Must be instantiated with the ethernet addresses of peer traffic generator
  * ports.
  */
-struct ether_addr peer_eth_addrs[RTE_MAX_ETHPORTS];
+struct rte_ether_addr peer_eth_addrs[RTE_MAX_ETHPORTS];
 portid_t nb_peer_eth_addrs = 0;
 
 /*
@@ -1969,7 +1969,7 @@ start_port(portid_t pid)
        portid_t pi;
        queueid_t qi;
        struct rte_port *port;
-       struct ether_addr mac_addr;
+       struct rte_ether_addr mac_addr;
        enum rte_eth_event_type event_type;
 
        if (port_id_is_invalid(pid, ENABLED_WARN))
index 3da728c..cc8618c 100644 (file)
@@ -160,7 +160,7 @@ struct softnic_port {
 struct rte_port {
        struct rte_eth_dev_info dev_info;   /**< PCI info + driver name */
        struct rte_eth_conf     dev_conf;   /**< Port configuration. */
-       struct ether_addr       eth_addr;   /**< Port ethernet address */
+       struct rte_ether_addr       eth_addr;   /**< Port ethernet address */
        struct rte_eth_stats    stats;      /**< Last port statistics */
        uint64_t                tx_dropped; /**< If no descriptor in TX ring */
        struct fwd_stream       *rx_stream; /**< Port RX stream, if unique */
@@ -187,7 +187,7 @@ struct rte_port {
        uint16_t                nb_tx_desc[MAX_QUEUE_ID+1]; /**< per queue tx desc number */
        struct rte_eth_rxconf   rx_conf[MAX_QUEUE_ID+1]; /**< per queue rx configuration */
        struct rte_eth_txconf   tx_conf[MAX_QUEUE_ID+1]; /**< per queue tx configuration */
-       struct ether_addr       *mc_addr_pool; /**< pool of multicast addrs */
+       struct rte_ether_addr       *mc_addr_pool; /**< pool of multicast addrs */
        uint32_t                mc_addr_nb; /**< nb. of addr. in mc_addr_pool */
        uint8_t                 slave_flag; /**< bonding slave port */
        struct port_flow        *flow_list; /**< Associated flows. */
@@ -451,7 +451,7 @@ extern struct fwd_stream **fwd_streams;
 extern uint16_t vxlan_gpe_udp_port; /**< UDP port of tunnel VXLAN-GPE. */
 
 extern portid_t nb_peer_eth_addrs; /**< Number of peer ethernet addresses. */
-extern struct ether_addr peer_eth_addrs[RTE_MAX_ETHPORTS];
+extern struct rte_ether_addr peer_eth_addrs[RTE_MAX_ETHPORTS];
 
 extern uint32_t burst_tx_delay_time; /**< Burst tx delay time(us) for mac-retry. */
 extern uint32_t burst_tx_retry_num;  /**< Burst tx retry number for mac-retry. */
@@ -743,8 +743,8 @@ void show_gro(portid_t port_id);
 void setup_gso(const char *mode, portid_t port_id);
 
 /* Functions to manage the set of filtered Multicast MAC addresses */
-void mcast_addr_add(portid_t port_id, struct ether_addr *mc_addr);
-void mcast_addr_remove(portid_t port_id, struct ether_addr *mc_addr);
+void mcast_addr_add(portid_t port_id, struct rte_ether_addr *mc_addr);
+void mcast_addr_remove(portid_t port_id, struct rte_ether_addr *mc_addr);
 void port_dcb_info_display(portid_t port_id);
 
 uint8_t *open_file(const char *file_path, uint32_t *size);
index 1f08b6e..3aa5e25 100644 (file)
@@ -158,7 +158,7 @@ pkt_burst_transmit(struct fwd_stream *fs)
        struct rte_mbuf *pkt;
        struct rte_mbuf *pkt_seg;
        struct rte_mempool *mbp;
-       struct ether_hdr eth_hdr;
+       struct rte_ether_hdr eth_hdr;
        uint16_t nb_tx;
        uint16_t nb_pkt;
        uint16_t vlan_tci, vlan_tci_outer;
@@ -236,9 +236,9 @@ pkt_burst_transmit(struct fwd_stream *fs)
                 */
                copy_buf_to_pkt(&eth_hdr, sizeof(eth_hdr), pkt, 0);
                copy_buf_to_pkt(&pkt_ip_hdr, sizeof(pkt_ip_hdr), pkt,
-                               sizeof(struct ether_hdr));
+                               sizeof(struct rte_ether_hdr));
                copy_buf_to_pkt(&pkt_udp_hdr, sizeof(pkt_udp_hdr), pkt,
-                               sizeof(struct ether_hdr) +
+                               sizeof(struct rte_ether_hdr) +
                                sizeof(struct ipv4_hdr));
 
                /*
@@ -250,7 +250,7 @@ pkt_burst_transmit(struct fwd_stream *fs)
                pkt->ol_flags = ol_flags;
                pkt->vlan_tci = vlan_tci;
                pkt->vlan_tci_outer = vlan_tci_outer;
-               pkt->l2_len = sizeof(struct ether_hdr);
+               pkt->l2_len = sizeof(struct rte_ether_hdr);
                pkt->l3_len = sizeof(struct ipv4_hdr);
                pkts_burst[nb_pkt] = pkt;
        }
@@ -296,7 +296,7 @@ tx_only_begin(__attribute__((unused)) portid_t pi)
 {
        uint16_t pkt_data_len;
 
-       pkt_data_len = (uint16_t) (tx_pkt_length - (sizeof(struct ether_hdr) +
+       pkt_data_len = (uint16_t) (tx_pkt_length - (sizeof(struct rte_ether_hdr) +
                                                    sizeof(struct ipv4_hdr) +
                                                    sizeof(struct udp_hdr)));
        setup_pkt_udp_ip_headers(&pkt_ip_hdr, &pkt_udp_hdr, pkt_data_len);
index f4125df..3181529 100644 (file)
@@ -14,7 +14,7 @@
 #include "testpmd.h"
 
 static inline void
-print_ether_addr(const char *what, struct ether_addr *eth_addr)
+print_ether_addr(const char *what, struct rte_ether_addr *eth_addr)
 {
        char buf[ETHER_ADDR_FMT_SIZE];
        ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr);
@@ -26,7 +26,7 @@ dump_pkt_burst(uint16_t port_id, uint16_t queue, struct rte_mbuf *pkts[],
              uint16_t nb_pkts, int is_rx)
 {
        struct rte_mbuf  *mb;
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        uint16_t eth_type;
        uint64_t ol_flags;
        uint16_t i, packet_type;
@@ -45,7 +45,7 @@ dump_pkt_burst(uint16_t port_id, uint16_t queue, struct rte_mbuf *pkts[],
               (unsigned int) nb_pkts);
        for (i = 0; i < nb_pkts; i++) {
                mb = pkts[i];
-               eth_hdr = rte_pktmbuf_mtod(mb, struct ether_hdr *);
+               eth_hdr = rte_pktmbuf_mtod(mb, struct rte_ether_hdr *);
                eth_type = RTE_BE_TO_CPU_16(eth_hdr->ether_type);
                ol_flags = mb->ol_flags;
                packet_type = mb->packet_type;
@@ -109,9 +109,9 @@ dump_pkt_burst(uint16_t port_id, uint16_t queue, struct rte_mbuf *pkts[],
                        uint8_t l3_len;
                        uint8_t l4_len;
                        uint8_t l4_proto;
-                       struct  vxlan_hdr *vxlan_hdr;
+                       struct  rte_vxlan_hdr *vxlan_hdr;
 
-                       l2_len  = sizeof(struct ether_hdr);
+                       l2_len  = sizeof(struct rte_ether_hdr);
 
                        /* Do not support ipv4 option field */
                        if (RTE_ETH_IS_IPV4_HDR(packet_type)) {
@@ -133,7 +133,7 @@ dump_pkt_burst(uint16_t port_id, uint16_t queue, struct rte_mbuf *pkts[],
                                l2_len + l3_len);
                                l4_len = sizeof(struct udp_hdr);
                                vxlan_hdr = rte_pktmbuf_mtod_offset(mb,
-                               struct vxlan_hdr *,
+                               struct rte_vxlan_hdr *,
                                l2_len + l3_len + l4_len);
                                udp_port = RTE_BE_TO_CPU_16(udp_hdr->dst_port);
                                vx_vni = rte_be_to_cpu_32(vxlan_hdr->vx_vni);
index 9de1444..fc9003a 100644 (file)
@@ -752,12 +752,12 @@ buffers using (**sw_trubo**) bbdev PMD.
         for (j = 0; j < op_num; j++) {
             /* Append the size of the ethernet header */
             rte_pktmbuf_append(input_pkts_burst[j],
-                    sizeof(struct ether_hdr));
+                    sizeof(struct rte_ether_hdr));
 
             /* set op */
 
             ops_burst[j]->turbo_enc.input.offset =
-                sizeof(struct ether_hdr);
+                sizeof(struct rte_ether_hdr);
 
             ops_burst[j]->turbo_enc->input.length =
                 rte_pktmbuf_pkt_len(bbdev_pkts[j]);
@@ -766,7 +766,7 @@ buffers using (**sw_trubo**) bbdev PMD.
                 input_pkts_burst[j];
 
             ops_burst[j]->turbo_enc->output.offset =
-                sizeof(struct ether_hdr);
+                sizeof(struct rte_ether_hdr);
 
             ops_burst[j]->turbo_enc->output.data =
                     output_pkts_burst[j];
index 003ed03..ae51c80 100644 (file)
@@ -91,7 +91,7 @@ initialisation of the ``Flow Classify`` application..
             .size = sizeof(uint8_t),
             .field_index = PROTO_FIELD_IPV4,
             .input_index = PROTO_INPUT_IPV4,
-            .offset = sizeof(struct ether_hdr) +
+            .offset = sizeof(struct rte_ether_hdr) +
                 offsetof(struct ipv4_hdr, next_proto_id),
         },
         /* next input field (IPv4 source address) - 4 consecutive bytes. */
@@ -101,7 +101,7 @@ initialisation of the ``Flow Classify`` application..
             .size = sizeof(uint32_t),
             .field_index = SRC_FIELD_IPV4,
             .input_index = SRC_INPUT_IPV4,
-            .offset = sizeof(struct ether_hdr) +
+            .offset = sizeof(struct rte_ether_hdr) +
                 offsetof(struct ipv4_hdr, src_addr),
         },
         /* next input field (IPv4 destination address) - 4 consecutive bytes. */
@@ -111,7 +111,7 @@ initialisation of the ``Flow Classify`` application..
             .size = sizeof(uint32_t),
             .field_index = DST_FIELD_IPV4,
             .input_index = DST_INPUT_IPV4,
-            .offset = sizeof(struct ether_hdr) +
+            .offset = sizeof(struct rte_ether_hdr) +
                 offsetof(struct ipv4_hdr, dst_addr),
         },
         /*
@@ -124,7 +124,7 @@ initialisation of the ``Flow Classify`` application..
             .size = sizeof(uint16_t),
             .field_index = SRCP_FIELD_IPV4,
             .input_index = SRCP_DESTP_INPUT_IPV4,
-            .offset = sizeof(struct ether_hdr) +
+            .offset = sizeof(struct rte_ether_hdr) +
                 sizeof(struct ipv4_hdr) +
                 offsetof(struct tcp_hdr, src_port),
         },
@@ -134,7 +134,7 @@ initialisation of the ``Flow Classify`` application..
              .size = sizeof(uint16_t),
              .field_index = DSTP_FIELD_IPV4,
              .input_index = SRCP_DESTP_INPUT_IPV4,
-             .offset = sizeof(struct ether_hdr) +
+             .offset = sizeof(struct rte_ether_hdr) +
                  sizeof(struct ipv4_hdr) +
                  offsetof(struct tcp_hdr, dst_port),
         },
@@ -275,7 +275,7 @@ Forwarding application is shown below:
     {
         struct rte_eth_conf port_conf = port_conf_default;
         const uint16_t rx_rings = 1, tx_rings = 1;
-        struct ether_addr addr;
+        struct rte_ether_addr addr;
         int retval;
         uint16_t q;
 
index 0d6fe2b..21f0170 100644 (file)
@@ -304,7 +304,7 @@ looks like the following:
    main_loop(void)
    {
            struct rte_mbuf *mbufs[32];
-           struct ether_hdr *eth_hdr;
+           struct rte_ether_hdr *eth_hdr;
            uint16_t nb_rx;
            uint16_t i;
            uint16_t j;
@@ -318,7 +318,7 @@ looks like the following:
                                            struct rte_mbuf *m = mbufs[j];
 
                                            eth_hdr = rte_pktmbuf_mtod(m,
-                                                        struct ether_hdr *);
+                                                        struct rte_ether_hdr *);
                                            print_ether_addr("src=",
                                                         &eth_hdr->s_addr);
                                            print_ether_addr(" - dst=",
@@ -348,7 +348,7 @@ queues and printing for each packet the destination queue:
                 if (nb_rx) {
                         for (j = 0; j < nb_rx; j++) {
                              struct rte_mbuf *m = mbufs[j];
-                             eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+                             eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
                              print_ether_addr("src=", &eth_hdr->s_addr);
                              print_ether_addr(" - dst=", &eth_hdr->d_addr);
                              printf(" - queue=0x%x", (unsigned int)i);
index ce1474e..8f2fb39 100644 (file)
@@ -146,7 +146,7 @@ Firstly, the Ethernet* header is removed from the packet and the IPv4 address is
 
     /* Remove the Ethernet header from the input packet */
 
-    iphdr = (struct ipv4_hdr *)rte_pktmbuf_adj(m, sizeof(struct ether_hdr));
+    iphdr = (struct ipv4_hdr *)rte_pktmbuf_adj(m, sizeof(struct rte_ether_hdr));
     RTE_ASSERT(iphdr != NULL);
     dest_addr = rte_be_to_cpu_32(iphdr->dst_addr);
 
@@ -216,14 +216,14 @@ The actual packet transmission is done in the mcast_send_pkt() function:
 
 .. code-block:: c
 
-    static inline void mcast_send_pkt(struct rte_mbuf *pkt, struct ether_addr *dest_addr, struct lcore_queue_conf *qconf, uint16_t port)
+    static inline void mcast_send_pkt(struct rte_mbuf *pkt, struct rte_ether_addr *dest_addr, struct lcore_queue_conf *qconf, uint16_t port)
     {
-        struct ether_hdr *ethdr;
+        struct rte_ether_hdr *ethdr;
         uint16_t len;
 
         /* Construct Ethernet header. */
 
-        ethdr = (struct ether_hdr *)rte_pktmbuf_prepend(pkt, (uint16_t) sizeof(*ethdr));
+        ethdr = (struct rte_ether_hdr *)rte_pktmbuf_prepend(pkt, (uint16_t) sizeof(*ethdr));
 
         RTE_ASSERT(ethdr != NULL);
 
index ba73d85..15ca6db 100644 (file)
@@ -451,13 +451,13 @@ Naturally, the number of ports in the portmask must be even, otherwise, the appl
     static void
     l2fwd_simple_forward(struct rte_mbuf *m, unsigned portid)
     {
-        struct ether_hdr *eth;
+        struct rte_ether_hdr *eth;
         void *tmp;
         unsigned dst_port;
 
         dst_port = l2fwd_dst_ports[portid];
 
-        eth = rte_pktmbuf_mtod(m, struct ether_hdr *);
+        eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
         /* 02:00:00:00:00:xx */
 
index 2b2d5af..33f7ee7 100644 (file)
@@ -367,13 +367,13 @@ Naturally, the number of ports in the portmask must be even, otherwise, the appl
     static void
     l2fwd_simple_forward(struct rte_mbuf *m, unsigned portid)
     {
-        struct ether_hdr *eth;
+        struct rte_ether_hdr *eth;
         void *tmp;
         unsigned dst_port;
 
         dst_port = l2fwd_dst_ports[portid];
 
-        eth = rte_pktmbuf_mtod(m, struct ether_hdr *);
+        eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
         /* 02:00:00:00:00:xx */
 
index ddd0f9a..58c4aae 100644 (file)
@@ -270,10 +270,10 @@ The key code snippet of simple_ipv4_fwd_4pkts() is shown below:
     {
         // ...
 
-        data[0] = _mm_loadu_si128(( m128i*)(rte_pktmbuf_mtod(m[0], unsigned char *) + sizeof(struct ether_hdr) + offsetof(struct ipv4_hdr, time_to_live)));
-        data[1] = _mm_loadu_si128(( m128i*)(rte_pktmbuf_mtod(m[1], unsigned char *) + sizeof(struct ether_hdr) + offsetof(struct ipv4_hdr, time_to_live)));
-        data[2] = _mm_loadu_si128(( m128i*)(rte_pktmbuf_mtod(m[2], unsigned char *) + sizeof(struct ether_hdr) + offsetof(struct ipv4_hdr, time_to_live)));
-        data[3] = _mm_loadu_si128(( m128i*)(rte_pktmbuf_mtod(m[3], unsigned char *) + sizeof(struct ether_hdr) + offsetof(struct ipv4_hdr, time_to_live)));
+        data[0] = _mm_loadu_si128(( m128i*)(rte_pktmbuf_mtod(m[0], unsigned char *) + sizeof(struct rte_ether_hdr) + offsetof(struct ipv4_hdr, time_to_live)));
+        data[1] = _mm_loadu_si128(( m128i*)(rte_pktmbuf_mtod(m[1], unsigned char *) + sizeof(struct rte_ether_hdr) + offsetof(struct ipv4_hdr, time_to_live)));
+        data[2] = _mm_loadu_si128(( m128i*)(rte_pktmbuf_mtod(m[2], unsigned char *) + sizeof(struct rte_ether_hdr) + offsetof(struct ipv4_hdr, time_to_live)));
+        data[3] = _mm_loadu_si128(( m128i*)(rte_pktmbuf_mtod(m[3], unsigned char *) + sizeof(struct rte_ether_hdr) + offsetof(struct ipv4_hdr, time_to_live)));
 
         key[0].xmm = _mm_and_si128(data[0], mask0);
         key[1].xmm = _mm_and_si128(data[1], mask0);
index 695c088..50baf34 100644 (file)
@@ -311,11 +311,11 @@ The processing is very simple: processes the TX port from the RX port and then r
     static void
     lsi_simple_forward(struct rte_mbuf *m, unsigned portid)
     {
-        struct ether_hdr *eth;
+        struct rte_ether_hdr *eth;
         void *tmp;
         unsigned dst_port = lsi_dst_ports[portid];
 
-        eth = rte_pktmbuf_mtod(m, struct ether_hdr *);
+        eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
         /* 02:00:00:00:00:xx */
 
index 53de503..8c16661 100644 (file)
@@ -212,17 +212,17 @@ PTP IEEE1588 L2 functionality.
     void
     parse_ptp_frames(uint16_t portid, struct rte_mbuf *m) {
         struct ptp_header *ptp_hdr;
-        struct ether_hdr *eth_hdr;
+        struct rte_ether_hdr *eth_hdr;
         uint16_t eth_type;
 
-        eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+        eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
         eth_type = rte_be_to_cpu_16(eth_hdr->ether_type);
 
         if (eth_type == PTP_PROTOCOL) {
             ptp_data.m = m;
             ptp_data.portid = portid;
             ptp_hdr = (struct ptp_header *)(rte_pktmbuf_mtod(m, char *)
-                        + sizeof(struct ether_hdr));
+                        + sizeof(struct rte_ether_hdr));
 
             switch (ptp_hdr->msgtype) {
             case SYNC:
index 85d96d8..36369dc 100644 (file)
@@ -79,7 +79,7 @@ comments:
     {
         struct rte_eth_conf port_conf = port_conf_default;
         const uint16_t rx_rings = 1, tx_rings = 1;
-        struct ether_addr addr;
+        struct rte_ether_addr addr;
         int retval;
         uint16_t q;
 
index adf258c..f7dab9e 100644 (file)
@@ -197,7 +197,7 @@ which tells the node where the packet has to be distributed.
         for (i = 0; i < rx_count; i++) {
             /* Handle IPv4 header.*/
             ipv4_hdr = rte_pktmbuf_mtod_offset(pkts[i], struct ipv4_hdr *,
-                    sizeof(struct ether_hdr));
+                    sizeof(struct rte_ether_hdr));
             ipv4_dst_ip[i] = ipv4_hdr->dst_addr;
             key_ptrs[i] = (void *)&ipv4_dst_ip[i];
         }
@@ -357,7 +357,7 @@ flow is not handled by the node.
         for (i = 0; i < num_packets; i++) {
             /* Handle IPv4 header.*/
             ipv4_hdr = rte_pktmbuf_mtod_offset(bufs[i], struct ipv4_hdr *,
-                    sizeof(struct ether_hdr));
+                    sizeof(struct rte_ether_hdr));
             ipv4_dst_ip[i] = ipv4_hdr->dst_addr;
             key_ptrs[i] = &ipv4_dst_ip[i];
         }
index 9595617..a73af75 100644 (file)
@@ -115,7 +115,7 @@ Forwarding application is shown below:
     {
         struct rte_eth_conf port_conf = port_conf_default;
         const uint16_t rx_rings = 1, tx_rings = 1;
-        struct ether_addr addr;
+        struct rte_ether_addr addr;
         int retval;
         uint16_t q;
 
index 0e9da97..eaf3850 100644 (file)
@@ -165,7 +165,7 @@ the MAC of VMDQ pool 2 on port 1 is 52:54:00:12:01:02.
     };
 
     /* pool mac addr template, pool mac addr is like: 52 54 00 12 port# pool# */
-    static struct ether_addr pool_addr_template = {
+    static struct rte_ether_addr pool_addr_template = {
         .addr_bytes = {0x52, 0x54, 0x00, 0x12, 0x00, 0x00}
     };
 
@@ -225,7 +225,7 @@ the MAC of VMDQ pool 2 on port 1 is 52:54:00:12:01:02.
 
     /* Set mac for each pool.*/
     for (q = 0; q < num_pools; q++) {
-        struct ether_addr mac;
+        struct rte_ether_addr mac;
         mac = pool_addr_template;
         mac.addr_bytes[4] = port;
         mac.addr_bytes[5] = q;
index 15bf73a..d6eebc8 100644 (file)
@@ -314,7 +314,7 @@ struct fman_if {
        /* The index of this MAC (within the Fman it belongs to) */
        uint8_t mac_idx;
        /* The MAC address */
-       struct ether_addr mac_addr;
+       struct rte_ether_addr mac_addr;
        /* The Qman channel to schedule Tx FQs to */
        u16 tx_channel_id;
        /* The hard-coded FQIDs for this interface. Note: this doesn't cover
index 7818de6..bf7bfae 100644 (file)
@@ -30,8 +30,8 @@ struct netcfg_info {
 
 struct interface_info {
        char *name;
-       struct ether_addr mac_addr;
-       struct ether_addr peer_mac;
+       struct rte_ether_addr mac_addr;
+       struct rte_ether_addr peer_mac;
        int mac_present;
        int fman_enabled_mac_interface;
 };
index 376d763..b38e8ee 100644 (file)
@@ -72,7 +72,7 @@ struct pmd_internals {
 
        int if_index;
        char *if_name;
-       struct ether_addr eth_addr;
+       struct rte_ether_addr eth_addr;
 
        struct tpacket_req req;
 
index c26f076..bc15add 100644 (file)
@@ -41,9 +41,9 @@ static int eth_ark_dev_stats_get(struct rte_eth_dev *dev,
                                  struct rte_eth_stats *stats);
 static void eth_ark_dev_stats_reset(struct rte_eth_dev *dev);
 static int eth_ark_set_default_mac_addr(struct rte_eth_dev *dev,
-                                        struct ether_addr *mac_addr);
+                                        struct rte_ether_addr *mac_addr);
 static int eth_ark_macaddr_add(struct rte_eth_dev *dev,
-                              struct ether_addr *mac_addr,
+                              struct rte_ether_addr *mac_addr,
                               uint32_t index,
                               uint32_t pool);
 static void eth_ark_macaddr_remove(struct rte_eth_dev *dev,
@@ -220,14 +220,14 @@ check_for_ext(struct ark_adapter *ark)
                (void (*)(struct rte_eth_dev *, void *))
                dlsym(ark->d_handle, "stats_reset");
        ark->user_ext.mac_addr_add =
-               (void (*)(struct rte_eth_dev *, struct ether_addr *, uint32_t,
+               (void (*)(struct rte_eth_dev *, struct rte_ether_addr *, uint32_t,
                          uint32_t, void *))
                dlsym(ark->d_handle, "mac_addr_add");
        ark->user_ext.mac_addr_remove =
                (void (*)(struct rte_eth_dev *, uint32_t, void *))
                dlsym(ark->d_handle, "mac_addr_remove");
        ark->user_ext.mac_addr_set =
-               (void (*)(struct rte_eth_dev *, struct ether_addr *,
+               (void (*)(struct rte_eth_dev *, struct rte_ether_addr *,
                          void *))
                dlsym(ark->d_handle, "mac_addr_set");
        ark->user_ext.set_mtu =
@@ -834,7 +834,7 @@ eth_ark_dev_stats_reset(struct rte_eth_dev *dev)
 
 static int
 eth_ark_macaddr_add(struct rte_eth_dev *dev,
-                   struct ether_addr *mac_addr,
+                   struct rte_ether_addr *mac_addr,
                    uint32_t index,
                    uint32_t pool)
 {
@@ -865,7 +865,7 @@ eth_ark_macaddr_remove(struct rte_eth_dev *dev, uint32_t index)
 
 static int
 eth_ark_set_default_mac_addr(struct rte_eth_dev *dev,
-                            struct ether_addr *mac_addr)
+                            struct rte_ether_addr *mac_addr)
 {
        struct ark_adapter *ark =
                (struct ark_adapter *)dev->data->dev_private;
index f5af215..5a987e4 100644 (file)
@@ -70,7 +70,7 @@ void stats_reset(struct rte_eth_dev *dev,
                 void *user_data);
 
 void mac_addr_add(struct rte_eth_dev *dev,
-                 struct ether_addr *macadr,
+                 struct rte_ether_addr *macadr,
                  uint32_t index,
                  uint32_t pool,
                  void *user_data);
@@ -80,7 +80,7 @@ void mac_addr_remove(struct rte_eth_dev *dev,
                     void *user_data);
 
 void mac_addr_set(struct rte_eth_dev *dev,
-                 struct ether_addr *mac_addr,
+                 struct rte_ether_addr *mac_addr,
                  void *user_data);
 
 int set_mtu(struct rte_eth_dev *dev,
index f820091..f660905 100644 (file)
@@ -71,12 +71,12 @@ struct ark_user_ext {
        int (*stats_get)(struct rte_eth_dev *, struct rte_eth_stats *, void *);
        void (*stats_reset)(struct rte_eth_dev *, void *);
        void (*mac_addr_add)(struct rte_eth_dev *,
-                                                 struct ether_addr *,
+                                                 struct rte_ether_addr *,
                                                 uint32_t,
                                                 uint32_t,
                                                 void *);
        void (*mac_addr_remove)(struct rte_eth_dev *, uint32_t, void *);
-       void (*mac_addr_set)(struct rte_eth_dev *, struct ether_addr *, void *);
+       void (*mac_addr_set)(struct rte_eth_dev *, struct rte_ether_addr *, void *);
        int (*set_mtu)(struct rte_eth_dev *, uint16_t, void *);
 };
 
index 5bc04f5..5be9e52 100644 (file)
@@ -91,14 +91,14 @@ static void atl_dev_interrupt_handler(void *param);
 
 
 static int atl_add_mac_addr(struct rte_eth_dev *dev,
-                           struct ether_addr *mac_addr,
+                           struct rte_ether_addr *mac_addr,
                            uint32_t index, uint32_t pool);
 static void atl_remove_mac_addr(struct rte_eth_dev *dev, uint32_t index);
 static int atl_set_default_mac_addr(struct rte_eth_dev *dev,
-                                          struct ether_addr *mac_addr);
+                                          struct rte_ether_addr *mac_addr);
 
 static int atl_dev_set_mc_addr_list(struct rte_eth_dev *dev,
-                                   struct ether_addr *mc_addr_set,
+                                   struct rte_ether_addr *mc_addr_set,
                                    uint32_t nb_mc_addr);
 
 /* RSS */
@@ -1226,7 +1226,7 @@ atl_update_mac_addr(struct rte_eth_dev *dev, uint32_t index,
 }
 
 static int
-atl_add_mac_addr(struct rte_eth_dev *dev, struct ether_addr *mac_addr,
+atl_add_mac_addr(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
                        uint32_t index __rte_unused, uint32_t pool __rte_unused)
 {
        if (is_zero_ether_addr(mac_addr)) {
@@ -1244,7 +1244,7 @@ atl_remove_mac_addr(struct rte_eth_dev *dev, uint32_t index)
 }
 
 static int
-atl_set_default_mac_addr(struct rte_eth_dev *dev, struct ether_addr *addr)
+atl_set_default_mac_addr(struct rte_eth_dev *dev, struct rte_ether_addr *addr)
 {
        atl_remove_mac_addr(dev, 0);
        atl_add_mac_addr(dev, addr, 0, 0);
@@ -1411,7 +1411,7 @@ atl_vlan_strip_queue_set(struct rte_eth_dev *dev, uint16_t queue_id, int on)
 
 static int
 atl_dev_set_mc_addr_list(struct rte_eth_dev *dev,
-                         struct ether_addr *mc_addr_set,
+                         struct rte_ether_addr *mc_addr_set,
                          uint32_t nb_mc_addr)
 {
        struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
index f11093a..401bd11 100644 (file)
@@ -654,8 +654,8 @@ static int hw_atl_utils_get_mac_permanent(struct aq_hw_s *self,
                mac_addr[1] = rte_constant_bswap32(mac_addr[1]);
        }
 
-       ether_addr_copy((struct ether_addr *)mac_addr,
-                       (struct ether_addr *)mac);
+       ether_addr_copy((struct rte_ether_addr *)mac_addr,
+                       (struct rte_ether_addr *)mac);
 
        if ((mac[0] & 0x01U) || ((mac[0] | mac[1] | mac[2]) == 0x00U)) {
                /* chip revision */
@@ -865,8 +865,8 @@ static int aq_fw1x_set_wol(struct aq_hw_s *self, bool wol_enabled, u8 *mac)
                prpc->msg_wol.pattern_id = 1U;
                prpc->msg_wol.wol_packet_type = 2U; /* Magic Packet */
 
-               ether_addr_copy((struct ether_addr *)mac,
-                       (struct ether_addr *)&prpc->msg_wol.wol_pattern);
+               ether_addr_copy((struct rte_ether_addr *)mac,
+                       (struct rte_ether_addr *)&prpc->msg_wol.wol_pattern);
        } else {
                rpc_size = sizeof(prpc->msg_id) + sizeof(prpc->msg_del_id);
 
index 6841d9b..1fc18bb 100644 (file)
@@ -218,8 +218,8 @@ int aq_fw2x_get_mac_permanent(struct aq_hw_s *self, u8 *mac)
                mac_addr[1] = rte_constant_bswap32(mac_addr[1]);
        }
 
-       ether_addr_copy((struct ether_addr *)mac_addr,
-                       (struct ether_addr *)mac);
+       ether_addr_copy((struct rte_ether_addr *)mac_addr,
+                       (struct rte_ether_addr *)mac);
 
        if ((mac[0] & 0x01U) || ((mac[0] | mac[1] | mac[2]) == 0x00U)) {
                unsigned int rnd = (uint32_t)rte_rand();
index dcf8d1c..be43f34 100644 (file)
@@ -211,6 +211,6 @@ int avf_query_stats(struct avf_adapter *adapter,
 int avf_config_promisc(struct avf_adapter *adapter, bool enable_unicast,
                       bool enable_multicast);
 int avf_add_del_eth_addr(struct avf_adapter *adapter,
-                        struct ether_addr *addr, bool add);
+                        struct rte_ether_addr *addr, bool add);
 int avf_add_del_vlan(struct avf_adapter *adapter, uint16_t vlanid, bool add);
 #endif /* _AVF_ETHDEV_H_ */
index e56d57c..523911e 100644 (file)
@@ -47,7 +47,7 @@ static void avf_dev_promiscuous_disable(struct rte_eth_dev *dev);
 static void avf_dev_allmulticast_enable(struct rte_eth_dev *dev);
 static void avf_dev_allmulticast_disable(struct rte_eth_dev *dev);
 static int avf_dev_add_mac_addr(struct rte_eth_dev *dev,
-                               struct ether_addr *addr,
+                               struct rte_ether_addr *addr,
                                uint32_t index,
                                uint32_t pool);
 static void avf_dev_del_mac_addr(struct rte_eth_dev *dev, uint32_t index);
@@ -66,7 +66,7 @@ static int avf_dev_rss_hash_conf_get(struct rte_eth_dev *dev,
                                     struct rte_eth_rss_conf *rss_conf);
 static int avf_dev_mtu_set(struct rte_eth_dev *dev, uint16_t mtu);
 static int avf_dev_set_default_mac_addr(struct rte_eth_dev *dev,
-                                        struct ether_addr *mac_addr);
+                                        struct rte_ether_addr *mac_addr);
 static int avf_dev_rx_queue_intr_enable(struct rte_eth_dev *dev,
                                        uint16_t queue_id);
 static int avf_dev_rx_queue_intr_disable(struct rte_eth_dev *dev,
@@ -687,7 +687,7 @@ avf_dev_allmulticast_disable(struct rte_eth_dev *dev)
 }
 
 static int
-avf_dev_add_mac_addr(struct rte_eth_dev *dev, struct ether_addr *addr,
+avf_dev_add_mac_addr(struct rte_eth_dev *dev, struct rte_ether_addr *addr,
                     __rte_unused uint32_t index,
                     __rte_unused uint32_t pool)
 {
@@ -718,7 +718,7 @@ avf_dev_del_mac_addr(struct rte_eth_dev *dev, uint32_t index)
        struct avf_adapter *adapter =
                AVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
        struct avf_info *vf = AVF_DEV_PRIVATE_TO_VF(adapter);
-       struct ether_addr *addr;
+       struct rte_ether_addr *addr;
        int err;
 
        addr = &dev->data->mac_addrs[index];
@@ -930,16 +930,16 @@ avf_dev_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
 
 static int
 avf_dev_set_default_mac_addr(struct rte_eth_dev *dev,
-                            struct ether_addr *mac_addr)
+                            struct rte_ether_addr *mac_addr)
 {
        struct avf_adapter *adapter =
                AVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
        struct avf_hw *hw = AVF_DEV_PRIVATE_TO_HW(adapter);
-       struct ether_addr *perm_addr, *old_addr;
+       struct rte_ether_addr *perm_addr, *old_addr;
        int ret;
 
-       old_addr = (struct ether_addr *)hw->mac.addr;
-       perm_addr = (struct ether_addr *)hw->mac.perm_addr;
+       old_addr = (struct rte_ether_addr *)hw->mac.addr;
+       perm_addr = (struct rte_ether_addr *)hw->mac.perm_addr;
 
        if (is_same_ether_addr(mac_addr, old_addr))
                return 0;
@@ -973,7 +973,7 @@ avf_dev_set_default_mac_addr(struct rte_eth_dev *dev,
        if (ret)
                return -EIO;
 
-       ether_addr_copy(mac_addr, (struct ether_addr *)hw->mac.addr);
+       ether_addr_copy(mac_addr, (struct rte_ether_addr *)hw->mac.addr);
        return 0;
 }
 
@@ -1244,9 +1244,9 @@ avf_dev_init(struct rte_eth_dev *eth_dev)
        /* If the MAC address is not configured by host,
         * generate a random one.
         */
-       if (!is_valid_assigned_ether_addr((struct ether_addr *)hw->mac.addr))
+       if (!is_valid_assigned_ether_addr((struct rte_ether_addr *)hw->mac.addr))
                eth_random_addr(hw->mac.addr);
-       ether_addr_copy((struct ether_addr *)hw->mac.addr,
+       ether_addr_copy((struct rte_ether_addr *)hw->mac.addr,
                        &eth_dev->data->mac_addrs[0]);
 
        /* register callback func to eal lib */
index fd90cc2..6ccd7a1 100644 (file)
@@ -636,7 +636,7 @@ avf_add_del_all_mac_addr(struct avf_adapter *adapter, bool add)
 {
        struct virtchnl_ether_addr_list *list;
        struct avf_info *vf = AVF_DEV_PRIVATE_TO_VF(adapter);
-       struct ether_addr *addr;
+       struct rte_ether_addr *addr;
        struct avf_cmd_info args;
        int len, err, i, j;
        int next_begin = 0;
@@ -753,7 +753,7 @@ avf_config_promisc(struct avf_adapter *adapter,
 }
 
 int
-avf_add_del_eth_addr(struct avf_adapter *adapter, struct ether_addr *addr,
+avf_add_del_eth_addr(struct avf_adapter *adapter, struct rte_ether_addr *addr,
                     bool add)
 {
        struct virtchnl_ether_addr_list *list;
index 0f8ccb9..834b1f3 100644 (file)
@@ -159,7 +159,7 @@ static const struct eth_dev_ops avp_eth_dev_ops = {
 struct avp_dev {
        uint32_t magic; /**< Memory validation marker */
        uint64_t device_id; /**< Unique system identifier */
-       struct ether_addr ethaddr; /**< Host specified MAC address */
+       struct rte_ether_addr ethaddr; /**< Host specified MAC address */
        struct rte_eth_dev_data *dev_data;
        /**< Back pointer to ethernet device data */
        volatile uint32_t flags; /**< Device operational flags */
@@ -1204,7 +1204,7 @@ avp_dev_tx_queue_setup(struct rte_eth_dev *eth_dev,
 }
 
 static inline int
-_avp_cmp_ether_addr(struct ether_addr *a, struct ether_addr *b)
+_avp_cmp_ether_addr(struct rte_ether_addr *a, struct rte_ether_addr *b)
 {
        uint16_t *_a = (uint16_t *)&a->addr_bytes[0];
        uint16_t *_b = (uint16_t *)&b->addr_bytes[0];
@@ -1214,7 +1214,7 @@ _avp_cmp_ether_addr(struct ether_addr *a, struct ether_addr *b)
 static inline int
 _avp_mac_filter(struct avp_dev *avp, struct rte_mbuf *m)
 {
-       struct ether_hdr *eth = rte_pktmbuf_mtod(m, struct 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)) {
                /* allow all packets destined to our address */
index b1cd298..810ac4a 100644 (file)
@@ -539,7 +539,7 @@ struct axgbe_port {
        /* Hardware features of the device */
        struct axgbe_hw_features hw_feat;
 
-       struct ether_addr mac_addr;
+       struct rte_ether_addr mac_addr;
 
        /* Software Tx/Rx structure pointers*/
        void **rx_queues;
index 2797593..f3e2355 100644 (file)
@@ -2168,8 +2168,8 @@ int bnx2x_tx_encap(struct bnx2x_tx_queue *txq, struct rte_mbuf *m0)
                        tx_start_bd->vlan_or_ethertype =
                            rte_cpu_to_le_16(pkt_prod);
                else {
-                       struct ether_hdr *eh =
-                           rte_pktmbuf_mtod(m0, struct ether_hdr *);
+                       struct rte_ether_hdr *eh =
+                           rte_pktmbuf_mtod(m0, struct rte_ether_hdr *);
 
                        tx_start_bd->vlan_or_ethertype =
                            rte_cpu_to_le_16(rte_be_to_cpu_16(eh->ether_type));
@@ -2179,8 +2179,8 @@ int bnx2x_tx_encap(struct bnx2x_tx_queue *txq, struct rte_mbuf *m0)
        bd_prod = NEXT_TX_BD(bd_prod);
        if (IS_VF(sc)) {
                struct eth_tx_parse_bd_e2 *tx_parse_bd;
-               const struct ether_hdr *eh =
-                   rte_pktmbuf_mtod(m0, struct ether_hdr *);
+               const struct rte_ether_hdr *eh =
+                   rte_pktmbuf_mtod(m0, struct rte_ether_hdr *);
                uint8_t mac_type = UNICAST_ADDRESS;
 
                tx_parse_bd =
index 0057843..37fd770 100644 (file)
@@ -498,7 +498,7 @@ bnx2x_dev_infos_get(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info)
 }
 
 static int
-bnx2x_mac_addr_add(struct rte_eth_dev *dev, struct ether_addr *mac_addr,
+bnx2x_mac_addr_add(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
                uint32_t index, uint32_t pool)
 {
        struct bnx2x_softc *sc = dev->data->dev_private;
@@ -643,7 +643,7 @@ bnx2x_common_dev_init(struct rte_eth_dev *eth_dev, int is_vf)
                }
        }
 
-       eth_dev->data->mac_addrs = (struct ether_addr *)sc->link_params.mac_addr;
+       eth_dev->data->mac_addrs = (struct rte_ether_addr *)sc->link_params.mac_addr;
 
        PMD_DRV_LOG(INFO, sc, "pcie_bus=%d, pcie_device=%d",
                        sc->pcie_bus, sc->pcie_device);
index 807ba17..c09f2f5 100644 (file)
@@ -74,7 +74,7 @@
 
 /* MAC address operations */
 struct bnx2x_mac_ops {
-       void (*mac_addr_add)(struct rte_eth_dev *dev, struct ether_addr *addr,
+       void (*mac_addr_add)(struct rte_eth_dev *dev, struct rte_ether_addr *addr,
                        uint16_t index, uint32_t pool);                           /* not implemented yet */
        void (*mac_addr_remove)(struct rte_eth_dev *dev, uint16_t index); /* not implemented yet */
 };
index 048bf12..a044e6e 100644 (file)
@@ -302,7 +302,7 @@ int bnx2x_vf_get_resources(struct bnx2x_softc *sc, uint8_t tx_count, uint8_t rx_
 
        if (is_valid_assigned_ether_addr(&sc_resp.resc.current_mac_addr))
                ether_addr_copy(&sc_resp.resc.current_mac_addr,
-                               (struct ether_addr *)sc->link_params.mac_addr);
+                               (struct rte_ether_addr *)sc->link_params.mac_addr);
        else
                eth_random_addr(sc->link_params.mac_addr);
 
index cc6fef9..6964c9d 100644 (file)
@@ -115,7 +115,7 @@ struct vf_resc {
        uint8_t num_vlan_filters;
        uint8_t num_mc_filters;
        uint8_t permanent_mac_addr[ETH_ALEN];
-       struct ether_addr current_mac_addr;
+       struct rte_ether_addr current_mac_addr;
        uint16_t pf_link_speed;
        uint32_t pf_link_supported;
 };
index c11fe9c..3f2404a 100644 (file)
@@ -760,7 +760,7 @@ static void bnxt_mac_addr_remove_op(struct rte_eth_dev *eth_dev,
 }
 
 static int bnxt_mac_addr_add_op(struct rte_eth_dev *eth_dev,
-                               struct ether_addr *mac_addr,
+                               struct rte_ether_addr *mac_addr,
                                uint32_t index, uint32_t pool)
 {
        struct bnxt *bp = (struct bnxt *)eth_dev->data->dev_private;
@@ -1451,7 +1451,7 @@ bnxt_vlan_offload_set_op(struct rte_eth_dev *dev, int mask)
 }
 
 static int
-bnxt_set_default_mac_addr_op(struct rte_eth_dev *dev, struct ether_addr *addr)
+bnxt_set_default_mac_addr_op(struct rte_eth_dev *dev, struct rte_ether_addr *addr)
 {
        struct bnxt *bp = (struct bnxt *)dev->data->dev_private;
        /* Default Filter is tied to VNIC 0 */
@@ -1489,7 +1489,7 @@ bnxt_set_default_mac_addr_op(struct rte_eth_dev *dev, struct ether_addr *addr)
 
 static int
 bnxt_dev_set_mc_addr_list_op(struct rte_eth_dev *eth_dev,
-                         struct ether_addr *mc_addr_set,
+                         struct rte_ether_addr *mc_addr_set,
                          uint32_t nb_mc_addr)
 {
        struct bnxt *bp = (struct bnxt *)eth_dev->data->dev_private;
index 9999760..b6f7612 100644 (file)
@@ -2578,7 +2578,7 @@ static void add_random_mac_if_needed(struct bnxt *bp,
                                     struct hwrm_func_cfg_input *cfg_req,
                                     int vf)
 {
-       struct ether_addr mac;
+       struct rte_ether_addr mac;
 
        if (bnxt_hwrm_func_qcfg_vf_default_mac(bp, vf, &mac))
                return;
@@ -3112,7 +3112,7 @@ int bnxt_hwrm_reject_fwd_resp(struct bnxt *bp, uint16_t target_id,
 }
 
 int bnxt_hwrm_func_qcfg_vf_default_mac(struct bnxt *bp, uint16_t vf,
-                                      struct ether_addr *mac)
+                                      struct rte_ether_addr *mac)
 {
        struct hwrm_func_qcfg_input req = {0};
        struct hwrm_func_qcfg_output *resp = bp->hwrm_cmd_resp_addr;
index ec9b3e0..53d79f0 100644 (file)
@@ -130,7 +130,7 @@ int bnxt_hwrm_func_bw_cfg(struct bnxt *bp, uint16_t vf,
                        uint16_t max_bw, uint16_t enables);
 int bnxt_hwrm_set_vf_vlan(struct bnxt *bp, int vf);
 int bnxt_hwrm_func_qcfg_vf_default_mac(struct bnxt *bp, uint16_t vf,
-                                      struct ether_addr *mac);
+                                      struct rte_ether_addr *mac);
 int bnxt_hwrm_func_qcfg_current_vf_vlan(struct bnxt *bp, int vf);
 int bnxt_hwrm_tunnel_dst_port_alloc(struct bnxt *bp, uint16_t port,
                                uint8_t tunnel_type);
index c298de8..5e3d1bf 100644 (file)
@@ -132,7 +132,7 @@ int rte_pmd_bnxt_set_all_queues_drop_en(uint16_t port, uint8_t on)
 }
 
 int rte_pmd_bnxt_set_vf_mac_addr(uint16_t port, uint16_t vf,
-                               struct ether_addr *mac_addr)
+                               struct rte_ether_addr *mac_addr)
 {
        struct rte_eth_dev *dev;
        struct rte_eth_dev_info dev_info;
@@ -647,7 +647,7 @@ int rte_pmd_bnxt_get_vf_tx_drop_count(uint16_t port, uint16_t vf_id,
                                             count);
 }
 
-int rte_pmd_bnxt_mac_addr_add(uint16_t port, struct ether_addr *addr,
+int rte_pmd_bnxt_mac_addr_add(uint16_t port, struct rte_ether_addr *addr,
                                uint32_t vf_id)
 {
        struct rte_eth_dev *dev;
@@ -655,7 +655,7 @@ int rte_pmd_bnxt_mac_addr_add(uint16_t port, struct ether_addr *addr,
        struct bnxt *bp;
        struct bnxt_filter_info *filter;
        struct bnxt_vnic_info vnic;
-       struct ether_addr dflt_mac;
+       struct rte_ether_addr dflt_mac;
        int rc;
 
        dev = &rte_eth_devices[port];
index 68fbe34..2e893cc 100644 (file)
@@ -67,7 +67,7 @@ int rte_pmd_bnxt_set_vf_mac_anti_spoof(uint16_t port, uint16_t vf, uint8_t on);
  *   - (-EINVAL) if *vf* or *mac_addr* is invalid.
  */
 int rte_pmd_bnxt_set_vf_mac_addr(uint16_t port, uint16_t vf,
-               struct ether_addr *mac_addr);
+               struct rte_ether_addr *mac_addr);
 
 /**
  * Enable/Disable vf vlan strip for all queues in a pool
@@ -303,7 +303,7 @@ int rte_pmd_bnxt_get_vf_tx_drop_count(uint16_t port, uint16_t vf_id,
  *   - (-ENOTSUP) Ethernet device is not a PF
  *   - (-ENOMEM) on an allocation failure
  */
-int rte_pmd_bnxt_mac_addr_add(uint16_t port, struct ether_addr *mac_addr,
+int rte_pmd_bnxt_mac_addr_add(uint16_t port, struct rte_ether_addr *mac_addr,
                                uint32_t vf_id);
 
 /**
index b668ff9..874aa91 100644 (file)
@@ -225,7 +225,7 @@ rte_eth_bond_active_slaves_get(uint16_t bonded_port_id, uint16_t slaves[],
  */
 int
 rte_eth_bond_mac_address_set(uint16_t bonded_port_id,
-               struct ether_addr *mac_addr);
+               struct rte_ether_addr *mac_addr);
 
 /**
  * Reset bonded device to use MAC from primary slave on bonded device and it's
index f8cea4b..608d754 100644 (file)
@@ -126,7 +126,7 @@ bond_print_lacp(struct lacpdu *l)
 #define MODE4_DEBUG(fmt, ...) do { } while (0)
 #endif
 
-static const struct ether_addr lacp_mac_addr = {
+static const struct rte_ether_addr lacp_mac_addr = {
        .addr_bytes = { 0x01, 0x80, 0xC2, 0x00, 0x00, 0x02 }
 };
 
@@ -803,7 +803,7 @@ bond_mode_8023ad_periodic_cb(void *arg)
        struct bond_dev_private *internals = bond_dev->data->dev_private;
        struct port *port;
        struct rte_eth_link link_info;
-       struct ether_addr slave_addr;
+       struct rte_ether_addr slave_addr;
        struct rte_mbuf *lacp_pkt = NULL;
 
        uint8_t i, slave_id;
@@ -1037,7 +1037,7 @@ void
 bond_mode_8023ad_mac_address_update(struct rte_eth_dev *bond_dev)
 {
        struct bond_dev_private *internals = bond_dev->data->dev_private;
-       struct ether_addr slave_addr;
+       struct rte_ether_addr slave_addr;
        struct port *slave, *agg_slave;
        uint16_t slave_id, i, j;
 
index d8b5dbc..cbad59a 100644 (file)
@@ -58,14 +58,14 @@ struct slow_protocol {
 
 /** Generic slow protocol frame type structure */
 struct slow_protocol_frame {
-       struct ether_hdr eth_hdr;
+       struct rte_ether_hdr eth_hdr;
        struct slow_protocol slow_protocol;
 } __attribute__((__packed__));
 
 struct port_params {
        uint16_t system_priority;
        /**< System priority (unused in current implementation) */
-       struct ether_addr system;
+       struct rte_ether_addr system;
        /**< System ID - Slave MAC address, same as bonding MAC address */
        uint16_t key;
        /**< Speed information (implementation dependednt) and duplex. */
@@ -103,7 +103,7 @@ struct lacpdu {
 
 /** LACPDU frame: Contains ethernet header and LACPDU. */
 struct lacpdu_header {
-       struct ether_hdr eth_hdr;
+       struct rte_ether_hdr eth_hdr;
        struct lacpdu lacpdu;
 } __attribute__((__packed__));
 
@@ -114,7 +114,7 @@ struct marker {
        uint8_t tlv_type_marker;
        uint8_t info_length;
        uint16_t requester_port;
-       struct ether_addr requester_system;
+       struct rte_ether_addr requester_system;
        uint32_t requester_transaction_id;
        uint8_t reserved_2[2];
 
@@ -124,7 +124,7 @@ struct marker {
 } __attribute__((__packed__));
 
 struct marker_header {
-       struct ether_hdr eth_hdr;
+       struct rte_ether_hdr eth_hdr;
        struct marker marker;
 } __attribute__((__packed__));
 
index 7ae2403..24b2b50 100644 (file)
@@ -72,7 +72,7 @@ mempool_alloc_error:
        return -ENOMEM;
 }
 
-void bond_mode_alb_arp_recv(struct ether_hdr *eth_h, uint16_t offset,
+void bond_mode_alb_arp_recv(struct rte_ether_hdr *eth_h, uint16_t offset,
                struct bond_dev_private *internals) {
        struct rte_arp_hdr *arp;
 
@@ -102,7 +102,7 @@ void bond_mode_alb_arp_recv(struct ether_hdr *eth_h, uint16_t offset,
                        client_info->app_ip != arp->arp_data.arp_tip ||
                        client_info->cli_ip != arp->arp_data.arp_sip ||
                        !is_same_ether_addr(&client_info->cli_mac, &arp->arp_data.arp_sha) ||
-                       client_info->vlan_count != offset / sizeof(struct vlan_hdr) ||
+                       client_info->vlan_count != offset / sizeof(struct rte_vlan_hdr) ||
                        memcmp(client_info->vlan, eth_h + 1, offset) != 0
        ) {
                client_info->in_use = 1;
@@ -113,14 +113,14 @@ void bond_mode_alb_arp_recv(struct ether_hdr *eth_h, uint16_t offset,
                rte_eth_macaddr_get(client_info->slave_idx, &client_info->app_mac);
                ether_addr_copy(&client_info->app_mac, &arp->arp_data.arp_tha);
                memcpy(client_info->vlan, eth_h + 1, offset);
-               client_info->vlan_count = offset / sizeof(struct vlan_hdr);
+               client_info->vlan_count = offset / sizeof(struct rte_vlan_hdr);
        }
        internals->mode6.ntt = 1;
        rte_spinlock_unlock(&internals->mode6.lock);
 }
 
 uint16_t
-bond_mode_alb_arp_xmit(struct ether_hdr *eth_h, uint16_t offset,
+bond_mode_alb_arp_xmit(struct rte_ether_hdr *eth_h, uint16_t offset,
                struct bond_dev_private *internals)
 {
        struct rte_arp_hdr *arp;
@@ -130,7 +130,7 @@ bond_mode_alb_arp_xmit(struct ether_hdr *eth_h, uint16_t offset,
 
        uint8_t hash_index;
 
-       struct ether_addr bonding_mac;
+       struct rte_ether_addr bonding_mac;
 
        arp = (struct rte_arp_hdr *)((char *)(eth_h + 1) + offset);
 
@@ -163,7 +163,7 @@ bond_mode_alb_arp_xmit(struct ether_hdr *eth_h, uint16_t offset,
                                                &client_info->app_mac);
                                ether_addr_copy(&client_info->app_mac, &arp->arp_data.arp_sha);
                                memcpy(client_info->vlan, eth_h + 1, offset);
-                               client_info->vlan_count = offset / sizeof(struct vlan_hdr);
+                               client_info->vlan_count = offset / sizeof(struct rte_vlan_hdr);
                                rte_spinlock_unlock(&internals->mode6.lock);
                                return client_info->slave_idx;
                        }
@@ -179,7 +179,7 @@ bond_mode_alb_arp_xmit(struct ether_hdr *eth_h, uint16_t offset,
                rte_eth_macaddr_get(client_info->slave_idx, &client_info->app_mac);
                ether_addr_copy(&client_info->app_mac, &arp->arp_data.arp_sha);
                memcpy(client_info->vlan, eth_h + 1, offset);
-               client_info->vlan_count = offset / sizeof(struct vlan_hdr);
+               client_info->vlan_count = offset / sizeof(struct rte_vlan_hdr);
                rte_spinlock_unlock(&internals->mode6.lock);
                return client_info->slave_idx;
        }
@@ -195,12 +195,12 @@ uint16_t
 bond_mode_alb_arp_upd(struct client_data *client_info,
                struct rte_mbuf *pkt, struct bond_dev_private *internals)
 {
-       struct ether_hdr *eth_h;
+       struct rte_ether_hdr *eth_h;
        struct rte_arp_hdr *arp_h;
        uint16_t slave_idx;
 
        rte_spinlock_lock(&internals->mode6.lock);
-       eth_h = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+       eth_h = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
 
        ether_addr_copy(&client_info->app_mac, &eth_h->s_addr);
        ether_addr_copy(&client_info->cli_mac, &eth_h->d_addr);
@@ -209,11 +209,11 @@ bond_mode_alb_arp_upd(struct client_data *client_info,
        else
                eth_h->ether_type = rte_cpu_to_be_16(ETHER_TYPE_ARP);
 
-       arp_h = (struct rte_arp_hdr *)((char *)eth_h + sizeof(struct ether_hdr)
-                       + client_info->vlan_count * sizeof(struct vlan_hdr));
+       arp_h = (struct rte_arp_hdr *)((char *)eth_h + sizeof(struct rte_ether_hdr)
+                       + client_info->vlan_count * sizeof(struct rte_vlan_hdr));
 
        memcpy(eth_h + 1, client_info->vlan,
-                       client_info->vlan_count * sizeof(struct vlan_hdr));
+                       client_info->vlan_count * sizeof(struct rte_vlan_hdr));
 
        ether_addr_copy(&client_info->app_mac, &arp_h->arp_data.arp_sha);
        arp_h->arp_data.arp_sip = client_info->app_ip;
index 4640fd2..386e70c 100644 (file)
 
 struct client_data {
        /** ARP data of single client */
-       struct ether_addr app_mac;
+       struct rte_ether_addr app_mac;
        /**< MAC address of application running DPDK */
        uint32_t app_ip;
        /**< IP address of application running DPDK */
-       struct ether_addr cli_mac;
+       struct rte_ether_addr cli_mac;
        /**< Client MAC address */
        uint32_t cli_ip;
        /**< Client IP address */
@@ -29,7 +29,7 @@ struct client_data {
        uint8_t ntt;
        /**< Flag indicating if we need to send update to this client on next tx */
 
-       struct vlan_hdr vlan[2];
+       struct rte_vlan_hdr vlan[2];
        /**< Content of vlan headers */
        uint8_t vlan_count;
        /**< Number of nested vlan headers */
@@ -68,7 +68,7 @@ bond_mode_alb_enable(struct rte_eth_dev *bond_dev);
  * @param internals            Bonding data.
  */
 void
-bond_mode_alb_arp_recv(struct ether_hdr *eth_h, uint16_t offset,
+bond_mode_alb_arp_recv(struct rte_ether_hdr *eth_h, uint16_t offset,
                struct bond_dev_private *internals);
 
 /**
@@ -85,7 +85,7 @@ bond_mode_alb_arp_recv(struct ether_hdr *eth_h, uint16_t offset,
  * Index of slave on which packet should be sent.
  */
 uint16_t
-bond_mode_alb_arp_xmit(struct ether_hdr *eth_h, uint16_t offset,
+bond_mode_alb_arp_xmit(struct rte_ether_hdr *eth_h, uint16_t offset,
                struct bond_dev_private *internals);
 
 /**
index 21bcd50..b64db79 100644 (file)
@@ -835,7 +835,7 @@ rte_eth_bond_active_slaves_get(uint16_t bonded_port_id, uint16_t slaves[],
 
 int
 rte_eth_bond_mac_address_set(uint16_t bonded_port_id,
-               struct ether_addr *mac_addr)
+               struct rte_ether_addr *mac_addr)
 {
        struct rte_eth_dev *bonded_eth_dev;
        struct bond_dev_private *internals;
index b60fde6..01bbb06 100644 (file)
@@ -282,7 +282,7 @@ bond_ethdev_parse_bond_mac_addr_kvarg(const char *key __rte_unused,
 
        /* Parse MAC */
        return cmdline_parse_etheraddr(NULL, value, extra_args,
-               sizeof(struct ether_addr));
+               sizeof(struct rte_ether_addr));
 }
 
 int
index 5272464..2eda2f7 100644 (file)
 static uint64_t tlb_last_obytets[RTE_MAX_ETHPORTS];
 
 static inline size_t
-get_vlan_offset(struct ether_hdr *eth_hdr, uint16_t *proto)
+get_vlan_offset(struct rte_ether_hdr *eth_hdr, uint16_t *proto)
 {
        size_t vlan_offset = 0;
 
        if (rte_cpu_to_be_16(ETHER_TYPE_VLAN) == *proto ||
                rte_cpu_to_be_16(ETHER_TYPE_QINQ) == *proto) {
-               struct vlan_hdr *vlan_hdr = (struct vlan_hdr *)(eth_hdr + 1);
+               struct rte_vlan_hdr *vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
 
-               vlan_offset = sizeof(struct vlan_hdr);
+               vlan_offset = sizeof(struct rte_vlan_hdr);
                *proto = vlan_hdr->eth_proto;
 
                if (rte_cpu_to_be_16(ETHER_TYPE_VLAN) == *proto) {
                        vlan_hdr = vlan_hdr + 1;
                        *proto = vlan_hdr->eth_proto;
-                       vlan_offset += sizeof(struct vlan_hdr);
+                       vlan_offset += sizeof(struct rte_vlan_hdr);
                }
        }
        return vlan_offset;
@@ -392,9 +392,9 @@ bond_ethdev_rx_burst_8023ad(void *queue, struct rte_mbuf **bufs,
        /* Cast to structure, containing bonded device's port id and queue id */
        struct bond_rx_queue *bd_rx_q = (struct bond_rx_queue *)queue;
        struct bond_dev_private *internals = bd_rx_q->dev_private;
-       struct ether_addr bond_mac;
+       struct rte_ether_addr bond_mac;
 
-       struct ether_hdr *hdr;
+       struct rte_ether_hdr *hdr;
 
        const uint16_t ether_type_slow_be = rte_be_to_cpu_16(ETHER_TYPE_SLOW);
        uint16_t num_rx_total = 0;      /* Total number of received packets */
@@ -442,7 +442,7 @@ bond_ethdev_rx_burst_8023ad(void *queue, struct rte_mbuf **bufs,
                        if (j + 3 < num_rx_total)
                                rte_prefetch0(rte_pktmbuf_mtod(bufs[j + 3], void *));
 
-                       hdr = rte_pktmbuf_mtod(bufs[j], struct ether_hdr *);
+                       hdr = rte_pktmbuf_mtod(bufs[j], struct rte_ether_hdr *);
                        subtype = ((struct slow_protocol_frame *)hdr)->slow_protocol.subtype;
 
                        /* Remove packet from array if it is slow packet or slave is not
@@ -584,7 +584,7 @@ update_client_stats(uint32_t addr, uint16_t port, uint32_t *TXorRXindicator)
 #endif
 
 static void
-mode6_debug(const char __attribute__((unused)) *info, struct ether_hdr *eth_h,
+mode6_debug(const char __attribute__((unused)) *info, struct rte_ether_hdr *eth_h,
                uint16_t port, uint32_t __attribute__((unused)) *burstnumber)
 {
        struct ipv4_hdr *ipv4_h;
@@ -629,7 +629,7 @@ bond_ethdev_rx_burst_alb(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
        struct bond_tx_queue *bd_tx_q = (struct bond_tx_queue *)queue;
        struct bond_dev_private *internals = bd_tx_q->dev_private;
-       struct ether_hdr *eth_h;
+       struct rte_ether_hdr *eth_h;
        uint16_t ether_type, offset;
        uint16_t nb_recv_pkts;
        int i;
@@ -637,7 +637,7 @@ bond_ethdev_rx_burst_alb(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
        nb_recv_pkts = bond_ethdev_rx_burst(queue, bufs, nb_pkts);
 
        for (i = 0; i < nb_recv_pkts; i++) {
-               eth_h = rte_pktmbuf_mtod(bufs[i], struct ether_hdr *);
+               eth_h = rte_pktmbuf_mtod(bufs[i], struct rte_ether_hdr *);
                ether_type = eth_h->ether_type;
                offset = get_vlan_offset(eth_h, &ether_type);
 
@@ -737,7 +737,7 @@ bond_ethdev_tx_burst_active_backup(void *queue,
 }
 
 static inline uint16_t
-ether_hash(struct ether_hdr *eth_hdr)
+ether_hash(struct rte_ether_hdr *eth_hdr)
 {
        unaligned_uint16_t *word_src_addr =
                (unaligned_uint16_t *)eth_hdr->s_addr.addr_bytes;
@@ -774,12 +774,12 @@ void
 burst_xmit_l2_hash(struct rte_mbuf **buf, uint16_t nb_pkts,
                uint8_t slave_count, uint16_t *slaves)
 {
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        uint32_t hash;
        int i;
 
        for (i = 0; i < nb_pkts; i++) {
-               eth_hdr = rte_pktmbuf_mtod(buf[i], struct ether_hdr *);
+               eth_hdr = rte_pktmbuf_mtod(buf[i], struct rte_ether_hdr *);
 
                hash = ether_hash(eth_hdr);
 
@@ -792,13 +792,13 @@ burst_xmit_l23_hash(struct rte_mbuf **buf, uint16_t nb_pkts,
                uint8_t slave_count, uint16_t *slaves)
 {
        uint16_t i;
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        uint16_t proto;
        size_t vlan_offset;
        uint32_t hash, l3hash;
 
        for (i = 0; i < nb_pkts; i++) {
-               eth_hdr = rte_pktmbuf_mtod(buf[i], struct ether_hdr *);
+               eth_hdr = rte_pktmbuf_mtod(buf[i], struct rte_ether_hdr *);
                l3hash = 0;
 
                proto = eth_hdr->ether_type;
@@ -829,7 +829,7 @@ void
 burst_xmit_l34_hash(struct rte_mbuf **buf, uint16_t nb_pkts,
                uint8_t slave_count, uint16_t *slaves)
 {
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        uint16_t proto;
        size_t vlan_offset;
        int i;
@@ -839,7 +839,7 @@ burst_xmit_l34_hash(struct rte_mbuf **buf, uint16_t nb_pkts,
        uint32_t hash, l3hash, l4hash;
 
        for (i = 0; i < nb_pkts; i++) {
-               eth_hdr = rte_pktmbuf_mtod(buf[i], struct ether_hdr *);
+               eth_hdr = rte_pktmbuf_mtod(buf[i], struct rte_ether_hdr *);
                proto = eth_hdr->ether_type;
                vlan_offset = get_vlan_offset(eth_hdr, &proto);
                l3hash = 0;
@@ -1001,9 +1001,9 @@ bond_ethdev_tx_burst_tlb(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
        uint16_t num_of_slaves = internals->active_slave_count;
        uint16_t slaves[RTE_MAX_ETHPORTS];
 
-       struct ether_hdr *ether_hdr;
-       struct ether_addr primary_slave_addr;
-       struct ether_addr active_slave_addr;
+       struct rte_ether_hdr *ether_hdr;
+       struct rte_ether_addr primary_slave_addr;
+       struct rte_ether_addr active_slave_addr;
 
        if (num_of_slaves < 1)
                return num_tx_total;
@@ -1025,7 +1025,7 @@ bond_ethdev_tx_burst_tlb(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
                        if (j + 3 < nb_pkts)
                                rte_prefetch0(rte_pktmbuf_mtod(bufs[j+3], void*));
 
-                       ether_hdr = rte_pktmbuf_mtod(bufs[j], struct ether_hdr *);
+                       ether_hdr = rte_pktmbuf_mtod(bufs[j], struct rte_ether_hdr *);
                        if (is_same_ether_addr(&ether_hdr->s_addr, &primary_slave_addr))
                                ether_addr_copy(&active_slave_addr, &ether_hdr->s_addr);
 #if defined(RTE_LIBRTE_BOND_DEBUG_ALB) || defined(RTE_LIBRTE_BOND_DEBUG_ALB_L1)
@@ -1061,7 +1061,7 @@ bond_ethdev_tx_burst_alb(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
        struct bond_tx_queue *bd_tx_q = (struct bond_tx_queue *)queue;
        struct bond_dev_private *internals = bd_tx_q->dev_private;
 
-       struct ether_hdr *eth_h;
+       struct rte_ether_hdr *eth_h;
        uint16_t ether_type, offset;
 
        struct client_data *client_info;
@@ -1091,7 +1091,7 @@ bond_ethdev_tx_burst_alb(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
        /* Search tx buffer for ARP packets and forward them to alb */
        for (i = 0; i < nb_pkts; i++) {
-               eth_h = rte_pktmbuf_mtod(bufs[i], struct ether_hdr *);
+               eth_h = rte_pktmbuf_mtod(bufs[i], struct rte_ether_hdr *);
                ether_type = eth_h->ether_type;
                offset = get_vlan_offset(eth_h, &ether_type);
 
@@ -1125,8 +1125,8 @@ bond_ethdev_tx_burst_alb(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
                                                     "Failed to allocate ARP packet from pool");
                                        continue;
                                }
-                               pkt_size = sizeof(struct ether_hdr) + sizeof(struct rte_arp_hdr)
-                                               + client_info->vlan_count * sizeof(struct vlan_hdr);
+                               pkt_size = sizeof(struct rte_ether_hdr) + sizeof(struct rte_arp_hdr)
+                                               + client_info->vlan_count * sizeof(struct rte_vlan_hdr);
                                upd_pkt->data_len = pkt_size;
                                upd_pkt->pkt_len = pkt_size;
 
@@ -1157,7 +1157,7 @@ bond_ethdev_tx_burst_alb(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 #if defined(RTE_LIBRTE_BOND_DEBUG_ALB) || defined(RTE_LIBRTE_BOND_DEBUG_ALB_L1)
        /* Print TX stats including update packets */
                        for (j = 0; j < slave_bufs_pkts[i]; j++) {
-                               eth_h = rte_pktmbuf_mtod(slave_bufs[i][j], struct ether_hdr *);
+                               eth_h = rte_pktmbuf_mtod(slave_bufs[i][j], struct rte_ether_hdr *);
                                mode6_debug("TX ARP:", eth_h, i, &burstnumberTX);
                        }
 #endif
@@ -1174,7 +1174,7 @@ bond_ethdev_tx_burst_alb(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
                        }
 #if defined(RTE_LIBRTE_BOND_DEBUG_ALB) || defined(RTE_LIBRTE_BOND_DEBUG_ALB_L1)
                        for (j = 0; j < update_bufs_pkts[i]; j++) {
-                               eth_h = rte_pktmbuf_mtod(update_bufs[i][j], struct ether_hdr *);
+                               eth_h = rte_pktmbuf_mtod(update_bufs[i][j], struct rte_ether_hdr *);
                                mode6_debug("TX ARPupd:", eth_h, i, &burstnumberTX);
                        }
 #endif
@@ -1491,9 +1491,9 @@ link_properties_valid(struct rte_eth_dev *ethdev,
 }
 
 int
-mac_address_get(struct rte_eth_dev *eth_dev, struct ether_addr *dst_mac_addr)
+mac_address_get(struct rte_eth_dev *eth_dev, struct rte_ether_addr *dst_mac_addr)
 {
-       struct ether_addr *mac_addr;
+       struct rte_ether_addr *mac_addr;
 
        if (eth_dev == NULL) {
                RTE_BOND_LOG(ERR, "NULL pointer eth_dev specified");
@@ -1512,9 +1512,9 @@ mac_address_get(struct rte_eth_dev *eth_dev, struct ether_addr *dst_mac_addr)
 }
 
 int
-mac_address_set(struct rte_eth_dev *eth_dev, struct ether_addr *new_mac_addr)
+mac_address_set(struct rte_eth_dev *eth_dev, struct rte_ether_addr *new_mac_addr)
 {
-       struct ether_addr *mac_addr;
+       struct rte_ether_addr *mac_addr;
 
        if (eth_dev == NULL) {
                RTE_BOND_LOG(ERR, "NULL pointer eth_dev specified");
@@ -1535,7 +1535,7 @@ mac_address_set(struct rte_eth_dev *eth_dev, struct ether_addr *new_mac_addr)
        return 0;
 }
 
-static const struct ether_addr null_mac_addr;
+static const struct rte_ether_addr null_mac_addr;
 
 /*
  * Add additional MAC addresses to the slave
@@ -1545,7 +1545,7 @@ slave_add_mac_addresses(struct rte_eth_dev *bonded_eth_dev,
                uint16_t slave_port_id)
 {
        int i, ret;
-       struct ether_addr *mac_addr;
+       struct rte_ether_addr *mac_addr;
 
        for (i = 1; i < BOND_MAX_MAC_ADDRS; i++) {
                mac_addr = &bonded_eth_dev->data->mac_addrs[i];
@@ -1573,7 +1573,7 @@ slave_remove_mac_addresses(struct rte_eth_dev *bonded_eth_dev,
                uint16_t slave_port_id)
 {
        int i, rc, ret;
-       struct ether_addr *mac_addr;
+       struct rte_ether_addr *mac_addr;
 
        rc = 0;
        for (i = 1; i < BOND_MAX_MAC_ADDRS; i++) {
@@ -1996,7 +1996,7 @@ slave_add(struct bond_dev_private *internals,
        slave_details->link_status_wait_to_complete = 0;
        /* clean tlb_last_obytes when adding port for bonding device */
        memcpy(&(slave_details->persisted_mac_addr), slave_eth_dev->data->mac_addrs,
-                       sizeof(struct ether_addr));
+                       sizeof(struct rte_ether_addr));
 }
 
 void
@@ -2042,7 +2042,7 @@ bond_ethdev_start(struct rte_eth_dev *eth_dev)
        }
 
        if (internals->user_defined_mac == 0) {
-               struct ether_addr *new_mac_addr = NULL;
+               struct rte_ether_addr *new_mac_addr = NULL;
 
                for (i = 0; i < internals->slave_count; i++)
                        if (internals->slaves[i].port_id == internals->primary_port)
@@ -2905,7 +2905,7 @@ bond_ethdev_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
 }
 
 static int
-bond_ethdev_mac_address_set(struct rte_eth_dev *dev, struct ether_addr *addr)
+bond_ethdev_mac_address_set(struct rte_eth_dev *dev, struct rte_ether_addr *addr)
 {
        if (mac_address_set(dev, addr)) {
                RTE_BOND_LOG(ERR, "Failed to update MAC address");
@@ -2927,7 +2927,7 @@ bond_filter_ctrl(struct rte_eth_dev *dev __rte_unused,
 }
 
 static int
-bond_ethdev_mac_addr_add(struct rte_eth_dev *dev, struct ether_addr *mac_addr,
+bond_ethdev_mac_addr_add(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
                                __rte_unused uint32_t index, uint32_t vmdq)
 {
        struct rte_eth_dev *slave_eth_dev;
@@ -2978,7 +2978,7 @@ bond_ethdev_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index)
                        goto end;
        }
 
-       struct ether_addr *mac_addr = &dev->data->mac_addrs[index];
+       struct rte_ether_addr *mac_addr = &dev->data->mac_addrs[index];
 
        for (i = 0; i < internals->slave_count; i++)
                rte_eth_dev_mac_addr_remove(internals->slaves[i].port_id,
@@ -3361,7 +3361,7 @@ bond_ethdev_configure(struct rte_eth_dev *dev)
        /* Parse MAC address for bonded device */
        arg_count = rte_kvargs_count(kvlist, PMD_BOND_MAC_ADDR_KVARG);
        if (arg_count == 1) {
-               struct ether_addr bond_mac;
+               struct rte_ether_addr bond_mac;
 
                if (rte_kvargs_process(kvlist, PMD_BOND_MAC_ADDR_KVARG,
                                       &bond_ethdev_parse_bond_mac_addr_kvarg, &bond_mac) < 0) {
index 3ea5d68..aa81489 100644 (file)
@@ -85,7 +85,7 @@ struct bond_slave_details {
        uint8_t link_status_wait_to_complete;
        uint8_t last_link_status;
        /**< Port Id of slave eth_dev */
-       struct ether_addr persisted_mac_addr;
+       struct rte_ether_addr persisted_mac_addr;
 
        uint16_t reta_size;
 };
@@ -230,10 +230,10 @@ link_properties_valid(struct rte_eth_dev *bonded_eth_dev,
                struct rte_eth_link *slave_dev_link);
 
 int
-mac_address_set(struct rte_eth_dev *eth_dev, struct ether_addr *new_mac_addr);
+mac_address_set(struct rte_eth_dev *eth_dev, struct rte_ether_addr *new_mac_addr);
 
 int
-mac_address_get(struct rte_eth_dev *eth_dev, struct ether_addr *dst_mac_addr);
+mac_address_get(struct rte_eth_dev *eth_dev, struct rte_ether_addr *dst_mac_addr);
 
 int
 mac_address_slaves_update(struct rte_eth_dev *bonded_eth_dev);
index 47cfc5f..fc0af49 100644 (file)
@@ -671,7 +671,7 @@ static inline void t4_os_set_hw_addr(struct adapter *adapter, int port_idx,
 {
        struct port_info *pi = adap2pinfo(adapter, port_idx);
 
-       ether_addr_copy((struct ether_addr *)hw_addr,
+       ether_addr_copy((struct rte_ether_addr *)hw_addr,
                        &pi->eth_dev->data->mac_addrs[0]);
 }
 
index b2f83ea..17728af 100644 (file)
@@ -1055,7 +1055,7 @@ static int cxgbe_get_regs(struct rte_eth_dev *eth_dev,
        return 0;
 }
 
-int cxgbe_mac_addr_set(struct rte_eth_dev *dev, struct ether_addr *addr)
+int cxgbe_mac_addr_set(struct rte_eth_dev *dev, struct rte_ether_addr *addr)
 {
        struct port_info *pi = (struct port_info *)(dev->data->dev_private);
        int ret;
index 8d0a105..03145ce 100644 (file)
@@ -16,7 +16,7 @@ void cxgbe_dev_promiscuous_enable(struct rte_eth_dev *eth_dev);
 void cxgbe_dev_promiscuous_disable(struct rte_eth_dev *eth_dev);
 void cxgbe_dev_allmulticast_enable(struct rte_eth_dev *eth_dev);
 void cxgbe_dev_allmulticast_disable(struct rte_eth_dev *eth_dev);
-int cxgbe_mac_addr_set(struct rte_eth_dev *dev, struct ether_addr *addr);
+int cxgbe_mac_addr_set(struct rte_eth_dev *dev, struct rte_ether_addr *addr);
 int cxgbe_dev_configure(struct rte_eth_dev *eth_dev);
 int cxgbe_dev_tx_queue_setup(struct rte_eth_dev *eth_dev, uint16_t queue_idx,
                             uint16_t nb_desc, unsigned int socket_id,
index 5c743c3..9aaabf4 100644 (file)
@@ -930,7 +930,7 @@ dpaa_flow_ctrl_get(struct rte_eth_dev *dev,
 
 static int
 dpaa_dev_add_mac_addr(struct rte_eth_dev *dev,
-                            struct ether_addr *addr,
+                            struct rte_ether_addr *addr,
                             uint32_t index,
                             __rte_unused uint32_t pool)
 {
@@ -960,7 +960,7 @@ dpaa_dev_remove_mac_addr(struct rte_eth_dev *dev,
 
 static int
 dpaa_dev_set_mac_addr(struct rte_eth_dev *dev,
-                      struct ether_addr *addr)
+                      struct rte_ether_addr *addr)
 {
        int ret;
        struct dpaa_if *dpaa_intf = dev->data->dev_private;
index c4471c2..937388c 100644 (file)
@@ -198,7 +198,7 @@ static inline void dpaa_eth_packet_info(struct rte_mbuf *m, void *fd_virt_addr)
 
 static inline void dpaa_checksum(struct rte_mbuf *mbuf)
 {
-       struct ether_hdr *eth_hdr = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+       struct rte_ether_hdr *eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
        char *l3_hdr = (char *)eth_hdr + mbuf->l2_len;
        struct ipv4_hdr *ipv4_hdr = (struct ipv4_hdr *)l3_hdr;
        struct ipv6_hdr *ipv6_hdr = (struct ipv6_hdr *)l3_hdr;
index 3987d13..dcfc1a9 100644 (file)
@@ -1054,7 +1054,7 @@ dpaa2_dev_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
 
 static int
 dpaa2_dev_add_mac_addr(struct rte_eth_dev *dev,
-                      struct ether_addr *addr,
+                      struct rte_ether_addr *addr,
                       __rte_unused uint32_t index,
                       __rte_unused uint32_t pool)
 {
@@ -1085,7 +1085,7 @@ dpaa2_dev_remove_mac_addr(struct rte_eth_dev *dev,
        struct dpaa2_dev_priv *priv = dev->data->dev_private;
        struct fsl_mc_io *dpni = (struct fsl_mc_io *)priv->hw;
        struct rte_eth_dev_data *data = dev->data;
-       struct ether_addr *macaddr;
+       struct rte_ether_addr *macaddr;
 
        PMD_INIT_FUNC_TRACE();
 
@@ -1105,7 +1105,7 @@ dpaa2_dev_remove_mac_addr(struct rte_eth_dev *dev,
 
 static int
 dpaa2_dev_set_mac_addr(struct rte_eth_dev *dev,
-                      struct ether_addr *addr)
+                      struct rte_ether_addr *addr)
 {
        int ret;
        struct dpaa2_dev_priv *priv = dev->data->dev_private;
@@ -1843,13 +1843,13 @@ static struct eth_dev_ops dpaa2_ethdev_ops = {
  */
 static int
 populate_mac_addr(struct fsl_mc_io *dpni_dev, struct dpaa2_dev_priv *priv,
-                 struct ether_addr *mac_entry)
+                 struct rte_ether_addr *mac_entry)
 {
        int ret;
-       struct ether_addr phy_mac, prime_mac;
+       struct rte_ether_addr phy_mac, prime_mac;
 
-       memset(&phy_mac, 0, sizeof(struct ether_addr));
-       memset(&prime_mac, 0, sizeof(struct ether_addr));
+       memset(&phy_mac, 0, sizeof(struct rte_ether_addr));
+       memset(&prime_mac, 0, sizeof(struct rte_ether_addr));
 
        /* Get the physical device MAC address */
        ret = dpni_get_port_mac_addr(dpni_dev, CMD_PRI_LOW, priv->token,
@@ -1883,7 +1883,7 @@ populate_mac_addr(struct fsl_mc_io *dpni_dev, struct dpaa2_dev_priv *priv,
                                              ret);
                                goto cleanup;
                        }
-                       memcpy(&prime_mac, &phy_mac, sizeof(struct ether_addr));
+                       memcpy(&prime_mac, &phy_mac, sizeof(struct rte_ether_addr));
                }
        } else if (is_zero_ether_addr(&prime_mac)) {
                /* In case phys and prime, both are zero, create random MAC */
@@ -1898,7 +1898,7 @@ populate_mac_addr(struct fsl_mc_io *dpni_dev, struct dpaa2_dev_priv *priv,
        }
 
        /* prime_mac the final MAC address */
-       memcpy(mac_entry, &prime_mac, sizeof(struct ether_addr));
+       memcpy(mac_entry, &prime_mac, sizeof(struct rte_ether_addr));
        return 0;
 
 cleanup:
index 28c1535..b4bb135 100644 (file)
@@ -89,14 +89,14 @@ static int eth_em_led_on(struct rte_eth_dev *dev);
 static int eth_em_led_off(struct rte_eth_dev *dev);
 
 static int em_get_rx_buffer_size(struct e1000_hw *hw);
-static int eth_em_rar_set(struct rte_eth_dev *dev, struct ether_addr *mac_addr,
+static int eth_em_rar_set(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
                          uint32_t index, uint32_t pool);
 static void eth_em_rar_clear(struct rte_eth_dev *dev, uint32_t index);
 static int eth_em_default_mac_addr_set(struct rte_eth_dev *dev,
-                                        struct ether_addr *addr);
+                                        struct rte_ether_addr *addr);
 
 static int eth_em_set_mc_addr_list(struct rte_eth_dev *dev,
-                                  struct ether_addr *mc_addr_set,
+                                  struct rte_ether_addr *mc_addr_set,
                                   uint32_t nb_mc_addr);
 
 #define EM_FC_PAUSE_TIME 0x0680
@@ -293,7 +293,7 @@ eth_em_dev_init(struct rte_eth_dev *eth_dev)
        }
 
        /* Copy the permanent MAC address */
-       ether_addr_copy((struct ether_addr *) hw->mac.addr,
+       ether_addr_copy((struct rte_ether_addr *) hw->mac.addr,
                eth_dev->data->mac_addrs);
 
        /* initialize the vfta */
@@ -1738,7 +1738,7 @@ eth_em_flow_ctrl_set(struct rte_eth_dev *dev, struct rte_eth_fc_conf *fc_conf)
 }
 
 static int
-eth_em_rar_set(struct rte_eth_dev *dev, struct ether_addr *mac_addr,
+eth_em_rar_set(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
                uint32_t index, __rte_unused uint32_t pool)
 {
        struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
@@ -1759,7 +1759,7 @@ eth_em_rar_clear(struct rte_eth_dev *dev, uint32_t index)
 
 static int
 eth_em_default_mac_addr_set(struct rte_eth_dev *dev,
-                           struct ether_addr *addr)
+                           struct rte_ether_addr *addr)
 {
        eth_em_rar_clear(dev, 0);
 
@@ -1809,7 +1809,7 @@ eth_em_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
 
 static int
 eth_em_set_mc_addr_list(struct rte_eth_dev *dev,
-                       struct ether_addr *mc_addr_set,
+                       struct rte_ether_addr *mc_addr_set,
                        uint32_t nb_mc_addr)
 {
        struct e1000_hw *hw;
index e542ef5..210e5c3 100644 (file)
@@ -141,11 +141,11 @@ static int eth_igb_led_off(struct rte_eth_dev *dev);
 static void igb_intr_disable(struct e1000_hw *hw);
 static int  igb_get_rx_buffer_size(struct e1000_hw *hw);
 static int eth_igb_rar_set(struct rte_eth_dev *dev,
-                          struct ether_addr *mac_addr,
+                          struct rte_ether_addr *mac_addr,
                           uint32_t index, uint32_t pool);
 static void eth_igb_rar_clear(struct rte_eth_dev *dev, uint32_t index);
 static int eth_igb_default_mac_addr_set(struct rte_eth_dev *dev,
-               struct ether_addr *addr);
+               struct rte_ether_addr *addr);
 
 static void igbvf_intr_disable(struct e1000_hw *hw);
 static int igbvf_dev_configure(struct rte_eth_dev *dev);
@@ -170,7 +170,7 @@ static int igbvf_vlan_filter_set(struct rte_eth_dev *dev,
 static int igbvf_set_vfta(struct e1000_hw *hw, uint16_t vid, bool on);
 static void igbvf_set_vfta_all(struct rte_eth_dev *dev, bool on);
 static int igbvf_default_mac_addr_set(struct rte_eth_dev *dev,
-               struct ether_addr *addr);
+               struct rte_ether_addr *addr);
 static int igbvf_get_reg_length(struct rte_eth_dev *dev);
 static int igbvf_get_regs(struct rte_eth_dev *dev,
                struct rte_dev_reg_info *regs);
@@ -227,7 +227,7 @@ static int eth_igb_get_module_info(struct rte_eth_dev *dev,
 static int eth_igb_get_module_eeprom(struct rte_eth_dev *dev,
                                     struct rte_dev_eeprom_info *info);
 static int eth_igb_set_mc_addr_list(struct rte_eth_dev *dev,
-                                   struct ether_addr *mc_addr_set,
+                                   struct rte_ether_addr *mc_addr_set,
                                    uint32_t nb_mc_addr);
 static int igb_timesync_enable(struct rte_eth_dev *dev);
 static int igb_timesync_disable(struct rte_eth_dev *dev);
@@ -819,7 +819,7 @@ eth_igb_dev_init(struct rte_eth_dev *eth_dev)
        }
 
        /* Copy the permanent MAC address */
-       ether_addr_copy((struct ether_addr *)hw->mac.addr, &eth_dev->data->mac_addrs[0]);
+       ether_addr_copy((struct rte_ether_addr *)hw->mac.addr, &eth_dev->data->mac_addrs[0]);
 
        /* initialize the vfta */
        memset(shadow_vfta, 0, sizeof(*shadow_vfta));
@@ -965,7 +965,7 @@ eth_igbvf_dev_init(struct rte_eth_dev *eth_dev)
        struct e1000_hw *hw =
                E1000_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
        int diag;
-       struct ether_addr *perm_addr = (struct ether_addr *)hw->mac.perm_addr;
+       struct rte_ether_addr *perm_addr = (struct rte_ether_addr *)hw->mac.perm_addr;
 
        PMD_INIT_FUNC_TRACE();
 
@@ -1039,7 +1039,7 @@ eth_igbvf_dev_init(struct rte_eth_dev *eth_dev)
                return diag;
        }
        /* Copy the permanent MAC address */
-       ether_addr_copy((struct ether_addr *) hw->mac.perm_addr,
+       ether_addr_copy((struct rte_ether_addr *) hw->mac.perm_addr,
                        &eth_dev->data->mac_addrs[0]);
 
        PMD_INIT_LOG(DEBUG, "port %d vendorID=0x%x deviceID=0x%x "
@@ -3097,7 +3097,7 @@ eth_igb_flow_ctrl_set(struct rte_eth_dev *dev, struct rte_eth_fc_conf *fc_conf)
 
 #define E1000_RAH_POOLSEL_SHIFT      (18)
 static int
-eth_igb_rar_set(struct rte_eth_dev *dev, struct ether_addr *mac_addr,
+eth_igb_rar_set(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
                uint32_t index, uint32_t pool)
 {
        struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
@@ -3123,7 +3123,7 @@ eth_igb_rar_clear(struct rte_eth_dev *dev, uint32_t index)
 
 static int
 eth_igb_default_mac_addr_set(struct rte_eth_dev *dev,
-                               struct ether_addr *addr)
+                               struct rte_ether_addr *addr)
 {
        eth_igb_rar_clear(dev, 0);
        eth_igb_rar_set(dev, (void *)addr, 0, 0);
@@ -3336,7 +3336,7 @@ igbvf_dev_close(struct rte_eth_dev *dev)
        struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
        struct e1000_adapter *adapter =
                E1000_DEV_PRIVATE(dev->data->dev_private);
-       struct ether_addr addr;
+       struct rte_ether_addr addr;
 
        PMD_INIT_FUNC_TRACE();
 
@@ -3481,7 +3481,7 @@ igbvf_vlan_filter_set(struct rte_eth_dev *dev, uint16_t vlan_id, int on)
 }
 
 static int
-igbvf_default_mac_addr_set(struct rte_eth_dev *dev, struct ether_addr *addr)
+igbvf_default_mac_addr_set(struct rte_eth_dev *dev, struct rte_ether_addr *addr)
 {
        struct e1000_hw *hw =
                E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
@@ -4884,7 +4884,7 @@ eth_igb_filter_ctrl(struct rte_eth_dev *dev,
 
 static int
 eth_igb_set_mc_addr_list(struct rte_eth_dev *dev,
-                        struct ether_addr *mc_addr_set,
+                        struct rte_ether_addr *mc_addr_set,
                         uint32_t nb_mc_addr)
 {
        struct e1000_hw *hw;
index b9f2e53..9f15213 100644 (file)
@@ -306,8 +306,8 @@ igb_vf_set_mac_addr(struct rte_eth_dev *dev, uint32_t vf, uint32_t *msgbuf)
        uint8_t *new_mac = (uint8_t *)(&msgbuf[1]);
        int rah;
 
-       if (is_unicast_ether_addr((struct ether_addr *)new_mac)) {
-               if (!is_zero_ether_addr((struct ether_addr *)new_mac))
+       if (is_unicast_ether_addr((struct rte_ether_addr *)new_mac)) {
+               if (!is_zero_ether_addr((struct rte_ether_addr *)new_mac))
                        rte_memcpy(vfinfo[vf].vf_mac_addresses, new_mac,
                                sizeof(vfinfo[vf].vf_mac_addresses));
                hw->mac.ops.rar_set(hw, new_mac, rar_entry);
index c29a581..165ff52 100644 (file)
@@ -1655,9 +1655,9 @@ static int eth_ena_dev_init(struct rte_eth_dev *eth_dev)
                                  ENA_ADMIN_FEATURE_OFFLOAD_DESC_TSO_IPV4_MASK;
 
        /* Copy MAC address and point DPDK to it */
-       eth_dev->data->mac_addrs = (struct ether_addr *)adapter->mac_addr;
-       ether_addr_copy((struct ether_addr *)get_feat_ctx.dev_attr.mac_addr,
-                       (struct ether_addr *)adapter->mac_addr);
+       eth_dev->data->mac_addrs = (struct rte_ether_addr *)adapter->mac_addr;
+       ether_addr_copy((struct rte_ether_addr *)get_feat_ctx.dev_attr.mac_addr,
+                       (struct rte_ether_addr *)adapter->mac_addr);
 
        adapter->drv_stats = rte_zmalloc("adapter stats",
                                         sizeof(*adapter->drv_stats),
@@ -1964,7 +1964,7 @@ eth_ena_prep_pkts(void *tx_queue, struct rte_mbuf **tx_pkts,
                 * length of the ethernet header.
                 */
                if (unlikely(m->l2_len == 0))
-                       m->l2_len = sizeof(struct ether_hdr);
+                       m->l2_len = sizeof(struct rte_ether_hdr);
 
                ip_hdr = rte_pktmbuf_mtod_offset(m, struct ipv4_hdr *,
                                                 m->l2_len);
index 3ee7bb4..1541368 100644 (file)
@@ -98,7 +98,7 @@ enetc_dev_init(struct rte_eth_dev *eth_dev)
        }
 
        /* Copy the permanent MAC address */
-       ether_addr_copy((struct ether_addr *)hw->mac.addr,
+       ether_addr_copy((struct rte_ether_addr *)hw->mac.addr,
                        &eth_dev->data->mac_addrs[0]);
 
        ENETC_PMD_DEBUG("port_id %d vendorID=0x%x deviceID=0x%x",
index 4d450fe..0d35a20 100644 (file)
@@ -579,7 +579,7 @@ static void enicpmd_dev_allmulticast_disable(struct rte_eth_dev *eth_dev)
 }
 
 static int enicpmd_add_mac_addr(struct rte_eth_dev *eth_dev,
-       struct ether_addr *mac_addr,
+       struct rte_ether_addr *mac_addr,
        __rte_unused uint32_t index, __rte_unused uint32_t pool)
 {
        struct enic *enic = pmd_priv(eth_dev);
@@ -604,7 +604,7 @@ static void enicpmd_remove_mac_addr(struct rte_eth_dev *eth_dev, uint32_t index)
 }
 
 static int enicpmd_set_mac_addr(struct rte_eth_dev *eth_dev,
-                               struct ether_addr *addr)
+                               struct rte_ether_addr *addr)
 {
        struct enic *enic = pmd_priv(eth_dev);
        int ret;
index bb9ed03..dbd638d 100644 (file)
@@ -497,8 +497,8 @@ static int
 enic_copy_item_eth_v2(const struct rte_flow_item *item,
                      struct filter_v2 *enic_filter, u8 *inner_ofst)
 {
-       struct ether_hdr enic_spec;
-       struct ether_hdr enic_mask;
+       struct rte_ether_hdr enic_spec;
+       struct rte_ether_hdr enic_mask;
        const struct rte_flow_item_eth *spec = item->spec;
        const struct rte_flow_item_eth *mask = item->mask;
        struct filter_generic_1 *gp = &enic_filter->u.generic_1;
@@ -527,20 +527,20 @@ enic_copy_item_eth_v2(const struct rte_flow_item *item,
        if (*inner_ofst == 0) {
                /* outer header */
                memcpy(gp->layer[FILTER_GENERIC_1_L2].mask, &enic_mask,
-                      sizeof(struct ether_hdr));
+                      sizeof(struct rte_ether_hdr));
                memcpy(gp->layer[FILTER_GENERIC_1_L2].val, &enic_spec,
-                      sizeof(struct ether_hdr));
+                      sizeof(struct rte_ether_hdr));
        } else {
                /* inner header */
-               if ((*inner_ofst + sizeof(struct ether_hdr)) >
+               if ((*inner_ofst + sizeof(struct rte_ether_hdr)) >
                     FILTER_GENERIC_1_KEY_LEN)
                        return ENOTSUP;
                /* Offset into L5 where inner Ethernet header goes */
                memcpy(&gp->layer[FILTER_GENERIC_1_L5].mask[*inner_ofst],
-                      &enic_mask, sizeof(struct ether_hdr));
+                      &enic_mask, sizeof(struct rte_ether_hdr));
                memcpy(&gp->layer[FILTER_GENERIC_1_L5].val[*inner_ofst],
-                      &enic_spec, sizeof(struct ether_hdr));
-               *inner_ofst += sizeof(struct ether_hdr);
+                      &enic_spec, sizeof(struct rte_ether_hdr));
+               *inner_ofst += sizeof(struct rte_ether_hdr);
        }
        return 0;
 }
@@ -574,9 +574,9 @@ enic_copy_item_vlan_v2(const struct rte_flow_item *item,
                mask = &rte_flow_item_vlan_mask;
 
        if (*inner_ofst == 0) {
-               struct ether_hdr *eth_mask =
+               struct rte_ether_hdr *eth_mask =
                        (void *)gp->layer[FILTER_GENERIC_1_L2].mask;
-               struct ether_hdr *eth_val =
+               struct rte_ether_hdr *eth_val =
                        (void *)gp->layer[FILTER_GENERIC_1_L2].val;
 
                /* Outer TPID cannot be matched */
@@ -590,14 +590,14 @@ enic_copy_item_vlan_v2(const struct rte_flow_item *item,
                gp->val_vlan = spec->tci;
        } else {
                /* Inner header. Mask/Val start at *inner_ofst into L5 */
-               if ((*inner_ofst + sizeof(struct vlan_hdr)) >
+               if ((*inner_ofst + sizeof(struct rte_vlan_hdr)) >
                     FILTER_GENERIC_1_KEY_LEN)
                        return ENOTSUP;
                memcpy(&gp->layer[FILTER_GENERIC_1_L5].mask[*inner_ofst],
-                      mask, sizeof(struct vlan_hdr));
+                      mask, sizeof(struct rte_vlan_hdr));
                memcpy(&gp->layer[FILTER_GENERIC_1_L5].val[*inner_ofst],
-                      spec, sizeof(struct vlan_hdr));
-               *inner_ofst += sizeof(struct vlan_hdr);
+                      spec, sizeof(struct rte_vlan_hdr));
+               *inner_ofst += sizeof(struct rte_vlan_hdr);
        }
        return 0;
 }
@@ -870,11 +870,11 @@ enic_copy_item_vxlan_v2(const struct rte_flow_item *item,
                mask = &rte_flow_item_vxlan_mask;
 
        memcpy(gp->layer[FILTER_GENERIC_1_L5].mask, mask,
-              sizeof(struct vxlan_hdr));
+              sizeof(struct rte_vxlan_hdr));
        memcpy(gp->layer[FILTER_GENERIC_1_L5].val, spec,
-              sizeof(struct vxlan_hdr));
+              sizeof(struct rte_vxlan_hdr));
 
-       *inner_ofst = sizeof(struct vxlan_hdr);
+       *inner_ofst = sizeof(struct rte_vxlan_hdr);
        return 0;
 }
 
index b258132..e362219 100644 (file)
@@ -1675,7 +1675,7 @@ static int enic_dev_init(struct enic *enic)
                dev_err(enic, "mac addr storage alloc failed, aborting.\n");
                return -1;
        }
-       ether_addr_copy((struct ether_addr *) enic->mac_addr,
+       ether_addr_copy((struct rte_ether_addr *) enic->mac_addr,
                        eth_dev->data->mac_addrs);
 
        vnic_dev_set_reset_flag(enic->vdev, 0);
index c3999f0..495f536 100644 (file)
@@ -158,7 +158,7 @@ static int
 fs_eth_dev_create(struct rte_vdev_device *vdev)
 {
        struct rte_eth_dev *dev;
-       struct ether_addr *mac;
+       struct rte_ether_addr *mac;
        struct fs_priv *priv;
        struct sub_device *sdev;
        const char *params;
index 626883c..d19f83e 100644 (file)
@@ -367,7 +367,7 @@ static int
 fs_get_mac_addr_arg(const char *key __rte_unused,
                const char *value, void *out)
 {
-       struct ether_addr *ea = out;
+       struct rte_ether_addr *ea = out;
        int ret;
 
        if ((value == NULL) || (out == NULL))
index 1783165..a7f2b0e 100644 (file)
@@ -166,7 +166,7 @@ fs_eth_dev_conf_apply(struct rte_eth_dev *dev,
                DEBUG("Configure additional MAC address%s",
                        (PRIV(dev)->nb_mac_addr > 2 ? "es" : ""));
        for (i = 1; i < PRIV(dev)->nb_mac_addr; i++) {
-               struct ether_addr *ea;
+               struct rte_ether_addr *ea;
 
                ea = &dev->data->mac_addrs[i];
                ret = rte_eth_dev_mac_addr_add(PORT_ID(sdev), ea,
index 7f8bcd4..27131c4 100644 (file)
@@ -1081,7 +1081,7 @@ fs_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index)
 
 static int
 fs_mac_addr_add(struct rte_eth_dev *dev,
-               struct ether_addr *mac_addr,
+               struct rte_ether_addr *mac_addr,
                uint32_t index,
                uint32_t vmdq)
 {
@@ -1110,7 +1110,7 @@ fs_mac_addr_add(struct rte_eth_dev *dev,
 }
 
 static int
-fs_mac_addr_set(struct rte_eth_dev *dev, struct ether_addr *mac_addr)
+fs_mac_addr_set(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr)
 {
        struct sub_device *sdev;
        uint8_t i;
@@ -1134,7 +1134,7 @@ fs_mac_addr_set(struct rte_eth_dev *dev, struct ether_addr *mac_addr)
 
 static int
 fs_set_mc_addr_list(struct rte_eth_dev *dev,
-                   struct ether_addr *mc_addr_set, uint32_t nb_mc_addr)
+                   struct rte_ether_addr *mc_addr_set, uint32_t nb_mc_addr)
 {
        struct sub_device *sdev;
        uint8_t i;
index 442e619..d9bef61 100644 (file)
@@ -144,10 +144,10 @@ struct fs_priv {
        TAILQ_HEAD(sub_flows, rte_flow) flow_list;
        /* current number of mac_addr slots allocated. */
        uint32_t nb_mac_addr;
-       struct ether_addr mac_addrs[FAILSAFE_MAX_ETHADDR];
+       struct rte_ether_addr mac_addrs[FAILSAFE_MAX_ETHADDR];
        uint32_t mac_addr_pool[FAILSAFE_MAX_ETHADDR];
        uint32_t nb_mcast_addr;
-       struct ether_addr *mcast_addrs;
+       struct rte_ether_addr *mcast_addrs;
        /* current capabilities */
        struct rte_eth_dev_info infos;
        struct rte_eth_dev_owner my_owner; /* Unique owner. */
index 46983e5..eb3e130 100644 (file)
@@ -619,7 +619,7 @@ fm10k_dev_mq_rx_configure(struct rte_eth_dev *dev)
        /* reset MAC/VLAN as it's based on VMDQ or PF main VSI */
        memset(dev->data->mac_addrs, 0,
                ETHER_ADDR_LEN * FM10K_MAX_MACADDR_NUM);
-       ether_addr_copy((const struct ether_addr *)hw->mac.addr,
+       ether_addr_copy((const struct rte_ether_addr *)hw->mac.addr,
                &dev->data->mac_addrs[0]);
        memset(macvlan, 0, sizeof(*macvlan));
        macvlan->nb_queue_pools = nb_queue_pools;
@@ -1669,7 +1669,7 @@ static void fm10k_MAC_filter_set(struct rte_eth_dev *dev,
 /* Add a MAC address, and update filters */
 static int
 fm10k_macaddr_add(struct rte_eth_dev *dev,
-               struct ether_addr *mac_addr,
+               struct rte_ether_addr *mac_addr,
                uint32_t index,
                uint32_t pool)
 {
@@ -3084,7 +3084,7 @@ eth_fm10k_dev_init(struct rte_eth_dev *dev)
 
        diag = fm10k_read_mac_addr(hw);
 
-       ether_addr_copy((const struct ether_addr *)hw->mac.addr,
+       ether_addr_copy((const struct rte_ether_addr *)hw->mac.addr,
                        &dev->data->mac_addrs[0]);
 
        if (diag != FM10K_SUCCESS ||
@@ -3093,7 +3093,7 @@ eth_fm10k_dev_init(struct rte_eth_dev *dev)
                /* Generate a random addr */
                eth_random_addr(hw->mac.addr);
                memcpy(hw->mac.perm_addr, hw->mac.addr, ETH_ALEN);
-               ether_addr_copy((const struct ether_addr *)hw->mac.addr,
+               ether_addr_copy((const struct rte_ether_addr *)hw->mac.addr,
                &dev->data->mac_addrs[0]);
        }
 
index f7a685c..fa2e39a 100644 (file)
@@ -266,7 +266,7 @@ static int i40e_flow_ctrl_set(struct rte_eth_dev *dev,
 static int i40e_priority_flow_ctrl_set(struct rte_eth_dev *dev,
                                       struct rte_eth_pfc_conf *pfc_conf);
 static int i40e_macaddr_add(struct rte_eth_dev *dev,
-                           struct ether_addr *mac_addr,
+                           struct rte_ether_addr *mac_addr,
                            uint32_t index,
                            uint32_t pool);
 static void i40e_macaddr_remove(struct rte_eth_dev *dev, uint32_t index);
@@ -380,7 +380,7 @@ static int i40e_get_module_eeprom(struct rte_eth_dev *dev,
                                  struct rte_dev_eeprom_info *info);
 
 static int i40e_set_default_mac_addr(struct rte_eth_dev *dev,
-                                     struct ether_addr *mac_addr);
+                                     struct rte_ether_addr *mac_addr);
 
 static int i40e_dev_mtu_set(struct rte_eth_dev *dev, uint16_t mtu);
 
@@ -1457,8 +1457,8 @@ eth_i40e_dev_init(struct rte_eth_dev *dev, void *init_params __rte_unused)
                goto err_get_mac_addr;
        }
        /* Copy the permanent MAC address */
-       ether_addr_copy((struct ether_addr *) hw->mac.addr,
-                       (struct ether_addr *) hw->mac.perm_addr);
+       ether_addr_copy((struct rte_ether_addr *) hw->mac.addr,
+                       (struct rte_ether_addr *) hw->mac.perm_addr);
 
        /* Disable flow control */
        hw->fc.requested_mode = I40E_FC_NONE;
@@ -1512,7 +1512,7 @@ eth_i40e_dev_init(struct rte_eth_dev *dev, void *init_params __rte_unused)
                        "Failed to allocated memory for storing mac address");
                goto err_mac_alloc;
        }
-       ether_addr_copy((struct ether_addr *)hw->mac.perm_addr,
+       ether_addr_copy((struct rte_ether_addr *)hw->mac.perm_addr,
                                        &dev->data->mac_addrs[0]);
 
        /* Init dcb to sw mode by default */
@@ -3944,7 +3944,7 @@ i40e_priority_flow_ctrl_set(__rte_unused struct rte_eth_dev *dev,
 /* Add a MAC address, and update filters */
 static int
 i40e_macaddr_add(struct rte_eth_dev *dev,
-                struct ether_addr *mac_addr,
+                struct rte_ether_addr *mac_addr,
                 __rte_unused uint32_t index,
                 uint32_t pool)
 {
@@ -3995,7 +3995,7 @@ i40e_macaddr_remove(struct rte_eth_dev *dev, uint32_t index)
        struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
        struct i40e_vsi *vsi;
        struct rte_eth_dev_data *data = dev->data;
-       struct ether_addr *macaddr;
+       struct rte_ether_addr *macaddr;
        int ret;
        uint32_t i;
        uint64_t pool_sel;
@@ -4036,8 +4036,8 @@ i40e_vf_mac_filter_set(struct i40e_pf *pf,
 {
        struct i40e_hw *hw;
        struct i40e_mac_filter_info mac_filter;
-       struct ether_addr old_mac;
-       struct ether_addr *new_mac;
+       struct rte_ether_addr old_mac;
+       struct rte_ether_addr *new_mac;
        struct i40e_pf_vf *vf = NULL;
        uint16_t vf_id;
        int ret;
@@ -4098,7 +4098,7 @@ i40e_vf_mac_filter_set(struct i40e_pf *pf,
 
                /* Clear device address as it has been removed */
                if (is_same_ether_addr(&(pf->dev_addr), new_mac))
-                       memset(&pf->dev_addr, 0, sizeof(struct ether_addr));
+                       memset(&pf->dev_addr, 0, sizeof(struct rte_ether_addr));
        }
 
        return 0;
@@ -5271,7 +5271,7 @@ i40e_update_default_filter_setting(struct i40e_vsi *vsi)
        ret = i40e_aq_remove_macvlan(hw, vsi->seid, &def_filter, 1, NULL);
        if (ret != I40E_SUCCESS) {
                struct i40e_mac_filter *f;
-               struct ether_addr *mac;
+               struct rte_ether_addr *mac;
 
                PMD_DRV_LOG(DEBUG,
                            "Cannot remove the default macvlan filter");
@@ -5291,7 +5291,7 @@ i40e_update_default_filter_setting(struct i40e_vsi *vsi)
                return ret;
        }
        rte_memcpy(&filter.mac_addr,
-               (struct ether_addr *)(hw->mac.perm_addr), ETH_ADDR_LEN);
+               (struct rte_ether_addr *)(hw->mac.perm_addr), ETH_ADDR_LEN);
        filter.filter_type = RTE_MACVLAN_PERFECT_MATCH;
        return i40e_vsi_add_mac(vsi, &filter);
 }
@@ -5409,7 +5409,7 @@ i40e_vsi_setup(struct i40e_pf *pf,
        struct i40e_mac_filter_info filter;
        int ret;
        struct i40e_vsi_context ctxt;
-       struct ether_addr broadcast =
+       struct rte_ether_addr broadcast =
                {.addr_bytes = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}};
 
        if (type != I40E_VSI_MAIN && type != I40E_VSI_SRIOV &&
@@ -6836,7 +6836,7 @@ DONE:
 /* Find out specific MAC filter */
 static struct i40e_mac_filter *
 i40e_find_mac_filter(struct i40e_vsi *vsi,
-                        struct ether_addr *macaddr)
+                        struct rte_ether_addr *macaddr)
 {
        struct i40e_mac_filter *f;
 
@@ -6920,7 +6920,7 @@ i40e_set_vlan_filter(struct i40e_vsi *vsi,
 int
 i40e_find_all_vlan_for_mac(struct i40e_vsi *vsi,
                           struct i40e_macvlan_filter *mv_f,
-                          int num, struct ether_addr *addr)
+                          int num, struct rte_ether_addr *addr)
 {
        int i;
        uint32_t j, k;
@@ -7214,7 +7214,7 @@ DONE:
 }
 
 int
-i40e_vsi_delete_mac(struct i40e_vsi *vsi, struct ether_addr *addr)
+i40e_vsi_delete_mac(struct i40e_vsi *vsi, struct rte_ether_addr *addr)
 {
        struct i40e_mac_filter *f;
        struct i40e_macvlan_filter *mv_f;
@@ -7508,10 +7508,10 @@ i40e_tunnel_filter_convert(
        struct i40e_aqc_cloud_filters_element_bb *cld_filter,
        struct i40e_tunnel_filter *tunnel_filter)
 {
-       ether_addr_copy((struct ether_addr *)&cld_filter->element.outer_mac,
-                       (struct ether_addr *)&tunnel_filter->input.outer_mac);
-       ether_addr_copy((struct ether_addr *)&cld_filter->element.inner_mac,
-                       (struct ether_addr *)&tunnel_filter->input.inner_mac);
+       ether_addr_copy((struct rte_ether_addr *)&cld_filter->element.outer_mac,
+                       (struct rte_ether_addr *)&tunnel_filter->input.outer_mac);
+       ether_addr_copy((struct rte_ether_addr *)&cld_filter->element.inner_mac,
+                       (struct rte_ether_addr *)&tunnel_filter->input.inner_mac);
        tunnel_filter->input.inner_vlan = cld_filter->element.inner_vlan;
        if ((rte_le_to_cpu_16(cld_filter->element.flags) &
             I40E_AQC_ADD_CLOUD_FLAGS_IPV6) ==
@@ -7620,9 +7620,9 @@ i40e_dev_tunnel_filter_set(struct i40e_pf *pf,
        pfilter = cld_filter;
 
        ether_addr_copy(&tunnel_filter->outer_mac,
-                       (struct ether_addr *)&pfilter->element.outer_mac);
+                       (struct rte_ether_addr *)&pfilter->element.outer_mac);
        ether_addr_copy(&tunnel_filter->inner_mac,
-                       (struct ether_addr *)&pfilter->element.inner_mac);
+                       (struct rte_ether_addr *)&pfilter->element.inner_mac);
 
        pfilter->element.inner_vlan =
                rte_cpu_to_le_16(tunnel_filter->inner_vlan);
@@ -8064,9 +8064,9 @@ i40e_dev_consistent_tunnel_filter_set(struct i40e_pf *pf,
        pfilter = cld_filter;
 
        ether_addr_copy(&tunnel_filter->outer_mac,
-                       (struct ether_addr *)&pfilter->element.outer_mac);
+                       (struct rte_ether_addr *)&pfilter->element.outer_mac);
        ether_addr_copy(&tunnel_filter->inner_mac,
-                       (struct ether_addr *)&pfilter->element.inner_mac);
+                       (struct rte_ether_addr *)&pfilter->element.inner_mac);
 
        pfilter->element.inner_vlan =
                rte_cpu_to_le_16(tunnel_filter->inner_vlan);
@@ -11835,7 +11835,7 @@ static int i40e_get_module_eeprom(struct rte_eth_dev *dev,
 }
 
 static int i40e_set_default_mac_addr(struct rte_eth_dev *dev,
-                                    struct ether_addr *mac_addr)
+                                    struct rte_ether_addr *mac_addr)
 {
        struct i40e_hw *hw = I40E_DEV_PRIVATE_TO_HW(dev->data->dev_private);
        struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
@@ -11968,10 +11968,10 @@ i40e_tunnel_filter_restore(struct i40e_pf *pf)
                        vsi = vf->vsi;
                }
                memset(&cld_filter, 0, sizeof(cld_filter));
-               ether_addr_copy((struct ether_addr *)&f->input.outer_mac,
-                       (struct ether_addr *)&cld_filter.element.outer_mac);
-               ether_addr_copy((struct ether_addr *)&f->input.inner_mac,
-                       (struct ether_addr *)&cld_filter.element.inner_mac);
+               ether_addr_copy((struct rte_ether_addr *)&f->input.outer_mac,
+                       (struct rte_ether_addr *)&cld_filter.element.outer_mac);
+               ether_addr_copy((struct rte_ether_addr *)&f->input.inner_mac,
+                       (struct rte_ether_addr *)&cld_filter.element.inner_mac);
                cld_filter.element.inner_vlan = f->input.inner_vlan;
                cld_filter.element.flags = f->input.flags;
                cld_filter.element.tenant_id = f->input.tenant_id;
index 11ecfc3..09ee61d 100644 (file)
@@ -278,7 +278,7 @@ struct i40e_adapter;
  */
 struct i40e_mac_filter_info {
        enum rte_mac_filter_type filter_type;
-       struct ether_addr mac_addr;
+       struct rte_ether_addr mac_addr;
 };
 
 TAILQ_HEAD(i40e_mac_filter_list, i40e_mac_filter);
@@ -331,7 +331,7 @@ struct i40e_veb {
 
 /* i40e MACVLAN filter structure */
 struct i40e_macvlan_filter {
-       struct ether_addr macaddr;
+       struct rte_ether_addr macaddr;
        enum rte_mac_filter_type filter_type;
        uint16_t vlan_id;
 };
@@ -422,7 +422,7 @@ struct i40e_pf_vf {
        uint16_t vf_idx; /* VF index in pf->vfs */
        uint16_t lan_nb_qps; /* Actual queues allocated */
        uint16_t reset_cnt; /* Total vf reset times */
-       struct ether_addr mac_addr;  /* Default MAC address */
+       struct rte_ether_addr mac_addr;  /* Default MAC address */
        /* version of the virtchnl from VF */
        struct virtchnl_version_info version;
        uint32_t request_caps; /* offload caps requested from VF */
@@ -642,7 +642,7 @@ struct i40e_fdir_info {
 
 /* Ethertype filter struct */
 struct i40e_ethertype_filter_input {
-       struct ether_addr mac_addr;   /* Mac address to match */
+       struct rte_ether_addr mac_addr;   /* Mac address to match */
        uint16_t ether_type;          /* Ether type to match */
 };
 
@@ -760,8 +760,8 @@ enum i40e_tunnel_type {
  * Tunneling Packet filter configuration.
  */
 struct i40e_tunnel_filter_conf {
-       struct ether_addr outer_mac;    /**< Outer MAC address to match. */
-       struct ether_addr inner_mac;    /**< Inner MAC address to match. */
+       struct rte_ether_addr outer_mac;    /**< Outer MAC address to match. */
+       struct rte_ether_addr inner_mac;    /**< Inner MAC address to match. */
        uint16_t inner_vlan;            /**< Inner VLAN to match. */
        uint32_t outer_vlan;            /**< Outer VLAN to match */
        enum i40e_tunnel_iptype ip_type; /**< IP address type. */
@@ -920,7 +920,7 @@ struct i40e_pf {
        bool offset_loaded;
 
        struct rte_eth_dev_data *dev_data; /* Pointer to the device data */
-       struct ether_addr dev_addr; /* PF device mac address */
+       struct rte_ether_addr dev_addr; /* PF device mac address */
        uint64_t flags; /* PF feature flags */
        /* All kinds of queue pair setting for different VSIs */
        struct i40e_pf_vf *vfs;
@@ -1024,7 +1024,7 @@ struct i40e_vf {
        uint16_t promisc_flags; /* Promiscuous setting */
        uint32_t vlan[I40E_VFTA_SIZE]; /* VLAN bit map */
 
-       struct ether_addr mc_addrs[I40E_NUM_MACADDR_MAX]; /* Multicast addrs */
+       struct rte_ether_addr mc_addrs[I40E_NUM_MACADDR_MAX]; /* Multicast addrs */
        uint16_t mc_addrs_num;   /* Multicast mac addresses number */
 
        /* Event from pf */
@@ -1129,7 +1129,7 @@ int i40e_switch_tx_queue(struct i40e_hw *hw, uint16_t q_idx, bool on);
 int i40e_vsi_add_vlan(struct i40e_vsi *vsi, uint16_t vlan);
 int i40e_vsi_delete_vlan(struct i40e_vsi *vsi, uint16_t vlan);
 int i40e_vsi_add_mac(struct i40e_vsi *vsi, struct i40e_mac_filter_info *filter);
-int i40e_vsi_delete_mac(struct i40e_vsi *vsi, struct ether_addr *addr);
+int i40e_vsi_delete_mac(struct i40e_vsi *vsi, struct rte_ether_addr *addr);
 void i40e_update_vsi_stats(struct i40e_vsi *vsi);
 void i40e_pf_disable_irq0(struct i40e_hw *hw);
 void i40e_pf_enable_irq0(struct i40e_hw *hw);
@@ -1204,7 +1204,7 @@ int i40e_dev_consistent_tunnel_filter_set(struct i40e_pf *pf,
 int i40e_fdir_flush(struct rte_eth_dev *dev);
 int i40e_find_all_vlan_for_mac(struct i40e_vsi *vsi,
                               struct i40e_macvlan_filter *mv_f,
-                              int num, struct ether_addr *addr);
+                              int num, struct rte_ether_addr *addr);
 int i40e_remove_macvlan_filters(struct i40e_vsi *vsi,
                                struct i40e_macvlan_filter *filter,
                                int total);
index baa6cc5..601ffdc 100644 (file)
@@ -106,7 +106,7 @@ static int i40evf_dev_tx_queue_start(struct rte_eth_dev *dev,
 static int i40evf_dev_tx_queue_stop(struct rte_eth_dev *dev,
                                    uint16_t tx_queue_id);
 static int i40evf_add_mac_addr(struct rte_eth_dev *dev,
-                              struct ether_addr *addr,
+                              struct rte_ether_addr *addr,
                               uint32_t index,
                               uint32_t pool);
 static void i40evf_del_mac_addr(struct rte_eth_dev *dev, uint32_t index);
@@ -123,7 +123,7 @@ static int i40evf_dev_rss_hash_conf_get(struct rte_eth_dev *dev,
                                        struct rte_eth_rss_conf *rss_conf);
 static int i40evf_dev_mtu_set(struct rte_eth_dev *dev, uint16_t mtu);
 static int i40evf_set_default_mac_addr(struct rte_eth_dev *dev,
-                                       struct ether_addr *mac_addr);
+                                       struct rte_ether_addr *mac_addr);
 static int
 i40evf_dev_rx_queue_intr_enable(struct rte_eth_dev *dev, uint16_t queue_id);
 static int
@@ -134,10 +134,10 @@ static void i40evf_handle_pf_event(struct rte_eth_dev *dev,
 
 static int
 i40evf_add_del_mc_addr_list(struct rte_eth_dev *dev,
-                       struct ether_addr *mc_addr_set,
+                       struct rte_ether_addr *mc_addr_set,
                        uint32_t nb_mc_addr, bool add);
 static int
-i40evf_set_mc_addr_list(struct rte_eth_dev *dev, struct ether_addr *mc_addr_set,
+i40evf_set_mc_addr_list(struct rte_eth_dev *dev, struct rte_ether_addr *mc_addr_set,
                        uint32_t nb_mc_addr);
 
 /* Default hash key buffer for RSS */
@@ -754,7 +754,7 @@ i40evf_stop_queues(struct rte_eth_dev *dev)
 
 static int
 i40evf_add_mac_addr(struct rte_eth_dev *dev,
-                   struct ether_addr *addr,
+                   struct rte_ether_addr *addr,
                    __rte_unused uint32_t index,
                    __rte_unused uint32_t pool)
 {
@@ -796,7 +796,7 @@ i40evf_add_mac_addr(struct rte_eth_dev *dev,
 
 static void
 i40evf_del_mac_addr_by_addr(struct rte_eth_dev *dev,
-                           struct ether_addr *addr)
+                           struct rte_ether_addr *addr)
 {
        struct virtchnl_ether_addr_list *list;
        struct i40e_vf *vf = I40EVF_DEV_PRIVATE_TO_VF(dev->data->dev_private);
@@ -837,7 +837,7 @@ static void
 i40evf_del_mac_addr(struct rte_eth_dev *dev, uint32_t index)
 {
        struct rte_eth_dev_data *data = dev->data;
-       struct ether_addr *addr;
+       struct rte_ether_addr *addr;
 
        addr = &data->mac_addrs[index];
 
@@ -1223,7 +1223,7 @@ i40evf_init_vf(struct rte_eth_dev *dev)
        vf->vsi.adapter = I40E_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
 
        /* Store the MAC address configured by host, or generate random one */
-       if (is_valid_assigned_ether_addr((struct ether_addr *)hw->mac.addr))
+       if (is_valid_assigned_ether_addr((struct rte_ether_addr *)hw->mac.addr))
                vf->flags |= I40E_FLAG_VF_MAC_BY_PF;
        else
                eth_random_addr(hw->mac.addr); /* Generate a random one */
@@ -1460,7 +1460,7 @@ i40evf_dev_init(struct rte_eth_dev *eth_dev)
                                ETHER_ADDR_LEN * I40E_NUM_MACADDR_MAX);
                return -ENOMEM;
        }
-       ether_addr_copy((struct ether_addr *)hw->mac.addr,
+       ether_addr_copy((struct rte_ether_addr *)hw->mac.addr,
                        &eth_dev->data->mac_addrs[0]);
 
        return 0;
@@ -1865,7 +1865,7 @@ i40evf_add_del_all_mac_addr(struct rte_eth_dev *dev, bool add)
        int next_begin = 0;
        int begin = 0;
        uint32_t len;
-       struct ether_addr *addr;
+       struct rte_ether_addr *addr;
        struct vf_cmd_info args;
 
        do {
@@ -2634,7 +2634,7 @@ i40evf_dev_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
 
 static int
 i40evf_set_default_mac_addr(struct rte_eth_dev *dev,
-                           struct ether_addr *mac_addr)
+                           struct rte_ether_addr *mac_addr)
 {
        struct i40e_vf *vf = I40EVF_DEV_PRIVATE_TO_VF(dev->data->dev_private);
        struct i40e_hw *hw = I40E_DEV_PRIVATE_TO_HW(dev->data->dev_private);
@@ -2647,18 +2647,18 @@ i40evf_set_default_mac_addr(struct rte_eth_dev *dev,
        if (vf->flags & I40E_FLAG_VF_MAC_BY_PF)
                return -EPERM;
 
-       i40evf_del_mac_addr_by_addr(dev, (struct ether_addr *)hw->mac.addr);
+       i40evf_del_mac_addr_by_addr(dev, (struct rte_ether_addr *)hw->mac.addr);
 
        if (i40evf_add_mac_addr(dev, mac_addr, 0, 0) != 0)
                return -EIO;
 
-       ether_addr_copy(mac_addr, (struct ether_addr *)hw->mac.addr);
+       ether_addr_copy(mac_addr, (struct rte_ether_addr *)hw->mac.addr);
        return 0;
 }
 
 static int
 i40evf_add_del_mc_addr_list(struct rte_eth_dev *dev,
-                       struct ether_addr *mc_addrs,
+                       struct rte_ether_addr *mc_addrs,
                        uint32_t mc_addrs_num, bool add)
 {
        struct virtchnl_ether_addr_list *list;
@@ -2712,7 +2712,7 @@ i40evf_add_del_mc_addr_list(struct rte_eth_dev *dev,
 }
 
 static int
-i40evf_set_mc_addr_list(struct rte_eth_dev *dev, struct ether_addr *mc_addrs,
+i40evf_set_mc_addr_list(struct rte_eth_dev *dev, struct rte_ether_addr *mc_addrs,
                        uint32_t mc_addrs_num)
 {
        struct i40e_vf *vf = I40EVF_DEV_PRIVATE_TO_VF(dev->data->dev_private);
index 4b32fee..dd940ce 100644 (file)
@@ -685,7 +685,7 @@ i40e_fdir_fill_eth_ip_head(const struct rte_eth_fdir_input *fdir_input,
 {
        static uint8_t vlan_frame[] = {0x81, 0, 0, 0};
        uint16_t *ether_type;
-       uint8_t len = 2 * sizeof(struct ether_addr);
+       uint8_t len = 2 * sizeof(struct rte_ether_addr);
        struct ipv4_hdr *ip;
        struct ipv6_hdr *ip6;
        static const uint8_t next_proto[] = {
@@ -701,7 +701,7 @@ i40e_fdir_fill_eth_ip_head(const struct rte_eth_fdir_input *fdir_input,
                [RTE_ETH_FLOW_NONFRAG_IPV6_OTHER] = IPPROTO_NONE,
        };
 
-       raw_pkt += 2 * sizeof(struct ether_addr);
+       raw_pkt += 2 * sizeof(struct rte_ether_addr);
        if (vlan && fdir_input->flow_ext.vlan_tci) {
                rte_memcpy(raw_pkt, vlan_frame, sizeof(vlan_frame));
                rte_memcpy(raw_pkt + sizeof(uint16_t),
@@ -959,7 +959,7 @@ i40e_flow_fdir_fill_eth_ip_head(struct i40e_pf *pf,
        struct i40e_customized_pctype *cus_pctype = NULL;
        static uint8_t vlan_frame[] = {0x81, 0, 0, 0};
        uint16_t *ether_type;
-       uint8_t len = 2 * sizeof(struct ether_addr);
+       uint8_t len = 2 * sizeof(struct rte_ether_addr);
        struct ipv4_hdr *ip;
        struct ipv6_hdr *ip6;
        uint8_t pctype = fdir_input->pctype;
@@ -977,7 +977,7 @@ i40e_flow_fdir_fill_eth_ip_head(struct i40e_pf *pf,
                [I40E_FILTER_PCTYPE_NONF_IPV6_OTHER] = IPPROTO_NONE,
        };
 
-       raw_pkt += 2 * sizeof(struct ether_addr);
+       raw_pkt += 2 * sizeof(struct rte_ether_addr);
        if (vlan && fdir_input->flow_ext.vlan_tci) {
                rte_memcpy(raw_pkt, vlan_frame, sizeof(vlan_frame));
                rte_memcpy(raw_pkt + sizeof(uint16_t),
index 7d787c1..210552e 100644 (file)
@@ -4803,10 +4803,10 @@ i40e_flow_destroy_tunnel_filter(struct i40e_pf *pf,
        int ret = 0;
 
        memset(&cld_filter, 0, sizeof(cld_filter));
-       ether_addr_copy((struct ether_addr *)&filter->input.outer_mac,
-                       (struct ether_addr *)&cld_filter.element.outer_mac);
-       ether_addr_copy((struct ether_addr *)&filter->input.inner_mac,
-                       (struct ether_addr *)&cld_filter.element.inner_mac);
+       ether_addr_copy((struct rte_ether_addr *)&filter->input.outer_mac,
+                       (struct rte_ether_addr *)&cld_filter.element.outer_mac);
+       ether_addr_copy((struct rte_ether_addr *)&filter->input.inner_mac,
+                       (struct rte_ether_addr *)&cld_filter.element.inner_mac);
        cld_filter.element.inner_vlan = filter->input.inner_vlan;
        cld_filter.element.flags = filter->input.flags;
        cld_filter.element.tenant_id = filter->input.tenant_id;
index dd3962d..5b77fa7 100644 (file)
@@ -349,7 +349,7 @@ i40e_pf_host_process_cmd_get_vf_resource(struct i40e_pf_vf *vf, uint8_t *msg,
        vf_res->vsi_res[0].vsi_id = vf->vsi->vsi_id;
        vf_res->vsi_res[0].num_queue_pairs = vf->vsi->nb_qps;
        ether_addr_copy(&vf->mac_addr,
-               (struct ether_addr *)vf_res->vsi_res[0].default_mac_addr);
+               (struct rte_ether_addr *)vf_res->vsi_res[0].default_mac_addr);
 
 send_msg:
        i40e_pf_host_send_msg_to_vf(vf, VIRTCHNL_OP_GET_VF_RESOURCES,
@@ -823,7 +823,7 @@ i40e_pf_host_process_cmd_add_ether_address(struct i40e_pf_vf *vf,
                        (struct virtchnl_ether_addr_list *)msg;
        struct i40e_mac_filter_info filter;
        int i;
-       struct ether_addr *mac;
+       struct rte_ether_addr *mac;
 
        if (!b_op) {
                i40e_pf_host_send_msg_to_vf(
@@ -842,7 +842,7 @@ i40e_pf_host_process_cmd_add_ether_address(struct i40e_pf_vf *vf,
        }
 
        for (i = 0; i < addr_list->num_elements; i++) {
-               mac = (struct ether_addr *)(addr_list->list[i].addr);
+               mac = (struct rte_ether_addr *)(addr_list->list[i].addr);
                rte_memcpy(&filter.mac_addr, mac, ETHER_ADDR_LEN);
                filter.filter_type = RTE_MACVLAN_PERFECT_MATCH;
                if (is_zero_ether_addr(mac) ||
@@ -869,7 +869,7 @@ i40e_pf_host_process_cmd_del_ether_address(struct i40e_pf_vf *vf,
        struct virtchnl_ether_addr_list *addr_list =
                (struct virtchnl_ether_addr_list *)msg;
        int i;
-       struct ether_addr *mac;
+       struct rte_ether_addr *mac;
 
        if (!b_op) {
                i40e_pf_host_send_msg_to_vf(
@@ -886,7 +886,7 @@ i40e_pf_host_process_cmd_del_ether_address(struct i40e_pf_vf *vf,
        }
 
        for (i = 0; i < addr_list->num_elements; i++) {
-               mac = (struct ether_addr *)(addr_list->list[i].addr);
+               mac = (struct rte_ether_addr *)(addr_list->list[i].addr);
                if(is_zero_ether_addr(mac) ||
                        i40e_vsi_delete_mac(vf->vsi, mac)) {
                        ret = I40E_ERR_INVALID_MAC_ADDR;
index 24751d1..91de076 100644 (file)
@@ -324,7 +324,7 @@ i40e_vf_representor_mac_addr_remove(struct rte_eth_dev *ethdev, uint32_t index)
 
 static int
 i40e_vf_representor_mac_addr_set(struct rte_eth_dev *ethdev,
-               struct ether_addr *mac_addr)
+               struct rte_ether_addr *mac_addr)
 {
        struct i40e_vf_representor *representor = ethdev->data->dev_private;
 
index bba62b1..e7b3336 100644 (file)
@@ -528,7 +528,7 @@ rte_pmd_i40e_set_vf_multicast_promisc(uint16_t port, uint16_t vf_id, uint8_t on)
 
 int
 rte_pmd_i40e_set_vf_mac_addr(uint16_t port, uint16_t vf_id,
-                            struct ether_addr *mac_addr)
+                            struct rte_ether_addr *mac_addr)
 {
        struct i40e_mac_filter *f;
        struct rte_eth_dev *dev;
@@ -570,11 +570,11 @@ rte_pmd_i40e_set_vf_mac_addr(uint16_t port, uint16_t vf_id,
        return 0;
 }
 
-static const struct ether_addr null_mac_addr;
+static const struct rte_ether_addr null_mac_addr;
 
 int
 rte_pmd_i40e_remove_vf_mac_addr(uint16_t port, uint16_t vf_id,
-       struct ether_addr *mac_addr)
+       struct rte_ether_addr *mac_addr)
 {
        struct rte_eth_dev *dev;
        struct i40e_pf_vf *vf;
@@ -723,7 +723,7 @@ int rte_pmd_i40e_set_vf_broadcast(uint16_t port, uint16_t vf_id,
        struct i40e_vsi *vsi;
        struct i40e_hw *hw;
        struct i40e_mac_filter_info filter;
-       struct ether_addr broadcast = {
+       struct rte_ether_addr broadcast = {
                .addr_bytes = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff} };
        int ret;
 
@@ -2354,7 +2354,7 @@ int rte_pmd_i40e_ptype_mapping_replace(uint16_t port,
 
 int
 rte_pmd_i40e_add_vf_mac_addr(uint16_t port, uint16_t vf_id,
-                            struct ether_addr *mac_addr)
+                            struct rte_ether_addr *mac_addr)
 {
        struct rte_eth_dev *dev;
        struct i40e_pf_vf *vf;
@@ -2491,10 +2491,10 @@ rte_pmd_i40e_flow_type_mapping_update(
 }
 
 int
-rte_pmd_i40e_query_vfid_by_mac(uint16_t port, const struct ether_addr *vf_mac)
+rte_pmd_i40e_query_vfid_by_mac(uint16_t port, const struct rte_ether_addr *vf_mac)
 {
        struct rte_eth_dev *dev;
-       struct ether_addr *mac;
+       struct rte_ether_addr *mac;
        struct i40e_pf *pf;
        int vf_id;
        struct i40e_pf_vf *vf;
index be4a602..55e7fa9 100644 (file)
@@ -453,7 +453,7 @@ int rte_pmd_i40e_set_vf_multicast_promisc(uint16_t port,
  *   - (-EINVAL) if *vf* or *mac_addr* is invalid.
  */
 int rte_pmd_i40e_set_vf_mac_addr(uint16_t port, uint16_t vf_id,
-                                struct ether_addr *mac_addr);
+                                struct rte_ether_addr *mac_addr);
 
 /**
  * Remove the VF MAC address.
@@ -471,7 +471,7 @@ int rte_pmd_i40e_set_vf_mac_addr(uint16_t port, uint16_t vf_id,
  */
 int
 rte_pmd_i40e_remove_vf_mac_addr(uint16_t port, uint16_t vf_id,
-       struct ether_addr *mac_addr);
+       struct rte_ether_addr *mac_addr);
 
 /**
  * Enable/Disable vf vlan strip for all queues in a pool
@@ -854,7 +854,7 @@ int rte_pmd_i40e_ptype_mapping_replace(uint16_t port,
  *   - (-EINVAL) if *vf* or *mac_addr* is invalid.
  */
 int rte_pmd_i40e_add_vf_mac_addr(uint16_t port, uint16_t vf_id,
-                                struct ether_addr *mac_addr);
+                                struct rte_ether_addr *mac_addr);
 
 #define RTE_PMD_I40E_PCTYPE_MAX                64
 #define RTE_PMD_I40E_FLOW_TYPE_MAX     64
@@ -924,7 +924,7 @@ int rte_pmd_i40e_flow_type_mapping_reset(uint16_t port);
  *    -ENOTSUP: i40e not supported for this port.
  */
 int rte_pmd_i40e_query_vfid_by_mac(uint16_t port,
-                                       const struct ether_addr *vf_mac);
+                                       const struct rte_ether_addr *vf_mac);
 
 /**
  * Do RSS queue region configuration for that port as
index c458bff..e7e1bae 100644 (file)
@@ -220,11 +220,11 @@ static int ixgbe_dev_interrupt_get_status(struct rte_eth_dev *dev);
 static int ixgbe_dev_interrupt_action(struct rte_eth_dev *dev);
 static void ixgbe_dev_interrupt_handler(void *param);
 static void ixgbe_dev_interrupt_delayed_handler(void *param);
-static int ixgbe_add_rar(struct rte_eth_dev *dev, struct ether_addr *mac_addr,
+static int ixgbe_add_rar(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
                         uint32_t index, uint32_t pool);
 static void ixgbe_remove_rar(struct rte_eth_dev *dev, uint32_t index);
 static int ixgbe_set_default_mac_addr(struct rte_eth_dev *dev,
-                                          struct ether_addr *mac_addr);
+                                          struct rte_ether_addr *mac_addr);
 static void ixgbe_dcb_init(struct ixgbe_hw *hw, struct ixgbe_dcb_config *dcb_config);
 static bool is_device_supported(struct rte_eth_dev *dev,
                                struct rte_pci_driver *drv);
@@ -263,7 +263,7 @@ static void ixgbevf_dev_allmulticast_disable(struct rte_eth_dev *dev);
 
 /* For Eth VMDQ APIs support */
 static int ixgbe_uc_hash_table_set(struct rte_eth_dev *dev, struct
-               ether_addr * mac_addr, uint8_t on);
+               rte_ether_addr * mac_addr, uint8_t on);
 static int ixgbe_uc_all_hash_table_set(struct rte_eth_dev *dev, uint8_t on);
 static int ixgbe_mirror_rule_set(struct rte_eth_dev *dev,
                struct rte_eth_mirror_conf *mirror_conf,
@@ -279,11 +279,11 @@ static void ixgbe_set_ivar_map(struct ixgbe_hw *hw, int8_t direction,
 static void ixgbe_configure_msix(struct rte_eth_dev *dev);
 
 static int ixgbevf_add_mac_addr(struct rte_eth_dev *dev,
-                               struct ether_addr *mac_addr,
+                               struct rte_ether_addr *mac_addr,
                                uint32_t index, uint32_t pool);
 static void ixgbevf_remove_mac_addr(struct rte_eth_dev *dev, uint32_t index);
 static int ixgbevf_set_default_mac_addr(struct rte_eth_dev *dev,
-                                            struct ether_addr *mac_addr);
+                                            struct rte_ether_addr *mac_addr);
 static int ixgbe_syn_filter_get(struct rte_eth_dev *dev,
                        struct rte_eth_syn_filter *filter);
 static int ixgbe_syn_filter_handle(struct rte_eth_dev *dev,
@@ -310,7 +310,7 @@ static int ixgbe_dev_filter_ctrl(struct rte_eth_dev *dev,
 static int ixgbevf_dev_set_mtu(struct rte_eth_dev *dev, uint16_t mtu);
 
 static int ixgbe_dev_set_mc_addr_list(struct rte_eth_dev *dev,
-                                     struct ether_addr *mc_addr_set,
+                                     struct rte_ether_addr *mc_addr_set,
                                      uint32_t nb_mc_addr);
 static int ixgbe_dev_get_dcb_info(struct rte_eth_dev *dev,
                                   struct rte_eth_dcb_info *dcb_info);
@@ -1215,7 +1215,7 @@ eth_ixgbe_dev_init(struct rte_eth_dev *eth_dev, void *init_params __rte_unused)
                return -ENOMEM;
        }
        /* Copy the permanent MAC address */
-       ether_addr_copy((struct ether_addr *) hw->mac.perm_addr,
+       ether_addr_copy((struct rte_ether_addr *) hw->mac.perm_addr,
                        &eth_dev->data->mac_addrs[0]);
 
        /* Allocate memory for storing hash filter MAC addresses */
@@ -1525,7 +1525,7 @@ ixgbevf_negotiate_api(struct ixgbe_hw *hw)
 }
 
 static void
-generate_random_mac_addr(struct ether_addr *mac_addr)
+generate_random_mac_addr(struct rte_ether_addr *mac_addr)
 {
        uint64_t random;
 
@@ -1556,7 +1556,7 @@ eth_ixgbevf_dev_init(struct rte_eth_dev *eth_dev)
                IXGBE_DEV_PRIVATE_TO_VFTA(eth_dev->data->dev_private);
        struct ixgbe_hwstrip *hwstrip =
                IXGBE_DEV_PRIVATE_TO_HWSTRIP_BITMAP(eth_dev->data->dev_private);
-       struct ether_addr *perm_addr = (struct ether_addr *) hw->mac.perm_addr;
+       struct rte_ether_addr *perm_addr = (struct rte_ether_addr *) hw->mac.perm_addr;
 
        PMD_INIT_FUNC_TRACE();
 
@@ -4863,7 +4863,7 @@ ixgbe_dev_rss_reta_query(struct rte_eth_dev *dev,
 }
 
 static int
-ixgbe_add_rar(struct rte_eth_dev *dev, struct ether_addr *mac_addr,
+ixgbe_add_rar(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
                                uint32_t index, uint32_t pool)
 {
        struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
@@ -4882,7 +4882,7 @@ ixgbe_remove_rar(struct rte_eth_dev *dev, uint32_t index)
 }
 
 static int
-ixgbe_set_default_mac_addr(struct rte_eth_dev *dev, struct ether_addr *addr)
+ixgbe_set_default_mac_addr(struct rte_eth_dev *dev, struct rte_ether_addr *addr)
 {
        struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
 
@@ -5319,7 +5319,7 @@ ixgbe_vt_check(struct ixgbe_hw *hw)
 }
 
 static uint32_t
-ixgbe_uta_vector(struct ixgbe_hw *hw, struct ether_addr *uc_addr)
+ixgbe_uta_vector(struct ixgbe_hw *hw, struct rte_ether_addr *uc_addr)
 {
        uint32_t vector = 0;
 
@@ -5350,7 +5350,7 @@ ixgbe_uta_vector(struct ixgbe_hw *hw, struct ether_addr *uc_addr)
 }
 
 static int
-ixgbe_uc_hash_table_set(struct rte_eth_dev *dev, struct ether_addr *mac_addr,
+ixgbe_uc_hash_table_set(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
                        uint8_t on)
 {
        uint32_t vector;
@@ -5982,7 +5982,7 @@ ixgbe_set_queue_rate_limit(struct rte_eth_dev *dev,
 }
 
 static int
-ixgbevf_add_mac_addr(struct rte_eth_dev *dev, struct ether_addr *mac_addr,
+ixgbevf_add_mac_addr(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
                     __attribute__((unused)) uint32_t index,
                     __attribute__((unused)) uint32_t pool)
 {
@@ -5994,7 +5994,7 @@ ixgbevf_add_mac_addr(struct rte_eth_dev *dev, struct ether_addr *mac_addr,
         * operation. Trap this case to avoid exhausting the [very limited]
         * set of PF resources used to store VF MAC addresses.
         */
-       if (memcmp(hw->mac.perm_addr, mac_addr, sizeof(struct ether_addr)) == 0)
+       if (memcmp(hw->mac.perm_addr, mac_addr, sizeof(struct rte_ether_addr)) == 0)
                return -1;
        diag = ixgbevf_set_uc_addr_vf(hw, 2, mac_addr->addr_bytes);
        if (diag != 0)
@@ -6014,8 +6014,8 @@ static void
 ixgbevf_remove_mac_addr(struct rte_eth_dev *dev, uint32_t index)
 {
        struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
-       struct ether_addr *perm_addr = (struct ether_addr *) hw->mac.perm_addr;
-       struct ether_addr *mac_addr;
+       struct rte_ether_addr *perm_addr = (struct rte_ether_addr *) hw->mac.perm_addr;
+       struct rte_ether_addr *mac_addr;
        uint32_t i;
        int diag;
 
@@ -6040,7 +6040,7 @@ ixgbevf_remove_mac_addr(struct rte_eth_dev *dev, uint32_t index)
                if (is_zero_ether_addr(mac_addr))
                        continue;
                /* Skip the permanent MAC address */
-               if (memcmp(perm_addr, mac_addr, sizeof(struct ether_addr)) == 0)
+               if (memcmp(perm_addr, mac_addr, sizeof(struct rte_ether_addr)) == 0)
                        continue;
                diag = ixgbevf_set_uc_addr_vf(hw, 2, mac_addr->addr_bytes);
                if (diag != 0)
@@ -6059,7 +6059,7 @@ ixgbevf_remove_mac_addr(struct rte_eth_dev *dev, uint32_t index)
 }
 
 static int
-ixgbevf_set_default_mac_addr(struct rte_eth_dev *dev, struct ether_addr *addr)
+ixgbevf_set_default_mac_addr(struct rte_eth_dev *dev, struct rte_ether_addr *addr)
 {
        struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 
@@ -6786,13 +6786,13 @@ ixgbe_dev_addr_list_itr(__attribute__((unused)) struct ixgbe_hw *hw,
 
        *vmdq = 0;
        mc_addr = *mc_addr_ptr;
-       *mc_addr_ptr = (mc_addr + sizeof(struct ether_addr));
+       *mc_addr_ptr = (mc_addr + sizeof(struct rte_ether_addr));
        return mc_addr;
 }
 
 static int
 ixgbe_dev_set_mc_addr_list(struct rte_eth_dev *dev,
-                         struct ether_addr *mc_addr_set,
+                         struct rte_ether_addr *mc_addr_set,
                          uint32_t nb_mc_addr)
 {
        struct ixgbe_hw *hw;
index 4b833ff..0840e14 100644 (file)
@@ -480,7 +480,7 @@ ixgbe_vf_set_mac_addr(struct rte_eth_dev *dev, uint32_t vf, uint32_t *msgbuf)
        int rar_entry = hw->mac.num_rar_entries - (vf + 1);
        uint8_t *new_mac = (uint8_t *)(&msgbuf[1]);
 
-       if (is_valid_assigned_ether_addr((struct ether_addr *)new_mac)) {
+       if (is_valid_assigned_ether_addr((struct rte_ether_addr *)new_mac)) {
                rte_memcpy(vfinfo[vf].vf_mac_addresses, new_mac, 6);
                return hw->mac.ops.set_rar(hw, rar_entry, new_mac, vf, IXGBE_RAH_AV);
        }
index b0fbbc4..2836bae 100644 (file)
@@ -25,7 +25,7 @@ ixgbe_vf_representor_link_update(struct rte_eth_dev *ethdev,
 
 static int
 ixgbe_vf_representor_mac_addr_set(struct rte_eth_dev *ethdev,
-       struct ether_addr *mac_addr)
+       struct rte_ether_addr *mac_addr)
 {
        struct ixgbe_vf_representor *representor = ethdev->data->dev_private;
 
@@ -210,7 +210,7 @@ ixgbe_vf_representor_init(struct rte_eth_dev *ethdev, void *init_params)
        vf_data = *IXGBE_DEV_PRIVATE_TO_P_VFDATA(
                representor->pf_ethdev->data->dev_private);
 
-       ethdev->data->mac_addrs = (struct ether_addr *)
+       ethdev->data->mac_addrs = (struct rte_ether_addr *)
                vf_data[representor->vf_id].vf_mac_addresses;
 
        /* Link state. Inherited from PF */
index 3a874f9..3defba1 100644 (file)
@@ -11,7 +11,7 @@
 
 int
 rte_pmd_ixgbe_set_vf_mac_addr(uint16_t port, uint16_t vf,
-                             struct ether_addr *mac_addr)
+                             struct rte_ether_addr *mac_addr)
 {
        struct ixgbe_hw *hw;
        struct ixgbe_vf_info *vfinfo;
@@ -35,7 +35,7 @@ rte_pmd_ixgbe_set_vf_mac_addr(uint16_t port, uint16_t vf,
        vfinfo = *(IXGBE_DEV_PRIVATE_TO_P_VFDATA(dev->data->dev_private));
        rar_entry = hw->mac.num_rar_entries - (vf + 1);
 
-       if (is_valid_assigned_ether_addr((struct ether_addr *)new_mac)) {
+       if (is_valid_assigned_ether_addr((struct rte_ether_addr *)new_mac)) {
                rte_memcpy(vfinfo[vf].vf_mac_addresses, new_mac,
                           ETHER_ADDR_LEN);
                return hw->mac.ops.set_rar(hw, rar_entry, new_mac, vf,
index 72a941f..84c6884 100644 (file)
@@ -42,7 +42,7 @@ int rte_pmd_ixgbe_ping_vf(uint16_t port, uint16_t vf);
  *   - (-EINVAL) if *vf* or *mac_addr* is invalid.
  */
 int rte_pmd_ixgbe_set_vf_mac_addr(uint16_t port, uint16_t vf,
-               struct ether_addr *mac_addr);
+               struct rte_ether_addr *mac_addr);
 
 /**
  * Enable/Disable VF VLAN anti spoofing.
index 72f3c16..a78059c 100644 (file)
@@ -51,7 +51,7 @@ struct pmd_internals {
        int stop_thread;
        int no_request_thread;
 
-       struct ether_addr eth_addr;
+       struct rte_ether_addr eth_addr;
 
        struct pmd_queue rx_queues[KNI_MAX_QUEUE_PER_PORT];
        struct pmd_queue tx_queues[KNI_MAX_QUEUE_PER_PORT];
index 0f59e44..ddf6bf6 100644 (file)
@@ -1834,7 +1834,7 @@ lio_dev_configure(struct rte_eth_dev *eth_dev)
                                       2 + i));
 
        /* Copy the permanent MAC address */
-       ether_addr_copy((struct ether_addr *)mac, &eth_dev->data->mac_addrs[0]);
+       ether_addr_copy((struct rte_ether_addr *)mac, &eth_dev->data->mac_addrs[0]);
 
        /* enable firmware checksum support for tunnel packets */
        lio_enable_hw_tunnel_rx_checksum(eth_dev);
index 3de7bc5..b942eee 100644 (file)
@@ -601,7 +601,7 @@ mlx4_pci_probe(struct rte_pci_driver *pci_drv, struct rte_pci_device *pci_dev)
                struct ibv_pd *pd = NULL;
                struct priv *priv = NULL;
                struct rte_eth_dev *eth_dev = NULL;
-               struct ether_addr mac;
+               struct rte_ether_addr mac;
 
                /* If port is not enabled, skip. */
                if (!(conf.ports.enabled & (1 << i)))
index e6fb934..b843032 100644 (file)
@@ -108,7 +108,7 @@ struct priv {
        } mr;
        LIST_HEAD(, mlx4_rss) rss; /**< Shared targets for Rx flow rules. */
        LIST_HEAD(, rte_flow) flows; /**< Configured flow rule handles. */
-       struct ether_addr mac[MLX4_MAX_MAC_ADDRESSES];
+       struct rte_ether_addr mac[MLX4_MAX_MAC_ADDRESSES];
        /**< Configured MAC addresses. Unused entries are zeroed. */
 };
 
@@ -125,9 +125,9 @@ void mlx4_promiscuous_disable(struct rte_eth_dev *dev);
 void mlx4_allmulticast_enable(struct rte_eth_dev *dev);
 void mlx4_allmulticast_disable(struct rte_eth_dev *dev);
 void mlx4_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index);
-int mlx4_mac_addr_add(struct rte_eth_dev *dev, struct ether_addr *mac_addr,
+int mlx4_mac_addr_add(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
                      uint32_t index, uint32_t vmdq);
-int mlx4_mac_addr_set(struct rte_eth_dev *dev, struct ether_addr *mac_addr);
+int mlx4_mac_addr_set(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr);
 int mlx4_vlan_filter_set(struct rte_eth_dev *dev, uint16_t vlan_id, int on);
 int mlx4_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats);
 void mlx4_stats_reset(struct rte_eth_dev *dev);
index 30deb3e..350271d 100644 (file)
@@ -461,7 +461,7 @@ mlx4_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index)
  *   0 on success, negative errno value otherwise and rte_errno is set.
  */
 int
-mlx4_mac_addr_add(struct rte_eth_dev *dev, struct ether_addr *mac_addr,
+mlx4_mac_addr_add(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
                  uint32_t index, uint32_t vmdq)
 {
        struct priv *priv = dev->data->dev_private;
@@ -539,7 +539,7 @@ mlx4_vlan_filter_set(struct rte_eth_dev *dev, uint16_t vlan_id, int on)
  *   0 on success, negative errno value otherwise and rte_errno is set.
  */
 int
-mlx4_mac_addr_set(struct rte_eth_dev *dev, struct ether_addr *mac_addr)
+mlx4_mac_addr_set(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr)
 {
        return mlx4_mac_addr_add(dev, mac_addr, 0, 0);
 }
index b40e7e5..087725d 100644 (file)
@@ -1349,7 +1349,7 @@ mlx4_flow_internal(struct priv *priv, struct rte_flow_error *error)
                        .type = RTE_FLOW_ACTION_TYPE_END,
                },
        };
-       struct ether_addr *rule_mac = &eth_spec.dst;
+       struct rte_ether_addr *rule_mac = &eth_spec.dst;
        rte_be16_t *rule_vlan =
                (priv->dev->data->dev_conf.rxmode.offloads &
                 DEV_RX_OFFLOAD_VLAN_FILTER) &&
@@ -1386,7 +1386,7 @@ next_vlan:
                }
        }
        for (i = 0; i != RTE_DIM(priv->mac) + 1; ++i) {
-               const struct ether_addr *mac;
+               const struct rte_ether_addr *mac;
 
                /* Broadcasts are handled by an extra iteration. */
                if (i < RTE_DIM(priv->mac))
index 8cbfee1..6f124dd 100644 (file)
@@ -742,7 +742,7 @@ mlx5_dev_spawn(struct rte_device *dpdk_dev,
 #ifdef HAVE_IBV_DEVICE_COUNTERS_SET_SUPPORT
        struct ibv_counter_set_description cs_desc = { .counter_type = 0 };
 #endif
-       struct ether_addr mac;
+       struct rte_ether_addr mac;
        char name[RTE_ETH_NAME_MAX_LEN];
        int own_domain_id = 0;
        unsigned int i;
index 2dec88a..47b9d91 100644 (file)
@@ -179,7 +179,7 @@ struct priv {
        struct ibv_pd *pd; /* Protection Domain. */
        char ibdev_name[IBV_SYSFS_NAME_MAX]; /* IB device name. */
        char ibdev_path[IBV_SYSFS_PATH_MAX]; /* IB device path for secondary */
-       struct ether_addr mac[MLX5_MAX_MAC_ADDRESSES]; /* MAC addresses. */
+       struct rte_ether_addr mac[MLX5_MAX_MAC_ADDRESSES]; /* MAC addresses. */
        BITFIELD_DECLARE(mac_own, uint64_t, MLX5_MAX_MAC_ADDRESSES);
        /* Bit-field of MAC addresses owned by the PMD. */
        uint16_t vlan_filter[MLX5_MAX_VLAN_IDS]; /* VLAN filters table. */
@@ -285,11 +285,11 @@ int mlx5_sysfs_switch_info(unsigned int ifindex,
 
 int mlx5_get_mac(struct rte_eth_dev *dev, uint8_t (*mac)[ETHER_ADDR_LEN]);
 void mlx5_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index);
-int mlx5_mac_addr_add(struct rte_eth_dev *dev, struct ether_addr *mac,
+int mlx5_mac_addr_add(struct rte_eth_dev *dev, struct rte_ether_addr *mac,
                      uint32_t index, uint32_t vmdq);
-int mlx5_mac_addr_set(struct rte_eth_dev *dev, struct ether_addr *mac_addr);
+int mlx5_mac_addr_set(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr);
 int mlx5_set_mc_addr_list(struct rte_eth_dev *dev,
-                         struct ether_addr *mc_addr_set, uint32_t nb_mc_addr);
+                         struct rte_ether_addr *mc_addr_set, uint32_t nb_mc_addr);
 
 /* mlx5_rss.c */
 
@@ -389,9 +389,9 @@ int mlx5_socket_connect(struct rte_eth_dev *priv);
 /* mlx5_nl.c */
 
 int mlx5_nl_init(int protocol);
-int mlx5_nl_mac_addr_add(struct rte_eth_dev *dev, struct ether_addr *mac,
+int mlx5_nl_mac_addr_add(struct rte_eth_dev *dev, struct rte_ether_addr *mac,
                         uint32_t index);
-int mlx5_nl_mac_addr_remove(struct rte_eth_dev *dev, struct ether_addr *mac,
+int mlx5_nl_mac_addr_remove(struct rte_eth_dev *dev, struct rte_ether_addr *mac,
                            uint32_t index);
 void mlx5_nl_mac_addr_sync(struct rte_eth_dev *dev);
 void mlx5_nl_mac_addr_flush(struct rte_eth_dev *dev);
index 131b62b..9b2b127 100644 (file)
@@ -365,8 +365,8 @@ flow_tcf_pedit_key_set_mac(const struct rte_flow_action *actions,
 {
        int idx = p_parser->sel.nkeys;
        uint32_t off = actions->type == RTE_FLOW_ACTION_TYPE_SET_MAC_SRC ?
-                                       offsetof(struct ether_hdr, s_addr) :
-                                       offsetof(struct ether_hdr, d_addr);
+                                       offsetof(struct rte_ether_hdr, s_addr) :
+                                       offsetof(struct rte_ether_hdr, d_addr);
        const struct rte_flow_action_set_mac *conf =
                (const struct rte_flow_action_set_mac *)actions->conf;
 
index 672a476..cee52a5 100644 (file)
@@ -76,7 +76,7 @@ mlx5_internal_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index)
        if (vf)
                mlx5_nl_mac_addr_remove(dev, &dev->data->mac_addrs[index],
                                        index);
-       memset(&dev->data->mac_addrs[index], 0, sizeof(struct ether_addr));
+       memset(&dev->data->mac_addrs[index], 0, sizeof(struct rte_ether_addr));
 }
 
 /**
@@ -93,7 +93,7 @@ mlx5_internal_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index)
  *   0 on success, a negative errno value otherwise and rte_errno is set.
  */
 static int
-mlx5_internal_mac_addr_add(struct rte_eth_dev *dev, struct ether_addr *mac,
+mlx5_internal_mac_addr_add(struct rte_eth_dev *dev, struct rte_ether_addr *mac,
                           uint32_t index)
 {
        struct priv *priv = dev->data->dev_private;
@@ -166,7 +166,7 @@ mlx5_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index)
  *   0 on success, a negative errno value otherwise and rte_errno is set.
  */
 int
-mlx5_mac_addr_add(struct rte_eth_dev *dev, struct ether_addr *mac,
+mlx5_mac_addr_add(struct rte_eth_dev *dev, struct rte_ether_addr *mac,
                  uint32_t index, uint32_t vmdq __rte_unused)
 {
        int ret;
@@ -195,7 +195,7 @@ mlx5_mac_addr_add(struct rte_eth_dev *dev, struct ether_addr *mac,
  *   0 on success, a negative errno value otherwise and rte_errno is set.
  */
 int
-mlx5_mac_addr_set(struct rte_eth_dev *dev, struct ether_addr *mac_addr)
+mlx5_mac_addr_set(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr)
 {
        DRV_LOG(DEBUG, "port %u setting primary MAC address",
                dev->data->port_id);
@@ -209,7 +209,7 @@ mlx5_mac_addr_set(struct rte_eth_dev *dev, struct ether_addr *mac_addr)
  */
 int
 mlx5_set_mc_addr_list(struct rte_eth_dev *dev,
-                     struct ether_addr *mc_addr_set, uint32_t nb_mc_addr)
+                     struct rte_ether_addr *mc_addr_set, uint32_t nb_mc_addr)
 {
        uint32_t i;
        int ret;
index d61826a..a82c0cc 100644 (file)
@@ -74,7 +74,7 @@
 
 /* Add/remove MAC address through Netlink */
 struct mlx5_nl_mac_addr {
-       struct ether_addr (*mac)[];
+       struct rte_ether_addr (*mac)[];
        /**< MAC address handled by the device. */
        int mac_n; /**< Number of addresses in the array. */
 };
@@ -358,7 +358,7 @@ mlx5_nl_mac_addr_cb(struct nlmsghdr *nh, void *arg)
  *   0 on success, a negative errno value otherwise and rte_errno is set.
  */
 static int
-mlx5_nl_mac_addr_list(struct rte_eth_dev *dev, struct ether_addr (*mac)[],
+mlx5_nl_mac_addr_list(struct rte_eth_dev *dev, struct rte_ether_addr (*mac)[],
                      int *mac_n)
 {
        struct priv *priv = dev->data->dev_private;
@@ -417,7 +417,7 @@ error:
  *   0 on success, a negative errno value otherwise and rte_errno is set.
  */
 static int
-mlx5_nl_mac_addr_modify(struct rte_eth_dev *dev, struct ether_addr *mac,
+mlx5_nl_mac_addr_modify(struct rte_eth_dev *dev, struct rte_ether_addr *mac,
                        int add)
 {
        struct priv *priv = dev->data->dev_private;
@@ -489,7 +489,7 @@ error:
  *   0 on success, a negative errno value otherwise and rte_errno is set.
  */
 int
-mlx5_nl_mac_addr_add(struct rte_eth_dev *dev, struct ether_addr *mac,
+mlx5_nl_mac_addr_add(struct rte_eth_dev *dev, struct rte_ether_addr *mac,
                     uint32_t index)
 {
        struct priv *priv = dev->data->dev_private;
@@ -517,7 +517,7 @@ mlx5_nl_mac_addr_add(struct rte_eth_dev *dev, struct ether_addr *mac,
  *   0 on success, a negative errno value otherwise and rte_errno is set.
  */
 int
-mlx5_nl_mac_addr_remove(struct rte_eth_dev *dev, struct ether_addr *mac,
+mlx5_nl_mac_addr_remove(struct rte_eth_dev *dev, struct rte_ether_addr *mac,
                        uint32_t index)
 {
        struct priv *priv = dev->data->dev_private;
@@ -535,7 +535,7 @@ mlx5_nl_mac_addr_remove(struct rte_eth_dev *dev, struct ether_addr *mac,
 void
 mlx5_nl_mac_addr_sync(struct rte_eth_dev *dev)
 {
-       struct ether_addr macs[MLX5_MAX_MAC_ADDRESSES];
+       struct rte_ether_addr macs[MLX5_MAX_MAC_ADDRESSES];
        int macs_n = 0;
        int i;
        int ret;
@@ -576,7 +576,7 @@ mlx5_nl_mac_addr_flush(struct rte_eth_dev *dev)
        int i;
 
        for (i = MLX5_MAX_MAC_ADDRESSES - 1; i >= 0; --i) {
-               struct ether_addr *m = &dev->data->mac_addrs[i];
+               struct rte_ether_addr *m = &dev->data->mac_addrs[i];
 
                if (BITFIELD_ISSET(priv->mac_own, i))
                        mlx5_nl_mac_addr_remove(dev, m, i);
index 1db468c..9aea61d 100644 (file)
@@ -791,7 +791,7 @@ txq_mbuf_to_swp(struct mlx5_txq_data *txq, struct rte_mbuf *buf,
         * in if any of SWP offsets is set. Therefore, all of the L3 offsets
         * should be set regardless of HW offload.
         */
-       off = buf->outer_l2_len + (vlan ? sizeof(struct vlan_hdr) : 0);
+       off = buf->outer_l2_len + (vlan ? sizeof(struct rte_vlan_hdr) : 0);
        offsets[1] = off >> 1; /* Outer L3 offset. */
        off += buf->outer_l3_len;
        if (tunnel == PKT_TX_TUNNEL_UDP)
index e2a9bb7..686b9ec 100644 (file)
@@ -269,7 +269,7 @@ mlx5_traffic_enable(struct rte_eth_dev *dev)
                .dst.addr_bytes = "\xff\xff\xff\xff\xff\xff",
        };
        const unsigned int vlan_filter_n = priv->vlan_filter_n;
-       const struct ether_addr cmp = {
+       const struct rte_ether_addr cmp = {
                .addr_bytes = "\x00\x00\x00\x00\x00\x00",
        };
        unsigned int i;
@@ -332,7 +332,7 @@ mlx5_traffic_enable(struct rte_eth_dev *dev)
        }
        /* Add MAC address flows. */
        for (i = 0; i != MLX5_MAX_MAC_ADDRESSES; ++i) {
-               struct ether_addr *mac = &dev->data->mac_addrs[i];
+               struct rte_ether_addr *mac = &dev->data->mac_addrs[i];
 
                if (!memcmp(mac, &cmp, sizeof(*mac)))
                        continue;
index f7071bc..8fd3441 100644 (file)
@@ -616,7 +616,7 @@ mvneta_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index)
  *   0 on success, negative error value otherwise.
  */
 static int
-mvneta_mac_addr_add(struct rte_eth_dev *dev, struct ether_addr *mac_addr,
+mvneta_mac_addr_add(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
                  uint32_t index, uint32_t vmdq __rte_unused)
 {
        struct mvneta_priv *priv = dev->data->dev_private;
@@ -649,7 +649,7 @@ mvneta_mac_addr_add(struct rte_eth_dev *dev, struct ether_addr *mac_addr,
  *   MAC address to register.
  */
 static int
-mvneta_mac_addr_set(struct rte_eth_dev *dev, struct ether_addr *mac_addr)
+mvneta_mac_addr_set(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr)
 {
        struct mvneta_priv *priv = dev->data->dev_private;
        int ret;
index 0682c63..bffad9c 100644 (file)
@@ -1101,7 +1101,7 @@ mrvl_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index)
  *   0 on success, negative error value otherwise.
  */
 static int
-mrvl_mac_addr_add(struct rte_eth_dev *dev, struct ether_addr *mac_addr,
+mrvl_mac_addr_add(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
                  uint32_t index, uint32_t vmdq __rte_unused)
 {
        struct mrvl_priv *priv = dev->data->dev_private;
@@ -1153,7 +1153,7 @@ mrvl_mac_addr_add(struct rte_eth_dev *dev, struct ether_addr *mac_addr,
  *   0 on success, negative error value otherwise.
  */
 static int
-mrvl_mac_addr_set(struct rte_eth_dev *dev, struct ether_addr *mac_addr)
+mrvl_mac_addr_set(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr)
 {
        struct mrvl_priv *priv = dev->data->dev_private;
        int ret;
index ffd1dab..7389865 100644 (file)
@@ -989,7 +989,7 @@ mrvl_parse_eth(const struct rte_flow_item *item, struct rte_flow *flow,
               struct rte_flow_error *error)
 {
        const struct rte_flow_item_eth *spec = NULL, *mask = NULL;
-       struct ether_addr zero;
+       struct rte_ether_addr zero;
        int ret;
 
        ret = mrvl_parse_init(item, (const void **)&spec, (const void **)&mask,
index 8e728d6..8e409eb 100644 (file)
@@ -298,7 +298,7 @@ hn_dev_allmulticast_disable(struct rte_eth_dev *dev)
 
 static int
 hn_dev_mc_addr_list(struct rte_eth_dev *dev,
-                    struct ether_addr *mc_addr_set,
+                    struct rte_ether_addr *mc_addr_set,
                     uint32_t nb_mc_addr)
 {
        /* No filtering on the synthetic path, but can do it on VF */
index f4a3664..a5cc952 100644 (file)
@@ -108,7 +108,7 @@ static void
 hn_update_packet_stats(struct hn_stats *stats, const struct rte_mbuf *m)
 {
        uint32_t s = m->pkt_len;
-       const struct ether_addr *ea;
+       const struct rte_ether_addr *ea;
 
        if (s == 64) {
                stats->size_bins[1]++;
@@ -127,7 +127,7 @@ hn_update_packet_stats(struct hn_stats *stats, const struct rte_mbuf *m)
                        stats->size_bins[7]++;
        }
 
-       ea = rte_pktmbuf_mtod(m, const struct ether_addr *);
+       ea = rte_pktmbuf_mtod(m, const struct rte_ether_addr *);
        if (is_multicast_ether_addr(ea)) {
                if (is_broadcast_ether_addr(ea))
                        stats->broadcast++;
index e1072c7..269510a 100644 (file)
@@ -126,7 +126,7 @@ struct hn_data {
        rte_atomic32_t  rndis_req_id;
        uint8_t         rndis_resp[256];
 
-       struct ether_addr mac_addr;
+       struct rte_ether_addr mac_addr;
 
        struct rte_eth_dev_owner owner;
        struct rte_intr_handle vf_intr;
@@ -184,7 +184,7 @@ void        hn_vf_allmulticast_disable(struct rte_eth_dev *dev);
 void   hn_vf_promiscuous_enable(struct rte_eth_dev *dev);
 void   hn_vf_promiscuous_disable(struct rte_eth_dev *dev);
 int    hn_vf_mc_addr_list(struct rte_eth_dev *dev,
-                          struct ether_addr *mc_addr_set,
+                          struct rte_ether_addr *mc_addr_set,
                           uint32_t nb_mc_addr);
 
 int    hn_vf_link_update(struct rte_eth_dev *dev,
index 7a84ad8..96f9e54 100644 (file)
 /* Search for VF with matching MAC address, return port id */
 static int hn_vf_match(const struct rte_eth_dev *dev)
 {
-       const struct ether_addr *mac = dev->data->mac_addrs;
+       const struct rte_ether_addr *mac = dev->data->mac_addrs;
        char buf[32];
        int i;
 
        ether_format_addr(buf, sizeof(buf), mac);
        RTE_ETH_FOREACH_DEV(i) {
                const struct rte_eth_dev *vf_dev = &rte_eth_devices[i];
-               const struct ether_addr *vf_mac = vf_dev->data->mac_addrs;
+               const struct rte_ether_addr *vf_mac = vf_dev->data->mac_addrs;
 
                if (vf_dev == dev)
                        continue;
@@ -394,7 +394,7 @@ void hn_vf_promiscuous_disable(struct rte_eth_dev *dev)
 }
 
 int hn_vf_mc_addr_list(struct rte_eth_dev *dev,
-                       struct ether_addr *mc_addr_set,
+                       struct rte_ether_addr *mc_addr_set,
                        uint32_t nb_mc_addr)
 {
        struct hn_data *hv = dev->data->dev_private;
index 4d6a797..56628b5 100644 (file)
@@ -110,7 +110,7 @@ static int nfp_net_rss_reta_write(struct rte_eth_dev *dev,
 static int nfp_net_rss_hash_write(struct rte_eth_dev *dev,
                        struct rte_eth_rss_conf *rss_conf);
 static int nfp_set_mac_addr(struct rte_eth_dev *dev,
-                            struct ether_addr *mac_addr);
+                            struct rte_ether_addr *mac_addr);
 
 /* The offset of the queue controller queues in the PCIe Target */
 #define NFP_PCIE_QUEUE(_q) (0x80000 + (NFP_QCP_QUEUE_ADDR_SZ * ((_q) & 0xff)))
@@ -544,7 +544,7 @@ nfp_net_write_mac(struct nfp_net_hw *hw, uint8_t *mac)
 }
 
 int
-nfp_set_mac_addr(struct rte_eth_dev *dev, struct ether_addr *mac_addr)
+nfp_set_mac_addr(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr)
 {
        struct nfp_net_hw *hw;
        uint32_t update, ctrl;
@@ -2888,7 +2888,7 @@ nfp_net_init(struct rte_eth_dev *eth_dev)
                nfp_net_vf_read_mac(hw);
        }
 
-       if (!is_valid_assigned_ether_addr((struct ether_addr *)&hw->mac_addr)) {
+       if (!is_valid_assigned_ether_addr((struct rte_ether_addr *)&hw->mac_addr)) {
                PMD_INIT_LOG(INFO, "Using random mac address for port %d",
                                   port);
                /* Using random mac addresses for VFs */
@@ -2897,7 +2897,7 @@ nfp_net_init(struct rte_eth_dev *eth_dev)
        }
 
        /* Copying mac address to DPDK eth_dev struct */
-       ether_addr_copy((struct ether_addr *)hw->mac_addr,
+       ether_addr_copy((struct rte_ether_addr *)hw->mac_addr,
                        &eth_dev->data->mac_addrs[0]);
 
        if (!(hw->cap & NFP_NET_CFG_CTRL_LIVE_ADDR))
index 1e8237a..b797593 100644 (file)
@@ -73,7 +73,7 @@ struct pmd_internals {
        struct null_queue rx_null_queues[RTE_MAX_QUEUES_PER_PORT];
        struct null_queue tx_null_queues[RTE_MAX_QUEUES_PER_PORT];
 
-       struct ether_addr eth_addr;
+       struct rte_ether_addr eth_addr;
        /** Bit mask of RSS offloads, the bit offset also means flow type */
        uint64_t flow_type_rss_offloads;
 
@@ -467,7 +467,7 @@ eth_rss_hash_conf_get(struct rte_eth_dev *dev,
 
 static int
 eth_mac_address_set(__rte_unused struct rte_eth_dev *dev,
-                   __rte_unused struct ether_addr *addr)
+                   __rte_unused struct rte_ether_addr *addr)
 {
        return 0;
 }
index 5431b44..e4dbdc0 100644 (file)
@@ -555,7 +555,7 @@ octeontx_dev_stats_reset(struct rte_eth_dev *dev)
 
 static int
 octeontx_dev_default_mac_addr_set(struct rte_eth_dev *dev,
-                                       struct ether_addr *addr)
+                                       struct rte_ether_addr *addr)
 {
        struct octeontx_nic *nic = octeontx_pmd_priv(dev);
        int ret;
index ede5ebb..e0ac16c 100644 (file)
@@ -77,7 +77,7 @@ struct pcap_tx_queue {
 struct pmd_internals {
        struct pcap_rx_queue rx_queue[RTE_PMD_PCAP_MAX_QUEUES];
        struct pcap_tx_queue tx_queue[RTE_PMD_PCAP_MAX_QUEUES];
-       struct ether_addr eth_addr;
+       struct rte_ether_addr eth_addr;
        int if_index;
        int single_iface;
        int phy_mac;
@@ -918,7 +918,7 @@ pmd_init_internals(struct rte_vdev_device *vdev,
         * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx'
         * where the middle 4 characters are converted to hex.
         */
-       (*internals)->eth_addr = (struct ether_addr) {
+       (*internals)->eth_addr = (struct rte_ether_addr) {
                .addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ }
        };
        (*internals)->phy_mac = 0;
index 5745832..57b02ce 100644 (file)
@@ -558,9 +558,9 @@ qede_ucast_filter(struct rte_eth_dev *eth_dev, struct ecore_filter_ucast *ucast,
        struct ecore_dev *edev = QEDE_INIT_EDEV(qdev);
        struct qede_ucast_entry *tmp = NULL;
        struct qede_ucast_entry *u;
-       struct ether_addr *mac_addr;
+       struct rte_ether_addr *mac_addr;
 
-       mac_addr  = (struct ether_addr *)ucast->mac;
+       mac_addr  = (struct rte_ether_addr *)ucast->mac;
        if (add) {
                SLIST_FOREACH(tmp, &qdev->uc_list_head, list) {
                        if ((memcmp(mac_addr, &tmp->mac,
@@ -604,7 +604,7 @@ qede_ucast_filter(struct rte_eth_dev *eth_dev, struct ecore_filter_ucast *ucast,
 }
 
 static int
-qede_add_mcast_filters(struct rte_eth_dev *eth_dev, struct ether_addr *mc_addrs,
+qede_add_mcast_filters(struct rte_eth_dev *eth_dev, struct rte_ether_addr *mc_addrs,
                       uint32_t mc_addrs_num)
 {
        struct qede_dev *qdev = QEDE_INIT_QDEV(eth_dev);
@@ -628,7 +628,7 @@ qede_add_mcast_filters(struct rte_eth_dev *eth_dev, struct ether_addr *mc_addrs,
        mcast.num_mc_addrs = mc_addrs_num;
        mcast.opcode = ECORE_FILTER_ADD;
        for (i = 0; i < mc_addrs_num; i++)
-               ether_addr_copy(&mc_addrs[i], (struct ether_addr *)
+               ether_addr_copy(&mc_addrs[i], (struct rte_ether_addr *)
                                                        &mcast.mac[i]);
        rc = ecore_filter_mcast_cmd(edev, &mcast, ECORE_SPQ_MODE_CB, NULL);
        if (rc != ECORE_SUCCESS) {
@@ -653,7 +653,7 @@ static int qede_del_mcast_filters(struct rte_eth_dev *eth_dev)
        mcast.opcode = ECORE_FILTER_REMOVE;
        j = 0;
        SLIST_FOREACH(tmp, &qdev->mc_list_head, list) {
-               ether_addr_copy(&tmp->mac, (struct ether_addr *)&mcast.mac[j]);
+               ether_addr_copy(&tmp->mac, (struct rte_ether_addr *)&mcast.mac[j]);
                j++;
        }
        rc = ecore_filter_mcast_cmd(edev, &mcast, ECORE_SPQ_MODE_CB, NULL);
@@ -700,7 +700,7 @@ qede_mac_int_ops(struct rte_eth_dev *eth_dev, struct ecore_filter_ucast *ucast,
 }
 
 static int
-qede_mac_addr_add(struct rte_eth_dev *eth_dev, struct ether_addr *mac_addr,
+qede_mac_addr_add(struct rte_eth_dev *eth_dev, struct rte_ether_addr *mac_addr,
                  __rte_unused uint32_t index, __rte_unused uint32_t pool)
 {
        struct ecore_filter_ucast ucast;
@@ -712,7 +712,7 @@ qede_mac_addr_add(struct rte_eth_dev *eth_dev, struct ether_addr *mac_addr,
        qede_set_ucast_cmn_params(&ucast);
        ucast.opcode = ECORE_FILTER_ADD;
        ucast.type = ECORE_FILTER_MAC;
-       ether_addr_copy(mac_addr, (struct ether_addr *)&ucast.mac);
+       ether_addr_copy(mac_addr, (struct rte_ether_addr *)&ucast.mac);
        re = (int)qede_mac_int_ops(eth_dev, &ucast, 1);
        return re;
 }
@@ -741,13 +741,13 @@ qede_mac_addr_remove(struct rte_eth_dev *eth_dev, uint32_t index)
 
        /* Use the index maintained by rte */
        ether_addr_copy(&eth_dev->data->mac_addrs[index],
-                       (struct ether_addr *)&ucast.mac);
+                       (struct rte_ether_addr *)&ucast.mac);
 
        qede_mac_int_ops(eth_dev, &ucast, false);
 }
 
 static int
-qede_mac_addr_set(struct rte_eth_dev *eth_dev, struct ether_addr *mac_addr)
+qede_mac_addr_set(struct rte_eth_dev *eth_dev, struct rte_ether_addr *mac_addr)
 {
        struct qede_dev *qdev = QEDE_INIT_QDEV(eth_dev);
        struct ecore_dev *edev = QEDE_INIT_EDEV(qdev);
@@ -1759,7 +1759,7 @@ static void qede_allmulticast_disable(struct rte_eth_dev *eth_dev)
 }
 
 static int
-qede_set_mc_addr_list(struct rte_eth_dev *eth_dev, struct ether_addr *mc_addrs,
+qede_set_mc_addr_list(struct rte_eth_dev *eth_dev, struct rte_ether_addr *mc_addrs,
                      uint32_t mc_addrs_num)
 {
        struct qede_dev *qdev = QEDE_INIT_QDEV(eth_dev);
@@ -2551,7 +2551,7 @@ static int qede_common_dev_init(struct rte_eth_dev *eth_dev, bool is_vf)
        }
 
        if (!is_vf) {
-               ether_addr_copy((struct ether_addr *)edev->hwfns[0].
+               ether_addr_copy((struct rte_ether_addr *)edev->hwfns[0].
                                hw_info.hw_mac_addr,
                                &eth_dev->data->mac_addrs[0]);
                ether_addr_copy(&eth_dev->data->mac_addrs[0],
@@ -2567,7 +2567,7 @@ static int qede_common_dev_init(struct rte_eth_dev *eth_dev, bool is_vf)
                                                &is_mac_forced);
                        if (is_mac_exist) {
                                DP_INFO(edev, "VF macaddr received from PF\n");
-                               ether_addr_copy((struct ether_addr *)&vf_mac,
+                               ether_addr_copy((struct rte_ether_addr *)&vf_mac,
                                                &eth_dev->data->mac_addrs[0]);
                                ether_addr_copy(&eth_dev->data->mac_addrs[0],
                                                &adapter->primary_mac);
index 622bd01..8d33642 100644 (file)
@@ -140,12 +140,12 @@ struct qede_vlan_entry {
 };
 
 struct qede_mcast_entry {
-       struct ether_addr mac;
+       struct rte_ether_addr mac;
        SLIST_ENTRY(qede_mcast_entry) list;
 };
 
 struct qede_ucast_entry {
-       struct ether_addr mac;
+       struct rte_ether_addr mac;
        uint16_t vlan;
        uint16_t vni;
        SLIST_ENTRY(qede_ucast_entry) list;
@@ -228,7 +228,7 @@ struct qede_dev {
        SLIST_HEAD(vlan_list_head, qede_vlan_entry)vlan_list_head;
        uint16_t configured_vlans;
        bool accept_any_vlan;
-       struct ether_addr primary_mac;
+       struct rte_ether_addr primary_mac;
        SLIST_HEAD(mc_list_head, qede_mcast_entry) mc_list_head;
        uint16_t num_mc_addr;
        SLIST_HEAD(uc_list_head, qede_ucast_entry) uc_list_head;
index 5e6571c..27fbe53 100644 (file)
@@ -465,8 +465,8 @@ qede_arfs_construct_pkt(struct rte_eth_dev *eth_dev,
 
        raw_pkt = (uint8_t *)buff;
 
-       len =  2 * sizeof(struct ether_addr);
-       raw_pkt += 2 * sizeof(struct ether_addr);
+       len =  2 * sizeof(struct rte_ether_addr);
+       raw_pkt += 2 * sizeof(struct rte_ether_addr);
        ether_type = (uint16_t *)raw_pkt;
        raw_pkt += sizeof(uint16_t);
        len += sizeof(uint16_t);
index ee5e54c..b840c74 100644 (file)
@@ -59,7 +59,7 @@ struct qed_dev_eth_info {
        uint8_t num_queues;
        uint8_t num_tc;
 
-       struct ether_addr port_mac;
+       struct rte_ether_addr port_mac;
        uint16_t num_vlan_filters;
        uint32_t num_mac_filters;
 
index 8a4772f..93f9e54 100644 (file)
@@ -902,23 +902,23 @@ static inline uint8_t qede_check_notunn_csum_l4(uint16_t flag)
 static inline uint32_t qede_rx_cqe_to_pkt_type_outer(struct rte_mbuf *m)
 {
        uint32_t packet_type = RTE_PTYPE_UNKNOWN;
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        struct ipv4_hdr *ipv4_hdr;
        struct ipv6_hdr *ipv6_hdr;
-       struct vlan_hdr *vlan_hdr;
+       struct rte_vlan_hdr *vlan_hdr;
        uint16_t ethertype;
        bool vlan_tagged = 0;
        uint16_t len;
 
-       eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
-       len = sizeof(struct ether_hdr);
+       eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
+       len = sizeof(struct rte_ether_hdr);
        ethertype = rte_cpu_to_be_16(eth_hdr->ether_type);
 
         /* Note: Valid only if VLAN stripping is disabled */
        if (ethertype == ETHER_TYPE_VLAN) {
                vlan_tagged = 1;
-               vlan_hdr = (struct vlan_hdr *)(eth_hdr + 1);
-               len += sizeof(struct vlan_hdr);
+               vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+               len += sizeof(struct rte_vlan_hdr);
                ethertype = rte_cpu_to_be_16(vlan_hdr->eth_proto);
        }
 
@@ -1105,7 +1105,7 @@ qede_check_notunn_csum_l3(struct rte_mbuf *m, uint16_t flag)
                m->packet_type = qede_rx_cqe_to_pkt_type(flag);
                if (RTE_ETH_IS_IPV4_HDR(m->packet_type)) {
                        ip = rte_pktmbuf_mtod_offset(m, struct ipv4_hdr *,
-                                          sizeof(struct ether_hdr));
+                                          sizeof(struct rte_ether_hdr));
                        pkt_csum = ip->hdr_checksum;
                        ip->hdr_checksum = 0;
                        calc_csum = rte_ipv4_cksum(ip);
index bfe2f17..937c54e 100644 (file)
@@ -51,7 +51,7 @@ struct pmd_internals {
        struct ring_queue rx_ring_queues[RTE_PMD_RING_MAX_RX_RINGS];
        struct ring_queue tx_ring_queues[RTE_PMD_RING_MAX_TX_RINGS];
 
-       struct ether_addr address;
+       struct rte_ether_addr address;
        enum dev_action action;
 };
 
@@ -215,7 +215,7 @@ eth_mac_addr_remove(struct rte_eth_dev *dev __rte_unused,
 
 static int
 eth_mac_addr_add(struct rte_eth_dev *dev __rte_unused,
-       struct ether_addr *mac_addr __rte_unused,
+       struct rte_ether_addr *mac_addr __rte_unused,
        uint32_t index __rte_unused,
        uint32_t vmdq __rte_unused)
 {
index 51be440..af8d94f 100644 (file)
@@ -132,7 +132,7 @@ struct sfc_port {
        boolean_t                       promisc;
        boolean_t                       allmulti;
 
-       struct ether_addr               default_mac_addr;
+       struct rte_ether_addr           default_mac_addr;
 
        unsigned int                    max_mcast_addrs;
        unsigned int                    nb_mcast_addrs;
index b2e17f2..761958d 100644 (file)
@@ -901,12 +901,12 @@ fail_inval:
        return -rc;
 }
 static int
-sfc_mac_addr_set(struct rte_eth_dev *dev, struct ether_addr *mac_addr)
+sfc_mac_addr_set(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr)
 {
        struct sfc_adapter *sa = dev->data->dev_private;
        const efx_nic_cfg_t *encp = efx_nic_cfg_get(sa->nic);
        struct sfc_port *port = &sa->port;
-       struct ether_addr *old_addr = &dev->data->mac_addrs[0];
+       struct rte_ether_addr *old_addr = &dev->data->mac_addrs[0];
        int rc = 0;
 
        sfc_adapter_lock(sa);
@@ -985,7 +985,7 @@ unlock:
 
 
 static int
-sfc_set_mc_addr_list(struct rte_eth_dev *dev, struct ether_addr *mc_addr_set,
+sfc_set_mc_addr_list(struct rte_eth_dev *dev, struct rte_ether_addr *mc_addr_set,
                     uint32_t nb_mc_addr)
 {
        struct sfc_adapter *sa = dev->data->dev_private;
@@ -1931,7 +1931,7 @@ sfc_eth_dev_init(struct rte_eth_dev *dev)
        struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
        int rc;
        const efx_nic_cfg_t *encp;
-       const struct ether_addr *from;
+       const struct rte_ether_addr *from;
 
        sfc_register_dp();
 
@@ -1986,7 +1986,7 @@ sfc_eth_dev_init(struct rte_eth_dev *dev)
         * The arguments are really reverse order in comparison to
         * Linux kernel. Copy from NIC config to Ethernet device data.
         */
-       from = (const struct ether_addr *)(encp->enc_mac_addr);
+       from = (const struct rte_ether_addr *)(encp->enc_mac_addr);
        ether_addr_copy(from, &dev->data->mac_addrs[0]);
 
        sfc_adapter_unlock(sa);
index 5384dbb..c6f403d 100644 (file)
@@ -213,7 +213,7 @@ sfc_port_start(struct sfc_adapter *sa)
                goto fail_mac_pdu_set;
 
        if (!port->isolated) {
-               struct ether_addr *addr = &port->default_mac_addr;
+               struct rte_ether_addr *addr = &port->default_mac_addr;
 
                sfc_log_init(sa, "set MAC address");
                rc = efx_mac_addr_set(sa->nic, addr->addr_bytes);
@@ -372,7 +372,7 @@ sfc_port_attach(struct sfc_adapter *sa)
 {
        struct sfc_port *port = &sa->port;
        const efx_nic_cfg_t *encp = efx_nic_cfg_get(sa->nic);
-       const struct ether_addr *from;
+       const struct rte_ether_addr *from;
        uint32_t mac_nstats;
        size_t mac_stats_size;
        long kvarg_stats_update_period_ms;
@@ -387,7 +387,7 @@ sfc_port_attach(struct sfc_adapter *sa)
        port->flow_ctrl_autoneg = B_TRUE;
 
        RTE_BUILD_BUG_ON(sizeof(encp->enc_mac_addr) != sizeof(*from));
-       from = (const struct ether_addr *)(encp->enc_mac_addr);
+       from = (const struct rte_ether_addr *)(encp->enc_mac_addr);
        ether_addr_copy(from, &port->default_mac_addr);
 
        port->max_mcast_addrs = EFX_MAC_MULTICAST_LIST_MAX;
index a8688a2..7ea6eb4 100644 (file)
@@ -528,13 +528,13 @@ inet_pton6(const char *src, unsigned char *dst)
        return 1;
 }
 
-static struct ether_addr *
+static struct rte_ether_addr *
 my_ether_aton(const char *a)
 {
        int i;
        char *end;
        unsigned long o[ETHER_ADDR_LEN];
-       static struct ether_addr ether_addr;
+       static struct rte_ether_addr ether_addr;
 
        i = 0;
        do {
@@ -568,7 +568,7 @@ my_ether_aton(const char *a)
        } else
                return NULL;
 
-       return (struct ether_addr *)&ether_addr;
+       return (struct rte_ether_addr *)&ether_addr;
 }
 
 int
@@ -596,15 +596,15 @@ softnic_parse_ipv6_addr(const char *token, struct in6_addr *ipv6)
 }
 
 int
-softnic_parse_mac_addr(const char *token, struct ether_addr *addr)
+softnic_parse_mac_addr(const char *token, struct rte_ether_addr *addr)
 {
-       struct ether_addr *tmp;
+       struct rte_ether_addr *tmp;
 
        tmp = my_ether_aton(token);
        if (tmp == NULL)
                return -1;
 
-       memcpy(addr, tmp, sizeof(struct ether_addr));
+       memcpy(addr, tmp, sizeof(struct rte_ether_addr));
        return 0;
 }
 
index 1ee3f82..6f408b2 100644 (file)
@@ -49,7 +49,7 @@ int softnic_parse_hex_string(char *src, uint8_t *dst, uint32_t *size);
 
 int softnic_parse_ipv4_addr(const char *token, struct in_addr *ipv4);
 int softnic_parse_ipv6_addr(const char *token, struct in6_addr *ipv6);
-int softnic_parse_mac_addr(const char *token, struct ether_addr *addr);
+int softnic_parse_mac_addr(const char *token, struct rte_ether_addr *addr);
 int softnic_parse_mpls_labels(char *string,
                uint32_t *labels, uint32_t *n_labels);
 
index 0fd264e..cac5a48 100644 (file)
@@ -351,7 +351,7 @@ pmd_free(struct pmd_internals *p)
        rte_free(p);
 }
 
-static struct ether_addr eth_addr = {
+static struct rte_ether_addr eth_addr = {
        .addr_bytes = {0},
 };
 
index 4e5e01c..4857fb5 100644 (file)
@@ -105,7 +105,7 @@ struct szedata2_tx_queue {
 int szedata2_logtype_init;
 int szedata2_logtype_driver;
 
-static struct ether_addr eth_addr = {
+static struct rte_ether_addr eth_addr = {
        .addr_bytes = { 0x00, 0x11, 0x17, 0x00, 0x00, 0x00 }
 };
 
@@ -1332,7 +1332,7 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 static int
 eth_mac_addr_set(struct rte_eth_dev *dev __rte_unused,
-               struct ether_addr *mac_addr __rte_unused)
+               struct rte_ether_addr *mac_addr __rte_unused)
 {
        return 0;
 }
@@ -1514,7 +1514,7 @@ rte_szedata2_eth_dev_init(struct rte_eth_dev *dev, struct port_info *pi)
        eth_link_update(dev, 0);
 
        /* Allocate space for one mac address */
-       data->mac_addrs = rte_zmalloc(data->name, sizeof(struct ether_addr),
+       data->mac_addrs = rte_zmalloc(data->name, sizeof(struct rte_ether_addr),
                        RTE_CACHE_LINE_SIZE);
        if (data->mac_addrs == NULL) {
                PMD_INIT_LOG(ERR, "Could not alloc space for MAC address!");
index 77f2694..473dcdb 100644 (file)
@@ -242,7 +242,7 @@ tap_verify_csum(struct rte_mbuf *mbuf)
        uint32_t l2 = mbuf->packet_type & RTE_PTYPE_L2_MASK;
        uint32_t l3 = mbuf->packet_type & RTE_PTYPE_L3_MASK;
        uint32_t l4 = mbuf->packet_type & RTE_PTYPE_L4_MASK;
-       unsigned int l2_len = sizeof(struct ether_hdr);
+       unsigned int l2_len = sizeof(struct rte_ether_hdr);
        unsigned int l3_len;
        uint16_t cksum = 0;
        void *l3_hdr;
@@ -1100,7 +1100,7 @@ tap_allmulti_disable(struct rte_eth_dev *dev)
 }
 
 static int
-tap_mac_set(struct rte_eth_dev *dev, struct ether_addr *mac_addr)
+tap_mac_set(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr)
 {
        struct pmd_internals *pmd = dev->data->dev_private;
        enum ioctl_mode mode = LOCAL_ONLY;
@@ -1122,14 +1122,14 @@ tap_mac_set(struct rte_eth_dev *dev, struct ether_addr *mac_addr)
        ret = tap_ioctl(pmd, SIOCGIFHWADDR, &ifr, 0, LOCAL_ONLY);
        if (ret < 0)
                return ret;
-       if (is_same_ether_addr((struct ether_addr *)&ifr.ifr_hwaddr.sa_data,
+       if (is_same_ether_addr((struct rte_ether_addr *)&ifr.ifr_hwaddr.sa_data,
                               mac_addr))
                return 0;
        /* Check the current MAC address on the remote */
        ret = tap_ioctl(pmd, SIOCGIFHWADDR, &ifr, 0, REMOTE_ONLY);
        if (ret < 0)
                return ret;
-       if (!is_same_ether_addr((struct ether_addr *)&ifr.ifr_hwaddr.sa_data,
+       if (!is_same_ether_addr((struct rte_ether_addr *)&ifr.ifr_hwaddr.sa_data,
                               mac_addr))
                mode = LOCAL_AND_REMOTE;
        ifr.ifr_hwaddr.sa_family = AF_LOCAL;
@@ -1393,7 +1393,7 @@ tap_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
 
 static int
 tap_set_mc_addr_list(struct rte_eth_dev *dev __rte_unused,
-                    struct ether_addr *mc_addr_set __rte_unused,
+                    struct rte_ether_addr *mc_addr_set __rte_unused,
                     uint32_t nb_mc_addr __rte_unused)
 {
        /*
@@ -1613,7 +1613,7 @@ static const struct eth_dev_ops ops = {
 
 static int
 eth_dev_tap_create(struct rte_vdev_device *vdev, char *tap_name,
-                  char *remote_iface, struct ether_addr *mac_addr,
+                  char *remote_iface, struct rte_ether_addr *mac_addr,
                   enum rte_tuntap_type type)
 {
        int numa_node = rte_socket_id();
@@ -1846,7 +1846,7 @@ set_remote_iface(const char *key __rte_unused,
        return 0;
 }
 
-static int parse_user_mac(struct ether_addr *user_mac,
+static int parse_user_mac(struct rte_ether_addr *user_mac,
                const char *value)
 {
        unsigned int index = 0;
@@ -1874,7 +1874,7 @@ set_mac_type(const char *key __rte_unused,
             const char *value,
             void *extra_args)
 {
-       struct ether_addr *user_mac = extra_args;
+       struct rte_ether_addr *user_mac = extra_args;
 
        if (!value)
                return 0;
@@ -1984,7 +1984,7 @@ rte_pmd_tap_probe(struct rte_vdev_device *dev)
        int speed;
        char tap_name[RTE_ETH_NAME_MAX_LEN];
        char remote_iface[RTE_ETH_NAME_MAX_LEN];
-       struct ether_addr user_mac = { .addr_bytes = {0} };
+       struct rte_ether_addr user_mac = { .addr_bytes = {0} };
        struct rte_eth_dev *eth_dev;
 
        strcpy(tuntap_name, "TAP");
index 44e2773..db42fa5 100644 (file)
@@ -69,7 +69,7 @@ struct pmd_internals {
        char remote_iface[RTE_ETH_NAME_MAX_LEN]; /* Remote netdevice name */
        char name[RTE_ETH_NAME_MAX_LEN];  /* Internal Tap device name */
        int type;                         /* Type field - TUN|TAP */
-       struct ether_addr eth_addr;       /* Mac address of the device port */
+       struct rte_ether_addr eth_addr;       /* Mac address of the device port */
        struct ifreq remote_initial_flags;   /* Remote netdevice flags on init */
        int remote_if_index;              /* remote netdevice IF_INDEX */
        int if_index;                     /* IF_INDEX for the port */
index 1cb7382..db3ed87 100644 (file)
@@ -37,7 +37,7 @@
 #define KEY_IDX                        0
 #define BPF_MAP_ID_KEY 1
 
-struct vlan_hdr {
+struct rte_vlan_hdr {
        __be16 proto;
        __be16 tci;
 };
@@ -141,12 +141,12 @@ rss_l3_l4(struct __sk_buff *skb)
 
        /* Get correct proto for 802.1ad */
        if (skb->vlan_present && skb->vlan_proto == htons(ETH_P_8021AD)) {
-               if (data + ETH_ALEN * 2 + sizeof(struct vlan_hdr) +
+               if (data + ETH_ALEN * 2 + sizeof(struct rte_vlan_hdr) +
                    sizeof(proto) > data_end)
                        return TC_ACT_OK;
                proto = *(__u16 *)(data + ETH_ALEN * 2 +
-                                  sizeof(struct vlan_hdr));
-               off += sizeof(struct vlan_hdr);
+                                  sizeof(struct rte_vlan_hdr));
+               off += sizeof(struct rte_vlan_hdr);
        }
 
        if (proto == htons(ETH_P_IP)) {
index 8f83d41..2a793a4 100644 (file)
@@ -135,8 +135,8 @@ nicvf_handle_mbx_intr(struct nicvf *nic)
                nic->node = mbx.nic_cfg.node_id;
                nic->sqs_mode = mbx.nic_cfg.sqs_mode;
                nic->loopback_supported = mbx.nic_cfg.loopback_supported;
-               ether_addr_copy((struct ether_addr *)mbx.nic_cfg.mac_addr,
-                               (struct ether_addr *)nic->mac_addr);
+               ether_addr_copy((struct rte_ether_addr *)mbx.nic_cfg.mac_addr,
+                               (struct rte_ether_addr *)nic->mac_addr);
                nic->pf_acked = true;
                break;
        case NIC_MBOX_MSG_ACK:
index 879d889..ec20879 100644 (file)
@@ -2179,10 +2179,10 @@ nicvf_eth_dev_init(struct rte_eth_dev *eth_dev)
                ret = -ENOMEM;
                goto alarm_fail;
        }
-       if (is_zero_ether_addr((struct ether_addr *)nic->mac_addr))
+       if (is_zero_ether_addr((struct rte_ether_addr *)nic->mac_addr))
                eth_random_addr(&nic->mac_addr[0]);
 
-       ether_addr_copy((struct ether_addr *)nic->mac_addr,
+       ether_addr_copy((struct rte_ether_addr *)nic->mac_addr,
                        &eth_dev->data->mac_addrs[0]);
 
        ret = nicvf_mbox_set_mac_addr(nic, nic->mac_addr);
index 16303ef..3124c1a 100644 (file)
@@ -68,7 +68,7 @@ struct vdev_netvsc_ctx {
        char devargs[256];                 /**< Fail-safe device arguments. */
        char if_name[IF_NAMESIZE];         /**< NetVSC netdevice name. */
        unsigned int if_index;             /**< NetVSC netdevice index. */
-       struct ether_addr if_addr;         /**< NetVSC MAC address. */
+       struct rte_ether_addr if_addr;     /**< NetVSC MAC address. */
        int pipe[2];                       /**< Fail-safe communication pipe. */
        char yield[256];                   /**< PCI sub-device arguments. */
 };
@@ -157,7 +157,7 @@ vdev_netvsc_iface_is_netvsc(const struct if_nameindex *iface)
  */
 static int
 vdev_netvsc_foreach_iface(int (*func)(const struct if_nameindex *iface,
-                                     const struct ether_addr *eth_addr,
+                                     const struct rte_ether_addr *eth_addr,
                                      va_list ap), int is_netvsc, ...)
 {
        struct if_nameindex *iface = if_nameindex();
@@ -178,7 +178,7 @@ vdev_netvsc_foreach_iface(int (*func)(const struct if_nameindex *iface,
        for (i = 0; iface[i].if_name; ++i) {
                int is_netvsc_ret;
                struct ifreq req;
-               struct ether_addr eth_addr;
+               struct rte_ether_addr eth_addr;
                va_list ap;
 
                is_netvsc_ret = vdev_netvsc_iface_is_netvsc(&iface[i]) ? 1 : 0;
@@ -371,7 +371,7 @@ vdev_netvsc_sysfs_readlink(char *buf, size_t size, const char *if_name,
  */
 static int
 vdev_netvsc_device_probe(const struct if_nameindex *iface,
-                   const struct ether_addr *eth_addr,
+                   const struct rte_ether_addr *eth_addr,
                    va_list ap)
 {
        struct vdev_netvsc_ctx *ctx = va_arg(ap, struct vdev_netvsc_ctx *);
@@ -510,7 +510,7 @@ vdev_netvsc_alarm(__rte_unused void *arg)
  */
 static int
 vdev_netvsc_netvsc_probe(const struct if_nameindex *iface,
-                        const struct ether_addr *eth_addr,
+                        const struct rte_ether_addr *eth_addr,
                         va_list ap)
 {
        const char *name = va_arg(ap, const char *);
@@ -530,7 +530,7 @@ vdev_netvsc_netvsc_probe(const struct if_nameindex *iface,
                                if (!strcmp(pair->value, iface->if_name))
                                        break;
                        } else if (!strcmp(pair->key, VDEV_NETVSC_ARG_MAC)) {
-                               struct ether_addr tmp;
+                               struct rte_ether_addr tmp;
 
                                if (sscanf(pair->value,
                                           "%" SCNx8 ":%" SCNx8 ":%" SCNx8 ":"
index 55e51c8..4c8d0ca 100644 (file)
@@ -43,7 +43,7 @@ static const char *valid_arguments[] = {
        NULL
 };
 
-static struct ether_addr base_eth_addr = {
+static struct rte_ether_addr base_eth_addr = {
        .addr_bytes = {
                0x56 /* V */,
                0x48 /* H */,
@@ -325,10 +325,10 @@ static inline void
 vhost_count_multicast_broadcast(struct vhost_queue *vq,
                                struct rte_mbuf *mbuf)
 {
-       struct ether_addr *ea = NULL;
+       struct rte_ether_addr *ea = NULL;
        struct vhost_stats *pstats = &vq->stats;
 
-       ea = rte_pktmbuf_mtod(mbuf, struct ether_addr *);
+       ea = rte_pktmbuf_mtod(mbuf, struct rte_ether_addr *);
        if (is_multicast_ether_addr(ea)) {
                if (is_broadcast_ether_addr(ea))
                        pstats->xstats[VHOST_BROADCAST_PKT]++;
@@ -1207,7 +1207,7 @@ eth_dev_vhost_create(struct rte_vdev_device *dev, char *iface_name,
        struct rte_eth_dev_data *data;
        struct pmd_internal *internal = NULL;
        struct rte_eth_dev *eth_dev = NULL;
-       struct ether_addr *eth_addr = NULL;
+       struct rte_ether_addr *eth_addr = NULL;
        struct rte_vhost_vring_state *vring_state = NULL;
        struct internal_list *list = NULL;
 
index 730c417..645b03c 100644 (file)
@@ -65,11 +65,11 @@ static void virtio_dev_free_mbufs(struct rte_eth_dev *dev);
 static int virtio_vlan_filter_set(struct rte_eth_dev *dev,
                                uint16_t vlan_id, int on);
 static int virtio_mac_addr_add(struct rte_eth_dev *dev,
-                               struct ether_addr *mac_addr,
+                               struct rte_ether_addr *mac_addr,
                                uint32_t index, uint32_t vmdq);
 static void virtio_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index);
 static int virtio_mac_addr_set(struct rte_eth_dev *dev,
-                               struct ether_addr *mac_addr);
+                               struct rte_ether_addr *mac_addr);
 
 static int virtio_intr_enable(struct rte_eth_dev *dev);
 static int virtio_intr_disable(struct rte_eth_dev *dev);
@@ -996,11 +996,11 @@ virtio_mac_table_set(struct virtio_hw *hw,
 }
 
 static int
-virtio_mac_addr_add(struct rte_eth_dev *dev, struct ether_addr *mac_addr,
+virtio_mac_addr_add(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
                    uint32_t index, uint32_t vmdq __rte_unused)
 {
        struct virtio_hw *hw = dev->data->dev_private;
-       const struct ether_addr *addrs = dev->data->mac_addrs;
+       const struct rte_ether_addr *addrs = dev->data->mac_addrs;
        unsigned int i;
        struct virtio_net_ctrl_mac *uc, *mc;
 
@@ -1015,7 +1015,7 @@ virtio_mac_addr_add(struct rte_eth_dev *dev, struct ether_addr *mac_addr,
        mc->entries = 0;
 
        for (i = 0; i < VIRTIO_MAX_MAC_ADDRS; i++) {
-               const struct ether_addr *addr
+               const struct rte_ether_addr *addr
                        = (i == index) ? mac_addr : addrs + i;
                struct virtio_net_ctrl_mac *tbl
                        = is_multicast_ether_addr(addr) ? mc : uc;
@@ -1030,7 +1030,7 @@ static void
 virtio_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index)
 {
        struct virtio_hw *hw = dev->data->dev_private;
-       struct ether_addr *addrs = dev->data->mac_addrs;
+       struct rte_ether_addr *addrs = dev->data->mac_addrs;
        struct virtio_net_ctrl_mac *uc, *mc;
        unsigned int i;
 
@@ -1058,7 +1058,7 @@ virtio_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index)
 }
 
 static int
-virtio_mac_addr_set(struct rte_eth_dev *dev, struct ether_addr *mac_addr)
+virtio_mac_addr_set(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr)
 {
        struct virtio_hw *hw = dev->data->dev_private;
 
@@ -1249,7 +1249,7 @@ virtio_notify_peers(struct rte_eth_dev *dev)
                return;
 
        rarp_mbuf = rte_net_make_rarp_packet(rxvq->mpool,
-                       (struct ether_addr *)hw->mac_addr);
+                       (struct rte_ether_addr *)hw->mac_addr);
        if (rarp_mbuf == NULL) {
                PMD_DRV_LOG(ERR, "failed to make RARP packet.");
                return;
@@ -1483,7 +1483,7 @@ virtio_init_device(struct rte_eth_dev *eth_dev, uint64_t req_features)
 
        /* Copy the permanent MAC address to: virtio_hw */
        virtio_get_hwaddr(hw);
-       ether_addr_copy((struct ether_addr *) hw->mac_addr,
+       ether_addr_copy((struct rte_ether_addr *) hw->mac_addr,
                        &eth_dev->data->mac_addrs[0]);
        PMD_INIT_LOG(DEBUG,
                     "PORT MAC: %02X:%02X:%02X:%02X:%02X:%02X",
index eb89143..ef8936a 100644 (file)
@@ -773,7 +773,7 @@ static void
 virtio_update_packet_stats(struct virtnet_stats *stats, struct rte_mbuf *mbuf)
 {
        uint32_t s = mbuf->pkt_len;
-       struct ether_addr *ea;
+       struct rte_ether_addr *ea;
 
        if (s == 64) {
                stats->size_bins[1]++;
@@ -792,7 +792,7 @@ virtio_update_packet_stats(struct virtnet_stats *stats, struct rte_mbuf *mbuf)
                        stats->size_bins[7]++;
        }
 
-       ea = rte_pktmbuf_mtod(mbuf, struct ether_addr *);
+       ea = rte_pktmbuf_mtod(mbuf, struct rte_ether_addr *);
        if (is_multicast_ether_addr(ea)) {
                if (is_broadcast_ether_addr(ea))
                        stats->broadcast++;
index 78e5b76..b1cbeef 100644 (file)
@@ -91,7 +91,7 @@ static int vmxnet3_dev_vlan_filter_set(struct rte_eth_dev *dev,
                                       uint16_t vid, int on);
 static int vmxnet3_dev_vlan_offload_set(struct rte_eth_dev *dev, int mask);
 static int vmxnet3_mac_addr_set(struct rte_eth_dev *dev,
-                                struct ether_addr *mac_addr);
+                                struct rte_ether_addr *mac_addr);
 static void vmxnet3_interrupt_handler(void *param);
 
 int vmxnet3_logtype_init;
@@ -311,7 +311,7 @@ eth_vmxnet3_dev_init(struct rte_eth_dev *eth_dev)
                return -ENOMEM;
        }
        /* Copy the permanent MAC address */
-       ether_addr_copy((struct ether_addr *) hw->perm_addr,
+       ether_addr_copy((struct rte_ether_addr *) hw->perm_addr,
                        &eth_dev->data->mac_addrs[0]);
 
        PMD_INIT_LOG(DEBUG, "MAC Address : %02x:%02x:%02x:%02x:%02x:%02x",
@@ -1162,11 +1162,11 @@ vmxnet3_dev_supported_ptypes_get(struct rte_eth_dev *dev)
 }
 
 static int
-vmxnet3_mac_addr_set(struct rte_eth_dev *dev, struct ether_addr *mac_addr)
+vmxnet3_mac_addr_set(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr)
 {
        struct vmxnet3_hw *hw = dev->data->dev_private;
 
-       ether_addr_copy(mac_addr, (struct ether_addr *)(hw->perm_addr));
+       ether_addr_copy(mac_addr, (struct rte_ether_addr *)(hw->perm_addr));
        vmxnet3_write_mac(hw, mac_addr->addr_bytes);
        return 0;
 }
index cf85f3d..ca3b1ef 100644 (file)
@@ -674,7 +674,7 @@ vmxnet3_guess_mss(struct vmxnet3_hw *hw, const Vmxnet3_RxCompDesc *rcd,
 
        ptr = rte_pktmbuf_mtod(rxm, char *);
        slen = rte_pktmbuf_data_len(rxm);
-       hlen = sizeof(struct ether_hdr);
+       hlen = sizeof(struct rte_ether_hdr);
 
        if (rcd->v4) {
                if (unlikely(slen < hlen + sizeof(struct ipv4_hdr)))
@@ -701,7 +701,7 @@ vmxnet3_guess_mss(struct vmxnet3_hw *hw, const Vmxnet3_RxCompDesc *rcd,
 
        if (unlikely(slen < hlen + sizeof(struct tcp_hdr)))
                return hw->mtu - hlen - sizeof(struct tcp_hdr) +
-                               sizeof(struct ether_hdr);
+                               sizeof(struct rte_ether_hdr);
 
        tcp_hdr = (struct tcp_hdr *)(ptr + hlen);
        hlen += (tcp_hdr->data_off & 0xf0) >> 2;
@@ -710,7 +710,7 @@ vmxnet3_guess_mss(struct vmxnet3_hw *hw, const Vmxnet3_RxCompDesc *rcd,
                return (rte_pktmbuf_pkt_len(rxm) - hlen +
                                rxm->udata64 - 1) / rxm->udata64;
        else
-               return hw->mtu - hlen + sizeof(struct ether_hdr);
+               return hw->mtu - hlen + sizeof(struct rte_ether_hdr);
 }
 
 /* Receive side checksum and other offloads */
index d68c06a..9fa4929 100644 (file)
@@ -273,7 +273,7 @@ signal_handler(int signum)
 }
 
 static void
-print_mac(unsigned int portid, struct ether_addr *bbdev_ports_eth_address)
+print_mac(unsigned int portid, struct rte_ether_addr *bbdev_ports_eth_address)
 {
        printf("Port %u, MAC address: %02X:%02X:%02X:%02X:%02X:%02X\n\n",
                        (unsigned int) portid,
@@ -341,14 +341,14 @@ check_port_link_status(uint16_t port_id)
 static inline void
 add_ether_hdr(struct rte_mbuf *pkt_src, struct rte_mbuf *pkt_dst)
 {
-       struct ether_hdr *eth_from;
-       struct ether_hdr *eth_to;
+       struct rte_ether_hdr *eth_from;
+       struct rte_ether_hdr *eth_to;
 
-       eth_from = rte_pktmbuf_mtod(pkt_src, struct ether_hdr *);
-       eth_to = rte_pktmbuf_mtod(pkt_dst, struct ether_hdr *);
+       eth_from = rte_pktmbuf_mtod(pkt_src, struct rte_ether_hdr *);
+       eth_to = rte_pktmbuf_mtod(pkt_dst, struct rte_ether_hdr *);
 
        /* copy header */
-       rte_memcpy(eth_to, eth_from, sizeof(struct ether_hdr));
+       rte_memcpy(eth_to, eth_from, sizeof(struct rte_ether_hdr));
 }
 
 static inline void
@@ -377,7 +377,7 @@ transform_enc_out_dec_in(struct rte_mbuf **mbufs, uint8_t *temp_buf,
 
        for (i = 0; i < num_pkts; ++i) {
                uint16_t pkt_data_len = rte_pktmbuf_data_len(mbufs[i]) -
-                               sizeof(struct ether_hdr);
+                               sizeof(struct rte_ether_hdr);
 
                /* Resize the packet if needed */
                if (pkt_data_len < ncb) {
@@ -395,7 +395,7 @@ transform_enc_out_dec_in(struct rte_mbuf **mbufs, uint8_t *temp_buf,
                        for (l = start_bit_idx; l < start_bit_idx + d; ++l) {
                                uint8_t *data = rte_pktmbuf_mtod_offset(
                                        mbufs[i], uint8_t *,
-                                       sizeof(struct ether_hdr) + (l >> 3));
+                                       sizeof(struct rte_ether_hdr) + (l >> 3));
                                if (*data & (0x80 >> (l & 7)))
                                        temp_buf[out_idx] = LLR_1_BIT;
                                else
@@ -410,7 +410,7 @@ transform_enc_out_dec_in(struct rte_mbuf **mbufs, uint8_t *temp_buf,
                }
 
                rte_memcpy(rte_pktmbuf_mtod_offset(mbufs[i], uint8_t *,
-                               sizeof(struct ether_hdr)), temp_buf, ncb);
+                               sizeof(struct rte_ether_hdr)), temp_buf, ncb);
        }
 }
 
@@ -423,9 +423,9 @@ verify_data(struct rte_mbuf **mbufs, uint16_t num_pkts)
                struct rte_mbuf *in = out->userdata;
 
                if (memcmp(rte_pktmbuf_mtod_offset(in, uint8_t *,
-                               sizeof(struct ether_hdr)),
+                               sizeof(struct rte_ether_hdr)),
                                rte_pktmbuf_mtod_offset(out, uint8_t *,
-                               sizeof(struct ether_hdr)),
+                               sizeof(struct rte_ether_hdr)),
                                K / 8 - CRC_24B_LEN))
                        printf("Input and output buffers are not equal!\n");
        }
@@ -439,7 +439,7 @@ initialize_ports(struct app_config_params *app_params,
        uint16_t port_id = app_params->port_id;
        uint16_t q;
        /* ethernet addresses of ports */
-       struct ether_addr bbdev_port_eth_addr;
+       struct rte_ether_addr bbdev_port_eth_addr;
 
        /* initialize ports */
        printf("\nInitializing port %u...\n", app_params->port_id);
@@ -707,14 +707,14 @@ run_encoding(struct lcore_conf *lcore_conf)
                char *data;
                const uint16_t pkt_data_len =
                                rte_pktmbuf_data_len(rx_pkts_burst[i]) -
-                               sizeof(struct ether_hdr);
+                               sizeof(struct rte_ether_hdr);
                /* save input mbuf pointer for later comparison */
                enc_out_pkts[i]->userdata = rx_pkts_burst[i];
 
                /* copy ethernet header */
                rte_pktmbuf_reset(enc_out_pkts[i]);
                data = rte_pktmbuf_append(enc_out_pkts[i],
-                               sizeof(struct ether_hdr));
+                               sizeof(struct rte_ether_hdr));
                if (data == NULL) {
                        printf(
                                "Not enough space for ethernet header in encoder output mbuf\n");
@@ -728,7 +728,7 @@ run_encoding(struct lcore_conf *lcore_conf)
                bbdev_ops_burst[i]->turbo_enc.input.data =
                                rx_pkts_burst[i];
                bbdev_ops_burst[i]->turbo_enc.input.offset =
-                               sizeof(struct ether_hdr);
+                               sizeof(struct rte_ether_hdr);
                /* Encoder will attach the CRC24B, adjust the length */
                bbdev_ops_burst[i]->turbo_enc.input.length = in_data_len;
 
@@ -746,7 +746,7 @@ run_encoding(struct lcore_conf *lcore_conf)
                bbdev_ops_burst[i]->turbo_enc.output.data =
                                enc_out_pkts[i];
                bbdev_ops_burst[i]->turbo_enc.output.offset =
-                               sizeof(struct ether_hdr);
+                               sizeof(struct rte_ether_hdr);
        }
 
        /* Enqueue packets on BBDevice */
@@ -834,15 +834,15 @@ run_decoding(struct lcore_conf *lcore_conf)
 
                bbdev_ops_burst[i]->turbo_dec.input.data = recv_pkts_burst[i];
                bbdev_ops_burst[i]->turbo_dec.input.offset =
-                               sizeof(struct ether_hdr);
+                               sizeof(struct rte_ether_hdr);
                bbdev_ops_burst[i]->turbo_dec.input.length =
                                rte_pktmbuf_data_len(recv_pkts_burst[i])
-                               - sizeof(struct ether_hdr);
+                               - sizeof(struct rte_ether_hdr);
 
                bbdev_ops_burst[i]->turbo_dec.hard_output.data =
                                recv_pkts_burst[i];
                bbdev_ops_burst[i]->turbo_dec.hard_output.offset =
-                               sizeof(struct ether_hdr);
+                               sizeof(struct rte_ether_hdr);
        }
 
        /* Enqueue packets on BBDevice */
index 2fe5a93..fe17936 100644 (file)
@@ -201,7 +201,7 @@ slave_port_init(uint16_t portid, struct rte_mempool *mbuf_pool)
                                "Start port %d failed (res=%d)",
                                portid, retval);
 
-       struct ether_addr addr;
+       struct rte_ether_addr addr;
 
        rte_eth_macaddr_get(portid, &addr);
        printf("Port %u MAC: ", portid);
@@ -276,7 +276,7 @@ bond_port_init(struct rte_mempool *mbuf_pool)
 
        rte_eth_promiscuous_enable(BOND_PORT);
 
-       struct ether_addr addr;
+       struct rte_ether_addr addr;
 
        rte_eth_macaddr_get(BOND_PORT, &addr);
        printf("Port %u MAC: ", (unsigned)BOND_PORT);
@@ -285,21 +285,21 @@ bond_port_init(struct rte_mempool *mbuf_pool)
 }
 
 static inline size_t
-get_vlan_offset(struct ether_hdr *eth_hdr, uint16_t *proto)
+get_vlan_offset(struct rte_ether_hdr *eth_hdr, uint16_t *proto)
 {
        size_t vlan_offset = 0;
 
        if (rte_cpu_to_be_16(ETHER_TYPE_VLAN) == *proto) {
-               struct vlan_hdr *vlan_hdr = (struct vlan_hdr *)(eth_hdr + 1);
+               struct rte_vlan_hdr *vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
 
-               vlan_offset = sizeof(struct vlan_hdr);
+               vlan_offset = sizeof(struct rte_vlan_hdr);
                *proto = vlan_hdr->eth_proto;
 
                if (rte_cpu_to_be_16(ETHER_TYPE_VLAN) == *proto) {
                        vlan_hdr = vlan_hdr + 1;
 
                        *proto = vlan_hdr->eth_proto;
-                       vlan_offset += sizeof(struct vlan_hdr);
+                       vlan_offset += sizeof(struct rte_vlan_hdr);
                }
        }
        return vlan_offset;
@@ -321,9 +321,9 @@ struct global_flag_stru_t *global_flag_stru_p = &global_flag_stru;
 static int lcore_main(__attribute__((unused)) void *arg1)
 {
        struct rte_mbuf *pkts[MAX_PKT_BURST] __rte_cache_aligned;
-       struct ether_addr d_addr;
+       struct rte_ether_addr d_addr;
 
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        struct rte_arp_hdr *arp_hdr;
        struct ipv4_hdr *ipv4_hdr;
        uint16_t ether_type, offset;
@@ -355,7 +355,7 @@ static int lcore_main(__attribute__((unused)) void *arg1)
                                global_flag_stru_p->port_packets[0]++;
                                rte_spinlock_unlock(&global_flag_stru_p->lock);
                        }
-                       eth_hdr = rte_pktmbuf_mtod(pkts[i], struct ether_hdr *);
+                       eth_hdr = rte_pktmbuf_mtod(pkts[i], struct rte_ether_hdr *);
                        ether_type = eth_hdr->ether_type;
                        if (ether_type == rte_cpu_to_be_16(ETHER_TYPE_VLAN))
                                printf("VLAN taged frame, offset:");
@@ -434,7 +434,7 @@ static void cmd_obj_send_parsed(void *parsed_result,
        char ip_str[INET6_ADDRSTRLEN];
 
        struct rte_mbuf *created_pkt;
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        struct rte_arp_hdr *arp_hdr;
 
        uint32_t bond_ip;
@@ -454,16 +454,16 @@ static void cmd_obj_send_parsed(void *parsed_result,
                return;
        }
 
-       pkt_size = sizeof(struct ether_hdr) + sizeof(struct rte_arp_hdr);
+       pkt_size = sizeof(struct rte_ether_hdr) + sizeof(struct rte_arp_hdr);
        created_pkt->data_len = pkt_size;
        created_pkt->pkt_len = pkt_size;
 
-       eth_hdr = rte_pktmbuf_mtod(created_pkt, struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(created_pkt, struct rte_ether_hdr *);
        rte_eth_macaddr_get(BOND_PORT, &eth_hdr->s_addr);
        memset(&eth_hdr->d_addr, 0xFF, ETHER_ADDR_LEN);
        eth_hdr->ether_type = rte_cpu_to_be_16(ETHER_TYPE_ARP);
 
-       arp_hdr = (struct rte_arp_hdr *)((char *)eth_hdr + sizeof(struct ether_hdr));
+       arp_hdr = (struct rte_arp_hdr *)((char *)eth_hdr + sizeof(struct rte_ether_hdr));
        arp_hdr->arp_hardware = rte_cpu_to_be_16(RTE_ARP_HRD_ETHER);
        arp_hdr->arp_protocol = rte_cpu_to_be_16(ETHER_TYPE_IPv4);
        arp_hdr->arp_hlen = ETHER_ADDR_LEN;
@@ -683,7 +683,7 @@ static void cmd_show_parsed(__attribute__((unused)) void *parsed_result,
 {
        uint16_t slaves[16] = {0};
        uint8_t len = 16;
-       struct ether_addr addr;
+       struct rte_ether_addr addr;
        uint16_t i = 0;
 
        while (i < slaves_count)        {
index 03a05e3..5a2bbec 100644 (file)
@@ -177,7 +177,7 @@ port_init(uint16_t port, struct rte_mempool *mbuf_pool)
                return 0;
        }
 
-       struct ether_addr addr;
+       struct rte_ether_addr addr;
        rte_eth_macaddr_get(port, &addr);
        printf("Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8
                        " %02"PRIx8" %02"PRIx8" %02"PRIx8"\n",
index a4e64b3..ce7f715 100644 (file)
@@ -30,7 +30,7 @@ struct pcmd_intstr_params {
 struct pcmd_intmac_params {
        cmdline_fixed_string_t cmd;
        uint16_t port;
-       struct ether_addr mac;
+       struct rte_ether_addr mac;
 };
 struct pcmd_str_params {
        cmdline_fixed_string_t cmd;
@@ -475,7 +475,7 @@ pcmd_macaddr_callback(void *ptr_params,
        void *ptr_data)
 {
        struct pcmd_intmac_params *params = ptr_params;
-       struct ether_addr mac_addr;
+       struct rte_ether_addr mac_addr;
        int stat;
 
        stat = 0;
index dc93adf..ae61e73 100644 (file)
@@ -32,7 +32,7 @@ struct txq_port {
 };
 
 struct app_port {
-       struct ether_addr mac_addr;
+       struct rte_ether_addr mac_addr;
        struct txq_port txq;
        rte_spinlock_t lock;
        int port_active;
@@ -160,9 +160,9 @@ static void setup_ports(struct app_config *app_cfg, int cnt_ports)
 static void process_frame(struct app_port *ptr_port,
        struct rte_mbuf *ptr_frame)
 {
-       struct ether_hdr *ptr_mac_hdr;
+       struct rte_ether_hdr *ptr_mac_hdr;
 
-       ptr_mac_hdr = rte_pktmbuf_mtod(ptr_frame, struct ether_hdr *);
+       ptr_mac_hdr = rte_pktmbuf_mtod(ptr_frame, struct rte_ether_hdr *);
        ether_addr_copy(&ptr_mac_hdr->s_addr, &ptr_mac_hdr->d_addr);
        ether_addr_copy(&ptr_port->mac_addr, &ptr_mac_hdr->s_addr);
 }
index e6a2e88..35984cf 100644 (file)
@@ -303,7 +303,7 @@ rte_ethtool_net_stop(uint16_t port_id)
 }
 
 int
-rte_ethtool_net_get_mac_addr(uint16_t port_id, struct ether_addr *addr)
+rte_ethtool_net_get_mac_addr(uint16_t port_id, struct rte_ether_addr *addr)
 {
        RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
        if (addr == NULL)
@@ -314,7 +314,7 @@ rte_ethtool_net_get_mac_addr(uint16_t port_id, struct ether_addr *addr)
 }
 
 int
-rte_ethtool_net_set_mac_addr(uint16_t port_id, struct ether_addr *addr)
+rte_ethtool_net_set_mac_addr(uint16_t port_id, struct rte_ether_addr *addr)
 {
        if (addr == NULL)
                return -EINVAL;
@@ -323,7 +323,7 @@ rte_ethtool_net_set_mac_addr(uint16_t port_id, struct ether_addr *addr)
 
 int
 rte_ethtool_net_validate_addr(uint16_t port_id __rte_unused,
-       struct ether_addr *addr)
+       struct rte_ether_addr *addr)
 {
        if (addr == NULL)
                return -EINVAL;
index 43adc97..da61430 100644 (file)
@@ -260,7 +260,7 @@ int rte_ethtool_net_stop(uint16_t port_id);
  *   - (0) if successful.
  *   - (-ENODEV) if *port_id* invalid.
  */
-int rte_ethtool_net_get_mac_addr(uint16_t port_id, struct ether_addr *addr);
+int rte_ethtool_net_get_mac_addr(uint16_t port_id, struct rte_ether_addr *addr);
 
 /**
  * Setting the Ethernet device MAC address.
@@ -276,7 +276,7 @@ int rte_ethtool_net_get_mac_addr(uint16_t port_id, struct ether_addr *addr);
  *   - (-EINVAL) if parameters invalid.
  *   - others depends on the specific operations implementation.
  */
-int rte_ethtool_net_set_mac_addr(uint16_t port_id, struct ether_addr *addr);
+int rte_ethtool_net_set_mac_addr(uint16_t port_id, struct rte_ether_addr *addr);
 
 /**
  * Validate if the provided MAC address is valid unicast address
@@ -292,7 +292,7 @@ int rte_ethtool_net_set_mac_addr(uint16_t port_id, struct ether_addr *addr);
  *   - (-EINVAL) if parameters invalid.
  *   - others depends on the specific operations implementation.
  */
-int rte_ethtool_net_validate_addr(uint16_t port_id, struct ether_addr *addr);
+int rte_ethtool_net_validate_addr(uint16_t port_id, struct rte_ether_addr *addr);
 
 /**
  * Setting the Ethernet device maximum Tx unit.
index 92e08bc..ee65b3e 100644 (file)
@@ -322,7 +322,7 @@ port_init(uint8_t port, struct rte_mempool *mbuf_pool)
                return retval;
 
        /* Display the port MAC address. */
-       struct ether_addr addr;
+       struct rte_ether_addr addr;
        rte_eth_macaddr_get(port, &addr);
        printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8
                           " %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\n",
index a6cc912..ef23d96 100644 (file)
@@ -99,11 +99,11 @@ struct config_data cdata;
 static __rte_always_inline void
 exchange_mac(struct rte_mbuf *m)
 {
-       struct ether_hdr *eth;
-       struct ether_addr addr;
+       struct rte_ether_hdr *eth;
+       struct rte_ether_addr addr;
 
        /* change mac addresses on packet (to use mbuf data) */
-       eth = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
        ether_addr_copy(&eth->d_addr, &addr);
        ether_addr_copy(&addr, &eth->d_addr);
 }
index 1996129..5ae81fa 100644 (file)
@@ -98,7 +98,7 @@ static struct rte_acl_field_def ipv4_defs[NUM_FIELDS_IPV4] = {
                .size = sizeof(uint8_t),
                .field_index = PROTO_FIELD_IPV4,
                .input_index = PROTO_INPUT_IPV4,
-               .offset = sizeof(struct ether_hdr) +
+               .offset = sizeof(struct rte_ether_hdr) +
                        offsetof(struct ipv4_hdr, next_proto_id),
        },
        /* next input field (IPv4 source address) - 4 consecutive bytes. */
@@ -108,7 +108,7 @@ static struct rte_acl_field_def ipv4_defs[NUM_FIELDS_IPV4] = {
                .size = sizeof(uint32_t),
                .field_index = SRC_FIELD_IPV4,
                .input_index = SRC_INPUT_IPV4,
-               .offset = sizeof(struct ether_hdr) +
+               .offset = sizeof(struct rte_ether_hdr) +
                        offsetof(struct ipv4_hdr, src_addr),
        },
        /* next input field (IPv4 destination address) - 4 consecutive bytes. */
@@ -118,7 +118,7 @@ static struct rte_acl_field_def ipv4_defs[NUM_FIELDS_IPV4] = {
                .size = sizeof(uint32_t),
                .field_index = DST_FIELD_IPV4,
                .input_index = DST_INPUT_IPV4,
-               .offset = sizeof(struct ether_hdr) +
+               .offset = sizeof(struct rte_ether_hdr) +
                        offsetof(struct ipv4_hdr, dst_addr),
        },
        /*
@@ -131,7 +131,7 @@ static struct rte_acl_field_def ipv4_defs[NUM_FIELDS_IPV4] = {
                .size = sizeof(uint16_t),
                .field_index = SRCP_FIELD_IPV4,
                .input_index = SRCP_DESTP_INPUT_IPV4,
-               .offset = sizeof(struct ether_hdr) +
+               .offset = sizeof(struct rte_ether_hdr) +
                        sizeof(struct ipv4_hdr) +
                        offsetof(struct tcp_hdr, src_port),
        },
@@ -141,7 +141,7 @@ static struct rte_acl_field_def ipv4_defs[NUM_FIELDS_IPV4] = {
                .size = sizeof(uint16_t),
                .field_index = DSTP_FIELD_IPV4,
                .input_index = SRCP_DESTP_INPUT_IPV4,
-               .offset = sizeof(struct ether_hdr) +
+               .offset = sizeof(struct rte_ether_hdr) +
                        sizeof(struct ipv4_hdr) +
                        offsetof(struct tcp_hdr, dst_port),
        },
@@ -192,7 +192,7 @@ static inline int
 port_init(uint8_t port, struct rte_mempool *mbuf_pool)
 {
        struct rte_eth_conf port_conf = port_conf_default;
-       struct ether_addr addr;
+       struct rte_ether_addr addr;
        const uint16_t rx_rings = 1, tx_rings = 1;
        int retval;
        uint16_t q;
index a73d120..dad8bcc 100644 (file)
@@ -45,7 +45,7 @@ struct rte_flow *flow;
 #include "flow_blocks.c"
 
 static inline void
-print_ether_addr(const char *what, struct ether_addr *eth_addr)
+print_ether_addr(const char *what, struct rte_ether_addr *eth_addr)
 {
        char buf[ETHER_ADDR_FMT_SIZE];
        ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr);
@@ -56,7 +56,7 @@ static void
 main_loop(void)
 {
        struct rte_mbuf *mbufs[32];
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        struct rte_flow_error error;
        uint16_t nb_rx;
        uint16_t i;
@@ -71,7 +71,7 @@ main_loop(void)
                                        struct rte_mbuf *m = mbufs[j];
 
                                        eth_hdr = rte_pktmbuf_mtod(m,
-                                                       struct ether_hdr *);
+                                                       struct rte_ether_hdr *);
                                        print_ether_addr("src=",
                                                        &eth_hdr->s_addr);
                                        print_ether_addr(" - dst=",
index 17a877d..ccde72c 100644 (file)
@@ -83,7 +83,7 @@ static uint16_t nb_rxd = RTE_TEST_RX_DESC_DEFAULT;
 static uint16_t nb_txd = RTE_TEST_TX_DESC_DEFAULT;
 
 /* ethernet addresses of ports */
-static struct ether_addr ports_eth_addr[RTE_MAX_ETHPORTS];
+static struct rte_ether_addr ports_eth_addr[RTE_MAX_ETHPORTS];
 
 #ifndef IPv4_BYTES
 #define IPv4_BYTES_FMT "%" PRIu8 ".%" PRIu8 ".%" PRIu8 ".%" PRIu8
@@ -244,7 +244,7 @@ l3fwd_simple_forward(struct rte_mbuf *m, struct lcore_queue_conf *qconf,
        port_out = port_in;
 
        /* Remove the Ethernet header and trailer from the input packet */
-       rte_pktmbuf_adj(m, (uint16_t)sizeof(struct ether_hdr));
+       rte_pktmbuf_adj(m, (uint16_t)sizeof(struct rte_ether_hdr));
 
        /* Build transmission burst */
        len = qconf->tx_mbufs[port_out].len;
@@ -332,13 +332,13 @@ l3fwd_simple_forward(struct rte_mbuf *m, struct lcore_queue_conf *qconf,
                void *d_addr_bytes;
 
                m = qconf->tx_mbufs[port_out].m_table[i];
-               struct ether_hdr *eth_hdr = (struct ether_hdr *)
-                       rte_pktmbuf_prepend(m, (uint16_t)sizeof(struct ether_hdr));
+               struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)
+                       rte_pktmbuf_prepend(m, (uint16_t)sizeof(struct rte_ether_hdr));
                if (eth_hdr == NULL) {
                        rte_panic("No headroom in mbuf.\n");
                }
 
-               m->l2_len = sizeof(struct ether_hdr);
+               m->l2_len = sizeof(struct rte_ether_hdr);
 
                /* 02:00:00:00:00:xx */
                d_addr_bytes = &eth_hdr->d_addr.addr_bytes[0];
@@ -560,7 +560,7 @@ parse_args(int argc, char **argv)
 }
 
 static void
-print_ethaddr(const char *name, struct ether_addr *eth_addr)
+print_ethaddr(const char *name, struct rte_ether_addr *eth_addr)
 {
        char buf[ETHER_ADDR_FMT_SIZE];
        ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr);
@@ -661,11 +661,11 @@ check_ptype(int portid)
 static inline void
 parse_ptype(struct rte_mbuf *m)
 {
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        uint32_t packet_type = RTE_PTYPE_UNKNOWN;
        uint16_t ether_type;
 
-       eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
        ether_type = eth_hdr->ether_type;
        if (ether_type == rte_cpu_to_be_16(ETHER_TYPE_IPv4))
                packet_type |= RTE_PTYPE_L3_IPV4_EXT_UNKNOWN;
index d1e5540..463c30c 100644 (file)
@@ -245,7 +245,7 @@ static void
 print_link_info(struct link *link, char *out, size_t out_size)
 {
        struct rte_eth_stats stats;
-       struct ether_addr mac_addr;
+       struct rte_ether_addr mac_addr;
        struct rte_eth_link eth_link;
        uint16_t mtu;
 
index ffcdeb3..4777f9f 100644 (file)
@@ -513,13 +513,13 @@ inet_pton6(const char *src, unsigned char *dst)
        return 1;
 }
 
-static struct ether_addr *
+static struct rte_ether_addr *
 my_ether_aton(const char *a)
 {
        int i;
        char *end;
        unsigned long o[ETHER_ADDR_LEN];
-       static struct ether_addr ether_addr;
+       static struct rte_ether_addr ether_addr;
 
        i = 0;
        do {
@@ -553,7 +553,7 @@ my_ether_aton(const char *a)
        } else
                return NULL;
 
-       return (struct ether_addr *)&ether_addr;
+       return (struct rte_ether_addr *)&ether_addr;
 }
 
 int
@@ -581,15 +581,15 @@ parse_ipv6_addr(const char *token, struct in6_addr *ipv6)
 }
 
 int
-parse_mac_addr(const char *token, struct ether_addr *addr)
+parse_mac_addr(const char *token, struct rte_ether_addr *addr)
 {
-       struct ether_addr *tmp;
+       struct rte_ether_addr *tmp;
 
        tmp = my_ether_aton(token);
        if (tmp == NULL)
                return -1;
 
-       memcpy(addr, tmp, sizeof(struct ether_addr));
+       memcpy(addr, tmp, sizeof(struct rte_ether_addr));
        return 0;
 }
 
index 261a8c8..4538f67 100644 (file)
@@ -47,7 +47,7 @@ int parse_hex_string(char *src, uint8_t *dst, uint32_t *size);
 
 int parse_ipv4_addr(const char *token, struct in_addr *ipv4);
 int parse_ipv6_addr(const char *token, struct in6_addr *ipv6);
-int parse_mac_addr(const char *token, struct ether_addr *addr);
+int parse_mac_addr(const char *token, struct rte_ether_addr *addr);
 int parse_mpls_labels(char *string, uint32_t *labels, uint32_t *n_labels);
 
 struct cpu_core_params {
index 17b55d4..2261539 100644 (file)
@@ -95,7 +95,7 @@ static uint16_t nb_rxd = RTE_TEST_RX_DESC_DEFAULT;
 static uint16_t nb_txd = RTE_TEST_TX_DESC_DEFAULT;
 
 /* ethernet addresses of ports */
-static struct ether_addr ports_eth_addr[RTE_MAX_ETHPORTS];
+static struct rte_ether_addr ports_eth_addr[RTE_MAX_ETHPORTS];
 
 #ifndef IPv4_BYTES
 #define IPv4_BYTES_FMT "%" PRIu8 ".%" PRIu8 ".%" PRIu8 ".%" PRIu8
@@ -308,7 +308,7 @@ static inline void
 reassemble(struct rte_mbuf *m, uint16_t portid, uint32_t queue,
        struct lcore_queue_conf *qconf, uint64_t tms)
 {
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        struct rte_ip_frag_tbl *tbl;
        struct rte_ip_frag_death_row *dr;
        struct rx_queue *rxq;
@@ -318,7 +318,7 @@ reassemble(struct rte_mbuf *m, uint16_t portid, uint32_t queue,
 
        rxq = &qconf->rx_queue_list[queue];
 
-       eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        dst_port = portid;
 
@@ -350,7 +350,7 @@ reassemble(struct rte_mbuf *m, uint16_t portid, uint32_t queue,
                        if (mo != m) {
                                m = mo;
                                eth_hdr = rte_pktmbuf_mtod(m,
-                                       struct ether_hdr *);
+                                       struct rte_ether_hdr *);
                                ip_hdr = (struct ipv4_hdr *)(eth_hdr + 1);
                        }
                }
@@ -388,7 +388,7 @@ reassemble(struct rte_mbuf *m, uint16_t portid, uint32_t queue,
 
                        if (mo != m) {
                                m = mo;
-                               eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+                               eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
                                ip_hdr = (struct ipv6_hdr *)(eth_hdr + 1);
                        }
                }
@@ -691,7 +691,7 @@ parse_args(int argc, char **argv)
 }
 
 static void
-print_ethaddr(const char *name, const struct ether_addr *eth_addr)
+print_ethaddr(const char *name, const struct rte_ether_addr *eth_addr)
 {
        char buf[ETHER_ADDR_FMT_SIZE];
        ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr);
index 1bc0b5b..abddc6f 100644 (file)
@@ -232,9 +232,9 @@ static inline void
 prepare_one_packet(struct rte_mbuf *pkt, struct ipsec_traffic *t)
 {
        uint8_t *nlp;
-       struct ether_hdr *eth;
+       struct rte_ether_hdr *eth;
 
-       eth = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+       eth = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
        if (eth->ether_type == rte_cpu_to_be_16(ETHER_TYPE_IPv4)) {
                nlp = (uint8_t *)rte_pktmbuf_adj(pkt, ETHER_HDR_LEN);
                nlp = RTE_PTR_ADD(nlp, offsetof(struct ip, ip_p));
@@ -318,11 +318,11 @@ static inline void
 prepare_tx_pkt(struct rte_mbuf *pkt, uint16_t port)
 {
        struct ip *ip;
-       struct ether_hdr *ethhdr;
+       struct rte_ether_hdr *ethhdr;
 
        ip = rte_pktmbuf_mtod(pkt, struct ip *);
 
-       ethhdr = (struct ether_hdr *)rte_pktmbuf_prepend(pkt, ETHER_HDR_LEN);
+       ethhdr = (struct rte_ether_hdr *)rte_pktmbuf_prepend(pkt, ETHER_HDR_LEN);
 
        if (ip->ip_v == IPVERSION) {
                pkt->ol_flags |= PKT_TX_IP_CKSUM | PKT_TX_IPV4;
@@ -340,9 +340,9 @@ prepare_tx_pkt(struct rte_mbuf *pkt, uint16_t port)
        }
 
        memcpy(&ethhdr->s_addr, &ethaddr_tbl[port].src,
-                       sizeof(struct ether_addr));
+                       sizeof(struct rte_ether_addr));
        memcpy(&ethhdr->d_addr, &ethaddr_tbl[port].dst,
-                       sizeof(struct ether_addr));
+                       sizeof(struct rte_ether_addr));
 }
 
 static inline void
@@ -1176,7 +1176,7 @@ parse_args(int32_t argc, char **argv)
 }
 
 static void
-print_ethaddr(const char *name, const struct ether_addr *eth_addr)
+print_ethaddr(const char *name, const struct rte_ether_addr *eth_addr)
 {
        char buf[ETHER_ADDR_FMT_SIZE];
        ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr);
@@ -1551,7 +1551,7 @@ port_init(uint16_t portid)
        uint16_t tx_queueid, rx_queueid, queue, lcore_id;
        int32_t ret, socket_id;
        struct lcore_conf *qconf;
-       struct ether_addr ethaddr;
+       struct rte_ether_addr ethaddr;
        struct rte_eth_conf local_port_conf = port_conf;
 
        rte_eth_dev_info_get(portid, &dev_info);
index 6530d48..297bf11 100644 (file)
@@ -80,7 +80,7 @@ static uint16_t nb_rxd = RTE_TEST_RX_DESC_DEFAULT;
 static uint16_t nb_txd = RTE_TEST_TX_DESC_DEFAULT;
 
 /* ethernet addresses of ports */
-static struct ether_addr ports_eth_addr[MAX_PORTS];
+static struct rte_ether_addr ports_eth_addr[MAX_PORTS];
 
 /* mask of enabled ports */
 static uint32_t enabled_port_mask = 0;
@@ -277,14 +277,14 @@ mcast_out_pkt(struct rte_mbuf *pkt, int use_clone)
  * and put it into the outgoing queue for the given port.
  */
 static inline void
-mcast_send_pkt(struct rte_mbuf *pkt, struct ether_addr *dest_addr,
+mcast_send_pkt(struct rte_mbuf *pkt, struct rte_ether_addr *dest_addr,
                struct lcore_queue_conf *qconf, uint16_t port)
 {
-       struct ether_hdr *ethdr;
+       struct rte_ether_hdr *ethdr;
        uint16_t len;
 
        /* Construct Ethernet header. */
-       ethdr = (struct ether_hdr *)rte_pktmbuf_prepend(pkt, (uint16_t)sizeof(*ethdr));
+       ethdr = (struct rte_ether_hdr *)rte_pktmbuf_prepend(pkt, (uint16_t)sizeof(*ethdr));
        RTE_ASSERT(ethdr != NULL);
 
        ether_addr_copy(dest_addr, &ethdr->d_addr);
@@ -312,11 +312,11 @@ mcast_forward(struct rte_mbuf *m, struct lcore_queue_conf *qconf)
        uint16_t port;
        union {
                uint64_t as_int;
-               struct ether_addr as_addr;
+               struct rte_ether_addr as_addr;
        } dst_eth_addr;
 
        /* Remove the Ethernet header from the input packet */
-       iphdr = (struct ipv4_hdr *)rte_pktmbuf_adj(m, (uint16_t)sizeof(struct ether_hdr));
+       iphdr = (struct ipv4_hdr *)rte_pktmbuf_adj(m, (uint16_t)sizeof(struct rte_ether_hdr));
        RTE_ASSERT(iphdr != NULL);
 
        dest_addr = rte_be_to_cpu_32(iphdr->dst_addr);
@@ -545,7 +545,7 @@ parse_args(int argc, char **argv)
 }
 
 static void
-print_ethaddr(const char *name, struct ether_addr *eth_addr)
+print_ethaddr(const char *name, struct rte_ether_addr *eth_addr)
 {
        char buf[ETHER_ADDR_FMT_SIZE];
        ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr);
index 80c401c..9ad3056 100644 (file)
@@ -764,7 +764,7 @@ kni_config_network_interface(uint16_t port_id, uint8_t if_up)
 }
 
 static void
-print_ethaddr(const char *name, struct ether_addr *mac_addr)
+print_ethaddr(const char *name, struct rte_ether_addr *mac_addr)
 {
        char buf[ETHER_ADDR_FMT_SIZE];
        ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, mac_addr);
@@ -783,10 +783,10 @@ kni_config_mac_address(uint16_t port_id, uint8_t mac_addr[])
        }
 
        RTE_LOG(INFO, APP, "Configure mac address of %d\n", port_id);
-       print_ethaddr("Address:", (struct ether_addr *)mac_addr);
+       print_ethaddr("Address:", (struct rte_ether_addr *)mac_addr);
 
        ret = rte_eth_dev_default_mac_addr_set(port_id,
-                                              (struct ether_addr *)mac_addr);
+                                              (struct rte_ether_addr *)mac_addr);
        if (ret < 0)
                RTE_LOG(ERR, APP, "Failed to config mac_addr for port %d\n",
                        port_id);
@@ -844,7 +844,7 @@ kni_alloc(uint16_t port_id)
                        }
                        /* Get the interface default mac address */
                        rte_eth_macaddr_get(port_id,
-                                       (struct ether_addr *)&conf.mac_addr);
+                                       (struct rte_ether_addr *)&conf.mac_addr);
 
                        rte_eth_dev_get_mtu(port_id, &conf.mtu);
 
index 0e6078a..1a8af28 100644 (file)
@@ -73,7 +73,7 @@ port_init(uint16_t port, struct rte_mempool *mbuf_pool)
                return retval;
 
        /* Display the port MAC address. */
-       struct ether_addr addr;
+       struct rte_ether_addr addr;
        rte_eth_macaddr_get(port, &addr);
        printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8
                           " %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\n",
index f12fd26..05fef7d 100644 (file)
@@ -78,7 +78,7 @@ static uint16_t nb_rxd = RTE_TEST_RX_DESC_DEFAULT;
 static uint16_t nb_txd = RTE_TEST_TX_DESC_DEFAULT;
 
 /* ethernet addresses of ports */
-static struct ether_addr l2fwd_ports_eth_addr[RTE_MAX_ETHPORTS];
+static struct rte_ether_addr l2fwd_ports_eth_addr[RTE_MAX_ETHPORTS];
 
 /* mask of enabled ports */
 static uint64_t l2fwd_enabled_port_mask;
@@ -383,19 +383,19 @@ l2fwd_simple_crypto_enqueue(struct rte_mbuf *m,
                struct rte_crypto_op *op,
                struct l2fwd_crypto_params *cparams)
 {
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        struct ipv4_hdr *ip_hdr;
 
        uint32_t ipdata_offset, data_len;
        uint32_t pad_len = 0;
        char *padding;
 
-       eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        if (eth_hdr->ether_type != rte_cpu_to_be_16(ETHER_TYPE_IPv4))
                return -1;
 
-       ipdata_offset = sizeof(struct ether_hdr);
+       ipdata_offset = sizeof(struct rte_ether_hdr);
 
        ip_hdr = (struct ipv4_hdr *)(rte_pktmbuf_mtod(m, char *) +
                        ipdata_offset);
@@ -589,10 +589,10 @@ l2fwd_send_packet(struct rte_mbuf *m, uint16_t port)
 static void
 l2fwd_mac_updating(struct rte_mbuf *m, uint16_t dest_portid)
 {
-       struct ether_hdr *eth;
+       struct rte_ether_hdr *eth;
        void *tmp;
 
-       eth = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        /* 02:00:00:00:00:xx */
        tmp = &eth->d_addr.addr_bytes[0];
index a4d28e1..033104d 100644 (file)
@@ -52,7 +52,7 @@ static uint16_t nb_rxd = RTE_TEST_RX_DESC_DEFAULT;
 static uint16_t nb_txd = RTE_TEST_TX_DESC_DEFAULT;
 
 /* ethernet addresses of ports */
-static struct ether_addr l2fwd_ports_eth_addr[RTE_MAX_ETHPORTS];
+static struct rte_ether_addr l2fwd_ports_eth_addr[RTE_MAX_ETHPORTS];
 
 /* mask of enabled ports */
 static uint32_t l2fwd_enabled_port_mask;
@@ -335,14 +335,14 @@ show_stats_cb(__rte_unused void *param)
 static void
 l2fwd_simple_forward(struct rte_mbuf *m, unsigned portid)
 {
-       struct ether_hdr *eth;
+       struct rte_ether_hdr *eth;
        void *tmp;
        int sent;
        unsigned dst_port;
        struct rte_eth_dev_tx_buffer *buffer;
 
        dst_port = l2fwd_dst_ports[portid];
-       eth = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        /* 02:00:00:00:00:xx */
        tmp = &eth->d_addr.addr_bytes[0];
index 0bf2b53..21d1993 100644 (file)
@@ -58,7 +58,7 @@ static uint16_t nb_rxd = RTE_TEST_RX_DESC_DEFAULT;
 static uint16_t nb_txd = RTE_TEST_TX_DESC_DEFAULT;
 
 /* ethernet addresses of ports */
-static struct ether_addr l2fwd_ports_eth_addr[RTE_MAX_ETHPORTS];
+static struct rte_ether_addr l2fwd_ports_eth_addr[RTE_MAX_ETHPORTS];
 
 /* mask of enabled ports */
 static uint32_t l2fwd_enabled_port_mask;
@@ -165,14 +165,14 @@ print_stats(__attribute__((unused)) struct rte_timer *ptr_timer,
 static void
 l2fwd_simple_forward(struct rte_mbuf *m, unsigned portid)
 {
-       struct ether_hdr *eth;
+       struct rte_ether_hdr *eth;
        void *tmp;
        int sent;
        unsigned dst_port;
        struct rte_eth_dev_tx_buffer *buffer;
 
        dst_port = l2fwd_dst_ports[portid];
-       eth = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        /* 02:00:00:00:00:xx */
        tmp = &eth->d_addr.addr_bytes[0];
index 6c23215..c1d6797 100644 (file)
@@ -59,7 +59,7 @@ static uint16_t nb_rxd = RTE_TEST_RX_DESC_DEFAULT;
 static uint16_t nb_txd = RTE_TEST_TX_DESC_DEFAULT;
 
 /* ethernet addresses of ports */
-static struct ether_addr l2fwd_ports_eth_addr[RTE_MAX_ETHPORTS];
+static struct rte_ether_addr l2fwd_ports_eth_addr[RTE_MAX_ETHPORTS];
 
 /* mask of enabled ports */
 static uint32_t l2fwd_enabled_port_mask = 0;
@@ -151,10 +151,10 @@ print_stats(void)
 static void
 l2fwd_mac_updating(struct rte_mbuf *m, unsigned dest_portid)
 {
-       struct ether_hdr *eth;
+       struct rte_ether_hdr *eth;
        void *tmp;
 
-       eth = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        /* 02:00:00:00:00:xx */
        tmp = &eth->d_addr.addr_bytes[0];
index a322ce4..ed25f75 100644 (file)
@@ -82,7 +82,7 @@ static uint16_t nb_rxd = RTE_TEST_RX_DESC_DEFAULT;
 static uint16_t nb_txd = RTE_TEST_TX_DESC_DEFAULT;
 
 /* ethernet addresses of ports */
-static struct ether_addr ports_eth_addr[RTE_MAX_ETHPORTS];
+static struct rte_ether_addr ports_eth_addr[RTE_MAX_ETHPORTS];
 
 /* mask of enabled ports */
 static uint32_t enabled_port_mask;
@@ -173,7 +173,7 @@ send_single_packet(struct rte_mbuf *m, uint16_t port);
                *c = (unsigned char)(ip >> 8 & 0xff);\
                *d = (unsigned char)(ip & 0xff);\
        } while (0)
-#define OFF_ETHHEAD    (sizeof(struct ether_hdr))
+#define OFF_ETHHEAD    (sizeof(struct rte_ether_hdr))
 #define OFF_IPV42PROTO (offsetof(struct ipv4_hdr, next_proto_id))
 #define OFF_IPV62PROTO (offsetof(struct ipv6_hdr, proto))
 #define MBUF_IPV4_2PROTO(m)    \
@@ -544,7 +544,7 @@ dump_acl4_rule(struct rte_mbuf *m, uint32_t sig)
        unsigned char a, b, c, d;
        struct ipv4_hdr *ipv4_hdr = rte_pktmbuf_mtod_offset(m,
                                                            struct ipv4_hdr *,
-                                                           sizeof(struct ether_hdr));
+                                                           sizeof(struct rte_ether_hdr));
 
        uint32_t_to_char(rte_bswap32(ipv4_hdr->src_addr), &a, &b, &c, &d);
        printf("Packet Src:%hhu.%hhu.%hhu.%hhu ", a, b, c, d);
@@ -568,7 +568,7 @@ dump_acl6_rule(struct rte_mbuf *m, uint32_t sig)
        uint32_t offset = sig & ~ACL_DENY_SIGNATURE;
        struct ipv6_hdr *ipv6_hdr = rte_pktmbuf_mtod_offset(m,
                                                            struct ipv6_hdr *,
-                                                           sizeof(struct ether_hdr));
+                                                           sizeof(struct rte_ether_hdr));
 
        printf("Packet Src");
        for (i = 0; i < RTE_DIM(ipv6_hdr->src_addr); i += sizeof(uint16_t))
@@ -625,7 +625,7 @@ prepare_one_packet(struct rte_mbuf **pkts_in, struct acl_search_t *acl,
 
        if (RTE_ETH_IS_IPV4_HDR(pkt->packet_type)) {
                ipv4_hdr = rte_pktmbuf_mtod_offset(pkt, struct ipv4_hdr *,
-                                                  sizeof(struct ether_hdr));
+                                                  sizeof(struct rte_ether_hdr));
 
                /* Check to make sure the packet is valid (RFC1812) */
                if (is_valid_ipv4_pkt(ipv4_hdr, pkt->pkt_len) >= 0) {
@@ -1754,7 +1754,7 @@ parse_args(int argc, char **argv)
 }
 
 static void
-print_ethaddr(const char *name, const struct ether_addr *eth_addr)
+print_ethaddr(const char *name, const struct rte_ether_addr *eth_addr)
 {
        char buf[ETHER_ADDR_FMT_SIZE];
        ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr);
index 68527d2..c36cafb 100644 (file)
@@ -121,7 +121,7 @@ static uint16_t nb_rxd = RTE_TEST_RX_DESC_DEFAULT;
 static uint16_t nb_txd = RTE_TEST_TX_DESC_DEFAULT;
 
 /* ethernet addresses of ports */
-static struct ether_addr ports_eth_addr[RTE_MAX_ETHPORTS];
+static struct rte_ether_addr ports_eth_addr[RTE_MAX_ETHPORTS];
 
 /* ethernet addresses of ports */
 static rte_spinlock_t locks[RTE_MAX_ETHPORTS];
@@ -576,11 +576,11 @@ get_ipv4_dst_port(struct ipv4_hdr *ipv4_hdr, uint16_t portid,
 static inline void
 parse_ptype_one(struct rte_mbuf *m)
 {
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        uint32_t packet_type = RTE_PTYPE_UNKNOWN;
        uint16_t ether_type;
 
-       eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
        ether_type = eth_hdr->ether_type;
        if (ether_type == rte_cpu_to_be_16(ETHER_TYPE_IPv4))
                packet_type |= RTE_PTYPE_L3_IPV4_EXT_UNKNOWN;
@@ -619,18 +619,18 @@ static inline void
 l3fwd_simple_forward(struct rte_mbuf *m, uint16_t portid,
                                struct lcore_conf *qconf)
 {
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        struct ipv4_hdr *ipv4_hdr;
        void *d_addr_bytes;
        uint16_t dst_port;
 
-       eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        if (RTE_ETH_IS_IPV4_HDR(m->packet_type)) {
                /* Handle IPv4 headers.*/
                ipv4_hdr =
                        rte_pktmbuf_mtod_offset(m, struct ipv4_hdr *,
-                                               sizeof(struct ether_hdr));
+                                               sizeof(struct rte_ether_hdr));
 
 #ifdef DO_RFC_1812_CHECKS
                /* Check to make sure the packet is valid (RFC1812) */
@@ -668,7 +668,7 @@ l3fwd_simple_forward(struct rte_mbuf *m, uint16_t portid,
 
                ipv6_hdr =
                        rte_pktmbuf_mtod_offset(m, struct ipv6_hdr *,
-                                               sizeof(struct ether_hdr));
+                                               sizeof(struct rte_ether_hdr));
 
                dst_port = get_ipv6_dst_port(ipv6_hdr, portid,
                                        qconf->ipv6_lookup_struct);
@@ -1355,7 +1355,7 @@ parse_args(int argc, char **argv)
 }
 
 static void
-print_ethaddr(const char *name, const struct ether_addr *eth_addr)
+print_ethaddr(const char *name, const struct rte_ether_addr *eth_addr)
 {
        char buf[ETHER_ADDR_FMT_SIZE];
        ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr);
index 41137f9..2c0c89e 100644 (file)
@@ -112,7 +112,7 @@ static uint16_t nb_rxd = RTE_TEST_RX_DESC_DEFAULT;
 static uint16_t nb_txd = RTE_TEST_TX_DESC_DEFAULT;
 
 /* ethernet addresses of ports */
-static struct ether_addr ports_eth_addr[RTE_MAX_ETHPORTS];
+static struct rte_ether_addr ports_eth_addr[RTE_MAX_ETHPORTS];
 
 /* mask of enabled ports */
 static uint32_t enabled_port_mask = 0;
@@ -417,15 +417,15 @@ static inline void
 l3fwd_simple_forward(struct rte_mbuf *m, uint16_t portid,
                      lookup_struct_t *l3fwd_lookup_struct)
 {
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        struct ipv4_hdr *ipv4_hdr;
        void *tmp;
        uint16_t dst_port;
 
-       eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        ipv4_hdr = rte_pktmbuf_mtod_offset(m, struct ipv4_hdr *,
-                                          sizeof(struct ether_hdr));
+                                          sizeof(struct rte_ether_hdr));
 
 #ifdef DO_RFC_1812_CHECKS
        /* Check to make sure the packet is valid (RFC1812) */
@@ -788,7 +788,7 @@ parse_args(int argc, char **argv)
 }
 
 static void
-print_ethaddr(const char *name, const struct ether_addr *eth_addr)
+print_ethaddr(const char *name, const struct rte_ether_addr *eth_addr)
 {
        char buf[ETHER_ADDR_FMT_SIZE];
        ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr);
index c962dea..1893f8c 100644 (file)
@@ -73,7 +73,7 @@ extern volatile bool force_quit;
 
 /* ethernet addresses of ports */
 extern uint64_t dest_eth_addr[RTE_MAX_ETHPORTS];
-extern struct ether_addr ports_eth_addr[RTE_MAX_ETHPORTS];
+extern struct rte_ether_addr ports_eth_addr[RTE_MAX_ETHPORTS];
 
 /* mask of enabled ports */
 extern uint32_t enabled_port_mask;
index 5ec99f9..0c68aa0 100644 (file)
@@ -68,13 +68,13 @@ processx4_step3(struct rte_mbuf *pkt[FWDSTEP], uint16_t dst_port[FWDSTEP])
        *p[2] = te[2];
        *p[3] = te[3];
 
-       rfc1812_process((struct ipv4_hdr *)((struct ether_hdr *)p[0] + 1),
+       rfc1812_process((struct ipv4_hdr *)((struct rte_ether_hdr *)p[0] + 1),
                &dst_port[0], pkt[0]->packet_type);
-       rfc1812_process((struct ipv4_hdr *)((struct ether_hdr *)p[1] + 1),
+       rfc1812_process((struct ipv4_hdr *)((struct rte_ether_hdr *)p[1] + 1),
                &dst_port[1], pkt[1]->packet_type);
-       rfc1812_process((struct ipv4_hdr *)((struct ether_hdr *)p[2] + 1),
+       rfc1812_process((struct ipv4_hdr *)((struct rte_ether_hdr *)p[2] + 1),
                &dst_port[2], pkt[2]->packet_type);
-       rfc1812_process((struct ipv4_hdr *)((struct ether_hdr *)p[3] + 1),
+       rfc1812_process((struct ipv4_hdr *)((struct rte_ether_hdr *)p[3] + 1),
                &dst_port[3], pkt[3]->packet_type);
 }
 
@@ -121,10 +121,10 @@ port_groupx4(uint16_t pn[FWDSTEP + 1], uint16_t *lp, vector unsigned short dp1,
 static inline void
 process_packet(struct rte_mbuf *pkt, uint16_t *dst_port)
 {
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        vector unsigned int te, ve;
 
-       eth_hdr = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
 
        te = *(vector unsigned int *)eth_hdr;
        ve = (vector unsigned int)val_eth[dst_port[0]];
index fa8f82b..64e79b9 100644 (file)
@@ -561,7 +561,7 @@ em_check_ptype(int portid)
 static inline void
 em_parse_ptype(struct rte_mbuf *m)
 {
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        uint32_t packet_type = RTE_PTYPE_UNKNOWN;
        uint16_t ether_type;
        void *l3;
@@ -569,9 +569,9 @@ em_parse_ptype(struct rte_mbuf *m)
        struct ipv4_hdr *ipv4_hdr;
        struct ipv6_hdr *ipv6_hdr;
 
-       eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
        ether_type = eth_hdr->ether_type;
-       l3 = (uint8_t *)eth_hdr + sizeof(struct ether_hdr);
+       l3 = (uint8_t *)eth_hdr + sizeof(struct rte_ether_hdr);
        if (ether_type == rte_cpu_to_be_16(ETHER_TYPE_IPv4)) {
                ipv4_hdr = (struct ipv4_hdr *)l3;
                hdr_len = (ipv4_hdr->version_ihl & IPV4_HDR_IHL_MASK) *
index 228164e..5612ef3 100644 (file)
@@ -9,20 +9,20 @@ static __rte_always_inline void
 l3fwd_em_simple_forward(struct rte_mbuf *m, uint16_t portid,
                struct lcore_conf *qconf)
 {
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        struct ipv4_hdr *ipv4_hdr;
        uint16_t dst_port;
        uint32_t tcp_or_udp;
        uint32_t l3_ptypes;
 
-       eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
        tcp_or_udp = m->packet_type & (RTE_PTYPE_L4_TCP | RTE_PTYPE_L4_UDP);
        l3_ptypes = m->packet_type & RTE_PTYPE_L3_MASK;
 
        if (tcp_or_udp && (l3_ptypes == RTE_PTYPE_L3_IPV4)) {
                /* Handle IPv4 headers.*/
                ipv4_hdr = rte_pktmbuf_mtod_offset(m, struct ipv4_hdr *,
-                                                  sizeof(struct ether_hdr));
+                                                  sizeof(struct rte_ether_hdr));
 
 #ifdef DO_RFC_1812_CHECKS
                /* Check to make sure the packet is valid (RFC1812) */
@@ -55,7 +55,7 @@ l3fwd_em_simple_forward(struct rte_mbuf *m, uint16_t portid,
                struct ipv6_hdr *ipv6_hdr;
 
                ipv6_hdr = rte_pktmbuf_mtod_offset(m, struct ipv6_hdr *,
-                                                  sizeof(struct ether_hdr));
+                                                  sizeof(struct rte_ether_hdr));
 
                dst_port = em_get_ipv6_dst_port(ipv6_hdr, portid,
                                        qconf->ipv6_lookup_struct);
index 22c26dc..5afe775 100644 (file)
@@ -92,7 +92,7 @@ em_get_dst_port(const struct lcore_conf *qconf, struct rte_mbuf *pkt,
 
                /* Handle IPv4 headers.*/
                ipv4_hdr = rte_pktmbuf_mtod_offset(pkt, struct ipv4_hdr *,
-                               sizeof(struct ether_hdr));
+                               sizeof(struct rte_ether_hdr));
 
                next_hop = em_get_ipv4_dst_port(ipv4_hdr, portid,
                                qconf->ipv4_lookup_struct);
@@ -107,7 +107,7 @@ em_get_dst_port(const struct lcore_conf *qconf, struct rte_mbuf *pkt,
 
                /* Handle IPv6 headers.*/
                ipv6_hdr = rte_pktmbuf_mtod_offset(pkt, struct ipv6_hdr *,
-                               sizeof(struct ether_hdr));
+                               sizeof(struct rte_ether_hdr));
 
                next_hop = em_get_ipv6_dst_port(ipv6_hdr, portid,
                                qconf->ipv6_lookup_struct);
@@ -142,7 +142,7 @@ l3fwd_em_send_packets(int nb_rx, struct rte_mbuf **pkts_burst,
 
        for (j = 0; j < EM_HASH_LOOKUP_COUNT && j < nb_rx; j++) {
                rte_prefetch0(rte_pktmbuf_mtod(pkts_burst[j],
-                                              struct ether_hdr *) + 1);
+                                              struct rte_ether_hdr *) + 1);
        }
 
        for (j = 0; j < n; j += EM_HASH_LOOKUP_COUNT) {
@@ -160,7 +160,7 @@ l3fwd_em_send_packets(int nb_rx, struct rte_mbuf **pkts_burst,
                for (i = 0, pos = j + EM_HASH_LOOKUP_COUNT;
                     i < EM_HASH_LOOKUP_COUNT && pos < nb_rx; i++, pos++) {
                        rte_prefetch0(rte_pktmbuf_mtod(pkts_burst[pos],
-                                                      struct ether_hdr *) + 1);
+                                                      struct rte_ether_hdr *) + 1);
                }
 
                if (tcp_or_udp && (l3_type == RTE_PTYPE_L3_IPV4)) {
index 16c8b04..3ee2304 100644 (file)
@@ -13,7 +13,7 @@ get_ipv4_5tuple(struct rte_mbuf *m0, int32x4_t mask0,
                union ipv4_5tuple_host *key)
 {
        int32x4_t tmpdata0 = vld1q_s32(rte_pktmbuf_mtod_offset(m0, int32_t *,
-                               sizeof(struct ether_hdr) +
+                               sizeof(struct rte_ether_hdr) +
                                offsetof(struct ipv4_hdr, time_to_live)));
 
        key->xmm = vandq_s32(tmpdata0, mask0);
@@ -25,17 +25,17 @@ get_ipv6_5tuple(struct rte_mbuf *m0, int32x4_t mask0,
 {
        int32x4_t tmpdata0 = vld1q_s32(
                        rte_pktmbuf_mtod_offset(m0, int *,
-                               sizeof(struct ether_hdr) +
+                               sizeof(struct rte_ether_hdr) +
                                offsetof(struct ipv6_hdr, payload_len)));
 
        int32x4_t tmpdata1 = vld1q_s32(
                        rte_pktmbuf_mtod_offset(m0, int *,
-                               sizeof(struct ether_hdr) +
+                               sizeof(struct rte_ether_hdr) +
                                offsetof(struct ipv6_hdr, payload_len) + 8));
 
        int32x4_t tmpdata2 = vld1q_s32(
                        rte_pktmbuf_mtod_offset(m0, int *,
-                               sizeof(struct ether_hdr) +
+                               sizeof(struct rte_ether_hdr) +
                                offsetof(struct ipv6_hdr, payload_len) + 16));
 
        key->xmm[0] = vandq_s32(tmpdata0, mask0);
index 41e2be9..8156bbb 100644 (file)
@@ -13,7 +13,7 @@ get_ipv4_5tuple(struct rte_mbuf *m0, __m128i mask0,
 {
         __m128i tmpdata0 = _mm_loadu_si128(
                        rte_pktmbuf_mtod_offset(m0, __m128i *,
-                               sizeof(struct ether_hdr) +
+                               sizeof(struct rte_ether_hdr) +
                                offsetof(struct ipv4_hdr, time_to_live)));
 
        key->xmm = _mm_and_si128(tmpdata0, mask0);
@@ -25,18 +25,18 @@ get_ipv6_5tuple(struct rte_mbuf *m0, __m128i mask0,
 {
        __m128i tmpdata0 = _mm_loadu_si128(
                        rte_pktmbuf_mtod_offset(m0, __m128i *,
-                               sizeof(struct ether_hdr) +
+                               sizeof(struct rte_ether_hdr) +
                                offsetof(struct ipv6_hdr, payload_len)));
 
        __m128i tmpdata1 = _mm_loadu_si128(
                        rte_pktmbuf_mtod_offset(m0, __m128i *,
-                               sizeof(struct ether_hdr) +
+                               sizeof(struct rte_ether_hdr) +
                                offsetof(struct ipv6_hdr, payload_len) +
                                sizeof(__m128i)));
 
        __m128i tmpdata2 = _mm_loadu_si128(
                        rte_pktmbuf_mtod_offset(m0, __m128i *,
-                               sizeof(struct ether_hdr) +
+                               sizeof(struct rte_ether_hdr) +
                                offsetof(struct ipv6_hdr, payload_len) +
                                sizeof(__m128i) + sizeof(__m128i)));
 
index 35cf5ea..6e7096c 100644 (file)
@@ -37,7 +37,7 @@ em_get_dst_port(const struct lcore_conf *qconf, struct rte_mbuf *pkt,
 
                /* Handle IPv4 headers.*/
                ipv4_hdr = rte_pktmbuf_mtod_offset(pkt, struct ipv4_hdr *,
-                               sizeof(struct ether_hdr));
+                               sizeof(struct rte_ether_hdr));
 
                next_hop = em_get_ipv4_dst_port(ipv4_hdr, portid,
                                qconf->ipv4_lookup_struct);
@@ -52,7 +52,7 @@ em_get_dst_port(const struct lcore_conf *qconf, struct rte_mbuf *pkt,
 
                /* Handle IPv6 headers.*/
                ipv6_hdr = rte_pktmbuf_mtod_offset(pkt, struct ipv6_hdr *,
-                               sizeof(struct ether_hdr));
+                               sizeof(struct rte_ether_hdr));
 
                next_hop = em_get_ipv6_dst_port(ipv6_hdr, portid,
                                qconf->ipv6_lookup_struct);
@@ -81,13 +81,13 @@ l3fwd_em_send_packets(int nb_rx, struct rte_mbuf **pkts_burst,
 
        if (nb_rx > 0) {
                rte_prefetch0(rte_pktmbuf_mtod(pkts_burst[0],
-                                              struct ether_hdr *) + 1);
+                                              struct rte_ether_hdr *) + 1);
        }
 
        for (i = 1, j = 0; j < nb_rx; i++, j++) {
                if (i < nb_rx) {
                        rte_prefetch0(rte_pktmbuf_mtod(pkts_burst[i],
-                                                      struct ether_hdr *) + 1);
+                                                      struct rte_ether_hdr *) + 1);
                }
                dst_port[j] = em_get_dst_port(qconf, pkts_burst[j], portid);
        }
index b1dc195..d7e1aef 100644 (file)
@@ -104,18 +104,18 @@ lpm_get_dst_port(const struct lcore_conf *qconf, struct rte_mbuf *pkt,
 {
        struct ipv6_hdr *ipv6_hdr;
        struct ipv4_hdr *ipv4_hdr;
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
 
        if (RTE_ETH_IS_IPV4_HDR(pkt->packet_type)) {
 
-               eth_hdr = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+               eth_hdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
                ipv4_hdr = (struct ipv4_hdr *)(eth_hdr + 1);
 
                return lpm_get_ipv4_dst_port(ipv4_hdr, portid,
                                             qconf->ipv4_lookup_struct);
        } else if (RTE_ETH_IS_IPV6_HDR(pkt->packet_type)) {
 
-               eth_hdr = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+               eth_hdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
                ipv6_hdr = (struct ipv6_hdr *)(eth_hdr + 1);
 
                return lpm_get_ipv6_dst_port(ipv6_hdr, portid,
@@ -136,7 +136,7 @@ lpm_get_dst_port_with_ipv4(const struct lcore_conf *qconf, struct rte_mbuf *pkt,
 {
        uint32_t next_hop;
        struct ipv6_hdr *ipv6_hdr;
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
 
        if (RTE_ETH_IS_IPV4_HDR(pkt->packet_type)) {
                return (uint16_t) ((rte_lpm_lookup(qconf->ipv4_lookup_struct,
@@ -145,7 +145,7 @@ lpm_get_dst_port_with_ipv4(const struct lcore_conf *qconf, struct rte_mbuf *pkt,
 
        } else if (RTE_ETH_IS_IPV6_HDR(pkt->packet_type)) {
 
-               eth_hdr = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+               eth_hdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
                ipv6_hdr = (struct ipv6_hdr *)(eth_hdr + 1);
 
                return (uint16_t) ((rte_lpm6_lookup(qconf->ipv6_lookup_struct,
@@ -372,11 +372,11 @@ lpm_check_ptype(int portid)
 static inline void
 lpm_parse_ptype(struct rte_mbuf *m)
 {
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        uint32_t packet_type = RTE_PTYPE_UNKNOWN;
        uint16_t ether_type;
 
-       eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
        ether_type = eth_hdr->ether_type;
        if (ether_type == rte_cpu_to_be_16(ETHER_TYPE_IPv4))
                packet_type |= RTE_PTYPE_L3_IPV4_EXT_UNKNOWN;
index b68868f..28635bf 100644 (file)
@@ -9,16 +9,16 @@ static __rte_always_inline void
 l3fwd_lpm_simple_forward(struct rte_mbuf *m, uint16_t portid,
                struct lcore_conf *qconf)
 {
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        struct ipv4_hdr *ipv4_hdr;
        uint16_t dst_port;
 
-       eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        if (RTE_ETH_IS_IPV4_HDR(m->packet_type)) {
                /* Handle IPv4 headers.*/
                ipv4_hdr = rte_pktmbuf_mtod_offset(m, struct ipv4_hdr *,
-                                                  sizeof(struct ether_hdr));
+                                                  sizeof(struct rte_ether_hdr));
 
 #ifdef DO_RFC_1812_CHECKS
                /* Check to make sure the packet is valid (RFC1812) */
@@ -51,7 +51,7 @@ l3fwd_lpm_simple_forward(struct rte_mbuf *m, uint16_t portid,
                struct ipv6_hdr *ipv6_hdr;
 
                ipv6_hdr = rte_pktmbuf_mtod_offset(m, struct ipv6_hdr *,
-                                                  sizeof(struct ether_hdr));
+                                                  sizeof(struct rte_ether_hdr));
 
                dst_port = lpm_get_ipv6_dst_port(ipv6_hdr, portid,
                                        qconf->ipv6_lookup_struct);
index 4c9e243..b36e991 100644 (file)
@@ -18,28 +18,28 @@ processx4_step1(struct rte_mbuf *pkt[FWDSTEP],
                uint32_t *ipv4_flag)
 {
        struct ipv4_hdr *ipv4_hdr;
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        uint32_t x0, x1, x2, x3;
 
-       eth_hdr = rte_pktmbuf_mtod(pkt[0], struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(pkt[0], struct rte_ether_hdr *);
        ipv4_hdr = (struct ipv4_hdr *)(eth_hdr + 1);
        x0 = ipv4_hdr->dst_addr;
        ipv4_flag[0] = pkt[0]->packet_type & RTE_PTYPE_L3_IPV4;
 
        rte_compiler_barrier();
-       eth_hdr = rte_pktmbuf_mtod(pkt[1], struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(pkt[1], struct rte_ether_hdr *);
        ipv4_hdr = (struct ipv4_hdr *)(eth_hdr + 1);
        x1 = ipv4_hdr->dst_addr;
        ipv4_flag[0] &= pkt[1]->packet_type;
 
        rte_compiler_barrier();
-       eth_hdr = rte_pktmbuf_mtod(pkt[2], struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(pkt[2], struct rte_ether_hdr *);
        ipv4_hdr = (struct ipv4_hdr *)(eth_hdr + 1);
        x2 = ipv4_hdr->dst_addr;
        ipv4_flag[0] &= pkt[2]->packet_type;
 
        rte_compiler_barrier();
-       eth_hdr = rte_pktmbuf_mtod(pkt[3], struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(pkt[3], struct rte_ether_hdr *);
        ipv4_hdr = (struct ipv4_hdr *)(eth_hdr + 1);
        x3 = ipv4_hdr->dst_addr;
        ipv4_flag[0] &= pkt[3]->packet_type;
index 02ec0d8..a3e42cf 100644 (file)
@@ -19,25 +19,25 @@ processx4_step1(struct rte_mbuf *pkt[FWDSTEP],
                uint32_t *ipv4_flag)
 {
        struct ipv4_hdr *ipv4_hdr;
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        int32_t dst[FWDSTEP];
 
-       eth_hdr = rte_pktmbuf_mtod(pkt[0], struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(pkt[0], struct rte_ether_hdr *);
        ipv4_hdr = (struct ipv4_hdr *)(eth_hdr + 1);
        dst[0] = ipv4_hdr->dst_addr;
        ipv4_flag[0] = pkt[0]->packet_type & RTE_PTYPE_L3_IPV4;
 
-       eth_hdr = rte_pktmbuf_mtod(pkt[1], struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(pkt[1], struct rte_ether_hdr *);
        ipv4_hdr = (struct ipv4_hdr *)(eth_hdr + 1);
        dst[1] = ipv4_hdr->dst_addr;
        ipv4_flag[0] &= pkt[1]->packet_type;
 
-       eth_hdr = rte_pktmbuf_mtod(pkt[2], struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(pkt[2], struct rte_ether_hdr *);
        ipv4_hdr = (struct ipv4_hdr *)(eth_hdr + 1);
        dst[2] = ipv4_hdr->dst_addr;
        ipv4_flag[0] &= pkt[2]->packet_type;
 
-       eth_hdr = rte_pktmbuf_mtod(pkt[3], struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(pkt[3], struct rte_ether_hdr *);
        ipv4_hdr = (struct ipv4_hdr *)(eth_hdr + 1);
        dst[3] = ipv4_hdr->dst_addr;
        ipv4_flag[0] &= pkt[3]->packet_type;
@@ -98,14 +98,14 @@ l3fwd_lpm_send_packets(int nb_rx, struct rte_mbuf **pkts_burst,
        if (k) {
                for (i = 0; i < FWDSTEP; i++) {
                        rte_prefetch0(rte_pktmbuf_mtod(pkts_burst[i],
-                                               struct ether_hdr *) + 1);
+                                               struct rte_ether_hdr *) + 1);
                }
 
                for (j = 0; j != k - FWDSTEP; j += FWDSTEP) {
                        for (i = 0; i < FWDSTEP; i++) {
                                rte_prefetch0(rte_pktmbuf_mtod(
                                                pkts_burst[j + i + FWDSTEP],
-                                               struct ether_hdr *) + 1);
+                                               struct rte_ether_hdr *) + 1);
                        }
 
                        processx4_step1(&pkts_burst[j], &dip, &ipv4_flag);
@@ -125,17 +125,17 @@ l3fwd_lpm_send_packets(int nb_rx, struct rte_mbuf **pkts_burst,
                switch (m) {
                case 3:
                        rte_prefetch0(rte_pktmbuf_mtod(pkts_burst[j],
-                                               struct ether_hdr *) + 1);
+                                               struct rte_ether_hdr *) + 1);
                        j++;
                        /* fallthrough */
                case 2:
                        rte_prefetch0(rte_pktmbuf_mtod(pkts_burst[j],
-                                               struct ether_hdr *) + 1);
+                                               struct rte_ether_hdr *) + 1);
                        j++;
                        /* fallthrough */
                case 1:
                        rte_prefetch0(rte_pktmbuf_mtod(pkts_burst[j],
-                                               struct ether_hdr *) + 1);
+                                               struct rte_ether_hdr *) + 1);
                        j++;
                }
 
index 1d16159..4603e07 100644 (file)
@@ -16,25 +16,25 @@ processx4_step1(struct rte_mbuf *pkt[FWDSTEP],
                uint32_t *ipv4_flag)
 {
        struct ipv4_hdr *ipv4_hdr;
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        uint32_t x0, x1, x2, x3;
 
-       eth_hdr = rte_pktmbuf_mtod(pkt[0], struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(pkt[0], struct rte_ether_hdr *);
        ipv4_hdr = (struct ipv4_hdr *)(eth_hdr + 1);
        x0 = ipv4_hdr->dst_addr;
        ipv4_flag[0] = pkt[0]->packet_type & RTE_PTYPE_L3_IPV4;
 
-       eth_hdr = rte_pktmbuf_mtod(pkt[1], struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(pkt[1], struct rte_ether_hdr *);
        ipv4_hdr = (struct ipv4_hdr *)(eth_hdr + 1);
        x1 = ipv4_hdr->dst_addr;
        ipv4_flag[0] &= pkt[1]->packet_type;
 
-       eth_hdr = rte_pktmbuf_mtod(pkt[2], struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(pkt[2], struct rte_ether_hdr *);
        ipv4_hdr = (struct ipv4_hdr *)(eth_hdr + 1);
        x2 = ipv4_hdr->dst_addr;
        ipv4_flag[0] &= pkt[2]->packet_type;
 
-       eth_hdr = rte_pktmbuf_mtod(pkt[3], struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(pkt[3], struct rte_ether_hdr *);
        ipv4_hdr = (struct ipv4_hdr *)(eth_hdr + 1);
        x3 = ipv4_hdr->dst_addr;
        ipv4_flag[0] &= pkt[3]->packet_type;
index 76ccdfa..af2dc47 100644 (file)
@@ -48,13 +48,13 @@ processx4_step3(struct rte_mbuf *pkt[FWDSTEP], uint16_t dst_port[FWDSTEP])
        vst1q_u32(p[2], ve[2]);
        vst1q_u32(p[3], ve[3]);
 
-       rfc1812_process((struct ipv4_hdr *)((struct ether_hdr *)p[0] + 1),
+       rfc1812_process((struct ipv4_hdr *)((struct rte_ether_hdr *)p[0] + 1),
                &dst_port[0], pkt[0]->packet_type);
-       rfc1812_process((struct ipv4_hdr *)((struct ether_hdr *)p[1] + 1),
+       rfc1812_process((struct ipv4_hdr *)((struct rte_ether_hdr *)p[1] + 1),
                &dst_port[1], pkt[1]->packet_type);
-       rfc1812_process((struct ipv4_hdr *)((struct ether_hdr *)p[2] + 1),
+       rfc1812_process((struct ipv4_hdr *)((struct rte_ether_hdr *)p[2] + 1),
                &dst_port[2], pkt[2]->packet_type);
-       rfc1812_process((struct ipv4_hdr *)((struct ether_hdr *)p[3] + 1),
+       rfc1812_process((struct ipv4_hdr *)((struct rte_ether_hdr *)p[3] + 1),
                &dst_port[3], pkt[3]->packet_type);
 }
 
@@ -104,10 +104,10 @@ port_groupx4(uint16_t pn[FWDSTEP + 1], uint16_t *lp, uint16x8_t dp1,
 static inline void
 process_packet(struct rte_mbuf *pkt, uint16_t *dst_port)
 {
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        uint32x4_t te, ve;
 
-       eth_hdr = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
 
        te = vld1q_u32((uint32_t *)eth_hdr);
        ve = vreinterpretq_u32_s32(val_eth[dst_port[0]]);
index ed5267c..3349f27 100644 (file)
@@ -48,13 +48,13 @@ processx4_step3(struct rte_mbuf *pkt[FWDSTEP], uint16_t dst_port[FWDSTEP])
        _mm_storeu_si128(p[2], te[2]);
        _mm_storeu_si128(p[3], te[3]);
 
-       rfc1812_process((struct ipv4_hdr *)((struct ether_hdr *)p[0] + 1),
+       rfc1812_process((struct ipv4_hdr *)((struct rte_ether_hdr *)p[0] + 1),
                &dst_port[0], pkt[0]->packet_type);
-       rfc1812_process((struct ipv4_hdr *)((struct ether_hdr *)p[1] + 1),
+       rfc1812_process((struct ipv4_hdr *)((struct rte_ether_hdr *)p[1] + 1),
                &dst_port[1], pkt[1]->packet_type);
-       rfc1812_process((struct ipv4_hdr *)((struct ether_hdr *)p[2] + 1),
+       rfc1812_process((struct ipv4_hdr *)((struct rte_ether_hdr *)p[2] + 1),
                &dst_port[2], pkt[2]->packet_type);
-       rfc1812_process((struct ipv4_hdr *)((struct ether_hdr *)p[3] + 1),
+       rfc1812_process((struct ipv4_hdr *)((struct rte_ether_hdr *)p[3] + 1),
                &dst_port[3], pkt[3]->packet_type);
 }
 
@@ -101,10 +101,10 @@ port_groupx4(uint16_t pn[FWDSTEP + 1], uint16_t *lp, __m128i dp1, __m128i dp2)
 static inline void
 process_packet(struct rte_mbuf *pkt, uint16_t *dst_port)
 {
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        __m128i te, ve;
 
-       eth_hdr = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
 
        te = _mm_loadu_si128((__m128i *)eth_hdr);
        ve = val_eth[dst_port[0]];
index e4b99ef..a91a0a1 100644 (file)
@@ -79,7 +79,7 @@ volatile bool force_quit;
 
 /* ethernet addresses of ports */
 uint64_t dest_eth_addr[RTE_MAX_ETHPORTS];
-struct ether_addr ports_eth_addr[RTE_MAX_ETHPORTS];
+struct rte_ether_addr ports_eth_addr[RTE_MAX_ETHPORTS];
 
 xmm_t val_eth[RTE_MAX_ETHPORTS];
 
@@ -634,7 +634,7 @@ parse_args(int argc, char **argv)
 }
 
 static void
-print_ethaddr(const char *name, const struct ether_addr *eth_addr)
+print_ethaddr(const char *name, const struct rte_ether_addr *eth_addr)
 {
        char buf[ETHER_ADDR_FMT_SIZE];
        ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr);
@@ -889,14 +889,14 @@ main(int argc, char **argv)
                print_ethaddr(" Address:", &ports_eth_addr[portid]);
                printf(", ");
                print_ethaddr("Destination:",
-                       (const struct ether_addr *)&dest_eth_addr[portid]);
+                       (const struct rte_ether_addr *)&dest_eth_addr[portid]);
                printf(", ");
 
                /*
                 * prepare src MACs for each port.
                 */
                ether_addr_copy(&ports_eth_addr[portid],
-                       (struct ether_addr *)(val_eth + portid) + 1);
+                       (struct rte_ether_addr *)(val_eth + portid) + 1);
 
                /* init memory */
                ret = init_mem(NB_MBUF);
index f3346d2..9997c58 100644 (file)
@@ -53,7 +53,7 @@ static uint16_t nb_rxd = RTE_TEST_RX_DESC_DEFAULT;
 static uint16_t nb_txd = RTE_TEST_TX_DESC_DEFAULT;
 
 /* ethernet addresses of ports */
-static struct ether_addr lsi_ports_eth_addr[RTE_MAX_ETHPORTS];
+static struct rte_ether_addr lsi_ports_eth_addr[RTE_MAX_ETHPORTS];
 
 /* mask of enabled ports */
 static uint32_t lsi_enabled_port_mask = 0;
@@ -163,13 +163,13 @@ print_stats(void)
 static void
 lsi_simple_forward(struct rte_mbuf *m, unsigned portid)
 {
-       struct ether_hdr *eth;
+       struct rte_ether_hdr *eth;
        void *tmp;
        unsigned dst_port = lsi_dst_ports[portid];
        int sent;
        struct rte_eth_dev_tx_buffer *buffer;
 
-       eth = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        /* 02:00:00:00:00:xx */
        tmp = &eth->d_addr.addr_bytes[0];
index 39a846a..c4e6b4a 100644 (file)
@@ -509,7 +509,7 @@ app_lcore_worker(
                        pkt = lp->mbuf_in.array[j];
                        ipv4_hdr = rte_pktmbuf_mtod_offset(pkt,
                                                           struct ipv4_hdr *,
-                                                          sizeof(struct ether_hdr));
+                                                          sizeof(struct rte_ether_hdr));
                        ipv4_dst = rte_be_to_cpu_32(ipv4_hdr->dst_addr);
 
                        if (unlikely(rte_lpm_lookup(lp->lpm_table, ipv4_dst, &port) != 0)) {
index 93a9a08..7be2beb 100644 (file)
@@ -65,7 +65,7 @@ get_printable_mac_addr(uint16_t port)
        if (unlikely(port >= RTE_MAX_ETHPORTS))
                return err_address;
        if (unlikely(addresses[port][0]=='\0')){
-               struct ether_addr mac;
+               struct rte_ether_addr mac;
                rte_eth_macaddr_get(port, &mac);
                snprintf(addresses[port], sizeof(addresses[port]),
                                "%02x:%02x:%02x:%02x:%02x:%02x\n",
index 149bfdd..ca31202 100644 (file)
@@ -255,7 +255,7 @@ configure_tx_buffers(struct rte_eth_dev_tx_buffer *tx_buffer[])
 static inline int
 configure_eth_port(uint16_t port_id)
 {
-       struct ether_addr addr;
+       struct rte_ether_addr addr;
        const uint16_t rxRings = 1, txRings = 1;
        int ret;
        uint16_t q;
index 4f8747b..b29ed9e 100644 (file)
@@ -92,11 +92,11 @@ check_ptype(int portid)
 static inline void
 parse_ptype(struct rte_mbuf *m)
 {
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        uint32_t packet_type = RTE_PTYPE_UNKNOWN;
        uint16_t ether_type;
 
-       eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
        ether_type = eth_hdr->ether_type;
        if (ether_type == rte_cpu_to_be_16(ETHER_TYPE_IPv4))
                packet_type |= RTE_PTYPE_L3_IPV4_EXT_UNKNOWN;
@@ -186,7 +186,7 @@ static uint16_t nb_txd = RTE_TEST_TX_DESC_DEFAULT;
 
 /* ethernet addresses of ports */
 static uint64_t dest_eth_addr[RTE_MAX_ETHPORTS];
-static struct ether_addr ports_eth_addr[RTE_MAX_ETHPORTS];
+static struct rte_ether_addr ports_eth_addr[RTE_MAX_ETHPORTS];
 
 static xmm_t val_eth[RTE_MAX_ETHPORTS];
 
@@ -884,39 +884,39 @@ static inline void l3fwd_simple_forward(struct rte_mbuf *m, uint16_t portid)
 static inline void
 simple_ipv4_fwd_8pkts(struct rte_mbuf *m[8], uint16_t portid)
 {
-       struct ether_hdr *eth_hdr[8];
+       struct rte_ether_hdr *eth_hdr[8];
        struct ipv4_hdr *ipv4_hdr[8];
        uint16_t dst_port[8];
        int32_t ret[8];
        union ipv4_5tuple_host key[8];
        __m128i data[8];
 
-       eth_hdr[0] = rte_pktmbuf_mtod(m[0], struct ether_hdr *);
-       eth_hdr[1] = rte_pktmbuf_mtod(m[1], struct ether_hdr *);
-       eth_hdr[2] = rte_pktmbuf_mtod(m[2], struct ether_hdr *);
-       eth_hdr[3] = rte_pktmbuf_mtod(m[3], struct ether_hdr *);
-       eth_hdr[4] = rte_pktmbuf_mtod(m[4], struct ether_hdr *);
-       eth_hdr[5] = rte_pktmbuf_mtod(m[5], struct ether_hdr *);
-       eth_hdr[6] = rte_pktmbuf_mtod(m[6], struct ether_hdr *);
-       eth_hdr[7] = rte_pktmbuf_mtod(m[7], struct ether_hdr *);
+       eth_hdr[0] = rte_pktmbuf_mtod(m[0], struct rte_ether_hdr *);
+       eth_hdr[1] = rte_pktmbuf_mtod(m[1], struct rte_ether_hdr *);
+       eth_hdr[2] = rte_pktmbuf_mtod(m[2], struct rte_ether_hdr *);
+       eth_hdr[3] = rte_pktmbuf_mtod(m[3], struct rte_ether_hdr *);
+       eth_hdr[4] = rte_pktmbuf_mtod(m[4], struct rte_ether_hdr *);
+       eth_hdr[5] = rte_pktmbuf_mtod(m[5], struct rte_ether_hdr *);
+       eth_hdr[6] = rte_pktmbuf_mtod(m[6], struct rte_ether_hdr *);
+       eth_hdr[7] = rte_pktmbuf_mtod(m[7], struct rte_ether_hdr *);
 
        /* Handle IPv4 headers.*/
        ipv4_hdr[0] = rte_pktmbuf_mtod_offset(m[0], struct ipv4_hdr *,
-                       sizeof(struct ether_hdr));
+                       sizeof(struct rte_ether_hdr));
        ipv4_hdr[1] = rte_pktmbuf_mtod_offset(m[1], struct ipv4_hdr *,
-                       sizeof(struct ether_hdr));
+                       sizeof(struct rte_ether_hdr));
        ipv4_hdr[2] = rte_pktmbuf_mtod_offset(m[2], struct ipv4_hdr *,
-                       sizeof(struct ether_hdr));
+                       sizeof(struct rte_ether_hdr));
        ipv4_hdr[3] = rte_pktmbuf_mtod_offset(m[3], struct ipv4_hdr *,
-                       sizeof(struct ether_hdr));
+                       sizeof(struct rte_ether_hdr));
        ipv4_hdr[4] = rte_pktmbuf_mtod_offset(m[4], struct ipv4_hdr *,
-                       sizeof(struct ether_hdr));
+                       sizeof(struct rte_ether_hdr));
        ipv4_hdr[5] = rte_pktmbuf_mtod_offset(m[5], struct ipv4_hdr *,
-                       sizeof(struct ether_hdr));
+                       sizeof(struct rte_ether_hdr));
        ipv4_hdr[6] = rte_pktmbuf_mtod_offset(m[6], struct ipv4_hdr *,
-                       sizeof(struct ether_hdr));
+                       sizeof(struct rte_ether_hdr));
        ipv4_hdr[7] = rte_pktmbuf_mtod_offset(m[7], struct ipv4_hdr *,
-                       sizeof(struct ether_hdr));
+                       sizeof(struct rte_ether_hdr));
 
 #ifdef DO_RFC_1812_CHECKS
        /* Check to make sure the packet is valid (RFC1812) */
@@ -967,28 +967,28 @@ simple_ipv4_fwd_8pkts(struct rte_mbuf *m[8], uint16_t portid)
 #endif /* End of #ifdef DO_RFC_1812_CHECKS */
 
        data[0] = _mm_loadu_si128(rte_pktmbuf_mtod_offset(m[0], __m128i *,
-                       sizeof(struct ether_hdr) +
+                       sizeof(struct rte_ether_hdr) +
                        offsetof(struct ipv4_hdr, time_to_live)));
        data[1] = _mm_loadu_si128(rte_pktmbuf_mtod_offset(m[1], __m128i *,
-                       sizeof(struct ether_hdr) +
+                       sizeof(struct rte_ether_hdr) +
                        offsetof(struct ipv4_hdr, time_to_live)));
        data[2] = _mm_loadu_si128(rte_pktmbuf_mtod_offset(m[2], __m128i *,
-                       sizeof(struct ether_hdr) +
+                       sizeof(struct rte_ether_hdr) +
                        offsetof(struct ipv4_hdr, time_to_live)));
        data[3] = _mm_loadu_si128(rte_pktmbuf_mtod_offset(m[3], __m128i *,
-                       sizeof(struct ether_hdr) +
+                       sizeof(struct rte_ether_hdr) +
                        offsetof(struct ipv4_hdr, time_to_live)));
        data[4] = _mm_loadu_si128(rte_pktmbuf_mtod_offset(m[4], __m128i *,
-                       sizeof(struct ether_hdr) +
+                       sizeof(struct rte_ether_hdr) +
                        offsetof(struct ipv4_hdr, time_to_live)));
        data[5] = _mm_loadu_si128(rte_pktmbuf_mtod_offset(m[5], __m128i *,
-                       sizeof(struct ether_hdr) +
+                       sizeof(struct rte_ether_hdr) +
                        offsetof(struct ipv4_hdr, time_to_live)));
        data[6] = _mm_loadu_si128(rte_pktmbuf_mtod_offset(m[6], __m128i *,
-                       sizeof(struct ether_hdr) +
+                       sizeof(struct rte_ether_hdr) +
                        offsetof(struct ipv4_hdr, time_to_live)));
        data[7] = _mm_loadu_si128(rte_pktmbuf_mtod_offset(m[7], __m128i *,
-                       sizeof(struct ether_hdr) +
+                       sizeof(struct rte_ether_hdr) +
                        offsetof(struct ipv4_hdr, time_to_live)));
 
        key[0].xmm = _mm_and_si128(data[0], mask0);
@@ -1094,13 +1094,13 @@ static inline void get_ipv6_5tuple(struct rte_mbuf *m0, __m128i mask0,
                __m128i mask1, union ipv6_5tuple_host *key)
 {
        __m128i tmpdata0 = _mm_loadu_si128(rte_pktmbuf_mtod_offset(m0,
-                       __m128i *, sizeof(struct ether_hdr) +
+                       __m128i *, sizeof(struct rte_ether_hdr) +
                        offsetof(struct ipv6_hdr, payload_len)));
        __m128i tmpdata1 = _mm_loadu_si128(rte_pktmbuf_mtod_offset(m0,
-                       __m128i *, sizeof(struct ether_hdr) +
+                       __m128i *, sizeof(struct rte_ether_hdr) +
                        offsetof(struct ipv6_hdr, payload_len) + sizeof(__m128i)));
        __m128i tmpdata2 = _mm_loadu_si128(rte_pktmbuf_mtod_offset(m0,
-                       __m128i *, sizeof(struct ether_hdr) +
+                       __m128i *, sizeof(struct rte_ether_hdr) +
                        offsetof(struct ipv6_hdr, payload_len) + sizeof(__m128i) +
                        sizeof(__m128i)));
        key->xmm[0] = _mm_and_si128(tmpdata0, mask0);
@@ -1113,37 +1113,37 @@ simple_ipv6_fwd_8pkts(struct rte_mbuf *m[8], uint16_t portid)
 {
        int32_t ret[8];
        uint16_t dst_port[8];
-       struct ether_hdr *eth_hdr[8];
+       struct rte_ether_hdr *eth_hdr[8];
        union ipv6_5tuple_host key[8];
 
        __attribute__((unused)) struct ipv6_hdr *ipv6_hdr[8];
 
-       eth_hdr[0] = rte_pktmbuf_mtod(m[0], struct ether_hdr *);
-       eth_hdr[1] = rte_pktmbuf_mtod(m[1], struct ether_hdr *);
-       eth_hdr[2] = rte_pktmbuf_mtod(m[2], struct ether_hdr *);
-       eth_hdr[3] = rte_pktmbuf_mtod(m[3], struct ether_hdr *);
-       eth_hdr[4] = rte_pktmbuf_mtod(m[4], struct ether_hdr *);
-       eth_hdr[5] = rte_pktmbuf_mtod(m[5], struct ether_hdr *);
-       eth_hdr[6] = rte_pktmbuf_mtod(m[6], struct ether_hdr *);
-       eth_hdr[7] = rte_pktmbuf_mtod(m[7], struct ether_hdr *);
+       eth_hdr[0] = rte_pktmbuf_mtod(m[0], struct rte_ether_hdr *);
+       eth_hdr[1] = rte_pktmbuf_mtod(m[1], struct rte_ether_hdr *);
+       eth_hdr[2] = rte_pktmbuf_mtod(m[2], struct rte_ether_hdr *);
+       eth_hdr[3] = rte_pktmbuf_mtod(m[3], struct rte_ether_hdr *);
+       eth_hdr[4] = rte_pktmbuf_mtod(m[4], struct rte_ether_hdr *);
+       eth_hdr[5] = rte_pktmbuf_mtod(m[5], struct rte_ether_hdr *);
+       eth_hdr[6] = rte_pktmbuf_mtod(m[6], struct rte_ether_hdr *);
+       eth_hdr[7] = rte_pktmbuf_mtod(m[7], struct rte_ether_hdr *);
 
        /* Handle IPv6 headers.*/
        ipv6_hdr[0] = rte_pktmbuf_mtod_offset(m[0], struct ipv6_hdr *,
-                       sizeof(struct ether_hdr));
+                       sizeof(struct rte_ether_hdr));
        ipv6_hdr[1] = rte_pktmbuf_mtod_offset(m[1], struct ipv6_hdr *,
-                       sizeof(struct ether_hdr));
+                       sizeof(struct rte_ether_hdr));
        ipv6_hdr[2] = rte_pktmbuf_mtod_offset(m[2], struct ipv6_hdr *,
-                       sizeof(struct ether_hdr));
+                       sizeof(struct rte_ether_hdr));
        ipv6_hdr[3] = rte_pktmbuf_mtod_offset(m[3], struct ipv6_hdr *,
-                       sizeof(struct ether_hdr));
+                       sizeof(struct rte_ether_hdr));
        ipv6_hdr[4] = rte_pktmbuf_mtod_offset(m[4], struct ipv6_hdr *,
-                       sizeof(struct ether_hdr));
+                       sizeof(struct rte_ether_hdr));
        ipv6_hdr[5] = rte_pktmbuf_mtod_offset(m[5], struct ipv6_hdr *,
-                       sizeof(struct ether_hdr));
+                       sizeof(struct rte_ether_hdr));
        ipv6_hdr[6] = rte_pktmbuf_mtod_offset(m[6], struct ipv6_hdr *,
-                       sizeof(struct ether_hdr));
+                       sizeof(struct rte_ether_hdr));
        ipv6_hdr[7] = rte_pktmbuf_mtod_offset(m[7], struct ipv6_hdr *,
-                       sizeof(struct ether_hdr));
+                       sizeof(struct rte_ether_hdr));
 
        get_ipv6_5tuple(m[0], mask1, mask2, &key[0]);
        get_ipv6_5tuple(m[1], mask1, mask2, &key[1]);
@@ -1228,16 +1228,16 @@ simple_ipv6_fwd_8pkts(struct rte_mbuf *m[8], uint16_t portid)
 static __rte_always_inline void
 l3fwd_simple_forward(struct rte_mbuf *m, uint16_t portid)
 {
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        struct ipv4_hdr *ipv4_hdr;
        uint16_t dst_port;
 
-       eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        if (RTE_ETH_IS_IPV4_HDR(m->packet_type)) {
                /* Handle IPv4 headers.*/
                ipv4_hdr = rte_pktmbuf_mtod_offset(m, struct ipv4_hdr *,
-                               sizeof(struct ether_hdr));
+                               sizeof(struct rte_ether_hdr));
 
 #ifdef DO_RFC_1812_CHECKS
                /* Check to make sure the packet is valid (RFC1812) */
@@ -1270,7 +1270,7 @@ l3fwd_simple_forward(struct rte_mbuf *m, uint16_t portid)
                struct ipv6_hdr *ipv6_hdr;
 
                ipv6_hdr = rte_pktmbuf_mtod_offset(m, struct ipv6_hdr *,
-                               sizeof(struct ether_hdr));
+                               sizeof(struct rte_ether_hdr));
 
                dst_port = get_ipv6_dst_port(ipv6_hdr, portid,
                                RTE_PER_LCORE(lcore_conf)->ipv6_lookup_struct);
@@ -1346,7 +1346,7 @@ get_dst_port(struct rte_mbuf *pkt, uint32_t dst_ipv4, uint16_t portid)
 {
        uint32_t next_hop;
        struct ipv6_hdr *ipv6_hdr;
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
 
        if (RTE_ETH_IS_IPV4_HDR(pkt->packet_type)) {
                return (uint16_t) ((rte_lpm_lookup(
@@ -1355,7 +1355,7 @@ get_dst_port(struct rte_mbuf *pkt, uint32_t dst_ipv4, uint16_t portid)
 
        } else if (RTE_ETH_IS_IPV6_HDR(pkt->packet_type)) {
 
-               eth_hdr = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+               eth_hdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
                ipv6_hdr = (struct ipv6_hdr *)(eth_hdr + 1);
 
                return (uint16_t) ((rte_lpm6_lookup(
@@ -1371,13 +1371,13 @@ get_dst_port(struct rte_mbuf *pkt, uint32_t dst_ipv4, uint16_t portid)
 static inline void
 process_packet(struct rte_mbuf *pkt, uint16_t *dst_port, uint16_t portid)
 {
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        struct ipv4_hdr *ipv4_hdr;
        uint32_t dst_ipv4;
        uint16_t dp;
        __m128i te, ve;
 
-       eth_hdr = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
        ipv4_hdr = (struct ipv4_hdr *)(eth_hdr + 1);
 
        dst_ipv4 = ipv4_hdr->dst_addr;
@@ -1403,25 +1403,25 @@ processx4_step1(struct rte_mbuf *pkt[FWDSTEP],
                uint32_t *ipv4_flag)
 {
        struct ipv4_hdr *ipv4_hdr;
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        uint32_t x0, x1, x2, x3;
 
-       eth_hdr = rte_pktmbuf_mtod(pkt[0], struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(pkt[0], struct rte_ether_hdr *);
        ipv4_hdr = (struct ipv4_hdr *)(eth_hdr + 1);
        x0 = ipv4_hdr->dst_addr;
        ipv4_flag[0] = pkt[0]->packet_type & RTE_PTYPE_L3_IPV4;
 
-       eth_hdr = rte_pktmbuf_mtod(pkt[1], struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(pkt[1], struct rte_ether_hdr *);
        ipv4_hdr = (struct ipv4_hdr *)(eth_hdr + 1);
        x1 = ipv4_hdr->dst_addr;
        ipv4_flag[0] &= pkt[1]->packet_type;
 
-       eth_hdr = rte_pktmbuf_mtod(pkt[2], struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(pkt[2], struct rte_ether_hdr *);
        ipv4_hdr = (struct ipv4_hdr *)(eth_hdr + 1);
        x2 = ipv4_hdr->dst_addr;
        ipv4_flag[0] &= pkt[2]->packet_type;
 
-       eth_hdr = rte_pktmbuf_mtod(pkt[3], struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(pkt[3], struct rte_ether_hdr *);
        ipv4_hdr = (struct ipv4_hdr *)(eth_hdr + 1);
        x3 = ipv4_hdr->dst_addr;
        ipv4_flag[0] &= pkt[3]->packet_type;
@@ -1503,13 +1503,13 @@ processx4_step3(struct rte_mbuf *pkt[FWDSTEP], uint16_t dst_port[FWDSTEP])
        _mm_store_si128(p[2], te[2]);
        _mm_store_si128(p[3], te[3]);
 
-       rfc1812_process((struct ipv4_hdr *)((struct ether_hdr *)p[0] + 1),
+       rfc1812_process((struct ipv4_hdr *)((struct rte_ether_hdr *)p[0] + 1),
                        &dst_port[0], pkt[0]->packet_type);
-       rfc1812_process((struct ipv4_hdr *)((struct ether_hdr *)p[1] + 1),
+       rfc1812_process((struct ipv4_hdr *)((struct rte_ether_hdr *)p[1] + 1),
                        &dst_port[1], pkt[1]->packet_type);
-       rfc1812_process((struct ipv4_hdr *)((struct ether_hdr *)p[2] + 1),
+       rfc1812_process((struct ipv4_hdr *)((struct rte_ether_hdr *)p[2] + 1),
                        &dst_port[2], pkt[2]->packet_type);
-       rfc1812_process((struct ipv4_hdr *)((struct ether_hdr *)p[3] + 1),
+       rfc1812_process((struct ipv4_hdr *)((struct rte_ether_hdr *)p[3] + 1),
                        &dst_port[3], pkt[3]->packet_type);
 }
 
@@ -3020,7 +3020,7 @@ parse_args(int argc, char **argv)
 }
 
 static void
-print_ethaddr(const char *name, const struct ether_addr *eth_addr)
+print_ethaddr(const char *name, const struct rte_ether_addr *eth_addr)
 {
        char buf[ETHER_ADDR_FMT_SIZE];
 
@@ -3576,14 +3576,14 @@ main(int argc, char **argv)
                print_ethaddr(" Address:", &ports_eth_addr[portid]);
                printf(", ");
                print_ethaddr("Destination:",
-                       (const struct ether_addr *)&dest_eth_addr[portid]);
+                       (const struct rte_ether_addr *)&dest_eth_addr[portid]);
                printf(", ");
 
                /*
                 * prepare src MACs for each port.
                 */
                ether_addr_copy(&ports_eth_addr[portid],
-                       (struct ether_addr *)(val_eth + portid) + 1);
+                       (struct rte_ether_addr *)(val_eth + portid) + 1);
 
                /* init memory */
                ret = init_mem(NB_MBUF);
index 82ae71c..7d28f59 100644 (file)
@@ -53,7 +53,7 @@ static const struct rte_eth_conf port_conf_default = {
        },
 };
 
-static const struct ether_addr ether_multicast = {
+static const struct rte_ether_addr ether_multicast = {
        .addr_bytes = {0x01, 0x1b, 0x19, 0x0, 0x0, 0x0}
 };
 
@@ -334,7 +334,7 @@ parse_sync(struct ptpv2_data_slave_ordinary *ptp_data, uint16_t rx_tstamp_idx)
        struct ptp_header *ptp_hdr;
 
        ptp_hdr = (struct ptp_header *)(rte_pktmbuf_mtod(ptp_data->m, char *)
-                       + sizeof(struct ether_hdr));
+                       + sizeof(struct rte_ether_hdr));
        ptp_data->seqID_SYNC = rte_be_to_cpu_16(ptp_hdr->seq_id);
 
        if (ptp_data->ptpset == 0) {
@@ -361,20 +361,20 @@ parse_sync(struct ptpv2_data_slave_ordinary *ptp_data, uint16_t rx_tstamp_idx)
 static void
 parse_fup(struct ptpv2_data_slave_ordinary *ptp_data)
 {
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        struct ptp_header *ptp_hdr;
        struct clock_id *client_clkid;
        struct ptp_message *ptp_msg;
        struct rte_mbuf *created_pkt;
        struct tstamp *origin_tstamp;
-       struct ether_addr eth_multicast = ether_multicast;
+       struct rte_ether_addr eth_multicast = ether_multicast;
        size_t pkt_size;
        int wait_us;
        struct rte_mbuf *m = ptp_data->m;
 
-       eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
        ptp_hdr = (struct ptp_header *)(rte_pktmbuf_mtod(m, char *)
-                       + sizeof(struct ether_hdr));
+                       + sizeof(struct rte_ether_hdr));
        if (memcmp(&ptp_data->master_clock_id,
                        &ptp_hdr->source_port_id.clock_id,
                        sizeof(struct clock_id)) != 0)
@@ -382,7 +382,7 @@ parse_fup(struct ptpv2_data_slave_ordinary *ptp_data)
 
        ptp_data->seqID_FOLLOWUP = rte_be_to_cpu_16(ptp_hdr->seq_id);
        ptp_msg = (struct ptp_message *) (rte_pktmbuf_mtod(m, char *) +
-                                         sizeof(struct ether_hdr));
+                                         sizeof(struct rte_ether_hdr));
 
        origin_tstamp = &ptp_msg->follow_up.precise_origin_tstamp;
        ptp_data->tstamp1.tv_nsec = ntohl(origin_tstamp->ns);
@@ -393,11 +393,11 @@ parse_fup(struct ptpv2_data_slave_ordinary *ptp_data)
        if (ptp_data->seqID_FOLLOWUP == ptp_data->seqID_SYNC) {
 
                created_pkt = rte_pktmbuf_alloc(mbuf_pool);
-               pkt_size = sizeof(struct ether_hdr) +
+               pkt_size = sizeof(struct rte_ether_hdr) +
                        sizeof(struct ptp_message);
                created_pkt->data_len = pkt_size;
                created_pkt->pkt_len = pkt_size;
-               eth_hdr = rte_pktmbuf_mtod(created_pkt, struct ether_hdr *);
+               eth_hdr = rte_pktmbuf_mtod(created_pkt, struct rte_ether_hdr *);
                rte_eth_macaddr_get(ptp_data->portid, &eth_hdr->s_addr);
 
                /* Set multicast address 01-1B-19-00-00-00. */
@@ -406,7 +406,7 @@ parse_fup(struct ptpv2_data_slave_ordinary *ptp_data)
                eth_hdr->ether_type = htons(PTP_PROTOCOL);
                ptp_msg = (struct ptp_message *)
                        (rte_pktmbuf_mtod(created_pkt, char *) +
-                       sizeof(struct ether_hdr));
+                       sizeof(struct rte_ether_hdr));
 
                ptp_msg->delay_req.hdr.seq_id = htons(ptp_data->seqID_SYNC);
                ptp_msg->delay_req.hdr.msg_type = DELAY_REQ;
@@ -499,7 +499,7 @@ parse_drsp(struct ptpv2_data_slave_ordinary *ptp_data)
        uint16_t seq_id;
 
        ptp_msg = (struct ptp_message *) (rte_pktmbuf_mtod(m, char *) +
-                                       sizeof(struct ether_hdr));
+                                       sizeof(struct rte_ether_hdr));
        seq_id = rte_be_to_cpu_16(ptp_msg->delay_resp.hdr.seq_id);
        if (memcmp(&ptp_data->client_clock_id,
                   &ptp_msg->delay_resp.req_port_id.clock_id,
@@ -535,17 +535,17 @@ parse_drsp(struct ptpv2_data_slave_ordinary *ptp_data)
 static void
 parse_ptp_frames(uint16_t portid, struct rte_mbuf *m) {
        struct ptp_header *ptp_hdr;
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        uint16_t eth_type;
 
-       eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
        eth_type = rte_be_to_cpu_16(eth_hdr->ether_type);
 
        if (eth_type == PTP_PROTOCOL) {
                ptp_data.m = m;
                ptp_data.portid = portid;
                ptp_hdr = (struct ptp_header *)(rte_pktmbuf_mtod(m, char *)
-                                       + sizeof(struct ether_hdr));
+                                       + sizeof(struct rte_ether_hdr));
 
                switch (ptp_hdr->msg_type) {
                case SYNC:
index 9b01124..9f3344b 100644 (file)
@@ -145,7 +145,7 @@ app_pkt_handle(struct rte_mbuf *pkt, uint64_t time)
 {
        uint8_t input_color, output_color;
        uint8_t *pkt_data = rte_pktmbuf_mtod(pkt, uint8_t *);
-       uint32_t pkt_len = rte_pktmbuf_pkt_len(pkt) - sizeof(struct ether_hdr);
+       uint32_t pkt_len = rte_pktmbuf_pkt_len(pkt) - sizeof(struct rte_ether_hdr);
        uint8_t flow_id = (uint8_t)(pkt_data[APP_PKT_FLOW_POS] & (APP_FLOWS_MAX - 1));
        input_color = pkt_data[APP_PKT_COLOR_POS];
        enum policer_action action;
index c55d387..61e92a8 100644 (file)
@@ -50,8 +50,8 @@ static void send_pause_frame(uint16_t port_id, uint16_t duration)
 {
        struct rte_mbuf *mbuf;
        struct ether_fc_frame *pause_frame;
-       struct ether_hdr *hdr;
-       struct ether_addr mac_addr;
+       struct rte_ether_hdr *hdr;
+       struct rte_ether_addr mac_addr;
 
        RTE_LOG_DP(DEBUG, USER1,
                        "Sending PAUSE frame (duration=%d) on port %d\n",
@@ -63,7 +63,7 @@ static void send_pause_frame(uint16_t port_id, uint16_t duration)
                return;
 
        /* Prepare a PAUSE frame */
-       hdr = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+       hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
        pause_frame = (struct ether_fc_frame *) &hdr[1];
 
        rte_eth_macaddr_get(port_id, &mac_addr);
index 2058be6..a277519 100644 (file)
@@ -115,7 +115,7 @@ port_init(uint16_t port, struct rte_mempool *mbuf_pool)
        if (retval < 0)
                return retval;
 
-       struct ether_addr addr;
+       struct rte_ether_addr addr;
 
        rte_eth_macaddr_get(port, &addr);
        printf("Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8
index 3b97fbd..8bec351 100644 (file)
@@ -275,7 +275,7 @@ handle_packets(struct rte_hash *h, struct rte_mbuf **bufs, uint16_t num_packets)
        for (i = 0; i < num_packets; i++) {
                /* Handle IPv4 header.*/
                ipv4_hdr = rte_pktmbuf_mtod_offset(bufs[i], struct ipv4_hdr *,
-                               sizeof(struct ether_hdr));
+                               sizeof(struct rte_ether_hdr));
                ipv4_dst_ip[i] = ipv4_hdr->dst_addr;
                key_ptrs[i] = &ipv4_dst_ip[i];
        }
index 404f1f1..a086c5a 100644 (file)
@@ -68,7 +68,7 @@ get_printable_mac_addr(uint16_t port)
 {
        static const char err_address[] = "00:00:00:00:00:00";
        static char addresses[RTE_MAX_ETHPORTS][sizeof(err_address)];
-       struct ether_addr mac;
+       struct rte_ether_addr mac;
 
        if (unlikely(port >= RTE_MAX_ETHPORTS))
                return err_address;
@@ -253,7 +253,7 @@ process_packets(uint32_t port_num __rte_unused, struct rte_mbuf *pkts[],
        for (i = 0; i < rx_count; i++) {
                /* Handle IPv4 header.*/
                ipv4_hdr = rte_pktmbuf_mtod_offset(pkts[i], struct ipv4_hdr *,
-                               sizeof(struct ether_hdr));
+                               sizeof(struct rte_ether_hdr));
                ipv4_dst_ip[i] = ipv4_hdr->dst_addr;
                key_ptrs[i] = (void *)&ipv4_dst_ip[i];
        }
index 4aba1dc..7e3cd87 100644 (file)
@@ -82,7 +82,7 @@ port_init(uint16_t port, struct rte_mempool *mbuf_pool)
                return retval;
 
        /* Display the port MAC address. */
-       struct ether_addr addr;
+       struct rte_ether_addr addr;
        rte_eth_macaddr_get(port, &addr);
        printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8
                           " %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\n",
index 7795d08..64d687c 100644 (file)
@@ -160,7 +160,7 @@ uint16_t ports[RTE_MAX_ETHPORTS];
 static unsigned nb_ports; /**< The number of ports specified in command line */
 
 /* ethernet addresses of ports */
-struct ether_addr ports_eth_addr[RTE_MAX_ETHPORTS];
+struct rte_ether_addr ports_eth_addr[RTE_MAX_ETHPORTS];
 
 /* heads for the main used and free linked lists for the data path. */
 static struct virtio_net_data_ll *ll_root_used;
index 966c63a..7a70f73 100644 (file)
@@ -50,7 +50,7 @@ struct vhost_dev {
        /**< Memory region information for gpa to hpa translation. */
        struct virtio_memory_regions_hpa *regions_hpa;
        /**< Device MAC address (Obtained on first TX packet). */
-       struct ether_addr mac_address;
+       struct rte_ether_addr mac_address;
        /**< RX queue number. */
        uint16_t rx_q;
        /**< Data core that the device is added to. */
index 7732821..ed2a405 100644 (file)
@@ -28,19 +28,19 @@ get_psd_sum(void *l3_hdr, uint16_t ethertype, uint64_t ol_flags)
  * header.
  */
 static void
-parse_ethernet(struct ether_hdr *eth_hdr, union tunnel_offload_info *info,
+parse_ethernet(struct rte_ether_hdr *eth_hdr, union tunnel_offload_info *info,
                uint8_t *l4_proto)
 {
        struct ipv4_hdr *ipv4_hdr;
        struct ipv6_hdr *ipv6_hdr;
        uint16_t ethertype;
 
-       info->outer_l2_len = sizeof(struct ether_hdr);
+       info->outer_l2_len = sizeof(struct rte_ether_hdr);
        ethertype = rte_be_to_cpu_16(eth_hdr->ether_type);
 
        if (ethertype == ETHER_TYPE_VLAN) {
-               struct vlan_hdr *vlan_hdr = (struct vlan_hdr *)(eth_hdr + 1);
-               info->outer_l2_len  += sizeof(struct vlan_hdr);
+               struct rte_vlan_hdr *vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+               info->outer_l2_len  += sizeof(struct rte_vlan_hdr);
                ethertype = rte_be_to_cpu_16(vlan_hdr->eth_proto);
        }
 
@@ -68,7 +68,7 @@ parse_ethernet(struct ether_hdr *eth_hdr, union tunnel_offload_info *info,
  * Calculate the checksum of a packet in hardware
  */
 static uint64_t
-process_inner_cksums(struct ether_hdr *eth_hdr, union tunnel_offload_info *info)
+process_inner_cksums(struct rte_ether_hdr *eth_hdr, union tunnel_offload_info *info)
 {
        void *l3_hdr = NULL;
        uint8_t l4_proto;
@@ -80,12 +80,12 @@ process_inner_cksums(struct ether_hdr *eth_hdr, union tunnel_offload_info *info)
        struct sctp_hdr *sctp_hdr;
        uint64_t ol_flags = 0;
 
-       info->l2_len = sizeof(struct ether_hdr);
+       info->l2_len = sizeof(struct rte_ether_hdr);
        ethertype = rte_be_to_cpu_16(eth_hdr->ether_type);
 
        if (ethertype == ETHER_TYPE_VLAN) {
-               struct vlan_hdr *vlan_hdr = (struct vlan_hdr *)(eth_hdr + 1);
-               info->l2_len  += sizeof(struct vlan_hdr);
+               struct rte_vlan_hdr *vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+               info->l2_len  += sizeof(struct rte_vlan_hdr);
                ethertype = rte_be_to_cpu_16(vlan_hdr->eth_proto);
        }
 
@@ -141,7 +141,7 @@ decapsulation(struct rte_mbuf *pkt)
        uint16_t outer_header_len;
        struct udp_hdr *udp_hdr;
        union tunnel_offload_info info = { .data = 0 };
-       struct ether_hdr *phdr = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+       struct rte_ether_hdr *phdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
 
        parse_ethernet(phdr, &info, &l4_proto);
 
@@ -158,7 +158,7 @@ decapsulation(struct rte_mbuf *pkt)
                (pkt->packet_type & RTE_PTYPE_TUNNEL_MASK) == 0)
                return -1;
        outer_header_len = info.outer_l2_len + info.outer_l3_len
-               + sizeof(struct udp_hdr) + sizeof(struct vxlan_hdr);
+               + sizeof(struct udp_hdr) + sizeof(struct rte_vxlan_hdr);
 
        rte_pktmbuf_adj(pkt, outer_header_len);
 
@@ -172,29 +172,29 @@ encapsulation(struct rte_mbuf *m, uint8_t queue_id)
        uint64_t ol_flags = 0;
        uint32_t old_len = m->pkt_len, hash;
        union tunnel_offload_info tx_offload = { .data = 0 };
-       struct ether_hdr *phdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       struct rte_ether_hdr *phdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        /*Allocate space for new ethernet, IPv4, UDP and VXLAN headers*/
-       struct ether_hdr *pneth = (struct ether_hdr *) rte_pktmbuf_prepend(m,
-               sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr)
-               + sizeof(struct udp_hdr) + sizeof(struct vxlan_hdr));
+       struct rte_ether_hdr *pneth = (struct rte_ether_hdr *) rte_pktmbuf_prepend(m,
+               sizeof(struct rte_ether_hdr) + sizeof(struct ipv4_hdr)
+               + sizeof(struct udp_hdr) + sizeof(struct rte_vxlan_hdr));
 
        struct ipv4_hdr *ip = (struct ipv4_hdr *) &pneth[1];
        struct udp_hdr *udp = (struct udp_hdr *) &ip[1];
-       struct vxlan_hdr *vxlan = (struct vxlan_hdr *) &udp[1];
+       struct rte_vxlan_hdr *vxlan = (struct rte_vxlan_hdr *) &udp[1];
 
        /* convert TX queue ID to vport ID */
        vport_id = queue_id - 1;
 
        /* replace original Ethernet header with ours */
        pneth = rte_memcpy(pneth, &app_l2_hdr[vport_id],
-               sizeof(struct ether_hdr));
+               sizeof(struct rte_ether_hdr));
 
        /* copy in IP header */
        ip = rte_memcpy(ip, &app_ip_hdr[vport_id],
                sizeof(struct ipv4_hdr));
        ip->total_length = rte_cpu_to_be_16(m->pkt_len
-                               - sizeof(struct ether_hdr));
+                               - sizeof(struct rte_ether_hdr));
 
        /* outer IP checksum */
        ol_flags |= PKT_TX_OUTER_IP_CKSUM;
@@ -209,7 +209,7 @@ encapsulation(struct rte_mbuf *m, uint8_t queue_id)
                m->l2_len += ETHER_VXLAN_HLEN;
        }
 
-       m->outer_l2_len = sizeof(struct ether_hdr);
+       m->outer_l2_len = sizeof(struct rte_ether_hdr);
        m->outer_l3_len = sizeof(struct ipv4_hdr);
 
        ol_flags |= PKT_TX_TUNNEL_VXLAN;
@@ -225,7 +225,7 @@ encapsulation(struct rte_mbuf *m, uint8_t queue_id)
        udp->dgram_cksum = 0;
        udp->dgram_len = rte_cpu_to_be_16(old_len
                                + sizeof(struct udp_hdr)
-                               + sizeof(struct vxlan_hdr));
+                               + sizeof(struct rte_vxlan_hdr));
 
        udp->dst_port = rte_cpu_to_be_16(vxdev.dst_port);
        hash = rte_hash_crc(phdr, 2 * ETHER_ADDR_LEN, phdr->ether_type);
index bff786a..780ae73 100644 (file)
 #define DEFAULT_VXLAN_PORT 4789
 
 extern struct ipv4_hdr app_ip_hdr[VXLAN_N_PORTS];
-extern struct ether_hdr app_l2_hdr[VXLAN_N_PORTS];
+extern struct rte_ether_hdr app_l2_hdr[VXLAN_N_PORTS];
 extern uint8_t tx_checksum;
 extern uint16_t tso_segsz;
 
 struct vxlan_port {
        uint32_t vport_id;           /**< VirtIO port id */
        uint32_t peer_ip;            /**< remote VTEP IP address */
-       struct ether_addr peer_mac;  /**< remote VTEP MAC address */
-       struct ether_addr vport_mac; /**< VirtIO port MAC address */
+       struct rte_ether_addr peer_mac;  /**< remote VTEP MAC address */
+       struct rte_ether_addr vport_mac; /**< VirtIO port MAC address */
 } __rte_cache_aligned;
 
 struct vxlan_conf {
index ad7fbe9..e4af7bc 100644 (file)
@@ -49,7 +49,7 @@
 struct vxlan_conf vxdev;
 
 struct ipv4_hdr app_ip_hdr[VXLAN_N_PORTS];
-struct ether_hdr app_l2_hdr[VXLAN_N_PORTS];
+struct rte_ether_hdr app_l2_hdr[VXLAN_N_PORTS];
 
 /* local VTEP IP address */
 uint8_t vxlan_multicast_ips[2][4] = { {239, 1, 1, 1 }, {239, 1, 2, 1 } };
@@ -227,7 +227,7 @@ int
 vxlan_link(struct vhost_dev *vdev, struct rte_mbuf *m)
 {
        int i, ret;
-       struct ether_hdr *pkt_hdr;
+       struct rte_ether_hdr *pkt_hdr;
        uint64_t portid = vdev->vid;
        struct ipv4_hdr *ip;
 
@@ -242,7 +242,7 @@ vxlan_link(struct vhost_dev *vdev, struct rte_mbuf *m)
        }
 
        /* Learn MAC address of guest device from packet */
-       pkt_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       pkt_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
        if (is_same_ether_addr(&(pkt_hdr->s_addr), &vdev->mac_address)) {
                RTE_LOG(INFO, VHOST_DATA,
                        "(%d) WARNING: This device is using an existing"
index 2c20e2e..4dc37d6 100644 (file)
@@ -9,7 +9,7 @@ extern uint16_t nb_devices;
 extern uint16_t udp_port;
 extern uint8_t filter_idx;
 extern uint16_t ports[RTE_MAX_ETHPORTS];
-extern struct ether_addr ports_eth_addr[RTE_MAX_ETHPORTS];
+extern struct rte_ether_addr ports_eth_addr[RTE_MAX_ETHPORTS];
 extern uint32_t enable_stats;
 extern struct device_statistics dev_statistics[MAX_DEVICES];
 extern uint8_t rx_decap;
index dc9ea10..bea6b97 100644 (file)
@@ -164,7 +164,7 @@ const uint16_t vlan_tags[] = {
 };
 
 /* ethernet addresses of ports */
-static struct ether_addr vmdq_ports_eth_addr[RTE_MAX_ETHPORTS];
+static struct rte_ether_addr vmdq_ports_eth_addr[RTE_MAX_ETHPORTS];
 
 static struct vhost_dev_tailq_list vhost_dev_list =
        TAILQ_HEAD_INITIALIZER(vhost_dev_list);
@@ -674,7 +674,7 @@ static unsigned check_ports_num(unsigned nb_ports)
 }
 
 static __rte_always_inline struct vhost_dev *
-find_vhost_dev(struct ether_addr *mac)
+find_vhost_dev(struct rte_ether_addr *mac)
 {
        struct vhost_dev *vdev;
 
@@ -694,11 +694,11 @@ find_vhost_dev(struct ether_addr *mac)
 static int
 link_vmdq(struct vhost_dev *vdev, struct rte_mbuf *m)
 {
-       struct ether_hdr *pkt_hdr;
+       struct rte_ether_hdr *pkt_hdr;
        int i, ret;
 
        /* Learn MAC address of guest device from packet */
-       pkt_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       pkt_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        if (find_vhost_dev(&pkt_hdr->s_addr)) {
                RTE_LOG(ERR, VHOST_DATA,
@@ -800,10 +800,10 @@ virtio_xmit(struct vhost_dev *dst_vdev, struct vhost_dev *src_vdev,
 static __rte_always_inline int
 virtio_tx_local(struct vhost_dev *vdev, struct rte_mbuf *m)
 {
-       struct ether_hdr *pkt_hdr;
+       struct rte_ether_hdr *pkt_hdr;
        struct vhost_dev *dst_vdev;
 
-       pkt_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       pkt_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        dst_vdev = find_vhost_dev(&pkt_hdr->d_addr);
        if (!dst_vdev)
@@ -838,7 +838,7 @@ find_local_dest(struct vhost_dev *vdev, struct rte_mbuf *m,
        uint32_t *offset, uint16_t *vlan_tag)
 {
        struct vhost_dev *dst_vdev;
-       struct ether_hdr *pkt_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       struct rte_ether_hdr *pkt_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        dst_vdev = find_vhost_dev(&pkt_hdr->d_addr);
        if (!dst_vdev)
@@ -880,7 +880,7 @@ static void virtio_tx_offload(struct rte_mbuf *m)
        void *l3_hdr;
        struct ipv4_hdr *ipv4_hdr = NULL;
        struct tcp_hdr *tcp_hdr = NULL;
-       struct ether_hdr *eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       struct rte_ether_hdr *eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        l3_hdr = (char *)eth_hdr + m->l2_len;
 
@@ -924,10 +924,10 @@ virtio_tx_route(struct vhost_dev *vdev, struct rte_mbuf *m, uint16_t vlan_tag)
        struct mbuf_table *tx_q;
        unsigned offset = 0;
        const uint16_t lcore_id = rte_lcore_id();
-       struct ether_hdr *nh;
+       struct rte_ether_hdr *nh;
 
 
-       nh = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       nh = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
        if (unlikely(is_broadcast_ether_addr(&nh->d_addr))) {
                struct vhost_dev *vdev2;
 
@@ -960,10 +960,10 @@ queue2nic:
        /*Add packet to the port tx queue*/
        tx_q = &lcore_tx_queue[lcore_id];
 
-       nh = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       nh = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
        if (unlikely(nh->ether_type == rte_cpu_to_be_16(ETHER_TYPE_VLAN))) {
                /* Guest has inserted the vlan tag. */
-               struct vlan_hdr *vh = (struct vlan_hdr *) (nh + 1);
+               struct rte_vlan_hdr *vh = (struct rte_vlan_hdr *) (nh + 1);
                uint16_t vlan_tag_be = rte_cpu_to_be_16(vlan_tag);
                if ((vm2vm_mode == VM2VM_HARDWARE) &&
                        (vh->vlan_tci != vlan_tag_be))
index 764c33a..7cba0ed 100644 (file)
@@ -35,7 +35,7 @@ struct vhost_dev {
        /**< Number of memory regions for gpa to hpa translation. */
        uint32_t nregions_hpa;
        /**< Device MAC address (Obtained on first TX packet). */
-       struct ether_addr mac_address;
+       struct rte_ether_addr mac_address;
        /**< RX VMDQ queue number. */
        uint16_t vmdq_rx_q;
        /**< Vlan tag assigned to the pool */
index 7fa47ba..d3713db 100644 (file)
@@ -135,7 +135,7 @@ get_pfid(struct policy *pol)
 
                RTE_ETH_FOREACH_DEV(x) {
                        ret = rte_pmd_i40e_query_vfid_by_mac(x,
-                               (struct ether_addr *)&(pol->pkt.vfid[i]));
+                               (struct rte_ether_addr *)&(pol->pkt.vfid[i]));
                        if (ret != -EINVAL) {
                                pol->port[i] = x;
                                break;
index 0db1b80..f359ba0 100644 (file)
@@ -34,7 +34,7 @@ struct cmd_quit_result {
 };
 
 union PFID {
-       struct ether_addr addr;
+       struct rte_ether_addr addr;
        uint64_t pfid;
 };
 
index 58c5fa4..cfbb991 100644 (file)
@@ -99,7 +99,7 @@ port_init(uint16_t port, struct rte_mempool *mbuf_pool)
                return retval;
 
        /* Display the port MAC address. */
-       struct ether_addr addr;
+       struct rte_ether_addr addr;
        rte_eth_macaddr_get(port, &addr);
        printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8
                           " %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\n",
@@ -348,7 +348,7 @@ main(int argc, char **argv)
 
                /* Initialize ports. */
                RTE_ETH_FOREACH_DEV(portid) {
-                       struct ether_addr eth;
+                       struct rte_ether_addr eth;
                        int w, j;
                        int ret;
 
index 627a5da..5195a51 100644 (file)
@@ -106,12 +106,12 @@ const uint16_t num_vlans = RTE_DIM(vlan_tags);
 static uint16_t num_pf_queues,  num_vmdq_queues;
 static uint16_t vmdq_pool_base, vmdq_queue_base;
 /* pool mac addr template, pool mac addr is like: 52 54 00 12 port# pool# */
-static struct ether_addr pool_addr_template = {
+static struct rte_ether_addr pool_addr_template = {
        .addr_bytes = {0x52, 0x54, 0x00, 0x12, 0x00, 0x00}
 };
 
 /* ethernet addresses of ports */
-static struct ether_addr vmdq_ports_eth_addr[RTE_MAX_ETHPORTS];
+static struct rte_ether_addr vmdq_ports_eth_addr[RTE_MAX_ETHPORTS];
 
 #define MAX_QUEUE_NUM_10G 128
 #define MAX_QUEUE_NUM_1G 8
@@ -281,7 +281,7 @@ port_init(uint16_t port, struct rte_mempool *mbuf_pool)
         * Removes this after i40e fixes this issue.
         */
        for (q = 0; q < num_pools; q++) {
-               struct ether_addr mac;
+               struct rte_ether_addr mac;
                mac = pool_addr_template;
                mac.addr_bytes[4] = port;
                mac.addr_bytes[5] = q;
@@ -407,10 +407,10 @@ vmdq_parse_args(int argc, char **argv)
 static void
 update_mac_address(struct rte_mbuf *m, unsigned dst_port)
 {
-       struct ether_hdr *eth;
+       struct rte_ether_hdr *eth;
        void *tmp;
 
-       eth = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        /* 02:00:00:00:00:xx */
        tmp = &eth->d_addr.addr_bytes[0];
index 6463683..75cf31a 100644 (file)
@@ -121,12 +121,12 @@ const uint16_t vlan_tags[] = {
 
 const uint16_t num_vlans = RTE_DIM(vlan_tags);
 /* pool mac addr template, pool mac addr is like: 52 54 00 12 port# pool# */
-static struct ether_addr pool_addr_template = {
+static struct rte_ether_addr pool_addr_template = {
        .addr_bytes = {0x52, 0x54, 0x00, 0x12, 0x00, 0x00}
 };
 
 /* ethernet addresses of ports */
-static struct ether_addr vmdq_ports_eth_addr[RTE_MAX_ETHPORTS];
+static struct rte_ether_addr vmdq_ports_eth_addr[RTE_MAX_ETHPORTS];
 
 /* Builds up the correct configuration for vmdq+dcb based on the vlan tags array
  * given above, and the number of traffic classes available for use. */
@@ -332,7 +332,7 @@ port_init(uint16_t port, struct rte_mempool *mbuf_pool)
 
        /* Set mac for each pool.*/
        for (q = 0; q < num_pools; q++) {
-               struct ether_addr mac;
+               struct rte_ether_addr mac;
 
                mac = pool_addr_template;
                mac.addr_bytes[4] = port;
@@ -494,10 +494,10 @@ vmdq_parse_args(int argc, char **argv)
 static void
 update_mac_address(struct rte_mbuf *m, unsigned dst_port)
 {
-       struct ether_hdr *eth;
+       struct rte_ether_hdr *eth;
        void *tmp;
 
-       eth = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
        /* 02:00:00:00:00:xx */
        tmp = &eth->d_addr.addr_bytes[0];
index 24e0475..c9cf33f 100644 (file)
@@ -12,9 +12,9 @@
 #include <ctype.h>
 #include <string.h>
 #include <sys/types.h>
-#include <net/ethernet.h>
 
 #include <rte_string_fns.h>
+#include <rte_ether.h>
 
 #include "cmdline_parse.h"
 #include "cmdline_parse_etheraddr.h"
@@ -29,21 +29,15 @@ struct cmdline_token_ops cmdline_token_etheraddr_ops = {
 /* the format can be either XX:XX:XX:XX:XX:XX or XXXX:XXXX:XXXX */
 #define ETHER_ADDRSTRLENLONG 18
 #define ETHER_ADDRSTRLENSHORT 15
+#define ETHER_ADDR_LEN 6
 
-#ifdef __linux__
-#define ea_oct ether_addr_octet
-#else
-#define ea_oct octet
-#endif
-
-
-static struct ether_addr *
+static struct rte_ether_addr *
 my_ether_aton(const char *a)
 {
        int i;
        char *end;
        unsigned long o[ETHER_ADDR_LEN];
-       static struct ether_addr ether_addr;
+       static struct rte_ether_addr ether_addr;
 
        i = 0;
        do {
@@ -63,21 +57,21 @@ my_ether_aton(const char *a)
                while (i-- != 0) {
                        if (o[i] > UINT8_MAX)
                                return NULL;
-                       ether_addr.ea_oct[i] = (uint8_t)o[i];
+                       ether_addr.addr_bytes[i] = (uint8_t)o[i];
                }
        /* Support the format XXXX:XXXX:XXXX */
        } else if (i == ETHER_ADDR_LEN / 2) {
                while (i-- != 0) {
                        if (o[i] > UINT16_MAX)
                                return NULL;
-                       ether_addr.ea_oct[i * 2] = (uint8_t)(o[i] >> 8);
-                       ether_addr.ea_oct[i * 2 + 1] = (uint8_t)(o[i] & 0xff);
+                       ether_addr.addr_bytes[i * 2] = (uint8_t)(o[i] >> 8);
+                       ether_addr.addr_bytes[i * 2 + 1] = (uint8_t)(o[i] & 0xff);
                }
        /* unknown format */
        } else
                return NULL;
 
-       return (struct ether_addr *)&ether_addr;
+       return (struct rte_ether_addr *)&ether_addr;
 }
 
 int
@@ -86,9 +80,9 @@ cmdline_parse_etheraddr(__attribute__((unused)) cmdline_parse_token_hdr_t *tk,
 {
        unsigned int token_len = 0;
        char ether_str[ETHER_ADDRSTRLENLONG+1];
-       struct ether_addr *tmp;
+       struct rte_ether_addr *tmp;
 
-       if (res && ressize < sizeof(struct ether_addr))
+       if (res && ressize < sizeof(struct rte_ether_addr))
                return -1;
 
        if (!buf || ! *buf)
@@ -108,7 +102,7 @@ cmdline_parse_etheraddr(__attribute__((unused)) cmdline_parse_token_hdr_t *tk,
        if (tmp == NULL)
                return -1;
        if (res)
-               memcpy(res, tmp, sizeof(struct ether_addr));
+               memcpy(res, tmp, sizeof(struct rte_ether_addr));
        return token_len;
 }
 
index 5ea8ae2..821d971 100644 (file)
@@ -110,7 +110,7 @@ struct rte_eth_mac_filter {
        uint8_t is_vf; /**< 1 for VF, 0 for port dev */
        uint16_t dst_id; /**< VF ID, available when is_vf is 1*/
        enum rte_mac_filter_type filter_type; /**< MAC filter type */
-       struct ether_addr mac_addr;
+       struct rte_ether_addr mac_addr;
 };
 
 /**
@@ -126,7 +126,7 @@ struct rte_eth_mac_filter {
  * RTE_ETH_FILTER_DELETE and RTE_ETH_FILTER_GET operations.
  */
 struct rte_eth_ethertype_filter {
-       struct ether_addr mac_addr;   /**< Mac address to match. */
+       struct rte_ether_addr mac_addr;   /**< Mac address to match. */
        uint16_t ether_type;          /**< Ether type to match */
        uint16_t flags;               /**< Flags from RTE_ETHTYPE_FLAGS_* */
        uint16_t queue;               /**< Queue assigned to when match*/
@@ -265,8 +265,8 @@ enum rte_tunnel_iptype {
  * Tunneling Packet filter configuration.
  */
 struct rte_eth_tunnel_filter_conf {
-       struct ether_addr outer_mac;    /**< Outer MAC address to match. */
-       struct ether_addr inner_mac;    /**< Inner MAC address to match. */
+       struct rte_ether_addr outer_mac;    /**< Outer MAC address to match. */
+       struct rte_ether_addr inner_mac;    /**< Inner MAC address to match. */
        uint16_t inner_vlan;            /**< Inner VLAN to match. */
        enum rte_tunnel_iptype ip_type; /**< IP address type. */
        /** Outer destination IP address to match if ETH_TUNNEL_FILTER_OIP
@@ -473,7 +473,7 @@ struct rte_eth_sctpv6_flow {
  * A structure used to define the input for MAC VLAN flow
  */
 struct rte_eth_mac_vlan_flow {
-       struct ether_addr mac_addr;  /**< Mac address to match. */
+       struct rte_ether_addr mac_addr;  /**< Mac address to match. */
 };
 
 /**
@@ -493,7 +493,7 @@ struct rte_eth_tunnel_flow {
        enum rte_eth_fdir_tunnel_type tunnel_type; /**< Tunnel type to match. */
        /** Tunnel ID to match. TNI, VNI... in big endian. */
        uint32_t tunnel_id;
-       struct ether_addr mac_addr;                /**< Mac address to match. */
+       struct rte_ether_addr mac_addr;                /**< Mac address to match. */
 };
 
 /**
index 571f0e8..08e226c 100644 (file)
@@ -1235,7 +1235,7 @@ static void
 rte_eth_dev_mac_restore(struct rte_eth_dev *dev,
                        struct rte_eth_dev_info *dev_info)
 {
-       struct ether_addr *addr;
+       struct rte_ether_addr *addr;
        uint16_t i;
        uint32_t pool = 0;
        uint64_t pool_mask;
@@ -2468,7 +2468,7 @@ rte_eth_dev_get_supported_ptypes(uint16_t port_id, uint32_t ptype_mask,
 }
 
 void
-rte_eth_macaddr_get(uint16_t port_id, struct ether_addr *mac_addr)
+rte_eth_macaddr_get(uint16_t port_id, struct rte_ether_addr *mac_addr)
 {
        struct rte_eth_dev *dev;
 
@@ -2942,7 +2942,7 @@ rte_eth_led_off(uint16_t port_id)
  * an empty spot.
  */
 static int
-get_mac_addr_index(uint16_t port_id, const struct ether_addr *addr)
+get_mac_addr_index(uint16_t port_id, const struct rte_ether_addr *addr)
 {
        struct rte_eth_dev_info dev_info;
        struct rte_eth_dev *dev = &rte_eth_devices[port_id];
@@ -2958,10 +2958,10 @@ get_mac_addr_index(uint16_t port_id, const struct ether_addr *addr)
        return -1;
 }
 
-static const struct ether_addr null_mac_addr;
+static const struct rte_ether_addr null_mac_addr;
 
 int
-rte_eth_dev_mac_addr_add(uint16_t port_id, struct ether_addr *addr,
+rte_eth_dev_mac_addr_add(uint16_t port_id, struct rte_ether_addr *addr,
                        uint32_t pool)
 {
        struct rte_eth_dev *dev;
@@ -3014,7 +3014,7 @@ rte_eth_dev_mac_addr_add(uint16_t port_id, struct ether_addr *addr,
 }
 
 int
-rte_eth_dev_mac_addr_remove(uint16_t port_id, struct ether_addr *addr)
+rte_eth_dev_mac_addr_remove(uint16_t port_id, struct rte_ether_addr *addr)
 {
        struct rte_eth_dev *dev;
        int index;
@@ -3045,7 +3045,7 @@ rte_eth_dev_mac_addr_remove(uint16_t port_id, struct ether_addr *addr)
 }
 
 int
-rte_eth_dev_default_mac_addr_set(uint16_t port_id, struct ether_addr *addr)
+rte_eth_dev_default_mac_addr_set(uint16_t port_id, struct rte_ether_addr *addr)
 {
        struct rte_eth_dev *dev;
        int ret;
@@ -3074,7 +3074,7 @@ rte_eth_dev_default_mac_addr_set(uint16_t port_id, struct ether_addr *addr)
  * an empty spot.
  */
 static int
-get_hash_mac_addr_index(uint16_t port_id, const struct ether_addr *addr)
+get_hash_mac_addr_index(uint16_t port_id, const struct rte_ether_addr *addr)
 {
        struct rte_eth_dev_info dev_info;
        struct rte_eth_dev *dev = &rte_eth_devices[port_id];
@@ -3093,7 +3093,7 @@ get_hash_mac_addr_index(uint16_t port_id, const struct ether_addr *addr)
 }
 
 int
-rte_eth_dev_uc_hash_table_set(uint16_t port_id, struct ether_addr *addr,
+rte_eth_dev_uc_hash_table_set(uint16_t port_id, struct rte_ether_addr *addr,
                                uint8_t on)
 {
        int index;
@@ -3936,7 +3936,7 @@ rte_eth_tx_queue_info_get(uint16_t port_id, uint16_t queue_id,
 
 int
 rte_eth_dev_set_mc_addr_list(uint16_t port_id,
-                            struct ether_addr *mc_addr_set,
+                            struct rte_ether_addr *mc_addr_set,
                             uint32_t nb_mc_addr)
 {
        struct rte_eth_dev *dev;
index fb40c89..5deb4e3 100644 (file)
@@ -2159,7 +2159,7 @@ int rte_eth_dev_set_rx_queue_stats_mapping(uint16_t port_id,
  *   A pointer to a structure of type *ether_addr* to be filled with
  *   the Ethernet address of the Ethernet device.
  */
-void rte_eth_macaddr_get(uint16_t port_id, struct ether_addr *mac_addr);
+void rte_eth_macaddr_get(uint16_t port_id, struct rte_ether_addr *mac_addr);
 
 /**
  * Retrieve the contextual information of an Ethernet device.
@@ -2843,7 +2843,7 @@ int rte_eth_dev_priority_flow_ctrl_set(uint16_t port_id,
  *   - (-ENOSPC) if no more MAC addresses can be added.
  *   - (-EINVAL) if MAC address is invalid.
  */
-int rte_eth_dev_mac_addr_add(uint16_t port_id, struct ether_addr *mac_addr,
+int rte_eth_dev_mac_addr_add(uint16_t port_id, struct rte_ether_addr *mac_addr,
                                uint32_t pool);
 
 /**
@@ -2859,7 +2859,7 @@ int rte_eth_dev_mac_addr_add(uint16_t port_id, struct ether_addr *mac_addr,
  *   - (-ENODEV) if *port* invalid.
  *   - (-EADDRINUSE) if attempting to remove the default MAC address
  */
-int rte_eth_dev_mac_addr_remove(uint16_t port_id, struct ether_addr *mac_addr);
+int rte_eth_dev_mac_addr_remove(uint16_t port_id, struct rte_ether_addr *mac_addr);
 
 /**
  * Set the default MAC address.
@@ -2875,7 +2875,7 @@ int rte_eth_dev_mac_addr_remove(uint16_t port_id, struct ether_addr *mac_addr);
  *   - (-EINVAL) if MAC address is invalid.
  */
 int rte_eth_dev_default_mac_addr_set(uint16_t port_id,
-               struct ether_addr *mac_addr);
+               struct rte_ether_addr *mac_addr);
 
 /**
  * Update Redirection Table(RETA) of Receive Side Scaling of Ethernet device.
@@ -2936,7 +2936,7 @@ int rte_eth_dev_rss_reta_query(uint16_t port_id,
  *   - (-EIO) if device is removed.
  *   - (-EINVAL) if bad parameter.
  */
-int rte_eth_dev_uc_hash_table_set(uint16_t port_id, struct ether_addr *addr,
+int rte_eth_dev_uc_hash_table_set(uint16_t port_id, struct rte_ether_addr *addr,
                                  uint8_t on);
 
  /**
@@ -3479,7 +3479,7 @@ rte_eth_dev_get_module_eeprom(uint16_t port_id,
  *   - (-ENOSPC) if *port_id* has not enough multicast filtering resources.
  */
 int rte_eth_dev_set_mc_addr_list(uint16_t port_id,
-                                struct ether_addr *mc_addr_set,
+                                struct rte_ether_addr *mc_addr_set,
                                 uint32_t nb_mc_addr);
 
 /**
index 0d28fd9..fa51862 100644 (file)
@@ -250,17 +250,17 @@ typedef void (*eth_mac_addr_remove_t)(struct rte_eth_dev *dev, uint32_t index);
 /**< @internal Remove MAC address from receive address register */
 
 typedef int (*eth_mac_addr_add_t)(struct rte_eth_dev *dev,
-                                 struct ether_addr *mac_addr,
+                                 struct rte_ether_addr *mac_addr,
                                  uint32_t index,
                                  uint32_t vmdq);
 /**< @internal Set a MAC address into Receive Address Address Register */
 
 typedef int (*eth_mac_addr_set_t)(struct rte_eth_dev *dev,
-                                 struct ether_addr *mac_addr);
+                                 struct rte_ether_addr *mac_addr);
 /**< @internal Set a MAC address into Receive Address Address Register */
 
 typedef int (*eth_uc_hash_table_set_t)(struct rte_eth_dev *dev,
-                                 struct ether_addr *mac_addr,
+                                 struct rte_ether_addr *mac_addr,
                                  uint8_t on);
 /**< @internal Set a Unicast Hash bitmap */
 
@@ -292,7 +292,7 @@ typedef int (*eth_udp_tunnel_port_del_t)(struct rte_eth_dev *dev,
 /**< @internal Delete tunneling UDP port */
 
 typedef int (*eth_set_mc_addr_list_t)(struct rte_eth_dev *dev,
-                                     struct ether_addr *mc_addr_set,
+                                     struct rte_ether_addr *mc_addr_set,
                                      uint32_t nb_mc_addr);
 /**< @internal set the list of multicast addresses on an Ethernet device */
 
@@ -597,10 +597,10 @@ struct rte_eth_dev_data {
        /**< Common rx buffer size handled by all queues */
 
        uint64_t rx_mbuf_alloc_failed; /**< RX ring mbuf allocation failures. */
-       struct ether_addr* mac_addrs;/**< Device Ethernet Link address. */
+       struct rte_ether_addr* mac_addrs;/**< Device Ethernet Link address. */
        uint64_t mac_pool_sel[ETH_NUM_RECEIVE_MAC_ADDR];
        /** bitmap array of associating Ethernet MAC addresses to pools */
-       struct ether_addr* hash_mac_addrs;
+       struct rte_ether_addr* hash_mac_addrs;
        /** Device Ethernet MAC addresses of hash filtering. */
        uint16_t port_id;           /**< Device [external] port identifier. */
        __extension__
index 26e2fcf..89e5e22 100644 (file)
@@ -577,8 +577,8 @@ static const struct rte_flow_item_raw rte_flow_item_raw_mask = {
  * same order as on the wire.
  */
 struct rte_flow_item_eth {
-       struct ether_addr dst; /**< Destination MAC. */
-       struct ether_addr src; /**< Source MAC. */
+       struct rte_ether_addr dst; /**< Destination MAC. */
+       struct rte_ether_addr src; /**< Source MAC. */
        rte_be16_t type; /**< EtherType or TPID. */
 };
 
@@ -974,9 +974,9 @@ struct rte_flow_item_arp_eth_ipv4 {
        uint8_t hln; /**< Hardware address length, normally 6. */
        uint8_t pln; /**< Protocol address length, normally 4. */
        rte_be16_t op; /**< Opcode (1 for request, 2 for reply). */
-       struct ether_addr sha; /**< Sender hardware address. */
+       struct rte_ether_addr sha; /**< Sender hardware address. */
        rte_be32_t spa; /**< Sender IPv4 address. */
-       struct ether_addr tha; /**< Target hardware address. */
+       struct rte_ether_addr tha; /**< Target hardware address. */
        rte_be32_t tpa; /**< Target IPv4 address. */
 };
 
@@ -1120,7 +1120,7 @@ rte_flow_item_icmp6_nd_opt_mask = {
 struct rte_flow_item_icmp6_nd_opt_sla_eth {
        uint8_t type; /**< ND option type, normally 1. */
        uint8_t length; /**< ND option length, normally 1. */
-       struct ether_addr sla; /**< Source Ethernet LLA. */
+       struct rte_ether_addr sla; /**< Source Ethernet LLA. */
 };
 
 /** Default mask for RTE_FLOW_ITEM_TYPE_ICMP6_ND_OPT_SLA_ETH. */
@@ -1145,7 +1145,7 @@ rte_flow_item_icmp6_nd_opt_sla_eth_mask = {
 struct rte_flow_item_icmp6_nd_opt_tla_eth {
        uint8_t type; /**< ND option type, normally 2. */
        uint8_t length; /**< ND option length, normally 1. */
-       struct ether_addr tla; /**< Target Ethernet LLA. */
+       struct rte_ether_addr tla; /**< Target Ethernet LLA. */
 };
 
 /** Default mask for RTE_FLOW_ITEM_TYPE_ICMP6_ND_OPT_TLA_ETH. */
index 870ac8c..1687860 100644 (file)
@@ -614,8 +614,8 @@ static inline void
 rxa_mtoip(struct rte_mbuf *m, struct ipv4_hdr **ipv4_hdr,
        struct ipv6_hdr **ipv6_hdr)
 {
-       struct ether_hdr *eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
-       struct vlan_hdr *vlan_hdr;
+       struct rte_ether_hdr *eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
+       struct rte_vlan_hdr *vlan_hdr;
 
        *ipv4_hdr = NULL;
        *ipv6_hdr = NULL;
@@ -630,7 +630,7 @@ rxa_mtoip(struct rte_mbuf *m, struct ipv4_hdr **ipv4_hdr,
                break;
 
        case RTE_BE16(ETHER_TYPE_VLAN):
-               vlan_hdr = (struct vlan_hdr *)(eth_hdr + 1);
+               vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
                switch (vlan_hdr->eth_proto) {
                case RTE_BE16(ETHER_TYPE_IPv4):
                        *ipv4_hdr = (struct ipv4_hdr *)(vlan_hdr + 1);
index 2c0f35c..552db8f 100644 (file)
@@ -194,7 +194,7 @@ gro_tcp4_reassemble(struct rte_mbuf *pkt,
                struct gro_tcp4_tbl *tbl,
                uint64_t start_time)
 {
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        struct ipv4_hdr *ipv4_hdr;
        struct tcp_hdr *tcp_hdr;
        uint32_t sent_seq;
@@ -207,7 +207,7 @@ gro_tcp4_reassemble(struct rte_mbuf *pkt,
        int cmp;
        uint8_t find;
 
-       eth_hdr = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
        ipv4_hdr = (struct ipv4_hdr *)((char *)eth_hdr + pkt->l2_len);
        tcp_hdr = (struct tcp_hdr *)((char *)ipv4_hdr + pkt->l3_len);
        hdr_len = pkt->l2_len + pkt->l3_len + pkt->l4_len;
index 6bb30cd..439f9a8 100644 (file)
@@ -19,8 +19,8 @@
 
 /* Header fields representing a TCP/IPv4 flow */
 struct tcp4_flow_key {
-       struct ether_addr eth_saddr;
-       struct ether_addr eth_daddr;
+       struct rte_ether_addr eth_saddr;
+       struct rte_ether_addr eth_daddr;
        uint32_t ip_src_addr;
        uint32_t ip_dst_addr;
 
index ca86f01..4985b01 100644 (file)
@@ -289,11 +289,11 @@ gro_vxlan_tcp4_reassemble(struct rte_mbuf *pkt,
                struct gro_vxlan_tcp4_tbl *tbl,
                uint64_t start_time)
 {
-       struct ether_hdr *outer_eth_hdr, *eth_hdr;
+       struct rte_ether_hdr *outer_eth_hdr, *eth_hdr;
        struct ipv4_hdr *outer_ipv4_hdr, *ipv4_hdr;
        struct tcp_hdr *tcp_hdr;
        struct udp_hdr *udp_hdr;
-       struct vxlan_hdr *vxlan_hdr;
+       struct rte_vxlan_hdr *vxlan_hdr;
        uint32_t sent_seq;
        uint16_t tcp_dl, frag_off, outer_ip_id, ip_id;
        uint8_t outer_is_atomic, is_atomic;
@@ -305,15 +305,15 @@ gro_vxlan_tcp4_reassemble(struct rte_mbuf *pkt,
        uint16_t hdr_len;
        uint8_t find;
 
-       outer_eth_hdr = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+       outer_eth_hdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
        outer_ipv4_hdr = (struct ipv4_hdr *)((char *)outer_eth_hdr +
                        pkt->outer_l2_len);
        udp_hdr = (struct udp_hdr *)((char *)outer_ipv4_hdr +
                        pkt->outer_l3_len);
-       vxlan_hdr = (struct vxlan_hdr *)((char *)udp_hdr +
+       vxlan_hdr = (struct rte_vxlan_hdr *)((char *)udp_hdr +
                        sizeof(struct udp_hdr));
-       eth_hdr = (struct ether_hdr *)((char *)vxlan_hdr +
-                       sizeof(struct vxlan_hdr));
+       eth_hdr = (struct rte_ether_hdr *)((char *)vxlan_hdr +
+                       sizeof(struct rte_vxlan_hdr));
        ipv4_hdr = (struct ipv4_hdr *)((char *)udp_hdr + pkt->l2_len);
        tcp_hdr = (struct tcp_hdr *)((char *)ipv4_hdr + pkt->l3_len);
 
index 0cafb92..7832942 100644 (file)
 /* Header fields representing a VxLAN flow */
 struct vxlan_tcp4_flow_key {
        struct tcp4_flow_key inner_key;
-       struct vxlan_hdr vxlan_hdr;
+       struct rte_vxlan_hdr vxlan_hdr;
 
-       struct ether_addr outer_eth_saddr;
-       struct ether_addr outer_eth_daddr;
+       struct rte_ether_addr outer_eth_saddr;
+       struct rte_ether_addr outer_eth_daddr;
 
        uint32_t outer_ip_src_addr;
        uint32_t outer_ip_dst_addr;
index a626a11..433f2c8 100644 (file)
@@ -18,11 +18,11 @@ extern "C" {
 #include <rte_mbuf.h>
 
 /* Minimum GSO segment size for TCP based packets. */
-#define RTE_GSO_SEG_SIZE_MIN (sizeof(struct ether_hdr) + \
+#define RTE_GSO_SEG_SIZE_MIN (sizeof(struct rte_ether_hdr) + \
                sizeof(struct ipv4_hdr) + sizeof(struct tcp_hdr) + 1)
 
 /* Minimum GSO segment size for UDP based packets. */
-#define RTE_GSO_UDP_SEG_SIZE_MIN (sizeof(struct ether_hdr) + \
+#define RTE_GSO_UDP_SEG_SIZE_MIN (sizeof(struct rte_ether_hdr) + \
                sizeof(struct ipv4_hdr) + sizeof(struct udp_hdr) + 1)
 
 /* GSO flags for rte_gso_ctx. */
index b8edd40..251698e 100644 (file)
@@ -451,7 +451,7 @@ kni_config_mac_address(uint16_t port_id, uint8_t mac_addr[])
        RTE_LOG(INFO, KNI, "Configure mac address of %d", port_id);
 
        ret = rte_eth_dev_default_mac_addr_set(port_id,
-                                              (struct ether_addr *)mac_addr);
+                                              (struct rte_ether_addr *)mac_addr);
        if (ret < 0)
                RTE_LOG(ERR, KNI, "Failed to config mac_addr for port %d\n",
                        port_id);
index 877874a..921adb4 100644 (file)
@@ -9,9 +9,9 @@
 #define RARP_PKT_SIZE  64
 struct rte_mbuf * __rte_experimental
 rte_net_make_rarp_packet(struct rte_mempool *mpool,
-               const struct ether_addr *mac)
+               const struct rte_ether_addr *mac)
 {
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        struct rte_arp_hdr *rarp;
        struct rte_mbuf *mbuf;
 
@@ -22,7 +22,7 @@ rte_net_make_rarp_packet(struct rte_mempool *mpool,
        if (mbuf == NULL)
                return NULL;
 
-       eth_hdr = (struct ether_hdr *)rte_pktmbuf_append(mbuf, RARP_PKT_SIZE);
+       eth_hdr = (struct rte_ether_hdr *)rte_pktmbuf_append(mbuf, RARP_PKT_SIZE);
        if (eth_hdr == NULL) {
                rte_pktmbuf_free(mbuf);
                return NULL;
index a94fa6a..f17c529 100644 (file)
@@ -22,9 +22,9 @@ extern "C" {
  * ARP header IPv4 payload.
  */
 struct rte_arp_ipv4 {
-       struct ether_addr arp_sha;  /**< sender hardware address */
+       struct rte_ether_addr arp_sha;  /**< sender hardware address */
        uint32_t          arp_sip;  /**< sender IP address */
-       struct ether_addr arp_tha;  /**< target hardware address */
+       struct rte_ether_addr arp_tha;  /**< target hardware address */
        uint32_t          arp_tip;  /**< target IP address */
 } __attribute__((__packed__));
 
@@ -65,7 +65,7 @@ struct rte_arp_hdr {
  */
 struct rte_mbuf * __rte_experimental
 rte_net_make_rarp_packet(struct rte_mempool *mpool,
-               const struct ether_addr *mac);
+               const struct rte_ether_addr *mac);
 
 #ifdef __cplusplus
 }
index bee2b34..ddb5318 100644 (file)
@@ -54,7 +54,7 @@ extern "C" {
  * administrator and does not contain OUIs.
  * See http://standards.ieee.org/regauth/groupmac/tutorial.html
  */
-struct ether_addr {
+struct rte_ether_addr {
        uint8_t addr_bytes[ETHER_ADDR_LEN]; /**< Addr bytes in tx order */
 } __attribute__((__packed__));
 
@@ -75,8 +75,8 @@ struct ether_addr {
  *  True  (1) if the given two ethernet address are the same;
  *  False (0) otherwise.
  */
-static inline int is_same_ether_addr(const struct ether_addr *ea1,
-                                    const struct ether_addr *ea2)
+static inline int is_same_ether_addr(const struct rte_ether_addr *ea1,
+                                    const struct rte_ether_addr *ea2)
 {
        int i;
        for (i = 0; i < ETHER_ADDR_LEN; i++)
@@ -95,7 +95,7 @@ static inline int is_same_ether_addr(const struct ether_addr *ea1,
  *   True  (1) if the given ethernet address is filled with zeros;
  *   false (0) otherwise.
  */
-static inline int is_zero_ether_addr(const struct ether_addr *ea)
+static inline int is_zero_ether_addr(const struct rte_ether_addr *ea)
 {
        int i;
        for (i = 0; i < ETHER_ADDR_LEN; i++)
@@ -114,7 +114,7 @@ static inline int is_zero_ether_addr(const struct ether_addr *ea)
  *   True  (1) if the given ethernet address is a unicast address;
  *   false (0) otherwise.
  */
-static inline int is_unicast_ether_addr(const struct ether_addr *ea)
+static inline int is_unicast_ether_addr(const struct rte_ether_addr *ea)
 {
        return (ea->addr_bytes[0] & ETHER_GROUP_ADDR) == 0;
 }
@@ -129,7 +129,7 @@ static inline int is_unicast_ether_addr(const struct ether_addr *ea)
  *   True  (1) if the given ethernet address is a multicast address;
  *   false (0) otherwise.
  */
-static inline int is_multicast_ether_addr(const struct ether_addr *ea)
+static inline int is_multicast_ether_addr(const struct rte_ether_addr *ea)
 {
        return ea->addr_bytes[0] & ETHER_GROUP_ADDR;
 }
@@ -144,7 +144,7 @@ static inline int is_multicast_ether_addr(const struct ether_addr *ea)
  *   True  (1) if the given ethernet address is a broadcast address;
  *   false (0) otherwise.
  */
-static inline int is_broadcast_ether_addr(const struct ether_addr *ea)
+static inline int is_broadcast_ether_addr(const struct rte_ether_addr *ea)
 {
        const unaligned_uint16_t *ea_words = (const unaligned_uint16_t *)ea;
 
@@ -162,7 +162,7 @@ static inline int is_broadcast_ether_addr(const struct ether_addr *ea)
  *   True  (1) if the given ethernet address is a universally assigned address;
  *   false (0) otherwise.
  */
-static inline int is_universal_ether_addr(const struct ether_addr *ea)
+static inline int is_universal_ether_addr(const struct rte_ether_addr *ea)
 {
        return (ea->addr_bytes[0] & ETHER_LOCAL_ADMIN_ADDR) == 0;
 }
@@ -177,7 +177,7 @@ static inline int is_universal_ether_addr(const struct ether_addr *ea)
  *   True  (1) if the given ethernet address is a locally assigned address;
  *   false (0) otherwise.
  */
-static inline int is_local_admin_ether_addr(const struct ether_addr *ea)
+static inline int is_local_admin_ether_addr(const struct rte_ether_addr *ea)
 {
        return (ea->addr_bytes[0] & ETHER_LOCAL_ADMIN_ADDR) != 0;
 }
@@ -193,7 +193,7 @@ static inline int is_local_admin_ether_addr(const struct ether_addr *ea)
  *   True  (1) if the given ethernet address is valid;
  *   false (0) otherwise.
  */
-static inline int is_valid_assigned_ether_addr(const struct ether_addr *ea)
+static inline int is_valid_assigned_ether_addr(const struct rte_ether_addr *ea)
 {
        return is_unicast_ether_addr(ea) && (!is_zero_ether_addr(ea));
 }
@@ -222,8 +222,8 @@ static inline void eth_random_addr(uint8_t *addr)
  * @param ea_to
  *   A pointer to a ether_addr structure where to copy the Ethernet address.
  */
-static inline void ether_addr_copy(const struct ether_addr *ea_from,
-                                  struct ether_addr *ea_to)
+static inline void ether_addr_copy(const struct rte_ether_addr *ea_from,
+                                  struct rte_ether_addr *ea_to)
 {
 #ifdef __INTEL_COMPILER
        uint16_t *from_words = (uint16_t *)(ea_from->addr_bytes);
@@ -253,7 +253,7 @@ static inline void ether_addr_copy(const struct ether_addr *ea_from,
  */
 static inline void
 ether_format_addr(char *buf, uint16_t size,
-                 const struct ether_addr *eth_addr)
+                 const struct rte_ether_addr *eth_addr)
 {
        snprintf(buf, size, "%02X:%02X:%02X:%02X:%02X:%02X",
                 eth_addr->addr_bytes[0],
@@ -268,9 +268,9 @@ ether_format_addr(char *buf, uint16_t size,
  * Ethernet header: Contains the destination address, source address
  * and frame type.
  */
-struct ether_hdr {
-       struct ether_addr d_addr; /**< Destination address. */
-       struct ether_addr s_addr; /**< Source address. */
+struct rte_ether_hdr {
+       struct rte_ether_addr d_addr; /**< Destination address. */
+       struct rte_ether_addr s_addr; /**< Source address. */
        uint16_t ether_type;      /**< Frame type. */
 } __attribute__((__packed__));
 
@@ -279,7 +279,7 @@ struct ether_hdr {
  * Contains the 16-bit VLAN Tag Control Identifier and the Ethernet type
  * of the encapsulated frame.
  */
-struct vlan_hdr {
+struct rte_vlan_hdr {
        uint16_t vlan_tci; /**< Priority (3) + CFI (1) + Identifier Code (12) */
        uint16_t eth_proto;/**< Ethernet type of encapsulated frame. */
 } __attribute__((__packed__));
@@ -289,7 +289,7 @@ struct vlan_hdr {
  * Contains the 8-bit flag, 24-bit VXLAN Network Identifier and
  * Reserved fields (24 bits and 8 bits)
  */
-struct vxlan_hdr {
+struct rte_vxlan_hdr {
        uint32_t vx_flags; /**< flag (8) + Reserved (24). */
        uint32_t vx_vni;   /**< VNI (24) + Reserved (8). */
 } __attribute__((__packed__));
@@ -307,7 +307,7 @@ struct vxlan_hdr {
 #define ETHER_TYPE_TEB  0x6558 /**< Transparent Ethernet Bridging. */
 #define ETHER_TYPE_LLDP 0x88CC /**< LLDP Protocol. */
 
-#define ETHER_VXLAN_HLEN (sizeof(struct udp_hdr) + sizeof(struct vxlan_hdr))
+#define ETHER_VXLAN_HLEN (sizeof(struct udp_hdr) + sizeof(struct rte_vxlan_hdr))
 /**< VXLAN tunnel header length. */
 
 /**
@@ -315,7 +315,7 @@ struct vxlan_hdr {
  * Contains the 8-bit flag, 8-bit next-protocol, 24-bit VXLAN Network
  * Identifier and Reserved fields (16 bits and 8 bits).
  */
-struct vxlan_gpe_hdr {
+struct rte_vxlan_gpe_hdr {
        uint8_t vx_flags;    /**< flag (8). */
        uint8_t reserved[2]; /**< Reserved (16). */
        uint8_t proto;       /**< next-protocol (8). */
@@ -332,7 +332,7 @@ struct vxlan_gpe_hdr {
 #define VXLAN_GPE_TYPE_VBNG 7 /**< vBNG Protocol. */
 
 #define ETHER_VXLAN_GPE_HLEN (sizeof(struct udp_hdr) + \
-                             sizeof(struct vxlan_gpe_hdr))
+                             sizeof(struct rte_vxlan_gpe_hdr))
 /**< VXLAN-GPE tunnel header length. */
 
 /**
@@ -348,19 +348,19 @@ struct vxlan_gpe_hdr {
  */
 static inline int rte_vlan_strip(struct rte_mbuf *m)
 {
-       struct ether_hdr *eh
-                = rte_pktmbuf_mtod(m, struct ether_hdr *);
-       struct vlan_hdr *vh;
+       struct rte_ether_hdr *eh
+                = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
+       struct rte_vlan_hdr *vh;
 
        if (eh->ether_type != rte_cpu_to_be_16(ETHER_TYPE_VLAN))
                return -1;
 
-       vh = (struct vlan_hdr *)(eh + 1);
+       vh = (struct rte_vlan_hdr *)(eh + 1);
        m->ol_flags |= PKT_RX_VLAN | PKT_RX_VLAN_STRIPPED;
        m->vlan_tci = rte_be_to_cpu_16(vh->vlan_tci);
 
        /* Copy ether header over rather than moving whole packet */
-       memmove(rte_pktmbuf_adj(m, sizeof(struct vlan_hdr)),
+       memmove(rte_pktmbuf_adj(m, sizeof(struct rte_vlan_hdr)),
                eh, 2 * ETHER_ADDR_LEN);
 
        return 0;
@@ -380,8 +380,8 @@ static inline int rte_vlan_strip(struct rte_mbuf *m)
  */
 static inline int rte_vlan_insert(struct rte_mbuf **m)
 {
-       struct ether_hdr *oh, *nh;
-       struct vlan_hdr *vh;
+       struct rte_ether_hdr *oh, *nh;
+       struct rte_vlan_hdr *vh;
 
        /* Can't insert header if mbuf is shared */
        if (rte_mbuf_refcnt_read(*m) > 1) {
@@ -394,16 +394,16 @@ static inline int rte_vlan_insert(struct rte_mbuf **m)
                *m = copy;
        }
 
-       oh = rte_pktmbuf_mtod(*m, struct ether_hdr *);
-       nh = (struct ether_hdr *)
-               rte_pktmbuf_prepend(*m, sizeof(struct vlan_hdr));
+       oh = rte_pktmbuf_mtod(*m, struct rte_ether_hdr *);
+       nh = (struct rte_ether_hdr *)
+               rte_pktmbuf_prepend(*m, sizeof(struct rte_vlan_hdr));
        if (nh == NULL)
                return -ENOSPC;
 
        memmove(nh, oh, 2 * ETHER_ADDR_LEN);
        nh->ether_type = rte_cpu_to_be_16(ETHER_TYPE_VLAN);
 
-       vh = (struct vlan_hdr *) (nh + 1);
+       vh = (struct rte_vlan_hdr *) (nh + 1);
        vh->vlan_tci = rte_cpu_to_be_16((*m)->vlan_tci);
 
        (*m)->ol_flags &= ~PKT_RX_VLAN_STRIPPED;
index 9eb7c74..75fb666 100644 (file)
@@ -228,8 +228,8 @@ uint32_t rte_net_get_ptype(const struct rte_mbuf *m,
        struct rte_net_hdr_lens *hdr_lens, uint32_t layers)
 {
        struct rte_net_hdr_lens local_hdr_lens;
-       const struct ether_hdr *eh;
-       struct ether_hdr eh_copy;
+       const struct rte_ether_hdr *eh;
+       struct rte_ether_hdr eh_copy;
        uint32_t pkt_type = RTE_PTYPE_L2_ETHER;
        uint32_t off = 0;
        uint16_t proto;
@@ -252,8 +252,8 @@ uint32_t rte_net_get_ptype(const struct rte_mbuf *m,
                goto l3; /* fast path if packet is IPv4 */
 
        if (proto == rte_cpu_to_be_16(ETHER_TYPE_VLAN)) {
-               const struct vlan_hdr *vh;
-               struct vlan_hdr vh_copy;
+               const struct rte_vlan_hdr *vh;
+               struct rte_vlan_hdr vh_copy;
 
                pkt_type = RTE_PTYPE_L2_ETHER_VLAN;
                vh = rte_pktmbuf_read(m, off, sizeof(*vh), &vh_copy);
@@ -263,8 +263,8 @@ uint32_t rte_net_get_ptype(const struct rte_mbuf *m,
                hdr_lens->l2_len += sizeof(*vh);
                proto = vh->eth_proto;
        } else if (proto == rte_cpu_to_be_16(ETHER_TYPE_QINQ)) {
-               const struct vlan_hdr *vh;
-               struct vlan_hdr vh_copy;
+               const struct rte_vlan_hdr *vh;
+               struct rte_vlan_hdr vh_copy;
 
                pkt_type = RTE_PTYPE_L2_ETHER_QINQ;
                vh = rte_pktmbuf_read(m, off + sizeof(*vh), sizeof(*vh),
@@ -383,8 +383,8 @@ uint32_t rte_net_get_ptype(const struct rte_mbuf *m,
        }
 
        if (proto == rte_cpu_to_be_16(ETHER_TYPE_VLAN)) {
-               const struct vlan_hdr *vh;
-               struct vlan_hdr vh_copy;
+               const struct rte_vlan_hdr *vh;
+               struct rte_vlan_hdr vh_copy;
 
                pkt_type &= ~RTE_PTYPE_INNER_L2_MASK;
                pkt_type |= RTE_PTYPE_INNER_L2_ETHER_VLAN;
@@ -395,8 +395,8 @@ uint32_t rte_net_get_ptype(const struct rte_mbuf *m,
                hdr_lens->inner_l2_len += sizeof(*vh);
                proto = vh->eth_proto;
        } else if (proto == rte_cpu_to_be_16(ETHER_TYPE_QINQ)) {
-               const struct vlan_hdr *vh;
-               struct vlan_hdr vh_copy;
+               const struct rte_vlan_hdr *vh;
+               struct rte_vlan_hdr vh_copy;
 
                pkt_type &= ~RTE_PTYPE_INNER_L2_MASK;
                pkt_type |= RTE_PTYPE_INNER_L2_ETHER_QINQ;
index 537e659..693be2c 100644 (file)
@@ -449,7 +449,7 @@ encap_cfg_check(struct rte_table_action_encap_config *encap)
 }
 
 struct encap_ether_data {
-       struct ether_hdr ether;
+       struct rte_ether_hdr ether;
 } __attribute__((__packed__));
 
 #define VLAN(pcp, dei, vid)                                \
@@ -458,14 +458,14 @@ struct encap_ether_data {
        (((uint64_t)(vid)) & 0xFFFLLU))                    \
 
 struct encap_vlan_data {
-       struct ether_hdr ether;
-       struct vlan_hdr vlan;
+       struct rte_ether_hdr ether;
+       struct rte_vlan_hdr vlan;
 } __attribute__((__packed__));
 
 struct encap_qinq_data {
-       struct ether_hdr ether;
-       struct vlan_hdr svlan;
-       struct vlan_hdr cvlan;
+       struct rte_ether_hdr ether;
+       struct rte_vlan_hdr svlan;
+       struct rte_vlan_hdr cvlan;
 } __attribute__((__packed__));
 
 #define ETHER_TYPE_MPLS_UNICAST                            0x8847
@@ -479,7 +479,7 @@ struct encap_qinq_data {
        (((uint64_t)(ttl)) & 0xFFLLU)))
 
 struct encap_mpls_data {
-       struct ether_hdr ether;
+       struct rte_ether_hdr ether;
        uint32_t mpls[RTE_TABLE_ACTION_MPLS_LABELS_MAX];
        uint32_t mpls_count;
 } __attribute__((__packed__));
@@ -496,40 +496,40 @@ struct pppoe_ppp_hdr {
 } __attribute__((__packed__));
 
 struct encap_pppoe_data {
-       struct ether_hdr ether;
+       struct rte_ether_hdr ether;
        struct pppoe_ppp_hdr pppoe_ppp;
 } __attribute__((__packed__));
 
 #define IP_PROTO_UDP                                       17
 
 struct encap_vxlan_ipv4_data {
-       struct ether_hdr ether;
+       struct rte_ether_hdr ether;
        struct ipv4_hdr ipv4;
        struct udp_hdr udp;
-       struct vxlan_hdr vxlan;
+       struct rte_vxlan_hdr vxlan;
 } __attribute__((__packed__));
 
 struct encap_vxlan_ipv4_vlan_data {
-       struct ether_hdr ether;
-       struct vlan_hdr vlan;
+       struct rte_ether_hdr ether;
+       struct rte_vlan_hdr vlan;
        struct ipv4_hdr ipv4;
        struct udp_hdr udp;
-       struct vxlan_hdr vxlan;
+       struct rte_vxlan_hdr vxlan;
 } __attribute__((__packed__));
 
 struct encap_vxlan_ipv6_data {
-       struct ether_hdr ether;
+       struct rte_ether_hdr ether;
        struct ipv6_hdr ipv6;
        struct udp_hdr udp;
-       struct vxlan_hdr vxlan;
+       struct rte_vxlan_hdr vxlan;
 } __attribute__((__packed__));
 
 struct encap_vxlan_ipv6_vlan_data {
-       struct ether_hdr ether;
-       struct vlan_hdr vlan;
+       struct rte_ether_hdr ether;
+       struct rte_vlan_hdr vlan;
        struct ipv6_hdr ipv6;
        struct udp_hdr udp;
-       struct vxlan_hdr vxlan;
+       struct rte_vxlan_hdr vxlan;
 } __attribute__((__packed__));
 
 static size_t
@@ -962,13 +962,13 @@ pkt_work_encap_vxlan_ipv4(struct rte_mbuf *mbuf,
 
        ether_length = (uint16_t)mbuf->pkt_len;
        ipv4_total_length = ether_length +
-               (sizeof(struct vxlan_hdr) +
+               (sizeof(struct rte_vxlan_hdr) +
                sizeof(struct udp_hdr) +
                sizeof(struct ipv4_hdr));
        ipv4_hdr_cksum = encap_vxlan_ipv4_checksum_update(vxlan_tbl->ipv4.hdr_checksum,
                rte_htons(ipv4_total_length));
        udp_length = ether_length +
-               (sizeof(struct vxlan_hdr) +
+               (sizeof(struct rte_vxlan_hdr) +
                sizeof(struct udp_hdr));
 
        vxlan_pkt = encap(ether, vxlan_tbl, sizeof(*vxlan_tbl));
@@ -992,13 +992,13 @@ pkt_work_encap_vxlan_ipv4_vlan(struct rte_mbuf *mbuf,
 
        ether_length = (uint16_t)mbuf->pkt_len;
        ipv4_total_length = ether_length +
-               (sizeof(struct vxlan_hdr) +
+               (sizeof(struct rte_vxlan_hdr) +
                sizeof(struct udp_hdr) +
                sizeof(struct ipv4_hdr));
        ipv4_hdr_cksum = encap_vxlan_ipv4_checksum_update(vxlan_tbl->ipv4.hdr_checksum,
                rte_htons(ipv4_total_length));
        udp_length = ether_length +
-               (sizeof(struct vxlan_hdr) +
+               (sizeof(struct rte_vxlan_hdr) +
                sizeof(struct udp_hdr));
 
        vxlan_pkt = encap(ether, vxlan_tbl, sizeof(*vxlan_tbl));
@@ -1022,10 +1022,10 @@ pkt_work_encap_vxlan_ipv6(struct rte_mbuf *mbuf,
 
        ether_length = (uint16_t)mbuf->pkt_len;
        ipv6_payload_length = ether_length +
-               (sizeof(struct vxlan_hdr) +
+               (sizeof(struct rte_vxlan_hdr) +
                sizeof(struct udp_hdr));
        udp_length = ether_length +
-               (sizeof(struct vxlan_hdr) +
+               (sizeof(struct rte_vxlan_hdr) +
                sizeof(struct udp_hdr));
 
        vxlan_pkt = encap(ether, vxlan_tbl, sizeof(*vxlan_tbl));
@@ -1048,10 +1048,10 @@ pkt_work_encap_vxlan_ipv6_vlan(struct rte_mbuf *mbuf,
 
        ether_length = (uint16_t)mbuf->pkt_len;
        ipv6_payload_length = ether_length +
-               (sizeof(struct vxlan_hdr) +
+               (sizeof(struct rte_vxlan_hdr) +
                sizeof(struct udp_hdr));
        udp_length = ether_length +
-               (sizeof(struct vxlan_hdr) +
+               (sizeof(struct rte_vxlan_hdr) +
                sizeof(struct udp_hdr));
 
        vxlan_pkt = encap(ether, vxlan_tbl, sizeof(*vxlan_tbl));
@@ -1098,7 +1098,7 @@ pkt_work_encap(struct rte_mbuf *mbuf,
        case 1LLU << RTE_TABLE_ACTION_ENCAP_MPLS:
        {
                struct encap_mpls_data *mpls = data;
-               size_t size = sizeof(struct ether_hdr) +
+               size_t size = sizeof(struct rte_ether_hdr) +
                        mpls->mpls_count * 4;
 
                encap(ip, data, size);
index c960612..400bd5e 100644 (file)
@@ -384,8 +384,8 @@ enum rte_table_action_encap_type {
 
 /** Pre-computed Ethernet header fields for encapsulation action. */
 struct rte_table_action_ether_hdr {
-       struct ether_addr da; /**< Destination address. */
-       struct ether_addr sa; /**< Source address. */
+       struct rte_ether_addr da; /**< Destination address. */
+       struct rte_ether_addr sa; /**< Source address. */
 };
 
 /** Pre-computed VLAN header fields for encapsulation action. */
index b4abad3..064ebb9 100644 (file)
@@ -356,7 +356,7 @@ struct virtio_net {
        uint64_t                log_size;
        uint64_t                log_base;
        uint64_t                log_addr;
-       struct ether_addr       mac;
+       struct rte_ether_addr   mac;
        uint16_t                mtu;
 
        struct vhost_device_ops const *notify_ops;
index f8794ee..4ff9b66 100644 (file)
@@ -969,18 +969,18 @@ parse_ethernet(struct rte_mbuf *m, uint16_t *l4_proto, void **l4_hdr)
        struct ipv4_hdr *ipv4_hdr;
        struct ipv6_hdr *ipv6_hdr;
        void *l3_hdr = NULL;
-       struct ether_hdr *eth_hdr;
+       struct rte_ether_hdr *eth_hdr;
        uint16_t ethertype;
 
-       eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+       eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 
-       m->l2_len = sizeof(struct ether_hdr);
+       m->l2_len = sizeof(struct rte_ether_hdr);
        ethertype = rte_be_to_cpu_16(eth_hdr->ether_type);
 
        if (ethertype == ETHER_TYPE_VLAN) {
-               struct vlan_hdr *vlan_hdr = (struct vlan_hdr *)(eth_hdr + 1);
+               struct rte_vlan_hdr *vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
 
-               m->l2_len += sizeof(struct vlan_hdr);
+               m->l2_len += sizeof(struct rte_vlan_hdr);
                ethertype = rte_be_to_cpu_16(vlan_hdr->eth_proto);
        }
 
index 524d221..8853d43 100644 (file)
@@ -39,7 +39,7 @@ struct rte_acl_field_def ipv4_field_formats[NUM_FIELDS_IPV4] = {
                .size = sizeof(uint8_t),
                .field_index = PROTO_FIELD_IPV4,
                .input_index = PROTO_FIELD_IPV4,
-               .offset = sizeof(struct ether_hdr) +
+               .offset = sizeof(struct rte_ether_hdr) +
                        offsetof(struct ipv4_hdr, next_proto_id),
        },
        {
@@ -47,7 +47,7 @@ struct rte_acl_field_def ipv4_field_formats[NUM_FIELDS_IPV4] = {
                .size = sizeof(uint32_t),
                .field_index = SRC_FIELD_IPV4,
                .input_index = SRC_FIELD_IPV4,
-               .offset = sizeof(struct ether_hdr) +
+               .offset = sizeof(struct rte_ether_hdr) +
                        offsetof(struct ipv4_hdr, src_addr),
        },
        {
@@ -55,7 +55,7 @@ struct rte_acl_field_def ipv4_field_formats[NUM_FIELDS_IPV4] = {
                .size = sizeof(uint32_t),
                .field_index = DST_FIELD_IPV4,
                .input_index = DST_FIELD_IPV4,
-               .offset = sizeof(struct ether_hdr) +
+               .offset = sizeof(struct rte_ether_hdr) +
                        offsetof(struct ipv4_hdr, dst_addr),
        },
        {
@@ -63,14 +63,14 @@ struct rte_acl_field_def ipv4_field_formats[NUM_FIELDS_IPV4] = {
                .size = sizeof(uint16_t),
                .field_index = SRCP_FIELD_IPV4,
                .input_index = SRCP_FIELD_IPV4,
-               .offset = sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr),
+               .offset = sizeof(struct rte_ether_hdr) + sizeof(struct ipv4_hdr),
        },
        {
                .type = RTE_ACL_FIELD_TYPE_RANGE,
                .size = sizeof(uint16_t),
                .field_index = DSTP_FIELD_IPV4,
                .input_index = SRCP_FIELD_IPV4,
-               .offset = sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr) +
+               .offset = sizeof(struct rte_ether_hdr) + sizeof(struct ipv4_hdr) +
                        sizeof(uint16_t),
        },
 };
index c201472..3e4a0a1 100644 (file)
@@ -441,14 +441,14 @@ app_main_loop_rx_metadata(void) {
 
                        if (RTE_ETH_IS_IPV4_HDR(m->packet_type)) {
                                ip_hdr = (struct ipv4_hdr *)
-                                       &m_data[sizeof(struct ether_hdr)];
+                                       &m_data[sizeof(struct rte_ether_hdr)];
                                ip_dst = ip_hdr->dst_addr;
 
                                k32 = (uint32_t *) key;
                                k32[0] = ip_dst & 0xFFFFFF00;
                        } else if (RTE_ETH_IS_IPV6_HDR(m->packet_type)) {
                                ipv6_hdr = (struct ipv6_hdr *)
-                                       &m_data[sizeof(struct ether_hdr)];
+                                       &m_data[sizeof(struct rte_ether_hdr)];
                                ipv6_dst = ipv6_hdr->dst_addr;
 
                                memcpy(key, ipv6_dst, 16);
index ccc0bd5..51ab0db 100644 (file)
@@ -53,16 +53,16 @@ copy_buf_to_pkt(void *buf, unsigned len, struct rte_mbuf *pkt, unsigned offset)
 }
 
 void
-initialize_eth_header(struct ether_hdr *eth_hdr, struct ether_addr *src_mac,
-               struct ether_addr *dst_mac, uint16_t ether_type,
+initialize_eth_header(struct rte_ether_hdr *eth_hdr, struct rte_ether_addr *src_mac,
+               struct rte_ether_addr *dst_mac, uint16_t ether_type,
                uint8_t vlan_enabled, uint16_t van_id)
 {
        ether_addr_copy(dst_mac, &eth_hdr->d_addr);
        ether_addr_copy(src_mac, &eth_hdr->s_addr);
 
        if (vlan_enabled) {
-               struct vlan_hdr *vhdr = (struct vlan_hdr *)((uint8_t *)eth_hdr +
-                               sizeof(struct ether_hdr));
+               struct rte_vlan_hdr *vhdr = (struct rte_vlan_hdr *)((uint8_t *)eth_hdr +
+                               sizeof(struct rte_ether_hdr));
 
                eth_hdr->ether_type = rte_cpu_to_be_16(ETHER_TYPE_VLAN);
 
@@ -74,8 +74,8 @@ initialize_eth_header(struct ether_hdr *eth_hdr, struct ether_addr *src_mac,
 }
 
 void
-initialize_arp_header(struct rte_arp_hdr *arp_hdr, struct ether_addr *src_mac,
-               struct ether_addr *dst_mac, uint32_t src_ip, uint32_t dst_ip,
+initialize_arp_header(struct rte_arp_hdr *arp_hdr, struct rte_ether_addr *src_mac,
+               struct rte_ether_addr *dst_mac, uint32_t src_ip, uint32_t dst_ip,
                uint32_t opcode)
 {
        arp_hdr->arp_hardware = rte_cpu_to_be_16(RTE_ARP_HRD_ETHER);
@@ -256,7 +256,7 @@ initialize_ipv4_header_proto(struct ipv4_hdr *ip_hdr, uint32_t src_addr,
 
 int
 generate_packet_burst(struct rte_mempool *mp, struct rte_mbuf **pkts_burst,
-               struct ether_hdr *eth_hdr, uint8_t vlan_enabled, void *ip_hdr,
+               struct rte_ether_hdr *eth_hdr, uint8_t vlan_enabled, void *ip_hdr,
                uint8_t ipv4, struct udp_hdr *udp_hdr, int nb_pkt_per_burst,
                uint8_t pkt_len, uint8_t nb_pkt_segs)
 {
@@ -293,9 +293,9 @@ nomore_mbuf:
                 * Copy headers in first packet segment(s).
                 */
                if (vlan_enabled)
-                       eth_hdr_size = sizeof(struct ether_hdr) + sizeof(struct vlan_hdr);
+                       eth_hdr_size = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr);
                else
-                       eth_hdr_size = sizeof(struct ether_hdr);
+                       eth_hdr_size = sizeof(struct rte_ether_hdr);
 
                copy_buf_to_pkt(eth_hdr, eth_hdr_size, pkt, 0);
 
@@ -334,7 +334,7 @@ nomore_mbuf:
 int
 generate_packet_burst_proto(struct rte_mempool *mp,
                struct rte_mbuf **pkts_burst,
-               struct ether_hdr *eth_hdr, uint8_t vlan_enabled, void *ip_hdr,
+               struct rte_ether_hdr *eth_hdr, uint8_t vlan_enabled, void *ip_hdr,
                uint8_t ipv4, uint8_t proto, void *proto_hdr,
                int nb_pkt_per_burst, uint8_t pkt_len, uint8_t nb_pkt_segs)
 {
@@ -371,10 +371,10 @@ nomore_mbuf:
                 * Copy headers in first packet segment(s).
                 */
                if (vlan_enabled)
-                       eth_hdr_size = sizeof(struct ether_hdr) +
-                               sizeof(struct vlan_hdr);
+                       eth_hdr_size = sizeof(struct rte_ether_hdr) +
+                               sizeof(struct rte_vlan_hdr);
                else
-                       eth_hdr_size = sizeof(struct ether_hdr);
+                       eth_hdr_size = sizeof(struct rte_ether_hdr);
 
                copy_buf_to_pkt(eth_hdr, eth_hdr_size, pkt, 0);
 
index b6e013a..8489212 100644 (file)
@@ -24,13 +24,13 @@ extern "C" {
 #define PACKET_BURST_GEN_PKT_LEN_128 128
 
 void
-initialize_eth_header(struct ether_hdr *eth_hdr, struct ether_addr *src_mac,
-               struct ether_addr *dst_mac, uint16_t ether_type,
+initialize_eth_header(struct rte_ether_hdr *eth_hdr, struct rte_ether_addr *src_mac,
+               struct rte_ether_addr *dst_mac, uint16_t ether_type,
                uint8_t vlan_enabled, uint16_t van_id);
 
 void
-initialize_arp_header(struct rte_arp_hdr *arp_hdr, struct ether_addr *src_mac,
-               struct ether_addr *dst_mac, uint32_t src_ip, uint32_t dst_ip,
+initialize_arp_header(struct rte_arp_hdr *arp_hdr, struct rte_ether_addr *src_mac,
+               struct rte_ether_addr *dst_mac, uint32_t src_ip, uint32_t dst_ip,
                uint32_t opcode);
 
 uint16_t
@@ -59,14 +59,14 @@ initialize_ipv4_header_proto(struct ipv4_hdr *ip_hdr, uint32_t src_addr,
 
 int
 generate_packet_burst(struct rte_mempool *mp, struct rte_mbuf **pkts_burst,
-               struct ether_hdr *eth_hdr, uint8_t vlan_enabled, void *ip_hdr,
+               struct rte_ether_hdr *eth_hdr, uint8_t vlan_enabled, void *ip_hdr,
                uint8_t ipv4, struct udp_hdr *udp_hdr, int nb_pkt_per_burst,
                uint8_t pkt_len, uint8_t nb_pkt_segs);
 
 int
 generate_packet_burst_proto(struct rte_mempool *mp,
                struct rte_mbuf **pkts_burst,
-               struct ether_hdr *eth_hdr, uint8_t vlan_enabled, void *ip_hdr,
+               struct rte_ether_hdr *eth_hdr, uint8_t vlan_enabled, void *ip_hdr,
                uint8_t ipv4, uint8_t proto, void *proto_hdr,
                int nb_pkt_per_burst, uint8_t pkt_len, uint8_t nb_pkt_segs);
 
index 6ceba4b..8e524e5 100644 (file)
@@ -82,7 +82,7 @@ const char * ether_addr_invalid_strs[] = {
 
 
 static int
-is_addr_different(const struct ether_addr addr, uint64_t num)
+is_addr_different(const struct rte_ether_addr addr, uint64_t num)
 {
        int i;
        for (i = 0; i < ETHER_ADDR_LEN; i++, num >>= 8)
@@ -97,7 +97,7 @@ int
 test_parse_etheraddr_invalid_param(void)
 {
        char buf[CMDLINE_TEST_BUFSIZE];
-       struct ether_addr result;
+       struct rte_ether_addr result;
        int ret = 0;
 
        /* try all null */
@@ -149,12 +149,12 @@ test_parse_etheraddr_invalid_data(void)
 {
        int ret = 0;
        unsigned i;
-       struct ether_addr result;
+       struct rte_ether_addr result;
 
        /* test full strings */
        for (i = 0; i < ETHERADDR_INVALID_STRS_SIZE; i++) {
 
-               memset(&result, 0, sizeof(struct ether_addr));
+               memset(&result, 0, sizeof(struct rte_ether_addr));
 
                ret = cmdline_parse_etheraddr(NULL, ether_addr_invalid_strs[i],
                        (void*)&result, sizeof(result));
@@ -174,12 +174,12 @@ test_parse_etheraddr_valid(void)
 {
        int ret = 0;
        unsigned i;
-       struct ether_addr result;
+       struct rte_ether_addr result;
 
        /* test full strings */
        for (i = 0; i < ETHERADDR_VALID_STRS_SIZE; i++) {
 
-               memset(&result, 0, sizeof(struct ether_addr));
+               memset(&result, 0, sizeof(struct rte_ether_addr));
 
                ret = cmdline_parse_etheraddr(NULL, ether_addr_valid_strs[i].str,
                        (void*)&result, sizeof(result));
@@ -198,7 +198,7 @@ test_parse_etheraddr_valid(void)
        /* test garbage strings */
        for (i = 0; i < ETHERADDR_GARBAGE_STRS_SIZE; i++) {
 
-               memset(&result, 0, sizeof(struct ether_addr));
+               memset(&result, 0, sizeof(struct rte_ether_addr));
 
                ret = cmdline_parse_etheraddr(NULL, ether_addr_garbage_strs[i],
                        (void*)&result, sizeof(result));
index 1d3be82..d0255ec 100644 (file)
@@ -78,7 +78,7 @@ port_init_common(uint16_t port, const struct rte_eth_conf *port_conf,
                return retval;
 
        /* Display the port MAC address. */
-       struct ether_addr addr;
+       struct rte_ether_addr addr;
        rte_eth_macaddr_get(port, &addr);
        printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8
                           " %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\n",
index c26c515..208d20c 100644 (file)
@@ -84,7 +84,7 @@ port_init_common(uint8_t port, const struct rte_eth_conf *port_conf,
                return retval;
 
        /* Display the port MAC address. */
-       struct ether_addr addr;
+       struct rte_ether_addr addr;
        rte_eth_macaddr_get(port, &addr);
        printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8
                           " %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\n",
index 5f5beee..f81bbba 100644 (file)
@@ -39,7 +39,7 @@ static struct rte_acl_field_def ipv4_defs[NUM_FIELDS_IPV4] = {
                .size = sizeof(uint8_t),
                .field_index = PROTO_FIELD_IPV4,
                .input_index = PROTO_INPUT_IPV4,
-               .offset = sizeof(struct ether_hdr) +
+               .offset = sizeof(struct rte_ether_hdr) +
                        offsetof(struct ipv4_hdr, next_proto_id),
        },
        /* next input field (IPv4 source address) - 4 consecutive bytes. */
@@ -49,7 +49,7 @@ static struct rte_acl_field_def ipv4_defs[NUM_FIELDS_IPV4] = {
                .size = sizeof(uint32_t),
                .field_index = SRC_FIELD_IPV4,
                .input_index = SRC_INPUT_IPV4,
-               .offset = sizeof(struct ether_hdr) +
+               .offset = sizeof(struct rte_ether_hdr) +
                        offsetof(struct ipv4_hdr, src_addr),
        },
        /* next input field (IPv4 destination address) - 4 consecutive bytes. */
@@ -59,7 +59,7 @@ static struct rte_acl_field_def ipv4_defs[NUM_FIELDS_IPV4] = {
                .size = sizeof(uint32_t),
                .field_index = DST_FIELD_IPV4,
                .input_index = DST_INPUT_IPV4,
-               .offset = sizeof(struct ether_hdr) +
+               .offset = sizeof(struct rte_ether_hdr) +
                        offsetof(struct ipv4_hdr, dst_addr),
        },
        /*
@@ -72,7 +72,7 @@ static struct rte_acl_field_def ipv4_defs[NUM_FIELDS_IPV4] = {
                .size = sizeof(uint16_t),
                .field_index = SRCP_FIELD_IPV4,
                .input_index = SRCP_DESTP_INPUT_IPV4,
-               .offset = sizeof(struct ether_hdr) +
+               .offset = sizeof(struct rte_ether_hdr) +
                        sizeof(struct ipv4_hdr) +
                        offsetof(struct tcp_hdr, src_port),
        },
@@ -82,7 +82,7 @@ static struct rte_acl_field_def ipv4_defs[NUM_FIELDS_IPV4] = {
                .size = sizeof(uint16_t),
                .field_index = DSTP_FIELD_IPV4,
                .input_index = SRCP_DESTP_INPUT_IPV4,
-               .offset = sizeof(struct ether_hdr) +
+               .offset = sizeof(struct rte_ether_hdr) +
                        sizeof(struct ipv4_hdr) +
                        offsetof(struct tcp_hdr, dst_port),
        },
@@ -489,7 +489,7 @@ static int
 init_ipv4_udp_traffic(struct rte_mempool *mp,
             struct rte_mbuf **pkts_burst, uint32_t burst_size)
 {
-       struct ether_hdr pkt_eth_hdr;
+       struct rte_ether_hdr pkt_eth_hdr;
        struct ipv4_hdr pkt_ipv4_hdr;
        struct udp_hdr pkt_udp_hdr;
        uint32_t src_addr = IPV4_ADDR(2, 2, 2, 3);
@@ -503,9 +503,9 @@ init_ipv4_udp_traffic(struct rte_mempool *mp,
 
        printf("Set up IPv4 UDP traffic\n");
        initialize_eth_header(&pkt_eth_hdr,
-               (struct ether_addr *)src_mac,
-               (struct ether_addr *)dst_mac, ETHER_TYPE_IPv4, 0, 0);
-       pktlen = (uint16_t)(sizeof(struct ether_hdr));
+               (struct rte_ether_addr *)src_mac,
+               (struct rte_ether_addr *)dst_mac, ETHER_TYPE_IPv4, 0, 0);
+       pktlen = (uint16_t)(sizeof(struct rte_ether_hdr));
        printf("ETH  pktlen %u\n", pktlen);
 
        pktlen = initialize_ipv4_header(&pkt_ipv4_hdr, src_addr, dst_addr,
@@ -526,7 +526,7 @@ static int
 init_ipv4_tcp_traffic(struct rte_mempool *mp,
             struct rte_mbuf **pkts_burst, uint32_t burst_size)
 {
-       struct ether_hdr pkt_eth_hdr;
+       struct rte_ether_hdr pkt_eth_hdr;
        struct ipv4_hdr pkt_ipv4_hdr;
        struct tcp_hdr pkt_tcp_hdr;
        uint32_t src_addr = IPV4_ADDR(1, 2, 3, 4);
@@ -540,9 +540,9 @@ init_ipv4_tcp_traffic(struct rte_mempool *mp,
 
        printf("Set up IPv4 TCP traffic\n");
        initialize_eth_header(&pkt_eth_hdr,
-               (struct ether_addr *)src_mac,
-               (struct ether_addr *)dst_mac, ETHER_TYPE_IPv4, 0, 0);
-       pktlen = (uint16_t)(sizeof(struct ether_hdr));
+               (struct rte_ether_addr *)src_mac,
+               (struct rte_ether_addr *)dst_mac, ETHER_TYPE_IPv4, 0, 0);
+       pktlen = (uint16_t)(sizeof(struct rte_ether_hdr));
        printf("ETH  pktlen %u\n", pktlen);
 
        pktlen = initialize_ipv4_header_proto(&pkt_ipv4_hdr, src_addr,
@@ -563,7 +563,7 @@ static int
 init_ipv4_sctp_traffic(struct rte_mempool *mp,
             struct rte_mbuf **pkts_burst, uint32_t burst_size)
 {
-       struct ether_hdr pkt_eth_hdr;
+       struct rte_ether_hdr pkt_eth_hdr;
        struct ipv4_hdr pkt_ipv4_hdr;
        struct sctp_hdr pkt_sctp_hdr;
        uint32_t src_addr = IPV4_ADDR(11, 12, 13, 14);
@@ -577,9 +577,9 @@ init_ipv4_sctp_traffic(struct rte_mempool *mp,
 
        printf("Set up IPv4 SCTP traffic\n");
        initialize_eth_header(&pkt_eth_hdr,
-               (struct ether_addr *)src_mac,
-               (struct ether_addr *)dst_mac, ETHER_TYPE_IPv4, 0, 0);
-       pktlen = (uint16_t)(sizeof(struct ether_hdr));
+               (struct rte_ether_addr *)src_mac,
+               (struct rte_ether_addr *)dst_mac, ETHER_TYPE_IPv4, 0, 0);
+       pktlen = (uint16_t)(sizeof(struct rte_ether_hdr));
        printf("ETH  pktlen %u\n", pktlen);
 
        pktlen = initialize_ipv4_header_proto(&pkt_ipv4_hdr, src_addr,
index 2c20f44..2527671 100644 (file)
@@ -73,11 +73,11 @@ struct link_bonding_unittest_params {
 
        struct rte_mempool *mbuf_pool;
 
-       struct ether_addr *default_slave_mac;
-       struct ether_addr *default_bonded_mac;
+       struct rte_ether_addr *default_slave_mac;
+       struct rte_ether_addr *default_bonded_mac;
 
        /* Packet Headers */
-       struct ether_hdr *pkt_eth_hdr;
+       struct rte_ether_hdr *pkt_eth_hdr;
        struct ipv4_hdr *pkt_ipv4_hdr;
        struct ipv6_hdr *pkt_ipv6_hdr;
        struct udp_hdr *pkt_udp_hdr;
@@ -99,8 +99,8 @@ static struct link_bonding_unittest_params default_params  = {
 
        .mbuf_pool = NULL,
 
-       .default_slave_mac = (struct ether_addr *)slave_mac,
-       .default_bonded_mac = (struct ether_addr *)bonded_mac,
+       .default_slave_mac = (struct rte_ether_addr *)slave_mac,
+       .default_bonded_mac = (struct rte_ether_addr *)bonded_mac,
 
        .pkt_eth_hdr = NULL,
        .pkt_ipv4_hdr = &pkt_ipv4_hdr,
@@ -210,12 +210,12 @@ static int
 test_setup(void)
 {
        int i, nb_mbuf_per_pool;
-       struct ether_addr *mac_addr = (struct ether_addr *)slave_mac;
+       struct rte_ether_addr *mac_addr = (struct rte_ether_addr *)slave_mac;
 
        /* Allocate ethernet packet header with space for VLAN header */
        if (test_params->pkt_eth_hdr == NULL) {
-               test_params->pkt_eth_hdr = malloc(sizeof(struct ether_hdr) +
-                               sizeof(struct vlan_hdr));
+               test_params->pkt_eth_hdr = malloc(sizeof(struct rte_ether_hdr) +
+                               sizeof(struct rte_vlan_hdr));
 
                TEST_ASSERT_NOT_NULL(test_params->pkt_eth_hdr,
                                "Ethernet header struct allocation failed!");
@@ -376,7 +376,7 @@ static int
 test_remove_slave_from_bonded_device(void)
 {
        int current_slave_count;
-       struct ether_addr read_mac_addr, *mac_addr;
+       struct rte_ether_addr read_mac_addr, *mac_addr;
        uint16_t slaves[RTE_MAX_ETHPORTS];
 
        TEST_ASSERT_SUCCESS(rte_eth_bond_slave_remove(test_params->bonded_port_id,
@@ -394,7 +394,7 @@ test_remove_slave_from_bonded_device(void)
                        current_slave_count, test_params->bonded_slave_count - 1);
 
 
-       mac_addr = (struct ether_addr *)slave_mac;
+       mac_addr = (struct rte_ether_addr *)slave_mac;
        mac_addr->addr_bytes[ETHER_ADDR_LEN-1] =
                        test_params->bonded_slave_count-1;
 
@@ -699,8 +699,8 @@ static int
 test_set_primary_slave(void)
 {
        int i, j, retval;
-       struct ether_addr read_mac_addr;
-       struct ether_addr *expected_mac_addr;
+       struct rte_ether_addr read_mac_addr;
+       struct rte_ether_addr *expected_mac_addr;
 
        /* Add 4 slaves to bonded device */
        for (i = test_params->bonded_slave_count; i < 4; i++)
@@ -750,7 +750,7 @@ test_set_primary_slave(void)
                                "Failed to start bonded port %d",
                                test_params->bonded_port_id);
 
-               expected_mac_addr = (struct ether_addr *)&slave_mac;
+               expected_mac_addr = (struct rte_ether_addr *)&slave_mac;
                expected_mac_addr->addr_bytes[ETHER_ADDR_LEN-1] = i;
 
                /* Check primary slave MAC */
@@ -801,12 +801,12 @@ static int
 test_set_explicit_bonded_mac(void)
 {
        int i;
-       struct ether_addr read_mac_addr;
-       struct ether_addr *mac_addr;
+       struct rte_ether_addr read_mac_addr;
+       struct rte_ether_addr *mac_addr;
 
        uint8_t explicit_bonded_mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x01 };
 
-       mac_addr = (struct ether_addr *)explicit_bonded_mac;
+       mac_addr = (struct rte_ether_addr *)explicit_bonded_mac;
 
        /* Invalid port ID */
        TEST_ASSERT_FAIL(rte_eth_bond_mac_address_set(INVALID_PORT_ID, mac_addr),
@@ -878,11 +878,11 @@ test_set_bonded_port_initialization_mac_assignment(void)
        uint16_t slaves[RTE_MAX_ETHPORTS];
        int slave_port_ids[BONDED_INIT_MAC_ASSIGNMENT_SLAVE_COUNT];
 
-       struct ether_addr slave_mac_addr, bonded_mac_addr, read_mac_addr;
+       struct rte_ether_addr slave_mac_addr, bonded_mac_addr, read_mac_addr;
 
        /* Initialize default values for MAC addresses */
-       memcpy(&slave_mac_addr, slave_mac, sizeof(struct ether_addr));
-       memcpy(&bonded_mac_addr, slave_mac, sizeof(struct ether_addr));
+       memcpy(&slave_mac_addr, slave_mac, sizeof(struct rte_ether_addr));
+       memcpy(&bonded_mac_addr, slave_mac, sizeof(struct rte_ether_addr));
 
        /*
         * 1. a - Create / configure  bonded / slave ethdevs
@@ -1268,11 +1268,11 @@ generate_test_burst(struct rte_mbuf **pkts_burst, uint16_t burst_size,
 
        if (toggle_dst_mac)
                initialize_eth_header(test_params->pkt_eth_hdr,
-                               (struct ether_addr *)src_mac, (struct ether_addr *)dst_mac_1,
+                               (struct rte_ether_addr *)src_mac, (struct rte_ether_addr *)dst_mac_1,
                                ether_type, vlan, vlan_id);
        else
                initialize_eth_header(test_params->pkt_eth_hdr,
-                               (struct ether_addr *)src_mac, (struct ether_addr *)dst_mac_0,
+                               (struct rte_ether_addr *)src_mac, (struct rte_ether_addr *)dst_mac_0,
                                ether_type, vlan, vlan_id);
 
 
@@ -1663,7 +1663,7 @@ test_roundrobin_rx_burst_on_multiple_slaves(void)
 static int
 test_roundrobin_verify_mac_assignment(void)
 {
-       struct ether_addr read_mac_addr, expected_mac_addr_0, expected_mac_addr_2;
+       struct rte_ether_addr read_mac_addr, expected_mac_addr_0, expected_mac_addr_2;
 
        int i;
 
@@ -1722,7 +1722,7 @@ test_roundrobin_verify_mac_assignment(void)
 
        /* Set explicit MAC address */
        TEST_ASSERT_SUCCESS(rte_eth_bond_mac_address_set(
-                       test_params->bonded_port_id, (struct ether_addr *)bonded_mac),
+                       test_params->bonded_port_id, (struct rte_ether_addr *)bonded_mac),
                        "Failed to set MAC");
 
        rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr);
@@ -1931,7 +1931,7 @@ int polling_test_slaves[TEST_RR_POLLING_LINK_STATUS_SLAVE_COUNT] = { -1, -1 };
 static int
 test_roundrobin_verfiy_polling_slave_link_status_change(void)
 {
-       struct ether_addr *mac_addr = (struct ether_addr *)polling_slave_mac;
+       struct rte_ether_addr *mac_addr = (struct rte_ether_addr *)polling_slave_mac;
        char slave_name[RTE_ETH_NAME_MAX_LEN];
 
        int i;
@@ -2030,7 +2030,7 @@ test_activebackup_tx_burst(void)
                        "Failed to initialize bonded device with slaves");
 
        initialize_eth_header(test_params->pkt_eth_hdr,
-                       (struct ether_addr *)src_mac, (struct ether_addr *)dst_mac_0,
+                       (struct rte_ether_addr *)src_mac, (struct rte_ether_addr *)dst_mac_0,
                        ETHER_TYPE_IPv4,  0, 0);
        pktlen = initialize_udp_header(test_params->pkt_udp_hdr, src_port,
                        dst_port_0, 16);
@@ -2237,7 +2237,7 @@ test_activebackup_verify_promiscuous_enable_disable(void)
 static int
 test_activebackup_verify_mac_assignment(void)
 {
-       struct ether_addr read_mac_addr, expected_mac_addr_0, expected_mac_addr_1;
+       struct rte_ether_addr read_mac_addr, expected_mac_addr_0, expected_mac_addr_1;
 
        rte_eth_macaddr_get(test_params->slave_port_ids[0], &expected_mac_addr_0);
        rte_eth_macaddr_get(test_params->slave_port_ids[1], &expected_mac_addr_1);
@@ -2319,7 +2319,7 @@ test_activebackup_verify_mac_assignment(void)
 
        /* Set explicit MAC address */
        TEST_ASSERT_SUCCESS(rte_eth_bond_mac_address_set(
-                       test_params->bonded_port_id, (struct ether_addr *)bonded_mac),
+                       test_params->bonded_port_id, (struct rte_ether_addr *)bonded_mac),
                        "failed to set MAC address");
 
        rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr);
@@ -2564,7 +2564,7 @@ test_balance_l2_tx_burst(void)
                        "Failed to set balance xmit policy.");
 
        initialize_eth_header(test_params->pkt_eth_hdr,
-                       (struct ether_addr *)src_mac, (struct ether_addr *)dst_mac_0,
+                       (struct rte_ether_addr *)src_mac, (struct rte_ether_addr *)dst_mac_0,
                        ETHER_TYPE_IPv4, 0, 0);
        pktlen = initialize_udp_header(test_params->pkt_udp_hdr, src_port,
                        dst_port_0, 16);
@@ -2579,7 +2579,7 @@ test_balance_l2_tx_burst(void)
                        "failed to generate packet burst");
 
        initialize_eth_header(test_params->pkt_eth_hdr,
-                       (struct ether_addr *)src_mac, (struct ether_addr *)dst_mac_1,
+                       (struct rte_ether_addr *)src_mac, (struct rte_ether_addr *)dst_mac_1,
                        ETHER_TYPE_IPv4, 0, 0);
 
        /* Generate a burst 2 of packets to transmit */
@@ -3129,7 +3129,7 @@ test_balance_verify_promiscuous_enable_disable(void)
 static int
 test_balance_verify_mac_assignment(void)
 {
-       struct ether_addr read_mac_addr, expected_mac_addr_0, expected_mac_addr_1;
+       struct rte_ether_addr read_mac_addr, expected_mac_addr_0, expected_mac_addr_1;
 
        rte_eth_macaddr_get(test_params->slave_port_ids[0], &expected_mac_addr_0);
        rte_eth_macaddr_get(test_params->slave_port_ids[1], &expected_mac_addr_1);
@@ -3211,7 +3211,7 @@ test_balance_verify_mac_assignment(void)
 
        /* Set explicit MAC address */
        TEST_ASSERT_SUCCESS(rte_eth_bond_mac_address_set(
-                       test_params->bonded_port_id, (struct ether_addr *)bonded_mac),
+                       test_params->bonded_port_id, (struct rte_ether_addr *)bonded_mac),
                        "failed to set MAC");
 
        rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr);
@@ -3402,7 +3402,7 @@ test_broadcast_tx_burst(void)
                        "Failed to initialise bonded device");
 
        initialize_eth_header(test_params->pkt_eth_hdr,
-                       (struct ether_addr *)src_mac, (struct ether_addr *)dst_mac_0,
+                       (struct rte_ether_addr *)src_mac, (struct rte_ether_addr *)dst_mac_0,
                        ETHER_TYPE_IPv4, 0, 0);
 
        pktlen = initialize_udp_header(test_params->pkt_udp_hdr, src_port,
@@ -3713,7 +3713,7 @@ test_broadcast_verify_promiscuous_enable_disable(void)
 static int
 test_broadcast_verify_mac_assignment(void)
 {
-       struct ether_addr read_mac_addr, expected_mac_addr_0, expected_mac_addr_1;
+       struct rte_ether_addr read_mac_addr, expected_mac_addr_0, expected_mac_addr_1;
 
        int i;
 
@@ -3774,7 +3774,7 @@ test_broadcast_verify_mac_assignment(void)
 
        /* Set explicit MAC address */
        TEST_ASSERT_SUCCESS(rte_eth_bond_mac_address_set(
-                       test_params->bonded_port_id, (struct ether_addr *)bonded_mac),
+                       test_params->bonded_port_id, (struct rte_ether_addr *)bonded_mac),
                        "Failed to set MAC address");
 
        rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr);
@@ -3985,12 +3985,12 @@ test_tlb_tx_burst(void)
                /*test two types of mac src own(bonding) and others */
                if (i % 2 == 0) {
                        initialize_eth_header(test_params->pkt_eth_hdr,
-                                       (struct ether_addr *)src_mac,
-                                       (struct ether_addr *)dst_mac_0, ETHER_TYPE_IPv4, 0, 0);
+                                       (struct rte_ether_addr *)src_mac,
+                                       (struct rte_ether_addr *)dst_mac_0, ETHER_TYPE_IPv4, 0, 0);
                } else {
                        initialize_eth_header(test_params->pkt_eth_hdr,
-                                       (struct ether_addr *)test_params->default_slave_mac,
-                                       (struct ether_addr *)dst_mac_0, ETHER_TYPE_IPv4, 0, 0);
+                                       (struct rte_ether_addr *)test_params->default_slave_mac,
+                                       (struct rte_ether_addr *)dst_mac_0, ETHER_TYPE_IPv4, 0, 0);
                }
                pktlen = initialize_udp_header(test_params->pkt_udp_hdr, src_port,
                                dst_port_0, 16);
@@ -4201,7 +4201,7 @@ test_tlb_verify_promiscuous_enable_disable(void)
 static int
 test_tlb_verify_mac_assignment(void)
 {
-       struct ether_addr read_mac_addr, expected_mac_addr_0, expected_mac_addr_1;
+       struct rte_ether_addr read_mac_addr, expected_mac_addr_0, expected_mac_addr_1;
 
        rte_eth_macaddr_get(test_params->slave_port_ids[0], &expected_mac_addr_0);
        rte_eth_macaddr_get(test_params->slave_port_ids[1], &expected_mac_addr_1);
@@ -4284,7 +4284,7 @@ test_tlb_verify_mac_assignment(void)
 
        /* Set explicit MAC address */
        TEST_ASSERT_SUCCESS(rte_eth_bond_mac_address_set(
-                       test_params->bonded_port_id, (struct ether_addr *)bonded_mac),
+                       test_params->bonded_port_id, (struct rte_ether_addr *)bonded_mac),
                        "failed to set MAC address");
 
        rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr);
@@ -4459,14 +4459,14 @@ test_alb_change_mac_in_reply_sent(void)
        struct rte_mbuf *pkt;
        struct rte_mbuf *pkts_sent[MAX_PKT_BURST];
 
-       struct ether_hdr *eth_pkt;
+       struct rte_ether_hdr *eth_pkt;
        struct rte_arp_hdr *arp_pkt;
 
        int slave_idx, nb_pkts, pkt_idx;
        int retval = 0;
 
-       struct ether_addr bond_mac, client_mac;
-       struct ether_addr *slave_mac1, *slave_mac2;
+       struct rte_ether_addr bond_mac, client_mac;
+       struct rte_ether_addr *slave_mac1, *slave_mac2;
 
        TEST_ASSERT_SUCCESS(
                        initialize_bonded_device_with_slaves(BONDING_MODE_ALB,
@@ -4492,40 +4492,40 @@ test_alb_change_mac_in_reply_sent(void)
         */
        pkt = rte_pktmbuf_alloc(test_params->mbuf_pool);
        memcpy(client_mac.addr_bytes, mac_client1, ETHER_ADDR_LEN);
-       eth_pkt = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+       eth_pkt = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
        initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_ARP, 0,
                        0);
-       arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt + sizeof(struct ether_hdr));
+       arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt + sizeof(struct rte_ether_hdr));
        initialize_arp_header(arp_pkt, &bond_mac, &client_mac, ip_host, ip_client1,
                        RTE_ARP_OP_REPLY);
        rte_eth_tx_burst(test_params->bonded_port_id, 0, &pkt, 1);
 
        pkt = rte_pktmbuf_alloc(test_params->mbuf_pool);
        memcpy(client_mac.addr_bytes, mac_client2, ETHER_ADDR_LEN);
-       eth_pkt = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+       eth_pkt = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
        initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_ARP, 0,
                        0);
-       arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt + sizeof(struct ether_hdr));
+       arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt + sizeof(struct rte_ether_hdr));
        initialize_arp_header(arp_pkt, &bond_mac, &client_mac, ip_host, ip_client2,
                        RTE_ARP_OP_REPLY);
        rte_eth_tx_burst(test_params->bonded_port_id, 0, &pkt, 1);
 
        pkt = rte_pktmbuf_alloc(test_params->mbuf_pool);
        memcpy(client_mac.addr_bytes, mac_client3, ETHER_ADDR_LEN);
-       eth_pkt = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+       eth_pkt = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
        initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_ARP, 0,
                        0);
-       arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt + sizeof(struct ether_hdr));
+       arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt + sizeof(struct rte_ether_hdr));
        initialize_arp_header(arp_pkt, &bond_mac, &client_mac, ip_host, ip_client3,
                        RTE_ARP_OP_REPLY);
        rte_eth_tx_burst(test_params->bonded_port_id, 0, &pkt, 1);
 
        pkt = rte_pktmbuf_alloc(test_params->mbuf_pool);
        memcpy(client_mac.addr_bytes, mac_client4, ETHER_ADDR_LEN);
-       eth_pkt = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+       eth_pkt = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
        initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_ARP, 0,
                        0);
-       arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt + sizeof(struct ether_hdr));
+       arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt + sizeof(struct rte_ether_hdr));
        initialize_arp_header(arp_pkt, &bond_mac, &client_mac, ip_host, ip_client4,
                        RTE_ARP_OP_REPLY);
        rte_eth_tx_burst(test_params->bonded_port_id, 0, &pkt, 1);
@@ -4545,8 +4545,8 @@ test_alb_change_mac_in_reply_sent(void)
                                MAX_PKT_BURST);
 
                for (pkt_idx = 0; pkt_idx < nb_pkts; pkt_idx++) {
-                       eth_pkt = rte_pktmbuf_mtod(pkts_sent[pkt_idx], struct ether_hdr *);
-                       arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt + sizeof(struct ether_hdr));
+                       eth_pkt = rte_pktmbuf_mtod(pkts_sent[pkt_idx], struct rte_ether_hdr *);
+                       arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt + sizeof(struct rte_ether_hdr));
 
                        if (slave_idx%2 == 0) {
                                if (!is_same_ether_addr(slave_mac1, &arp_pkt->arp_data.arp_sha)) {
@@ -4570,7 +4570,7 @@ test_end:
 static int
 test_alb_reply_from_client(void)
 {
-       struct ether_hdr *eth_pkt;
+       struct rte_ether_hdr *eth_pkt;
        struct rte_arp_hdr *arp_pkt;
 
        struct rte_mbuf *pkt;
@@ -4579,8 +4579,8 @@ test_alb_reply_from_client(void)
        int slave_idx, nb_pkts, pkt_idx, nb_pkts_sum = 0;
        int retval = 0;
 
-       struct ether_addr bond_mac, client_mac;
-       struct ether_addr *slave_mac1, *slave_mac2;
+       struct rte_ether_addr bond_mac, client_mac;
+       struct rte_ether_addr *slave_mac1, *slave_mac2;
 
        TEST_ASSERT_SUCCESS(
                        initialize_bonded_device_with_slaves(BONDING_MODE_ALB,
@@ -4605,10 +4605,10 @@ test_alb_reply_from_client(void)
         */
        pkt = rte_pktmbuf_alloc(test_params->mbuf_pool);
        memcpy(client_mac.addr_bytes, mac_client1, ETHER_ADDR_LEN);
-       eth_pkt = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+       eth_pkt = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
        initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_ARP, 0,
                        0);
-       arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt + sizeof(struct ether_hdr));
+       arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt + sizeof(struct rte_ether_hdr));
        initialize_arp_header(arp_pkt, &client_mac, &bond_mac, ip_client1, ip_host,
                        RTE_ARP_OP_REPLY);
        virtual_ethdev_add_mbufs_to_rx_queue(test_params->slave_port_ids[0], &pkt,
@@ -4616,10 +4616,10 @@ test_alb_reply_from_client(void)
 
        pkt = rte_pktmbuf_alloc(test_params->mbuf_pool);
        memcpy(client_mac.addr_bytes, mac_client2, ETHER_ADDR_LEN);
-       eth_pkt = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+       eth_pkt = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
        initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_ARP, 0,
                        0);
-       arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt + sizeof(struct ether_hdr));
+       arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt + sizeof(struct rte_ether_hdr));
        initialize_arp_header(arp_pkt, &client_mac, &bond_mac, ip_client2, ip_host,
                        RTE_ARP_OP_REPLY);
        virtual_ethdev_add_mbufs_to_rx_queue(test_params->slave_port_ids[0], &pkt,
@@ -4627,10 +4627,10 @@ test_alb_reply_from_client(void)
 
        pkt = rte_pktmbuf_alloc(test_params->mbuf_pool);
        memcpy(client_mac.addr_bytes, mac_client3, ETHER_ADDR_LEN);
-       eth_pkt = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+       eth_pkt = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
        initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_ARP, 0,
                        0);
-       arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt + sizeof(struct ether_hdr));
+       arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt + sizeof(struct rte_ether_hdr));
        initialize_arp_header(arp_pkt, &client_mac, &bond_mac, ip_client3, ip_host,
                        RTE_ARP_OP_REPLY);
        virtual_ethdev_add_mbufs_to_rx_queue(test_params->slave_port_ids[0], &pkt,
@@ -4638,10 +4638,10 @@ test_alb_reply_from_client(void)
 
        pkt = rte_pktmbuf_alloc(test_params->mbuf_pool);
        memcpy(client_mac.addr_bytes, mac_client4, ETHER_ADDR_LEN);
-       eth_pkt = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+       eth_pkt = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
        initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_ARP, 0,
                        0);
-       arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt + sizeof(struct ether_hdr));
+       arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt + sizeof(struct rte_ether_hdr));
        initialize_arp_header(arp_pkt, &client_mac, &bond_mac, ip_client4, ip_host,
                        RTE_ARP_OP_REPLY);
        virtual_ethdev_add_mbufs_to_rx_queue(test_params->slave_port_ids[0], &pkt,
@@ -4666,8 +4666,8 @@ test_alb_reply_from_client(void)
                nb_pkts_sum += nb_pkts;
 
                for (pkt_idx = 0; pkt_idx < nb_pkts; pkt_idx++) {
-                       eth_pkt = rte_pktmbuf_mtod(pkts_sent[pkt_idx], struct ether_hdr *);
-                       arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt + sizeof(struct ether_hdr));
+                       eth_pkt = rte_pktmbuf_mtod(pkts_sent[pkt_idx], struct rte_ether_hdr *);
+                       arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt + sizeof(struct rte_ether_hdr));
 
                        if (slave_idx%2 == 0) {
                                if (!is_same_ether_addr(slave_mac1, &arp_pkt->arp_data.arp_sha)) {
@@ -4697,8 +4697,8 @@ test_end:
 static int
 test_alb_receive_vlan_reply(void)
 {
-       struct ether_hdr *eth_pkt;
-       struct vlan_hdr *vlan_pkt;
+       struct rte_ether_hdr *eth_pkt;
+       struct rte_vlan_hdr *vlan_pkt;
        struct rte_arp_hdr *arp_pkt;
 
        struct rte_mbuf *pkt;
@@ -4707,7 +4707,7 @@ test_alb_receive_vlan_reply(void)
        int slave_idx, nb_pkts, pkt_idx;
        int retval = 0;
 
-       struct ether_addr bond_mac, client_mac;
+       struct rte_ether_addr bond_mac, client_mac;
 
        TEST_ASSERT_SUCCESS(
                        initialize_bonded_device_with_slaves(BONDING_MODE_ALB,
@@ -4731,10 +4731,10 @@ test_alb_receive_vlan_reply(void)
         */
        pkt = rte_pktmbuf_alloc(test_params->mbuf_pool);
        memcpy(client_mac.addr_bytes, mac_client1, ETHER_ADDR_LEN);
-       eth_pkt = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+       eth_pkt = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
        initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_VLAN, 0,
                        0);
-       vlan_pkt = (struct vlan_hdr *)((char *)(eth_pkt + 1));
+       vlan_pkt = (struct rte_vlan_hdr *)((char *)(eth_pkt + 1));
        vlan_pkt->vlan_tci = rte_cpu_to_be_16(1);
        vlan_pkt->eth_proto = rte_cpu_to_be_16(ETHER_TYPE_VLAN);
        vlan_pkt = vlan_pkt+1;
@@ -4758,8 +4758,8 @@ test_alb_receive_vlan_reply(void)
                                MAX_PKT_BURST);
 
                for (pkt_idx = 0; pkt_idx < nb_pkts; pkt_idx++) {
-                       eth_pkt = rte_pktmbuf_mtod(pkts_sent[pkt_idx], struct ether_hdr *);
-                       vlan_pkt = (struct vlan_hdr *)((char *)(eth_pkt + 1));
+                       eth_pkt = rte_pktmbuf_mtod(pkts_sent[pkt_idx], struct rte_ether_hdr *);
+                       vlan_pkt = (struct rte_vlan_hdr *)((char *)(eth_pkt + 1));
                        if (vlan_pkt->vlan_tci != rte_cpu_to_be_16(1)) {
                                retval = -1;
                                goto test_end;
index e539f07..63fcafa 100644 (file)
 #define INVALID_PORT_ID         (0xFF)
 #define INVALID_BONDING_MODE    (-1)
 
-static const struct ether_addr slave_mac_default = {
+static const struct rte_ether_addr slave_mac_default = {
        { 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00 }
 };
 
-static const struct ether_addr parnter_mac_default = {
+static const struct rte_ether_addr parnter_mac_default = {
        { 0x22, 0xBB, 0xFF, 0xBB, 0x00, 0x00 }
 };
 
-static const struct ether_addr parnter_system = {
+static const struct rte_ether_addr parnter_system = {
        { 0x33, 0xFF, 0xBB, 0xFF, 0x00, 0x00 }
 };
 
-static const struct ether_addr slow_protocol_mac_addr = {
+static const struct rte_ether_addr slow_protocol_mac_addr = {
        { 0x01, 0x80, 0xC2, 0x00, 0x00, 0x02 }
 };
 
@@ -80,8 +80,8 @@ struct slave_conf {
 };
 
 struct ether_vlan_hdr {
-       struct ether_hdr pkt_eth_hdr;
-       struct vlan_hdr vlan_hdr;
+       struct rte_ether_hdr pkt_eth_hdr;
+       struct rte_vlan_hdr vlan_hdr;
 };
 
 struct link_bonding_unittest_params {
@@ -224,7 +224,7 @@ configure_ethdev(uint16_t port_id, uint8_t start)
 static int
 add_slave(struct slave_conf *slave, uint8_t start)
 {
-       struct ether_addr addr, addr_check;
+       struct rte_ether_addr addr, addr_check;
 
        /* Some sanity check */
        RTE_VERIFY(test_params.slave_ports <= slave &&
@@ -293,12 +293,12 @@ remove_slave(struct slave_conf *slave)
 static void
 lacp_recv_cb(uint16_t slave_id, struct rte_mbuf *lacp_pkt)
 {
-       struct ether_hdr *hdr;
+       struct rte_ether_hdr *hdr;
        struct slow_protocol_frame *slow_hdr;
 
        RTE_VERIFY(lacp_pkt != NULL);
 
-       hdr = rte_pktmbuf_mtod(lacp_pkt, struct ether_hdr *);
+       hdr = rte_pktmbuf_mtod(lacp_pkt, struct rte_ether_hdr *);
        RTE_VERIFY(hdr->ether_type == rte_cpu_to_be_16(ETHER_TYPE_SLOW));
 
        slow_hdr = rte_pktmbuf_mtod(lacp_pkt, struct slow_protocol_frame *);
@@ -474,12 +474,12 @@ testsuite_teardown(void)
 static int
 make_lacp_reply(struct slave_conf *slave, struct rte_mbuf *pkt)
 {
-       struct ether_hdr *hdr;
+       struct rte_ether_hdr *hdr;
        struct slow_protocol_frame *slow_hdr;
        struct lacpdu *lacp;
 
        /* look for LACP */
-       hdr = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+       hdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
        if (hdr->ether_type != rte_cpu_to_be_16(ETHER_TYPE_SLOW))
                return 1;
 
@@ -718,8 +718,8 @@ test_mode4_agg_mode_selection(void)
 }
 
 static int
-generate_packets(struct ether_addr *src_mac,
-       struct ether_addr *dst_mac, uint16_t count, struct rte_mbuf **buf)
+generate_packets(struct rte_ether_addr *src_mac,
+       struct rte_ether_addr *dst_mac, uint16_t count, struct rte_mbuf **buf)
 {
        uint16_t pktlen = PACKET_BURST_GEN_PKT_LEN;
        uint8_t vlan_enable = 0;
@@ -731,7 +731,7 @@ generate_packets(struct ether_addr *src_mac,
        uint32_t ip_src[4] = { [0 ... 2] = 0xDEADBEEF, [3] = IPv4(192, 168, 0, 1) };
        uint32_t ip_dst[4] = { [0 ... 2] = 0xFEEDFACE, [3] = IPv4(192, 168, 0, 2) };
 
-       struct ether_hdr pkt_eth_hdr;
+       struct rte_ether_hdr pkt_eth_hdr;
        struct udp_hdr pkt_udp_hdr;
        union {
                struct ipv4_hdr v4;
@@ -765,8 +765,8 @@ generate_packets(struct ether_addr *src_mac,
 }
 
 static int
-generate_and_put_packets(struct slave_conf *slave, struct ether_addr *src_mac,
-               struct ether_addr *dst_mac, uint16_t count)
+generate_and_put_packets(struct slave_conf *slave, struct rte_ether_addr *src_mac,
+               struct rte_ether_addr *dst_mac, uint16_t count)
 {
        struct rte_mbuf *pkts[MAX_PKT_BURST];
        int retval;
@@ -796,11 +796,11 @@ test_mode4_rx(void)
        int retval;
        unsigned delay;
 
-       struct ether_hdr *hdr;
+       struct rte_ether_hdr *hdr;
 
-       struct ether_addr src_mac = { { 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00 } };
-       struct ether_addr dst_mac;
-       struct ether_addr bonded_mac;
+       struct rte_ether_addr src_mac = { { 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00 } };
+       struct rte_ether_addr dst_mac;
+       struct rte_ether_addr bonded_mac;
 
        retval = initialize_bonded_device_with_slaves(TEST_PROMISC_SLAVE_COUNT,
                                                      0);
@@ -844,7 +844,7 @@ test_mode4_rx(void)
                int cnt[2] = { 0, 0 };
 
                for (i = 0; i < expected_pkts_cnt; i++) {
-                       hdr = rte_pktmbuf_mtod(pkts[i], struct ether_hdr *);
+                       hdr = rte_pktmbuf_mtod(pkts[i], struct rte_ether_hdr *);
                        cnt[is_same_ether_addr(&hdr->d_addr, &bonded_mac)]++;
                }
 
@@ -888,7 +888,7 @@ test_mode4_rx(void)
                int eq_cnt = 0;
 
                for (i = 0; i < expected_pkts_cnt; i++) {
-                       hdr = rte_pktmbuf_mtod(pkts[i], struct ether_hdr *);
+                       hdr = rte_pktmbuf_mtod(pkts[i], struct rte_ether_hdr *);
                        eq_cnt += is_same_ether_addr(&hdr->d_addr, &bonded_mac);
                }
 
@@ -977,8 +977,8 @@ test_mode4_tx_burst(void)
        int retval;
        unsigned delay;
 
-       struct ether_addr dst_mac = { { 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00 } };
-       struct ether_addr bonded_mac;
+       struct rte_ether_addr dst_mac = { { 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00 } };
+       struct rte_ether_addr bonded_mac;
 
        retval = initialize_bonded_device_with_slaves(TEST_TX_SLAVE_COUNT, 0);
        TEST_ASSERT_SUCCESS(retval, "Failed to initialize bonded device");
@@ -1351,7 +1351,7 @@ test_mode4_ext_ctrl(void)
        uint8_t i;
 
        struct rte_mbuf *lacp_tx_buf[SLAVE_COUNT];
-       struct ether_addr src_mac, dst_mac;
+       struct rte_ether_addr src_mac, dst_mac;
        struct lacpdu_header lacpdu = {
                .lacpdu = {
                        .subtype = SLOW_SUBTYPE_LACP,
@@ -1405,7 +1405,7 @@ test_mode4_ext_lacp(void)
 
        struct rte_mbuf *lacp_tx_buf[SLAVE_COUNT];
        struct rte_mbuf *buf[SLAVE_COUNT];
-       struct ether_addr src_mac, dst_mac;
+       struct rte_ether_addr src_mac, dst_mac;
        struct lacpdu_header lacpdu = {
                .lacpdu = {
                        .subtype = SLOW_SUBTYPE_LACP,
index d82de2c..4392522 100644 (file)
@@ -495,7 +495,7 @@ test_setup(void)
        int port_id;
        char name[256];
        struct slave_conf *port;
-       struct ether_addr mac_addr = { .addr_bytes = {0} };
+       struct rte_ether_addr mac_addr = { .addr_bytes = {0} };
 
        if (test_params.mbuf_pool == NULL) {
 
index f5095c8..1265cb8 100644 (file)
@@ -58,7 +58,7 @@
 
 static struct rte_mempool *mbufpool[NB_SOCKETS];
 /* ethernet addresses of ports */
-static struct ether_addr ports_eth_addr[RTE_MAX_ETHPORTS];
+static struct rte_ether_addr ports_eth_addr[RTE_MAX_ETHPORTS];
 
 static struct rte_eth_conf port_conf = {
        .rxmode = {
@@ -171,7 +171,7 @@ check_all_ports_link_status(uint16_t port_num, uint32_t port_mask)
 }
 
 static void
-print_ethaddr(const char *name, const struct ether_addr *eth_addr)
+print_ethaddr(const char *name, const struct rte_ether_addr *eth_addr)
 {
        char buf[ETHER_ADDR_FMT_SIZE];
        ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr);
@@ -182,7 +182,7 @@ static int
 init_traffic(struct rte_mempool *mp,
             struct rte_mbuf **pkts_burst, uint32_t burst_size)
 {
-       struct ether_hdr pkt_eth_hdr;
+       struct rte_ether_hdr pkt_eth_hdr;
        struct ipv4_hdr pkt_ipv4_hdr;
        struct udp_hdr pkt_udp_hdr;
        uint32_t pktlen;
@@ -191,8 +191,8 @@ init_traffic(struct rte_mempool *mp,
 
 
        initialize_eth_header(&pkt_eth_hdr,
-               (struct ether_addr *)src_mac,
-               (struct ether_addr *)dst_mac, ETHER_TYPE_IPv4, 0, 0);
+               (struct rte_ether_addr *)src_mac,
+               (struct rte_ether_addr *)dst_mac, ETHER_TYPE_IPv4, 0, 0);
 
        pktlen = initialize_ipv4_header(&pkt_ipv4_hdr,
                                        IPV4_ADDR(10, 0, 0, 1),
index 32e500b..3cbf584 100644 (file)
@@ -78,15 +78,15 @@ create_mempool(void)
 static void
 prepare_pkt(struct rte_mbuf *mbuf)
 {
-       struct ether_hdr *eth_hdr;
-       struct vlan_hdr *vlan1, *vlan2;
+       struct rte_ether_hdr *eth_hdr;
+       struct rte_vlan_hdr *vlan1, *vlan2;
        struct ipv4_hdr *ip_hdr;
 
        /* Simulate a classifier */
-       eth_hdr = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
-       vlan1 = (struct vlan_hdr *)(&eth_hdr->ether_type );
-       vlan2 = (struct vlan_hdr *)((uintptr_t)&eth_hdr->ether_type + sizeof(struct vlan_hdr));
-       eth_hdr = (struct ether_hdr *)((uintptr_t)&eth_hdr->ether_type + 2 *sizeof(struct vlan_hdr));
+       eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+       vlan1 = (struct rte_vlan_hdr *)(&eth_hdr->ether_type );
+       vlan2 = (struct rte_vlan_hdr *)((uintptr_t)&eth_hdr->ether_type + sizeof(struct rte_vlan_hdr));
+       eth_hdr = (struct rte_ether_hdr *)((uintptr_t)&eth_hdr->ether_type + 2 *sizeof(struct rte_vlan_hdr));
        ip_hdr = (struct ipv4_hdr *)((uintptr_t)eth_hdr +  sizeof(eth_hdr->ether_type));
 
        vlan1->vlan_tci = rte_cpu_to_be_16(SUBPORT);
index f8ddc2d..15ce644 100644 (file)
@@ -218,7 +218,7 @@ virtual_ethdev_promiscuous_mode_disable(struct rte_eth_dev *dev __rte_unused)
 
 static int
 virtual_ethdev_mac_address_set(__rte_unused struct rte_eth_dev *dev,
-                              __rte_unused struct ether_addr *addr)
+                              __rte_unused struct rte_ether_addr *addr)
 {
        return 0;
 }
@@ -496,7 +496,7 @@ virtual_ethdev_get_mbufs_from_tx_queue(uint16_t port_id,
 
 
 int
-virtual_ethdev_create(const char *name, struct ether_addr *mac_addr,
+virtual_ethdev_create(const char *name, struct rte_ether_addr *mac_addr,
                uint8_t socket_id, uint8_t isr_support)
 {
        struct rte_pci_device *pci_dev = NULL;
index 5ca02bb..120b58b 100644 (file)
@@ -15,7 +15,7 @@ int
 virtual_ethdev_init(void);
 
 int
-virtual_ethdev_create(const char *name, struct ether_addr *mac_addr,
+virtual_ethdev_create(const char *name, struct rte_ether_addr *mac_addr,
                uint8_t socket_id, uint8_t isr_support);
 
 void