void test_benchmark_queue(int argc, char **argv)
{
struct pg_error *error = NULL;
struct pg_brick *queue_enter;
struct pg_brick *queue_exit;
struct pg_bench bench;
struct pg_bench_stats stats;
struct ether_addr mac1 = {{0x52,0x54,0x00,0x12,0x34,0x11}};
struct ether_addr mac2 = {{0x52,0x54,0x00,0x12,0x34,0x21}};
uint32_t len;
queue_enter = pg_queue_new("enter", 10, &error);
if (error) {
pg_error_print(error);
g_assert(0);
}
queue_exit = pg_queue_new("enter", 10, &error);
if (error) {
pg_error_print(error);
g_assert(0);
}
if (pg_queue_friend(queue_enter, queue_exit, &error)) {
pg_error_print(error);
g_assert(0);
}
g_assert(!pg_bench_init(&bench, "queue", argc, argv, &error));
bench.input_brick = queue_enter;
bench.input_side = WEST_SIDE;
bench.output_brick = queue_exit;
bench.output_side = WEST_SIDE;
bench.output_poll = true;
bench.max_burst_cnt = 1000000;
bench.count_brick = NULL;
bench.pkts_nb = 64;
bench.pkts_mask = pg_mask_firsts(64);
bench.pkts = pg_packets_create(bench.pkts_mask);
bench.pkts = pg_packets_append_ether(
bench.pkts,
bench.pkts_mask,
&mac1, &mac2,
ETHER_TYPE_IPv4);
len = sizeof(struct ipv4_hdr) + sizeof(struct udp_hdr) + 1400;
pg_packets_append_ipv4(
bench.pkts,
bench.pkts_mask,
0x000000EE, 0x000000CC, len, 17);
bench.pkts = pg_packets_append_udp(
bench.pkts,
bench.pkts_mask,
1000, 2000, 1400);
bench.pkts = pg_packets_append_blank(bench.pkts, bench.pkts_mask, 1400);
g_assert(!pg_bench_run(&bench, &stats, &error));
pg_bench_print(&stats);
pg_packets_free(bench.pkts, bench.pkts_mask);
pg_brick_destroy(queue_enter);
pg_brick_destroy(queue_exit);
}
static void test_brick_pkts_count_west(void)
{
TEST_PKTS_COUNT_INIT();
unsigned int pkts_count;
int j;
for (j = 0, pkts_count = NB_PKTS; j < NB_LOOP;
++j, pkts_count += NB_PKTS) {
pg_brick_burst_to_west(brick, 0, pkts,
pg_mask_firsts(NB_PKTS), &error);
g_assert(!error);
g_assert(pg_brick_pkts_count_get(collect_east, WEST_SIDE) == 0);
g_assert(pg_brick_pkts_count_get(collect_east, EAST_SIDE) == 0);
g_assert(pg_brick_pkts_count_get(collect_west,
WEST_SIDE) == pkts_count);
g_assert(pg_brick_pkts_count_get(collect_west, EAST_SIDE) == 0);
g_assert(pg_brick_pkts_count_get(brick, WEST_SIDE) == pkts_count);
g_assert(pg_brick_pkts_count_get(brick, EAST_SIDE) == 0);
TEST_PKTS_COUNT_CHECK(pg_brick_west_burst_get, collect_west, 0);
TEST_PKTS_COUNT_CHECK(pg_brick_east_burst_get, collect_west, 3);
TEST_PKTS_COUNT_CHECK(pg_brick_west_burst_get, collect_east, 0);
TEST_PKTS_COUNT_CHECK(pg_brick_east_burst_get, collect_east, 0);
}
TEST_PKTS_COUNT_DESTROY();
}
void test_benchmark_antispoof(void)
{
struct pg_error *error = NULL;
struct pg_brick *antispoof;
struct pg_bench bench;
struct pg_bench_stats stats;
struct ether_addr mac1 = {{0x52,0x54,0x00,0x12,0x34,0x11}};
struct ether_addr mac2 = {{0x52,0x54,0x00,0x12,0x34,0x21}};
uint32_t len;
pg_bench_init(&bench);
antispoof = pg_antispoof_new("antispoof", 1, 1, EAST_SIDE,
mac1, &error);
g_assert(!error);
pg_antispoof_arp_enable(antispoof, 0x000000EE);
bench.input_brick = antispoof;
bench.input_side = WEST_SIDE;
bench.output_brick = antispoof;
bench.output_side = EAST_SIDE;
bench.output_poll = false;
bench.max_burst_cnt = 10000000;
bench.count_brick = NULL;
bench.pkts_nb = 64;
bench.pkts_mask = pg_mask_firsts(64);
bench.pkts = pg_packets_create(bench.pkts_mask);
bench.pkts = pg_packets_append_ether(
bench.pkts,
bench.pkts_mask,
&mac1, &mac2,
ETHER_TYPE_IPv4);
len = sizeof(struct ipv4_hdr) + sizeof(struct udp_hdr) +
sizeof(struct vxlan_hdr) + sizeof(struct ether_hdr) + 1400;
pg_packets_append_ipv4(
bench.pkts,
bench.pkts_mask,
0x000000EE, 0x000000CC, len, 17);
bench.pkts = pg_packets_append_udp(
bench.pkts,
bench.pkts_mask,
1000, 2000, 1400);
bench.pkts = pg_packets_append_blank(bench.pkts, bench.pkts_mask, 1400);
g_assert(pg_bench_run(&bench, &stats, &error));
/* We know that this brick burst all packets. */
stats.pkts_burst = stats.pkts_sent;
g_assert(pg_bench_print(&stats, NULL));
pg_packets_free(bench.pkts, bench.pkts_mask);
pg_brick_destroy(antispoof);
}
void test_benchmark_print(int argc, char **argv)
{
struct pg_error *error = NULL;
struct pg_brick *print;
struct pg_bench bench;
struct pg_bench_stats stats;
struct ether_addr mac1 = {{0x52,0x54,0x00,0x12,0x34,0x11}};
struct ether_addr mac2 = {{0x52,0x54,0x00,0x12,0x34,0x21}};
uint32_t len;
g_assert(!pg_bench_init(&bench, "print", argc, argv, &error));
print = pg_print_new("print", stderr,
PG_PRINT_FLAG_SUMMARY | PG_PRINT_FLAG_TIMESTAMP,
NULL, &error);
g_assert(!error);
bench.input_brick = print;
bench.input_side = WEST_SIDE;
bench.output_brick = print;
bench.output_side = EAST_SIDE;
bench.output_poll = false;
bench.max_burst_cnt = 100000;
bench.count_brick = NULL;
bench.pkts_nb = 64;
bench.pkts_mask = pg_mask_firsts(64);
bench.pkts = pg_packets_create(bench.pkts_mask);
bench.pkts = pg_packets_append_ether(
bench.pkts,
bench.pkts_mask,
&mac1, &mac2,
ETHER_TYPE_IPv4);
bench.brick_full_burst = 1;
len = sizeof(struct ipv4_hdr) + sizeof(struct udp_hdr) + 1400;
pg_packets_append_ipv4(
bench.pkts,
bench.pkts_mask,
0x000000EE, 0x000000CC, len, 17);
bench.pkts = pg_packets_append_udp(
bench.pkts,
bench.pkts_mask,
1000, 2000, 1400);
bench.pkts = pg_packets_append_blank(bench.pkts, bench.pkts_mask, 1400);
g_assert(pg_bench_run(&bench, &stats, &error) == 0);
pg_bench_print(&stats);
pg_packets_free(bench.pkts, bench.pkts_mask);
pg_brick_destroy(print);
}
static void test_diode_east_bad_direction(void)
{
TEST_DIODE_INIT(WEST_SIDE);
/* send a burst to the east from the westest nope brick */
pg_brick_burst_to_east(node1, 0, pkts, pg_mask_firsts(NB_PKTS),
&error);
/* check no packet ended */
DIODE_TEST(pg_brick_west_burst_get, collect_east, 0);
DIODE_TEST(pg_brick_east_burst_get, collect_east, 0);
DIODE_TEST(pg_brick_west_burst_get, collect_west, 0);
DIODE_TEST(pg_brick_east_burst_get, collect_west, 0);
TEST_DIODE_DESTROY();
}
static void test_sorting_pmtud(void)
{
struct pg_error *error = NULL;
struct pg_brick *pmtud;
struct pg_brick *col_east;
struct rte_mbuf **pkts;
uint64_t pkts_mask;
struct ether_addr eth = {{0}};
pkts = pg_packets_append_ether(pg_packets_create(pg_mask_firsts(64)),
pg_mask_firsts(64), ð, ð,
ETHER_TYPE_IPv4);
pg_packets_append_ipv4(pkts, pg_mask_firsts(64), 1, 2, 0, 0);
pg_packets_append_blank(pkts,
pg_mask_firsts(32),
431 - sizeof(struct ipv4_hdr) -
sizeof(struct ether_hdr));
pg_packets_append_blank(pkts,
pg_mask_firsts(64) & ~pg_mask_firsts(32),
430 - sizeof(struct ipv4_hdr) -
sizeof(struct ether_hdr));
pmtud = pg_pmtud_new("pmtud", PG_WEST_SIDE, 430, &error);
g_assert(!error);
col_east = pg_collect_new("col_east", &error);
g_assert(!error);
pg_brick_link(pmtud, col_east, &error);
g_assert(!error);
pg_brick_burst(pmtud, PG_WEST_SIDE, 0, pkts, pg_mask_firsts(64), &error);
g_assert(!error);
pg_brick_west_burst_get(col_east, &pkts_mask, &error);
g_assert(!error);
g_assert(pg_mask_count(pkts_mask) == 32);
pg_brick_destroy(pmtud);
pg_brick_destroy(col_east);
pg_packets_free(pkts, pg_mask_firsts(64));
g_free(pkts);
}
static void test_sorting_pmtud_df(void)
{
struct pg_error *error = NULL;
struct pg_brick *pmtud;
struct pg_brick *col_east;
struct rte_mbuf **pkts;
uint64_t pkts_mask;
struct ether_addr eth = {{0}};
uint64_t buff[4] = {0, 0, 0, 0};
pkts = pg_packets_append_ether(pg_packets_create(pg_mask_firsts(64)),
pg_mask_firsts(64), ð, ð,
ETHER_TYPE_IPv4);
pg_packets_append_ipv4(pkts, pg_mask_firsts(32), 1, 2, 0, 0);
/* Initialise ip header to 0, this ensure that DF flag is not set*/
pg_packets_append_buf(pkts,
pg_mask_firsts(64) & ~pg_mask_firsts(32),
buff, sizeof(uint64_t) * 4);
pg_packets_append_blank(pkts, pg_mask_firsts(64), 400);
pmtud = pg_pmtud_new("pmtud", PG_WEST_SIDE, 430, &error);
g_assert(!error);
col_east = pg_collect_new("col_east", &error);
g_assert(!error);
pg_brick_link(pmtud, col_east, &error);
g_assert(!error);
pg_brick_burst(pmtud, PG_WEST_SIDE, 0, pkts, pg_mask_firsts(64), &error);
g_assert(!error);
pg_brick_west_burst_get(col_east, &pkts_mask, &error);
g_assert(!error);
g_assert(pg_mask_count(pkts_mask) == 32);
pg_brick_destroy(pmtud);
pg_brick_destroy(col_east);
pg_packets_free(pkts, pg_mask_firsts(64));
g_free(pkts);
}
static void test_queue_reset(void)
{
# define NB_PKTS 64
struct pg_error *error = NULL;
struct pg_brick *queue1, *queue2, *collect;
struct rte_mbuf **result_pkts;
struct rte_mbuf *pkts[NB_PKTS];
uint64_t pkts_mask, i, j;
uint16_t count = 0;
struct rte_mempool *mbuf_pool = pg_get_mempool();
/**
* Burst packets in queue1 and test reset of queue1
* [queue1] ~ [queue2]----[collect]
*/
queue1 = pg_queue_new("q1", 10, &error);
CHECK_ERROR(error);
queue2 = pg_queue_new("q2", 10, &error);
CHECK_ERROR(error);
collect = pg_collect_new("collect", 1, 1, &error);
CHECK_ERROR(error);
pg_brick_link(queue2, collect, &error);
CHECK_ERROR(error);
g_assert(!pg_queue_friend(queue1, queue2, &error));
CHECK_ERROR(error);
for (i = 0; i < NB_PKTS; i++) {
pkts[i] = rte_pktmbuf_alloc(mbuf_pool);
g_assert(pkts[i]);
pkts[i]->udata64 = i;
pg_set_mac_addrs(pkts[i],
"F0:F1:F2:F3:F4:F5",
"E0:E1:E2:E3:E4:E5");
}
for (j = 0; j < 100; j++) {
for (i = 0; i < NB_PKTS; i++)
pkts[i]->udata64 = i * j;
/* burst and reset */
pg_brick_burst_to_east(queue1, 0, pkts, pg_mask_firsts(NB_PKTS),
&error);
CHECK_ERROR(error);
g_assert(pg_queue_pressure(queue1) > 0);
g_assert(!pg_brick_reset(queue1, &error));
g_assert(pg_queue_get_friend(queue1) == NULL);
g_assert(pg_queue_get_friend(queue2) == NULL);
g_assert(pg_queue_pressure(queue1) == 0);
g_assert(pg_queue_pressure(queue2) == 0);
pg_brick_poll(queue2, &count, &error);
g_assert(!error);
g_assert(count == 0);
/* refriend and burst ok */
g_assert(!pg_queue_friend(queue1, queue2, &error));
g_assert(!error);
g_assert(pg_queue_are_friend(queue1, queue2));
g_assert(!error);
pg_brick_burst_to_east(queue1, 0, pkts, pg_mask_firsts(NB_PKTS),
&error);
CHECK_ERROR(error);
g_assert(pg_queue_pressure(queue1) > 0);
pg_brick_poll(queue2, &count, &error);
g_assert(count == NB_PKTS);
result_pkts = pg_brick_west_burst_get(collect, &pkts_mask,
&error);
CHECK_ERROR(error);
g_assert(pkts_mask == pg_mask_firsts(NB_PKTS));
for (i = 0; i < NB_PKTS; i++) {
g_assert(result_pkts[i]);
g_assert(result_pkts[i]->udata64 == i * j);
}
pg_brick_reset(collect, &error);
CHECK_ERROR(error);
}
/* clean */
for (i = 0; i < NB_PKTS; i++)
rte_pktmbuf_free(pkts[i]);
pg_brick_decref(queue1, &error);
CHECK_ERROR(error);
pg_brick_decref(queue2, &error);
CHECK_ERROR(error);
pg_brick_decref(collect, &error);
CHECK_ERROR(error);
# undef NB_PKTS
}
static void test_icmp_pmtud(void)
{
struct pg_error *error = NULL;
struct pg_brick *pmtud;
struct pg_brick *col_east;
struct pg_brick *col_west;
/* struct pg_brick *print_east; */
/* struct pg_brick *print_west; */
/* FILE *east_file = fopen("east_file.pcap", "w+"); */
/* FILE *west_file = fopen("west_file.pcap", "w+"); */
struct rte_mbuf **pkts;
struct rte_mbuf *tmp;
uint64_t pkts_mask;
struct ether_addr eth_s = {{2}};
struct ether_addr eth_d = {{4}};
pkts = pg_packets_append_ether(pg_packets_create(pg_mask_firsts(64)),
pg_mask_firsts(64), ð_s, ð_d,
ETHER_TYPE_IPv4);
pg_packets_append_ipv4(pkts, pg_mask_firsts(64), 1, 2, 0, 0);
/* 10 caracter with the \0*/
pg_packets_append_str(pkts, pg_mask_firsts(64), "siegzeon ");
pg_packets_append_blank(pkts,
pg_mask_firsts(32),
421 - sizeof(struct ipv4_hdr) -
sizeof(struct ether_hdr));
pg_packets_append_blank(pkts,
pg_mask_firsts(64) & ~pg_mask_firsts(32),
420 - sizeof(struct ipv4_hdr) -
sizeof(struct ether_hdr));
/*
* [col_west] -- [print_west] -- [pmtud] -- [print_east] -- [col_east]
*/
pmtud = pg_pmtud_new("pmtud", PG_WEST_SIDE, 430, &error);
g_assert(!error);
col_east = pg_collect_new("col_east", &error);
g_assert(col_east);
g_assert(!error);
col_west = pg_collect_new("col_west", &error);
g_assert(!error);
g_assert(col_west);
/* print_east = pg_print_new("print_east", 1, 1, east_file, */
/* PG_PRINT_FLAG_PCAP, NULL, &error); */
/* g_assert(col_east); */
/* g_assert(!error); */
/* print_west = pg_print_new("print_west", 1, 1, west_file, */
/* PG_PRINT_FLAG_PCAP, NULL, &error); */
/* g_assert(!error); */
/* g_assert(col_west); */
/* pg_brick_chained_links(&error, col_west, print_west, pmtud, */
/* print_east, col_east); */
/* g_assert(!error); */
pg_brick_chained_links(&error, col_west, pmtud, col_east);
g_assert(!error);
pg_brick_burst_to_east(pmtud, 0, pkts, pg_mask_firsts(64), &error);
g_assert(!error);
pg_brick_west_burst_get(col_east, &pkts_mask, &error);
g_assert(!error);
g_assert(pg_mask_count(pkts_mask) == 32);
g_assert(pg_brick_pkts_count_get(pmtud, PG_EAST_SIDE) == 64);
g_assert(pg_brick_pkts_count_get(col_east, PG_EAST_SIDE) == 32);
g_assert(pg_brick_pkts_count_get(col_west, PG_WEST_SIDE) == 32);
tmp = pg_brick_east_burst_get(col_west, &pkts_mask, &error)[0];
g_assert(pkts_mask == 1);
g_assert(tmp);
pg_brick_destroy(col_west);
pg_brick_destroy(pmtud);
pg_brick_destroy(col_east);
pg_packets_free(pkts, pg_mask_firsts(64));
/* fclose(east_file); */
/* fclose(west_file); */
g_free(pkts);
return;
}
static void inside_to_vxlan(void)
{
struct pg_error *error = NULL;
struct pg_brick *vtep;
struct pg_bench bench;
struct pg_bench_stats stats;
struct pg_brick *inside_nop;
struct ether_addr mac1 = {{0x52,0x54,0x00,0x12,0x34,0x11}};
struct ether_addr mac2 = {{0x52,0x54,0x00,0x12,0x34,0x21}};
struct ether_addr mac3 = {{0x52,0x54,0x00,0x12,0x34,0x31}};
uint32_t len;
pg_bench_init(&bench);
vtep = pg_vtep_new("vtep", 1, 1, EAST_SIDE, inet_addr("192.168.0.1"),
mac3, NO_PACKETS_CLEANUP | NO_COPY |
NO_INNERMAC_CKECK, &error);
g_assert(!error);
inside_nop = pg_nop_new("nop-input", &error);
bench.input_brick = inside_nop;
bench.input_side = WEST_SIDE;
bench.output_brick = vtep;
bench.output_side = EAST_SIDE;
bench.output_poll = false;
bench.max_burst_cnt = 3000000;
bench.count_brick = pg_nop_new("nop-inside", &error);
bench.post_burst_op = remove_vtep_hdr;
g_assert(!error);
pg_brick_link(inside_nop, vtep, &error);
g_assert(!error);
pg_brick_link(vtep, bench.count_brick, &error);
g_assert(!error);
pg_vtep_add_vni(vtep, inside_nop, 0,
inet_addr("224.0.0.5"), &error);
g_assert(!error);
bench.pkts_nb = 64;
bench.pkts_mask = pg_mask_firsts(64);
bench.pkts = pg_packets_create(bench.pkts_mask);
bench.pkts = pg_packets_append_ether(
bench.pkts,
bench.pkts_mask,
&mac1, &mac2,
ETHER_TYPE_IPv4);
len = sizeof(struct ipv4_hdr) + sizeof(struct udp_hdr) + 1356;
pg_packets_append_ipv4(
bench.pkts,
bench.pkts_mask,
0x000000EE, 0x000000CC, len, 17);
bench.pkts = pg_packets_append_udp(
bench.pkts,
bench.pkts_mask,
1000, 2000, 1356);
bench.pkts = pg_packets_append_blank(bench.pkts, bench.pkts_mask, 1356);
//g_assert(pg_bench_run(&bench, &stats, &error));
pg_bench_run(&bench, &stats, &error);
pg_error_print(error);
/* We know that this brick burst all packets. */
stats.pkts_burst = stats.pkts_sent;
printf("[inside] ==> [vtep] ==> [count] (VXLAN side)\n");
g_assert(pg_bench_print(&stats, NULL));
pg_packets_free(bench.pkts, bench.pkts_mask);
pg_brick_destroy(vtep);
pg_brick_destroy(inside_nop);
pg_brick_destroy(bench.count_brick);
}
static void vxlan_to_inside(void)
{
struct pg_error *error = NULL;
struct pg_brick *vtep;
struct pg_bench bench;
struct pg_bench_stats stats;
struct pg_brick *outside_nop;
struct ether_addr mac3 = {{0x52,0x54,0x00,0x12,0x34,0x31}};
struct ether_addr mac4 = {{0x52,0x54,0x00,0x12,0x34,0x41}};
static struct ether_addr mac_vtep = {{0xb0,0xb1,0xb2,0xb3,0xb4,0xb5}};
uint32_t len;
vtep = pg_vtep_new("vtep", 1, 1, WEST_SIDE, 0x000000EE,
mac_vtep,
NO_INNERMAC_CKECK | NO_PACKETS_CLEANUP | NO_COPY,
&error);
g_assert(!error);
pg_bench_init(&bench);
outside_nop = pg_nop_new("nop-outside", &error);
bench.input_brick = outside_nop;
bench.input_side = WEST_SIDE;
bench.output_brick = vtep;
bench.output_side = EAST_SIDE;
bench.output_poll = false;
bench.max_burst_cnt = 1000000;
bench.count_brick = pg_nop_new("nop-bench", &error);
bench.post_burst_op = add_vtep_hdr;
g_assert(!error);
pg_brick_link(outside_nop, vtep, &error);
g_assert(!error);
pg_brick_link(vtep, bench.count_brick, &error);
g_assert(!error);
pg_vtep_add_vni(vtep, bench.count_brick, 1,
inet_addr("224.0.0.1"), &error);
pg_error_print(error);
g_assert(!error);
bench.pkts_nb = 64;
bench.pkts_mask = pg_mask_firsts(64);
bench.pkts = pg_packets_create(bench.pkts_mask);
bench.pkts = pg_packets_append_ether(
bench.pkts,
bench.pkts_mask,
&mac_vtep, &mac_vtep,
ETHER_TYPE_IPv4);
len = sizeof(struct ipv4_hdr) + sizeof(struct udp_hdr) +
sizeof(struct vxlan_hdr) + sizeof(struct ether_hdr) + 1400;
pg_packets_append_ipv4(
bench.pkts,
bench.pkts_mask,
0x000000EE, 0x000000CC, len, 17);
bench.pkts = pg_packets_append_udp(
bench.pkts,
bench.pkts_mask,
1000, 2000, 1400);
pg_packets_append_vxlan(bench.pkts, bench.pkts_mask, 1);
bench.pkts = pg_packets_append_ether(
bench.pkts,
bench.pkts_mask,
&mac3, &mac4,
ETHER_TYPE_IPv4);
bench.pkts = pg_packets_append_blank(bench.pkts, bench.pkts_mask, 1400);
memcpy(vxlan_hdr, rte_pktmbuf_mtod(bench.pkts[0], void *), len - 1400);
vxlan_hdr[sizeof(struct ipv4_hdr) + sizeof(struct udp_hdr) +
sizeof(struct vxlan_hdr) +
sizeof(struct ether_hdr)] = '\0';
g_assert(pg_bench_run(&bench, &stats, &error));
/* We know that this brick burst all packets. */
stats.pkts_burst = stats.pkts_sent;
printf("[outside] ==> [vtep] ==> [count] (no VXLAN side)\n");
g_assert(pg_bench_print(&stats, NULL));
pg_packets_free(bench.pkts, bench.pkts_mask);
pg_brick_destroy(vtep);
pg_brick_destroy(outside_nop);
pg_brick_destroy(bench.count_brick);
}
static void inside_to_vxlan(int argc, char **argv)
{
struct pg_error *error = NULL;
struct pg_brick *vtep;
struct pg_bench bench;
struct pg_bench_stats stats;
struct pg_brick *inside_nop;
struct ether_addr mac1 = {{0x52,0x54,0x00,0x12,0x34,0x11}};
struct ether_addr mac2 = {{0x52,0x54,0x00,0x12,0x34,0x21}};
struct ether_addr mac3 = {{0x52,0x54,0x00,0x12,0x34,0x31}};
uint32_t len;
g_assert(!pg_bench_init(&bench, "vtep inside to vxlan",
argc, argv, &error));
vtep = pg_vtep_new("vtep", 1, 1, EAST_SIDE, inet_addr("192.168.0.1"),
mac3, PG_VTEP_DST_PORT, ALL_OPTI, &error);
g_assert(!error);
inside_nop = pg_nop_new("nop-input", &error);
bench.input_brick = inside_nop;
bench.input_side = WEST_SIDE;
bench.output_brick = vtep;
bench.output_side = EAST_SIDE;
bench.output_poll = false;
bench.max_burst_cnt = 3000000;
bench.count_brick = pg_nop_new("nop-inside", &error);
bench.post_burst_op = remove_vtep_hdr;
g_assert(!error);
pg_brick_link(inside_nop, vtep, &error);
g_assert(!error);
pg_brick_link(vtep, bench.count_brick, &error);
g_assert(!error);
pg_vtep_add_vni(vtep, inside_nop, 0,
inet_addr("224.0.0.5"), &error);
g_assert(!error);
bench.pkts_nb = 64;
bench.pkts_mask = pg_mask_firsts(64);
bench.pkts = pg_packets_create(bench.pkts_mask);
bench.pkts = pg_packets_append_ether(
bench.pkts,
bench.pkts_mask,
&mac1, &mac2,
ETHER_TYPE_IPv4);
len = sizeof(struct ipv4_hdr) + sizeof(struct udp_hdr) + 1356;
pg_packets_append_ipv4(
bench.pkts,
bench.pkts_mask,
0x000000EE, 0x000000CC, len, 17);
bench.pkts = pg_packets_append_udp(
bench.pkts,
bench.pkts_mask,
1000, PG_VTEP_DST_PORT, 1356);
bench.pkts = pg_packets_append_blank(bench.pkts, bench.pkts_mask, 1356);
bench.brick_full_burst = 1;
//g_assert(pg_bench_run(&bench, &stats, &error));
pg_bench_run(&bench, &stats, &error);
g_assert(!pg_error_is_set(&error));
pg_bench_print(&stats);
pg_packets_free(bench.pkts, bench.pkts_mask);
pg_brick_destroy(vtep);
pg_brick_destroy(inside_nop);
pg_brick_destroy(bench.count_brick);
}
static void vxlan_to_inside(int flags, const char *title, int argc, char **argv)
{
struct pg_error *error = NULL;
struct pg_brick *vtep;
struct pg_bench bench;
struct pg_bench_stats stats;
struct pg_brick *outside_nop;
struct ether_addr mac3 = {{0x52,0x54,0x00,0x12,0x34,0x31}};
struct ether_addr mac4 = {{0x52,0x54,0x00,0x12,0x34,0x41}};
static struct ether_addr mac_vtep = {{0xb0,0xb1,0xb2,0xb3,0xb4,0xb5}};
uint32_t len;
vtep = pg_vtep_new("vtep", 1, 1, WEST_SIDE, 0x000000EE,
mac_vtep, PG_VTEP_DST_PORT, flags, &error);
g_assert(!error);
g_assert(!pg_bench_init(&bench, title, argc, argv, &error));
outside_nop = pg_nop_new("nop-outside", &error);
bench.input_brick = outside_nop;
bench.input_side = WEST_SIDE;
bench.output_brick = vtep;
bench.output_side = EAST_SIDE;
bench.output_poll = false;
bench.max_burst_cnt = 1000000;
bench.count_brick = pg_nop_new("nop-bench", &error);
if (flags & NO_COPY)
bench.post_burst_op = add_vtep_hdr;
g_assert(!error);
pg_brick_link(outside_nop, vtep, &error);
g_assert(!error);
pg_brick_link(vtep, bench.count_brick, &error);
g_assert(!error);
pg_vtep_add_vni(vtep, bench.count_brick, 1,
inet_addr("224.0.0.1"), &error);
g_assert(!pg_error_is_set(&error));
if (pg_vtep_add_mac(vtep, 1, &mac4, &error) < 0)
pg_error_print(error);
g_assert(!pg_error_is_set(&error));
pg_vtep_add_mac(vtep, 1, &mac3, &error);
if (pg_vtep_add_mac(vtep, 1, &mac4, &error) < 0)
pg_error_print(error);
g_assert(!pg_error_is_set(&error));
bench.pkts_nb = 64;
bench.pkts_mask = pg_mask_firsts(64);
bench.pkts = pg_packets_create(bench.pkts_mask);
bench.pkts = pg_packets_append_ether(
bench.pkts,
bench.pkts_mask,
&mac_vtep, &mac_vtep,
ETHER_TYPE_IPv4);
bench.brick_full_burst = 1;
len = sizeof(struct ipv4_hdr) + sizeof(struct udp_hdr) +
sizeof(struct vxlan_hdr) + sizeof(struct ether_hdr) + 1400;
pg_packets_append_ipv4(
bench.pkts,
bench.pkts_mask,
0x000000EE, 0x000000CC, len, 17);
bench.pkts = pg_packets_append_udp(
bench.pkts,
bench.pkts_mask,
1000, PG_VTEP_DST_PORT, 1400);
pg_packets_append_vxlan(bench.pkts, bench.pkts_mask, 1);
bench.pkts = pg_packets_append_ether(
bench.pkts,
bench.pkts_mask,
&mac3, &mac4,
ETHER_TYPE_IPv4);
bench.pkts = pg_packets_append_blank(bench.pkts, bench.pkts_mask, 1400);
memcpy(vxlan_hdr, rte_pktmbuf_mtod(bench.pkts[0], void *), len - 1400);
vxlan_hdr[sizeof(struct ipv4_hdr) + sizeof(struct udp_hdr) +
sizeof(struct vxlan_hdr) +
sizeof(struct ether_hdr)] = '\0';
g_assert(pg_bench_run(&bench, &stats, &error) == 0);
pg_bench_print(&stats);
pg_packets_free(bench.pkts, bench.pkts_mask);
pg_brick_destroy(vtep);
pg_brick_destroy(outside_nop);
pg_brick_destroy(bench.count_brick);
}
static void test_brick_flow_west(void)
{
struct pg_brick_config *config = pg_brick_config_new("mybrick", 4, 4);
struct pg_brick *brick1, *brick2, *collect_west, *collect_east;
struct rte_mbuf mbufs[NB_PKTS];
struct rte_mbuf **result_pkts;
struct rte_mbuf *pkts[NB_PKTS];
uint16_t i;
uint64_t pkts_mask;
struct pg_error *error = NULL;
/* prepare the packets to send */
for (i = 0; i < NB_PKTS; i++) {
mbufs[i].udata64 = i;
pkts[i] = &mbufs[i];
}
/* create a chain of a few nop brick with collectors on each sides */
brick1 = pg_brick_new("nop", config, &error);
g_assert(!error);
brick2 = pg_brick_new("nop", config, &error);
g_assert(!error);
collect_west = pg_brick_new("collect", config, &error);
g_assert(!error);
g_assert(collect_west);
collect_east = pg_brick_new("collect", config, &error);
g_assert(!error);
g_assert(collect_east);
pg_brick_link(collect_west, brick1, &error);
g_assert(!error);
pg_brick_link(brick1, brick2, &error);
g_assert(!error);
pg_brick_link(brick2, collect_east, &error);
g_assert(!error);
/* send a pkts to the west from the eastest nope brick */
pg_brick_burst_to_west(brick2, 0, pkts, NB_PKTS,
pg_mask_firsts(NB_PKTS), &error);
g_assert(!error);
/* check pkts counter */
g_assert(pg_brick_pkts_count_get(collect_east, WEST_SIDE) == 0);
g_assert(pg_brick_pkts_count_get(collect_east, EAST_SIDE) == 0);
g_assert(pg_brick_pkts_count_get(collect_west, WEST_SIDE) == 3);
g_assert(pg_brick_pkts_count_get(collect_west, EAST_SIDE) == 0);
g_assert(pg_brick_pkts_count_get(brick1, WEST_SIDE) == 3);
g_assert(pg_brick_pkts_count_get(brick1, EAST_SIDE) == 0);
g_assert(pg_brick_pkts_count_get(brick2, WEST_SIDE) == 3);
g_assert(pg_brick_pkts_count_get(brick2, EAST_SIDE) == 0);
/* check no packet ended on the east */
result_pkts = pg_brick_west_burst_get(collect_east, &pkts_mask, &error);
g_assert(!error);
g_assert(!pkts_mask);
g_assert(!result_pkts);
result_pkts = pg_brick_east_burst_get(collect_east, &pkts_mask, &error);
g_assert(!error);
g_assert(!pkts_mask);
g_assert(!result_pkts);
/* collect pkts on the west */
result_pkts = pg_brick_west_burst_get(collect_west, &pkts_mask, &error);
g_assert(!error);
g_assert(!pkts_mask);
g_assert(!result_pkts);
result_pkts = pg_brick_east_burst_get(collect_west, &pkts_mask, &error);
g_assert(!error);
g_assert(pkts_mask == pg_mask_firsts(NB_PKTS));
g_assert(result_pkts);
for (i = 0; i < NB_PKTS; i++)
g_assert(result_pkts[i]->udata64 == i);
/* break the chain */
pg_brick_unlink(brick1, &error);
g_assert(!error);
pg_brick_unlink(brick2, &error);
g_assert(!error);
pg_brick_unlink(collect_west, &error);
g_assert(!error);
pg_brick_unlink(collect_east, &error);
g_assert(!error);
/* destroy */
pg_brick_decref(brick1, &error);
g_assert(!error);
pg_brick_decref(brick2, &error);
g_assert(!error);
pg_brick_decref(collect_west, &error);
g_assert(!error);
pg_brick_decref(collect_east, &error);
g_assert(!error);
pg_brick_config_free(config);
}
/* this test harness a Linux guest to check that packet are send and received
* by the vhost brick. An ethernet bridge inside the guest will forward packets
* between the two vhost-user virtio interfaces.
*/
static void test_vhost_flow_(int qemu_exit_signal)
{
const char mac_addr_0[18] = "52:54:00:12:34:11";
const char mac_addr_1[18] = "52:54:00:12:34:12";
struct rte_mempool *mbuf_pool = pg_get_mempool();
struct pg_brick *vhost_0, *vhost_1, *collect;
struct rte_mbuf *pkts[PG_MAX_PKTS_BURST];
const char *socket_path_0, *socket_path_1;
struct pg_error *error = NULL;
struct rte_mbuf **result_pkts;
int ret, qemu_pid, i;
uint64_t pkts_mask;
/* start vhost */
ret = pg_vhost_start("/tmp", &error);
g_assert(ret == 0);
g_assert(!error);
/* instanciate brick */
vhost_0 = pg_vhost_new("vhost-0", &error);
g_assert(!error);
g_assert(vhost_0);
vhost_1 = pg_vhost_new("vhost-1", &error);
g_assert(!error);
g_assert(vhost_1);
collect = pg_collect_new("collect", &error);
g_assert(!error);
g_assert(collect);
/* build the graph */
pg_brick_link(collect, vhost_1, &error);
g_assert(!error);
/* spawn first QEMU */
socket_path_0 = pg_vhost_socket_path(vhost_0, &error);
g_assert(!error);
g_assert(socket_path_0);
socket_path_1 = pg_vhost_socket_path(vhost_1, &error);
g_assert(!error);
g_assert(socket_path_1);
qemu_pid = pg_util_spawn_qemu(socket_path_0, socket_path_1,
mac_addr_0, mac_addr_1,
glob_vm_path,
glob_vm_key_path,
glob_hugepages_path, &error);
g_assert(!error);
g_assert(qemu_pid);
/* Prepare VM's bridge. */
# define SSH(c) \
g_assert(pg_util_ssh("localhost", ssh_port_id, glob_vm_key_path, c) == 0)
SSH("brctl addbr br0");
SSH("ifconfig br0 up");
SSH("ifconfig ens4 up");
SSH("ifconfig ens5 up");
SSH("brctl addif br0 ens4");
SSH("brctl addif br0 ens5");
SSH("brctl setfd br0 0");
SSH("brctl stp br0 off");
# undef SSH
ssh_port_id++;
/* prepare packet to send */
for (i = 0; i < NB_PKTS; i++) {
pkts[i] = rte_pktmbuf_alloc(mbuf_pool);
g_assert(pkts[i]);
rte_pktmbuf_append(pkts[i], ETHER_MIN_LEN);
/* set random dst/src mac address so the linux guest bridge
* will not filter them
*/
pg_set_mac_addrs(pkts[i],
"52:54:00:12:34:15", "52:54:00:12:34:16");
/* set size */
pg_set_ether_type(pkts[i], ETHER_MIN_LEN - ETHER_HDR_LEN - 4);
}
/* send packet to the guest via one interface */
pg_brick_burst_to_east(vhost_0, 0, pkts,
pg_mask_firsts(NB_PKTS), &error);
g_assert(!error);
/* let the packet propagate and flow */
for (i = 0; i < 10; i++) {
uint16_t count = 0;
usleep(100000);
pg_brick_poll(vhost_1, &count, &error);
g_assert(!error);
if (count)
break;
}
result_pkts = pg_brick_east_burst_get(collect, &pkts_mask, &error);
g_assert(!error);
g_assert(result_pkts);
g_assert(pg_brick_rx_bytes(vhost_0) == 0);
g_assert(pg_brick_tx_bytes(vhost_0) != 0);
g_assert(pg_brick_rx_bytes(vhost_1) != 0);
g_assert(pg_brick_tx_bytes(vhost_1) == 0);
/* kill QEMU */
pg_util_stop_qemu(qemu_pid, qemu_exit_signal);
/* free result packets */
pg_packets_free(result_pkts, pkts_mask);
/* free sent packet */
for (i = 0; i < NB_PKTS; i++)
rte_pktmbuf_free(pkts[i]);
/* break the graph */
pg_brick_unlink(collect, &error);
g_assert(!error);
/* clean up */
/* pg_brick_decref(vhost_0, &error); */
pg_brick_destroy(vhost_0);
g_assert(!error);
pg_brick_destroy(vhost_1);
/* pg_brick_decref(vhost_1, &error); */
g_assert(!error);
pg_brick_decref(collect, &error);
g_assert(!error);
/* stop vhost */
pg_vhost_stop();
}
void test_benchmark_tap(int argc, char **argv)
{
struct pg_error *error = NULL;
struct pg_brick *tap_enter;
struct pg_brick *tap_exit;
struct pg_bench bench;
struct pg_bench_stats stats;
struct ether_addr mac1 = {{0x52,0x54,0x00,0x12,0x34,0x11}};
struct ether_addr mac2 = {{0x52,0x54,0x00,0x12,0x34,0x21}};
uint32_t len;
tap_enter = pg_tap_new("tap 0", "bench0", &error);
g_assert(tap_enter);
g_assert(!error);
tap_exit = pg_tap_new("tap 1", "bench1", &error);
g_assert(tap_exit);
g_assert(!error);
/* put both tap in a linux bridge */
run_ok("brctl -h &> /dev/null");
run("ip netns del bench &> /dev/null");
run_ok("ip netns add bench");
run_ok("ip netns exec bench ip link set dev lo up");
run_ok("ip link set bench0 up netns bench");
run_ok("ip link set bench1 up netns bench");
run_ok("ip netns exec bench brctl addbr br0");
run_ok("ip netns exec bench brctl addif br0 bench0");
run_ok("ip netns exec bench brctl addif br0 bench1");
run_ok("ip netns exec bench ip link set br0 up");
g_assert(!pg_bench_init(&bench, "tap", argc, argv, &error));
bench.input_brick = tap_enter;
bench.input_side = WEST_SIDE;
bench.output_brick = tap_exit;
bench.output_side = WEST_SIDE;
bench.output_poll = true;
bench.max_burst_cnt = 100000;
bench.count_brick = NULL;
bench.pkts_nb = 64;
bench.pkts_mask = pg_mask_firsts(64);
bench.pkts = pg_packets_create(bench.pkts_mask);
bench.pkts = pg_packets_append_ether(
bench.pkts,
bench.pkts_mask,
&mac1, &mac2,
ETHER_TYPE_IPv4);
len = sizeof(struct ipv4_hdr) + sizeof(struct udp_hdr) + 1400;
pg_packets_append_ipv4(
bench.pkts,
bench.pkts_mask,
0x000000EE, 0x000000CC, len, 17);
bench.pkts = pg_packets_append_udp(
bench.pkts,
bench.pkts_mask,
1000, 2000, 1400);
bench.pkts = pg_packets_append_blank(bench.pkts, bench.pkts_mask, 1400);
g_assert(!pg_bench_run(&bench, &stats, &error));
pg_bench_print(&stats);
pg_packets_free(bench.pkts, bench.pkts_mask);
pg_brick_destroy(tap_enter);
pg_brick_destroy(tap_exit);
run("ip netns del bench");
}
static int packetsgen_poll(struct pg_brick *brick,
uint16_t *pkts_cnt,
struct pg_error **errp)
{
struct pg_packetsgen_state *state;
struct rte_mempool *mp = pg_get_mempool();
struct rte_mbuf **pkts;
struct pg_brick_side *s;
uint64_t pkts_mask;
int ret;
uint16_t i;
state = pg_brick_get_state(brick, struct pg_packetsgen_state);
s = &brick->sides[state->output];
pkts = g_new0(struct rte_mbuf*, state->packets_nb);
for (i = 0; i < state->packets_nb; i++) {
pkts[i] = rte_pktmbuf_clone(state->packets[i], mp);
pkts[i]->udata64 = i;
}
pkts_mask = pg_mask_firsts(state->packets_nb);
*pkts_cnt = state->packets_nb;
ret = pg_brick_side_forward(s, pg_flip_side(state->output),
pkts,
pkts_mask, errp);
pg_packets_free(pkts, pkts_mask);
g_free(pkts);
return ret;
}
