selftests/bpf: Add test to cover sockmap with ktls

The selftest can reproduce an issue where we miss the uncharge operation
when freeing msg, which will cause the following warning. We fixed the
issue and added this reproducer to selftest to ensure it will not happen
again.

------------[ cut here ]------------
WARNING: CPU: 1 PID: 40 at net/ipv4/af_inet.c inet_sock_destruct+0x173/0x1d5
Tainted: [W]=WARN
Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.15.0-1 04/01/2014
Workqueue: events sk_psock_destroy
RIP: 0010:inet_sock_destruct+0x173/0x1d5
RSP: 0018:ffff8880085cfc18 EFLAGS: 00010202
RAX: 1ffff11003dbfc00 RBX: ffff88801edfe3e8 RCX: ffffffff822f5af4
RDX: 0000000000000007 RSI: dffffc0000000000 RDI: ffff88801edfe16c
RBP: ffff88801edfe184 R08: ffffed1003dbfc31 R09: 0000000000000000
R10: ffffffff822f5ab7 R11: ffff88801edfe187 R12: ffff88801edfdec0
R13: ffff888020376ac0 R14: ffff888020376ac0 R15: ffff888020376a60
CS:  0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 0000556365155830 CR3: 000000001d6aa000 CR4: 0000000000350ef0
Call Trace:
 <TASK>
 __sk_destruct+0x46/0x222
 sk_psock_destroy+0x22f/0x242
 process_one_work+0x504/0x8a8
 ? process_one_work+0x39d/0x8a8
 ? __pfx_process_one_work+0x10/0x10
 ? worker_thread+0x44/0x2ae
 ? __list_add_valid_or_report+0x83/0xea
 ? srso_return_thunk+0x5/0x5f
 ? __list_add+0x45/0x52
 process_scheduled_works+0x73/0x82
 worker_thread+0x1ce/0x2ae

Acked-by: John Fastabend <john.fastabend@gmail.com>
Signed-off-by: Jiayuan Chen <jiayuan.chen@linux.dev>
Signed-off-by: Martin KaFai Lau <martin.lau@kernel.org>
Link: https://lore.kernel.org/r/20250425060015.6968-3-jiayuan.chen@linux.dev

diff --git a/tools/testing/selftests/bpf/prog_tests/sockmap_ktls.c b/tools/testing/selftests/bpf/prog_tests/sockmap_ktls.c
index 3044f54..b6c471d 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/sockmap_ktls.c
+++ b/tools/testing/selftests/bpf/prog_tests/sockmap_ktls.c
@@ -240,6 +240,80 @@ out:
        test_sockmap_ktls__destroy(skel);
 }
 
+static void test_sockmap_ktls_tx_no_buf(int family, int sotype, bool push)
+{
+       int c = -1, p = -1, one = 1, two = 2;
+       struct test_sockmap_ktls *skel;
+       unsigned char *data = NULL;
+       struct msghdr msg = {0};
+       struct iovec iov[2];
+       int prog_fd, map_fd;
+       int txrx_buf = 1024;
+       int iov_length = 8192;
+       int err;
+
+       skel = test_sockmap_ktls__open_and_load();
+       if (!ASSERT_TRUE(skel, "open ktls skel"))
+               return;
+
+       err = create_pair(family, sotype, &c, &p);
+       if (!ASSERT_OK(err, "create_pair()"))
+               goto out;
+
+       err = setsockopt(c, SOL_SOCKET, SO_RCVBUFFORCE, &txrx_buf, sizeof(int));
+       err |= setsockopt(p, SOL_SOCKET, SO_SNDBUFFORCE, &txrx_buf, sizeof(int));
+       if (!ASSERT_OK(err, "set buf limit"))
+               goto out;
+
+       prog_fd = bpf_program__fd(skel->progs.prog_sk_policy_redir);
+       map_fd = bpf_map__fd(skel->maps.sock_map);
+
+       err = bpf_prog_attach(prog_fd, map_fd, BPF_SK_MSG_VERDICT, 0);
+       if (!ASSERT_OK(err, "bpf_prog_attach sk msg"))
+               goto out;
+
+       err = bpf_map_update_elem(map_fd, &one, &c, BPF_NOEXIST);
+       if (!ASSERT_OK(err, "bpf_map_update_elem(c)"))
+               goto out;
+
+       err = bpf_map_update_elem(map_fd, &two, &p, BPF_NOEXIST);
+       if (!ASSERT_OK(err, "bpf_map_update_elem(p)"))
+               goto out;
+
+       skel->bss->apply_bytes = 1024;
+
+       err = init_ktls_pairs(c, p);
+       if (!ASSERT_OK(err, "init_ktls_pairs(c, p)"))
+               goto out;
+
+       data = calloc(iov_length, sizeof(char));
+       if (!data)
+               goto out;
+
+       iov[0].iov_base = data;
+       iov[0].iov_len = iov_length;
+       iov[1].iov_base = data;
+       iov[1].iov_len = iov_length;
+       msg.msg_iov = iov;
+       msg.msg_iovlen = 2;
+
+       for (;;) {
+               err = sendmsg(c, &msg, MSG_DONTWAIT);
+               if (err <= 0)
+                       break;
+       }
+
+out:
+       if (data)
+               free(data);
+       if (c != -1)
+               close(c);
+       if (p != -1)
+               close(p);
+
+       test_sockmap_ktls__destroy(skel);
+}
+
 static void run_tests(int family, enum bpf_map_type map_type)
 {
        int map;
@@ -262,6 +336,8 @@ static void run_ktls_test(int family, int sotype)
                test_sockmap_ktls_tx_cork(family, sotype, false);
        if (test__start_subtest("tls tx cork with push"))
                test_sockmap_ktls_tx_cork(family, sotype, true);
+       if (test__start_subtest("tls tx egress with no buf"))
+               test_sockmap_ktls_tx_no_buf(family, sotype, true);
 }
 
 void test_sockmap_ktls(void)

diff --git a/tools/testing/selftests/bpf/progs/test_sockmap_ktls.c b/tools/testing/selftests/bpf/progs/test_sockmap_ktls.c
index e0f7579..8bdb998 100644 (file)
--- a/tools/testing/selftests/bpf/progs/test_sockmap_ktls.c
+++ b/tools/testing/selftests/bpf/progs/test_sockmap_ktls.c
@@ -6,6 +6,7 @@
 int cork_byte;
 int push_start;
 int push_end;
+int apply_bytes;
 
 struct {
        __uint(type, BPF_MAP_TYPE_SOCKMAP);
@@ -24,3 +25,12 @@ int prog_sk_policy(struct sk_msg_md *msg)
 
        return SK_PASS;
 }
+
+SEC("sk_msg")
+int prog_sk_policy_redir(struct sk_msg_md *msg)
+{
+       int two = 2;
+
+       bpf_msg_apply_bytes(msg, apply_bytes);
+       return bpf_msg_redirect_map(msg, &sock_map, two, 0);
+}