new file mode 100644
@@ -0,0 +1,451 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (C) 2024. Huawei Technologies Co., Ltd */
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <test_progs.h>
+
+#include "htab_dynkey_test_success.skel.h"
+#include "htab_dynkey_test_failure.skel.h"
+
+struct id_dname_key {
+ int id;
+ struct bpf_dynptr_user name;
+};
+
+struct dname_key {
+ struct bpf_dynptr_user name;
+};
+
+struct multiple_dynptr_key {
+ struct dname_key f_1;
+ unsigned long f_2;
+ struct id_dname_key f_3;
+ unsigned long f_4;
+};
+
+static char *name_list[] = {
+ "systemd",
+ "[rcu_sched]",
+ "[kworker/42:0H-events_highpri]",
+ "[ksoftirqd/58]",
+ "[rcu_tasks_trace]",
+};
+
+#define INIT_VALUE 100
+#define INIT_ID 1000
+
+static void setup_pure_dynptr_key_map(int fd)
+{
+ struct bpf_dynptr_user key, _cur_key, _next_key;
+ struct bpf_dynptr_user *cur_key, *next_key;
+ bool marked[ARRAY_SIZE(name_list)];
+ unsigned int i, next_idx, size;
+ unsigned long value, got;
+ char name[2][64];
+ char msg[64];
+ void *data;
+ int err;
+
+ /* lookup non-existent keys */
+ for (i = 0; i < ARRAY_SIZE(name_list); i++) {
+ snprintf(msg, sizeof(msg), "#%u bad lookup", i);
+ /* Use strdup() to ensure that the content pointed by dynptr is
+ * used for lookup instead of the pointer in dynptr. sys_bpf()
+ * will handle the NULL case properly.
+ */
+ data = strdup(name_list[i]);
+ bpf_dynptr_user_init(data, strlen(name_list[i]) + 1, &key);
+ err = bpf_map_lookup_elem(fd, &key, &value);
+ ASSERT_EQ(err, -ENOENT, msg);
+ free(data);
+ }
+
+ /* update keys */
+ for (i = 0; i < ARRAY_SIZE(name_list); i++) {
+ snprintf(msg, sizeof(msg), "#%u insert", i);
+ data = strdup(name_list[i]);
+ bpf_dynptr_user_init(data, strlen(name_list[i]) + 1, &key);
+ value = INIT_VALUE + i;
+ err = bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST);
+ ASSERT_OK(err, msg);
+ free(data);
+ }
+
+ /* lookup existent keys */
+ for (i = 0; i < ARRAY_SIZE(name_list); i++) {
+ snprintf(msg, sizeof(msg), "#%u lookup", i);
+ data = strdup(name_list[i]);
+ bpf_dynptr_user_init(data, strlen(name_list[i]) + 1, &key);
+ got = 0;
+ err = bpf_map_lookup_elem(fd, &key, &got);
+ ASSERT_OK(err, msg);
+ free(data);
+
+ value = INIT_VALUE + i;
+ ASSERT_EQ(got, value, msg);
+ }
+
+ /* delete keys */
+ for (i = 0; i < ARRAY_SIZE(name_list); i++) {
+ snprintf(msg, sizeof(msg), "#%u delete", i);
+ data = strdup(name_list[i]);
+ bpf_dynptr_user_init(data, strlen(name_list[i]) + 1, &key);
+ err = bpf_map_delete_elem(fd, &key);
+ ASSERT_OK(err, msg);
+ free(data);
+ }
+
+ /* re-insert keys */
+ for (i = 0; i < ARRAY_SIZE(name_list); i++) {
+ snprintf(msg, sizeof(msg), "#%u re-insert", i);
+ data = strdup(name_list[i]);
+ bpf_dynptr_user_init(data, strlen(name_list[i]) + 1, &key);
+ value = 0;
+ err = bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST);
+ ASSERT_OK(err, msg);
+ free(data);
+ }
+
+ /* overwrite keys */
+ for (i = 0; i < ARRAY_SIZE(name_list); i++) {
+ snprintf(msg, sizeof(msg), "#%u overwrite", i);
+ data = strdup(name_list[i]);
+ bpf_dynptr_user_init(data, strlen(name_list[i]) + 1, &key);
+ value = INIT_VALUE + i;
+ err = bpf_map_update_elem(fd, &key, &value, BPF_EXIST);
+ ASSERT_OK(err, msg);
+ free(data);
+ }
+
+ /* get_next keys */
+ next_idx = 0;
+ cur_key = NULL;
+ next_key = &_next_key;
+ memset(&marked, 0, sizeof(marked));
+ while (true) {
+ bpf_dynptr_user_init(name[next_idx], sizeof(name[next_idx]), next_key);
+ err = bpf_map_get_next_key(fd, cur_key, next_key);
+ if (err) {
+ ASSERT_EQ(err, -ENOENT, "get_next_key");
+ break;
+ }
+
+ size = bpf_dynptr_user_size(next_key);
+ data = bpf_dynptr_user_data(next_key);
+ for (i = 0; i < ARRAY_SIZE(name_list); i++) {
+ if (size == strlen(name_list[i]) + 1 &&
+ !memcmp(name_list[i], data, size)) {
+ ASSERT_FALSE(marked[i], name_list[i]);
+ marked[i] = true;
+ break;
+ }
+ }
+ ASSERT_EQ(next_key->rsvd, 0, "rsvd");
+
+ if (!cur_key)
+ cur_key = &_cur_key;
+ *cur_key = *next_key;
+ next_idx ^= 1;
+ }
+
+ for (i = 0; i < ARRAY_SIZE(marked); i++)
+ ASSERT_TRUE(marked[i], name_list[i]);
+
+ /* lookup_and_delete all elements except the first one */
+ for (i = 1; i < ARRAY_SIZE(name_list); i++) {
+ snprintf(msg, sizeof(msg), "#%u lookup_delete", i);
+ data = strdup(name_list[i]);
+ bpf_dynptr_user_init(data, strlen(name_list[i]) + 1, &key);
+ got = 0;
+ err = bpf_map_lookup_and_delete_elem(fd, &key, &got);
+ ASSERT_OK(err, msg);
+ free(data);
+
+ value = INIT_VALUE + i;
+ ASSERT_EQ(got, value, msg);
+ }
+
+ /* get the key after the first element */
+ cur_key = &_cur_key;
+ strncpy(name[0], name_list[0], sizeof(name[0]) - 1);
+ name[0][sizeof(name[0]) - 1] = 0;
+ bpf_dynptr_user_init(name[0], strlen(name[0]) + 1, cur_key);
+
+ next_key = &_next_key;
+ bpf_dynptr_user_init(name[1], sizeof(name[1]), next_key);
+ err = bpf_map_get_next_key(fd, cur_key, next_key);
+ ASSERT_EQ(err, -ENOENT, "get_last");
+}
+
+static void setup_mixed_dynptr_key_map(int fd)
+{
+ struct id_dname_key key, _cur_key, _next_key;
+ struct id_dname_key *cur_key, *next_key;
+ bool marked[ARRAY_SIZE(name_list)];
+ unsigned int i, next_idx, size;
+ unsigned long value;
+ char name[2][64];
+ char msg[64];
+ void *data;
+ int err;
+
+ /* Zero the hole */
+ memset(&key, 0, sizeof(key));
+
+ /* lookup non-existent keys */
+ for (i = 0; i < ARRAY_SIZE(name_list); i++) {
+ snprintf(msg, sizeof(msg), "#%u bad lookup", i);
+ key.id = INIT_ID + i;
+ data = strdup(name_list[i]);
+ bpf_dynptr_user_init(data, strlen(name_list[i]) + 1, &key.name);
+ err = bpf_map_lookup_elem(fd, &key, &value);
+ ASSERT_EQ(err, -ENOENT, msg);
+ free(data);
+ }
+
+ /* update keys */
+ for (i = 0; i < ARRAY_SIZE(name_list); i++) {
+ snprintf(msg, sizeof(msg), "#%u insert", i);
+ key.id = INIT_ID + i;
+ data = strdup(name_list[i]);
+ bpf_dynptr_user_init(data, strlen(name_list[i]) + 1, &key.name);
+ value = INIT_VALUE + i;
+ err = bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST);
+ ASSERT_OK(err, msg);
+ free(data);
+ }
+
+ /* lookup existent keys */
+ for (i = 0; i < ARRAY_SIZE(name_list); i++) {
+ unsigned long got = 0;
+
+ snprintf(msg, sizeof(msg), "#%u lookup", i);
+ key.id = INIT_ID + i;
+ data = strdup(name_list[i]);
+ bpf_dynptr_user_init(data, strlen(name_list[i]) + 1, &key.name);
+ err = bpf_map_lookup_elem(fd, &key, &got);
+ ASSERT_OK(err, msg);
+ free(data);
+
+ value = INIT_VALUE + i;
+ ASSERT_EQ(got, value, msg);
+ }
+
+ /* delete keys */
+ for (i = 0; i < ARRAY_SIZE(name_list); i++) {
+ snprintf(msg, sizeof(msg), "#%u delete", i);
+ key.id = INIT_ID + i;
+ data = strdup(name_list[i]);
+ bpf_dynptr_user_init(data, strlen(name_list[i]) + 1, &key.name);
+ err = bpf_map_delete_elem(fd, &key);
+ ASSERT_OK(err, msg);
+ free(data);
+ }
+
+ /* re-insert keys */
+ for (i = 0; i < ARRAY_SIZE(name_list); i++) {
+ snprintf(msg, sizeof(msg), "#%u re-insert", i);
+ key.id = INIT_ID + i;
+ data = strdup(name_list[i]);
+ bpf_dynptr_user_init(data, strlen(name_list[i]) + 1, &key.name);
+ value = 0;
+ err = bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST);
+ ASSERT_OK(err, msg);
+ free(data);
+ }
+
+ /* overwrite keys */
+ for (i = 0; i < ARRAY_SIZE(name_list); i++) {
+ snprintf(msg, sizeof(msg), "#%u overwrite", i);
+ key.id = INIT_ID + i;
+ data = strdup(name_list[i]);
+ bpf_dynptr_user_init(data, strlen(name_list[i]) + 1, &key.name);
+ value = INIT_VALUE + i;
+ err = bpf_map_update_elem(fd, &key, &value, BPF_EXIST);
+ ASSERT_OK(err, msg);
+ free(data);
+ }
+
+ /* get_next keys */
+ next_idx = 0;
+ cur_key = NULL;
+ next_key = &_next_key;
+ memset(&marked, 0, sizeof(marked));
+ while (true) {
+ bpf_dynptr_user_init(name[next_idx], sizeof(name[next_idx]), &next_key->name);
+ err = bpf_map_get_next_key(fd, cur_key, next_key);
+ if (err) {
+ ASSERT_EQ(err, -ENOENT, "last get_next");
+ break;
+ }
+
+ size = bpf_dynptr_user_size(&next_key->name);
+ data = bpf_dynptr_user_data(&next_key->name);
+ for (i = 0; i < ARRAY_SIZE(name_list); i++) {
+ if (size == strlen(name_list[i]) + 1 &&
+ !memcmp(name_list[i], data, size)) {
+ ASSERT_FALSE(marked[i], name_list[i]);
+ ASSERT_EQ(next_key->id, INIT_ID + i, name_list[i]);
+ marked[i] = true;
+ break;
+ }
+ }
+ ASSERT_EQ(next_key->name.rsvd, 0, "rsvd");
+
+ if (!cur_key)
+ cur_key = &_cur_key;
+ *cur_key = *next_key;
+ next_idx ^= 1;
+ }
+
+ for (i = 0; i < ARRAY_SIZE(marked); i++)
+ ASSERT_TRUE(marked[i], name_list[i]);
+}
+
+static void setup_multiple_dynptr_key_map(int fd)
+{
+ struct multiple_dynptr_key key, cur_key, next_key;
+ unsigned long value;
+ unsigned int size;
+ char name[4][64];
+ void *data[2];
+ int err;
+
+ /* Zero the hole */
+ memset(&key, 0, sizeof(key));
+
+ key.f_2 = 2;
+ key.f_3.id = 3;
+ key.f_4 = 4;
+
+ /* lookup a non-existent key */
+ data[0] = strdup(name_list[0]);
+ data[1] = strdup(name_list[1]);
+ bpf_dynptr_user_init(data[0], strlen(name_list[0]) + 1, &key.f_1.name);
+ bpf_dynptr_user_init(data[1], strlen(name_list[1]) + 1, &key.f_3.name);
+ err = bpf_map_lookup_elem(fd, &key, &value);
+ ASSERT_EQ(err, -ENOENT, "lookup");
+
+ /* update key */
+ value = INIT_VALUE;
+ err = bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST);
+ ASSERT_OK(err, "update");
+ free(data[0]);
+ free(data[1]);
+
+ /* lookup key */
+ data[0] = strdup(name_list[0]);
+ data[1] = strdup(name_list[1]);
+ bpf_dynptr_user_init(data[0], strlen(name_list[0]) + 1, &key.f_1.name);
+ bpf_dynptr_user_init(data[1], strlen(name_list[1]) + 1, &key.f_3.name);
+ err = bpf_map_lookup_elem(fd, &key, &value);
+ ASSERT_OK(err, "lookup");
+ ASSERT_EQ(value, INIT_VALUE, "lookup");
+
+ /* delete key */
+ err = bpf_map_delete_elem(fd, &key);
+ ASSERT_OK(err, "delete");
+ free(data[0]);
+ free(data[1]);
+
+ /* re-insert keys */
+ bpf_dynptr_user_init(name_list[0], strlen(name_list[0]) + 1, &key.f_1.name);
+ bpf_dynptr_user_init(name_list[1], strlen(name_list[1]) + 1, &key.f_3.name);
+ value = 0;
+ err = bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST);
+ ASSERT_OK(err, "re-insert");
+
+ /* overwrite keys */
+ data[0] = strdup(name_list[0]);
+ data[1] = strdup(name_list[1]);
+ bpf_dynptr_user_init(data[0], strlen(name_list[0]) + 1, &key.f_1.name);
+ bpf_dynptr_user_init(data[1], strlen(name_list[1]) + 1, &key.f_3.name);
+ value = INIT_VALUE;
+ err = bpf_map_update_elem(fd, &key, &value, BPF_EXIST);
+ ASSERT_OK(err, "overwrite");
+ free(data[0]);
+ free(data[1]);
+
+ /* get_next_key */
+ bpf_dynptr_user_init(name[0], sizeof(name[0]), &next_key.f_1.name);
+ bpf_dynptr_user_init(name[1], sizeof(name[1]), &next_key.f_3.name);
+ err = bpf_map_get_next_key(fd, NULL, &next_key);
+ ASSERT_OK(err, "first get_next");
+
+ size = bpf_dynptr_user_size(&next_key.f_1.name);
+ data[0] = bpf_dynptr_user_data(&next_key.f_1.name);
+ if (ASSERT_EQ(size, strlen(name_list[0]) + 1, "f_1 size"))
+ ASSERT_TRUE(!memcmp(name_list[0], data[0], size), "f_1 data");
+ ASSERT_EQ(next_key.f_1.name.rsvd, 0, "f_1 rsvd");
+
+ ASSERT_EQ(next_key.f_2, 2, "f_2");
+
+ ASSERT_EQ(next_key.f_3.id, 3, "f_3 id");
+ size = bpf_dynptr_user_size(&next_key.f_3.name);
+ data[0] = bpf_dynptr_user_data(&next_key.f_3.name);
+ if (ASSERT_EQ(size, strlen(name_list[1]) + 1, "f_3 size"))
+ ASSERT_TRUE(!memcmp(name_list[1], data[0], size), "f_3 data");
+ ASSERT_EQ(next_key.f_3.name.rsvd, 0, "f_3 rsvd");
+
+ ASSERT_EQ(next_key.f_4, 4, "f_4");
+
+ cur_key = next_key;
+ bpf_dynptr_user_init(name[2], sizeof(name[2]), &next_key.f_1.name);
+ bpf_dynptr_user_init(name[3], sizeof(name[3]), &next_key.f_3.name);
+ err = bpf_map_get_next_key(fd, &cur_key, &next_key);
+ ASSERT_EQ(err, -ENOENT, "last get_next_key");
+}
+
+static void test_htab_dynptr_key(bool pure, bool multiple)
+{
+ struct htab_dynkey_test_success *skel;
+ struct bpf_program *prog;
+ int err;
+
+ skel = htab_dynkey_test_success__open();
+ if (!ASSERT_OK_PTR(skel, "open()"))
+ return;
+
+ prog = pure ? skel->progs.pure_dynptr_key :
+ (multiple ? skel->progs.multiple_dynptr_key : skel->progs.mixed_dynptr_key);
+ bpf_program__set_autoload(prog, true);
+
+ err = htab_dynkey_test_success__load(skel);
+ if (!ASSERT_OK(err, "load()"))
+ goto out;
+
+ if (pure) {
+ setup_pure_dynptr_key_map(bpf_map__fd(skel->maps.htab_1));
+ setup_pure_dynptr_key_map(bpf_map__fd(skel->maps.htab_2));
+ } else if (multiple) {
+ setup_multiple_dynptr_key_map(bpf_map__fd(skel->maps.htab_4));
+ } else {
+ setup_mixed_dynptr_key_map(bpf_map__fd(skel->maps.htab_3));
+ }
+
+ skel->bss->pid = getpid();
+
+ err = htab_dynkey_test_success__attach(skel);
+ if (!ASSERT_OK(err, "attach()"))
+ goto out;
+
+ usleep(1);
+
+ ASSERT_EQ(skel->bss->test_err, 0, "test");
+out:
+ htab_dynkey_test_success__destroy(skel);
+}
+
+void test_htab_dynkey_test(void)
+{
+ if (test__start_subtest("pure_dynptr_key"))
+ test_htab_dynptr_key(true, false);
+ if (test__start_subtest("mixed_dynptr_key"))
+ test_htab_dynptr_key(false, false);
+ if (test__start_subtest("multiple_dynptr_key"))
+ test_htab_dynptr_key(false, true);
+
+ RUN_TESTS(htab_dynkey_test_failure);
+}
new file mode 100644
@@ -0,0 +1,270 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (C) 2024. Huawei Technologies Co., Ltd */
+#include <linux/types.h>
+#include <linux/bpf.h>
+#include <bpf/bpf_helpers.h>
+#include <bpf/bpf_tracing.h>
+#include <errno.h>
+
+#include "bpf_misc.h"
+
+char _license[] SEC("license") = "GPL";
+
+struct bpf_map;
+
+struct id_dname_key {
+ int id;
+ struct bpf_dynptr name;
+};
+
+struct dname_id_key {
+ struct bpf_dynptr name;
+ int id;
+};
+
+struct id_name_key {
+ int id;
+ char name[20];
+};
+
+struct dname_key {
+ struct bpf_dynptr name;
+};
+
+struct dname_dname_key {
+ struct bpf_dynptr name_1;
+ struct bpf_dynptr name_2;
+};
+
+struct dname_dname_id_key {
+ struct dname_dname_key names;
+ __u64 id;
+};
+
+struct dname_id_id_id_key {
+ struct bpf_dynptr name;
+ __u64 id[3];
+};
+
+struct dname_dname_dname_key {
+ struct bpf_dynptr name_1;
+ struct bpf_dynptr name_2;
+ struct bpf_dynptr name_3;
+};
+
+struct {
+ __uint(type, BPF_MAP_TYPE_HASH);
+ __uint(max_entries, 10);
+ __uint(map_flags, BPF_F_NO_PREALLOC | BPF_F_DYNPTR_IN_KEY);
+ __type(key, struct id_dname_key);
+ __type(value, unsigned long);
+ __uint(map_extra, 1024);
+} htab_1 SEC(".maps");
+
+struct {
+ __uint(type, BPF_MAP_TYPE_HASH);
+ __uint(max_entries, 10);
+ __uint(map_flags, BPF_F_NO_PREALLOC | BPF_F_DYNPTR_IN_KEY);
+ __type(key, struct dname_key);
+ __type(value, unsigned long);
+ __uint(map_extra, 1024);
+} htab_2 SEC(".maps");
+
+struct {
+ __uint(type, BPF_MAP_TYPE_HASH);
+ __uint(max_entries, 10);
+ __uint(map_flags, BPF_F_NO_PREALLOC | BPF_F_DYNPTR_IN_KEY);
+ __type(key, struct dname_dname_id_key);
+ __type(value, unsigned long);
+ __uint(map_extra, 1024);
+} htab_3 SEC(".maps");
+
+struct {
+ __uint(type, BPF_MAP_TYPE_HASH);
+ __uint(max_entries, 10);
+ __uint(map_flags, BPF_F_NO_PREALLOC | BPF_F_DYNPTR_IN_KEY);
+ __type(key, struct bpf_dynptr);
+ __type(value, unsigned long);
+ __uint(map_extra, 1024);
+} htab_4 SEC(".maps");
+
+struct {
+ __uint(type, BPF_MAP_TYPE_RINGBUF);
+ __uint(max_entries, 4096);
+} ringbuf SEC(".maps");
+
+char dynptr_buf[32] = {};
+
+/* uninitialized dynptr */
+SEC("fentry/" SYS_PREFIX "sys_nanosleep")
+__failure __msg("dynptr-key expects dynptr at offset 8")
+int BPF_PROG(uninit_dynptr)
+{
+ struct id_dname_key key;
+
+ key.id = 100;
+ bpf_map_lookup_elem(&htab_1, &key);
+
+ return 0;
+}
+
+/* invalid dynptr */
+SEC("fentry/" SYS_PREFIX "sys_nanosleep")
+__failure __msg("dynptr-key expects dynptr at offset 8")
+int BPF_PROG(invalid_dynptr)
+{
+ struct id_dname_key key;
+
+ key.id = 100;
+ bpf_ringbuf_reserve_dynptr(&ringbuf, 10, 0, &key.name);
+ bpf_ringbuf_discard_dynptr(&key.name, 0);
+ bpf_map_lookup_elem(&htab_1, &key);
+
+ return 0;
+}
+
+/* expect no-dynptr got dynptr */
+SEC("fentry/" SYS_PREFIX "sys_nanosleep")
+__failure __msg("dynptr-key expects non-dynptr at offset 0")
+int BPF_PROG(invalid_non_dynptr)
+{
+ struct dname_id_key key;
+
+ __builtin_memcpy(dynptr_buf, "test", 4);
+ bpf_dynptr_from_mem(dynptr_buf, 4, 0, &key.name);
+ key.id = 100;
+ bpf_map_lookup_elem(&htab_1, &key);
+
+ return 0;
+}
+
+/* expect dynptr get non-dynptr */
+SEC("fentry/" SYS_PREFIX "sys_nanosleep")
+__failure __msg("dynptr-key expects dynptr at offset 8")
+int BPF_PROG(no_dynptr)
+{
+ struct id_name_key key;
+
+ key.id = 100;
+ __builtin_memset(key.name, 0, sizeof(key.name));
+ __builtin_memcpy(key.name, "test", 4);
+ bpf_map_lookup_elem(&htab_1, &key);
+
+ return 0;
+}
+
+/* malformed */
+SEC("fentry/" SYS_PREFIX "sys_nanosleep")
+__failure __msg("malformed dynptr-key at offset 8")
+int BPF_PROG(malformed_dynptr)
+{
+ struct dname_dname_key key;
+
+ bpf_dynptr_from_mem(dynptr_buf, 4, 0, &key.name_1);
+ bpf_dynptr_from_mem(dynptr_buf, 4, 0, &key.name_2);
+
+ bpf_map_lookup_elem(&htab_2, (void *)&key + 8);
+
+ return 0;
+}
+
+/* expect no-dynptr got dynptr */
+SEC("fentry/" SYS_PREFIX "sys_nanosleep")
+__failure __msg("dynptr-key expects non-dynptr at offset 32")
+int BPF_PROG(invalid_non_dynptr_2)
+{
+ struct dname_dname_dname_key key;
+
+ bpf_dynptr_from_mem(dynptr_buf, 4, 0, &key.name_1);
+ bpf_dynptr_from_mem(dynptr_buf, 4, 0, &key.name_2);
+ bpf_dynptr_from_mem(dynptr_buf, 4, 0, &key.name_3);
+
+ bpf_map_lookup_elem(&htab_3, &key);
+
+ return 0;
+}
+
+/* expect dynptr get non-dynptr */
+SEC("fentry/" SYS_PREFIX "sys_nanosleep")
+__failure __msg("dynptr-key expects dynptr at offset 16")
+int BPF_PROG(no_dynptr_2)
+{
+ struct dname_id_id_id_key key;
+
+ bpf_dynptr_from_mem(dynptr_buf, 4, 0, &key.name);
+ bpf_map_lookup_elem(&htab_3, &key);
+
+ return 0;
+}
+
+/* misaligned */
+SEC("fentry/" SYS_PREFIX "sys_nanosleep")
+__failure __msg("R2 misaligned offset -28 for dynptr-key")
+int BPF_PROG(misaligned_dynptr)
+{
+ struct dname_dname_key key;
+
+ bpf_map_lookup_elem(&htab_1, (char *)&key + 4);
+
+ return 0;
+}
+
+/* variable offset */
+SEC("fentry/" SYS_PREFIX "sys_nanosleep")
+__failure __msg("R2 variable offset prohibited for dynptr-key")
+int BPF_PROG(variable_offset_dynptr)
+{
+ struct bpf_dynptr dynptr_1;
+ struct bpf_dynptr dynptr_2;
+ char *key;
+
+ bpf_dynptr_from_mem(dynptr_buf, 4, 0, &dynptr_1);
+ bpf_dynptr_from_mem(dynptr_buf, 4, 0, &dynptr_2);
+
+ key = (char *)&dynptr_2;
+ key = key + (bpf_get_prandom_u32() & 1) * 16;
+
+ bpf_map_lookup_elem(&htab_2, key);
+
+ return 0;
+}
+
+SEC("fentry/" SYS_PREFIX "sys_nanosleep")
+__failure __msg("map dynptr-key requires stack ptr but got map_value")
+int BPF_PROG(map_value_as_key)
+{
+ bpf_map_lookup_elem(&htab_1, dynptr_buf);
+
+ return 0;
+}
+
+static int lookup_htab(struct bpf_map *map, struct id_dname_key *key, void *value, void *data)
+{
+ bpf_map_lookup_elem(&htab_1, key);
+ return 0;
+}
+
+SEC("fentry/" SYS_PREFIX "sys_nanosleep")
+__failure __msg("map dynptr-key requires stack ptr but got map_key")
+int BPF_PROG(map_key_as_key)
+{
+ bpf_for_each_map_elem(&htab_1, lookup_htab, NULL, 0);
+ return 0;
+}
+
+__noinline __weak int subprog_lookup_htab(struct bpf_dynptr *dynptr)
+{
+ bpf_map_lookup_elem(&htab_4, dynptr);
+ return 0;
+}
+
+SEC("fentry/" SYS_PREFIX "sys_nanosleep")
+__failure __msg("R2 type=dynptr_ptr expected=")
+int BPF_PROG(subprog_dynptr)
+{
+ struct bpf_dynptr dynptr;
+
+ bpf_dynptr_from_mem(dynptr_buf, 4, 0, &dynptr);
+ subprog_lookup_htab(&dynptr);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,399 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (C) 2024. Huawei Technologies Co., Ltd */
+#include <linux/types.h>
+#include <linux/bpf.h>
+#include <bpf/bpf_helpers.h>
+#include <bpf/bpf_tracing.h>
+#include <errno.h>
+
+#include "bpf_misc.h"
+
+char _license[] SEC("license") = "GPL";
+
+struct pure_dynptr_key {
+ struct bpf_dynptr name;
+};
+
+struct mixed_dynptr_key {
+ int id;
+ struct bpf_dynptr name;
+};
+
+struct multiple_dynptr_key {
+ struct pure_dynptr_key f_1;
+ unsigned long f_2;
+ struct mixed_dynptr_key f_3;
+ unsigned long f_4;
+};
+
+struct {
+ __uint(type, BPF_MAP_TYPE_HASH);
+ __uint(max_entries, 10);
+ __uint(map_flags, BPF_F_NO_PREALLOC | BPF_F_DYNPTR_IN_KEY);
+ __type(key, struct bpf_dynptr);
+ __type(value, unsigned long);
+ __uint(map_extra, 1024);
+} htab_1 SEC(".maps");
+
+struct {
+ __uint(type, BPF_MAP_TYPE_HASH);
+ __uint(max_entries, 10);
+ __uint(map_flags, BPF_F_NO_PREALLOC | BPF_F_DYNPTR_IN_KEY);
+ __type(key, struct pure_dynptr_key);
+ __type(value, unsigned long);
+ __uint(map_extra, 1024);
+} htab_2 SEC(".maps");
+
+struct {
+ __uint(type, BPF_MAP_TYPE_HASH);
+ __uint(max_entries, 10);
+ __uint(map_flags, BPF_F_NO_PREALLOC | BPF_F_DYNPTR_IN_KEY);
+ __type(key, struct mixed_dynptr_key);
+ __type(value, unsigned long);
+ __uint(map_extra, 1024);
+} htab_3 SEC(".maps");
+
+struct {
+ __uint(type, BPF_MAP_TYPE_HASH);
+ __uint(max_entries, 10);
+ __uint(map_flags, BPF_F_NO_PREALLOC | BPF_F_DYNPTR_IN_KEY);
+ __type(key, struct multiple_dynptr_key);
+ __type(value, unsigned long);
+ __uint(map_extra, 1024);
+} htab_4 SEC(".maps");
+
+struct {
+ __uint(type, BPF_MAP_TYPE_RINGBUF);
+ __uint(max_entries, 4096);
+} ringbuf SEC(".maps");
+
+int pid = 0;
+int test_err = 0;
+char dynptr_buf[2][32] = {{}, {}};
+
+static const char systemd_name[] = "systemd";
+static const char udevd_name[] = "udevd";
+static const char rcu_sched_name[] = "[rcu_sched]";
+
+struct bpf_map;
+
+static int test_pure_dynptr_key_htab(struct bpf_map *htab)
+{
+ unsigned long new_value, *value;
+ struct bpf_dynptr key;
+ int err = 0;
+
+ /* Lookup a existent key */
+ __builtin_memcpy(dynptr_buf[0], systemd_name, sizeof(systemd_name));
+ bpf_dynptr_from_mem(dynptr_buf[0], sizeof(systemd_name), 0, &key);
+ value = bpf_map_lookup_elem(htab, &key);
+ if (!value) {
+ err = 1;
+ goto out;
+ }
+ if (*value != 100) {
+ err = 2;
+ goto out;
+ }
+
+ /* Look up a non-existent key */
+ __builtin_memcpy(dynptr_buf[0], udevd_name, sizeof(udevd_name));
+ bpf_dynptr_from_mem(dynptr_buf[0], sizeof(udevd_name), 0, &key);
+ value = bpf_map_lookup_elem(htab, &key);
+ if (value) {
+ err = 3;
+ goto out;
+ }
+
+ /* Insert a new key */
+ new_value = 42;
+ err = bpf_map_update_elem(htab, &key, &new_value, BPF_NOEXIST);
+ if (err) {
+ err = 4;
+ goto out;
+ }
+
+ /* Insert an existent key */
+ bpf_ringbuf_reserve_dynptr(&ringbuf, sizeof(udevd_name), 0, &key);
+ err = bpf_dynptr_write(&key, 0, (void *)udevd_name, sizeof(udevd_name), 0);
+ if (err) {
+ bpf_ringbuf_discard_dynptr(&key, 0);
+ err = 5;
+ goto out;
+ }
+
+ err = bpf_map_update_elem(htab, &key, &new_value, BPF_NOEXIST);
+ bpf_ringbuf_discard_dynptr(&key, 0);
+ if (err != -EEXIST) {
+ err = 6;
+ goto out;
+ }
+
+ /* Lookup it again */
+ bpf_dynptr_from_mem(dynptr_buf[0], sizeof(udevd_name), 0, &key);
+ value = bpf_map_lookup_elem(htab, &key);
+ if (!value) {
+ err = 7;
+ goto out;
+ }
+ if (*value != 42) {
+ err = 8;
+ goto out;
+ }
+
+ /* Delete then lookup it */
+ bpf_ringbuf_reserve_dynptr(&ringbuf, sizeof(udevd_name), 0, &key);
+ err = bpf_dynptr_write(&key, 0, (void *)udevd_name, sizeof(udevd_name), 0);
+ if (err) {
+ bpf_ringbuf_discard_dynptr(&key, 0);
+ err = 9;
+ goto out;
+ }
+ err = bpf_map_delete_elem(htab, &key);
+ bpf_ringbuf_discard_dynptr(&key, 0);
+ if (err) {
+ err = 10;
+ goto out;
+ }
+
+ bpf_dynptr_from_mem(dynptr_buf[0], sizeof(udevd_name), 0, &key);
+ value = bpf_map_lookup_elem(htab, &key);
+ if (value) {
+ err = 10;
+ goto out;
+ }
+out:
+ return err;
+}
+
+static int test_mixed_dynptr_key_htab(struct bpf_map *htab)
+{
+ unsigned long new_value, *value;
+ char udevd_name[] = "udevd";
+ struct mixed_dynptr_key key;
+ int err = 0;
+
+ __builtin_memset(&key, 0, sizeof(key));
+ key.id = 1000;
+
+ /* Lookup a existent key */
+ __builtin_memcpy(dynptr_buf[0], systemd_name, sizeof(systemd_name));
+ bpf_dynptr_from_mem(dynptr_buf[0], sizeof(systemd_name), 0, &key.name);
+ value = bpf_map_lookup_elem(htab, &key);
+ if (!value) {
+ err = 1;
+ goto out;
+ }
+ if (*value != 100) {
+ err = 2;
+ goto out;
+ }
+
+ /* Look up a non-existent key */
+ __builtin_memcpy(dynptr_buf[0], udevd_name, sizeof(udevd_name));
+ bpf_dynptr_from_mem(dynptr_buf[0], sizeof(udevd_name), 0, &key.name);
+ value = bpf_map_lookup_elem(htab, &key);
+ if (value) {
+ err = 3;
+ goto out;
+ }
+
+ /* Insert a new key */
+ new_value = 42;
+ err = bpf_map_update_elem(htab, &key, &new_value, BPF_NOEXIST);
+ if (err) {
+ err = 4;
+ goto out;
+ }
+
+ /* Insert an existent key */
+ bpf_ringbuf_reserve_dynptr(&ringbuf, sizeof(udevd_name), 0, &key.name);
+ err = bpf_dynptr_write(&key.name, 0, (void *)udevd_name, sizeof(udevd_name), 0);
+ if (err) {
+ bpf_ringbuf_discard_dynptr(&key.name, 0);
+ err = 5;
+ goto out;
+ }
+
+ err = bpf_map_update_elem(htab, &key, &new_value, BPF_NOEXIST);
+ bpf_ringbuf_discard_dynptr(&key.name, 0);
+ if (err != -EEXIST) {
+ err = 6;
+ goto out;
+ }
+
+ /* Lookup it again */
+ bpf_dynptr_from_mem(dynptr_buf[0], sizeof(udevd_name), 0, &key.name);
+ value = bpf_map_lookup_elem(htab, &key);
+ if (!value) {
+ err = 7;
+ goto out;
+ }
+ if (*value != 42) {
+ err = 8;
+ goto out;
+ }
+
+ /* Delete then lookup it */
+ bpf_ringbuf_reserve_dynptr(&ringbuf, sizeof(udevd_name), 0, &key.name);
+ err = bpf_dynptr_write(&key.name, 0, (void *)udevd_name, sizeof(udevd_name), 0);
+ if (err) {
+ bpf_ringbuf_discard_dynptr(&key.name, 0);
+ err = 9;
+ goto out;
+ }
+ err = bpf_map_delete_elem(htab, &key);
+ bpf_ringbuf_discard_dynptr(&key.name, 0);
+ if (err) {
+ err = 10;
+ goto out;
+ }
+
+ bpf_dynptr_from_mem(dynptr_buf[0], sizeof(udevd_name), 0, &key.name);
+ value = bpf_map_lookup_elem(htab, &key);
+ if (value) {
+ err = 10;
+ goto out;
+ }
+out:
+ return err;
+}
+
+static int test_multiple_dynptr_key_htab(struct bpf_map *htab)
+{
+ unsigned long new_value, *value;
+ struct multiple_dynptr_key key;
+ int err = 0;
+
+ __builtin_memset(&key, 0, sizeof(key));
+ key.f_2 = 2;
+ key.f_3.id = 3;
+ key.f_4 = 4;
+
+ /* Lookup a existent key */
+ __builtin_memcpy(dynptr_buf[0], systemd_name, sizeof(systemd_name));
+ bpf_dynptr_from_mem(dynptr_buf[0], sizeof(systemd_name), 0, &key.f_1.name);
+ __builtin_memcpy(dynptr_buf[1], rcu_sched_name, sizeof(rcu_sched_name));
+ bpf_dynptr_from_mem(dynptr_buf[1], sizeof(rcu_sched_name), 0, &key.f_3.name);
+ value = bpf_map_lookup_elem(htab, &key);
+ if (!value) {
+ err = 1;
+ goto out;
+ }
+ if (*value != 100) {
+ err = 2;
+ goto out;
+ }
+
+ /* Look up a non-existent key */
+ bpf_dynptr_from_mem(dynptr_buf[1], sizeof(rcu_sched_name), 0, &key.f_1.name);
+ bpf_dynptr_from_mem(dynptr_buf[0], sizeof(systemd_name), 0, &key.f_3.name);
+ value = bpf_map_lookup_elem(htab, &key);
+ if (value) {
+ err = 3;
+ goto out;
+ }
+
+ /* Insert a new key */
+ new_value = 42;
+ err = bpf_map_update_elem(htab, &key, &new_value, BPF_NOEXIST);
+ if (err) {
+ err = 4;
+ goto out;
+ }
+
+ /* Insert an existent key */
+ bpf_ringbuf_reserve_dynptr(&ringbuf, sizeof(rcu_sched_name), 0, &key.f_1.name);
+ err = bpf_dynptr_write(&key.f_1.name, 0, (void *)rcu_sched_name, sizeof(rcu_sched_name), 0);
+ if (err) {
+ bpf_ringbuf_discard_dynptr(&key.f_1.name, 0);
+ err = 5;
+ goto out;
+ }
+ err = bpf_map_update_elem(htab, &key, &new_value, BPF_NOEXIST);
+ bpf_ringbuf_discard_dynptr(&key.f_1.name, 0);
+ if (err != -EEXIST) {
+ err = 6;
+ goto out;
+ }
+
+ /* Lookup a non-existent key */
+ bpf_dynptr_from_mem(dynptr_buf[1], sizeof(rcu_sched_name), 0, &key.f_1.name);
+ key.f_4 = 0;
+ value = bpf_map_lookup_elem(htab, &key);
+ if (value) {
+ err = 7;
+ goto out;
+ }
+
+ /* Lookup an existent key */
+ key.f_4 = 4;
+ value = bpf_map_lookup_elem(htab, &key);
+ if (!value) {
+ err = 8;
+ goto out;
+ }
+ if (*value != 42) {
+ err = 9;
+ goto out;
+ }
+
+ /* Delete the newly-inserted key */
+ bpf_ringbuf_reserve_dynptr(&ringbuf, sizeof(systemd_name), 0, &key.f_3.name);
+ err = bpf_dynptr_write(&key.f_3.name, 0, (void *)systemd_name, sizeof(systemd_name), 0);
+ if (err) {
+ bpf_ringbuf_discard_dynptr(&key.f_3.name, 0);
+ err = 10;
+ goto out;
+ }
+ err = bpf_map_delete_elem(htab, &key);
+ if (err) {
+ bpf_ringbuf_discard_dynptr(&key.f_3.name, 0);
+ err = 11;
+ goto out;
+ }
+
+ /* Lookup it again */
+ value = bpf_map_lookup_elem(htab, &key);
+ bpf_ringbuf_discard_dynptr(&key.f_3.name, 0);
+ if (value) {
+ err = 12;
+ goto out;
+ }
+out:
+ return err;
+}
+
+SEC("?fentry/" SYS_PREFIX "sys_nanosleep")
+int BPF_PROG(pure_dynptr_key)
+{
+ if (bpf_get_current_pid_tgid() >> 32 != pid)
+ return 0;
+
+ test_err = test_pure_dynptr_key_htab((struct bpf_map *)&htab_1);
+ test_err |= test_pure_dynptr_key_htab((struct bpf_map *)&htab_2) << 8;
+
+ return 0;
+}
+
+SEC("?fentry/" SYS_PREFIX "sys_nanosleep")
+int BPF_PROG(mixed_dynptr_key)
+{
+ if (bpf_get_current_pid_tgid() >> 32 != pid)
+ return 0;
+
+ test_err = test_mixed_dynptr_key_htab((struct bpf_map *)&htab_3);
+
+ return 0;
+}
+
+SEC("?fentry/" SYS_PREFIX "sys_nanosleep")
+int BPF_PROG(multiple_dynptr_key)
+{
+ if (bpf_get_current_pid_tgid() >> 32 != pid)
+ return 0;
+
+ test_err = test_multiple_dynptr_key_htab((struct bpf_map *)&htab_4);
+
+ return 0;
+}