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: Joe Stringer <joe@wand.net.nz>
Acked-by: Alexei Starovoitov <ast@kernel.org>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>

diff --git a/tools/testing/selftests/bpf/Makefile b/tools/testing/selftests/bpf/Makefile
index f802de5..1381ab8 100644 (file)
--- a/tools/testing/selftests/bpf/Makefile
+++ b/tools/testing/selftests/bpf/Makefile
@@ -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 \

diff --git a/tools/testing/selftests/bpf/test_progs.c b/tools/testing/selftests/bpf/test_progs.c
index 63a6718..e8becca 100644 (file)
--- a/tools/testing/selftests/bpf/test_progs.c
+++ b/tools/testing/selftests/bpf/test_progs.c
@@ -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;

diff --git a/tools/testing/selftests/bpf/test_sk_lookup_kern.c b/tools/testing/selftests/bpf/test_sk_lookup_kern.c
new file mode 100644 (file)
index 0000000..b745bdc
--- /dev/null
+++ b/tools/testing/selftests/bpf/test_sk_lookup_kern.c
@@ -0,0 +1,180 @@
+/* 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;
+}