map_in_map_batch_ops.c

  1// SPDX-License-Identifier: GPL-2.0
  2
  3#include <stdio.h>
  4#include <errno.h>
  5#include <string.h>
  6#include <unistd.h>
  7
  8#include <bpf/bpf.h>
  9#include <bpf/libbpf.h>
 10
 11#include <test_maps.h>
 12
 13#define OUTER_MAP_ENTRIES 10
 14
 15static __u32 get_map_id_from_fd(int map_fd)
 16{
 17	struct bpf_map_info map_info = {};
 18	uint32_t info_len = sizeof(map_info);
 19	int ret;
 20
 21	ret = bpf_map_get_info_by_fd(map_fd, &map_info, &info_len);
 22	CHECK(ret < 0, "Finding map info failed", "error:%s\n",
 23	      strerror(errno));
 24
 25	return map_info.id;
 26}
 27
 28/* This creates number of OUTER_MAP_ENTRIES maps that will be stored
 29 * in outer map and return the created map_fds
 30 */
 31static void create_inner_maps(enum bpf_map_type map_type,
 32			      __u32 *inner_map_fds)
 33{
 34	int map_fd, map_index, ret;
 35	__u32 map_key = 0, map_id;
 36	char map_name[16];
 37
 38	for (map_index = 0; map_index < OUTER_MAP_ENTRIES; map_index++) {
 39		memset(map_name, 0, sizeof(map_name));
 40		snprintf(map_name, sizeof(map_name), "inner_map_fd_%d", map_index);
 41		map_fd = bpf_map_create(map_type, map_name, sizeof(__u32),
 42					sizeof(__u32), 1, NULL);
 43		CHECK(map_fd < 0,
 44		      "inner bpf_map_create() failed",
 45		      "map_type=(%d) map_name(%s), error:%s\n",
 46		      map_type, map_name, strerror(errno));
 47
 48		/* keep track of the inner map fd as it is required
 49		 * to add records in outer map
 50		 */
 51		inner_map_fds[map_index] = map_fd;
 52
 53		/* Add entry into this created map
 54		 * eg: map1 key = 0, value = map1's map id
 55		 *     map2 key = 0, value = map2's map id
 56		 */
 57		map_id = get_map_id_from_fd(map_fd);
 58		ret = bpf_map_update_elem(map_fd, &map_key, &map_id, 0);
 59		CHECK(ret != 0,
 60		      "bpf_map_update_elem failed",
 61		      "map_type=(%d) map_name(%s), error:%s\n",
 62		      map_type, map_name, strerror(errno));
 63	}
 64}
 65
 66static int create_outer_map(enum bpf_map_type map_type, __u32 inner_map_fd)
 67{
 68	int outer_map_fd;
 69	LIBBPF_OPTS(bpf_map_create_opts, attr);
 70
 71	attr.inner_map_fd = inner_map_fd;
 72	outer_map_fd = bpf_map_create(map_type, "outer_map", sizeof(__u32),
 73				      sizeof(__u32), OUTER_MAP_ENTRIES,
 74				      &attr);
 75	CHECK(outer_map_fd < 0,
 76	      "outer bpf_map_create()",
 77	      "map_type=(%d), error:%s\n",
 78	      map_type, strerror(errno));
 79
 80	return outer_map_fd;
 81}
 82
 83static void validate_fetch_results(int outer_map_fd,
 84				   __u32 *fetched_keys, __u32 *fetched_values,
 85				   __u32 max_entries_fetched)
 86{
 87	__u32 inner_map_key, inner_map_value;
 88	int inner_map_fd, entry, err;
 89	__u32 outer_map_value;
 90
 91	for (entry = 0; entry < max_entries_fetched; ++entry) {
 92		outer_map_value = fetched_values[entry];
 93		inner_map_fd = bpf_map_get_fd_by_id(outer_map_value);
 94		CHECK(inner_map_fd < 0,
 95		      "Failed to get inner map fd",
 96		      "from id(%d), error=%s\n",
 97		      outer_map_value, strerror(errno));
 98		err = bpf_map_get_next_key(inner_map_fd, NULL, &inner_map_key);
 99		CHECK(err != 0,
100		      "Failed to get inner map key",
101		      "error=%s\n", strerror(errno));
102
103		err = bpf_map_lookup_elem(inner_map_fd, &inner_map_key,
104					  &inner_map_value);
105
106		close(inner_map_fd);
107
108		CHECK(err != 0,
109		      "Failed to get inner map value",
110		      "for key(%d), error=%s\n",
111		      inner_map_key, strerror(errno));
112
113		/* Actual value validation */
114		CHECK(outer_map_value != inner_map_value,
115		      "Failed to validate inner map value",
116		      "fetched(%d) and lookedup(%d)!\n",
117		      outer_map_value, inner_map_value);
118	}
119}
120
121static void fetch_and_validate(int outer_map_fd,
122			       struct bpf_map_batch_opts *opts,
123			       __u32 batch_size, bool delete_entries,
124			       bool has_holes)
125{
126	int err, max_entries = OUTER_MAP_ENTRIES - !!has_holes;
127	__u32 *fetched_keys, *fetched_values, total_fetched = 0, i;
128	__u32 batch_key = 0, fetch_count, step_size = batch_size;
129	__u32 value_size = sizeof(__u32);
130
131	/* Total entries needs to be fetched */
132	fetched_keys = calloc(max_entries, value_size);
133	fetched_values = calloc(max_entries, value_size);
134	CHECK((!fetched_keys || !fetched_values),
135	      "Memory allocation failed for fetched_keys or fetched_values",
136	      "error=%s\n", strerror(errno));
137
138	/* hash map may not always return full batch */
139	for (i = 0; i < OUTER_MAP_ENTRIES; i++) {
140		fetch_count = step_size;
141		err = delete_entries
142		      ? bpf_map_lookup_and_delete_batch(outer_map_fd,
143				      total_fetched ? &batch_key : NULL,
144				      &batch_key,
145				      fetched_keys + total_fetched,
146				      fetched_values + total_fetched,
147				      &fetch_count, opts)
148		      : bpf_map_lookup_batch(outer_map_fd,
149				      total_fetched ? &batch_key : NULL,
150				      &batch_key,
151				      fetched_keys + total_fetched,
152				      fetched_values + total_fetched,
153				      &fetch_count, opts);
154
155		if (err && errno == ENOSPC) {
156			/* Fetch again with higher batch size */
157			total_fetched = 0;
158			step_size += batch_size;
159			continue;
160		}
161
162		CHECK((err < 0 && (errno != ENOENT)),
163		      "lookup with steps failed",
164		      "error: %s\n", strerror(errno));
165
166		/* Update the total fetched number */
167		total_fetched += fetch_count;
168		if (err)
169			break;
170	}
171
172	CHECK((total_fetched != max_entries),
173	      "Unable to fetch expected entries !",
174	      "total_fetched(%d) and max_entries(%d) error: (%d):%s\n",
175	      total_fetched, max_entries, errno, strerror(errno));
176
177	/* validate the fetched entries */
178	validate_fetch_results(outer_map_fd, fetched_keys,
179			       fetched_values, total_fetched);
180	printf("batch_op(%s) is successful with batch_size(%d)\n",
181	       delete_entries ? "LOOKUP_AND_DELETE" : "LOOKUP", batch_size);
182
183	free(fetched_keys);
184	free(fetched_values);
185}
186
187static void _map_in_map_batch_ops(enum bpf_map_type outer_map_type,
188				  enum bpf_map_type inner_map_type,
189				  bool has_holes)
190{
191	__u32 max_entries = OUTER_MAP_ENTRIES - !!has_holes;
192	__u32 *outer_map_keys, *inner_map_fds;
193	LIBBPF_OPTS(bpf_map_batch_opts, opts);
194	__u32 value_size = sizeof(__u32);
195	int batch_size[2] = {5, 10};
196	__u32 map_index, op_index;
197	int outer_map_fd, ret;
198
199	outer_map_keys = calloc(OUTER_MAP_ENTRIES, value_size);
200	inner_map_fds = calloc(OUTER_MAP_ENTRIES, value_size);
201	CHECK((!outer_map_keys || !inner_map_fds),
202	      "Memory allocation failed for outer_map_keys or inner_map_fds",
203	      "error=%s\n", strerror(errno));
204
205	create_inner_maps(inner_map_type, inner_map_fds);
206
207	outer_map_fd = create_outer_map(outer_map_type, *inner_map_fds);
208	/* create outer map keys */
209	for (map_index = 0; map_index < max_entries; map_index++)
210		outer_map_keys[map_index] =
211			((outer_map_type == BPF_MAP_TYPE_ARRAY_OF_MAPS)
212			 ? 9 : 1000) - map_index;
213
214	/* This condition is only meaningful for array of maps.
215	 *
216	 * max_entries == OUTER_MAP_ENTRIES - 1 if it is true. Say
217	 * max_entries is short for n, then outer_map_keys looks like:
218	 *
219	 *   [n, n-1, ... 2, 1]
220	 *
221	 * We change it to
222	 *
223	 *   [n, n-1, ... 2, 0]
224	 *
225	 * So it will leave key 1 as a hole. It will serve to test the
226	 * correctness when batch on an array: a "non-exist" key might be
227	 * actually allocated and returned from key iteration.
228	 */
229	if (has_holes)
230		outer_map_keys[max_entries - 1]--;
231
232	/* batch operation - map_update */
233	ret = bpf_map_update_batch(outer_map_fd, outer_map_keys,
234				   inner_map_fds, &max_entries, &opts);
235	CHECK(ret != 0,
236	      "Failed to update the outer map batch ops",
237	      "error=%s\n", strerror(errno));
238
239	/* batch operation - map_lookup */
240	for (op_index = 0; op_index < 2; ++op_index)
241		fetch_and_validate(outer_map_fd, &opts,
242				   batch_size[op_index], false,
243				   has_holes);
244
245	/* batch operation - map_lookup_delete */
246	if (outer_map_type == BPF_MAP_TYPE_HASH_OF_MAPS)
247		fetch_and_validate(outer_map_fd, &opts,
248				   max_entries, true /*delete*/,
249				   has_holes);
250
251	/* close all map fds */
252	for (map_index = 0; map_index < OUTER_MAP_ENTRIES; map_index++)
253		close(inner_map_fds[map_index]);
254	close(outer_map_fd);
255
256	free(inner_map_fds);
257	free(outer_map_keys);
258}
259
260void test_map_in_map_batch_ops_array(void)
261{
262	_map_in_map_batch_ops(BPF_MAP_TYPE_ARRAY_OF_MAPS, BPF_MAP_TYPE_ARRAY, false);
263	printf("%s:PASS with inner ARRAY map\n", __func__);
264	_map_in_map_batch_ops(BPF_MAP_TYPE_ARRAY_OF_MAPS, BPF_MAP_TYPE_HASH, false);
265	printf("%s:PASS with inner HASH map\n", __func__);
266	_map_in_map_batch_ops(BPF_MAP_TYPE_ARRAY_OF_MAPS, BPF_MAP_TYPE_ARRAY, true);
267	printf("%s:PASS with inner ARRAY map with holes\n", __func__);
268	_map_in_map_batch_ops(BPF_MAP_TYPE_ARRAY_OF_MAPS, BPF_MAP_TYPE_HASH, true);
269	printf("%s:PASS with inner HASH map with holes\n", __func__);
270}
271
272void test_map_in_map_batch_ops_hash(void)
273{
274	_map_in_map_batch_ops(BPF_MAP_TYPE_HASH_OF_MAPS, BPF_MAP_TYPE_ARRAY, false);
275	printf("%s:PASS with inner ARRAY map\n", __func__);
276	_map_in_map_batch_ops(BPF_MAP_TYPE_HASH_OF_MAPS, BPF_MAP_TYPE_HASH, false);
277	printf("%s:PASS with inner HASH map\n", __func__);
278}