From: Yonghong Song <[email protected]>
Tested bpf_map_lookup_and_delete_batch() and bpf_map_update_batch()
functionality.
$ ./test_maps
...
test_hmap_lookup_and_delete_batch:PASS
test_pcpu_hmap_lookup_and_delete_batch:PASS
...
Signed-off-by: Yonghong Song <[email protected]>
Signed-off-by: Brian Vazquez <[email protected]>
---
.../map_lookup_and_delete_batch_htab.c | 257 ++++++++++++++++++
1 file changed, 257 insertions(+)
create mode 100644 tools/testing/selftests/bpf/map_tests/map_lookup_and_delete_batch_htab.c
diff --git a/tools/testing/selftests/bpf/map_tests/map_lookup_and_delete_batch_htab.c b/tools/testing/selftests/bpf/map_tests/map_lookup_and_delete_batch_htab.c
new file mode 100644
index 0000000000000..93e024cb85c60
--- /dev/null
+++ b/tools/testing/selftests/bpf/map_tests/map_lookup_and_delete_batch_htab.c
@@ -0,0 +1,257 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2019 Facebook */
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+
+#include <bpf/bpf.h>
+#include <bpf/libbpf.h>
+
+#include <bpf_util.h>
+#include <test_maps.h>
+
+static void map_batch_update(int map_fd, __u32 max_entries, int *keys,
+ void *values, bool is_pcpu)
+{
+ typedef BPF_DECLARE_PERCPU(int, value);
+ int i, j, err;
+ value *v;
+
+ if (is_pcpu)
+ v = (value *)values;
+
+ for (i = 0; i < max_entries; i++) {
+ keys[i] = i + 1;
+ if (is_pcpu)
+ for (j = 0; j < bpf_num_possible_cpus(); j++)
+ bpf_percpu(v[i], j) = i + 2 + j;
+ else
+ ((int *)values)[i] = i + 2;
+ }
+
+ err = bpf_map_update_batch(map_fd, keys, values, &max_entries, 0, 0);
+ CHECK(err, "bpf_map_update_batch()", "error:%s\n", strerror(errno));
+}
+
+static void map_batch_verify(int *visited, __u32 max_entries,
+ int *keys, void *values, bool is_pcpu)
+{
+ typedef BPF_DECLARE_PERCPU(int, value);
+ value *v;
+ int i, j;
+
+ if (is_pcpu)
+ v = (value *)values;
+
+ memset(visited, 0, max_entries * sizeof(*visited));
+ for (i = 0; i < max_entries; i++) {
+
+ if (is_pcpu) {
+ for (j = 0; j < bpf_num_possible_cpus(); j++) {
+ CHECK(keys[i] + 1 + j != bpf_percpu(v[i], j),
+ "key/value checking",
+ "error: i %d j %d key %d value %d\n",
+ i, j, keys[i], bpf_percpu(v[i], j));
+ }
+ } else {
+ CHECK(keys[i] + 1 != ((int *)values)[i],
+ "key/value checking",
+ "error: i %d key %d value %d\n", i, keys[i],
+ ((int *)values)[i]);
+ }
+
+ visited[i] = 1;
+
+ }
+ for (i = 0; i < max_entries; i++) {
+ CHECK(visited[i] != 1, "visited checking",
+ "error: keys array at index %d missing\n", i);
+ }
+}
+
+void __test_map_lookup_and_delete_batch(bool is_pcpu)
+{
+ int map_type = is_pcpu ? BPF_MAP_TYPE_PERCPU_HASH : BPF_MAP_TYPE_HASH;
+ struct bpf_create_map_attr xattr = {
+ .name = "hash_map",
+ .map_type = map_type,
+ .key_size = sizeof(int),
+ .value_size = sizeof(int),
+ };
+ typedef BPF_DECLARE_PERCPU(int, value);
+ int map_fd, *keys, *visited, key;
+ __u32 batch = 0, count, total, total_success;
+ const __u32 max_entries = 10;
+ int err, i, step, value_size;
+ value pcpu_values[10];
+ bool nospace_err;
+ void *values;
+
+ xattr.max_entries = max_entries;
+ map_fd = bpf_create_map_xattr(&xattr);
+ CHECK(map_fd == -1,
+ "bpf_create_map_xattr()", "error:%s\n", strerror(errno));
+
+ value_size = is_pcpu ? sizeof(value) : sizeof(int);
+ keys = malloc(max_entries * sizeof(int));
+ if (is_pcpu)
+ values = pcpu_values;
+ else
+ values = malloc(max_entries * sizeof(int));
+ visited = malloc(max_entries * sizeof(int));
+ CHECK(!keys || !values || !visited, "malloc()",
+ "error:%s\n", strerror(errno));
+
+ /* test 1: lookup/delete an empty hash table, -ENOENT */
+ count = max_entries;
+ err = bpf_map_lookup_and_delete_batch(map_fd, NULL, &batch, keys,
+ values, &count, 0, 0);
+ CHECK((err && errno != ENOENT), "empty map",
+ "error: %s\n", strerror(errno));
+
+ /* populate elements to the map */
+ map_batch_update(map_fd, max_entries, keys, values, is_pcpu);
+
+ /* test 2: lookup/delete with count = 0, success */
+ batch = 0;
+ count = 0;
+ err = bpf_map_lookup_and_delete_batch(map_fd, NULL, &batch, keys,
+ values, &count, 0, 0);
+ CHECK(err, "count = 0", "error: %s\n", strerror(errno));
+
+ /* test 3: lookup/delete with count = max_entries, success */
+ memset(keys, 0, max_entries * sizeof(*keys));
+ memset(values, 0, max_entries * value_size);
+ count = max_entries;
+ batch = 0;
+ err = bpf_map_lookup_and_delete_batch(map_fd, NULL, &batch, keys,
+ values, &count, 0, 0);
+ CHECK((err && errno != ENOENT), "count = max_entries",
+ "error: %s\n", strerror(errno));
+ CHECK(count != max_entries, "count = max_entries",
+ "count = %u, max_entries = %u\n", count, max_entries);
+ map_batch_verify(visited, max_entries, keys, values, is_pcpu);
+
+ /* bpf_map_get_next_key() should return -ENOENT for an empty map. */
+ err = bpf_map_get_next_key(map_fd, NULL, &key);
+ CHECK(!err, "bpf_map_get_next_key()", "error: %s\n", strerror(errno));
+
+ /* test 4: lookup/delete 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, is_pcpu);
+ memset(keys, 0, max_entries * sizeof(*keys));
+ memset(values, 0, max_entries * value_size);
+ batch = 0;
+ total = 0;
+ i = 0;
+ /* iteratively lookup/delete elements with 'step'
+ * elements each
+ */
+ count = step;
+ nospace_err = false;
+ while (true) {
+ err = bpf_map_lookup_batch(map_fd,
+ total ? &batch : NULL,
+ &batch, keys + total,
+ values +
+ total * value_size,
+ &count, 0, 0);
+ /* It is possible that we are failing due to buffer size
+ * not big enough. In such cases, let us just exit and
+ * go with large steps. Not that a buffer size with
+ * max_entries should always work.
+ */
+ if (err && errno == ENOSPC) {
+ nospace_err = true;
+ break;
+ }
+
+
+ CHECK((err && errno != ENOENT), "lookup with steps",
+ "error: %s\n", strerror(errno));
+
+ total += count;
+ if (err)
+ break;
+
+ i++;
+ }
+ if (nospace_err == true)
+ continue;
+
+ CHECK(total != max_entries, "lookup with steps",
+ "total = %u, max_entries = %u\n", total, max_entries);
+ map_batch_verify(visited, max_entries, keys, values, is_pcpu);
+
+ memset(keys, 0, max_entries * sizeof(*keys));
+ memset(values, 0, max_entries * value_size);
+ batch = 0;
+ total = 0;
+ i = 0;
+ /* iteratively lookup/delete elements with 'step'
+ * elements each
+ */
+ count = step;
+ nospace_err = false;
+ while (true) {
+ err = bpf_map_lookup_and_delete_batch(map_fd,
+ total ? &batch : NULL,
+ &batch, keys + total,
+ values +
+ total * value_size,
+ &count, 0, 0);
+ /* It is possible that we are failing due to buffer size
+ * not big enough. In such cases, let us just exit and
+ * go with large steps. Not that a buffer size with
+ * max_entries should always work.
+ */
+ if (err && errno == ENOSPC) {
+ nospace_err = true;
+ break;
+ }
+
+ CHECK((err && errno != ENOENT), "lookup with steps",
+ "error: %s\n", strerror(errno));
+
+ total += count;
+ if (err)
+ break;
+ i++;
+ }
+
+ if (nospace_err == true)
+ continue;
+
+ CHECK(total != max_entries, "lookup/delete with steps",
+ "total = %u, max_entries = %u\n", total, max_entries);
+
+ map_batch_verify(visited, max_entries, keys, values, is_pcpu);
+ err = bpf_map_get_next_key(map_fd, NULL, &key);
+ CHECK(!err, "bpf_map_get_next_key()", "error: %s\n",
+ strerror(errno));
+
+ total_success++;
+ }
+
+ CHECK(total_success == 0, "check total_success",
+ "unexpected failure\n");
+}
+
+void test_hmap_lookup_and_delete_batch(void)
+{
+ __test_map_lookup_and_delete_batch(false);
+ printf("%s:PASS\n", __func__);
+}
+
+void test_pcpu_hmap_lookup_and_delete_batch(void)
+{
+ __test_map_lookup_and_delete_batch(true);
+ printf("%s:PASS\n", __func__);
+}
+
+void test_map_lookup_and_delete_batch_htab(void)
+{
+ test_hmap_lookup_and_delete_batch();
+ test_pcpu_hmap_lookup_and_delete_batch();
+}
--
2.24.0.432.g9d3f5f5b63-goog
On 11/19/19 11:30 AM, Brian Vazquez wrote:
> From: Yonghong Song <[email protected]>
>
> Tested bpf_map_lookup_and_delete_batch() and bpf_map_update_batch()
> functionality.
> $ ./test_maps
> ...
> test_hmap_lookup_and_delete_batch:PASS
> test_pcpu_hmap_lookup_and_delete_batch:PASS
> ...
Maybe you can add another tests for lookup_batch() and delete_batch()
so all new APIs get tested?
>
> Signed-off-by: Yonghong Song <[email protected]>
> Signed-off-by: Brian Vazquez <[email protected]>
> ---
> .../map_lookup_and_delete_batch_htab.c | 257 ++++++++++++++++++
> 1 file changed, 257 insertions(+)
> create mode 100644 tools/testing/selftests/bpf/map_tests/map_lookup_and_delete_batch_htab.c
>
> diff --git a/tools/testing/selftests/bpf/map_tests/map_lookup_and_delete_batch_htab.c b/tools/testing/selftests/bpf/map_tests/map_lookup_and_delete_batch_htab.c
> new file mode 100644
> index 0000000000000..93e024cb85c60
> --- /dev/null
> +++ b/tools/testing/selftests/bpf/map_tests/map_lookup_and_delete_batch_htab.c
> @@ -0,0 +1,257 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/* Copyright (c) 2019 Facebook */
> +#include <stdio.h>
> +#include <errno.h>
> +#include <string.h>
> +
> +#include <bpf/bpf.h>
> +#include <bpf/libbpf.h>
> +
> +#include <bpf_util.h>
> +#include <test_maps.h>
> +
> +static void map_batch_update(int map_fd, __u32 max_entries, int *keys,
> + void *values, bool is_pcpu)
> +{
> + typedef BPF_DECLARE_PERCPU(int, value);
> + int i, j, err;
> + value *v;
> +
> + if (is_pcpu)
> + v = (value *)values;
> +
> + for (i = 0; i < max_entries; i++) {
> + keys[i] = i + 1;
> + if (is_pcpu)
> + for (j = 0; j < bpf_num_possible_cpus(); j++)
> + bpf_percpu(v[i], j) = i + 2 + j;
> + else
> + ((int *)values)[i] = i + 2;
> + }
> +
> + err = bpf_map_update_batch(map_fd, keys, values, &max_entries, 0, 0);
> + CHECK(err, "bpf_map_update_batch()", "error:%s\n", strerror(errno));
> +}
> +
> +static void map_batch_verify(int *visited, __u32 max_entries,
> + int *keys, void *values, bool is_pcpu)
> +{
> + typedef BPF_DECLARE_PERCPU(int, value);
> + value *v;
> + int i, j;
> +
> + if (is_pcpu)
> + v = (value *)values;
> +
> + memset(visited, 0, max_entries * sizeof(*visited));
> + for (i = 0; i < max_entries; i++) {
> +
> + if (is_pcpu) {
> + for (j = 0; j < bpf_num_possible_cpus(); j++) {
> + CHECK(keys[i] + 1 + j != bpf_percpu(v[i], j),
> + "key/value checking",
> + "error: i %d j %d key %d value %d\n",
> + i, j, keys[i], bpf_percpu(v[i], j));
> + }
> + } else {
> + CHECK(keys[i] + 1 != ((int *)values)[i],
> + "key/value checking",
> + "error: i %d key %d value %d\n", i, keys[i],
> + ((int *)values)[i]);
> + }
> +
> + visited[i] = 1;
> +
> + }
> + for (i = 0; i < max_entries; i++) {
> + CHECK(visited[i] != 1, "visited checking",
> + "error: keys array at index %d missing\n", i);
> + }
> +}
> +
> +void __test_map_lookup_and_delete_batch(bool is_pcpu)
> +{
> + int map_type = is_pcpu ? BPF_MAP_TYPE_PERCPU_HASH : BPF_MAP_TYPE_HASH;
> + struct bpf_create_map_attr xattr = {
> + .name = "hash_map",
> + .map_type = map_type,
> + .key_size = sizeof(int),
> + .value_size = sizeof(int),
> + };
> + typedef BPF_DECLARE_PERCPU(int, value);
> + int map_fd, *keys, *visited, key;
> + __u32 batch = 0, count, total, total_success;
> + const __u32 max_entries = 10;
> + int err, i, step, value_size;
> + value pcpu_values[10];
> + bool nospace_err;
> + void *values;
> +
> + xattr.max_entries = max_entries;
> + map_fd = bpf_create_map_xattr(&xattr);
> + CHECK(map_fd == -1,
> + "bpf_create_map_xattr()", "error:%s\n", strerror(errno));
> +
> + value_size = is_pcpu ? sizeof(value) : sizeof(int);
> + keys = malloc(max_entries * sizeof(int));
> + if (is_pcpu)
> + values = pcpu_values;
> + else
> + values = malloc(max_entries * sizeof(int));
> + visited = malloc(max_entries * sizeof(int));
> + CHECK(!keys || !values || !visited, "malloc()",
> + "error:%s\n", strerror(errno));
> +
> + /* test 1: lookup/delete an empty hash table, -ENOENT */
> + count = max_entries;
> + err = bpf_map_lookup_and_delete_batch(map_fd, NULL, &batch, keys,
> + values, &count, 0, 0);
> + CHECK((err && errno != ENOENT), "empty map",
> + "error: %s\n", strerror(errno));
> +
> + /* populate elements to the map */
> + map_batch_update(map_fd, max_entries, keys, values, is_pcpu);
> +
> + /* test 2: lookup/delete with count = 0, success */
> + batch = 0;
> + count = 0;
> + err = bpf_map_lookup_and_delete_batch(map_fd, NULL, &batch, keys,
> + values, &count, 0, 0);
> + CHECK(err, "count = 0", "error: %s\n", strerror(errno));
> +
> + /* test 3: lookup/delete with count = max_entries, success */
> + memset(keys, 0, max_entries * sizeof(*keys));
> + memset(values, 0, max_entries * value_size);
> + count = max_entries;
> + batch = 0;
> + err = bpf_map_lookup_and_delete_batch(map_fd, NULL, &batch, keys,
> + values, &count, 0, 0);
> + CHECK((err && errno != ENOENT), "count = max_entries",
> + "error: %s\n", strerror(errno));
> + CHECK(count != max_entries, "count = max_entries",
> + "count = %u, max_entries = %u\n", count, max_entries);
> + map_batch_verify(visited, max_entries, keys, values, is_pcpu);
> +
> + /* bpf_map_get_next_key() should return -ENOENT for an empty map. */
> + err = bpf_map_get_next_key(map_fd, NULL, &key);
> + CHECK(!err, "bpf_map_get_next_key()", "error: %s\n", strerror(errno));
> +
> + /* test 4: lookup/delete 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, is_pcpu);
> + memset(keys, 0, max_entries * sizeof(*keys));
> + memset(values, 0, max_entries * value_size);
> + batch = 0;
> + total = 0;
> + i = 0;
> + /* iteratively lookup/delete elements with 'step'
> + * elements each
> + */
> + count = step;
> + nospace_err = false;
> + while (true) {
> + err = bpf_map_lookup_batch(map_fd,
> + total ? &batch : NULL,
> + &batch, keys + total,
> + values +
> + total * value_size,
> + &count, 0, 0);
> + /* It is possible that we are failing due to buffer size
> + * not big enough. In such cases, let us just exit and
> + * go with large steps. Not that a buffer size with
> + * max_entries should always work.
> + */
> + if (err && errno == ENOSPC) {
> + nospace_err = true;
> + break;
> + }
> +
> +
> + CHECK((err && errno != ENOENT), "lookup with steps",
> + "error: %s\n", strerror(errno));
> +
> + total += count;
> + if (err)
> + break;
> +
> + i++;
> + }
> + if (nospace_err == true)
> + continue;
> +
> + CHECK(total != max_entries, "lookup with steps",
> + "total = %u, max_entries = %u\n", total, max_entries);
> + map_batch_verify(visited, max_entries, keys, values, is_pcpu);
> +
> + memset(keys, 0, max_entries * sizeof(*keys));
> + memset(values, 0, max_entries * value_size);
> + batch = 0;
> + total = 0;
> + i = 0;
> + /* iteratively lookup/delete elements with 'step'
> + * elements each
> + */
> + count = step;
> + nospace_err = false;
> + while (true) {
> + err = bpf_map_lookup_and_delete_batch(map_fd,
> + total ? &batch : NULL,
> + &batch, keys + total,
> + values +
> + total * value_size,
> + &count, 0, 0);
> + /* It is possible that we are failing due to buffer size
> + * not big enough. In such cases, let us just exit and
> + * go with large steps. Not that a buffer size with
> + * max_entries should always work.
> + */
> + if (err && errno == ENOSPC) {
> + nospace_err = true;
> + break;
> + }
> +
> + CHECK((err && errno != ENOENT), "lookup with steps",
> + "error: %s\n", strerror(errno));
> +
> + total += count;
> + if (err)
> + break;
> + i++;
> + }
> +
> + if (nospace_err == true)
> + continue;
> +
> + CHECK(total != max_entries, "lookup/delete with steps",
> + "total = %u, max_entries = %u\n", total, max_entries);
> +
> + map_batch_verify(visited, max_entries, keys, values, is_pcpu);
> + err = bpf_map_get_next_key(map_fd, NULL, &key);
> + CHECK(!err, "bpf_map_get_next_key()", "error: %s\n",
> + strerror(errno));
> +
> + total_success++;
> + }
> +
> + CHECK(total_success == 0, "check total_success",
> + "unexpected failure\n");
> +}
> +
> +void test_hmap_lookup_and_delete_batch(void)
> +{
> + __test_map_lookup_and_delete_batch(false);
> + printf("%s:PASS\n", __func__);
> +}
> +
> +void test_pcpu_hmap_lookup_and_delete_batch(void)
> +{
> + __test_map_lookup_and_delete_batch(true);
> + printf("%s:PASS\n", __func__);
> +}
> +
> +void test_map_lookup_and_delete_batch_htab(void)
> +{
> + test_hmap_lookup_and_delete_batch();
> + test_pcpu_hmap_lookup_and_delete_batch();
> +}
>
On Thu, Nov 21, 2019 at 10:36 AM Yonghong Song <[email protected]> wrote:
>
>
>
> On 11/19/19 11:30 AM, Brian Vazquez wrote:
> > From: Yonghong Song <[email protected]>
> >
> > Tested bpf_map_lookup_and_delete_batch() and bpf_map_update_batch()
> > functionality.
> > $ ./test_maps
> > ...
> > test_hmap_lookup_and_delete_batch:PASS
> > test_pcpu_hmap_lookup_and_delete_batch:PASS
> > ...
>
> Maybe you can add another tests for lookup_batch() and delete_batch()
> so all new APIs get tested?
I did test lookup_batch() and the code is there, I will add
delete_batch() testing and change the name of the tests to better
reflect what is being tested.
>
> >
> > Signed-off-by: Yonghong Song <[email protected]>
> > Signed-off-by: Brian Vazquez <[email protected]>
> > ---
> > .../map_lookup_and_delete_batch_htab.c | 257 ++++++++++++++++++
> > 1 file changed, 257 insertions(+)
> > create mode 100644 tools/testing/selftests/bpf/map_tests/map_lookup_and_delete_batch_htab.c
> >
> > diff --git a/tools/testing/selftests/bpf/map_tests/map_lookup_and_delete_batch_htab.c b/tools/testing/selftests/bpf/map_tests/map_lookup_and_delete_batch_htab.c
> > new file mode 100644
> > index 0000000000000..93e024cb85c60
> > --- /dev/null
> > +++ b/tools/testing/selftests/bpf/map_tests/map_lookup_and_delete_batch_htab.c
> > @@ -0,0 +1,257 @@
> > +// SPDX-License-Identifier: GPL-2.0
> > +/* Copyright (c) 2019 Facebook */
> > +#include <stdio.h>
> > +#include <errno.h>
> > +#include <string.h>
> > +
> > +#include <bpf/bpf.h>
> > +#include <bpf/libbpf.h>
> > +
> > +#include <bpf_util.h>
> > +#include <test_maps.h>
> > +
> > +static void map_batch_update(int map_fd, __u32 max_entries, int *keys,
> > + void *values, bool is_pcpu)
> > +{
> > + typedef BPF_DECLARE_PERCPU(int, value);
> > + int i, j, err;
> > + value *v;
> > +
> > + if (is_pcpu)
> > + v = (value *)values;
> > +
> > + for (i = 0; i < max_entries; i++) {
> > + keys[i] = i + 1;
> > + if (is_pcpu)
> > + for (j = 0; j < bpf_num_possible_cpus(); j++)
> > + bpf_percpu(v[i], j) = i + 2 + j;
> > + else
> > + ((int *)values)[i] = i + 2;
> > + }
> > +
> > + err = bpf_map_update_batch(map_fd, keys, values, &max_entries, 0, 0);
> > + CHECK(err, "bpf_map_update_batch()", "error:%s\n", strerror(errno));
> > +}
> > +
> > +static void map_batch_verify(int *visited, __u32 max_entries,
> > + int *keys, void *values, bool is_pcpu)
> > +{
> > + typedef BPF_DECLARE_PERCPU(int, value);
> > + value *v;
> > + int i, j;
> > +
> > + if (is_pcpu)
> > + v = (value *)values;
> > +
> > + memset(visited, 0, max_entries * sizeof(*visited));
> > + for (i = 0; i < max_entries; i++) {
> > +
> > + if (is_pcpu) {
> > + for (j = 0; j < bpf_num_possible_cpus(); j++) {
> > + CHECK(keys[i] + 1 + j != bpf_percpu(v[i], j),
> > + "key/value checking",
> > + "error: i %d j %d key %d value %d\n",
> > + i, j, keys[i], bpf_percpu(v[i], j));
> > + }
> > + } else {
> > + CHECK(keys[i] + 1 != ((int *)values)[i],
> > + "key/value checking",
> > + "error: i %d key %d value %d\n", i, keys[i],
> > + ((int *)values)[i]);
> > + }
> > +
> > + visited[i] = 1;
> > +
> > + }
> > + for (i = 0; i < max_entries; i++) {
> > + CHECK(visited[i] != 1, "visited checking",
> > + "error: keys array at index %d missing\n", i);
> > + }
> > +}
> > +
> > +void __test_map_lookup_and_delete_batch(bool is_pcpu)
> > +{
> > + int map_type = is_pcpu ? BPF_MAP_TYPE_PERCPU_HASH : BPF_MAP_TYPE_HASH;
> > + struct bpf_create_map_attr xattr = {
> > + .name = "hash_map",
> > + .map_type = map_type,
> > + .key_size = sizeof(int),
> > + .value_size = sizeof(int),
> > + };
> > + typedef BPF_DECLARE_PERCPU(int, value);
> > + int map_fd, *keys, *visited, key;
> > + __u32 batch = 0, count, total, total_success;
> > + const __u32 max_entries = 10;
> > + int err, i, step, value_size;
> > + value pcpu_values[10];
> > + bool nospace_err;
> > + void *values;
> > +
> > + xattr.max_entries = max_entries;
> > + map_fd = bpf_create_map_xattr(&xattr);
> > + CHECK(map_fd == -1,
> > + "bpf_create_map_xattr()", "error:%s\n", strerror(errno));
> > +
> > + value_size = is_pcpu ? sizeof(value) : sizeof(int);
> > + keys = malloc(max_entries * sizeof(int));
> > + if (is_pcpu)
> > + values = pcpu_values;
> > + else
> > + values = malloc(max_entries * sizeof(int));
> > + visited = malloc(max_entries * sizeof(int));
> > + CHECK(!keys || !values || !visited, "malloc()",
> > + "error:%s\n", strerror(errno));
> > +
> > + /* test 1: lookup/delete an empty hash table, -ENOENT */
> > + count = max_entries;
> > + err = bpf_map_lookup_and_delete_batch(map_fd, NULL, &batch, keys,
> > + values, &count, 0, 0);
> > + CHECK((err && errno != ENOENT), "empty map",
> > + "error: %s\n", strerror(errno));
> > +
> > + /* populate elements to the map */
> > + map_batch_update(map_fd, max_entries, keys, values, is_pcpu);
> > +
> > + /* test 2: lookup/delete with count = 0, success */
> > + batch = 0;
> > + count = 0;
> > + err = bpf_map_lookup_and_delete_batch(map_fd, NULL, &batch, keys,
> > + values, &count, 0, 0);
> > + CHECK(err, "count = 0", "error: %s\n", strerror(errno));
> > +
> > + /* test 3: lookup/delete with count = max_entries, success */
> > + memset(keys, 0, max_entries * sizeof(*keys));
> > + memset(values, 0, max_entries * value_size);
> > + count = max_entries;
> > + batch = 0;
> > + err = bpf_map_lookup_and_delete_batch(map_fd, NULL, &batch, keys,
> > + values, &count, 0, 0);
> > + CHECK((err && errno != ENOENT), "count = max_entries",
> > + "error: %s\n", strerror(errno));
> > + CHECK(count != max_entries, "count = max_entries",
> > + "count = %u, max_entries = %u\n", count, max_entries);
> > + map_batch_verify(visited, max_entries, keys, values, is_pcpu);
> > +
> > + /* bpf_map_get_next_key() should return -ENOENT for an empty map. */
> > + err = bpf_map_get_next_key(map_fd, NULL, &key);
> > + CHECK(!err, "bpf_map_get_next_key()", "error: %s\n", strerror(errno));
> > +
> > + /* test 4: lookup/delete 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, is_pcpu);
> > + memset(keys, 0, max_entries * sizeof(*keys));
> > + memset(values, 0, max_entries * value_size);
> > + batch = 0;
> > + total = 0;
> > + i = 0;
> > + /* iteratively lookup/delete elements with 'step'
> > + * elements each
> > + */
> > + count = step;
> > + nospace_err = false;
> > + while (true) {
> > + err = bpf_map_lookup_batch(map_fd,
> > + total ? &batch : NULL,
> > + &batch, keys + total,
> > + values +
> > + total * value_size,
> > + &count, 0, 0);
> > + /* It is possible that we are failing due to buffer size
> > + * not big enough. In such cases, let us just exit and
> > + * go with large steps. Not that a buffer size with
> > + * max_entries should always work.
> > + */
> > + if (err && errno == ENOSPC) {
> > + nospace_err = true;
> > + break;
> > + }
> > +
> > +
> > + CHECK((err && errno != ENOENT), "lookup with steps",
> > + "error: %s\n", strerror(errno));
> > +
> > + total += count;
> > + if (err)
> > + break;
> > +
> > + i++;
> > + }
> > + if (nospace_err == true)
> > + continue;
> > +
> > + CHECK(total != max_entries, "lookup with steps",
> > + "total = %u, max_entries = %u\n", total, max_entries);
> > + map_batch_verify(visited, max_entries, keys, values, is_pcpu);
> > +
> > + memset(keys, 0, max_entries * sizeof(*keys));
> > + memset(values, 0, max_entries * value_size);
> > + batch = 0;
> > + total = 0;
> > + i = 0;
> > + /* iteratively lookup/delete elements with 'step'
> > + * elements each
> > + */
> > + count = step;
> > + nospace_err = false;
> > + while (true) {
> > + err = bpf_map_lookup_and_delete_batch(map_fd,
> > + total ? &batch : NULL,
> > + &batch, keys + total,
> > + values +
> > + total * value_size,
> > + &count, 0, 0);
> > + /* It is possible that we are failing due to buffer size
> > + * not big enough. In such cases, let us just exit and
> > + * go with large steps. Not that a buffer size with
> > + * max_entries should always work.
> > + */
> > + if (err && errno == ENOSPC) {
> > + nospace_err = true;
> > + break;
> > + }
> > +
> > + CHECK((err && errno != ENOENT), "lookup with steps",
> > + "error: %s\n", strerror(errno));
> > +
> > + total += count;
> > + if (err)
> > + break;
> > + i++;
> > + }
> > +
> > + if (nospace_err == true)
> > + continue;
> > +
> > + CHECK(total != max_entries, "lookup/delete with steps",
> > + "total = %u, max_entries = %u\n", total, max_entries);
> > +
> > + map_batch_verify(visited, max_entries, keys, values, is_pcpu);
> > + err = bpf_map_get_next_key(map_fd, NULL, &key);
> > + CHECK(!err, "bpf_map_get_next_key()", "error: %s\n",
> > + strerror(errno));
> > +
> > + total_success++;
> > + }
> > +
> > + CHECK(total_success == 0, "check total_success",
> > + "unexpected failure\n");
> > +}
> > +
> > +void test_hmap_lookup_and_delete_batch(void)
> > +{
> > + __test_map_lookup_and_delete_batch(false);
> > + printf("%s:PASS\n", __func__);
> > +}
> > +
> > +void test_pcpu_hmap_lookup_and_delete_batch(void)
> > +{
> > + __test_map_lookup_and_delete_batch(true);
> > + printf("%s:PASS\n", __func__);
> > +}
> > +
> > +void test_map_lookup_and_delete_batch_htab(void)
> > +{
> > + test_hmap_lookup_and_delete_batch();
> > + test_pcpu_hmap_lookup_and_delete_batch();
> > +}
> >