selftests/bpf: Add an iterator selftest for bpf_sk_storage_delete (593f6d41) · Commits · 戴 / test

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

+64 −0

Original line number	Diff line number	Diff line
		@@ -20,6 +20,7 @@
		#include "bpf_iter_bpf_percpu_hash_map.skel.h"
		#include "bpf_iter_bpf_array_map.skel.h"
		#include "bpf_iter_bpf_percpu_array_map.skel.h"
		#include "bpf_iter_bpf_sk_storage_helpers.skel.h"
		#include "bpf_iter_bpf_sk_storage_map.skel.h"
		#include "bpf_iter_test_kern5.skel.h"
		#include "bpf_iter_test_kern6.skel.h"
		@@ -913,6 +914,67 @@ out:
		bpf_iter_bpf_percpu_array_map__destroy(skel);
		}

		/* An iterator program deletes all local storage in a map. */
		static void test_bpf_sk_storage_delete(void)
		{
		DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
		struct bpf_iter_bpf_sk_storage_helpers *skel;
		union bpf_iter_link_info linfo;
		int err, len, map_fd, iter_fd;
		struct bpf_link *link;
		int sock_fd = -1;
		__u32 val = 42;
		char buf[64];

		skel = bpf_iter_bpf_sk_storage_helpers__open_and_load();
		if (CHECK(!skel, "bpf_iter_bpf_sk_storage_helpers__open_and_load",
		"skeleton open_and_load failed\n"))
		return;

		map_fd = bpf_map__fd(skel->maps.sk_stg_map);

		sock_fd = socket(AF_INET6, SOCK_STREAM, 0);
		if (CHECK(sock_fd < 0, "socket", "errno: %d\n", errno))
		goto out;
		err = bpf_map_update_elem(map_fd, &sock_fd, &val, BPF_NOEXIST);
		if (CHECK(err, "map_update", "map_update failed\n"))
		goto out;

		memset(&linfo, 0, sizeof(linfo));
		linfo.map.map_fd = map_fd;
		opts.link_info = &linfo;
		opts.link_info_len = sizeof(linfo);
		link = bpf_program__attach_iter(skel->progs.delete_bpf_sk_storage_map,
		&opts);
		if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))
		goto out;

		iter_fd = bpf_iter_create(bpf_link__fd(link));
		if (CHECK(iter_fd < 0, "create_iter", "create_iter failed\n"))
		goto free_link;

		/* do some tests */
		while ((len = read(iter_fd, buf, sizeof(buf))) > 0)
		;
		if (CHECK(len < 0, "read", "read failed: %s\n", strerror(errno)))
		goto close_iter;

		/* test results */
		err = bpf_map_lookup_elem(map_fd, &sock_fd, &val);
		if (CHECK(!err \|\| errno != ENOENT, "bpf_map_lookup_elem",
		"map value wasn't deleted (err=%d, errno=%d)\n", err, errno))
		goto close_iter;

		close_iter:
		close(iter_fd);
		free_link:
		bpf_link__destroy(link);
		out:
		if (sock_fd >= 0)
		close(sock_fd);
		bpf_iter_bpf_sk_storage_helpers__destroy(skel);
		}

		static void test_bpf_sk_storage_map(void)
		{
		DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
		@@ -1067,6 +1129,8 @@ void test_bpf_iter(void)
		test_bpf_percpu_array_map();
		if (test__start_subtest("bpf_sk_storage_map"))
		test_bpf_sk_storage_map();
		if (test__start_subtest("bpf_sk_storage_delete"))
		test_bpf_sk_storage_delete();
		if (test__start_subtest("rdonly-buf-out-of-bound"))
		test_rdonly_buf_out_of_bound();
		if (test__start_subtest("buf-neg-offset"))

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

0 → 100644

+23 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0
		/* Copyright (c) 2020 Google LLC. */
		#include "bpf_iter.h"
		#include <bpf/bpf_helpers.h>
		#include <bpf/bpf_tracing.h>

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

		struct {
		__uint(type, BPF_MAP_TYPE_SK_STORAGE);
		__uint(map_flags, BPF_F_NO_PREALLOC);
		__type(key, int);
		__type(value, int);
		} sk_stg_map SEC(".maps");

		SEC("iter/bpf_sk_storage_map")
		int delete_bpf_sk_storage_map(struct bpf_iter__bpf_sk_storage_map *ctx)
		{
		if (ctx->sk)
		bpf_sk_storage_delete(&sk_stg_map, ctx->sk);

		return 0;
		}

Admin message