Commit 11c70163 authored by Amery Hung's avatar Amery Hung Committed by Martin KaFai Lau
Browse files

selftests/bpf: Add a basic fifo qdisc test 



This selftest includes a bare minimum fifo qdisc, which simply enqueues
sk_buffs into the back of a bpf list and dequeues from the front of the
list.

Signed-off-by: default avatarAmery Hung <amery.hung@bytedance.com>
Signed-off-by: default avatarMartin KaFai Lau <martin.lau@kernel.org>
Acked-by: default avatarToke Høiland-Jørgensen <toke@redhat.com>
Link: https://patch.msgid.link/20250409214606.2000194-9-ameryhung@gmail.com
parent 4b15121d

tools/testing/selftests/bpf/config

+1 −0
Original line number Diff line number Diff line
@@ -71,6 +71,7 @@ CONFIG_NET_IPGRE=y 
CONFIG_NET_IPGRE_DEMUX=y

CONFIG_NET_IPIP=y

CONFIG_NET_MPLS_GSO=y

CONFIG_NET_SCH_BPF=y

CONFIG_NET_SCH_FQ=y

CONFIG_NET_SCH_INGRESS=y

CONFIG_NET_SCHED=y

tools/testing/selftests/bpf/prog_tests/bpf_qdisc.c

0 → 100644
+81 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0



#include <linux/pkt_sched.h>

#include <linux/rtnetlink.h>

#include <test_progs.h>



#include "network_helpers.h"

#include "bpf_qdisc_fifo.skel.h"



#define LO_IFINDEX 1



static const unsigned int total_bytes = 10 * 1024 * 1024;



static void do_test(char *qdisc)

{

	DECLARE_LIBBPF_OPTS(bpf_tc_hook, hook, .ifindex = LO_IFINDEX,

			    .attach_point = BPF_TC_QDISC,

			    .parent = TC_H_ROOT,

			    .handle = 0x8000000,

			    .qdisc = qdisc);

	int srv_fd = -1, cli_fd = -1;

	int err;



	err = bpf_tc_hook_create(&hook);

	if (!ASSERT_OK(err, "attach qdisc"))

		return;



	srv_fd = start_server(AF_INET6, SOCK_STREAM, NULL, 0, 0);

	if (!ASSERT_OK_FD(srv_fd, "start server"))

		goto done;



	cli_fd = connect_to_fd(srv_fd, 0);

	if (!ASSERT_OK_FD(cli_fd, "connect to client"))

		goto done;



	err = send_recv_data(srv_fd, cli_fd, total_bytes);

	ASSERT_OK(err, "send_recv_data");



done:

	if (srv_fd != -1)

		close(srv_fd);

	if (cli_fd != -1)

		close(cli_fd);



	bpf_tc_hook_destroy(&hook);

}



static void test_fifo(void)

{

	struct bpf_qdisc_fifo *fifo_skel;

	struct bpf_link *link;



	fifo_skel = bpf_qdisc_fifo__open_and_load();

	if (!ASSERT_OK_PTR(fifo_skel, "bpf_qdisc_fifo__open_and_load"))

		return;



	link = bpf_map__attach_struct_ops(fifo_skel->maps.fifo);

	if (!ASSERT_OK_PTR(link, "bpf_map__attach_struct_ops")) {

		bpf_qdisc_fifo__destroy(fifo_skel);

		return;

	}



	do_test("bpf_fifo");



	bpf_link__destroy(link);

	bpf_qdisc_fifo__destroy(fifo_skel);

}



void test_bpf_qdisc(void)

{

	struct netns_obj *netns;



	netns = netns_new("bpf_qdisc_ns", true);

	if (!ASSERT_OK_PTR(netns, "netns_new"))

		return;



	if (test__start_subtest("fifo"))

		test_fifo();



	netns_free(netns);

}

tools/testing/selftests/bpf/progs/bpf_qdisc_common.h

0 → 100644
+31 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */



#ifndef _BPF_QDISC_COMMON_H

#define _BPF_QDISC_COMMON_H



#define NET_XMIT_SUCCESS        0x00

#define NET_XMIT_DROP           0x01    /* skb dropped                  */

#define NET_XMIT_CN             0x02    /* congestion notification      */



#define TC_PRIO_CONTROL  7

#define TC_PRIO_MAX      15



#define private(name) SEC(".data." #name) __hidden __attribute__((aligned(8)))



u32 bpf_skb_get_hash(struct sk_buff *p) __ksym;

void bpf_kfree_skb(struct sk_buff *p) __ksym;

void bpf_qdisc_skb_drop(struct sk_buff *p, struct bpf_sk_buff_ptr *to_free) __ksym;

void bpf_qdisc_watchdog_schedule(struct Qdisc *sch, u64 expire, u64 delta_ns) __ksym;

void bpf_qdisc_bstats_update(struct Qdisc *sch, const struct sk_buff *skb) __ksym;



static struct qdisc_skb_cb *qdisc_skb_cb(const struct sk_buff *skb)

{

	return (struct qdisc_skb_cb *)skb->cb;

}



static inline unsigned int qdisc_pkt_len(const struct sk_buff *skb)

{

	return qdisc_skb_cb(skb)->pkt_len;

}



#endif

tools/testing/selftests/bpf/progs/bpf_qdisc_fifo.c

0 → 100644
+117 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0



#include <vmlinux.h>

#include "bpf_experimental.h"

#include "bpf_qdisc_common.h"



char _license[] SEC("license") = "GPL";



struct skb_node {

	struct sk_buff __kptr * skb;

	struct bpf_list_node node;

};



private(A) struct bpf_spin_lock q_fifo_lock;

private(A) struct bpf_list_head q_fifo __contains(skb_node, node);



SEC("struct_ops/bpf_fifo_enqueue")

int BPF_PROG(bpf_fifo_enqueue, struct sk_buff *skb, struct Qdisc *sch,

	     struct bpf_sk_buff_ptr *to_free)

{

	struct skb_node *skbn;

	u32 pkt_len;



	if (sch->q.qlen == sch->limit)

		goto drop;



	skbn = bpf_obj_new(typeof(*skbn));

	if (!skbn)

		goto drop;



	pkt_len = qdisc_pkt_len(skb);



	sch->q.qlen++;

	skb = bpf_kptr_xchg(&skbn->skb, skb);

	if (skb)

		bpf_qdisc_skb_drop(skb, to_free);



	bpf_spin_lock(&q_fifo_lock);

	bpf_list_push_back(&q_fifo, &skbn->node);

	bpf_spin_unlock(&q_fifo_lock);



	sch->qstats.backlog += pkt_len;

	return NET_XMIT_SUCCESS;

drop:

	bpf_qdisc_skb_drop(skb, to_free);

	return NET_XMIT_DROP;

}



SEC("struct_ops/bpf_fifo_dequeue")

struct sk_buff *BPF_PROG(bpf_fifo_dequeue, struct Qdisc *sch)

{

	struct bpf_list_node *node;

	struct sk_buff *skb = NULL;

	struct skb_node *skbn;



	bpf_spin_lock(&q_fifo_lock);

	node = bpf_list_pop_front(&q_fifo);

	bpf_spin_unlock(&q_fifo_lock);

	if (!node)

		return NULL;



	skbn = container_of(node, struct skb_node, node);

	skb = bpf_kptr_xchg(&skbn->skb, skb);

	bpf_obj_drop(skbn);

	if (!skb)

		return NULL;



	sch->qstats.backlog -= qdisc_pkt_len(skb);

	bpf_qdisc_bstats_update(sch, skb);

	sch->q.qlen--;



	return skb;

}



SEC("struct_ops/bpf_fifo_init")

int BPF_PROG(bpf_fifo_init, struct Qdisc *sch, struct nlattr *opt,

	     struct netlink_ext_ack *extack)

{

	sch->limit = 1000;

	return 0;

}



SEC("struct_ops/bpf_fifo_reset")

void BPF_PROG(bpf_fifo_reset, struct Qdisc *sch)

{

	struct bpf_list_node *node;

	struct skb_node *skbn;

	int i;



	bpf_for(i, 0, sch->q.qlen) {

		struct sk_buff *skb = NULL;



		bpf_spin_lock(&q_fifo_lock);

		node = bpf_list_pop_front(&q_fifo);

		bpf_spin_unlock(&q_fifo_lock);



		if (!node)

			break;



		skbn = container_of(node, struct skb_node, node);

		skb = bpf_kptr_xchg(&skbn->skb, skb);

		if (skb)

			bpf_kfree_skb(skb);

		bpf_obj_drop(skbn);

	}

	sch->q.qlen = 0;

}



SEC(".struct_ops")

struct Qdisc_ops fifo = {

	.enqueue   = (void *)bpf_fifo_enqueue,

	.dequeue   = (void *)bpf_fifo_dequeue,

	.init      = (void *)bpf_fifo_init,

	.reset     = (void *)bpf_fifo_reset,

	.id        = "bpf_fifo",

};