bpf: fix ktls panic and add tests
Subsystems (6)
cover bpf: fix ktls panic and add tests
We can reproduce the issue using the existing test program:
'test_sockmap --ktls'
Or use the selftest I provided, which will cause a panic:
[ 2172.936997] ------------[ cut here ]------------ [ 2172.936999] kernel BUG at lib/iov_iter.c:629! ...... [ 2172.944996] PKRU: 55555554 [ 2172.945155] Call Trace: [ 2172.945299] <TASK> [ 2172.945428] ? die+0x36/0x90 [ 2172.945601] ? do_trap+0xdd/0x100 [ 2172.945795] ? iov_iter_revert+0x178/0x180 [ 2172.946031] ? iov_iter_revert+0x178/0x180 [ 2172.946267] ? do_error_trap+0x7d/0x110 [ 2172.946499] ? iov_iter_revert+0x178/0x180 [ 2172.946736] ? exc_invalid_op+0x50/0x70 [ 2172.946961] ? iov_iter_revert+0x178/0x180 [ 2172.947197] ? asm_exc_invalid_op+0x1a/0x20 [ 2172.947446] ? iov_iter_revert+0x178/0x180 [ 2172.947683] ? iov_iter_revert+0x5c/0x180 [ 2172.947913] tls_sw_sendmsg_locked.isra.0+0x794/0x840 [ 2172.948206] tls_sw_sendmsg+0x52/0x80 [ 2172.948420] ? inet_sendmsg+0x1f/0x70 [ 2172.948634] __sys_sendto+0x1cd/0x200 [ 2172.948848] ? find_held_lock+0x2b/0x80 [ 2172.949072] ? syscall_trace_enter+0x140/0x270 [ 2172.949330] ? __lock_release.isra.0+0x5e/0x170 [ 2172.949595] ? find_held_lock+0x2b/0x80 [ 2172.949817] ? syscall_trace_enter+0x140/0x270 [ 2172.950211] ? lockdep_hardirqs_on_prepare+0xda/0x190 [ 2172.950632] ? ktime_get_coarse_real_ts64+0xc2/0xd0 [ 2172.951036] __x64_sys_sendto+0x24/0x30 [ 2172.951382] do_syscall_64+0x90/0x170
1. It looks like the issue started occurring after I bounding ktls and bpf together, and the addition of assertions to iov_iter has caused a panic. If my fix tag is incorrect, please assist me in correcting the fix tag.
2. I make minimal changes for now, and if there are other reasons that cause similar panics, we can revisit later. For now, this fix should be sufficient.
Jiayuan Chen (2):
bpf: fix ktls panic
selftests/bpf: add ktls selftest
net/tls/tls_sw.c | 8 +- .../selftests/bpf/prog_tests/sockmap_ktls.c | 175 +++++++++++++++++- .../selftests/bpf/progs/test_sockmap_ktls.c | 26 +++ 3 files changed, 205 insertions(+), 4 deletions(-) create mode 100644 tools/testing/selftests/bpf/progs/test_sockmap_ktls.c
Signature · 1 line
2.43.5
PATCH 1/2 bpf: fix ktls panic
[ 2172.936997] ------------[ cut here ]------------ [ 2172.936999] kernel BUG at lib/iov_iter.c:629! ...... [ 2172.944996] PKRU: 55555554 [ 2172.945155] Call Trace: [ 2172.945299] <TASK> [ 2172.945428] ? die+0x36/0x90 [ 2172.945601] ? do_trap+0xdd/0x100 [ 2172.945795] ? iov_iter_revert+0x178/0x180 [ 2172.946031] ? iov_iter_revert+0x178/0x180 [ 2172.946267] ? do_error_trap+0x7d/0x110 [ 2172.946499] ? iov_iter_revert+0x178/0x180 [ 2172.946736] ? exc_invalid_op+0x50/0x70 [ 2172.946961] ? iov_iter_revert+0x178/0x180 [ 2172.947197] ? asm_exc_invalid_op+0x1a/0x20 [ 2172.947446] ? iov_iter_revert+0x178/0x180 [ 2172.947683] ? iov_iter_revert+0x5c/0x180 [ 2172.947913] tls_sw_sendmsg_locked.isra.0+0x794/0x840 [ 2172.948206] tls_sw_sendmsg+0x52/0x80 [ 2172.948420] ? inet_sendmsg+0x1f/0x70 [ 2172.948634] __sys_sendto+0x1cd/0x200 [ 2172.948848] ? find_held_lock+0x2b/0x80 [ 2172.949072] ? syscall_trace_enter+0x140/0x270 [ 2172.949330] ? __lock_release.isra.0+0x5e/0x170 [ 2172.949595] ? find_held_lock+0x2b/0x80 [ 2172.949817] ? syscall_trace_enter+0x140/0x270 [ 2172.950211] ? lockdep_hardirqs_on_prepare+0xda/0x190 [ 2172.950632] ? ktime_get_coarse_real_ts64+0xc2/0xd0 [ 2172.951036] __x64_sys_sendto+0x24/0x30 [ 2172.951382] do_syscall_64+0x90/0x170
......
After calling bpf_exec_tx_verdict(), the size of msg_pl->sg may increase, e.g., when the BPF program executes bpf_msg_push_data().
If the BPF program sets cork_bytes and sg.size is smaller than cork_bytes, it will return -ENOSPC and attempt to roll back to the non-zero copy logic. However, during rollback, msg->msg_iter is reset, but since msg_pl->sg.size has been increased, subsequent executions will exceed the actual size of msg_iter.
'''iov_iter_revert(&msg->msg_iter, msg_pl->sg.size - orig_size); '''
The changes in this commit are based on the following considerations:
1. When cork_bytes is set, rolling back to non-zero copy logic is pointless and can directly go to zero-copy logic.
2. Suppose sg.size is initially 5, and we push it to 100, setting apply_bytes to 7. Then, 98 bytes of data are sent out, leaving 2 bytes to be processed. The rollback logic cannot determine which data has been processed and which hasn't.
This current change is based on the principle of minimal modification, which won't make things worse. If we still encounter similar panic further, we can consider a more comprehensive solution.
--- net/tls/tls_sw.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
net/tls/tls_sw.c +6 -2
@@ -1120,9 +1120,13 @@ static int tls_sw_sendmsg_locked(struct sock *sk, struct msghdr *msg, num_async++; else if (ret == -ENOMEM) goto wait_for_memory; - else if (ctx->open_rec && ret == -ENOSPC) + else if (ctx->open_rec && ret == -ENOSPC) { +if (msg_pl->cork_bytes) { + ret =0 ; + goto send_end; + } goto rollback_iter; - else if (ret != -EAGAIN) + } else if (ret != -EAGAIN) goto send_end; }continue ;
Signature · 1 line
2.43.5
John Fastabend
maintainerRe: [PATCH bpf v1 1/2] bpf: fix ktls panic
Quoted 46 lines · Jiayuan Chen
[ 2172.936997] ------------[ cut here ]------------ [ 2172.936999] kernel BUG at lib/iov_iter.c:629! ...... [ 2172.944996] PKRU: 55555554 [ 2172.945155] Call Trace: [ 2172.945299] <TASK> [ 2172.945428] ? die+0x36/0x90 [ 2172.945601] ? do_trap+0xdd/0x100 [ 2172.945795] ? iov_iter_revert+0x178/0x180 [ 2172.946031] ? iov_iter_revert+0x178/0x180 [ 2172.946267] ? do_error_trap+0x7d/0x110 [ 2172.946499] ? iov_iter_revert+0x178/0x180 [ 2172.946736] ? exc_invalid_op+0x50/0x70 [ 2172.946961] ? iov_iter_revert+0x178/0x180 [ 2172.947197] ? asm_exc_invalid_op+0x1a/0x20 [ 2172.947446] ? iov_iter_revert+0x178/0x180 [ 2172.947683] ? iov_iter_revert+0x5c/0x180 [ 2172.947913] tls_sw_sendmsg_locked.isra.0+0x794/0x840 [ 2172.948206] tls_sw_sendmsg+0x52/0x80 [ 2172.948420] ? inet_sendmsg+0x1f/0x70 [ 2172.948634] __sys_sendto+0x1cd/0x200 [ 2172.948848] ? find_held_lock+0x2b/0x80 [ 2172.949072] ? syscall_trace_enter+0x140/0x270 [ 2172.949330] ? __lock_release.isra.0+0x5e/0x170 [ 2172.949595] ? find_held_lock+0x2b/0x80 [ 2172.949817] ? syscall_trace_enter+0x140/0x270 [ 2172.950211] ? lockdep_hardirqs_on_prepare+0xda/0x190 [ 2172.950632] ? ktime_get_coarse_real_ts64+0xc2/0xd0 [ 2172.951036] __x64_sys_sendto+0x24/0x30 [ 2172.951382] do_syscall_64+0x90/0x170......
After calling
bpf_exec_tx_verdict(), the size ofmsg_pl->sgmay increase, e.g., when the BPF program executesbpf_msg_push_data().If the BPF program sets
cork_bytesand sg.size is smaller thancork_bytes, it will return-ENOSPCand attempt to roll back to the non-zero copy logic. However, during rollback,msg->msg_iteris reset, but sincemsg_pl->sg.sizehas been increased, subsequent executions will exceed the actual size ofmsg_iter.
'''iov_iter_revert(&msg->msg_iter, msg_pl->sg.size - orig_size); '''The changes in this commit are based on the following considerations:
Quoted 7 lines
1. When
cork_bytesis set, rolling back to non-zero copy logic is pointless and can directly go to zero-copy logic.2. Suppose sg.size is initially 5, and we push it to 100, setting
apply_bytesto 7. Then, 98 bytes of data are sent out, leaving 2 bytes to be processed. The rollback logic cannot determine which data has been processed and which hasn't.
This is the error path we are talking about correct?
if (msg->cork_bytes && msg->cork_bytes > msg->sg.size &&
!enospc && !full_record) {
err = -ENOSPC;
goto out_err;
}Quoted 17 lines
This current change is based on the principle of minimal modification, which won't make things worse. If we still encounter similar panic further, we can consider a more comprehensive solution.
Fixes fcb14cb1bdac ("new iov_iter flavour - ITER_UBUF")Fixes d3b18ad31f93 ("tls: add bpf support to sk_msg handling")Signed-off-by Jiayuan Chen <[email protected]>--- net/tls/tls_sw.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)net/tls/tls_sw.c +0
-0
net/tls/tls_sw.c static int tls_sw_sendmsg_locked(struct sock *sk, struct msghdr *msg, · line 1127
Quoted 9 lines
net/tls/tls_sw.c +5
-1@@ -1120,9 +1120,13 @@ static int tls_sw_sendmsg_locked(struct sock *sk, struct msghdr *msg, num_async++; else if (ret == -ENOMEM) goto wait_for_memory; - else if (ctx->open_rec && ret == -ENOSPC) + else if (ctx->open_rec && ret == -ENOSPC) { +if (msg_pl->cork_bytes) { + ret =0 ; + goto send_end; + }
The app will lose bytes here I suspect if we return copied == try_to_copy then no error makes it to the user?
Could we return delta from bpf_exec_tx_verdict and then we can calculate the correct number of bytes to revert? I'll need to check but its not clear to me if BPF program pushes data that the right thing is done with delta there now.
Thanks for looking into this.
Re: [PATCH bpf v1 1/2] bpf: fix ktls panic
Quoted 11 lines · John Fastabend
Quoted 9 lines · Jiayuan Chen
[ 2172.936997] ------------[ cut here ]------------ [ 2172.936999] kernel BUG at lib/iov_iter.c:629!......
pointless and can directly go to zero-copy logic.2. Suppose sg.size is initially 5, and we push it to 100, setting
apply_bytesto 7. Then, 98 bytes of data are sent out, leaving 2 bytes to be processed. The rollback logic cannot determine which data has been processed and which hasn't.
Quoted 8 lines
This is the error path we are talking about correct?
if (msg->cork_bytes && msg->cork_bytes > msg->sg.size && !enospc && !full_record) { err = -ENOSPC; goto out_err; }
yes, it its.
Quoted 10 lines
Quoted 10 lines
net/tls/tls_sw.c +0
-1@@ -1120,9 +1120,13 @@ static int tls_sw_sendmsg_locked(struct sock *sk, struct msghdr *msg, num_async++; else if (ret == -ENOMEM) goto wait_for_memory; - else if (ctx->open_rec && ret == -ENOSPC)
Quoted 8 lines
net/tls/tls_sw.c static int tls_sw_sendmsg_locked(struct sock *sk, struct msghdr *msg, · line 1127
Quoted 5 lines
net/tls/tls_sw.c +5
-0+else if (ctx->open_rec && ret == -ENOSPC ) { +if (msg_pl->cork_bytes) { + ret =0 ; + goto send_end; + }The app will lose bytes here I suspect if we return copied ==
try_to_copythen no error makes it to the user?
I looked into the corking logic for non-TLS sockets in tcp_bpf_sendmsg, and I found that when a "cork" situation occurs, the user-space send doesn't return an error, and the returned length is the same as the input length parameter, even if some data is cached. I think TLS should also behave similarly.
Additionally, I saw that the current non-zero-copy logic for handling corking is written as:
'''
line 1177
else if (ret != -EAGAIN) {
if (ret == -ENOSPC)
ret = 0;
goto send_end;
}'''
Meanwhile, I set cork_bytes to 1 and tested the following behavior logic:
'''send(msg, 1);send(msg+1, 1);send(msg+2, remain_length);
'''
Both the sender and receiver seem to be working normally both for TLS and non-TLS sockets.
Quoted 6 lines
Could we return delta from
bpf_exec_tx_verdictand then we can calculate the correct number of bytes to revert? I'll need to check but its not clear to me if BPF program pushes data that the right thing is done with delta there now.Thanks for looking into this.
Let's assume the original data is "abcdefgh" (8 bytes), and after 3 pushes by the BPF program, it becomes 11-byte data: "abc?de?fgh?".
Then, we set cork_bytes to 6, which means the first 6 bytes have been processed, and the remaining 5 bytes "?fgh?" will be cached until the length meets the cork_bytes requirement.
However, some data in "?fgh?" is not within 'sg->msg_iter' (but in msg_pl instead), especially the data "?" we pushed.
So it doesn't seem as simple as just reverting through an offset of msg_iter. It appears that 'msg_iter' and 'msg_pl' are two separate objects, and the BPF program modifies the scatterlist within the msg_pl.
--
Thanks.
Re: [PATCH bpf v1 1/2] bpf: fix ktls panic
Quoted 84 lines · Jiayuan Chen
Quoted 11 lines · John Fastabend
Quoted 9 lines · Jiayuan Chen
[ 2172.936997] ------------[ cut here ]------------ [ 2172.936999] kernel BUG at lib/iov_iter.c:629!......
pointless and can directly go to zero-copy logic.2. Suppose sg.size is initially 5, and we push it to 100, setting
apply_bytesto 7. Then, 98 bytes of data are sent out, leaving 2 bytes to be processed. The rollback logic cannot determine which data has been processed and which hasn't.Quoted 8 lines
This is the error path we are talking about correct?
if (msg->cork_bytes && msg->cork_bytes > msg->sg.size && !enospc && !full_record) { err = -ENOSPC; goto out_err; }yes, it its.
Quoted 10 lines
Quoted 10 lines
net/tls/tls_sw.c +0
-1@@ -1120,9 +1120,13 @@ static int tls_sw_sendmsg_locked(struct sock *sk, struct msghdr *msg, num_async++; else if (ret == -ENOMEM) goto wait_for_memory; - else if (ctx->open_rec && ret == -ENOSPC)Quoted 8 lines
net/tls/tls_sw.c static int tls_sw_sendmsg_locked(struct sock *sk, struct msghdr *msg, · line 1127
Quoted 5 lines
net/tls/tls_sw.c +5
-0+else if (ctx->open_rec && ret == -ENOSPC ) { +if (msg_pl->cork_bytes) { + ret =0 ; + goto send_end; + }The app will lose bytes here I suspect if we return copied ==
try_to_copythen no error makes it to the user?I looked into the corking logic for non-TLS sockets in
tcp_bpf_sendmsg, and I found that when a "cork" situation occurs, the user-space send doesn't return an error, and the returned length is the same as the input length parameter, even if some data is cached. I think TLS should also behave similarly.Additionally, I saw that the current non-zero-copy logic for handling corking is written as:
'''
line 1177else if (ret != -EAGAIN) { if (ret == -ENOSPC) ret = 0; goto send_end; }'''
Meanwhile, I set
cork_bytesto 1 and tested the following behavior logic:
'''send(msg, 1);send(msg+1, 1);send(msg+2, remain_length);
'''
Both the sender and receiver seem to be working normally both for TLS and non-TLS sockets.Quoted 6 lines
Could we return delta from
bpf_exec_tx_verdictand then we can calculate the correct number of bytes to revert? I'll need to check but its not clear to me if BPF program pushes data that the right thing is done with delta there now.Thanks for looking into this.
Let's assume the original data is "abcdefgh" (8 bytes), and after 3 pushes by the BPF program, it becomes 11-byte data: "abc?de?fgh?".
Then, we set
cork_bytesto 6, which means the first 6 bytes have been processed, and the remaining 5 bytes "?fgh?" will be cached until the length meets thecork_bytesrequirement.However, some data in "?fgh?" is not within '
sg->msg_iter' (but inmsg_plinstead), especially the data "?" we pushed.
Quoted 7 lines
So it doesn't seem as simple as just reverting through an offset of
msg_iter. It appears that 'msg_iter' and 'msg_pl' are two separate objects, and the BPF program modifies the scatterlist within themsg_pl.--
Thanks.
Hi John
Just checking in on the status of my patch. If there's any new feedback, I'm happy to move forward with the next steps.
Regards.
PATCH 2/2 selftests/bpf: add ktls selftest
In reply to Jiayuan Chenadd ktls selftest
--- .../selftests/bpf/prog_tests/sockmap_ktls.c | 175 +++++++++++++++++- .../selftests/bpf/progs/test_sockmap_ktls.c | 26 +++ 2 files changed, 199 insertions(+), 2 deletions(-) create mode 100644 tools/testing/selftests/bpf/progs/test_sockmap_ktls.c
tools/testing/selftests/bpf/prog_tests/sockmap_ktls.c +173 -2
@@ -3,13 +3,64 @@/* * Tests for sockmap/sockhash holding kTLS sockets. */ - +#include <error.h> #include <netinet/tcp.h> +#include <linux/tls.h> #include "test_progs.h" +#include "sockmap_helpers.h" +#include "test_skmsg_load_helpers.skel.h" +#include "test_sockmap_ktls.skel.h" #define MAX_TEST_NAME 80#define TCP_ULP 31 +static int init_ktls_pairs (int c,int p) +{ +int err; +struct tls12_crypto_info_aes_gcm_128 crypto_rx; +struct tls12_crypto_info_aes_gcm_128 crypto_tx; + + err =setsockopt (c,IPPROTO_TCP ,TCP_ULP ,"tls" ,strlen ("tls" )); +if (!ASSERT_OK (err,"setsockopt(TCP_ULP)" )) + goto out; + + err =setsockopt (p,IPPROTO_TCP ,TCP_ULP ,"tls" ,strlen ("tls" )); +if (!ASSERT_OK (err,"setsockopt(TCP_ULP)" )) + goto out; + +memset (&crypto_rx,0 ,sizeof (crypto_rx)); +memset (&crypto_tx,0 ,sizeof (crypto_tx)); + crypto_rx.info.version =TLS_1_2_VERSION ; + crypto_tx.info.version =TLS_1_2_VERSION ; + crypto_rx.info.cipher_type =TLS_CIPHER_AES_GCM_128 ; + crypto_tx.info.cipher_type =TLS_CIPHER_AES_GCM_128 ; + + err =setsockopt (c,SOL_TLS ,TLS_TX , &crypto_tx,sizeof (crypto_tx)); +if (!ASSERT_OK (err,"setsockopt(TLS_TX)" )) + goto out; + + err =setsockopt (p,SOL_TLS ,TLS_RX , &crypto_rx,sizeof (crypto_rx)); +if (!ASSERT_OK (err,"setsockopt(TLS_RX)" )) + goto out; +return 0 ; +out: +return -1 ; +} + +static int create_ktls_pairs (int family,int sotype,int *c,int *p) +{ +int err; + + err =create_pair (family, sotype, c, p); +if (!ASSERT_OK (err,"create_pair()" )) +return -1 ; + + err =init_ktls_pairs (*c, *p); +if (!ASSERT_OK (err,"init_ktls_pairs(c, p)" )) +return -1 ; +return 0 ; +} +static int tcp_server (int family) {int err, s;
@@ -146,6 +197,115 @@ static const char *fmt_test_name(const char *subtest_name, int family,return test_name; } +static void test_sockmap_ktls_offload (int family,int sotype) +{ +int err; +int c =0 , p =0 , sent, recvd; +char msg[12 ] ="hello world\0" ; +char rcv[13 ]; + + err =create_ktls_pairs (family, sotype, &c, &p); +if (!ASSERT_OK (err,"create_ktls_pairs()" )) + goto out; + + sent =send (c, msg,sizeof (msg),0 ); +if (!ASSERT_OK (err,"send(msg)" )) + goto out; + + recvd =recv (p, rcv,sizeof (rcv),0 ); +if (!ASSERT_OK (err,"recv(msg)" ) || + !ASSERT_EQ (recvd, sent,"length mismatch" )) + goto out; + +ASSERT_OK (memcmp (msg, rcv,sizeof (msg)),"data mismatch" ); + +out: +if (c) +close (c); +if (p) +close (p); +} + +static void test_sockmap_ktls_tx_cork (int family,int sotype,bool push) +{ +int err, off; +int i, j; +int start_push =0 , push_len =0 ; +int c =0 , p =0 , one =1 , sent, recvd; +int prog_fd, map_fd; +char msg[12 ] ="hello world\0" ; +char rcv[20 ] = {0 }; +struct test_sockmap_ktls *skel; + + 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; + + prog_fd =bpf_program__fd (skel->progs.prog_sk_policy); + 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 =init_ktls_pairs (c, p); +if (!ASSERT_OK (err,"init_ktls_pairs(c, p)" )) + goto out; + + skel->bss->cork_byte =sizeof (msg); +if (push) { + start_push =1 ; + push_len =2 ; + } + skel->bss->push_start = start_push; + skel->bss->push_end = push_len; + + off =sizeof (msg) /2 ; + sent =send (c, msg, off,0 ); +if (!ASSERT_EQ (sent, off,"send(msg)" )) + goto out; + + recvd =recv_timeout (p, rcv,sizeof (rcv),MSG_DONTWAIT ,1 ); +if (!ASSERT_EQ (-1 , recvd,"expected no data" )) + goto out; + +/* send remaining msg */ + sent =send (c, msg + off,sizeof (msg) - off,0 ); +if (!ASSERT_EQ (sent,sizeof (msg) - off,"send remaining data" )) + goto out; + + recvd =recv_timeout (p, rcv,sizeof (rcv),MSG_DONTWAIT ,1 ); +if (!ASSERT_OK (err,"recv(msg)" ) || + !ASSERT_EQ (recvd,sizeof (msg) + push_len,"check length mismatch" )) + goto out; + +for (i =0 , j =0 ; i < recvd;) { +/* skip checking the data that has been pushed in */ +if (i >= start_push && i <= start_push + push_len -1 ) { + i++; +continue ; + } +if (!ASSERT_EQ (rcv[i], msg[j],"data mismatch" )) + goto out; + i++; + j++; + } +out: +if (c) +close (c); +if (p) +close (p); +test_sockmap_ktls__destroy (skel); +} +static void run_tests (int family,enum bpf_map_type map_type) {int map;
@@ -158,14 +318,25 @@ static void run_tests(int family, enum bpf_map_type map_type)test_sockmap_ktls_disconnect_after_delete (family, map);if (test__start_subtest (fmt_test_name ("update_fails_when_sock_has_ulp" , family, map_type)))test_sockmap_ktls_update_fails_when_sock_has_ulp (family, map); -close (map); } +static void run_ktls_test (int family,int sotype) +{ +if (test__start_subtest ("tls simple offload" )) +test_sockmap_ktls_offload (family, sotype); +if (test__start_subtest ("tls tx cork" )) +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); +} +void test_sockmap_ktls (void ) {run_tests (AF_INET ,BPF_MAP_TYPE_SOCKMAP );run_tests (AF_INET ,BPF_MAP_TYPE_SOCKHASH );run_tests (AF_INET6 ,BPF_MAP_TYPE_SOCKMAP );run_tests (AF_INET6 ,BPF_MAP_TYPE_SOCKHASH ); +run_ktls_test (AF_INET ,SOCK_STREAM ); +run_ktls_test (AF_INET6 ,SOCK_STREAM ); }
tools/testing/selftests/bpf/progs/test_sockmap_ktls.c new file +26 -0
@@ -0,0 +1,26 @@ +// SPDX-License-Identifier: GPL-2.0 +#include <linux/bpf.h> +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_endian.h> + +int cork_byte; +int push_start; +int push_end; + +struct { + __uint(type, BPF_MAP_TYPE_SOCKMAP); + __uint(max_entries, 20); + __type(key, int); + __type(value, int); +} sock_map SEC(".maps"); + +SEC("sk_msg") +int prog_sk_policy (struct sk_msg_md *msg) +{ +if (cork_byte >0 ) +bpf_msg_cork_bytes (msg, cork_byte); +if (push_start >0 && push_end >0 ) +bpf_msg_push_data (msg, push_start, push_end,0 ); + +return SK_PASS ; +}
Signature · 1 line
2.43.5