xref: /linux/tools/testing/selftests/bpf/prog_tests/local_kptr_ownership.c (revision 5fc5768c7ca92895ccd1de94dc521e5a55ae7896)

// SPDX-License-Identifier: GPL-2.0
/* Copyright (c) 2026 Meta Platforms, Inc. and affiliates. */

#include <bpf/btf.h>
#include <linux/btf.h>
#include <test_progs.h>

#define SPIN_LOCK 2
#define LIST_HEAD 3
#define LIST_NODE 4
/* Keep in sync with BTF_MAX_OWNERSHIP_DEPTH. */
#define MAX_OWNERSHIP_DEPTH 8

static struct btf *init_btf(void)
{
	struct btf *btf;
	int id;

	btf = btf__new_empty();
	if (!ASSERT_OK_PTR(btf, "btf__new_empty"))
		return NULL;
	id = btf__add_int(btf, "int", 4, BTF_INT_SIGNED);
	if (!ASSERT_EQ(id, 1, "btf__add_int"))
		goto err_out;
	id = btf__add_struct(btf, "bpf_spin_lock", 4);
	if (!ASSERT_EQ(id, SPIN_LOCK, "btf__add_struct bpf_spin_lock"))
		goto err_out;
	id = btf__add_struct(btf, "bpf_list_head", 16);
	if (!ASSERT_EQ(id, LIST_HEAD, "btf__add_struct bpf_list_head"))
		goto err_out;
	id = btf__add_struct(btf, "bpf_list_node", 24);
	if (!ASSERT_EQ(id, LIST_NODE, "btf__add_struct bpf_list_node"))
		goto err_out;
	return btf;

err_out:
	btf__free(btf);
	return NULL;
}

static int add_local_kptr(struct btf *btf, int pointee_id, const char *tag)
{
	int id;

	id = btf__add_type_tag(btf, tag, pointee_id);
	if (!ASSERT_GT(id, 0, "btf__add_type_tag"))
		return id;
	id = btf__add_ptr(btf, id);
	ASSERT_GT(id, 0, "btf__add_ptr");
	return id;
}

static void test_self_cycle(const char *tag, int expected_err)
{
	struct btf *btf;
	int id, err;

	btf = init_btf();
	if (!ASSERT_OK_PTR(btf, "init_btf"))
		return;
	id = add_local_kptr(btf, 7, tag);
	if (id <= 0)
		goto out;
	id = btf__add_struct(btf, "self_cycle", 8);
	if (!ASSERT_EQ(id, 7, "btf__add_struct self_cycle"))
		goto out;
	err = btf__add_field(btf, "next", 6, 0, 0);
	if (!ASSERT_OK(err, "btf__add_field self_cycle::next"))
		goto out;

	err = btf__load_into_kernel(btf);
	ASSERT_EQ(err, expected_err, "check btf");
out:
	btf__free(btf);
}

static void test_aba_cycle(void)
{
	struct btf *btf;
	int id, err;

	btf = init_btf();
	if (!ASSERT_OK_PTR(btf, "init_btf"))
		return;
	id = add_local_kptr(btf, 10, "kptr");
	if (id <= 0)
		goto out;
	id = add_local_kptr(btf, 9, "kptr");
	if (id <= 0)
		goto out;
	id = btf__add_struct(btf, "cycle_a", 8);
	if (!ASSERT_EQ(id, 9, "btf__add_struct cycle_a"))
		goto out;
	err = btf__add_field(btf, "b", 6, 0, 0);
	if (!ASSERT_OK(err, "btf__add_field cycle_a::b"))
		goto out;
	id = btf__add_struct(btf, "cycle_b", 8);
	if (!ASSERT_EQ(id, 10, "btf__add_struct cycle_b"))
		goto out;
	err = btf__add_field(btf, "a", 8, 0, 0);
	if (!ASSERT_OK(err, "btf__add_field cycle_b::a"))
		goto out;

	err = btf__load_into_kernel(btf);
	ASSERT_EQ(err, -ELOOP, "check btf");
out:
	btf__free(btf);
}

static void test_mixed_cycle(void)
{
	struct btf *btf;
	int id, err;

	btf = init_btf();
	if (!ASSERT_OK_PTR(btf, "init_btf"))
		return;
	id = add_local_kptr(btf, 7, "kptr");
	if (id <= 0)
		goto out;
	id = btf__add_struct(btf, "mixed_owner", 20);
	if (!ASSERT_EQ(id, 7, "btf__add_struct mixed_owner"))
		goto out;
	err = btf__add_field(btf, "root", LIST_HEAD, 0, 0);
	if (!ASSERT_OK(err, "btf__add_field mixed_owner::root"))
		goto out;
	err = btf__add_field(btf, "lock", SPIN_LOCK, 128, 0);
	if (!ASSERT_OK(err, "btf__add_field mixed_owner::lock"))
		goto out;
	id = btf__add_decl_tag(btf, "contains:mixed_node:node", 7, 0);
	if (!ASSERT_EQ(id, 8, "btf__add_decl_tag mixed_owner"))
		goto out;
	id = btf__add_struct(btf, "mixed_node", 32);
	if (!ASSERT_EQ(id, 9, "btf__add_struct mixed_node"))
		goto out;
	err = btf__add_field(btf, "node", LIST_NODE, 0, 0);
	if (!ASSERT_OK(err, "btf__add_field mixed_node::node"))
		goto out;
	err = btf__add_field(btf, "owner", 6, 192, 0);
	if (!ASSERT_OK(err, "btf__add_field mixed_node::owner"))
		goto out;

	err = btf__load_into_kernel(btf);
	ASSERT_EQ(err, -ELOOP, "check btf");
out:
	btf__free(btf);
}

static void test_acyclic_depth(int depth, bool child_first, bool shared_suffix, int expected_err)
{
	int ptr_id[MAX_OWNERSHIP_DEPTH + 1];
	int first_struct_id;
	struct btf *btf;
	int id, err, i, n, pointee_id;

	btf = init_btf();
	if (!ASSERT_OK_PTR(btf, "init_btf"))
		return;
	first_struct_id = 5 + 2 * depth;
	for (i = 0; i < depth; i++) {
		if (i == depth - 1)
			pointee_id = first_struct_id + depth;
		else
			pointee_id = first_struct_id + (child_first ? depth - 2 - i : i + 1);
		ptr_id[i] = add_local_kptr(btf, pointee_id, "kptr");
		if (ptr_id[i] <= 0)
			goto out;
	}
	for (n = 0; n < depth; n++) {
		char name[32];
		int offset = 0;

		i = child_first ? depth - 1 - n : n;
		snprintf(name, sizeof(name), "owner_%d", i);
		id = btf__add_struct(btf, name, shared_suffix && !i ? 16 : 8);
		if (!ASSERT_EQ(id, first_struct_id + n, "btf__add_struct owner"))
			goto out;
		if (shared_suffix && !i) {
			/*
			 * Visit the shared suffix through the shorter path before
			 * reaching it again with less remaining depth.
			 */
			err = btf__add_field(btf, "suffix", ptr_id[1], 0, 0);
			if (!ASSERT_OK(err, "btf__add_field owner::suffix"))
				goto out;
			offset = 64;
		}
		err = btf__add_field(btf, "next", ptr_id[i], offset, 0);
		if (!ASSERT_OK(err, "btf__add_field owner::next"))
			goto out;
	}
	id = btf__add_struct(btf, "plain_leaf", 4);
	if (!ASSERT_EQ(id, first_struct_id + depth, "btf__add_struct plain_leaf"))
		goto out;

	err = btf__load_into_kernel(btf);
	ASSERT_EQ(err, expected_err, "check btf");
out:
	btf__free(btf);
}

static void test_graph_depth(bool rbtree, int depth, int expected_err)
{
	int root_type = LIST_HEAD, node_type = LIST_NODE, node_size = 24;
	int id, err, i, lock_off, root_off, size;
	struct btf *btf;

	btf = init_btf();
	if (!ASSERT_OK_PTR(btf, "init_btf"))
		return;
	if (rbtree) {
		root_type = btf__add_struct(btf, "bpf_rb_root", 16);
		if (!ASSERT_GT(root_type, 0, "btf__add_struct bpf_rb_root"))
			goto out;
		node_type = btf__add_struct(btf, "bpf_rb_node", 32);
		if (!ASSERT_GT(node_type, 0, "btf__add_struct bpf_rb_node"))
			goto out;
		node_size = 32;
	}

	for (i = 0; i < depth; i++) {
		char name[32], tag[64];

		lock_off = i ? node_size : 0;
		root_off = lock_off + 8;
		size = i == depth - 1 ? node_size : root_off + 16;
		snprintf(name, sizeof(name), "graph_owner_%d", i);
		id = btf__add_struct(btf, name, size);
		if (!ASSERT_GT(id, 0, "btf__add_struct graph_owner"))
			goto out;
		if (i) {
			err = btf__add_field(btf, "node", node_type, 0, 0);
			if (!ASSERT_OK(err, "btf__add_field graph_owner::node"))
				goto out;
		}
		if (i == depth - 1)
			continue;
		err = btf__add_field(btf, "lock", SPIN_LOCK, lock_off * 8, 0);
		if (!ASSERT_OK(err, "btf__add_field graph_owner::lock"))
			goto out;
		err = btf__add_field(btf, "root", root_type, root_off * 8, 0);
		if (!ASSERT_OK(err, "btf__add_field graph_owner::root"))
			goto out;
		snprintf(tag, sizeof(tag), "contains:graph_owner_%d:node", i + 1);
		err = btf__add_decl_tag(btf, tag, id, i ? 2 : 1);
		if (!ASSERT_GT(err, 0, "btf__add_decl_tag graph_owner"))
			goto out;
	}

	err = btf__load_into_kernel(btf);
	ASSERT_EQ(err, expected_err, "check btf");
out:
	btf__free(btf);
}

void test_local_kptr_ownership(void)
{
	if (test__start_subtest("self_cycle"))
		test_self_cycle("kptr", -ELOOP);
	if (test__start_subtest("untrusted_self_cycle"))
		test_self_cycle("kptr_untrusted", 0);
	if (test__start_subtest("percpu_self_cycle"))
		test_self_cycle("percpu_kptr", -ELOOP);
	if (test__start_subtest("ABA_cycle"))
		test_aba_cycle();
	if (test__start_subtest("mixed_graph_root_cycle"))
		test_mixed_cycle();
	if (test__start_subtest("max_acyclic"))
		test_acyclic_depth(MAX_OWNERSHIP_DEPTH, false, false, 0);
	if (test__start_subtest("too_deep_acyclic"))
		test_acyclic_depth(MAX_OWNERSHIP_DEPTH + 1, false, false, -ELOOP);
	if (test__start_subtest("max_acyclic_child_first"))
		test_acyclic_depth(MAX_OWNERSHIP_DEPTH, true, false, 0);
	if (test__start_subtest("too_deep_acyclic_child_first"))
		test_acyclic_depth(MAX_OWNERSHIP_DEPTH + 1, true, false, -ELOOP);
	if (test__start_subtest("max_acyclic_shared_suffix"))
		test_acyclic_depth(MAX_OWNERSHIP_DEPTH, false, true, 0);
	if (test__start_subtest("too_deep_acyclic_shared_suffix"))
		test_acyclic_depth(MAX_OWNERSHIP_DEPTH + 1, false, true, -ELOOP);
	if (test__start_subtest("list_three_types"))
		test_graph_depth(false, 3, 0);
	if (test__start_subtest("list_four_types"))
		test_graph_depth(false, 4, 0);
	if (test__start_subtest("list_max_depth"))
		test_graph_depth(false, MAX_OWNERSHIP_DEPTH, 0);
	if (test__start_subtest("list_too_deep"))
		test_graph_depth(false, MAX_OWNERSHIP_DEPTH + 1, -ELOOP);
	if (test__start_subtest("rbtree_three_types"))
		test_graph_depth(true, 3, 0);
	if (test__start_subtest("rbtree_four_types"))
		test_graph_depth(true, 4, 0);
	if (test__start_subtest("rbtree_max_depth"))
		test_graph_depth(true, MAX_OWNERSHIP_DEPTH, 0);
	if (test__start_subtest("rbtree_too_deep"))
		test_graph_depth(true, MAX_OWNERSHIP_DEPTH + 1, -ELOOP);
}