-/*-
- * BSD LICENSE
- *
- * Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in
- * the documentation and/or other materials provided with the
- * distribution.
- * * Neither the name of Intel Corporation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2010-2014 Intel Corporation
*/
#include <string.h>
#define SLAVE_COUNT (4)
-#define RX_RING_SIZE 128
-#define TX_RING_SIZE 512
+#define RX_RING_SIZE 1024
+#define TX_RING_SIZE 1024
#define MBUF_CACHE_SIZE (250)
#define BURST_SIZE (32)
#define MAX_PKT_BURST (32)
#define DEF_PKT_BURST (16)
-#define BONDED_DEV_NAME ("unit_test_mode4_bond_dev")
+#define BONDED_DEV_NAME ("net_bonding_m4_bond_dev")
-#define SLAVE_DEV_NAME_FMT ("unit_test_mode4_slave_%d")
-#define SLAVE_RX_QUEUE_FMT ("unit_test_mode4_slave_%d_rx")
-#define SLAVE_TX_QUEUE_FMT ("unit_test_mode4_slave_%d_tx")
+#define SLAVE_DEV_NAME_FMT ("net_virt_%d")
+#define SLAVE_RX_QUEUE_FMT ("net_virt_%d_rx")
+#define SLAVE_TX_QUEUE_FMT ("net_virt_%d_tx")
#define INVALID_SOCKET_ID (-1)
#define INVALID_PORT_ID (0xFF)
#define INVALID_BONDING_MODE (-1)
-static const struct ether_addr slave_mac_default = {
+static const struct rte_ether_addr slave_mac_default = {
{ 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00 }
};
-static const struct ether_addr parnter_mac_default = {
+static const struct rte_ether_addr parnter_mac_default = {
{ 0x22, 0xBB, 0xFF, 0xBB, 0x00, 0x00 }
};
-static const struct ether_addr parnter_system = {
+static const struct rte_ether_addr parnter_system = {
{ 0x33, 0xFF, 0xBB, 0xFF, 0x00, 0x00 }
};
-static const struct ether_addr slow_protocol_mac_addr = {
+static const struct rte_ether_addr slow_protocol_mac_addr = {
{ 0x01, 0x80, 0xC2, 0x00, 0x00, 0x02 }
};
struct slave_conf {
struct rte_ring *rx_queue;
struct rte_ring *tx_queue;
- uint8_t port_id;
+ uint16_t port_id;
uint8_t bonded : 1;
uint8_t lacp_parnter_state;
};
struct ether_vlan_hdr {
- struct ether_hdr pkt_eth_hdr;
- struct vlan_hdr vlan_hdr;
+ struct rte_ether_hdr pkt_eth_hdr;
+ struct rte_vlan_hdr vlan_hdr;
};
struct link_bonding_unittest_params {
.mq_mode = ETH_MQ_RX_NONE,
.max_rx_pkt_len = ETHER_MAX_LEN,
.split_hdr_size = 0,
- .header_split = 0, /**< Header Split disabled */
- .hw_ip_checksum = 0, /**< IP checksum offload enabled */
- .hw_vlan_filter = 0, /**< VLAN filtering disabled */
- .jumbo_frame = 0, /**< Jumbo Frame Support disabled */
- .hw_strip_crc = 0, /**< CRC stripped by hardware */
},
.txmode = {
.mq_mode = ETH_MQ_TX_NONE,
static int
slave_get_pkts(struct slave_conf *slave, struct rte_mbuf **buf, uint16_t size)
{
- return rte_ring_dequeue_burst(slave->tx_queue, (void **)buf, size);
+ return rte_ring_dequeue_burst(slave->tx_queue, (void **)buf,
+ size, NULL);
}
/*
static int
slave_put_pkts(struct slave_conf *slave, struct rte_mbuf **buf, uint16_t size)
{
- return rte_ring_enqueue_burst(slave->rx_queue, (void **)buf, size);
+ return rte_ring_enqueue_burst(slave->rx_queue, (void **)buf,
+ size, NULL);
}
static uint16_t
}
static int
-configure_ethdev(uint8_t port_id, uint8_t start)
+configure_ethdev(uint16_t port_id, uint8_t start)
{
TEST_ASSERT(rte_eth_dev_configure(port_id, 1, 1, &default_pmd_conf) == 0,
"Failed to configure device %u", port_id);
static int
add_slave(struct slave_conf *slave, uint8_t start)
{
- struct ether_addr addr, addr_check;
+ struct rte_ether_addr addr, addr_check;
/* Some sanity check */
RTE_VERIFY(test_params.slave_ports <= slave &&
}
static void
-lacp_recv_cb(uint8_t slave_id, struct rte_mbuf *lacp_pkt)
+lacp_recv_cb(uint16_t slave_id, struct rte_mbuf *lacp_pkt)
{
- struct ether_hdr *hdr;
+ struct rte_ether_hdr *hdr;
struct slow_protocol_frame *slow_hdr;
RTE_VERIFY(lacp_pkt != NULL);
- hdr = rte_pktmbuf_mtod(lacp_pkt, struct ether_hdr *);
+ hdr = rte_pktmbuf_mtod(lacp_pkt, struct rte_ether_hdr *);
RTE_VERIFY(hdr->ether_type == rte_cpu_to_be_16(ETHER_TYPE_SLOW));
slow_hdr = rte_pktmbuf_mtod(lacp_pkt, struct slow_protocol_frame *);
}
static int
-initialize_bonded_device_with_slaves(uint8_t slave_count, uint8_t external_sm)
+initialize_bonded_device_with_slaves(uint16_t slave_count, uint8_t external_sm)
{
uint8_t i;
{
struct slave_conf *slave;
int retval;
- uint8_t slaves[RTE_MAX_ETHPORTS];
- uint8_t i;
+ uint16_t slaves[RTE_MAX_ETHPORTS];
+ uint16_t i;
rte_eth_dev_stop(test_params.bonded_port_id);
char name[RTE_ETH_NAME_MAX_LEN];
struct slave_conf *port;
const uint8_t socket_id = rte_socket_id();
- uint8_t i;
+ uint16_t i;
if (test_params.mbuf_pool == NULL) {
nb_mbuf_per_pool = TEST_RX_DESC_MAX + DEF_PKT_BURST +
TEST_ASSERT(retval >= 0,
"Failed to create ring ethdev '%s'\n", name);
- port->port_id = rte_eth_dev_count() - 1;
+ port->port_id = rte_eth_dev_count_avail() - 1;
}
retval = configure_ethdev(port->port_id, 1);
static int
make_lacp_reply(struct slave_conf *slave, struct rte_mbuf *pkt)
{
- struct ether_hdr *hdr;
+ struct rte_ether_hdr *hdr;
struct slow_protocol_frame *slow_hdr;
struct lacpdu *lacp;
/* look for LACP */
- hdr = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
+ hdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
if (hdr->ether_type != rte_cpu_to_be_16(ETHER_TYPE_SLOW))
return 1;
TEST_ASSERT_EQUAL(all_slaves_done, 1, "Bond handshake failed\n");
/* If flags doesn't match - report failure */
- return all_slaves_done = 1 ? TEST_SUCCESS : TEST_FAILED;
+ return all_slaves_done == 1 ? TEST_SUCCESS : TEST_FAILED;
}
#define TEST_LACP_SLAVE_COUT RTE_DIM(test_params.slave_ports)
return TEST_SUCCESS;
}
+static int
+test_mode4_agg_mode_selection(void)
+{
+ int retval;
+ /* Test and verify for Stable mode */
+ retval = initialize_bonded_device_with_slaves(TEST_LACP_SLAVE_COUT, 0);
+ TEST_ASSERT_SUCCESS(retval, "Failed to initialize bonded device");
+
+
+ retval = rte_eth_bond_8023ad_agg_selection_set(
+ test_params.bonded_port_id, AGG_STABLE);
+ TEST_ASSERT_SUCCESS(retval, "Failed to initialize bond aggregation mode");
+ retval = bond_handshake();
+ TEST_ASSERT_SUCCESS(retval, "Initial handshake failed");
+
+
+ retval = rte_eth_bond_8023ad_agg_selection_get(
+ test_params.bonded_port_id);
+ TEST_ASSERT_EQUAL(retval, AGG_STABLE,
+ "Wrong agg mode received from bonding device");
+
+ retval = remove_slaves_and_stop_bonded_device();
+ TEST_ASSERT_SUCCESS(retval, "Test cleanup failed.");
+
+
+ /* test and verify for Bandwidth mode */
+ retval = initialize_bonded_device_with_slaves(TEST_LACP_SLAVE_COUT, 0);
+ TEST_ASSERT_SUCCESS(retval, "Failed to initialize bonded device");
+
+
+ retval = rte_eth_bond_8023ad_agg_selection_set(
+ test_params.bonded_port_id,
+ AGG_BANDWIDTH);
+ TEST_ASSERT_SUCCESS(retval,
+ "Failed to initialize bond aggregation mode");
+ retval = bond_handshake();
+ TEST_ASSERT_SUCCESS(retval, "Initial handshake failed");
+
+ retval = rte_eth_bond_8023ad_agg_selection_get(
+ test_params.bonded_port_id);
+ TEST_ASSERT_EQUAL(retval, AGG_BANDWIDTH,
+ "Wrong agg mode received from bonding device");
+
+ retval = remove_slaves_and_stop_bonded_device();
+ TEST_ASSERT_SUCCESS(retval, "Test cleanup failed.");
+
+ /* test and verify selection for count mode */
+ retval = initialize_bonded_device_with_slaves(TEST_LACP_SLAVE_COUT, 0);
+ TEST_ASSERT_SUCCESS(retval, "Failed to initialize bonded device");
+
+
+ retval = rte_eth_bond_8023ad_agg_selection_set(
+ test_params.bonded_port_id, AGG_COUNT);
+ TEST_ASSERT_SUCCESS(retval,
+ "Failed to initialize bond aggregation mode");
+ retval = bond_handshake();
+ TEST_ASSERT_SUCCESS(retval, "Initial handshake failed");
+
+ retval = rte_eth_bond_8023ad_agg_selection_get(
+ test_params.bonded_port_id);
+ TEST_ASSERT_EQUAL(retval, AGG_COUNT,
+ "Wrong agg mode received from bonding device");
+
+ retval = remove_slaves_and_stop_bonded_device();
+ TEST_ASSERT_SUCCESS(retval, "Test cleanup failed.");
+
+ return TEST_SUCCESS;
+}
static int
-generate_packets(struct ether_addr *src_mac,
- struct ether_addr *dst_mac, uint16_t count, struct rte_mbuf **buf)
+generate_packets(struct rte_ether_addr *src_mac,
+ struct rte_ether_addr *dst_mac, uint16_t count, struct rte_mbuf **buf)
{
uint16_t pktlen = PACKET_BURST_GEN_PKT_LEN;
uint8_t vlan_enable = 0;
uint32_t ip_src[4] = { [0 ... 2] = 0xDEADBEEF, [3] = IPv4(192, 168, 0, 1) };
uint32_t ip_dst[4] = { [0 ... 2] = 0xFEEDFACE, [3] = IPv4(192, 168, 0, 2) };
- struct ether_hdr pkt_eth_hdr;
+ struct rte_ether_hdr pkt_eth_hdr;
struct udp_hdr pkt_udp_hdr;
union {
struct ipv4_hdr v4;
}
static int
-generate_and_put_packets(struct slave_conf *slave, struct ether_addr *src_mac,
- struct ether_addr *dst_mac, uint16_t count)
+generate_and_put_packets(struct slave_conf *slave,
+ struct rte_ether_addr *src_mac,
+ struct rte_ether_addr *dst_mac, uint16_t count)
{
struct rte_mbuf *pkts[MAX_PKT_BURST];
int retval;
int retval;
unsigned delay;
- struct ether_hdr *hdr;
+ struct rte_ether_hdr *hdr;
- struct ether_addr src_mac = { { 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00 } };
- struct ether_addr dst_mac;
- struct ether_addr bonded_mac;
+ struct rte_ether_addr src_mac = {
+ { 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00 } };
+ struct rte_ether_addr dst_mac;
+ struct rte_ether_addr bonded_mac;
retval = initialize_bonded_device_with_slaves(TEST_PROMISC_SLAVE_COUNT,
0);
int cnt[2] = { 0, 0 };
for (i = 0; i < expected_pkts_cnt; i++) {
- hdr = rte_pktmbuf_mtod(pkts[i], struct ether_hdr *);
+ hdr = rte_pktmbuf_mtod(pkts[i], struct rte_ether_hdr *);
cnt[is_same_ether_addr(&hdr->d_addr, &bonded_mac)]++;
}
TEST_ASSERT(cnt[0] == expected_pkts_cnt / 2 &&
cnt[1] == expected_pkts_cnt / 2,
"Expected %u packets with the same MAC and %u with different but "
- "got %u with the same and %u with diffrent MAC",
+ "got %u with the same and %u with different MAC",
expected_pkts_cnt / 2, expected_pkts_cnt / 2, cnt[1], cnt[0]);
} else if (retval > 0)
free_pkts(pkts, retval);
int eq_cnt = 0;
for (i = 0; i < expected_pkts_cnt; i++) {
- hdr = rte_pktmbuf_mtod(pkts[i], struct ether_hdr *);
+ hdr = rte_pktmbuf_mtod(pkts[i], struct rte_ether_hdr *);
eq_cnt += is_same_ether_addr(&hdr->d_addr, &bonded_mac);
}
break;
}
- TEST_ASSERT(j < 5, "Failed to agregate slave after link up");
+ TEST_ASSERT(j < 5, "Failed to aggregate slave after link up");
}
remove_slaves_and_stop_bonded_device();
int retval;
unsigned delay;
- struct ether_addr dst_mac = { { 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00 } };
- struct ether_addr bonded_mac;
+ struct rte_ether_addr dst_mac = {
+ { 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00 } };
+ struct rte_ether_addr bonded_mac;
retval = initialize_bonded_device_with_slaves(TEST_TX_SLAVE_COUNT, 0);
TEST_ASSERT_SUCCESS(retval, "Failed to initialize bonded device");
retval = bond_handshake_reply(slave);
TEST_ASSERT(retval >= 0, "Handshake failed");
- /* Remove replay for slave that supose to be expired. */
+ /* Remove replay for slave that suppose to be expired. */
if (slave == exp_slave) {
while (rte_ring_count(slave->rx_queue) > 0) {
void *pkt = NULL;
uint8_t i;
struct rte_mbuf *lacp_tx_buf[SLAVE_COUNT];
- struct ether_addr src_mac, dst_mac;
+ struct rte_ether_addr src_mac, dst_mac;
struct lacpdu_header lacpdu = {
.lacpdu = {
.subtype = SLOW_SUBTYPE_LACP,
struct rte_mbuf *lacp_tx_buf[SLAVE_COUNT];
struct rte_mbuf *buf[SLAVE_COUNT];
- struct ether_addr src_mac, dst_mac;
+ struct rte_ether_addr src_mac, dst_mac;
struct lacpdu_header lacpdu = {
.lacpdu = {
.subtype = SLOW_SUBTYPE_LACP,
{
struct slave_conf *port;
uint8_t i, env_state;
- uint8_t slaves[RTE_DIM(test_params.slave_ports)];
+ uint16_t slaves[RTE_DIM(test_params.slave_ports)];
int slaves_count;
env_state = 0;
return test_result;
}
+static int
+test_mode4_agg_mode_selection_wrapper(void){
+ return test_mode4_executor(&test_mode4_agg_mode_selection);
+}
+
static int
test_mode4_lacp_wrapper(void)
{
.setup = test_setup,
.teardown = testsuite_teardown,
.unit_test_cases = {
+ TEST_CASE_NAMED("test_mode4_agg_mode_selection",
+ test_mode4_agg_mode_selection_wrapper),
TEST_CASE_NAMED("test_mode4_lacp", test_mode4_lacp_wrapper),
TEST_CASE_NAMED("test_mode4_rx", test_mode4_rx_wrapper),
TEST_CASE_NAMED("test_mode4_tx_burst", test_mode4_tx_burst_wrapper),
git.droids-corp.org / dpdk.git / blobdiff