From: Brian Vazquez <brianvv@google.com>
To: Brian Vazquez <brianvv.kernel@gmail.com>,
Brian Vazquez <brianvv@google.com>,
Alexei Starovoitov <ast@kernel.org>,
Daniel Borkmann <daniel@iogearbox.net>,
"David S . Miller" <davem@davemloft.net>
Cc: Yonghong Song <yhs@fb.com>, Stanislav Fomichev <sdf@google.com>,
Petar Penkov <ppenkov@google.com>,
Willem de Bruijn <willemb@google.com>,
linux-kernel@vger.kernel.org, netdev@vger.kernel.org,
bpf@vger.kernel.org
Subject: [PATCH v3 bpf-next 11/11] selftests/bpf: add batch ops testing to lpm_trie bpf map
Date: Wed, 11 Dec 2019 14:33:44 -0800 [thread overview]
Message-ID: <20191211223344.165549-12-brianvv@google.com> (raw)
In-Reply-To: <20191211223344.165549-1-brianvv@google.com>
Tested bpf_map_batch_ops functionality.
$ ./test_maps
...
test_trie_map_batch_ops:PASS
...
Signed-off-by: Brian Vazquez <brianvv@google.com>
Signed-off-by: Yonghong Song <yhs@fb.com>
---
.../bpf/map_tests/trie_map_batch_ops.c | 235 ++++++++++++++++++
1 file changed, 235 insertions(+)
create mode 100644 tools/testing/selftests/bpf/map_tests/trie_map_batch_ops.c
diff --git a/tools/testing/selftests/bpf/map_tests/trie_map_batch_ops.c b/tools/testing/selftests/bpf/map_tests/trie_map_batch_ops.c
new file mode 100644
index 0000000000000..927e898bea2d0
--- /dev/null
+++ b/tools/testing/selftests/bpf/map_tests/trie_map_batch_ops.c
@@ -0,0 +1,235 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <arpa/inet.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 i, err;
+ struct bpf_lpm_trie_key *key_helper;
+ void *key, *values;
+ size_t key_size;
+
+ key_size = sizeof(*key_helper) + sizeof(__u32);
+ key = alloca(max_entries * key_size);
+ values = alloca(max_entries * sizeof(int));
+
+ for (i = 0; i < max_entries; i++) {
+ key_helper = (struct bpf_lpm_trie_key *)(key + i * key_size);
+ inet_pton(AF_INET, "192.168.0.0", key_helper->data);
+ key_helper->data[3] = i;
+ key_helper->prefixlen = 16 + i;
+ ((int *)values)[i] = i + 1;
+ }
+
+ err = bpf_map_update_batch(map_fd, key, 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,
+ void *keys, void *values)
+{
+ struct bpf_lpm_trie_key *key;
+ size_t key_size;
+ int i;
+
+ memset(visited, 0, max_entries * sizeof(*visited));
+ key_size = sizeof(*key) + sizeof(__u32);
+
+ for (i = 0; i < max_entries; i++) {
+ key = keys + i * key_size;
+ CHECK(key->data[3] + 1 != ((int *)values)[i],
+ "key/value checking",
+ "error: i %d key %d.%d.%d.%d value %d\n", i, key->data[0],
+ key->data[1], key->data[2], key->data[3],
+ ((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_trie_map_lookup_and_delete_batch(void)
+{
+ struct bpf_lpm_trie_key *batch, *key_p;
+ size_t key_size = sizeof(*key_p) + sizeof(__u32);
+ struct bpf_create_map_attr xattr = {
+ .name = "lpm_trie_map",
+ .map_type = BPF_MAP_TYPE_LPM_TRIE,
+ .key_size = key_size,
+ .value_size = sizeof(int),
+ };
+ __u32 count, total, total_success;
+ const __u32 max_entries = 10;
+ int map_fd, *visited, key;
+ int err, i, step;
+ int *values;
+ void *keys;
+
+ xattr.max_entries = max_entries;
+ xattr.map_flags = BPF_F_NO_PREALLOC;
+ map_fd = bpf_create_map_xattr(&xattr);
+ CHECK(map_fd == -1,
+ "bpf_create_map_xattr()", "error:%s\n", strerror(errno));
+
+ keys = malloc(max_entries * key_size);
+ batch = malloc(key_size);
+ 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);
+
+ /* test 2: lookup/delete with count = 0, success */
+ 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 * key_size);
+ memset(values, 0, max_entries * sizeof(int));
+ count = max_entries;
+ 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);
+
+ /* 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 = 4; step < max_entries; step++) {
+ map_batch_update(map_fd, max_entries);
+ memset(keys, 0, max_entries * key_size);
+ memset(values, 0, max_entries * sizeof(int));
+ total = 0;
+ /* iteratively lookup elements with 'step'
+ * elements each
+ */
+ count = step;
+ while (true) {
+ err = bpf_map_lookup_batch(map_fd,
+ total ? batch : NULL,
+ batch,
+ keys + total * key_size,
+ values + total,
+ &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.
+ */
+ CHECK((err && errno != ENOENT), "lookup with steps",
+ "error: %s\n", strerror(errno));
+
+ total += count;
+ if (err)
+ break;
+ }
+
+ CHECK(total != max_entries, "lookup with steps",
+ "total = %u, max_entries = %u\n", total, max_entries);
+ map_batch_verify(visited, max_entries, keys, values);
+
+ total = 0;
+ while (true) {
+ err = bpf_map_delete_batch(map_fd,
+ keys + total * key_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.
+ */
+ CHECK((err && errno != ENOENT), "lookup with steps",
+ "error: %s\n", strerror(errno));
+ total += count;
+ if (err)
+ break;
+ }
+
+ CHECK(total != max_entries, "delete with steps",
+ "total = %u, max_entries = %u\n", total, max_entries);
+
+ /* check map is empty, errno == -ENOENT */
+ err = bpf_map_get_next_key(map_fd, NULL, keys);
+ CHECK(!err || errno != ENOENT, "bpf_map_get_next_key()",
+ "error: %s\n", strerror(errno));
+
+ map_batch_update(map_fd, max_entries);
+ memset(keys, 0, max_entries * key_size);
+ memset(values, 0, max_entries * sizeof(int));
+ total = 0;
+ i = 0;
+ /* iteratively lookup/delete elements with 'step'
+ * elements each
+ */
+ count = step;
+ while (true) {
+ err = bpf_map_lookup_and_delete_batch(map_fd,
+ total ? batch : NULL,
+ batch,
+ keys + total * key_size,
+ values + total,
+ &count, 0, 0);
+
+ CHECK((err && errno != ENOENT), "lookup with steps",
+ "error: %s\n", strerror(errno));
+
+ total += count;
+ if (err)
+ break;
+ i++;
+ }
+
+ 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);
+ 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 trie_map_batch_ops(void)
+{
+ __test_trie_map_lookup_and_delete_batch();
+ printf("test_%s:PASS\n", __func__);
+}
+
+void test_trie_map_batch_ops(void)
+{
+ trie_map_batch_ops();
+}
--
2.24.1.735.g03f4e72817-goog
next prev parent reply other threads:[~2019-12-11 22:35 UTC|newest]
Thread overview: 31+ messages / expand[flat|nested] mbox.gz Atom feed top
2019-12-11 22:33 [PATCH v3 bpf-next 00/11] add bpf batch ops to process more than 1 elem Brian Vazquez
2019-12-11 22:33 ` [PATCH v3 bpf-next 01/11] bpf: add bpf_map_{value_size,update_value,map_copy_value} functions Brian Vazquez
2019-12-13 17:05 ` Yonghong Song
2019-12-11 22:33 ` [PATCH v3 bpf-next 02/11] bpf: add generic support for lookup and lookup_and_delete batch ops Brian Vazquez
2019-12-13 17:26 ` Yonghong Song
2020-01-07 6:50 ` Brian Vazquez
2020-01-07 18:06 ` Yonghong Song
2019-12-11 22:33 ` [PATCH v3 bpf-next 03/11] bpf: add generic support for update and delete " Brian Vazquez
2019-12-13 17:38 ` Yonghong Song
2019-12-11 22:33 ` [PATCH v3 bpf-next 04/11] bpf: add lookup and updated batch ops to arraymap Brian Vazquez
2019-12-13 17:39 ` Yonghong Song
2019-12-11 22:33 ` [PATCH v3 bpf-next 05/11] bpf: add generic_batch_ops to lpm_trie map Brian Vazquez
2019-12-13 17:46 ` Yonghong Song
2020-01-07 6:39 ` Brian Vazquez
2020-01-07 17:57 ` Yonghong Song
2019-12-11 22:33 ` [PATCH v3 bpf-next 06/11] bpf: add batch ops to all htab bpf map Brian Vazquez
2019-12-13 18:14 ` Yonghong Song
2019-12-13 18:58 ` Yonghong Song
2020-01-07 7:02 ` Brian Vazquez
2020-01-07 18:18 ` Yonghong Song
2020-01-08 0:32 ` Brian Vazquez
2019-12-11 22:33 ` [PATCH v3 bpf-next 07/11] tools/bpf: sync uapi header bpf.h Brian Vazquez
2019-12-11 22:33 ` [PATCH v3 bpf-next 08/11] libbpf: add libbpf support to batch ops Brian Vazquez
2019-12-19 0:54 ` Andrii Nakryiko
2020-01-07 6:51 ` Brian Vazquez
2019-12-11 22:33 ` [PATCH v3 bpf-next 09/11] selftests/bpf: add batch ops testing for htab and htab_percpu map Brian Vazquez
2019-12-13 18:34 ` Yonghong Song
2019-12-13 18:40 ` Yonghong Song
2019-12-11 22:33 ` [PATCH v3 bpf-next 10/11] selftests/bpf: add batch ops testing to array bpf map Brian Vazquez
2019-12-11 22:33 ` Brian Vazquez [this message]
2019-12-13 5:16 ` [PATCH v3 bpf-next 00/11] add bpf batch ops to process more than 1 elem Alexei Starovoitov
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20191211223344.165549-12-brianvv@google.com \
--to=brianvv@google.com \
--cc=ast@kernel.org \
--cc=bpf@vger.kernel.org \
--cc=brianvv.kernel@gmail.com \
--cc=daniel@iogearbox.net \
--cc=davem@davemloft.net \
--cc=linux-kernel@vger.kernel.org \
--cc=netdev@vger.kernel.org \
--cc=ppenkov@google.com \
--cc=sdf@google.com \
--cc=willemb@google.com \
--cc=yhs@fb.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).