Commit dfae1eee authored by Yonghong Song's avatar Yonghong Song Committed by Alexei Starovoitov
Browse files

selftests/bpf: Add tests for cgrp_local_storage with local percpu kptr 



Add a non-sleepable cgrp_local_storage test with percpu kptr. The
test does allocation of percpu data, assigning values to percpu
data and retrieval of percpu data. The de-allocation of percpu
data is done when the map is freed.

Signed-off-by: default avatarYonghong Song <yonghong.song@linux.dev>
Link: https://lore.kernel.org/r/20230827152827.2001784-1-yonghong.song@linux.dev


Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parent 46200d6d

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

+40 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

#include <test_progs.h>

#include "percpu_alloc_array.skel.h"

#include "percpu_alloc_cgrp_local_storage.skel.h"



static void test_array(void)

{
@@ -69,10 +70,49 @@ static void test_array_sleepable(void) 
	percpu_alloc_array__destroy(skel);

}



static void test_cgrp_local_storage(void)

{

	struct percpu_alloc_cgrp_local_storage *skel;

	int err, cgroup_fd, prog_fd;

	LIBBPF_OPTS(bpf_test_run_opts, topts);



	cgroup_fd = test__join_cgroup("/percpu_alloc");

	if (!ASSERT_GE(cgroup_fd, 0, "join_cgroup /percpu_alloc"))

		return;



	skel = percpu_alloc_cgrp_local_storage__open();

	if (!ASSERT_OK_PTR(skel, "percpu_alloc_cgrp_local_storage__open"))

		goto close_fd;



	skel->rodata->nr_cpus = libbpf_num_possible_cpus();



	err = percpu_alloc_cgrp_local_storage__load(skel);

	if (!ASSERT_OK(err, "percpu_alloc_cgrp_local_storage__load"))

		goto destroy_skel;



	err = percpu_alloc_cgrp_local_storage__attach(skel);

	if (!ASSERT_OK(err, "percpu_alloc_cgrp_local_storage__attach"))

		goto destroy_skel;



	prog_fd = bpf_program__fd(skel->progs.test_cgrp_local_storage_1);

	err = bpf_prog_test_run_opts(prog_fd, &topts);

	ASSERT_OK(err, "test_run cgrp_local_storage 1-3");

	ASSERT_EQ(topts.retval, 0, "test_run cgrp_local_storage 1-3");

	ASSERT_EQ(skel->bss->cpu0_field_d, 2, "cpu0_field_d");

	ASSERT_EQ(skel->bss->sum_field_c, 1, "sum_field_c");



destroy_skel:

	percpu_alloc_cgrp_local_storage__destroy(skel);

close_fd:

	close(cgroup_fd);

}



void test_percpu_alloc(void)

{

	if (test__start_subtest("array"))

		test_array();

	if (test__start_subtest("array_sleepable"))

		test_array_sleepable();

	if (test__start_subtest("cgrp_local_storage"))

		test_cgrp_local_storage();

}

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

0 → 100644
+105 −0
Original line number Diff line number Diff line 
#include "bpf_experimental.h"



struct val_t {

	long b, c, d;

};



struct elem {

	long sum;

	struct val_t __percpu_kptr *pc;

};



struct {

	__uint(type, BPF_MAP_TYPE_CGRP_STORAGE);

	__uint(map_flags, BPF_F_NO_PREALLOC);

	__type(key, int);

	__type(value, struct elem);

} cgrp SEC(".maps");



const volatile int nr_cpus;



/* Initialize the percpu object */

SEC("fentry/bpf_fentry_test1")

int BPF_PROG(test_cgrp_local_storage_1)

{

	struct task_struct *task;

	struct val_t __percpu_kptr *p;

	struct elem *e;



	task = bpf_get_current_task_btf();

	e = bpf_cgrp_storage_get(&cgrp, task->cgroups->dfl_cgrp, 0,

				 BPF_LOCAL_STORAGE_GET_F_CREATE);

	if (!e)

		return 0;



	p = bpf_percpu_obj_new(struct val_t);

	if (!p)

		return 0;



	p = bpf_kptr_xchg(&e->pc, p);

	if (p)

		bpf_percpu_obj_drop(p);



	return 0;

}



/* Percpu data collection */

SEC("fentry/bpf_fentry_test2")

int BPF_PROG(test_cgrp_local_storage_2)

{

	struct task_struct *task;

	struct val_t __percpu_kptr *p;

	struct val_t *v;

	struct elem *e;



	task = bpf_get_current_task_btf();

	e = bpf_cgrp_storage_get(&cgrp, task->cgroups->dfl_cgrp, 0, 0);

	if (!e)

		return 0;



	p = e->pc;

	if (!p)

		return 0;



	v = bpf_per_cpu_ptr(p, 0);

	if (!v)

		return 0;

	v->c = 1;

	v->d = 2;

	return 0;

}



int cpu0_field_d, sum_field_c;



/* Summarize percpu data collection */

SEC("fentry/bpf_fentry_test3")

int BPF_PROG(test_cgrp_local_storage_3)

{

	struct task_struct *task;

	struct val_t __percpu_kptr *p;

	struct val_t *v;

	struct elem *e;

	int i;



	task = bpf_get_current_task_btf();

	e = bpf_cgrp_storage_get(&cgrp, task->cgroups->dfl_cgrp, 0, 0);

	if (!e)

		return 0;



	p = e->pc;

	if (!p)

		return 0;



	bpf_for(i, 0, nr_cpus) {

		v = bpf_per_cpu_ptr(p, i);

		if (v) {

			if (i == 0)

				cpu0_field_d = v->d;

			sum_field_c += v->c;

		}

	}



	return 0;

}



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