Commit d66b7739 authored by Yan Zhai's avatar Yan Zhai Committed by Alexei Starovoitov
Browse files

selftests: bpf: test batch lookup on array of maps with holes 



Iterating through array of maps may encounter non existing keys. The
batch operation should not fail on when this happens.

Signed-off-by: default avatarYan Zhai <yan@cloudflare.com>
Acked-by: default avatarHou Tao <houtao1@huawei.com>
Link: https://lore.kernel.org/r/9007237b9606dc2ee44465a4447fe46e13f3bea6.1739171594.git.yan@cloudflare.com


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

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

+44 −18
Original line number Diff line number Diff line
@@ -120,11 +120,12 @@ static void validate_fetch_results(int outer_map_fd, 


static void fetch_and_validate(int outer_map_fd,

			       struct bpf_map_batch_opts *opts,

			       __u32 batch_size, bool delete_entries)

			       __u32 batch_size, bool delete_entries,

			       bool has_holes)

{

	__u32 *fetched_keys, *fetched_values, total_fetched = 0;

	__u32 batch_key = 0, fetch_count, step_size;

	int err, max_entries = OUTER_MAP_ENTRIES;

	int err, max_entries = OUTER_MAP_ENTRIES - !!has_holes;

	__u32 *fetched_keys, *fetched_values, total_fetched = 0, i;

	__u32 batch_key = 0, fetch_count, step_size = batch_size;

	__u32 value_size = sizeof(__u32);



	/* Total entries needs to be fetched */
@@ -134,9 +135,8 @@ static void fetch_and_validate(int outer_map_fd, 
	      "Memory allocation failed for fetched_keys or fetched_values",

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



	for (step_size = batch_size;

	     step_size <= max_entries;

	     step_size += batch_size) {

	/* hash map may not always return full batch */

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

		fetch_count = step_size;

		err = delete_entries

		      ? bpf_map_lookup_and_delete_batch(outer_map_fd,
@@ -155,6 +155,7 @@ static void fetch_and_validate(int outer_map_fd, 
		if (err && errno == ENOSPC) {

			/* Fetch again with higher batch size */

			total_fetched = 0;

			step_size += batch_size;

			continue;

		}
@@ -184,18 +185,19 @@ static void fetch_and_validate(int outer_map_fd, 
}



static void _map_in_map_batch_ops(enum bpf_map_type outer_map_type,

				  enum bpf_map_type inner_map_type)

				  enum bpf_map_type inner_map_type,

				  bool has_holes)

{

	__u32 max_entries = OUTER_MAP_ENTRIES - !!has_holes;

	__u32 *outer_map_keys, *inner_map_fds;

	__u32 max_entries = OUTER_MAP_ENTRIES;

	LIBBPF_OPTS(bpf_map_batch_opts, opts);

	__u32 value_size = sizeof(__u32);

	int batch_size[2] = {5, 10};

	__u32 map_index, op_index;

	int outer_map_fd, ret;



	outer_map_keys = calloc(max_entries, value_size);

	inner_map_fds = calloc(max_entries, value_size);

	outer_map_keys = calloc(OUTER_MAP_ENTRIES, value_size);

	inner_map_fds = calloc(OUTER_MAP_ENTRIES, value_size);

	CHECK((!outer_map_keys || !inner_map_fds),

	      "Memory allocation failed for outer_map_keys or inner_map_fds",

	      "error=%s\n", strerror(errno));
@@ -209,6 +211,24 @@ static void _map_in_map_batch_ops(enum bpf_map_type outer_map_type, 
			((outer_map_type == BPF_MAP_TYPE_ARRAY_OF_MAPS)

			 ? 9 : 1000) - map_index;



	/* This condition is only meaningful for array of maps.

	 *

	 * max_entries == OUTER_MAP_ENTRIES - 1 if it is true. Say

	 * max_entries is short for n, then outer_map_keys looks like:

	 *

	 *   [n, n-1, ... 2, 1]

	 *

	 * We change it to

	 *

	 *   [n, n-1, ... 2, 0]

	 *

	 * So it will leave key 1 as a hole. It will serve to test the

	 * correctness when batch on an array: a "non-exist" key might be

	 * actually allocated and returned from key iteration.

	 */

	if (has_holes)

		outer_map_keys[max_entries - 1]--;



	/* batch operation - map_update */

	ret = bpf_map_update_batch(outer_map_fd, outer_map_keys,

				   inner_map_fds, &max_entries, &opts);
@@ -219,15 +239,17 @@ static void _map_in_map_batch_ops(enum bpf_map_type outer_map_type, 
	/* batch operation - map_lookup */

	for (op_index = 0; op_index < 2; ++op_index)

		fetch_and_validate(outer_map_fd, &opts,

				   batch_size[op_index], false);

				   batch_size[op_index], false,

				   has_holes);



	/* batch operation - map_lookup_delete */

	if (outer_map_type == BPF_MAP_TYPE_HASH_OF_MAPS)

		fetch_and_validate(outer_map_fd, &opts,

				   max_entries, true /*delete*/);

				   max_entries, true /*delete*/,

				   has_holes);



	/* close all map fds */

	for (map_index = 0; map_index < max_entries; map_index++)

	for (map_index = 0; map_index < OUTER_MAP_ENTRIES; map_index++)

		close(inner_map_fds[map_index]);

	close(outer_map_fd);
@@ -237,16 +259,20 @@ static void _map_in_map_batch_ops(enum bpf_map_type outer_map_type, 


void test_map_in_map_batch_ops_array(void)

{

	_map_in_map_batch_ops(BPF_MAP_TYPE_ARRAY_OF_MAPS, BPF_MAP_TYPE_ARRAY);

	_map_in_map_batch_ops(BPF_MAP_TYPE_ARRAY_OF_MAPS, BPF_MAP_TYPE_ARRAY, false);

	printf("%s:PASS with inner ARRAY map\n", __func__);

	_map_in_map_batch_ops(BPF_MAP_TYPE_ARRAY_OF_MAPS, BPF_MAP_TYPE_HASH);

	_map_in_map_batch_ops(BPF_MAP_TYPE_ARRAY_OF_MAPS, BPF_MAP_TYPE_HASH, false);

	printf("%s:PASS with inner HASH map\n", __func__);

	_map_in_map_batch_ops(BPF_MAP_TYPE_ARRAY_OF_MAPS, BPF_MAP_TYPE_ARRAY, true);

	printf("%s:PASS with inner ARRAY map with holes\n", __func__);

	_map_in_map_batch_ops(BPF_MAP_TYPE_ARRAY_OF_MAPS, BPF_MAP_TYPE_HASH, true);

	printf("%s:PASS with inner HASH map with holes\n", __func__);

}



void test_map_in_map_batch_ops_hash(void)

{

	_map_in_map_batch_ops(BPF_MAP_TYPE_HASH_OF_MAPS, BPF_MAP_TYPE_ARRAY);

	_map_in_map_batch_ops(BPF_MAP_TYPE_HASH_OF_MAPS, BPF_MAP_TYPE_ARRAY, false);

	printf("%s:PASS with inner ARRAY map\n", __func__);

	_map_in_map_batch_ops(BPF_MAP_TYPE_HASH_OF_MAPS, BPF_MAP_TYPE_HASH);

	_map_in_map_batch_ops(BPF_MAP_TYPE_HASH_OF_MAPS, BPF_MAP_TYPE_HASH, false);

	printf("%s:PASS with inner HASH map\n", __func__);

}