Commit de375f4e authored by Joe Stringer's avatar Joe Stringer Committed by Daniel Borkmann
Browse files

selftests/bpf: Add C tests for reference tracking 



Add some tests that demonstrate and test the balanced lookup/free
nature of socket lookup. Section names that start with "fail" represent
programs that are expected to fail verification; all others should
succeed.

Signed-off-by: default avatarJoe Stringer <joe@wand.net.nz>
Acked-by: default avatarAlexei Starovoitov <ast@kernel.org>
Signed-off-by: default avatarDaniel Borkmann <daniel@iogearbox.net>
parent 29cd77f4

tools/testing/selftests/bpf/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -36,7 +36,7 @@ TEST_GEN_FILES = test_pkt_access.o test_xdp.o test_l4lb.o test_tcp_estats.o test 
	test_get_stack_rawtp.o test_sockmap_kern.o test_sockhash_kern.o \

	test_lwt_seg6local.o sendmsg4_prog.o sendmsg6_prog.o test_lirc_mode2_kern.o \

	get_cgroup_id_kern.o socket_cookie_prog.o test_select_reuseport_kern.o \

	test_skb_cgroup_id_kern.o bpf_flow.o netcnt_prog.o

	test_skb_cgroup_id_kern.o bpf_flow.o netcnt_prog.o test_sk_lookup_kern.o



# Order correspond to 'make run_tests' order

TEST_PROGS := test_kmod.sh \

tools/testing/selftests/bpf/test_progs.c

+38 −0
Original line number Diff line number Diff line
@@ -1698,6 +1698,43 @@ static void test_task_fd_query_tp(void) 
				   "sys_enter_read");

}



static void test_reference_tracking()

{

	const char *file = "./test_sk_lookup_kern.o";

	struct bpf_object *obj;

	struct bpf_program *prog;

	__u32 duration;

	int err = 0;



	obj = bpf_object__open(file);

	if (IS_ERR(obj)) {

		error_cnt++;

		return;

	}



	bpf_object__for_each_program(prog, obj) {

		const char *title;



		/* Ignore .text sections */

		title = bpf_program__title(prog, false);

		if (strstr(title, ".text") != NULL)

			continue;



		bpf_program__set_type(prog, BPF_PROG_TYPE_SCHED_CLS);



		/* Expect verifier failure if test name has 'fail' */

		if (strstr(title, "fail") != NULL) {

			libbpf_set_print(NULL, NULL, NULL);

			err = !bpf_program__load(prog, "GPL", 0);

			libbpf_set_print(printf, printf, NULL);

		} else {

			err = bpf_program__load(prog, "GPL", 0);

		}

		CHECK(err, title, "\n");

	}

	bpf_object__close(obj);

}



int main(void)

{

	jit_enabled = is_jit_enabled();
@@ -1719,6 +1756,7 @@ int main(void) 
	test_get_stack_raw_tp();

	test_task_fd_query_rawtp();

	test_task_fd_query_tp();

	test_reference_tracking();



	printf("Summary: %d PASSED, %d FAILED\n", pass_cnt, error_cnt);

	return error_cnt ? EXIT_FAILURE : EXIT_SUCCESS;

tools/testing/selftests/bpf/test_sk_lookup_kern.c

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

// Copyright (c) 2018 Covalent IO, Inc. http://covalent.io



#include <stddef.h>

#include <stdbool.h>

#include <string.h>

#include <linux/bpf.h>

#include <linux/if_ether.h>

#include <linux/in.h>

#include <linux/ip.h>

#include <linux/ipv6.h>

#include <linux/pkt_cls.h>

#include <linux/tcp.h>

#include <sys/socket.h>

#include "bpf_helpers.h"

#include "bpf_endian.h"



int _version SEC("version") = 1;

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



/* Fill 'tuple' with L3 info, and attempt to find L4. On fail, return NULL. */

static struct bpf_sock_tuple *get_tuple(void *data, __u64 nh_off,

					void *data_end, __u16 eth_proto,

					bool *ipv4)

{

	struct bpf_sock_tuple *result;

	__u8 proto = 0;

	__u64 ihl_len;



	if (eth_proto == bpf_htons(ETH_P_IP)) {

		struct iphdr *iph = (struct iphdr *)(data + nh_off);



		if (iph + 1 > data_end)

			return NULL;

		ihl_len = iph->ihl * 4;

		proto = iph->protocol;

		*ipv4 = true;

		result = (struct bpf_sock_tuple *)&iph->saddr;

	} else if (eth_proto == bpf_htons(ETH_P_IPV6)) {

		struct ipv6hdr *ip6h = (struct ipv6hdr *)(data + nh_off);



		if (ip6h + 1 > data_end)

			return NULL;

		ihl_len = sizeof(*ip6h);

		proto = ip6h->nexthdr;

		*ipv4 = true;

		result = (struct bpf_sock_tuple *)&ip6h->saddr;

	}



	if (data + nh_off + ihl_len > data_end || proto != IPPROTO_TCP)

		return NULL;



	return result;

}



SEC("sk_lookup_success")

int bpf_sk_lookup_test0(struct __sk_buff *skb)

{

	void *data_end = (void *)(long)skb->data_end;

	void *data = (void *)(long)skb->data;

	struct ethhdr *eth = (struct ethhdr *)(data);

	struct bpf_sock_tuple *tuple;

	struct bpf_sock *sk;

	size_t tuple_len;

	bool ipv4;



	if (eth + 1 > data_end)

		return TC_ACT_SHOT;



	tuple = get_tuple(data, sizeof(*eth), data_end, eth->h_proto, &ipv4);

	if (!tuple || tuple + sizeof *tuple > data_end)

		return TC_ACT_SHOT;



	tuple_len = ipv4 ? sizeof(tuple->ipv4) : sizeof(tuple->ipv6);

	sk = bpf_sk_lookup_tcp(skb, tuple, tuple_len, 0, 0);

	if (sk)

		bpf_sk_release(sk);

	return sk ? TC_ACT_OK : TC_ACT_UNSPEC;

}



SEC("sk_lookup_success_simple")

int bpf_sk_lookup_test1(struct __sk_buff *skb)

{

	struct bpf_sock_tuple tuple = {};

	struct bpf_sock *sk;



	sk = bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), 0, 0);

	if (sk)

		bpf_sk_release(sk);

	return 0;

}



SEC("fail_use_after_free")

int bpf_sk_lookup_uaf(struct __sk_buff *skb)

{

	struct bpf_sock_tuple tuple = {};

	struct bpf_sock *sk;

	__u32 family = 0;



	sk = bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), 0, 0);

	if (sk) {

		bpf_sk_release(sk);

		family = sk->family;

	}

	return family;

}



SEC("fail_modify_sk_pointer")

int bpf_sk_lookup_modptr(struct __sk_buff *skb)

{

	struct bpf_sock_tuple tuple = {};

	struct bpf_sock *sk;

	__u32 family;



	sk = bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), 0, 0);

	if (sk) {

		sk += 1;

		bpf_sk_release(sk);

	}

	return 0;

}



SEC("fail_modify_sk_or_null_pointer")

int bpf_sk_lookup_modptr_or_null(struct __sk_buff *skb)

{

	struct bpf_sock_tuple tuple = {};

	struct bpf_sock *sk;

	__u32 family;



	sk = bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), 0, 0);

	sk += 1;

	if (sk)

		bpf_sk_release(sk);

	return 0;

}



SEC("fail_no_release")

int bpf_sk_lookup_test2(struct __sk_buff *skb)

{

	struct bpf_sock_tuple tuple = {};



	bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), 0, 0);

	return 0;

}



SEC("fail_release_twice")

int bpf_sk_lookup_test3(struct __sk_buff *skb)

{

	struct bpf_sock_tuple tuple = {};

	struct bpf_sock *sk;



	sk = bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), 0, 0);

	bpf_sk_release(sk);

	bpf_sk_release(sk);

	return 0;

}



SEC("fail_release_unchecked")

int bpf_sk_lookup_test4(struct __sk_buff *skb)

{

	struct bpf_sock_tuple tuple = {};

	struct bpf_sock *sk;



	sk = bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), 0, 0);

	bpf_sk_release(sk);

	return 0;

}



void lookup_no_release(struct __sk_buff *skb)

{

	struct bpf_sock_tuple tuple = {};

	bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), 0, 0);

}



SEC("fail_no_release_subcall")

int bpf_sk_lookup_test5(struct __sk_buff *skb)

{

	lookup_no_release(skb);

	return 0;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE