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

net: add rte prefix to ether functions

Browse Source 
Add 'rte_' prefix to functions:
- rename is_same_ether_addr() as rte_is_same_ether_addr().
- rename is_zero_ether_addr() as rte_is_zero_ether_addr().
- rename is_unicast_ether_addr() as rte_is_unicast_ether_addr().
- rename is_multicast_ether_addr() as rte_is_multicast_ether_addr().
- rename is_broadcast_ether_addr() as rte_is_broadcast_ether_addr().
- rename is_universal_ether_addr() as rte_is_universal_ether_addr().
- rename is_local_admin_ether_addr() as rte_is_local_admin_ether_addr().
- rename is_valid_assigned_ether_addr() as rte_is_valid_assigned_ether_addr().
- rename eth_random_addr() as rte_eth_random_addr().
- rename ether_addr_copy() as rte_ether_addr_copy().
- rename ether_format_addr() as rte_ether_format_addr().

Signed-off-by: Olivier Matz <olivier.matz@6wind.com>
Reviewed-by: Stephen Hemminger <stephen@networkplumber.org>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
Reviewed-by: Ferruh Yigit <ferruh.yigit@intel.com>
This commit is contained in:
Olivier Matz 2019-05-21 18:13:04 +02:00 committed by Ferruh Yigit
parent 6d13ea8e8e
commit 538da7a1ca
122 changed files with 506 additions and 444 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -8813,8 +8813,8 @@ cmd_tunnel_filter_parsed(void *parsed_result,
memset(&tunnel_filter_conf, 0, sizeof(tunnel_filter_conf));
ether_addr_copy(&res->outer_mac, &tunnel_filter_conf.outer_mac);
ether_addr_copy(&res->inner_mac, &tunnel_filter_conf.inner_mac);
rte_ether_addr_copy(&res->outer_mac, &tunnel_filter_conf.outer_mac);
rte_ether_addr_copy(&res->inner_mac, &tunnel_filter_conf.inner_mac);
tunnel_filter_conf.inner_vlan = res->inner_vlan;
if (res->ip_value.family == AF_INET) {
@ -12472,7 +12472,7 @@ static void cmd_mcast_addr_parsed(void *parsed_result,
{
struct cmd_mcast_addr_result *res = parsed_result;
if (!is_multicast_ether_addr(&res->mc_addr)) {
if (!rte_is_multicast_ether_addr(&res->mc_addr)) {
printf("Invalid multicast addr %02X:%02X:%02X:%02X:%02X:%02X\n",
res->mc_addr.addr_bytes[0], res->mc_addr.addr_bytes[1],
res->mc_addr.addr_bytes[2], res->mc_addr.addr_bytes[3],

8
app/test-pmd/config.c
View File

@ -111,7 +111,7 @@ static void
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);
rte_ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr);
printf("%s%s", name, buf);
}
@ -3536,7 +3536,7 @@ mcast_addr_add(portid_t port_id, struct rte_ether_addr *mc_addr)
* in the pool of multicast addresses.
*/
for (i = 0; i < port->mc_addr_nb; i++) {
if (is_same_ether_addr(mc_addr, &port->mc_addr_pool[i])) {
if (rte_is_same_ether_addr(mc_addr, &port->mc_addr_pool[i])) {
printf("multicast address already filtered by port\n");
return;
}
@ -3544,7 +3544,7 @@ mcast_addr_add(portid_t port_id, struct rte_ether_addr *mc_addr)
if (mcast_addr_pool_extend(port) != 0)
return;
ether_addr_copy(mc_addr, &port->mc_addr_pool[i]);
rte_ether_addr_copy(mc_addr, &port->mc_addr_pool[i]);
eth_port_multicast_addr_list_set(port_id);
}
@ -3563,7 +3563,7 @@ mcast_addr_remove(portid_t port_id, struct rte_ether_addr *mc_addr)
* Search the pool of multicast MAC addresses for the removed address.
*/
for (i = 0; i < port->mc_addr_nb; i++) {
if (is_same_ether_addr(mc_addr, &port->mc_addr_pool[i]))
if (rte_is_same_ether_addr(mc_addr, &port->mc_addr_pool[i]))
break;
}
if (i == port->mc_addr_nb) {

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

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

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

@ -171,8 +171,8 @@ pkt_burst_flow_gen(struct fwd_stream *fs)
/* Initialize Ethernet header. */
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);
rte_ether_addr_copy(&cfg_ether_dst, &eth_hdr->d_addr);
rte_ether_addr_copy(&cfg_ether_src, &eth_hdr->s_addr);
eth_hdr->ether_type = rte_cpu_to_be_16(ETHER_TYPE_IPv4);
/* Initialize IP header. */

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

@ -225,7 +225,7 @@ ether_addr_dump(const char *what, const struct rte_ether_addr *ea)
{
char buf[ETHER_ADDR_FMT_SIZE];
ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, ea);
rte_ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, ea);
if (what)
printf("%s", what);
printf("%s", buf);
@ -370,12 +370,14 @@ reply_to_icmp_echo_rqsts(struct fwd_stream *fs)
continue;
}
if (verbose_level > 0) {
ether_addr_copy(&arp_h->arp_data.arp_sha, &eth_addr);
rte_ether_addr_copy(&arp_h->arp_data.arp_sha,
&eth_addr);
ether_addr_dump(" sha=", &eth_addr);
ip_addr = arp_h->arp_data.arp_sip;
ipv4_addr_dump(" sip=", ip_addr);
printf("\n");
ether_addr_copy(&arp_h->arp_data.arp_tha, &eth_addr);
rte_ether_addr_copy(&arp_h->arp_data.arp_tha,
&eth_addr);
ether_addr_dump(" tha=", &eth_addr);
ip_addr = arp_h->arp_data.arp_tip;
ipv4_addr_dump(" tip=", ip_addr);
@ -391,15 +393,18 @@ reply_to_icmp_echo_rqsts(struct fwd_stream *fs)
*/
/* Use source MAC address as destination MAC address. */
ether_addr_copy(&eth_h->s_addr, &eth_h->d_addr);
rte_ether_addr_copy(&eth_h->s_addr, &eth_h->d_addr);
/* Set source MAC address with MAC address of TX port */
ether_addr_copy(&ports[fs->tx_port].eth_addr,
rte_ether_addr_copy(&ports[fs->tx_port].eth_addr,
&eth_h->s_addr);
arp_h->arp_opcode = rte_cpu_to_be_16(RTE_ARP_OP_REPLY);
ether_addr_copy(&arp_h->arp_data.arp_tha, &eth_addr);
ether_addr_copy(&arp_h->arp_data.arp_sha, &arp_h->arp_data.arp_tha);
ether_addr_copy(&eth_h->s_addr, &arp_h->arp_data.arp_sha);
rte_ether_addr_copy(&arp_h->arp_data.arp_tha,
&eth_addr);
rte_ether_addr_copy(&arp_h->arp_data.arp_sha,
&arp_h->arp_data.arp_tha);
rte_ether_addr_copy(&eth_h->s_addr,
&arp_h->arp_data.arp_sha);
/* Swap IP addresses in ARP payload */
ip_addr = arp_h->arp_data.arp_sip;
@ -456,9 +461,9 @@ reply_to_icmp_echo_rqsts(struct fwd_stream *fs)
* ICMP checksum is computed by assuming it is valid in the
* echo request and not verified.
*/
ether_addr_copy(&eth_h->s_addr, &eth_addr);
ether_addr_copy(&eth_h->d_addr, &eth_h->s_addr);
ether_addr_copy(&eth_addr, &eth_h->d_addr);
rte_ether_addr_copy(&eth_h->s_addr, &eth_addr);
rte_ether_addr_copy(&eth_h->d_addr, &eth_h->s_addr);
rte_ether_addr_copy(&eth_addr, &eth_h->d_addr);
ip_addr = ip_h->src_addr;
if (is_multicast_ipv4_addr(ip_h->dst_addr)) {
uint32_t ip_src;

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

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

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

@ -92,9 +92,9 @@ pkt_burst_mac_forward(struct fwd_stream *fs)
void *));
mb = pkts_burst[i];
eth_hdr = rte_pktmbuf_mtod(mb, struct rte_ether_hdr *);
ether_addr_copy(&peer_eth_addrs[fs->peer_addr],
rte_ether_addr_copy(&peer_eth_addrs[fs->peer_addr],
&eth_hdr->d_addr);
ether_addr_copy(&ports[fs->tx_port].eth_addr,
rte_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;

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

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

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

@ -266,8 +266,8 @@ pkt_burst_transmit(struct fwd_stream *fs)
/*
* Initialize Ethernet header.
*/
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);
rte_ether_addr_copy(&peer_eth_addrs[fs->peer_addr], &eth_hdr.d_addr);
rte_ether_addr_copy(&ports[fs->tx_port].eth_addr, &eth_hdr.s_addr);
eth_hdr.ether_type = rte_cpu_to_be_16(ETHER_TYPE_IPv4);
if (rte_mempool_get_bulk(mbp, (void **)pkts_burst,

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

@ -17,7 +17,7 @@ static inline void
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);
rte_ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr);
printf("%s%s", what, buf);
}

8
app/test/packet_burst_generator.c
View File

@ -58,8 +58,8 @@ initialize_eth_header(struct rte_ether_hdr *eth_hdr,
struct rte_ether_addr *dst_mac, uint16_t ether_type,
uint8_t vlan_enabled, uint16_t van_id)
{
ether_addr_copy(dst_mac, &eth_hdr->d_addr);
ether_addr_copy(src_mac, &eth_hdr->s_addr);
rte_ether_addr_copy(dst_mac, &eth_hdr->d_addr);
rte_ether_addr_copy(src_mac, &eth_hdr->s_addr);
if (vlan_enabled) {
struct rte_vlan_hdr *vhdr = (struct rte_vlan_hdr *)(
@ -86,9 +86,9 @@ initialize_arp_header(struct rte_arp_hdr *arp_hdr,
arp_hdr->arp_hlen = ETHER_ADDR_LEN;
arp_hdr->arp_plen = sizeof(uint32_t);
arp_hdr->arp_opcode = rte_cpu_to_be_16(opcode);
ether_addr_copy(src_mac, &arp_hdr->arp_data.arp_sha);
rte_ether_addr_copy(src_mac, &arp_hdr->arp_data.arp_sha);
arp_hdr->arp_data.arp_sip = src_ip;
ether_addr_copy(dst_mac, &arp_hdr->arp_data.arp_tha);
rte_ether_addr_copy(dst_mac, &arp_hdr->arp_data.arp_tha);
arp_hdr->arp_data.arp_tip = dst_ip;
}

18
app/test/test_link_bonding.c
View File

@ -4510,7 +4510,7 @@ test_alb_change_mac_in_reply_sent(void)
MAX_PKT_BURST);
}
ether_addr_copy(
rte_ether_addr_copy(
rte_eth_devices[test_params->bonded_port_id].data->mac_addrs,
&bond_mac);
@ -4583,12 +4583,14 @@ test_alb_change_mac_in_reply_sent(void)
sizeof(struct rte_ether_hdr));
if (slave_idx%2 == 0) {
if (!is_same_ether_addr(slave_mac1, &arp_pkt->arp_data.arp_sha)) {
if (!rte_is_same_ether_addr(slave_mac1,
&arp_pkt->arp_data.arp_sha)) {
retval = -1;
goto test_end;
}
} else {
if (!is_same_ether_addr(slave_mac2, &arp_pkt->arp_data.arp_sha)) {
if (!rte_is_same_ether_addr(slave_mac2,
&arp_pkt->arp_data.arp_sha)) {
retval = -1;
goto test_end;
}
@ -4629,7 +4631,7 @@ test_alb_reply_from_client(void)
MAX_PKT_BURST);
}
ether_addr_copy(
rte_ether_addr_copy(
rte_eth_devices[test_params->bonded_port_id].data->mac_addrs,
&bond_mac);
@ -4710,12 +4712,14 @@ test_alb_reply_from_client(void)
sizeof(struct rte_ether_hdr));
if (slave_idx%2 == 0) {
if (!is_same_ether_addr(slave_mac1, &arp_pkt->arp_data.arp_sha)) {
if (!rte_is_same_ether_addr(slave_mac1,
&arp_pkt->arp_data.arp_sha)) {
retval = -1;
goto test_end;
}
} else {
if (!is_same_ether_addr(slave_mac2, &arp_pkt->arp_data.arp_sha)) {
if (!rte_is_same_ether_addr(slave_mac2,
&arp_pkt->arp_data.arp_sha)) {
retval = -1;
goto test_end;
}
@ -4762,7 +4766,7 @@ test_alb_receive_vlan_reply(void)
MAX_PKT_BURST);
}
ether_addr_copy(
rte_ether_addr_copy(
rte_eth_devices[test_params->bonded_port_id].data->mac_addrs,
&bond_mac);

29
app/test/test_link_bonding_mode4.c
View File

@ -232,7 +232,7 @@ add_slave(struct slave_conf *slave, uint8_t start)
RTE_VERIFY(slave->bonded == 0);
RTE_VERIFY(slave->port_id != INVALID_PORT_ID);
ether_addr_copy(&slave_mac_default, &addr);
rte_ether_addr_copy(&slave_mac_default, &addr);
addr.addr_bytes[ETHER_ADDR_LEN - 1] = slave->port_id;
rte_eth_dev_mac_addr_remove(slave->port_id, &addr);
@ -253,7 +253,7 @@ add_slave(struct slave_conf *slave, uint8_t start)
}
rte_eth_macaddr_get(slave->port_id, &addr_check);
TEST_ASSERT_EQUAL(is_same_ether_addr(&addr, &addr_check), 1,
TEST_ASSERT_EQUAL(rte_is_same_ether_addr(&addr, &addr_check), 1,
"Slave MAC address is not as expected");
RTE_VERIFY(slave->lacp_parnter_state == 0);
@ -491,7 +491,7 @@ make_lacp_reply(struct slave_conf *slave, struct rte_mbuf *pkt)
slow_hdr = rte_pktmbuf_mtod(pkt, struct slow_protocol_frame *);
/* Change source address to partner address */
ether_addr_copy(&parnter_mac_default, &slow_hdr->eth_hdr.s_addr);
rte_ether_addr_copy(&parnter_mac_default, &slow_hdr->eth_hdr.s_addr);
slow_hdr->eth_hdr.s_addr.addr_bytes[ETHER_ADDR_LEN - 1] = slave->port_id;
lacp = (struct lacpdu *) &slow_hdr->slow_protocol;
@ -503,7 +503,7 @@ make_lacp_reply(struct slave_conf *slave, struct rte_mbuf *pkt)
lacp->partner.state = lacp->actor.state;
ether_addr_copy(&parnter_system, &lacp->actor.port_params.system);
rte_ether_addr_copy(&parnter_system, &lacp->actor.port_params.system);
lacp->actor.state = STATE_LACP_ACTIVE |
STATE_SYNCHRONIZATION |
STATE_AGGREGATION |
@ -812,7 +812,7 @@ test_mode4_rx(void)
TEST_ASSERT_SUCCESS(retval, "Initial handshake failed");
rte_eth_macaddr_get(test_params.bonded_port_id, &bonded_mac);
ether_addr_copy(&bonded_mac, &dst_mac);
rte_ether_addr_copy(&bonded_mac, &dst_mac);
/* Assert that dst address is not bonding address. Do not set the
* least significant bit of the zero byte as this would create a
@ -847,7 +847,8 @@ test_mode4_rx(void)
for (i = 0; i < expected_pkts_cnt; i++) {
hdr = rte_pktmbuf_mtod(pkts[i], struct rte_ether_hdr *);
cnt[is_same_ether_addr(&hdr->d_addr, &bonded_mac)]++;
cnt[rte_is_same_ether_addr(&hdr->d_addr,
&bonded_mac)]++;
}
free_pkts(pkts, expected_pkts_cnt);
@ -891,7 +892,8 @@ test_mode4_rx(void)
for (i = 0; i < expected_pkts_cnt; i++) {
hdr = rte_pktmbuf_mtod(pkts[i], struct rte_ether_hdr *);
eq_cnt += is_same_ether_addr(&hdr->d_addr, &bonded_mac);
eq_cnt += rte_is_same_ether_addr(&hdr->d_addr,
&bonded_mac);
}
free_pkts(pkts, expected_pkts_cnt);
@ -1133,10 +1135,11 @@ init_marker(struct rte_mbuf *pkt, struct slave_conf *slave)
struct marker_header *);
/* Copy multicast destination address */
ether_addr_copy(&slow_protocol_mac_addr, &marker_hdr->eth_hdr.d_addr);
rte_ether_addr_copy(&slow_protocol_mac_addr,
&marker_hdr->eth_hdr.d_addr);
/* Init source address */
ether_addr_copy(&parnter_mac_default, &marker_hdr->eth_hdr.s_addr);
rte_ether_addr_copy(&parnter_mac_default, &marker_hdr->eth_hdr.s_addr);
marker_hdr->eth_hdr.s_addr.addr_bytes[ETHER_ADDR_LEN-1] = slave->port_id;
marker_hdr->eth_hdr.ether_type = rte_cpu_to_be_16(ETHER_TYPE_SLOW);
@ -1361,8 +1364,8 @@ test_mode4_ext_ctrl(void)
},
};
ether_addr_copy(&parnter_system, &src_mac);
ether_addr_copy(&slow_protocol_mac_addr, &dst_mac);
rte_ether_addr_copy(&parnter_system, &src_mac);
rte_ether_addr_copy(&slow_protocol_mac_addr, &dst_mac);
initialize_eth_header(&lacpdu.eth_hdr, &src_mac, &dst_mac,
ETHER_TYPE_SLOW, 0, 0);
@ -1415,8 +1418,8 @@ test_mode4_ext_lacp(void)
},
};
ether_addr_copy(&parnter_system, &src_mac);
ether_addr_copy(&slow_protocol_mac_addr, &dst_mac);
rte_ether_addr_copy(&parnter_system, &src_mac);
rte_ether_addr_copy(&slow_protocol_mac_addr, &dst_mac);
initialize_eth_header(&lacpdu.eth_hdr, &src_mac, &dst_mac,
ETHER_TYPE_SLOW, 0, 0);

2
app/test/test_pmd_perf.c
View File

@ -174,7 +174,7 @@ static void
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);
rte_ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr);
printf("%s%s", name, buf);
}

4
doc/guides/sample_app_ug/ipv4_multicast.rst
View File

@ -227,8 +227,8 @@ The actual packet transmission is done in the mcast_send_pkt() function:
RTE_ASSERT(ethdr != NULL);
ether_addr_copy(dest_addr, &ethdr->d_addr);
ether_addr_copy(&ports_eth_addr[port], &ethdr->s_addr);
rte_ether_addr_copy(dest_addr, &ethdr->d_addr);
rte_ether_addr_copy(&ports_eth_addr[port], &ethdr->s_addr);
ethdr->ether_type = rte_be_to_cpu_16(ETHER_TYPE_IPv4);
/* Put new packet into the output queue */

2
doc/guides/sample_app_ug/l2_forward_job_stats.rst
View File

@ -467,7 +467,7 @@ Naturally, the number of ports in the portmask must be even, otherwise, the appl
/* src addr */
ether_addr_copy(&l2fwd_ports_eth_addr[dst_port], &eth->s_addr);
rte_ether_addr_copy(&l2fwd_ports_eth_addr[dst_port], &eth->s_addr);
l2fwd_send_packet(m, (uint8_t) dst_port);
}

2
doc/guides/sample_app_ug/l2_forward_real_virtual.rst
View File

@ -383,7 +383,7 @@ Naturally, the number of ports in the portmask must be even, otherwise, the appl
/* src addr */
ether_addr_copy(&l2fwd_ports_eth_addr[dst_port], &eth->s_addr);
rte_ether_addr_copy(&l2fwd_ports_eth_addr[dst_port], &eth->s_addr);
l2fwd_send_packet(m, (uint8_t) dst_port);
}

2
doc/guides/sample_app_ug/link_status_intr.rst
View File

@ -324,7 +324,7 @@ The processing is very simple: processes the TX port from the RX port and then r
*((uint64_t *)tmp) = 0x000000000002 + (dst_port << 40);
/* src addr */
ether_addr_copy(&lsi_ports_eth_addr[dst_port], &eth->s_addr);
rte_ether_addr_copy(&lsi_ports_eth_addr[dst_port], &eth->s_addr);
lsi_send_packet(m, dst_port);
}

2
drivers/net/atlantic/atl_ethdev.c
View File

@ -1578,7 +1578,7 @@ static int
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)) {
if (rte_is_zero_ether_addr(mac_addr)) {
PMD_DRV_LOG(ERR, "Invalid Ethernet Address");
return -EINVAL;
}

4
drivers/net/atlantic/hw_atl/hw_atl_utils.c
View File

@ -657,7 +657,7 @@ 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 rte_ether_addr *)mac_addr,
rte_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)) {
@ -868,7 +868,7 @@ 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 rte_ether_addr *)mac,
rte_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);

2
drivers/net/atlantic/hw_atl/hw_atl_utils_fw2x.c
View File

@ -228,7 +228,7 @@ 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 rte_ether_addr *)mac_addr,
rte_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)) {

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

@ -1014,7 +1014,7 @@ eth_avp_dev_init(struct rte_eth_dev *eth_dev)
}
/* Get a mac from device config */
ether_addr_copy(&avp->ethaddr, &eth_dev->data->mac_addrs[0]);
rte_ether_addr_copy(&avp->ethaddr, &eth_dev->data->mac_addrs[0]);
return 0;
}
@ -1216,12 +1216,12 @@ _avp_mac_filter(struct avp_dev *avp, struct rte_mbuf *m)
return 0;
}
if (likely(is_broadcast_ether_addr(&eth->d_addr))) {
if (likely(rte_is_broadcast_ether_addr(&eth->d_addr))) {
/* allow all broadcast packets */
return 0;
}
if (likely(is_multicast_ether_addr(&eth->d_addr))) {
if (likely(rte_is_multicast_ether_addr(&eth->d_addr))) {
/* allow all multicast packets */
return 0;
}

6
drivers/net/axgbe/axgbe_ethdev.c
View File

@ -634,11 +634,11 @@ eth_axgbe_dev_init(struct rte_eth_dev *eth_dev)
return -ENOMEM;
}
if (!is_valid_assigned_ether_addr(&pdata->mac_addr))
eth_random_addr(pdata->mac_addr.addr_bytes);
if (!rte_is_valid_assigned_ether_addr(&pdata->mac_addr))
rte_eth_random_addr(pdata->mac_addr.addr_bytes);
/* Copy the permanent MAC address */
ether_addr_copy(&pdata->mac_addr, &eth_dev->data->mac_addrs[0]);
rte_ether_addr_copy(&pdata->mac_addr, &eth_dev->data->mac_addrs[0]);
/* Clock settings */
pdata->sysclk_rate = AXGBE_V2_DMA_CLOCK_FREQ;

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

@ -2214,8 +2214,8 @@ int bnx2x_tx_encap(struct bnx2x_tx_queue *txq, struct rte_mbuf *m0)
tx_parse_bd =
&txq->tx_ring[TX_BD(bd_prod, txq)].parse_bd_e2;
if (is_multicast_ether_addr(&eh->d_addr)) {
if (is_broadcast_ether_addr(&eh->d_addr))
if (rte_is_multicast_ether_addr(&eh->d_addr)) {
if (rte_is_broadcast_ether_addr(&eh->d_addr))
mac_type = BROADCAST_ADDRESS;
else
mac_type = MULTICAST_ADDRESS;

6
drivers/net/bnx2x/bnx2x_vfpf.c
View File

@ -300,11 +300,11 @@ int bnx2x_vf_get_resources(struct bnx2x_softc *sc, uint8_t tx_count, uint8_t rx_
sc->igu_sb_cnt, sc->igu_base_sb);
strncpy(sc->fw_ver, sc_resp.fw_ver, sizeof(sc->fw_ver));
if (is_valid_assigned_ether_addr(&sc_resp.resc.current_mac_addr))
ether_addr_copy(&sc_resp.resc.current_mac_addr,
if (rte_is_valid_assigned_ether_addr(&sc_resp.resc.current_mac_addr))
rte_ether_addr_copy(&sc_resp.resc.current_mac_addr,
(struct rte_ether_addr *)sc->link_params.mac_addr);
else
eth_random_addr(sc->link_params.mac_addr);
rte_eth_random_addr(sc->link_params.mac_addr);
out:
bnx2x_vf_finalize(sc, &acq->first_tlv);

12
drivers/net/bnxt/bnxt_flow.c
View File

@ -187,10 +187,10 @@ bnxt_validate_and_parse_flow_type(struct bnxt *bp,
* Destination MAC address mask must not be partially
* set. Should be all 1's or all 0's.
*/
if ((!is_zero_ether_addr(&eth_mask->src) &&
!is_broadcast_ether_addr(&eth_mask->src)) ||
(!is_zero_ether_addr(&eth_mask->dst) &&
!is_broadcast_ether_addr(&eth_mask->dst))) {
if ((!rte_is_zero_ether_addr(&eth_mask->src) &&
!rte_is_broadcast_ether_addr(&eth_mask->src)) ||
(!rte_is_zero_ether_addr(&eth_mask->dst) &&
!rte_is_broadcast_ether_addr(&eth_mask->dst))) {
rte_flow_error_set(error,
EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
@ -209,7 +209,7 @@ bnxt_validate_and_parse_flow_type(struct bnxt *bp,
return -rte_errno;
}
if (is_broadcast_ether_addr(&eth_mask->dst)) {
if (rte_is_broadcast_ether_addr(&eth_mask->dst)) {
rte_memcpy(filter->dst_macaddr,
&eth_spec->dst, 6);
en |= use_ntuple ?
@ -217,7 +217,7 @@ bnxt_validate_and_parse_flow_type(struct bnxt *bp,
EM_FLOW_ALLOC_INPUT_EN_DST_MACADDR;
}
if (is_broadcast_ether_addr(&eth_mask->src)) {
if (rte_is_broadcast_ether_addr(&eth_mask->src)) {
rte_memcpy(filter->src_macaddr,
&eth_spec->src, 6);
en |= use_ntuple ?

2
drivers/net/bnxt/bnxt_hwrm.c
View File

@ -2586,7 +2586,7 @@ static void add_random_mac_if_needed(struct bnxt *bp,
if (memcmp(mac.addr_bytes, "\x00\x00\x00\x00\x00", 6) == 0) {
cfg_req->enables |=
rte_cpu_to_le_32(HWRM_FUNC_CFG_INPUT_ENABLES_DFLT_MAC_ADDR);
eth_random_addr(cfg_req->dflt_mac_addr);
rte_eth_random_addr(cfg_req->dflt_mac_addr);
bp->pf.vf_info[vf].random_mac = true;
} else {
memcpy(cfg_req->dflt_mac_addr, mac.addr_bytes, ETHER_ADDR_LEN);

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

@ -322,7 +322,7 @@ rx_machine(struct bond_dev_private *internals, uint16_t slave_id,
agg = &bond_mode_8023ad_ports[port->aggregator_port_id];
bool match = port->actor.system_priority ==
lacp->partner.port_params.system_priority &&
is_same_ether_addr(&agg->actor.system,
rte_is_same_ether_addr(&agg->actor.system,
&lacp->partner.port_params.system) &&
port->actor.port_priority ==
lacp->partner.port_params.port_priority &&
@ -575,7 +575,7 @@ tx_machine(struct bond_dev_private *internals, uint16_t slave_id)
hdr = rte_pktmbuf_mtod(lacp_pkt, struct lacpdu_header *);
/* Source and destination MAC */
ether_addr_copy(&lacp_mac_addr, &hdr->eth_hdr.d_addr);
rte_ether_addr_copy(&lacp_mac_addr, &hdr->eth_hdr.d_addr);
rte_eth_macaddr_get(slave_id, &hdr->eth_hdr.s_addr);
hdr->eth_hdr.ether_type = rte_cpu_to_be_16(ETHER_TYPE_SLOW);
@ -592,7 +592,8 @@ tx_machine(struct bond_dev_private *internals, uint16_t slave_id)
memcpy(&hdr->lacpdu.actor.port_params, &port->actor,
sizeof(port->actor));
agg = &bond_mode_8023ad_ports[port->aggregator_port_id];
ether_addr_copy(&agg->actor.system, &hdr->lacpdu.actor.port_params.system);
rte_ether_addr_copy(&agg->actor.system,
&hdr->lacpdu.actor.port_params.system);
lacpdu->actor.state = port->actor_state;
/* PARTNER */
@ -694,9 +695,10 @@ selection_logic(struct bond_dev_private *internals, uint16_t slave_id)
* ID (MAC address). */
if ((agg->actor.key == port->actor.key &&
agg->partner.system_priority == port->partner.system_priority &&
is_same_ether_addr(&agg->partner.system, &port->partner.system) == 1
rte_is_same_ether_addr(&agg->partner.system,
&port->partner.system) == 1
&& (agg->partner.key == port->partner.key)) &&
is_zero_ether_addr(&port->partner.system) != 1 &&
rte_is_zero_ether_addr(&port->partner.system) != 1 &&
(agg->actor.key &
rte_cpu_to_be_16(BOND_LINK_FULL_DUPLEX_KEY)) != 0) {
@ -791,7 +793,7 @@ rx_machine_update(struct bond_dev_private *internals, uint16_t slave_id,
RTE_ASSERT(lacp->lacpdu.subtype == SLOW_SUBTYPE_LACP);
partner = &lacp->lacpdu.partner;
if (is_same_ether_addr(&partner->port_params.system,
if (rte_is_same_ether_addr(&partner->port_params.system,
&internals->mode4.mac_addr)) {
/* This LACP frame is sending to the bonding port
* so pass it to rx_machine.
@ -842,8 +844,8 @@ bond_mode_8023ad_periodic_cb(void *arg)
SM_FLAG_SET(port, NTT);
}
if (!is_same_ether_addr(&port->actor.system, &slave_addr)) {
ether_addr_copy(&slave_addr, &port->actor.system);
if (!rte_is_same_ether_addr(&port->actor.system, &slave_addr)) {
rte_ether_addr_copy(&slave_addr, &port->actor.system);
if (port->aggregator_port_id == slave_id)
SM_FLAG_SET(port, NTT);
}
@ -1055,10 +1057,10 @@ bond_mode_8023ad_mac_address_update(struct rte_eth_dev *bond_dev)
slave = &bond_mode_8023ad_ports[slave_id];
rte_eth_macaddr_get(slave_id, &slave_addr);
if (is_same_ether_addr(&slave_addr, &slave->actor.system))
if (rte_is_same_ether_addr(&slave_addr, &slave->actor.system))
continue;
ether_addr_copy(&slave_addr, &slave->actor.system);
rte_ether_addr_copy(&slave_addr, &slave->actor.system);
/* Do nothing if this port is not an aggregator. In other case
* Set NTT flag on every port that use this aggregator. */
if (slave->aggregator_port_id != slave_id)

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

@ -102,17 +102,21 @@ void bond_mode_alb_arp_recv(struct rte_ether_hdr *eth_h, uint16_t offset,
if (client_info->in_use == 0 ||
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) ||
!rte_is_same_ether_addr(&client_info->cli_mac,
&arp->arp_data.arp_sha) ||
client_info->vlan_count != offset / sizeof(struct rte_vlan_hdr) ||
memcmp(client_info->vlan, eth_h + 1, offset) != 0
) {
client_info->in_use = 1;
client_info->app_ip = arp->arp_data.arp_tip;
client_info->cli_ip = arp->arp_data.arp_sip;
ether_addr_copy(&arp->arp_data.arp_sha, &client_info->cli_mac);
rte_ether_addr_copy(&arp->arp_data.arp_sha,
&client_info->cli_mac);
client_info->slave_idx = calculate_slave(internals);
rte_eth_macaddr_get(client_info->slave_idx, &client_info->app_mac);
ether_addr_copy(&client_info->app_mac, &arp->arp_data.arp_tha);
rte_eth_macaddr_get(client_info->slave_idx,
&client_info->app_mac);
rte_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 rte_vlan_hdr);
}
@ -140,7 +144,7 @@ bond_mode_alb_arp_xmit(struct rte_ether_hdr *eth_h, uint16_t offset,
* current primary port.
*/
rte_eth_macaddr_get(internals->port_id, &bonding_mac);
if (!is_same_ether_addr(&bonding_mac, &arp->arp_data.arp_sha)) {
if (!rte_is_same_ether_addr(&bonding_mac, &arp->arp_data.arp_sha)) {
rte_eth_macaddr_get(internals->current_primary_port,
&arp->arp_data.arp_sha);
return internals->current_primary_port;
@ -156,13 +160,16 @@ bond_mode_alb_arp_xmit(struct rte_ether_hdr *eth_h, uint16_t offset,
if (client_info->app_ip == arp->arp_data.arp_sip &&
client_info->cli_ip == arp->arp_data.arp_tip) {
/* Entry is already assigned to this client */
if (!is_broadcast_ether_addr(&arp->arp_data.arp_tha)) {
ether_addr_copy(&arp->arp_data.arp_tha,
&client_info->cli_mac);
if (!rte_is_broadcast_ether_addr(
&arp->arp_data.arp_tha)) {
rte_ether_addr_copy(
&arp->arp_data.arp_tha,
&client_info->cli_mac);
}
rte_eth_macaddr_get(client_info->slave_idx,
&client_info->app_mac);
ether_addr_copy(&client_info->app_mac, &arp->arp_data.arp_sha);
rte_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 rte_vlan_hdr);
rte_spinlock_unlock(&internals->mode6.lock);
@ -174,11 +181,14 @@ bond_mode_alb_arp_xmit(struct rte_ether_hdr *eth_h, uint16_t offset,
client_info->in_use = 1;
client_info->ntt = 0;
client_info->app_ip = arp->arp_data.arp_sip;
ether_addr_copy(&arp->arp_data.arp_tha, &client_info->cli_mac);
rte_ether_addr_copy(&arp->arp_data.arp_tha,
&client_info->cli_mac);
client_info->cli_ip = arp->arp_data.arp_tip;
client_info->slave_idx = calculate_slave(internals);
rte_eth_macaddr_get(client_info->slave_idx, &client_info->app_mac);
ether_addr_copy(&client_info->app_mac, &arp->arp_data.arp_sha);
rte_eth_macaddr_get(client_info->slave_idx,
&client_info->app_mac);
rte_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 rte_vlan_hdr);
rte_spinlock_unlock(&internals->mode6.lock);
@ -203,8 +213,8 @@ bond_mode_alb_arp_upd(struct client_data *client_info,
rte_spinlock_lock(&internals->mode6.lock);
eth_h = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
ether_addr_copy(&client_info->app_mac, &eth_h->s_addr);
ether_addr_copy(&client_info->cli_mac, &eth_h->d_addr);
rte_ether_addr_copy(&client_info->app_mac, &eth_h->s_addr);
rte_ether_addr_copy(&client_info->cli_mac, &eth_h->d_addr);
if (client_info->vlan_count > 0)
eth_h->ether_type = rte_cpu_to_be_16(ETHER_TYPE_VLAN);
else
@ -217,9 +227,9 @@ bond_mode_alb_arp_upd(struct client_data *client_info,
memcpy(eth_h + 1, client_info->vlan,
client_info->vlan_count * sizeof(struct rte_vlan_hdr));
ether_addr_copy(&client_info->app_mac, &arp_h->arp_data.arp_sha);
rte_ether_addr_copy(&client_info->app_mac, &arp_h->arp_data.arp_sha);
arp_h->arp_data.arp_sip = client_info->app_ip;
ether_addr_copy(&client_info->cli_mac, &arp_h->arp_data.arp_tha);
rte_ether_addr_copy(&client_info->cli_mac, &arp_h->arp_data.arp_tha);
arp_h->arp_data.arp_tip = client_info->cli_ip;
arp_h->arp_hardware = rte_cpu_to_be_16(RTE_ARP_HRD_ETHER);

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

@ -454,8 +454,8 @@ bond_ethdev_rx_burst_8023ad(void *queue, struct rte_mbuf **bufs,
if (unlikely(is_lacp_packets(hdr->ether_type, subtype, bufs[j]) ||
!collecting ||
(!promisc &&
!is_multicast_ether_addr(&hdr->d_addr) &&
!is_same_ether_addr(bond_mac,
!rte_is_multicast_ether_addr(&hdr->d_addr) &&
!rte_is_same_ether_addr(bond_mac,
&hdr->d_addr)))) {
if (hdr->ether_type == ether_type_slow_be) {
@ -1021,7 +1021,7 @@ bond_ethdev_tx_burst_tlb(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
sizeof(internals->tlb_slaves_order[0]) * num_of_slaves);
ether_addr_copy(primary_port->data->mac_addrs, &primary_slave_addr);
rte_ether_addr_copy(primary_port->data->mac_addrs, &primary_slave_addr);
if (nb_pkts > 3) {
for (i = 0; i < 3; i++)
@ -1036,8 +1036,10 @@ bond_ethdev_tx_burst_tlb(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
ether_hdr = rte_pktmbuf_mtod(bufs[j],
struct rte_ether_hdr *);
if (is_same_ether_addr(&ether_hdr->s_addr, &primary_slave_addr))
ether_addr_copy(&active_slave_addr, &ether_hdr->s_addr);
if (rte_is_same_ether_addr(&ether_hdr->s_addr,
&primary_slave_addr))
rte_ether_addr_copy(&active_slave_addr,
&ether_hdr->s_addr);
#if defined(RTE_LIBRTE_BOND_DEBUG_ALB) || defined(RTE_LIBRTE_BOND_DEBUG_ALB_L1)
mode6_debug("TX IPv4:", ether_hdr, slaves[i], &burstnumberTX);
#endif
@ -1523,7 +1525,7 @@ mac_address_get(struct rte_eth_dev *eth_dev,
mac_addr = eth_dev->data->mac_addrs;
ether_addr_copy(mac_addr, dst_mac_addr);
rte_ether_addr_copy(mac_addr, dst_mac_addr);
return 0;
}
@ -1566,7 +1568,7 @@ slave_add_mac_addresses(struct rte_eth_dev *bonded_eth_dev,
for (i = 1; i < BOND_MAX_MAC_ADDRS; i++) {
mac_addr = &bonded_eth_dev->data->mac_addrs[i];
if (is_same_ether_addr(mac_addr, &null_mac_addr))
if (rte_is_same_ether_addr(mac_addr, &null_mac_addr))
break;
ret = rte_eth_dev_mac_addr_add(slave_port_id, mac_addr, 0);
@ -1595,7 +1597,7 @@ slave_remove_mac_addresses(struct rte_eth_dev *bonded_eth_dev,
rc = 0;
for (i = 1; i < BOND_MAX_MAC_ADDRS; i++) {
mac_addr = &bonded_eth_dev->data->mac_addrs[i];
if (is_same_ether_addr(mac_addr, &null_mac_addr))
if (rte_is_same_ether_addr(mac_addr, &null_mac_addr))
break;
ret = rte_eth_dev_mac_addr_remove(slave_port_id, mac_addr);

2
drivers/net/cxgbe/base/adapter.h
View 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 rte_ether_addr *)hw_addr,
rte_ether_addr_copy((struct rte_ether_addr *)hw_addr,
&pi->eth_dev->data->mac_addrs[0]);
}

4
drivers/net/cxgbe/cxgbe_flow.c
View File

@ -115,12 +115,12 @@ ch_rte_parsetype_eth(const void *dmask, const struct rte_flow_item *item,
mask = umask ? umask : (const struct rte_flow_item_eth *)dmask;
/* we don't support SRC_MAC filtering*/
if (!is_zero_ether_addr(&mask->src))
if (!rte_is_zero_ether_addr(&mask->src))
return rte_flow_error_set(e, ENOTSUP, RTE_FLOW_ERROR_TYPE_ITEM,
item,
"src mac filtering not supported");
if (!is_zero_ether_addr(&mask->dst)) {
if (!rte_is_zero_ether_addr(&mask->dst)) {
const u8 *addr = (const u8 *)&spec->dst.addr_bytes[0];
const u8 *m = (const u8 *)&mask->dst.addr_bytes[0];
struct rte_flow *flow = (struct rte_flow *)fs->private;

2
drivers/net/dpaa/dpaa_ethdev.c
View File

@ -1374,7 +1374,7 @@ dpaa_dev_init(struct rte_eth_dev *eth_dev)
}
/* copy the primary mac address */
ether_addr_copy(&fman_intf->mac_addr, &eth_dev->data->mac_addrs[0]);
rte_ether_addr_copy(&fman_intf->mac_addr, &eth_dev->data->mac_addrs[0]);
RTE_LOG(INFO, PMD, "net: dpaa: %s: %02x:%02x:%02x:%02x:%02x:%02x\n",
dpaa_device->name,

8
drivers/net/dpaa2/dpaa2_ethdev.c
View File

@ -2021,9 +2021,9 @@ populate_mac_addr(struct fsl_mc_io *dpni_dev, struct dpaa2_dev_priv *priv,
* If empty_mac(phy), return prime.
* if both are empty, create random MAC, set as prime and return
*/
if (!is_zero_ether_addr(&phy_mac)) {
if (!rte_is_zero_ether_addr(&phy_mac)) {
/* If the addresses are not same, overwrite prime */
if (!is_same_ether_addr(&phy_mac, &prime_mac)) {
if (!rte_is_same_ether_addr(&phy_mac, &prime_mac)) {
ret = dpni_set_primary_mac_addr(dpni_dev, CMD_PRI_LOW,
priv->token,
phy_mac.addr_bytes);
@ -2035,9 +2035,9 @@ populate_mac_addr(struct fsl_mc_io *dpni_dev, struct dpaa2_dev_priv *priv,
memcpy(&prime_mac, &phy_mac,
sizeof(struct rte_ether_addr));
}
} else if (is_zero_ether_addr(&prime_mac)) {
} else if (rte_is_zero_ether_addr(&prime_mac)) {
/* In case phys and prime, both are zero, create random MAC */
eth_random_addr(prime_mac.addr_bytes);
rte_eth_random_addr(prime_mac.addr_bytes);
ret = dpni_set_primary_mac_addr(dpni_dev, CMD_PRI_LOW,
priv->token,
prime_mac.addr_bytes);

2
drivers/net/e1000/em_ethdev.c
View File

@ -294,7 +294,7 @@ eth_em_dev_init(struct rte_eth_dev *eth_dev)
}
/* Copy the permanent MAC address */
ether_addr_copy((struct rte_ether_addr *)hw->mac.addr,
rte_ether_addr_copy((struct rte_ether_addr *)hw->mac.addr,
eth_dev->data->mac_addrs);
/* initialize the vfta */

8
drivers/net/e1000/igb_ethdev.c
View File

@ -840,7 +840,7 @@ eth_igb_dev_init(struct rte_eth_dev *eth_dev)
}
/* Copy the permanent MAC address */
ether_addr_copy((struct rte_ether_addr *)hw->mac.addr,
rte_ether_addr_copy((struct rte_ether_addr *)hw->mac.addr,
&eth_dev->data->mac_addrs[0]);
/* initialize the vfta */
@ -1039,8 +1039,8 @@ eth_igbvf_dev_init(struct rte_eth_dev *eth_dev)
}
/* Generate a random MAC address, if none was assigned by PF. */
if (is_zero_ether_addr(perm_addr)) {
eth_random_addr(perm_addr->addr_bytes);
if (rte_is_zero_ether_addr(perm_addr)) {
rte_eth_random_addr(perm_addr->addr_bytes);
PMD_INIT_LOG(INFO, "\tVF MAC address not assigned by Host PF");
PMD_INIT_LOG(INFO, "\tAssign randomly generated MAC address "
"%02x:%02x:%02x:%02x:%02x:%02x",
@ -1059,7 +1059,7 @@ eth_igbvf_dev_init(struct rte_eth_dev *eth_dev)
return diag;
}
/* Copy the permanent MAC address */
ether_addr_copy((struct rte_ether_addr *)hw->mac.perm_addr,
rte_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 "

8
drivers/net/e1000/igb_flow.c
View File

@ -548,9 +548,9 @@ cons_parse_ethertype_filter(const struct rte_flow_attr *attr,
* Mask bits of destination MAC address must be full
* of 1 or full of 0.
*/
if (!is_zero_ether_addr(&eth_mask->src) ||
(!is_zero_ether_addr(&eth_mask->dst) &&
!is_broadcast_ether_addr(&eth_mask->dst))) {
if (!rte_is_zero_ether_addr(&eth_mask->src) ||
(!rte_is_zero_ether_addr(&eth_mask->dst) &&
!rte_is_broadcast_ether_addr(&eth_mask->dst))) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
item, "Invalid ether address mask");
@ -567,7 +567,7 @@ cons_parse_ethertype_filter(const struct rte_flow_attr *attr,
/* If mask bits of destination MAC address
* are full of 1, set RTE_ETHTYPE_FLAGS_MAC.
*/
if (is_broadcast_ether_addr(&eth_mask->dst)) {
if (rte_is_broadcast_ether_addr(&eth_mask->dst)) {
filter->mac_addr = eth_spec->dst;
filter->flags |= RTE_ETHTYPE_FLAGS_MAC;
} else {

6
drivers/net/e1000/igb_pf.c
View File

@ -43,7 +43,7 @@ int igb_vf_perm_addr_gen(struct rte_eth_dev *dev, uint16_t vf_num)
uint16_t vfn;
for (vfn = 0; vfn < vf_num; vfn++) {
eth_random_addr(vf_mac_addr);
rte_eth_random_addr(vf_mac_addr);
/* keep the random address as default */
memcpy(vfinfo[vfn].vf_mac_addresses, vf_mac_addr,
ETHER_ADDR_LEN);
@ -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 rte_ether_addr *)new_mac)) {
if (!is_zero_ether_addr((struct rte_ether_addr *)new_mac))
if (rte_is_unicast_ether_addr((struct rte_ether_addr *)new_mac)) {
if (!rte_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);

3
drivers/net/ena/ena_ethdev.c
View File

@ -1814,7 +1814,8 @@ static int eth_ena_dev_init(struct rte_eth_dev *eth_dev)
/* Copy MAC address and point DPDK to it */
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,
rte_ether_addr_copy((struct rte_ether_addr *)
get_feat_ctx.dev_attr.mac_addr,
(struct rte_ether_addr *)adapter->mac_addr);
/*

2
drivers/net/enetc/enetc_ethdev.c
View File

@ -840,7 +840,7 @@ enetc_dev_init(struct rte_eth_dev *eth_dev)
}
/* Copy the permanent MAC address */
ether_addr_copy((struct rte_ether_addr *)hw->mac.addr,
rte_ether_addr_copy((struct rte_ether_addr *)hw->mac.addr,
&eth_dev->data->mac_addrs[0]);
/* Set MTU */

13
drivers/net/enic/enic_ethdev.c
View File

@ -648,7 +648,7 @@ static void debug_log_add_del_addr(struct rte_ether_addr *addr, bool add)
{
char mac_str[ETHER_ADDR_FMT_SIZE];
ether_format_addr(mac_str, ETHER_ADDR_FMT_SIZE, addr);
rte_ether_format_addr(mac_str, ETHER_ADDR_FMT_SIZE, addr);
PMD_INIT_LOG(DEBUG, " %s address %s\n",
add ? "add" : "remove", mac_str);
}
@ -668,9 +668,10 @@ static int enicpmd_set_mc_addr_list(struct rte_eth_dev *eth_dev,
/* Validate the given addresses first */
for (i = 0; i < nb_mc_addr && mc_addr_set != NULL; i++) {
addr = &mc_addr_set[i];
if (!is_multicast_ether_addr(addr) ||
is_broadcast_ether_addr(addr)) {
ether_format_addr(mac_str, ETHER_ADDR_FMT_SIZE, addr);
if (!rte_is_multicast_ether_addr(addr) ||
rte_is_broadcast_ether_addr(addr)) {
rte_ether_format_addr(mac_str,
ETHER_ADDR_FMT_SIZE, addr);
PMD_INIT_LOG(ERR, " invalid multicast address %s\n",
mac_str);
return -EINVAL;
@ -704,7 +705,7 @@ static int enicpmd_set_mc_addr_list(struct rte_eth_dev *eth_dev,
for (i = 0; i < enic->mc_count; i++) {
addr = &enic->mc_addrs[i];
for (j = 0; j < nb_mc_addr; j++) {
if (is_same_ether_addr(addr, &mc_addr_set[j]))
if (rte_is_same_ether_addr(addr, &mc_addr_set[j]))
break;
}
if (j < nb_mc_addr)
@ -718,7 +719,7 @@ static int enicpmd_set_mc_addr_list(struct rte_eth_dev *eth_dev,
for (i = 0; i < nb_mc_addr; i++) {
addr = &mc_addr_set[i];
for (j = 0; j < enic->mc_count; j++) {
if (is_same_ether_addr(addr, &enic->mc_addrs[j]))
if (rte_is_same_ether_addr(addr, &enic->mc_addrs[j]))
break;
}
if (j < enic->mc_count)

2
drivers/net/enic/enic_main.c
View File

@ -1673,7 +1673,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 rte_ether_addr *)enic->mac_addr,
rte_ether_addr_copy((struct rte_ether_addr *)enic->mac_addr,
eth_dev->data->mac_addrs);
vnic_dev_set_reset_flag(enic->vdev, 0);

6
drivers/net/failsafe/failsafe.c
View File

@ -253,8 +253,8 @@ fs_eth_dev_create(struct rte_vdev_device *vdev)
*/
FOREACH_SUBDEV(sdev, i, dev)
if (sdev->state >= DEV_PROBED) {
ether_addr_copy(&ETH(sdev)->data->mac_addrs[0],
mac);
rte_ether_addr_copy(
&ETH(sdev)->data->mac_addrs[0], mac);
break;
}
/*
@ -265,7 +265,7 @@ fs_eth_dev_create(struct rte_vdev_device *vdev)
* probed slaves.
*/
if (i == priv->subs_tail)
eth_random_addr(&mac->addr_bytes[0]);
rte_eth_random_addr(&mac->addr_bytes[0]);
}
INFO("MAC address is %02x:%02x:%02x:%02x:%02x:%02x",
mac->addr_bytes[0], mac->addr_bytes[1],

2
drivers/net/failsafe/failsafe_ether.c
View File

@ -174,7 +174,7 @@ fs_eth_dev_conf_apply(struct rte_eth_dev *dev,
if (ret) {
char ea_fmt[ETHER_ADDR_FMT_SIZE];
ether_format_addr(ea_fmt, ETHER_ADDR_FMT_SIZE, ea);
rte_ether_format_addr(ea_fmt, ETHER_ADDR_FMT_SIZE, ea);
ERROR("Adding MAC address %s failed", ea_fmt);
return ret;
}

12
drivers/net/fm10k/fm10k_ethdev.c
View File

@ -614,7 +614,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 rte_ether_addr *)hw->mac.addr,
rte_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;
@ -1534,7 +1534,7 @@ fm10k_vlan_filter_set(struct rte_eth_dev *dev, uint16_t vlan_id, int on)
for (mac_index = 0; (mac_index < FM10K_MAX_MACADDR_NUM) &&
(result == FM10K_SUCCESS); mac_index++) {
if (is_zero_ether_addr(&data->mac_addrs[mac_index]))
if (rte_is_zero_ether_addr(&data->mac_addrs[mac_index]))
continue;
if (mac_num > macvlan->mac_num - 1) {
PMD_INIT_LOG(ERR, "MAC address number "
@ -3090,16 +3090,16 @@ eth_fm10k_dev_init(struct rte_eth_dev *dev)
diag = fm10k_read_mac_addr(hw);
ether_addr_copy((const struct rte_ether_addr *)hw->mac.addr,
rte_ether_addr_copy((const struct rte_ether_addr *)hw->mac.addr,
&dev->data->mac_addrs[0]);
if (diag != FM10K_SUCCESS ||
!is_valid_assigned_ether_addr(dev->data->mac_addrs)) {
!rte_is_valid_assigned_ether_addr(dev->data->mac_addrs)) {
/* Generate a random addr */
eth_random_addr(hw->mac.addr);
rte_eth_random_addr(hw->mac.addr);
memcpy(hw->mac.perm_addr, hw->mac.addr, ETH_ALEN);
ether_addr_copy((const struct rte_ether_addr *)hw->mac.addr,
rte_ether_addr_copy((const struct rte_ether_addr *)hw->mac.addr,
&dev->data->mac_addrs[0]);
}

43
drivers/net/i40e/i40e_ethdev.c
View File

@ -1469,7 +1469,7 @@ 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 rte_ether_addr *)hw->mac.addr,
rte_ether_addr_copy((struct rte_ether_addr *)hw->mac.addr,
(struct rte_ether_addr *)hw->mac.perm_addr);
/* Disable flow control */
@ -1521,7 +1521,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 rte_ether_addr *)hw->mac.perm_addr,
rte_ether_addr_copy((struct rte_ether_addr *)hw->mac.perm_addr,
&dev->data->mac_addrs[0]);
/* Init dcb to sw mode by default */
@ -4123,7 +4123,7 @@ i40e_vf_mac_filter_set(struct i40e_pf *pf,
new_mac = &filter->mac_addr;
if (is_zero_ether_addr(new_mac)) {
if (rte_is_zero_ether_addr(new_mac)) {
PMD_DRV_LOG(ERR, "Invalid ethernet address.");
return -EINVAL;
}
@ -4136,7 +4136,7 @@ i40e_vf_mac_filter_set(struct i40e_pf *pf,
}
vf = &pf->vfs[vf_id];
if (add && is_same_ether_addr(new_mac, &(pf->dev_addr))) {
if (add && rte_is_same_ether_addr(new_mac, &pf->dev_addr)) {
PMD_DRV_LOG(INFO, "Ignore adding permanent MAC address.");
return -EINVAL;
}
@ -4154,7 +4154,7 @@ i40e_vf_mac_filter_set(struct i40e_pf *pf,
PMD_DRV_LOG(ERR, "Failed to add MAC filter.");
return -1;
}
ether_addr_copy(new_mac, &pf->dev_addr);
rte_ether_addr_copy(new_mac, &pf->dev_addr);
} else {
rte_memcpy(hw->mac.addr, hw->mac.perm_addr,
ETHER_ADDR_LEN);
@ -4165,7 +4165,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))
if (rte_is_same_ether_addr(&pf->dev_addr, new_mac))
memset(&pf->dev_addr, 0, sizeof(struct rte_ether_addr));
}
@ -6913,7 +6913,7 @@ i40e_find_mac_filter(struct i40e_vsi *vsi,
struct i40e_mac_filter *f;
TAILQ_FOREACH(f, &vsi->mac_list, next) {
if (is_same_ether_addr(macaddr, &f->mac_info.mac_addr))
if (rte_is_same_ether_addr(macaddr, &f->mac_info.mac_addr))
return f;
}
@ -7586,9 +7586,11 @@ i40e_tunnel_filter_convert(
struct i40e_aqc_cloud_filters_element_bb *cld_filter,
struct i40e_tunnel_filter *tunnel_filter)
{
ether_addr_copy((struct rte_ether_addr *)&cld_filter->element.outer_mac,
rte_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,
rte_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) &
@ -7697,9 +7699,9 @@ i40e_dev_tunnel_filter_set(struct i40e_pf *pf,
}
pfilter = cld_filter;
ether_addr_copy(&tunnel_filter->outer_mac,
rte_ether_addr_copy(&tunnel_filter->outer_mac,
(struct rte_ether_addr *)&pfilter->element.outer_mac);
ether_addr_copy(&tunnel_filter->inner_mac,
rte_ether_addr_copy(&tunnel_filter->inner_mac,
(struct rte_ether_addr *)&pfilter->element.inner_mac);
pfilter->element.inner_vlan =
@ -8144,9 +8146,9 @@ i40e_dev_consistent_tunnel_filter_set(struct i40e_pf *pf,
}
pfilter = cld_filter;
ether_addr_copy(&tunnel_filter->outer_mac,
rte_ether_addr_copy(&tunnel_filter->outer_mac,
(struct rte_ether_addr *)&pfilter->element.outer_mac);
ether_addr_copy(&tunnel_filter->inner_mac,
rte_ether_addr_copy(&tunnel_filter->inner_mac,
(struct rte_ether_addr *)&pfilter->element.inner_mac);
pfilter->element.inner_vlan =
@ -8627,13 +8629,13 @@ i40e_tunnel_filter_param_check(struct i40e_pf *pf,
}
if ((filter->filter_type & ETH_TUNNEL_FILTER_OMAC) &&
(is_zero_ether_addr(&filter->outer_mac))) {
(rte_is_zero_ether_addr(&filter->outer_mac))) {
PMD_DRV_LOG(ERR, "Cannot add NULL outer MAC address");
return -EINVAL;
}
if ((filter->filter_type & ETH_TUNNEL_FILTER_IMAC) &&
(is_zero_ether_addr(&filter->inner_mac))) {
(rte_is_zero_ether_addr(&filter->inner_mac))) {
PMD_DRV_LOG(ERR, "Cannot add NULL inner MAC address");
return -EINVAL;
}
@ -11960,13 +11962,14 @@ static int i40e_set_default_mac_addr(struct rte_eth_dev *dev,
struct i40e_mac_filter *f;
int ret;
if (!is_valid_assigned_ether_addr(mac_addr)) {
if (!rte_is_valid_assigned_ether_addr(mac_addr)) {
PMD_DRV_LOG(ERR, "Tried to set invalid MAC address.");
return -EINVAL;
}
TAILQ_FOREACH(f, &vsi->mac_list, next) {
if (is_same_ether_addr(&pf->dev_addr, &f->mac_info.mac_addr))
if (rte_is_same_ether_addr(&pf->dev_addr,
&f->mac_info.mac_addr))
break;
}
@ -12084,9 +12087,11 @@ i40e_tunnel_filter_restore(struct i40e_pf *pf)
vsi = vf->vsi;
}
memset(&cld_filter, 0, sizeof(cld_filter));
ether_addr_copy((struct rte_ether_addr *)&f->input.outer_mac,
rte_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,
rte_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;

17
drivers/net/i40e/i40e_ethdev_vf.c
View File

@ -788,7 +788,7 @@ i40evf_add_mac_addr(struct rte_eth_dev *dev,
int err;
struct vf_cmd_info args;
if (is_zero_ether_addr(addr)) {
if (rte_is_zero_ether_addr(addr)) {
PMD_DRV_LOG(ERR, "Invalid mac:%x:%x:%x:%x:%x:%x",
addr->addr_bytes[0], addr->addr_bytes[1],
addr->addr_bytes[2], addr->addr_bytes[3],
@ -1274,10 +1274,11 @@ 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 rte_ether_addr *)hw->mac.addr))
if (rte_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 */
rte_eth_random_addr(hw->mac.addr); /* Generate a random one */
I40E_WRITE_REG(hw, I40E_VFINT_DYN_CTL01,
(I40E_ITR_INDEX_DEFAULT <<
@ -1512,7 +1513,7 @@ i40evf_dev_init(struct rte_eth_dev *eth_dev)
ETHER_ADDR_LEN * I40E_NUM_MACADDR_MAX);
return -ENOMEM;
}
ether_addr_copy((struct rte_ether_addr *)hw->mac.addr,
rte_ether_addr_copy((struct rte_ether_addr *)hw->mac.addr,
&eth_dev->data->mac_addrs[0]);
return 0;
@ -1937,7 +1938,7 @@ i40evf_add_del_all_mac_addr(struct rte_eth_dev *dev, bool add)
j = 0;
len = sizeof(struct virtchnl_ether_addr_list);
for (i = begin; i < I40E_NUM_MACADDR_MAX; i++, next_begin++) {
if (is_zero_ether_addr(&dev->data->mac_addrs[i]))
if (rte_is_zero_ether_addr(&dev->data->mac_addrs[i]))
continue;
len += sizeof(struct virtchnl_ether_addr);
if (len >= I40E_AQ_BUF_SZ) {
@ -1954,7 +1955,7 @@ i40evf_add_del_all_mac_addr(struct rte_eth_dev *dev, bool add)
for (i = begin; i < next_begin; i++) {
addr = &dev->data->mac_addrs[i];
if (is_zero_ether_addr(addr))
if (rte_is_zero_ether_addr(addr))
continue;
rte_memcpy(list->list[j].addr, addr->addr_bytes,
sizeof(addr->addr_bytes));
@ -2707,7 +2708,7 @@ i40evf_set_default_mac_addr(struct rte_eth_dev *dev,
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);
if (!is_valid_assigned_ether_addr(mac_addr)) {
if (!rte_is_valid_assigned_ether_addr(mac_addr)) {
PMD_DRV_LOG(ERR, "Tried to set invalid MAC address.");
return -EINVAL;
}
@ -2720,7 +2721,7 @@ i40evf_set_default_mac_addr(struct rte_eth_dev *dev,
if (i40evf_add_mac_addr(dev, mac_addr, 0, 0) != 0)
return -EIO;
ether_addr_copy(mac_addr, (struct rte_ether_addr *)hw->mac.addr);
rte_ether_addr_copy(mac_addr, (struct rte_ether_addr *)hw->mac.addr);
return 0;
}

24
drivers/net/i40e/i40e_flow.c
View File

@ -2006,9 +2006,9 @@ i40e_flow_parse_ethertype_pattern(struct rte_eth_dev *dev,
* Mask bits of destination MAC address must be full
* of 1 or full of 0.
*/
if (!is_zero_ether_addr(&eth_mask->src) ||
(!is_zero_ether_addr(&eth_mask->dst) &&
!is_broadcast_ether_addr(&eth_mask->dst))) {
if (!rte_is_zero_ether_addr(&eth_mask->src) ||
(!rte_is_zero_ether_addr(&eth_mask->dst) &&
!rte_is_broadcast_ether_addr(&eth_mask->dst))) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
item,
@ -2027,7 +2027,7 @@ i40e_flow_parse_ethertype_pattern(struct rte_eth_dev *dev,
/* If mask bits of destination MAC address
* are full of 1, set RTE_ETHTYPE_FLAGS_MAC.
*/
if (is_broadcast_ether_addr(&eth_mask->dst)) {
if (rte_is_broadcast_ether_addr(&eth_mask->dst)) {
filter->mac_addr = eth_spec->dst;
filter->flags |= RTE_ETHTYPE_FLAGS_MAC;
} else {
@ -2484,8 +2484,8 @@ i40e_flow_parse_fdir_pattern(struct rte_eth_dev *dev,
eth_mask = item->mask;
if (eth_spec && eth_mask) {
if (!is_zero_ether_addr(&eth_mask->src) ||
!is_zero_ether_addr(&eth_mask->dst)) {
if (!rte_is_zero_ether_addr(&eth_mask->src) ||
!rte_is_zero_ether_addr(&eth_mask->dst)) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
item,
@ -3325,8 +3325,8 @@ i40e_flow_parse_vxlan_pattern(__rte_unused struct rte_eth_dev *dev,
/* DST address of inner MAC shouldn't be masked.
* SRC address of Inner MAC should be masked.
*/
if (!is_broadcast_ether_addr(&eth_mask->dst) ||
!is_zero_ether_addr(&eth_mask->src) ||
if (!rte_is_broadcast_ether_addr(&eth_mask->dst) ||
!rte_is_zero_ether_addr(&eth_mask->src) ||
eth_mask->type) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
@ -3555,8 +3555,8 @@ i40e_flow_parse_nvgre_pattern(__rte_unused struct rte_eth_dev *dev,
/* DST address of inner MAC shouldn't be masked.
* SRC address of Inner MAC should be masked.
*/
if (!is_broadcast_ether_addr(&eth_mask->dst) ||
!is_zero_ether_addr(&eth_mask->src) ||
if (!rte_is_broadcast_ether_addr(&eth_mask->dst) ||
!rte_is_zero_ether_addr(&eth_mask->src) ||
eth_mask->type) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
@ -4810,9 +4810,9 @@ i40e_flow_destroy_tunnel_filter(struct i40e_pf *pf,
int ret = 0;
memset(&cld_filter, 0, sizeof(cld_filter));
ether_addr_copy((struct rte_ether_addr *)&filter->input.outer_mac,
rte_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,
rte_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;

6
drivers/net/i40e/i40e_pf.c
View File

@ -348,7 +348,7 @@ i40e_pf_host_process_cmd_get_vf_resource(struct i40e_pf_vf *vf, uint8_t *msg,
vf_res->vsi_res[0].vsi_type = VIRTCHNL_VSI_SRIOV;
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,
rte_ether_addr_copy(&vf->mac_addr,
(struct rte_ether_addr *)vf_res->vsi_res[0].default_mac_addr);
send_msg:
@ -845,7 +845,7 @@ i40e_pf_host_process_cmd_add_ether_address(struct i40e_pf_vf *vf,
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) ||
if (rte_is_zero_ether_addr(mac) ||
i40e_vsi_add_mac(vf->vsi, &filter)) {
ret = I40E_ERR_INVALID_MAC_ADDR;
goto send_msg;
@ -887,7 +887,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 rte_ether_addr *)(addr_list->list[i].addr);
if(is_zero_ether_addr(mac) ||
if (rte_is_zero_ether_addr(mac) ||
i40e_vsi_delete_mac(vf->vsi, mac)) {
ret = I40E_ERR_INVALID_MAC_ADDR;
goto send_msg;

10
drivers/net/i40e/rte_pmd_i40e.c
View File

@ -560,7 +560,7 @@ rte_pmd_i40e_set_vf_mac_addr(uint16_t port, uint16_t vf_id,
return -EINVAL;
}
ether_addr_copy(mac_addr, &vf->mac_addr);
rte_ether_addr_copy(mac_addr, &vf->mac_addr);
/* Remove all existing mac */
TAILQ_FOREACH_SAFE(f, &vsi->mac_list, next, temp)
@ -604,9 +604,9 @@ rte_pmd_i40e_remove_vf_mac_addr(uint16_t port, uint16_t vf_id,
return -EINVAL;
}
if (is_same_ether_addr(mac_addr, &vf->mac_addr))
if (rte_is_same_ether_addr(mac_addr, &vf->mac_addr))
/* Reset the mac with NULL address */
ether_addr_copy(&null_mac_addr, &vf->mac_addr);
rte_ether_addr_copy(&null_mac_addr, &vf->mac_addr);
/* Remove the mac */
i40e_vsi_delete_mac(vsi, mac_addr);
@ -2387,7 +2387,7 @@ rte_pmd_i40e_add_vf_mac_addr(uint16_t port, uint16_t vf_id,
}
mac_filter.filter_type = RTE_MACVLAN_PERFECT_MATCH;
ether_addr_copy(mac_addr, &mac_filter.mac_addr);
rte_ether_addr_copy(mac_addr, &mac_filter.mac_addr);
ret = i40e_vsi_add_mac(vsi, &mac_filter);
if (ret != I40E_SUCCESS) {
PMD_DRV_LOG(ERR, "Failed to add MAC filter.");
@ -2515,7 +2515,7 @@ rte_pmd_i40e_query_vfid_by_mac(uint16_t port,
vf = &pf->vfs[vf_id];
mac = &vf->mac_addr;
if (is_same_ether_addr(mac, vf_mac))
if (rte_is_same_ether_addr(mac, vf_mac))
return vf_id;
}

14
drivers/net/iavf/iavf_ethdev.c
View File

@ -706,7 +706,7 @@ iavf_dev_add_mac_addr(struct rte_eth_dev *dev, struct rte_ether_addr *addr,
struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(adapter);
int err;
if (is_zero_ether_addr(addr)) {
if (rte_is_zero_ether_addr(addr)) {
PMD_DRV_LOG(ERR, "Invalid Ethernet Address");
return -EINVAL;
}
@ -951,11 +951,11 @@ iavf_dev_set_default_mac_addr(struct rte_eth_dev *dev,
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))
if (rte_is_same_ether_addr(mac_addr, old_addr))
return 0;
/* If the MAC address is configured by host, skip the setting */
if (is_valid_assigned_ether_addr(perm_addr))
if (rte_is_valid_assigned_ether_addr(perm_addr))
return -EPERM;
ret = iavf_add_del_eth_addr(adapter, old_addr, FALSE);
@ -983,7 +983,7 @@ iavf_dev_set_default_mac_addr(struct rte_eth_dev *dev,
if (ret)
return -EIO;
ether_addr_copy(mac_addr, (struct rte_ether_addr *)hw->mac.addr);
rte_ether_addr_copy(mac_addr, (struct rte_ether_addr *)hw->mac.addr);
return 0;
}
@ -1317,10 +1317,10 @@ iavf_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(
if (!rte_is_valid_assigned_ether_addr(
(struct rte_ether_addr *)hw->mac.addr))
eth_random_addr(hw->mac.addr);
ether_addr_copy((struct rte_ether_addr *)hw->mac.addr,
rte_eth_random_addr(hw->mac.addr);
rte_ether_addr_copy((struct rte_ether_addr *)hw->mac.addr,
&eth_dev->data->mac_addrs[0]);
/* register callback func to eal lib */

4
drivers/net/iavf/iavf_vchnl.c
View File

@ -647,7 +647,7 @@ iavf_add_del_all_mac_addr(struct iavf_adapter *adapter, bool add)
len = sizeof(struct virtchnl_ether_addr_list);
for (i = begin; i < IAVF_NUM_MACADDR_MAX; i++, next_begin++) {
addr = &adapter->eth_dev->data->mac_addrs[i];
if (is_zero_ether_addr(addr))
if (rte_is_zero_ether_addr(addr))
continue;
len += sizeof(struct virtchnl_ether_addr);
if (len >= IAVF_AQ_BUF_SZ) {
@ -664,7 +664,7 @@ iavf_add_del_all_mac_addr(struct iavf_adapter *adapter, bool add)
for (i = begin; i < next_begin; i++) {
addr = &adapter->eth_dev->data->mac_addrs[i];
if (is_zero_ether_addr(addr))
if (rte_is_zero_ether_addr(addr))
continue;
rte_memcpy(list->list[j].addr, addr->addr_bytes,
sizeof(addr->addr_bytes));

16
drivers/net/ice/ice_ethdev.c
View File

@ -485,13 +485,14 @@ ice_init_mac_address(struct rte_eth_dev *dev)
{
struct ice_hw *hw = ICE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
if (!is_unicast_ether_addr
if (!rte_is_unicast_ether_addr
((struct rte_ether_addr *)hw->port_info[0].mac.lan_addr)) {
PMD_INIT_LOG(ERR, "Invalid MAC address");
return -EINVAL;
}
ether_addr_copy((struct rte_ether_addr *)hw->port_info[0].mac.lan_addr,
rte_ether_addr_copy(
(struct rte_ether_addr *)hw->port_info[0].mac.lan_addr,
(struct rte_ether_addr *)hw->port_info[0].mac.perm_addr);
dev->data->mac_addrs =
@ -502,8 +503,9 @@ ice_init_mac_address(struct rte_eth_dev *dev)
return -ENOMEM;
}
/* store it to dev data */
ether_addr_copy((struct rte_ether_addr *)hw->port_info[0].mac.perm_addr,
&dev->data->mac_addrs[0]);
rte_ether_addr_copy(
(struct rte_ether_addr *)hw->port_info[0].mac.perm_addr,
&dev->data->mac_addrs[0]);
return 0;
}
@ -514,7 +516,7 @@ ice_find_mac_filter(struct ice_vsi *vsi, struct rte_ether_addr *macaddr)
struct ice_mac_filter *f;
TAILQ_FOREACH(f, &vsi->mac_list, next) {
if (is_same_ether_addr(macaddr, &f->mac_info.mac_addr))
if (rte_is_same_ether_addr(macaddr, &f->mac_info.mac_addr))
return f;
}
@ -2357,13 +2359,13 @@ static int ice_macaddr_set(struct rte_eth_dev *dev,
uint8_t flags = 0;
int ret;
if (!is_valid_assigned_ether_addr(mac_addr)) {
if (!rte_is_valid_assigned_ether_addr(mac_addr)) {
PMD_DRV_LOG(ERR, "Tried to set invalid MAC address.");
return -EINVAL;
}
TAILQ_FOREACH(f, &vsi->mac_list, next) {
if (is_same_ether_addr(&pf->dev_addr, &f->mac_info.mac_addr))
if (rte_is_same_ether_addr(&pf->dev_addr, &f->mac_info.mac_addr))
break;
}

9
drivers/net/ipn3ke/ipn3ke_representor.c
View File

@ -124,9 +124,10 @@ ipn3ke_rpst_dev_start(struct rte_eth_dev *dev)
snprintf(attr_name, IPN3KE_RAWDEV_ATTR_LEN_MAX, "%s",
"LineSideBaseMAC");
rawdev->dev_ops->attr_get(rawdev, attr_name, &base_mac);
ether_addr_copy((struct rte_ether_addr *)&base_mac, &rpst->mac_addr);
rte_ether_addr_copy((struct rte_ether_addr *)&base_mac,
&rpst->mac_addr);
ether_addr_copy(&rpst->mac_addr, &dev->data->mac_addrs[0]);
rte_ether_addr_copy(&rpst->mac_addr, &dev->data->mac_addrs[0]);
dev->data->mac_addrs->addr_bytes[ETHER_ADDR_LEN - 1] =
(uint8_t)rpst->port_id + 1;
@ -656,13 +657,13 @@ ipn3ke_rpst_mac_addr_set(struct rte_eth_dev *ethdev,
struct ipn3ke_rpst *rpst = IPN3KE_DEV_PRIVATE_TO_RPST(ethdev);
uint32_t val;
if (!is_valid_assigned_ether_addr(mac_addr)) {
if (!rte_is_valid_assigned_ether_addr(mac_addr)) {
IPN3KE_AFU_PMD_ERR("Tried to set invalid MAC address.");
return -EINVAL;
}
if (hw->retimer.mac_type == IFPGA_RAWDEV_RETIMER_MAC_TYPE_10GE_XFI) {
ether_addr_copy(&mac_addr[0], &rpst->mac_addr);
rte_ether_addr_copy(&mac_addr[0], &rpst->mac_addr);
/* Set mac address */
rte_memcpy(((char *)(&val)), &mac_addr[0], sizeof(uint32_t));

8
drivers/net/ixgbe/ixgbe_ethdev.c
View File

@ -1223,7 +1223,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 rte_ether_addr *)hw->mac.perm_addr,
rte_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 */
@ -1661,7 +1661,7 @@ eth_ixgbevf_dev_init(struct rte_eth_dev *eth_dev)
}
/* Generate a random MAC address, if none was assigned by PF. */
if (is_zero_ether_addr(perm_addr)) {
if (rte_is_zero_ether_addr(perm_addr)) {
generate_random_mac_addr(perm_addr);
diag = ixgbe_set_rar_vf(hw, 1, perm_addr->addr_bytes, 0, 1);
if (diag) {
@ -1681,7 +1681,7 @@ eth_ixgbevf_dev_init(struct rte_eth_dev *eth_dev)
}
/* Copy the permanent MAC address */
ether_addr_copy(perm_addr, &eth_dev->data->mac_addrs[0]);
rte_ether_addr_copy(perm_addr, &eth_dev->data->mac_addrs[0]);
/* reset the hardware with the new settings */
diag = hw->mac.ops.start_hw(hw);
@ -6092,7 +6092,7 @@ ixgbevf_remove_mac_addr(struct rte_eth_dev *dev, uint32_t index)
if (i == index)
continue;
/* Skip NULL MAC addresses */
if (is_zero_ether_addr(mac_addr))
if (rte_is_zero_ether_addr(mac_addr))
continue;
/* Skip the permanent MAC address */
if (memcmp(perm_addr, mac_addr,

8
drivers/net/ixgbe/ixgbe_flow.c
View File

@ -744,9 +744,9 @@ cons_parse_ethertype_filter(const struct rte_flow_attr *attr,
* Mask bits of destination MAC address must be full
* of 1 or full of 0.
*/
if (!is_zero_ether_addr(&eth_mask->src) ||
(!is_zero_ether_addr(&eth_mask->dst) &&
!is_broadcast_ether_addr(&eth_mask->dst))) {
if (!rte_is_zero_ether_addr(&eth_mask->src) ||
(!rte_is_zero_ether_addr(&eth_mask->dst) &&
!rte_is_broadcast_ether_addr(&eth_mask->dst))) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
item, "Invalid ether address mask");
@ -763,7 +763,7 @@ cons_parse_ethertype_filter(const struct rte_flow_attr *attr,
/* If mask bits of destination MAC address
* are full of 1, set RTE_ETHTYPE_FLAGS_MAC.
*/
if (is_broadcast_ether_addr(&eth_mask->dst)) {
if (rte_is_broadcast_ether_addr(&eth_mask->dst)) {
filter->mac_addr = eth_spec->dst;
filter->flags |= RTE_ETHTYPE_FLAGS_MAC;
} else {

5
drivers/net/ixgbe/ixgbe_pf.c
View File

@ -46,7 +46,7 @@ int ixgbe_vf_perm_addr_gen(struct rte_eth_dev *dev, uint16_t vf_num)
uint16_t vfn;
for (vfn = 0; vfn < vf_num; vfn++) {
eth_random_addr(vf_mac_addr);
rte_eth_random_addr(vf_mac_addr);
/* keep the random address as default */
memcpy(vfinfo[vfn].vf_mac_addresses, vf_mac_addr,
ETHER_ADDR_LEN);
@ -463,7 +463,8 @@ 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 rte_ether_addr *)new_mac)) {
if (rte_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);
}

3
drivers/net/ixgbe/rte_pmd_ixgbe.c
View File

@ -35,7 +35,8 @@ 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 rte_ether_addr *)new_mac)) {
if (rte_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,

2
drivers/net/kni/rte_eth_kni.c
View File

@ -363,7 +363,7 @@ eth_kni_create(struct rte_vdev_device *vdev,
data->dev_link = pmd_link;
data->mac_addrs = &internals->eth_addr;
eth_random_addr(internals->eth_addr.addr_bytes);
rte_eth_random_addr(internals->eth_addr.addr_bytes);
eth_dev->dev_ops = &eth_kni_ops;

2
drivers/net/liquidio/lio_ethdev.c
View File

@ -1835,7 +1835,7 @@ lio_dev_configure(struct rte_eth_dev *eth_dev)
2 + i));
/* Copy the permanent MAC address */
ether_addr_copy((struct rte_ether_addr *)mac,
rte_ether_addr_copy((struct rte_ether_addr *)mac,
&eth_dev->data->mac_addrs[0]);
/* enable firmware checksum support for tunnel packets */

2
drivers/net/mlx4/mlx4_ethdev.c
View File

@ -522,7 +522,7 @@ mlx4_set_mc_addr_list(struct rte_eth_dev *dev, struct rte_ether_addr *list,
for (i = RTE_DIM(priv->mac) - num;
i != RTE_DIM(priv->mac) - priv->mac_mc;
++i)
if (!is_zero_ether_addr(&priv->mac[i])) {
if (!rte_is_zero_ether_addr(&priv->mac[i])) {
rte_errno = EBUSY;
return -rte_errno;
}

2
drivers/net/mlx4/mlx4_flow.c
View File

@ -1398,7 +1398,7 @@ next_vlan:
mac = &priv->mac[i];
else
mac = &eth_mask.dst;
if (is_zero_ether_addr(mac))
if (rte_is_zero_ether_addr(mac))
continue;
/* Check if MAC flow rule is already present. */
for (flow = LIST_FIRST(&priv->flows);

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

@ -3334,7 +3334,7 @@ flow_tcf_translate(struct rte_eth_dev *dev, struct mlx5_flow *dev_flow,
" parameter is ignored");
break;
}
if (!is_zero_ether_addr(&mask.eth->dst)) {
if (!rte_is_zero_ether_addr(&mask.eth->dst)) {
mnl_attr_put(nlh, TCA_FLOWER_KEY_ETH_DST,
ETHER_ADDR_LEN,
spec.eth->dst.addr_bytes);
@ -3342,7 +3342,7 @@ flow_tcf_translate(struct rte_eth_dev *dev, struct mlx5_flow *dev_flow,
ETHER_ADDR_LEN,
mask.eth->dst.addr_bytes);
}
if (!is_zero_ether_addr(&mask.eth->src)) {
if (!rte_is_zero_ether_addr(&mask.eth->src)) {
mnl_attr_put(nlh, TCA_FLOWER_KEY_ETH_SRC,
ETHER_ADDR_LEN,
spec.eth->src.addr_bytes);

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

@ -71,7 +71,7 @@ mlx5_internal_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index)
const int vf = priv->config.vf;
assert(index < MLX5_MAX_MAC_ADDRESSES);
if (is_zero_ether_addr(&dev->data->mac_addrs[index]))
if (rte_is_zero_ether_addr(&dev->data->mac_addrs[index]))
return;
if (vf)
mlx5_nl_mac_addr_remove(dev, &dev->data->mac_addrs[index],
@ -101,7 +101,7 @@ mlx5_internal_mac_addr_add(struct rte_eth_dev *dev, struct rte_ether_addr *mac,
unsigned int i;
assert(index < MLX5_MAX_MAC_ADDRESSES);
if (is_zero_ether_addr(mac)) {
if (rte_is_zero_ether_addr(mac)) {
rte_errno = EINVAL;
return -rte_errno;
}

6
drivers/net/mlx5/mlx5_nl.c
View File

@ -340,7 +340,7 @@ mlx5_nl_mac_addr_cb(struct nlmsghdr *nh, void *arg)
#ifndef NDEBUG
char m[18];
ether_format_addr(m, 18, RTA_DATA(attribute));
rte_ether_format_addr(m, 18, RTA_DATA(attribute));
DRV_LOG(DEBUG, "bridge MAC address %s", m);
#endif
memcpy(&(*data->mac)[data->mac_n++],
@ -555,14 +555,14 @@ mlx5_nl_mac_addr_sync(struct rte_eth_dev *dev)
/* Verify the address is not in the array yet. */
for (j = 0; j != MLX5_MAX_MAC_ADDRESSES; ++j)
if (is_same_ether_addr(&macs[i],
if (rte_is_same_ether_addr(&macs[i],
&dev->data->mac_addrs[j]))
break;
if (j != MLX5_MAX_MAC_ADDRESSES)
continue;
/* Find the first entry available. */
for (j = 0; j != MLX5_MAX_MAC_ADDRESSES; ++j) {
if (is_zero_ether_addr(&dev->data->mac_addrs[j])) {
if (rte_is_zero_ether_addr(&dev->data->mac_addrs[j])) {
dev->data->mac_addrs[j] = macs[i];
break;
}

6
drivers/net/mvneta/mvneta_ethdev.c
View File

@ -595,7 +595,7 @@ mvneta_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index)
ret = neta_ppio_remove_mac_addr(priv->ppio,
dev->data->mac_addrs[index].addr_bytes);
if (ret) {
ether_format_addr(buf, sizeof(buf),
rte_ether_format_addr(buf, sizeof(buf),
&dev->data->mac_addrs[index]);
MVNETA_LOG(ERR, "Failed to remove mac %s", buf);
}
@ -633,7 +633,7 @@ mvneta_mac_addr_add(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
ret = neta_ppio_add_mac_addr(priv->ppio, mac_addr->addr_bytes);
if (ret) {
ether_format_addr(buf, sizeof(buf), mac_addr);
rte_ether_format_addr(buf, sizeof(buf), mac_addr);
MVNETA_LOG(ERR, "Failed to add mac %s", buf);
return -1;
}
@ -661,7 +661,7 @@ mvneta_mac_addr_set(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr)
ret = neta_ppio_set_mac_addr(priv->ppio, mac_addr->addr_bytes);
if (ret) {
char buf[ETHER_ADDR_FMT_SIZE];
ether_format_addr(buf, sizeof(buf), mac_addr);
rte_ether_format_addr(buf, sizeof(buf), mac_addr);
MVNETA_LOG(ERR, "Failed to set mac to %s", buf);
}
return 0;

6
drivers/net/mvpp2/mrvl_ethdev.c
View File

@ -1080,7 +1080,7 @@ mrvl_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index)
ret = pp2_ppio_remove_mac_addr(priv->ppio,
dev->data->mac_addrs[index].addr_bytes);
if (ret) {
ether_format_addr(buf, sizeof(buf),
rte_ether_format_addr(buf, sizeof(buf),
&dev->data->mac_addrs[index]);
MRVL_LOG(ERR, "Failed to remove mac %s", buf);
}
@ -1134,7 +1134,7 @@ mrvl_mac_addr_add(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
*/
ret = pp2_ppio_add_mac_addr(priv->ppio, mac_addr->addr_bytes);
if (ret) {
ether_format_addr(buf, sizeof(buf), mac_addr);
rte_ether_format_addr(buf, sizeof(buf), mac_addr);
MRVL_LOG(ERR, "Failed to add mac %s", buf);
return -1;
}
@ -1168,7 +1168,7 @@ mrvl_mac_addr_set(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr)
ret = pp2_ppio_set_mac_addr(priv->ppio, mac_addr->addr_bytes);
if (ret) {
char buf[ETHER_ADDR_FMT_SIZE];
ether_format_addr(buf, sizeof(buf), mac_addr);
rte_ether_format_addr(buf, sizeof(buf), mac_addr);
MRVL_LOG(ERR, "Failed to set mac to %s", buf);
}

4
drivers/net/netvsc/hn_rxtx.c
View File

@ -128,8 +128,8 @@ hn_update_packet_stats(struct hn_stats *stats, const struct rte_mbuf *m)
}
ea = rte_pktmbuf_mtod(m, const struct rte_ether_addr *);
if (is_multicast_ether_addr(ea)) {
if (is_broadcast_ether_addr(ea))
if (rte_is_multicast_ether_addr(ea)) {
if (rte_is_broadcast_ether_addr(ea))
stats->broadcast++;
else
stats->multicast++;

2
drivers/net/netvsc/hn_vf.c
View File

@ -42,7 +42,7 @@ static int hn_vf_match(const struct rte_eth_dev *dev)
if (vf_dev == dev)
continue;
if (is_same_ether_addr(mac, vf_mac))
if (rte_is_same_ether_addr(mac, vf_mac))
return i;
}
return -ENOENT;

6
drivers/net/nfb/nfb_ethdev.c
View File

@ -360,7 +360,7 @@ nfb_eth_mac_addr_set(struct rte_eth_dev *dev,
struct pmd_internals *internals = (struct pmd_internals *)
data->dev_private;
if (!is_valid_assigned_ether_addr(mac_addr))
if (!rte_is_valid_assigned_ether_addr(mac_addr))
return -EINVAL;
for (i = 0; i < ETHER_ADDR_LEN; i++) {
@ -371,7 +371,7 @@ nfb_eth_mac_addr_set(struct rte_eth_dev *dev,
for (i = 0; i < internals->max_rxmac; ++i)
nc_rxmac_set_mac(internals->rxmac[i], 0, mac, 1);
ether_addr_copy(mac_addr, data->mac_addrs);
rte_ether_addr_copy(mac_addr, data->mac_addrs);
return 0;
}
@ -472,7 +472,7 @@ nfb_eth_dev_init(struct rte_eth_dev *dev)
return -EINVAL;
}
eth_random_addr(eth_addr_init.addr_bytes);
rte_eth_random_addr(eth_addr_init.addr_bytes);
eth_addr_init.addr_bytes[0] = eth_addr.addr_bytes[0];
eth_addr_init.addr_bytes[1] = eth_addr.addr_bytes[1];
eth_addr_init.addr_bytes[2] = eth_addr.addr_bytes[2];

6
drivers/net/nfp/nfp_net.c
View File

@ -2962,17 +2962,17 @@ nfp_net_init(struct rte_eth_dev *eth_dev)
nfp_net_vf_read_mac(hw);
}
if (!is_valid_assigned_ether_addr(
if (!rte_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 */
eth_random_addr(&hw->mac_addr[0]);
rte_eth_random_addr(&hw->mac_addr[0]);
nfp_net_write_mac(hw, (uint8_t *)&hw->mac_addr);
}
/* Copying mac address to DPDK eth_dev struct */
ether_addr_copy((struct rte_ether_addr *)hw->mac_addr,
rte_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))

2
drivers/net/null/rte_eth_null.c
View File

@ -535,7 +535,7 @@ eth_dev_null_create(struct rte_vdev_device *dev,
internals->packet_size = packet_size;
internals->packet_copy = packet_copy;
internals->port_id = eth_dev->data->port_id;
eth_random_addr(internals->eth_addr.addr_bytes);
rte_eth_random_addr(internals->eth_addr.addr_bytes);
internals->flow_type_rss_offloads = ETH_RSS_PROTO_MASK;
internals->reta_size = RTE_DIM(internals->reta_conf) * RTE_RETA_GROUP_SIZE;

29
drivers/net/qede/qede_ethdev.c
View File

@ -580,7 +580,7 @@ qede_ucast_filter(struct rte_eth_dev *eth_dev, struct ecore_filter_ucast *ucast,
DP_ERR(edev, "Did not allocate memory for ucast\n");
return -ENOMEM;
}
ether_addr_copy(mac_addr, &u->mac);
rte_ether_addr_copy(mac_addr, &u->mac);
u->vlan = ucast->vlan;
u->vni = ucast->vni;
SLIST_INSERT_HEAD(&qdev->uc_list_head, u, list);
@ -623,14 +623,14 @@ qede_add_mcast_filters(struct rte_eth_dev *eth_dev,
DP_ERR(edev, "Did not allocate memory for mcast\n");
return -ENOMEM;
}
ether_addr_copy(&mc_addrs[i], &m->mac);
rte_ether_addr_copy(&mc_addrs[i], &m->mac);
SLIST_INSERT_HEAD(&qdev->mc_list_head, m, list);
}
memset(&mcast, 0, sizeof(mcast));
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 rte_ether_addr *)
rte_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) {
@ -655,7 +655,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,
rte_ether_addr_copy(&tmp->mac,
(struct rte_ether_addr *)&mcast.mac[j]);
j++;
}
@ -709,13 +709,13 @@ qede_mac_addr_add(struct rte_eth_dev *eth_dev, struct rte_ether_addr *mac_addr,
struct ecore_filter_ucast ucast;
int re;
if (!is_valid_assigned_ether_addr(mac_addr))
if (!rte_is_valid_assigned_ether_addr(mac_addr))
return -EINVAL;
qede_set_ucast_cmn_params(&ucast);
ucast.opcode = ECORE_FILTER_ADD;
ucast.type = ECORE_FILTER_MAC;
ether_addr_copy(mac_addr, (struct rte_ether_addr *)&ucast.mac);
rte_ether_addr_copy(mac_addr, (struct rte_ether_addr *)&ucast.mac);
re = (int)qede_mac_int_ops(eth_dev, &ucast, 1);
return re;
}
@ -735,7 +735,7 @@ qede_mac_addr_remove(struct rte_eth_dev *eth_dev, uint32_t index)
return;
}
if (!is_valid_assigned_ether_addr(&eth_dev->data->mac_addrs[index]))
if (!rte_is_valid_assigned_ether_addr(&eth_dev->data->mac_addrs[index]))
return;
qede_set_ucast_cmn_params(&ucast);
@ -743,7 +743,7 @@ qede_mac_addr_remove(struct rte_eth_dev *eth_dev, uint32_t index)
ucast.type = ECORE_FILTER_MAC;
/* Use the index maintained by rte */
ether_addr_copy(&eth_dev->data->mac_addrs[index],
rte_ether_addr_copy(&eth_dev->data->mac_addrs[index],
(struct rte_ether_addr *)&ucast.mac);
qede_mac_int_ops(eth_dev, &ucast, false);
@ -1774,7 +1774,7 @@ qede_set_mc_addr_list(struct rte_eth_dev *eth_dev,
}
for (i = 0; i < mc_addrs_num; i++) {
if (!is_multicast_ether_addr(&mc_addrs[i])) {
if (!rte_is_multicast_ether_addr(&mc_addrs[i])) {
DP_ERR(edev, "Not a valid multicast MAC\n");
return -EINVAL;
}
@ -2552,10 +2552,10 @@ static int qede_common_dev_init(struct rte_eth_dev *eth_dev, bool is_vf)
}
if (!is_vf) {
ether_addr_copy((struct rte_ether_addr *)edev->hwfns[0].
rte_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],
rte_ether_addr_copy(&eth_dev->data->mac_addrs[0],
&adapter->primary_mac);
} else {
ecore_vf_read_bulletin(ECORE_LEADING_HWFN(edev),
@ -2568,11 +2568,12 @@ 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(
rte_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);
rte_ether_addr_copy(
&eth_dev->data->mac_addrs[0],
&adapter->primary_mac);
} else {
DP_ERR(edev, "No VF macaddr assigned\n");
}

6
drivers/net/sfc/sfc_ethdev.c
View File

@ -983,7 +983,7 @@ sfc_mac_addr_set(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr)
* Copy the address to the device private data so that
* it could be recalled in the case of adapter restart.
*/
ether_addr_copy(mac_addr, &port->default_mac_addr);
rte_ether_addr_copy(mac_addr, &port->default_mac_addr);
/*
* Neither of the two following checks can return
@ -1043,7 +1043,7 @@ sfc_mac_addr_set(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr)
unlock:
if (rc != 0)
ether_addr_copy(old_addr, &port->default_mac_addr);
rte_ether_addr_copy(old_addr, &port->default_mac_addr);
sfc_adapter_unlock(sa);
@ -2126,7 +2126,7 @@ sfc_eth_dev_init(struct rte_eth_dev *dev)
* Linux kernel. Copy from NIC config to Ethernet device data.
*/
from = (const struct rte_ether_addr *)(encp->enc_mac_addr);
ether_addr_copy(from, &dev->data->mac_addrs[0]);
rte_ether_addr_copy(from, &dev->data->mac_addrs[0]);
sfc_adapter_unlock(sa);

10
drivers/net/sfc/sfc_flow.c
View File

@ -277,7 +277,7 @@ sfc_flow_parse_eth(const struct rte_flow_item *item,
if (spec == NULL)
return 0;
if (is_same_ether_addr(&mask->dst, &supp_mask.dst)) {
if (rte_is_same_ether_addr(&mask->dst, &supp_mask.dst)) {
efx_spec->efs_match_flags |= is_ifrm ?
EFX_FILTER_MATCH_IFRM_LOC_MAC :
EFX_FILTER_MATCH_LOC_MAC;
@ -285,7 +285,7 @@ sfc_flow_parse_eth(const struct rte_flow_item *item,
EFX_MAC_ADDR_LEN);
} else if (memcmp(mask->dst.addr_bytes, ig_mask,
EFX_MAC_ADDR_LEN) == 0) {
if (is_unicast_ether_addr(&spec->dst))
if (rte_is_unicast_ether_addr(&spec->dst))
efx_spec->efs_match_flags |= is_ifrm ?
EFX_FILTER_MATCH_IFRM_UNKNOWN_UCAST_DST :
EFX_FILTER_MATCH_UNKNOWN_UCAST_DST;
@ -293,7 +293,7 @@ sfc_flow_parse_eth(const struct rte_flow_item *item,
efx_spec->efs_match_flags |= is_ifrm ?
EFX_FILTER_MATCH_IFRM_UNKNOWN_MCAST_DST :
EFX_FILTER_MATCH_UNKNOWN_MCAST_DST;
} else if (!is_zero_ether_addr(&mask->dst)) {
} else if (!rte_is_zero_ether_addr(&mask->dst)) {
goto fail_bad_mask;
}
@ -302,11 +302,11 @@ sfc_flow_parse_eth(const struct rte_flow_item *item,
* ethertype masks are equal to zero in inner frame,
* so these fields are filled in only for the outer frame
*/
if (is_same_ether_addr(&mask->src, &supp_mask.src)) {
if (rte_is_same_ether_addr(&mask->src, &supp_mask.src)) {
efx_spec->efs_match_flags |= EFX_FILTER_MATCH_REM_MAC;
rte_memcpy(efx_spec->efs_rem_mac, spec->src.addr_bytes,
EFX_MAC_ADDR_LEN);
} else if (!is_zero_ether_addr(&mask->src)) {
} else if (!rte_is_zero_ether_addr(&mask->src)) {
goto fail_bad_mask;
}

2
drivers/net/sfc/sfc_port.c
View File

@ -402,7 +402,7 @@ sfc_port_attach(struct sfc_adapter *sa)
RTE_BUILD_BUG_ON(sizeof(encp->enc_mac_addr) != sizeof(*from));
from = (const struct rte_ether_addr *)(encp->enc_mac_addr);
ether_addr_copy(from, &port->default_mac_addr);
rte_ether_addr_copy(from, &port->default_mac_addr);
port->max_mcast_addrs = EFX_MAC_MULTICAST_LIST_MAX;
port->nb_mcast_addrs = 0;

4
drivers/net/softnic/rte_eth_softnic_flow.c
View File

@ -1681,9 +1681,9 @@ flow_rule_action_get(struct pmd_internals *softnic,
item,
"VXLAN ENCAP: first encap item should be ether");
}
ether_addr_copy(&spec.eth.dst,
rte_ether_addr_copy(&spec.eth.dst,
&rule_action->encap.vxlan.ether.da);
ether_addr_copy(&spec.eth.src,
rte_ether_addr_copy(&spec.eth.src,
&rule_action->encap.vxlan.ether.sa);
item++;

2
drivers/net/szedata2/rte_eth_szedata2.c
View File

@ -1522,7 +1522,7 @@ rte_szedata2_eth_dev_init(struct rte_eth_dev *dev, struct port_info *pi)
return -ENOMEM;
}
ether_addr_copy(&eth_addr, data->mac_addrs);
rte_ether_addr_copy(&eth_addr, data->mac_addrs);
PMD_INIT_LOG(INFO, "%s device %s successfully initialized",
RTE_STR(RTE_SZEDATA2_DRIVER_NAME), data->name);

13
drivers/net/tap/rte_eth_tap.c
View File

@ -1163,7 +1163,7 @@ tap_mac_set(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr)
return -ENOTSUP;
}
if (is_zero_ether_addr(mac_addr)) {
if (rte_is_zero_ether_addr(mac_addr)) {
TAP_LOG(ERR, "%s: can't set an empty MAC address",
dev->device->name);
return -EINVAL;
@ -1172,14 +1172,15 @@ tap_mac_set(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr)
ret = tap_ioctl(pmd, SIOCGIFHWADDR, &ifr, 0, LOCAL_ONLY);
if (ret < 0)
return ret;
if (is_same_ether_addr((struct rte_ether_addr *)&ifr.ifr_hwaddr.sa_data,
mac_addr))
if (rte_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(
if (!rte_is_same_ether_addr(
(struct rte_ether_addr *)&ifr.ifr_hwaddr.sa_data,
mac_addr))
mode = LOCAL_AND_REMOTE;
@ -1754,8 +1755,8 @@ eth_dev_tap_create(struct rte_vdev_device *vdev, const char *tap_name,
}
if (pmd->type == ETH_TUNTAP_TYPE_TAP) {
if (is_zero_ether_addr(mac_addr))
eth_random_addr((uint8_t *)&pmd->eth_addr);
if (rte_is_zero_ether_addr(mac_addr))
rte_eth_random_addr((uint8_t *)&pmd->eth_addr);
else
rte_memcpy(&pmd->eth_addr, mac_addr, sizeof(*mac_addr));
}

4
drivers/net/tap/tap_flow.c
View File

@ -537,14 +537,14 @@ tap_flow_create_eth(const struct rte_flow_item *item, void *data)
if (!flow)
return 0;
msg = &flow->msg;
if (!is_zero_ether_addr(&mask->dst)) {
if (!rte_is_zero_ether_addr(&mask->dst)) {
tap_nlattr_add(&msg->nh, TCA_FLOWER_KEY_ETH_DST, ETHER_ADDR_LEN,
&spec->dst.addr_bytes);
tap_nlattr_add(&msg->nh,
TCA_FLOWER_KEY_ETH_DST_MASK, ETHER_ADDR_LEN,
&mask->dst.addr_bytes);
}
if (!is_zero_ether_addr(&mask->src)) {
if (!rte_is_zero_ether_addr(&mask->src)) {
tap_nlattr_add(&msg->nh, TCA_FLOWER_KEY_ETH_SRC, ETHER_ADDR_LEN,
&spec->src.addr_bytes);
tap_nlattr_add(&msg->nh,

6
drivers/net/thunderx/nicvf_ethdev.c
View 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 rte_ether_addr *)nic->mac_addr))
eth_random_addr(&nic->mac_addr[0]);
if (rte_is_zero_ether_addr((struct rte_ether_addr *)nic->mac_addr))
rte_eth_random_addr(&nic->mac_addr[0]);
ether_addr_copy((struct rte_ether_addr *)nic->mac_addr,
rte_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);

4
drivers/net/vdev_netvsc/vdev_netvsc.c
View File

@ -387,7 +387,7 @@ vdev_netvsc_device_probe(const struct if_nameindex *iface,
strlcpy(ctx->if_name, iface->if_name, sizeof(ctx->if_name));
return 0;
}
if (!is_same_ether_addr(eth_addr, &ctx->if_addr))
if (!rte_is_same_ether_addr(eth_addr, &ctx->if_addr))
return 0;
/* Look for associated PCI device. */
ret = vdev_netvsc_sysfs_readlink(buf, sizeof(buf), iface->if_name,
@ -544,7 +544,7 @@ vdev_netvsc_netvsc_probe(const struct if_nameindex *iface,
pair->value);
return -EINVAL;
}
if (is_same_ether_addr(eth_addr, &tmp))
if (rte_is_same_ether_addr(eth_addr, &tmp))
break;
}
}

4
drivers/net/vhost/rte_eth_vhost.c
View File

@ -329,8 +329,8 @@ vhost_count_multicast_broadcast(struct vhost_queue *vq,
struct vhost_stats *pstats = &vq->stats;
ea = rte_pktmbuf_mtod(mbuf, struct rte_ether_addr *);
if (is_multicast_ether_addr(ea)) {
if (is_broadcast_ether_addr(ea))
if (rte_is_multicast_ether_addr(ea)) {
if (rte_is_broadcast_ether_addr(ea))
pstats->xstats[VHOST_BROADCAST_PKT]++;
else
pstats->xstats[VHOST_MULTICAST_PKT]++;

10
drivers/net/virtio/virtio_ethdev.c
View File

@ -1108,7 +1108,7 @@ virtio_get_hwaddr(struct virtio_hw *hw)
offsetof(struct virtio_net_config, mac),
&hw->mac_addr, ETHER_ADDR_LEN);
} else {
eth_random_addr(&hw->mac_addr[0]);
rte_eth_random_addr(&hw->mac_addr[0]);
virtio_set_hwaddr(hw);
}
}
@ -1164,7 +1164,7 @@ virtio_mac_addr_add(struct rte_eth_dev *dev, struct rte_ether_addr *mac_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;
= rte_is_multicast_ether_addr(addr) ? mc : uc;
memcpy(&tbl->macs[tbl->entries++], addr, ETHER_ADDR_LEN);
}
@ -1193,10 +1193,10 @@ virtio_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index)
for (i = 0; i < VIRTIO_MAX_MAC_ADDRS; i++) {
struct virtio_net_ctrl_mac *tbl;
if (i == index || is_zero_ether_addr(addrs + i))
if (i == index || rte_is_zero_ether_addr(addrs + i))
continue;
tbl = is_multicast_ether_addr(addrs + i) ? mc : uc;
tbl = rte_is_multicast_ether_addr(addrs + i) ? mc : uc;
memcpy(&tbl->macs[tbl->entries++], addrs + i, ETHER_ADDR_LEN);
}
@ -1662,7 +1662,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 rte_ether_addr *)hw->mac_addr,
rte_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",

4
drivers/net/virtio/virtio_rxtx.c
View File

@ -1114,8 +1114,8 @@ virtio_update_packet_stats(struct virtnet_stats *stats, struct rte_mbuf *mbuf)
}
ea = rte_pktmbuf_mtod(mbuf, struct rte_ether_addr *);
if (is_multicast_ether_addr(ea)) {
if (is_broadcast_ether_addr(ea))
if (rte_is_multicast_ether_addr(ea)) {
if (rte_is_broadcast_ether_addr(ea))
stats->broadcast++;
else
stats->multicast++;

4
drivers/net/vmxnet3/vmxnet3_ethdev.c
View File

@ -316,7 +316,7 @@ eth_vmxnet3_dev_init(struct rte_eth_dev *eth_dev)
return -ENOMEM;
}
/* Copy the permanent MAC address */
ether_addr_copy((struct rte_ether_addr *)hw->perm_addr,
rte_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",
@ -1209,7 +1209,7 @@ 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 rte_ether_addr *)(hw->perm_addr));
rte_ether_addr_copy(mac_addr, (struct rte_ether_addr *)(hw->perm_addr));
vmxnet3_write_mac(hw, mac_addr->addr_bytes);
return 0;
}

9
examples/bond/main.c
View File

@ -390,12 +390,13 @@ static int lcore_main(__attribute__((unused)) void *arg1)
if (arp_hdr->arp_opcode == rte_cpu_to_be_16(RTE_ARP_OP_REQUEST)) {
arp_hdr->arp_opcode = rte_cpu_to_be_16(RTE_ARP_OP_REPLY);
/* Switch src and dst data and set bonding MAC */
ether_addr_copy(&eth_hdr->s_addr, &eth_hdr->d_addr);
rte_ether_addr_copy(&eth_hdr->s_addr, &eth_hdr->d_addr);
rte_eth_macaddr_get(BOND_PORT, &eth_hdr->s_addr);
ether_addr_copy(&arp_hdr->arp_data.arp_sha, &arp_hdr->arp_data.arp_tha);
rte_ether_addr_copy(&arp_hdr->arp_data.arp_sha,
&arp_hdr->arp_data.arp_tha);
arp_hdr->arp_data.arp_tip = arp_hdr->arp_data.arp_sip;
rte_eth_macaddr_get(BOND_PORT, &d_addr);
ether_addr_copy(&d_addr, &arp_hdr->arp_data.arp_sha);
rte_ether_addr_copy(&d_addr, &arp_hdr->arp_data.arp_sha);
arp_hdr->arp_data.arp_sip = bond_ip;
rte_eth_tx_burst(BOND_PORT, 0, &pkts[i], 1);
is_free = 1;
@ -410,7 +411,7 @@ static int lcore_main(__attribute__((unused)) void *arg1)
}
ipv4_hdr = (struct ipv4_hdr *)((char *)(eth_hdr + 1) + offset);
if (ipv4_hdr->dst_addr == bond_ip) {
ether_addr_copy(&eth_hdr->s_addr, &eth_hdr->d_addr);
rte_ether_addr_copy(&eth_hdr->s_addr, &eth_hdr->d_addr);
rte_eth_macaddr_get(BOND_PORT, &eth_hdr->s_addr);
ipv4_hdr->dst_addr = ipv4_hdr->src_addr;
ipv4_hdr->src_addr = bond_ip;

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

@ -161,8 +161,8 @@ static void process_frame(struct app_port *ptr_port,
struct rte_ether_hdr *ptr_mac_hdr;
ptr_mac_hdr = rte_pktmbuf_mtod(ptr_frame, struct rte_ether_hdr *);
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);
rte_ether_addr_copy(&ptr_mac_hdr->s_addr, &ptr_mac_hdr->d_addr);
rte_ether_addr_copy(&ptr_port->mac_addr, &ptr_mac_hdr->s_addr);
}
static int slave_main(__attribute__((unused)) void *ptr_data)

2
examples/ethtool/lib/rte_ethtool.c
View File

@ -327,7 +327,7 @@ rte_ethtool_net_validate_addr(uint16_t port_id __rte_unused,
{
if (addr == NULL)
return -EINVAL;
return is_valid_assigned_ether_addr(addr);
return rte_is_valid_assigned_ether_addr(addr);
}
int

4
examples/eventdev_pipeline/pipeline_common.h
View File

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

2
examples/flow_filtering/main.c
View File

@ -48,7 +48,7 @@ static inline void
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);
rte_ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr);
printf("%s%s", what, buf);
}

5
examples/ip_fragmentation/main.c
View File

@ -354,7 +354,8 @@ l3fwd_simple_forward(struct rte_mbuf *m, struct lcore_queue_conf *qconf,
*((uint64_t *)d_addr_bytes) = 0x000000000002 + ((uint64_t)port_out << 40);
/* src addr */
ether_addr_copy(&ports_eth_addr[port_out], &eth_hdr->s_addr);
rte_ether_addr_copy(&ports_eth_addr[port_out],
&eth_hdr->s_addr);
if (ipv6)
eth_hdr->ether_type = rte_be_to_cpu_16(ETHER_TYPE_IPv6);
else
@ -572,7 +573,7 @@ static void
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);
rte_ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr);
printf("%s%s", name, buf);
}

4
examples/ip_reassembly/main.c
View File

@ -410,7 +410,7 @@ reassemble(struct rte_mbuf *m, uint16_t portid, uint32_t queue,
*((uint64_t *)d_addr_bytes) = 0x000000000002 + ((uint64_t)dst_port << 40);
/* src addr */
ether_addr_copy(&ports_eth_addr[dst_port], &eth_hdr->s_addr);
rte_ether_addr_copy(&ports_eth_addr[dst_port], &eth_hdr->s_addr);
send_single_packet(m, dst_port);
}
@ -695,7 +695,7 @@ static void
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);
rte_ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr);
printf("%s%s", name, buf);
}

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

@ -1428,7 +1428,7 @@ static void
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);
rte_ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr);
printf("%s%s", name, buf);
}

6
examples/ipv4_multicast/main.c
View File

@ -278,8 +278,8 @@ mcast_send_pkt(struct rte_mbuf *pkt, struct rte_ether_addr *dest_addr,
rte_pktmbuf_prepend(pkt, (uint16_t)sizeof(*ethdr));
RTE_ASSERT(ethdr != NULL);
ether_addr_copy(dest_addr, &ethdr->d_addr);
ether_addr_copy(&ports_eth_addr[port], &ethdr->s_addr);
rte_ether_addr_copy(dest_addr, &ethdr->d_addr);
rte_ether_addr_copy(&ports_eth_addr[port], &ethdr->s_addr);
ethdr->ether_type = rte_be_to_cpu_16(ETHER_TYPE_IPv4);
/* Put new packet into the output queue */
@ -540,7 +540,7 @@ static void
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);
rte_ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr);
printf("%s%s", name, buf);
}

2
examples/kni/main.c
View File

@ -835,7 +835,7 @@ static void
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);
rte_ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, mac_addr);
RTE_LOG(INFO, APP, "\t%s%s\n", name, buf);
}

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

@ -603,7 +603,7 @@ l2fwd_mac_updating(struct rte_mbuf *m, uint16_t dest_portid)
*((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dest_portid << 40);
/* src addr */
ether_addr_copy(&l2fwd_ports_eth_addr[dest_portid], &eth->s_addr);
rte_ether_addr_copy(&l2fwd_ports_eth_addr[dest_portid], &eth->s_addr);
}
static void

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

@ -349,7 +349,7 @@ l2fwd_simple_forward(struct rte_mbuf *m, unsigned portid)
*((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dst_port << 40);
/* src addr */
ether_addr_copy(&l2fwd_ports_eth_addr[dst_port], &eth->s_addr);
rte_ether_addr_copy(&l2fwd_ports_eth_addr[dst_port], &eth->s_addr);
buffer = tx_buffer[dst_port];
sent = rte_eth_tx_buffer(dst_port, 0, buffer, m);

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

@ -179,7 +179,7 @@ l2fwd_simple_forward(struct rte_mbuf *m, unsigned portid)
*((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dst_port << 40);
/* src addr */
ether_addr_copy(&l2fwd_ports_eth_addr[dst_port], &eth->s_addr);
rte_ether_addr_copy(&l2fwd_ports_eth_addr[dst_port], &eth->s_addr);
buffer = tx_buffer[dst_port];
sent = rte_eth_tx_buffer(dst_port, 0, buffer, m);

2
examples/l2fwd/main.c
View File

@ -161,7 +161,7 @@ l2fwd_mac_updating(struct rte_mbuf *m, unsigned dest_portid)
*((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dest_portid << 40);
/* src addr */
ether_addr_copy(&l2fwd_ports_eth_addr[dest_portid], &eth->s_addr);
rte_ether_addr_copy(&l2fwd_ports_eth_addr[dest_portid], &eth->s_addr);
}
static void

Some files were not shown because too many files have changed in this diff Show More