Commit 35ec1cdf authored by Martin KaFai Lau's avatar Martin KaFai Lau

Merge branch 'monitor network traffic for flaky test cases'

Kui-Feng Lee says:

====================
Capture packets in the background for flaky test cases related to
network features.

We have some flaky test cases that are difficult to debug without
knowing what the traffic looks like. Capturing packets, the CI log and
packet files may help developers to fix these flaky test cases.

This patch set monitors a few test cases. Recently, they have been
showing flaky behavior.

    lo      In  IPv4 127.0.0.1:40265 > 127.0.0.1:55907: TCP, length 68, SYN
    lo      In  IPv4 127.0.0.1:55907 > 127.0.0.1:40265: TCP, length 60, SYN, ACK
    lo      In  IPv4 127.0.0.1:40265 > 127.0.0.1:55907: TCP, length 60, ACK
    lo      In  IPv4 127.0.0.1:55907 > 127.0.0.1:40265: TCP, length 52, ACK
    lo      In  IPv4 127.0.0.1:40265 > 127.0.0.1:55907: TCP, length 52, FIN, ACK
    lo      In  IPv4 127.0.0.1:55907 > 127.0.0.1:40265: TCP, length 52, RST, ACK
    Packet file: packets-2173-86-select_reuseport:sockhash_IPv4_TCP_LOOPBACK_test_detach_bpf-test.log
    #280/87 select_reuseport/sockhash IPv4/TCP LOOPBACK test_detach_bpf:OK

The above block is the log of a test case. It shows every packet of a
connection. The captured packets are stored in the file called
packets-2173-86-select_reuseport:sockhash_IPv4_TCP_LOOPBACK_test_detach_bpf-test.log.

We have a set of high-level helpers and a test_progs option to
simplify the process of enabling the traffic monitor. netns_new() and
netns_free() are helpers used to create and delete namespaces while
also enabling the traffic monitor for the namespace based on the
patterns provided by the "-m" option of test_progs. The value of the
"-m" option is a list of patterns used to enable the traffic monitor
for a group of tests or a file containing patterns. CI can utilize
this option to enable monitoring.

traffic_monitor_start() and traffic_monitor_stop() are low-level
functions to start monitoring explicitly. You can have more controls,
however high-level helpers are preferred.

The following block is an example that monitors the network traffic of
a test case in a network namespace.

    struct netns_obj *netns;

    ...
    netns = netns_new("test", true);
    if (!ASSERT_TRUE(netns, "netns_new"))
        goto err;

    ... test ...

    netns_free(netns);

netns_new() will create a network namespace named "test" and bring up
"lo" in the namespace. By passing "true" as the 2nd argument, it will
set the network namespace of the current process to
"test".netns_free() will destroy the namespace, and the process will
leave the "test" namespace if the struct netns_obj returned by
netns_new() is created with "true" as the 2nd argument. If the name of
the test matches the patterns given by the "-m" option, the traffic
monitor will be enabled for the "test" namespace as well.

The packet files are located in the directory "/tmp/tmon_pcap/". The
directory is intended to be compressed as a file so that developers
can download it from the CI.

This feature is enabled only if libpcap is available when building
selftests.
---

Changes from v7:

 - Remove ":" with "__" from the file names of traffic logs. ':' would
   cause an error of the upload-artifact action of github.

 - Move remove_netns() to avoid a forward declaration.

Changes from v6:

 - Remove unnecessary memcpy for addresses.

 - Make packet messages similar to what tcpdump prints.

 - Check return value of inet_ntop().

 - Remove duplicated errno in messages.

 - Print arphdr_type for not handled packets.

 - Set dev "lo" in make_netns().

 - Avoid stacking netns by moving traffic_monitor_start() to earlier
   position.

 - Remove the word "packet" from packet messages.

 - Replace pipe with eventfd (wake_fd) to synchronize background threads.

Changes from v5:

 - Remove "-m" completely if traffic monitor is not enabled.

Changes from v4:

 - Use pkg-config to detect libpcap, and enable traffic monitor if
   there is libpcap.

 - Move traffic monitor functions back to network_helper.c, and pass
   extra parameters to traffic_monitor_start().

 - Use flockfile() & funlockfile() to avoid log interleaving.

 - Show "In", "Out", "M" ... for captured packets.

 - Print a warning message if the user pass a "-m" when libpcap is not
   available.

 - Bring up dev lo in netns_new().

Changes from v3:

 - Rebase to the latest tip of bpf-next/for-next

 - Change verb back to C string.

Changes from v2:

 - Include pcap header files conditionally.

 - Move the implementation of traffic monitor to test_progs.c.

 - Include test name and namespace as a part of names of packet files.

 - Parse and print ICMP(v4|v6) packets.

 - Add netns_new() and netns_free() to create and delete network
   namespaces.

   - Make tc_redirect, sockmap_listen and select_reuseport test in a
     network namespace.

 - Add the "-m" option to test_progs to enable traffic monitor for the
   tests matching the pattern. CI may use this option to enable
   monitoring for a given set of tests.

Changes from v1:

 - Move to calling libpcap directly to capture packets in a background
   thread.

 - Print parsed packet information for TCP and UDP packets.

v1: https://lore.kernel.org/all/20240713055552.2482367-5-thinker.li@gmail.com/
v2: https://lore.kernel.org/all/20240723182439.1434795-1-thinker.li@gmail.com/
v3: https://lore.kernel.org/all/20240730002745.1484204-1-thinker.li@gmail.com/
v4: https://lore.kernel.org/all/20240731193140.758210-1-thinker.li@gmail.com/
v5: https://lore.kernel.org/all/20240806221243.1806879-1-thinker.li@gmail.com/
v6: https://lore.kernel.org/all/20240807183149.764711-1-thinker.li@gmail.com/
v7: https://lore.kernel.org/all/20240810023534.2458227-2-thinker.li@gmail.com/
====================
Signed-off-by: default avatarMartin KaFai Lau <martin.lau@kernel.org>
parents b97ce547 69354085
......@@ -41,6 +41,10 @@ CFLAGS += -g $(OPT_FLAGS) -rdynamic \
LDFLAGS += $(SAN_LDFLAGS)
LDLIBS += $(LIBELF_LIBS) -lz -lrt -lpthread
LDLIBS += $(shell $(PKG_CONFIG) --libs libpcap 2>/dev/null)
CFLAGS += $(shell $(PKG_CONFIG) --cflags libpcap 2>/dev/null)
CFLAGS += $(shell $(PKG_CONFIG) --exists libpcap 2>/dev/null && echo "-DTRAFFIC_MONITOR=1")
# The following tests perform type punning and they may break strict
# aliasing rules, which are exploited by both GCC and clang by default
# while optimizing. This can lead to broken programs.
......
......@@ -11,17 +11,31 @@
#include <arpa/inet.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/un.h>
#include <sys/eventfd.h>
#include <linux/err.h>
#include <linux/in.h>
#include <linux/in6.h>
#include <linux/limits.h>
#include <linux/ip.h>
#include <linux/udp.h>
#include <netinet/tcp.h>
#include <net/if.h>
#include "bpf_util.h"
#include "network_helpers.h"
#include "test_progs.h"
#ifdef TRAFFIC_MONITOR
/* Prevent pcap.h from including pcap/bpf.h and causing conflicts */
#define PCAP_DONT_INCLUDE_PCAP_BPF_H 1
#include <pcap/pcap.h>
#include <pcap/dlt.h>
#endif
#ifndef IPPROTO_MPTCP
#define IPPROTO_MPTCP 262
#endif
......@@ -432,6 +446,52 @@ char *ping_command(int family)
return "ping";
}
int remove_netns(const char *name)
{
char *cmd;
int r;
r = asprintf(&cmd, "ip netns del %s >/dev/null 2>&1", name);
if (r < 0) {
log_err("Failed to malloc cmd");
return -1;
}
r = system(cmd);
free(cmd);
return r;
}
int make_netns(const char *name)
{
char *cmd;
int r;
r = asprintf(&cmd, "ip netns add %s", name);
if (r < 0) {
log_err("Failed to malloc cmd");
return -1;
}
r = system(cmd);
free(cmd);
if (r)
return r;
r = asprintf(&cmd, "ip -n %s link set lo up", name);
if (r < 0) {
log_err("Failed to malloc cmd for setting up lo");
remove_netns(name);
return -1;
}
r = system(cmd);
free(cmd);
return r;
}
struct nstoken {
int orig_netns_fd;
};
......@@ -660,3 +720,443 @@ int send_recv_data(int lfd, int fd, uint32_t total_bytes)
return err;
}
#ifdef TRAFFIC_MONITOR
struct tmonitor_ctx {
pcap_t *pcap;
pcap_dumper_t *dumper;
pthread_t thread;
int wake_fd;
volatile bool done;
char pkt_fname[PATH_MAX];
int pcap_fd;
};
/* Is this packet captured with a Ethernet protocol type? */
static bool is_ethernet(const u_char *packet)
{
u16 arphdr_type;
memcpy(&arphdr_type, packet + 8, 2);
arphdr_type = ntohs(arphdr_type);
/* Except the following cases, the protocol type contains the
* Ethernet protocol type for the packet.
*
* https://www.tcpdump.org/linktypes/LINKTYPE_LINUX_SLL2.html
*/
switch (arphdr_type) {
case 770: /* ARPHRD_FRAD */
case 778: /* ARPHDR_IPGRE */
case 803: /* ARPHRD_IEEE80211_RADIOTAP */
printf("Packet captured: arphdr_type=%d\n", arphdr_type);
return false;
}
return true;
}
static const char * const pkt_types[] = {
"In",
"B", /* Broadcast */
"M", /* Multicast */
"C", /* Captured with the promiscuous mode */
"Out",
};
static const char *pkt_type_str(u16 pkt_type)
{
if (pkt_type < ARRAY_SIZE(pkt_types))
return pkt_types[pkt_type];
return "Unknown";
}
/* Show the information of the transport layer in the packet */
static void show_transport(const u_char *packet, u16 len, u32 ifindex,
const char *src_addr, const char *dst_addr,
u16 proto, bool ipv6, u8 pkt_type)
{
char *ifname, _ifname[IF_NAMESIZE];
const char *transport_str;
u16 src_port, dst_port;
struct udphdr *udp;
struct tcphdr *tcp;
ifname = if_indextoname(ifindex, _ifname);
if (!ifname) {
snprintf(_ifname, sizeof(_ifname), "unknown(%d)", ifindex);
ifname = _ifname;
}
if (proto == IPPROTO_UDP) {
udp = (struct udphdr *)packet;
src_port = ntohs(udp->source);
dst_port = ntohs(udp->dest);
transport_str = "UDP";
} else if (proto == IPPROTO_TCP) {
tcp = (struct tcphdr *)packet;
src_port = ntohs(tcp->source);
dst_port = ntohs(tcp->dest);
transport_str = "TCP";
} else if (proto == IPPROTO_ICMP) {
printf("%-7s %-3s IPv4 %s > %s: ICMP, length %d, type %d, code %d\n",
ifname, pkt_type_str(pkt_type), src_addr, dst_addr, len,
packet[0], packet[1]);
return;
} else if (proto == IPPROTO_ICMPV6) {
printf("%-7s %-3s IPv6 %s > %s: ICMPv6, length %d, type %d, code %d\n",
ifname, pkt_type_str(pkt_type), src_addr, dst_addr, len,
packet[0], packet[1]);
return;
} else {
printf("%-7s %-3s %s %s > %s: protocol %d\n",
ifname, pkt_type_str(pkt_type), ipv6 ? "IPv6" : "IPv4",
src_addr, dst_addr, proto);
return;
}
/* TCP or UDP*/
flockfile(stdout);
if (ipv6)
printf("%-7s %-3s IPv6 %s.%d > %s.%d: %s, length %d",
ifname, pkt_type_str(pkt_type), src_addr, src_port,
dst_addr, dst_port, transport_str, len);
else
printf("%-7s %-3s IPv4 %s:%d > %s:%d: %s, length %d",
ifname, pkt_type_str(pkt_type), src_addr, src_port,
dst_addr, dst_port, transport_str, len);
if (proto == IPPROTO_TCP) {
if (tcp->fin)
printf(", FIN");
if (tcp->syn)
printf(", SYN");
if (tcp->rst)
printf(", RST");
if (tcp->ack)
printf(", ACK");
}
printf("\n");
funlockfile(stdout);
}
static void show_ipv6_packet(const u_char *packet, u32 ifindex, u8 pkt_type)
{
char src_buf[INET6_ADDRSTRLEN], dst_buf[INET6_ADDRSTRLEN];
struct ipv6hdr *pkt = (struct ipv6hdr *)packet;
const char *src, *dst;
u_char proto;
src = inet_ntop(AF_INET6, &pkt->saddr, src_buf, sizeof(src_buf));
if (!src)
src = "<invalid>";
dst = inet_ntop(AF_INET6, &pkt->daddr, dst_buf, sizeof(dst_buf));
if (!dst)
dst = "<invalid>";
proto = pkt->nexthdr;
show_transport(packet + sizeof(struct ipv6hdr),
ntohs(pkt->payload_len),
ifindex, src, dst, proto, true, pkt_type);
}
static void show_ipv4_packet(const u_char *packet, u32 ifindex, u8 pkt_type)
{
char src_buf[INET_ADDRSTRLEN], dst_buf[INET_ADDRSTRLEN];
struct iphdr *pkt = (struct iphdr *)packet;
const char *src, *dst;
u_char proto;
src = inet_ntop(AF_INET, &pkt->saddr, src_buf, sizeof(src_buf));
if (!src)
src = "<invalid>";
dst = inet_ntop(AF_INET, &pkt->daddr, dst_buf, sizeof(dst_buf));
if (!dst)
dst = "<invalid>";
proto = pkt->protocol;
show_transport(packet + sizeof(struct iphdr),
ntohs(pkt->tot_len),
ifindex, src, dst, proto, false, pkt_type);
}
static void *traffic_monitor_thread(void *arg)
{
char *ifname, _ifname[IF_NAMESIZE];
const u_char *packet, *payload;
struct tmonitor_ctx *ctx = arg;
pcap_dumper_t *dumper = ctx->dumper;
int fd = ctx->pcap_fd, nfds, r;
int wake_fd = ctx->wake_fd;
struct pcap_pkthdr header;
pcap_t *pcap = ctx->pcap;
u32 ifindex;
fd_set fds;
u16 proto;
u8 ptype;
nfds = (fd > wake_fd ? fd : wake_fd) + 1;
FD_ZERO(&fds);
while (!ctx->done) {
FD_SET(fd, &fds);
FD_SET(wake_fd, &fds);
r = select(nfds, &fds, NULL, NULL, NULL);
if (!r)
continue;
if (r < 0) {
if (errno == EINTR)
continue;
log_err("Fail to select on pcap fd and wake fd");
break;
}
/* This instance of pcap is non-blocking */
packet = pcap_next(pcap, &header);
if (!packet)
continue;
/* According to the man page of pcap_dump(), first argument
* is the pcap_dumper_t pointer even it's argument type is
* u_char *.
*/
pcap_dump((u_char *)dumper, &header, packet);
/* Not sure what other types of packets look like. Here, we
* parse only Ethernet and compatible packets.
*/
if (!is_ethernet(packet))
continue;
/* Skip SLL2 header
* https://www.tcpdump.org/linktypes/LINKTYPE_LINUX_SLL2.html
*
* Although the document doesn't mention that, the payload
* doesn't include the Ethernet header. The payload starts
* from the first byte of the network layer header.
*/
payload = packet + 20;
memcpy(&proto, packet, 2);
proto = ntohs(proto);
memcpy(&ifindex, packet + 4, 4);
ifindex = ntohl(ifindex);
ptype = packet[10];
if (proto == ETH_P_IPV6) {
show_ipv6_packet(payload, ifindex, ptype);
} else if (proto == ETH_P_IP) {
show_ipv4_packet(payload, ifindex, ptype);
} else {
ifname = if_indextoname(ifindex, _ifname);
if (!ifname) {
snprintf(_ifname, sizeof(_ifname), "unknown(%d)", ifindex);
ifname = _ifname;
}
printf("%-7s %-3s Unknown network protocol type 0x%x\n",
ifname, pkt_type_str(ptype), proto);
}
}
return NULL;
}
/* Prepare the pcap handle to capture packets.
*
* This pcap is non-blocking and immediate mode is enabled to receive
* captured packets as soon as possible. The snaplen is set to 1024 bytes
* to limit the size of captured content. The format of the link-layer
* header is set to DLT_LINUX_SLL2 to enable handling various link-layer
* technologies.
*/
static pcap_t *traffic_monitor_prepare_pcap(void)
{
char errbuf[PCAP_ERRBUF_SIZE];
pcap_t *pcap;
int r;
/* Listen on all NICs in the namespace */
pcap = pcap_create("any", errbuf);
if (!pcap) {
log_err("Failed to open pcap: %s", errbuf);
return NULL;
}
/* Limit the size of the packet (first N bytes) */
r = pcap_set_snaplen(pcap, 1024);
if (r) {
log_err("Failed to set snaplen: %s", pcap_geterr(pcap));
goto error;
}
/* To receive packets as fast as possible */
r = pcap_set_immediate_mode(pcap, 1);
if (r) {
log_err("Failed to set immediate mode: %s", pcap_geterr(pcap));
goto error;
}
r = pcap_setnonblock(pcap, 1, errbuf);
if (r) {
log_err("Failed to set nonblock: %s", errbuf);
goto error;
}
r = pcap_activate(pcap);
if (r) {
log_err("Failed to activate pcap: %s", pcap_geterr(pcap));
goto error;
}
/* Determine the format of the link-layer header */
r = pcap_set_datalink(pcap, DLT_LINUX_SLL2);
if (r) {
log_err("Failed to set datalink: %s", pcap_geterr(pcap));
goto error;
}
return pcap;
error:
pcap_close(pcap);
return NULL;
}
static void encode_test_name(char *buf, size_t len, const char *test_name, const char *subtest_name)
{
char *p;
if (subtest_name)
snprintf(buf, len, "%s__%s", test_name, subtest_name);
else
snprintf(buf, len, "%s", test_name);
while ((p = strchr(buf, '/')))
*p = '_';
while ((p = strchr(buf, ' ')))
*p = '_';
}
#define PCAP_DIR "/tmp/tmon_pcap"
/* Start to monitor the network traffic in the given network namespace.
*
* netns: the name of the network namespace to monitor. If NULL, the
* current network namespace is monitored.
* test_name: the name of the running test.
* subtest_name: the name of the running subtest if there is. It should be
* NULL if it is not a subtest.
*
* This function will start a thread to capture packets going through NICs
* in the give network namespace.
*/
struct tmonitor_ctx *traffic_monitor_start(const char *netns, const char *test_name,
const char *subtest_name)
{
struct nstoken *nstoken = NULL;
struct tmonitor_ctx *ctx;
char test_name_buf[64];
static int tmon_seq;
int r;
if (netns) {
nstoken = open_netns(netns);
if (!nstoken)
return NULL;
}
ctx = malloc(sizeof(*ctx));
if (!ctx) {
log_err("Failed to malloc ctx");
goto fail_ctx;
}
memset(ctx, 0, sizeof(*ctx));
encode_test_name(test_name_buf, sizeof(test_name_buf), test_name, subtest_name);
snprintf(ctx->pkt_fname, sizeof(ctx->pkt_fname),
PCAP_DIR "/packets-%d-%d-%s-%s.log", getpid(), tmon_seq++,
test_name_buf, netns ? netns : "unknown");
r = mkdir(PCAP_DIR, 0755);
if (r && errno != EEXIST) {
log_err("Failed to create " PCAP_DIR);
goto fail_pcap;
}
ctx->pcap = traffic_monitor_prepare_pcap();
if (!ctx->pcap)
goto fail_pcap;
ctx->pcap_fd = pcap_get_selectable_fd(ctx->pcap);
if (ctx->pcap_fd < 0) {
log_err("Failed to get pcap fd");
goto fail_dumper;
}
/* Create a packet file */
ctx->dumper = pcap_dump_open(ctx->pcap, ctx->pkt_fname);
if (!ctx->dumper) {
log_err("Failed to open pcap dump: %s", ctx->pkt_fname);
goto fail_dumper;
}
/* Create an eventfd to wake up the monitor thread */
ctx->wake_fd = eventfd(0, 0);
if (ctx->wake_fd < 0) {
log_err("Failed to create eventfd");
goto fail_eventfd;
}
r = pthread_create(&ctx->thread, NULL, traffic_monitor_thread, ctx);
if (r) {
log_err("Failed to create thread");
goto fail;
}
close_netns(nstoken);
return ctx;
fail:
close(ctx->wake_fd);
fail_eventfd:
pcap_dump_close(ctx->dumper);
unlink(ctx->pkt_fname);
fail_dumper:
pcap_close(ctx->pcap);
fail_pcap:
free(ctx);
fail_ctx:
close_netns(nstoken);
return NULL;
}
static void traffic_monitor_release(struct tmonitor_ctx *ctx)
{
pcap_close(ctx->pcap);
pcap_dump_close(ctx->dumper);
close(ctx->wake_fd);
free(ctx);
}
/* Stop the network traffic monitor.
*
* ctx: the context returned by traffic_monitor_start()
*/
void traffic_monitor_stop(struct tmonitor_ctx *ctx)
{
__u64 w = 1;
if (!ctx)
return;
/* Stop the monitor thread */
ctx->done = true;
/* Wake up the background thread. */
write(ctx->wake_fd, &w, sizeof(w));
pthread_join(ctx->thread, NULL);
printf("Packet file: %s\n", strrchr(ctx->pkt_fname, '/') + 1);
traffic_monitor_release(ctx);
}
#endif /* TRAFFIC_MONITOR */
......@@ -93,6 +93,8 @@ struct nstoken;
struct nstoken *open_netns(const char *name);
void close_netns(struct nstoken *token);
int send_recv_data(int lfd, int fd, uint32_t total_bytes);
int make_netns(const char *name);
int remove_netns(const char *name);
static __u16 csum_fold(__u32 csum)
{
......@@ -136,4 +138,22 @@ static inline __sum16 csum_ipv6_magic(const struct in6_addr *saddr,
return csum_fold((__u32)s);
}
struct tmonitor_ctx;
#ifdef TRAFFIC_MONITOR
struct tmonitor_ctx *traffic_monitor_start(const char *netns, const char *test_name,
const char *subtest_name);
void traffic_monitor_stop(struct tmonitor_ctx *ctx);
#else
static inline struct tmonitor_ctx *traffic_monitor_start(const char *netns, const char *test_name,
const char *subtest_name)
{
return NULL;
}
static inline void traffic_monitor_stop(struct tmonitor_ctx *ctx)
{
}
#endif
#endif
......@@ -37,9 +37,7 @@ static int sk_fds[REUSEPORT_ARRAY_SIZE];
static int reuseport_array = -1, outer_map = -1;
static enum bpf_map_type inner_map_type;
static int select_by_skb_data_prog;
static int saved_tcp_syncookie = -1;
static struct bpf_object *obj;
static int saved_tcp_fo = -1;
static __u32 index_zero;
static int epfd;
......@@ -193,14 +191,6 @@ static int write_int_sysctl(const char *sysctl, int v)
return 0;
}
static void restore_sysctls(void)
{
if (saved_tcp_fo != -1)
write_int_sysctl(TCP_FO_SYSCTL, saved_tcp_fo);
if (saved_tcp_syncookie != -1)
write_int_sysctl(TCP_SYNCOOKIE_SYSCTL, saved_tcp_syncookie);
}
static int enable_fastopen(void)
{
int fo;
......@@ -793,6 +783,7 @@ static void test_config(int sotype, sa_family_t family, bool inany)
TEST_INIT(test_pass_on_err),
TEST_INIT(test_detach_bpf),
};
struct netns_obj *netns;
char s[MAX_TEST_NAME];
const struct test *t;
......@@ -808,9 +799,21 @@ static void test_config(int sotype, sa_family_t family, bool inany)
if (!test__start_subtest(s))
continue;
netns = netns_new("select_reuseport", true);
if (!ASSERT_OK_PTR(netns, "netns_new"))
continue;
if (CHECK_FAIL(enable_fastopen()))
goto out;
if (CHECK_FAIL(disable_syncookie()))
goto out;
setup_per_test(sotype, family, inany, t->no_inner_map);
t->fn(sotype, family);
cleanup_per_test(t->no_inner_map);
out:
netns_free(netns);
}
}
......@@ -850,21 +853,7 @@ void test_map_type(enum bpf_map_type mt)
void serial_test_select_reuseport(void)
{
saved_tcp_fo = read_int_sysctl(TCP_FO_SYSCTL);
if (saved_tcp_fo < 0)
goto out;
saved_tcp_syncookie = read_int_sysctl(TCP_SYNCOOKIE_SYSCTL);
if (saved_tcp_syncookie < 0)
goto out;
if (enable_fastopen())
goto out;
if (disable_syncookie())
goto out;
test_map_type(BPF_MAP_TYPE_REUSEPORT_SOCKARRAY);
test_map_type(BPF_MAP_TYPE_SOCKMAP);
test_map_type(BPF_MAP_TYPE_SOCKHASH);
out:
restore_sysctls();
}
......@@ -1925,6 +1925,7 @@ static void test_udp_unix_redir(struct test_sockmap_listen *skel, struct bpf_map
int family)
{
const char *family_name, *map_name;
struct netns_obj *netns;
char s[MAX_TEST_NAME];
family_name = family_str(family);
......@@ -1932,8 +1933,15 @@ static void test_udp_unix_redir(struct test_sockmap_listen *skel, struct bpf_map
snprintf(s, sizeof(s), "%s %s %s", map_name, family_name, __func__);
if (!test__start_subtest(s))
return;
netns = netns_new("sockmap_listen", true);
if (!ASSERT_OK_PTR(netns, "netns_new"))
return;
inet_unix_skb_redir_to_connected(skel, map, family);
unix_inet_skb_redir_to_connected(skel, map, family);
netns_free(netns);
}
static void run_tests(struct test_sockmap_listen *skel, struct bpf_map *map,
......
......@@ -68,6 +68,7 @@
__FILE__, __LINE__, strerror(errno), ##__VA_ARGS__)
static const char * const namespaces[] = {NS_SRC, NS_FWD, NS_DST, NULL};
static struct netns_obj *netns_objs[3];
static int write_file(const char *path, const char *newval)
{
......@@ -87,27 +88,41 @@ static int write_file(const char *path, const char *newval)
static int netns_setup_namespaces(const char *verb)
{
struct netns_obj **ns_obj = netns_objs;
const char * const *ns = namespaces;
char cmd[128];
while (*ns) {
snprintf(cmd, sizeof(cmd), "ip netns %s %s", verb, *ns);
if (!ASSERT_OK(system(cmd), cmd))
if (strcmp(verb, "add") == 0) {
*ns_obj = netns_new(*ns, false);
if (!ASSERT_OK_PTR(*ns_obj, "netns_new"))
return -1;
} else {
if (!ASSERT_OK_PTR(*ns_obj, "netns_obj is NULL"))
return -1;
netns_free(*ns_obj);
*ns_obj = NULL;
}
ns++;
ns_obj++;
}
return 0;
}
static void netns_setup_namespaces_nofail(const char *verb)
{
struct netns_obj **ns_obj = netns_objs;
const char * const *ns = namespaces;
char cmd[128];
while (*ns) {
snprintf(cmd, sizeof(cmd), "ip netns %s %s > /dev/null 2>&1", verb, *ns);
system(cmd);
if (strcmp(verb, "add") == 0) {
*ns_obj = netns_new(*ns, false);
} else {
if (*ns_obj)
netns_free(*ns_obj);
*ns_obj = NULL;
}
ns++;
ns_obj++;
}
}
......
......@@ -18,6 +18,8 @@
#include <bpf/btf.h>
#include "json_writer.h"
#include "network_helpers.h"
#ifdef __GLIBC__
#include <execinfo.h> /* backtrace */
#endif
......@@ -155,6 +157,7 @@ struct prog_test_def {
void (*run_serial_test)(void);
bool should_run;
bool need_cgroup_cleanup;
bool should_tmon;
};
/* Override C runtime library's usleep() implementation to ensure nanosleep()
......@@ -192,39 +195,39 @@ static bool should_run(struct test_selector *sel, int num, const char *name)
return num < sel->num_set_len && sel->num_set[num];
}
static bool should_run_subtest(struct test_selector *sel,
struct test_selector *subtest_sel,
int subtest_num,
static bool match_subtest(struct test_filter_set *filter,
const char *test_name,
const char *subtest_name)
{
int i, j;
for (i = 0; i < sel->blacklist.cnt; i++) {
if (glob_match(test_name, sel->blacklist.tests[i].name)) {
if (!sel->blacklist.tests[i].subtest_cnt)
return false;
for (i = 0; i < filter->cnt; i++) {
if (glob_match(test_name, filter->tests[i].name)) {
if (!filter->tests[i].subtest_cnt)
return true;
for (j = 0; j < sel->blacklist.tests[i].subtest_cnt; j++) {
for (j = 0; j < filter->tests[i].subtest_cnt; j++) {
if (glob_match(subtest_name,
sel->blacklist.tests[i].subtests[j]))
return false;
filter->tests[i].subtests[j]))
return true;
}
}
}
for (i = 0; i < sel->whitelist.cnt; i++) {
if (glob_match(test_name, sel->whitelist.tests[i].name)) {
if (!sel->whitelist.tests[i].subtest_cnt)
return true;
return false;
}
for (j = 0; j < sel->whitelist.tests[i].subtest_cnt; j++) {
if (glob_match(subtest_name,
sel->whitelist.tests[i].subtests[j]))
static bool should_run_subtest(struct test_selector *sel,
struct test_selector *subtest_sel,
int subtest_num,
const char *test_name,
const char *subtest_name)
{
if (match_subtest(&sel->blacklist, test_name, subtest_name))
return false;
if (match_subtest(&sel->whitelist, test_name, subtest_name))
return true;
}
}
}
if (!sel->whitelist.cnt && !subtest_sel->num_set)
return true;
......@@ -232,6 +235,19 @@ static bool should_run_subtest(struct test_selector *sel,
return subtest_num < subtest_sel->num_set_len && subtest_sel->num_set[subtest_num];
}
static bool should_tmon(struct test_selector *sel, const char *name)
{
int i;
for (i = 0; i < sel->whitelist.cnt; i++) {
if (glob_match(name, sel->whitelist.tests[i].name) &&
!sel->whitelist.tests[i].subtest_cnt)
return true;
}
return false;
}
static char *test_result(bool failed, bool skipped)
{
return failed ? "FAIL" : (skipped ? "SKIP" : "OK");
......@@ -488,6 +504,10 @@ bool test__start_subtest(const char *subtest_name)
return false;
}
subtest_state->should_tmon = match_subtest(&env.tmon_selector.whitelist,
test->test_name,
subtest_name);
env.subtest_state = subtest_state;
stdio_hijack_init(&subtest_state->log_buf, &subtest_state->log_cnt);
......@@ -624,6 +644,92 @@ int compare_stack_ips(int smap_fd, int amap_fd, int stack_trace_len)
return err;
}
struct netns_obj {
char *nsname;
struct tmonitor_ctx *tmon;
struct nstoken *nstoken;
};
/* Create a new network namespace with the given name.
*
* Create a new network namespace and set the network namespace of the
* current process to the new network namespace if the argument "open" is
* true. This function should be paired with netns_free() to release the
* resource and delete the network namespace.
*
* It also implements the functionality of the option "-m" by starting
* traffic monitor on the background to capture the packets in this network
* namespace if the current test or subtest matching the pattern.
*
* nsname: the name of the network namespace to create.
* open: open the network namespace if true.
*
* Return: the network namespace object on success, NULL on failure.
*/
struct netns_obj *netns_new(const char *nsname, bool open)
{
struct netns_obj *netns_obj = malloc(sizeof(*netns_obj));
const char *test_name, *subtest_name;
int r;
if (!netns_obj)
return NULL;
memset(netns_obj, 0, sizeof(*netns_obj));
netns_obj->nsname = strdup(nsname);
if (!netns_obj->nsname)
goto fail;
/* Create the network namespace */
r = make_netns(nsname);
if (r)
goto fail;
/* Start traffic monitor */
if (env.test->should_tmon ||
(env.subtest_state && env.subtest_state->should_tmon)) {
test_name = env.test->test_name;
subtest_name = env.subtest_state ? env.subtest_state->name : NULL;
netns_obj->tmon = traffic_monitor_start(nsname, test_name, subtest_name);
if (!netns_obj->tmon) {
fprintf(stderr, "Failed to start traffic monitor for %s\n", nsname);
goto fail;
}
} else {
netns_obj->tmon = NULL;
}
if (open) {
netns_obj->nstoken = open_netns(nsname);
if (!netns_obj->nstoken)
goto fail;
}
return netns_obj;
fail:
traffic_monitor_stop(netns_obj->tmon);
remove_netns(nsname);
free(netns_obj->nsname);
free(netns_obj);
return NULL;
}
/* Delete the network namespace.
*
* This function should be paired with netns_new() to delete the namespace
* created by netns_new().
*/
void netns_free(struct netns_obj *netns_obj)
{
if (!netns_obj)
return;
traffic_monitor_stop(netns_obj->tmon);
close_netns(netns_obj->nstoken);
remove_netns(netns_obj->nsname);
free(netns_obj->nsname);
free(netns_obj);
}
/* extern declarations for test funcs */
#define DEFINE_TEST(name) \
extern void test_##name(void) __weak; \
......@@ -667,7 +773,8 @@ enum ARG_KEYS {
ARG_TEST_NAME_GLOB_DENYLIST = 'd',
ARG_NUM_WORKERS = 'j',
ARG_DEBUG = -1,
ARG_JSON_SUMMARY = 'J'
ARG_JSON_SUMMARY = 'J',
ARG_TRAFFIC_MONITOR = 'm',
};
static const struct argp_option opts[] = {
......@@ -694,6 +801,10 @@ static const struct argp_option opts[] = {
{ "debug", ARG_DEBUG, NULL, 0,
"print extra debug information for test_progs." },
{ "json-summary", ARG_JSON_SUMMARY, "FILE", 0, "Write report in json format to this file."},
#ifdef TRAFFIC_MONITOR
{ "traffic-monitor", ARG_TRAFFIC_MONITOR, "NAMES", 0,
"Monitor network traffic of tests with name matching the pattern (supports '*' wildcard)." },
#endif
{},
};
......@@ -905,6 +1016,18 @@ static error_t parse_arg(int key, char *arg, struct argp_state *state)
break;
case ARGP_KEY_END:
break;
#ifdef TRAFFIC_MONITOR
case ARG_TRAFFIC_MONITOR:
if (arg[0] == '@')
err = parse_test_list_file(arg + 1,
&env->tmon_selector.whitelist,
true);
else
err = parse_test_list(arg,
&env->tmon_selector.whitelist,
true);
break;
#endif
default:
return ARGP_ERR_UNKNOWN;
}
......@@ -1736,6 +1859,8 @@ int main(int argc, char **argv)
test->test_num, test->test_name, test->test_name, test->test_name);
exit(EXIT_ERR_SETUP_INFRA);
}
if (test->should_run)
test->should_tmon = should_tmon(&env.tmon_selector, test->test_name);
}
/* ignore workers if we are just listing */
......@@ -1820,6 +1945,7 @@ int main(int argc, char **argv)
free_test_selector(&env.test_selector);
free_test_selector(&env.subtest_selector);
free_test_selector(&env.tmon_selector);
free_test_states();
if (env.succ_cnt + env.fail_cnt + env.skip_cnt == 0)
......
......@@ -74,6 +74,7 @@ struct subtest_state {
int error_cnt;
bool skipped;
bool filtered;
bool should_tmon;
FILE *stdout_saved;
};
......@@ -98,6 +99,7 @@ struct test_state {
struct test_env {
struct test_selector test_selector;
struct test_selector subtest_selector;
struct test_selector tmon_selector;
bool verifier_stats;
bool debug;
enum verbosity verbosity;
......@@ -428,6 +430,10 @@ int write_sysctl(const char *sysctl, const char *value);
int get_bpf_max_tramp_links_from(struct btf *btf);
int get_bpf_max_tramp_links(void);
struct netns_obj;
struct netns_obj *netns_new(const char *name, bool open);
void netns_free(struct netns_obj *netns);
#ifdef __x86_64__
#define SYS_NANOSLEEP_KPROBE_NAME "__x64_sys_nanosleep"
#elif defined(__s390x__)
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment