Commit 3733bfbb authored by Pedro Tammela's avatar Pedro Tammela Committed by Daniel Borkmann
Browse files

bpf, selftests: Update array map tests for per-cpu batched ops 



Follows the same logic as the hashtable tests.

Signed-off-by: default avatarPedro Tammela <pctammela@mojatatu.com>
Signed-off-by: default avatarDaniel Borkmann <daniel@iogearbox.net>
Link: https://lore.kernel.org/bpf/20210424214510.806627-3-pctammela@mojatatu.com
parent f008d732

tools/testing/selftests/bpf/map_tests/array_map_batch_ops.c

+75 −29
Original line number Diff line number Diff line
@@ -9,10 +9,13 @@ 


#include <test_maps.h>



static int nr_cpus;



static void map_batch_update(int map_fd, __u32 max_entries, int *keys,

			     int *values)

			     __s64 *values, bool is_pcpu)

{

	int i, err;

	int i, j, err;

	int cpu_offset = 0;

	DECLARE_LIBBPF_OPTS(bpf_map_batch_opts, opts,

		.elem_flags = 0,

		.flags = 0,
@@ -20,22 +23,41 @@ static void map_batch_update(int map_fd, __u32 max_entries, int *keys, 


	for (i = 0; i < max_entries; i++) {

		keys[i] = i;

		if (is_pcpu) {

			cpu_offset = i * nr_cpus;

			for (j = 0; j < nr_cpus; j++)

				(values + cpu_offset)[j] = i + 1 + j;

		} else {

			values[i] = i + 1;

		}

	}



	err = bpf_map_update_batch(map_fd, keys, values, &max_entries, &opts);

	CHECK(err, "bpf_map_update_batch()", "error:%s\n", strerror(errno));

}



static void map_batch_verify(int *visited, __u32 max_entries,

			     int *keys, int *values)

static void map_batch_verify(int *visited, __u32 max_entries, int *keys,

			     __s64 *values, bool is_pcpu)

{

	int i;

	int i, j;

	int cpu_offset = 0;



	memset(visited, 0, max_entries * sizeof(*visited));

	for (i = 0; i < max_entries; i++) {

		if (is_pcpu) {

			cpu_offset = i * nr_cpus;

			for (j = 0; j < nr_cpus; j++) {

				__s64 value = (values + cpu_offset)[j];

				CHECK(keys[i] + j + 1 != value,

				      "key/value checking",

				      "error: i %d j %d key %d value %lld\n", i,

				      j, keys[i], value);

			}

		} else {

			CHECK(keys[i] + 1 != values[i], "key/value checking",

		      "error: i %d key %d value %d\n", i, keys[i], values[i]);

			      "error: i %d key %d value %lld\n", i, keys[i],

			      values[i]);

		}

		visited[i] = 1;

	}

	for (i = 0; i < max_entries; i++) {
@@ -44,19 +66,21 @@ static void map_batch_verify(int *visited, __u32 max_entries, 
	}

}



void test_array_map_batch_ops(void)

static void __test_map_lookup_and_update_batch(bool is_pcpu)

{

	struct bpf_create_map_attr xattr = {

		.name = "array_map",

		.map_type = BPF_MAP_TYPE_ARRAY,

		.map_type = is_pcpu ? BPF_MAP_TYPE_PERCPU_ARRAY :

				      BPF_MAP_TYPE_ARRAY,

		.key_size = sizeof(int),

		.value_size = sizeof(int),

		.value_size = sizeof(__s64),

	};

	int map_fd, *keys, *values, *visited;

	int map_fd, *keys, *visited;

	__u32 count, total, total_success;

	const __u32 max_entries = 10;

	__u64 batch = 0;

	int err, step;

	int err, step, value_size;

	void *values;

	DECLARE_LIBBPF_OPTS(bpf_map_batch_opts, opts,

		.elem_flags = 0,

		.flags = 0,
@@ -67,22 +91,23 @@ void test_array_map_batch_ops(void) 
	CHECK(map_fd == -1,

	      "bpf_create_map_xattr()", "error:%s\n", strerror(errno));



	keys = malloc(max_entries * sizeof(int));

	values = malloc(max_entries * sizeof(int));

	visited = malloc(max_entries * sizeof(int));

	value_size = sizeof(__s64);

	if (is_pcpu)

		value_size *= nr_cpus;



	keys = calloc(max_entries, sizeof(*keys));

	values = calloc(max_entries, value_size);

	visited = calloc(max_entries, sizeof(*visited));

	CHECK(!keys || !values || !visited, "malloc()", "error:%s\n",

	      strerror(errno));



	/* populate elements to the map */

	map_batch_update(map_fd, max_entries, keys, values);



	/* test 1: lookup in a loop with various steps. */

	total_success = 0;

	for (step = 1; step < max_entries; step++) {

		map_batch_update(map_fd, max_entries, keys, values);

		map_batch_verify(visited, max_entries, keys, values);

		map_batch_update(map_fd, max_entries, keys, values, is_pcpu);

		map_batch_verify(visited, max_entries, keys, values, is_pcpu);

		memset(keys, 0, max_entries * sizeof(*keys));

		memset(values, 0, max_entries * sizeof(*values));

		memset(values, 0, max_entries * value_size);

		batch = 0;

		total = 0;

		/* iteratively lookup/delete elements with 'step'
@@ -91,9 +116,9 @@ void test_array_map_batch_ops(void) 
		count = step;

		while (true) {

			err = bpf_map_lookup_batch(map_fd,

						total ? &batch : NULL, &batch,

						keys + total,

						values + total,

						   total ? &batch : NULL,

						   &batch, keys + total,

						   values + total * value_size,

						   &count, &opts);



			CHECK((err && errno != ENOENT), "lookup with steps",
@@ -108,7 +133,7 @@ void test_array_map_batch_ops(void) 
		CHECK(total != max_entries, "lookup with steps",

		      "total = %u, max_entries = %u\n", total, max_entries);



		map_batch_verify(visited, max_entries, keys, values);

		map_batch_verify(visited, max_entries, keys, values, is_pcpu);



		total_success++;

	}
@@ -116,9 +141,30 @@ void test_array_map_batch_ops(void) 
	CHECK(total_success == 0, "check total_success",

	      "unexpected failure\n");



	printf("%s:PASS\n", __func__);



	free(keys);

	free(values);

	free(visited);

}



static void array_map_batch_ops(void)

{

	__test_map_lookup_and_update_batch(false);

	printf("test_%s:PASS\n", __func__);

}



static void array_percpu_map_batch_ops(void)

{

	__test_map_lookup_and_update_batch(true);

	printf("test_%s:PASS\n", __func__);

}



void test_array_map_batch_ops(void)

{

	nr_cpus = libbpf_num_possible_cpus();



	CHECK(nr_cpus < 0, "nr_cpus checking",

	      "error: get possible cpus failed");



	array_map_batch_ops();

	array_percpu_map_batch_ops();

}