PROG_TEST_RUN support for sk_lookup programs
Subsystems (7)
v3 cover PROG_TEST_RUN support for sk_lookup programs
We don't have PROG_TEST_RUN support for sk_lookup programs at the moment. So far this hasn't been a problem, since we can run our tests in a separate network namespace. For benchmarking it's nice to have PROG_TEST_RUN, so I've gone and implemented it.
Based on discussion on the v1 I've dropped support for testing multiple programs at once.
Changes since v2:
- Fix test_verifier failure (Alexei)
Changes since v1:
- Add sparse annotations to the t_* functions
- Add appropriate type casts in bpf_prog_test_run_sk_lookup
- Drop running multiple programs
Lorenz Bauer (5):
bpf: consolidate shared test timing code
bpf: add PROG_TEST_RUN support for sk_lookup programs
selftests: bpf: convert sk_lookup ctx access tests to PROG_TEST_RUN
selftests: bpf: check that PROG_TEST_RUN repeats as requested
selftests: bpf: don't run sk_lookup in verifier tests
include/linux/bpf.h | 10 + include/uapi/linux/bpf.h | 5 +- net/bpf/test_run.c | 246 +++++++++++++----- net/core/filter.c | 1 + tools/include/uapi/linux/bpf.h | 5 +- .../selftests/bpf/prog_tests/prog_run_xattr.c | 51 +++- .../selftests/bpf/prog_tests/sk_lookup.c | 83 ++++-- .../selftests/bpf/progs/test_sk_lookup.c | 62 +++-- tools/testing/selftests/bpf/test_verifier.c | 4 +- .../selftests/bpf/verifier/ctx_sk_lookup.c | 1 + 10 files changed, 356 insertions(+), 112 deletions(-)
Signature · 1 line
2.27.0
PATCH v3 1/5 bpf: consolidate shared test timing code
Share the timing / signal interruption logic between different implementations of PROG_TEST_RUN. There is a change in behaviour as well. We check the loop exit condition before checking for pending signals. This resolves an edge case where a signal arrives during the last iteration. Instead of aborting with EINTR we return the successful result to user space.
--- net/bpf/test_run.c | 141 +++++++++++++++++++++++++-------------------- 1 file changed, 78 insertions(+), 63 deletions(-)
net/bpf/test_run.c +78 -63
@@ -16,14 +16,78 @@#define CREATE_TRACE_POINTS #include <trace/events/bpf_test_run.h> +struct test_timer { +enum {NO_PREEMPT ,NO_MIGRATE } mode; +u32 i; +u64 time_start, time_spent; +}; + +static void t_enter (struct test_timer *t) +__acquires (rcu) +{ +rcu_read_lock (); +if (t->mode ==NO_PREEMPT ) +preempt_disable (); +else +migrate_disable (); + + t->time_start =ktime_get_ns (); +} + +static void t_leave (struct test_timer *t) +__releases (rcu) +{ + t->time_start =0 ; + +if (t->mode ==NO_PREEMPT ) +preempt_enable (); +else +migrate_enable (); +rcu_read_unlock (); +} + +static bool t_continue (struct test_timer *t,u32 repeat,int *err,u32 *duration) +__must_hold (rcu) +{ + t->i++; +if (t->i >= repeat) { +/* We're done. */ + t->time_spent +=ktime_get_ns () - t->time_start; +do_div (t->time_spent, t->i); + *duration = t->time_spent >U32_MAX ?U32_MAX : (u32 )t->time_spent; + *err =0 ; + goto reset; + } + +if (signal_pending (current)) { +/* During iteration: we've been cancelled, abort. */ + *err = -EINTR ; + goto reset; + } + +if (need_resched ()) { +/* During iteration: we need to reschedule between runs. */ + t->time_spent +=ktime_get_ns () - t->time_start; +t_leave (t); +cond_resched (); +t_enter (t); + } + +/* Do another round. */ +return true; + +reset: + t->i =0 ; +return false; +} +static int bpf_test_run (struct bpf_prog *prog,void *ctx,u32 repeat,u32 *retval,u32 *time,bool xdp) {struct bpf_cgroup_storage *storage[MAX_BPF_CGROUP_STORAGE_TYPE ] = {NULL }; +struct test_timer t = {NO_MIGRATE };enum bpf_cgroup_storage_type stype; -u64 time_start, time_spent =0 ; -int ret =0 ; -u32 i; +int ret;for_each_cgroup_storage_type (stype) { storage[stype] =bpf_cgroup_storage_alloc (prog, stype);
@@ -38,40 +102,16 @@ static int bpf_test_run(struct bpf_prog *prog, void *ctx, u32 repeat,if (!repeat) repeat =1 ; -rcu_read_lock (); -migrate_disable (); - time_start =ktime_get_ns (); -for (i =0 ; i < repeat; i++) { +t_enter (&t); +do {bpf_cgroup_storage_set (storage);if (xdp) *retval =bpf_prog_run_xdp (prog, ctx);else *retval =BPF_PROG_RUN (prog, ctx); - -if (signal_pending (current)) { - ret = -EINTR ; -break ; - } - -if (need_resched ()) { - time_spent +=ktime_get_ns () - time_start; -migrate_enable (); -rcu_read_unlock (); - -cond_resched (); - -rcu_read_lock (); -migrate_disable (); - time_start =ktime_get_ns (); - } - } - time_spent +=ktime_get_ns () - time_start; -migrate_enable (); -rcu_read_unlock (); - -do_div (time_spent, repeat); - *time = time_spent >U32_MAX ?U32_MAX : (u32 )time_spent; + }while (t_continue (&t, repeat, &ret, time)); +t_leave (&t);for_each_cgroup_storage_type (stype)bpf_cgroup_storage_free (storage[stype]);
@@ -674,18 +714,17 @@ int bpf_prog_test_run_flow_dissector(struct bpf_prog *prog,const union bpf_attr *kattr, union bpf_attr __user *uattr) { + struct test_timer t = { NO_PREEMPT };u32 size = kattr->test.data_size_in;struct bpf_flow_dissector ctx = {};u32 repeat = kattr->test.repeat;struct bpf_flow_keys *user_ctx;struct bpf_flow_keys flow_keys; -u64 time_start, time_spent =0 ;const struct ethhdr *eth;unsigned int flags =0 ;u32 retval, duration;void *data;int ret; -u32 i;if (prog->type !=BPF_PROG_TYPE_FLOW_DISSECTOR )return -EINVAL ;
@@ -721,39 +760,15 @@ int bpf_prog_test_run_flow_dissector(struct bpf_prog *prog, ctx.data = data; ctx.data_end = (__u8 *)data + size; -rcu_read_lock (); -preempt_disable (); - time_start =ktime_get_ns (); -for (i =0 ; i < repeat; i++) { +t_enter (&t); +do { retval =bpf_flow_dissect (prog, &ctx, eth->h_proto,ETH_HLEN , size, flags); + }while (t_continue (&t, repeat, &ret, &duration)); +t_leave (&t); -if (signal_pending (current)) { -preempt_enable (); -rcu_read_unlock (); - - ret = -EINTR ; - goto out; - } - -if (need_resched ()) { - time_spent +=ktime_get_ns () - time_start; -preempt_enable (); -rcu_read_unlock (); - -cond_resched (); - -rcu_read_lock (); -preempt_disable (); - time_start =ktime_get_ns (); - } - } - time_spent +=ktime_get_ns () - time_start; -preempt_enable (); -rcu_read_unlock (); - -do_div (time_spent, repeat); - duration = time_spent >U32_MAX ?U32_MAX : (u32 )time_spent; +if (ret <0 ) + goto out; ret =bpf_test_finish (kattr, uattr, &flow_keys,sizeof (flow_keys), retval, duration);
Signature · 1 line
2.27.0
Re: [PATCH bpf-next v3 1/5] bpf: consolidate shared test timing code
Quoted 18 lines · Lorenz Bauer
Share the timing / signal interruption logic between different implementations of
PROG_TEST_RUN. There is a change in behaviour as well. We check the loop exit condition before checking for pending signals. This resolves an edge case where a signal arrives during the last iteration. Instead of aborting with EINTR we return the successful result to user space.Signed-off-by Lorenz Bauer <[email protected]>--- net/bpf/test_run.c | 141 +++++++++++++++++++++++++-------------------- 1 file changed, 78 insertions(+), 63 deletions(-)net/bpf/test_run.c +0
-0
net/bpf/test_run.c line 19
Quoted 4 lines
net/bpf/test_run.c +1
-0@@ -16,14 +16,78 @@#define CREATE_TRACE_POINTS #include <trace/events/bpf_test_run.h> +struct test_timer {
nit: super generic name, I'd add bpf_ prefix throughout (bpf_test_timer, bpf_test_timer_enter, bpf_test_timer_leave, and so on)
Quoted 5 lines
net/bpf/test_run.c +5
-0+enum {NO_PREEMPT ,NO_MIGRATE } mode; +u32 i; +u64 time_start, time_spent; +}; +
[...]
PATCH v3 2/5 bpf: add PROG_TEST_RUN support for sk_lookup programs
In reply to Lorenz BauerAllow to pass sk_lookup programs to PROG_TEST_RUN. User space provides the full bpf_sk_lookup struct as context. Since the context includes a socket pointer that can't be exposed to user space we define that PROG_TEST_RUN returns the cookie of the selected socket or zero in place of the socket pointer.
We don't support testing programs that select a reuseport socket, since this would mean running another (unrelated) BPF program from the sk_lookup test handler.
--- include/linux/bpf.h | 10 ++++ include/uapi/linux/bpf.h | 5 +- net/bpf/test_run.c | 105 +++++++++++++++++++++++++++++++++ net/core/filter.c | 1 + tools/include/uapi/linux/bpf.h | 5 +- 5 files changed, 124 insertions(+), 2 deletions(-)
include/linux/bpf.h +10 -0
@@ -1491,6 +1491,9 @@ int bpf_prog_test_run_flow_dissector(struct bpf_prog *prog,int bpf_prog_test_run_raw_tp (struct bpf_prog *prog,const union bpf_attr *kattr,union bpf_attr __user *uattr); +int bpf_prog_test_run_sk_lookup (struct bpf_prog *prog, +const union bpf_attr *kattr, +union bpf_attr __user *uattr);bool btf_ctx_access (int off,int size,enum bpf_access_type type,const struct bpf_prog *prog,struct bpf_insn_access_aux *info);
@@ -1692,6 +1695,13 @@ static inline int bpf_prog_test_run_flow_dissector(struct bpf_prog *prog,return -ENOTSUPP ; } +static inline int bpf_prog_test_run_sk_lookup (struct bpf_prog *prog, +const union bpf_attr *kattr, +union bpf_attr __user *uattr) +{ +return -ENOTSUPP ; +} +static inline void bpf_map_put (struct bpf_map *map) { }
include/uapi/linux/bpf.h +4 -1
@@ -5243,7 +5243,10 @@ struct bpf_pidns_info {/* User accessible data for SK_LOOKUP programs. Add new fields at the end. */ struct bpf_sk_lookup { - __bpf_md_ptr(struct bpf_sock *, sk); /* Selected socket */ +union { + __bpf_md_ptr(struct bpf_sock *, sk); /* Selected socket */ +__u64 cookie;/* Non-zero if socket was selected in PROG_TEST_RUN */ + };__u32 family;/* Protocol family (AF_INET, AF_INET6) */ __u32 protocol;/* IP protocol (IPPROTO_TCP, IPPROTO_UDP) */
net/bpf/test_run.c +105 -0
116 lines not on this page · raw message
net/core/filter.c +1 -0
@@ -10457,6 +10457,7 @@ static u32 sk_lookup_convert_ctx_access(enum bpf_access_type type, }const struct bpf_prog_ops sk_lookup_prog_ops = { + .test_run = bpf_prog_test_run_sk_lookup, };const struct bpf_verifier_ops sk_lookup_verifier_ops = {
tools/include/uapi/linux/bpf.h +4 -1
@@ -5243,7 +5243,10 @@ struct bpf_pidns_info {/* User accessible data for SK_LOOKUP programs. Add new fields at the end. */ struct bpf_sk_lookup { - __bpf_md_ptr(struct bpf_sock *, sk); /* Selected socket */ +union { + __bpf_md_ptr(struct bpf_sock *, sk); /* Selected socket */ +__u64 cookie;/* Non-zero if socket was selected in PROG_TEST_RUN */ + };__u32 family;/* Protocol family (AF_INET, AF_INET6) */ __u32 protocol;/* IP protocol (IPPROTO_TCP, IPPROTO_UDP) */
Signature · 1 line
2.27.0
PATCH v3 3/5 selftests: bpf: convert sk_lookup ctx access tests to PROG_TEST_RUN
In reply to Lorenz BauerConvert the selftests for sk_lookup narrow context access to use PROG_TEST_RUN instead of creating actual sockets. This ensures that ctx is populated correctly when using PROG_TEST_RUN.
Assert concrete values since we now control remote_ip and remote_port.
--- .../selftests/bpf/prog_tests/sk_lookup.c | 83 +++++++++++++++---- .../selftests/bpf/progs/test_sk_lookup.c | 62 +++++++++----- 2 files changed, 109 insertions(+), 36 deletions(-)
tools/testing/selftests/bpf/prog_tests/sk_lookup.c +68 -15
@@ -241,6 +241,48 @@ static int make_client(int sotype, const char *ip, int port)return -1 ; } +static __u64 socket_cookie (int fd) +{ +__u64 cookie; +socklen_t cookie_len =sizeof (cookie); + +if (CHECK (getsockopt (fd,SOL_SOCKET ,SO_COOKIE , &cookie, &cookie_len) <0 , +"getsockopt(SO_COOKIE)" ,"%s\n" ,strerror (errno))) +return 0 ; +return cookie; +} + +static int fill_sk_lookup_ctx (struct bpf_sk_lookup *ctx,const char *local_ip,__u16 local_port, +const char *remote_ip,__u16 remote_port) +{ +void *local, *remote; +int err; + +memset (ctx,0 ,sizeof (*ctx)); + ctx->local_port = local_port; + ctx->remote_port =htons (remote_port); + +if (is_ipv6 (local_ip)) { + ctx->family =AF_INET6 ; + local = &ctx->local_ip6[0 ]; + remote = &ctx->remote_ip6[0 ]; + }else { + ctx->family =AF_INET ; + local = &ctx->local_ip4; + remote = &ctx->remote_ip4; + } + + err =inet_pton (ctx->family, local_ip, local); +if (CHECK (err !=1 ,"inet_pton" ,"local_ip failed\n" )) +return 1 ; + + err =inet_pton (ctx->family, remote_ip, remote); +if (CHECK (err !=1 ,"inet_pton" ,"remote_ip failed\n" )) +return 1 ; + +return 0 ; +} +static int send_byte (int fd) {ssize_t n;
@@ -1009,18 +1051,27 @@ static void test_drop_on_reuseport(struct test_sk_lookup *skel)static void run_sk_assign (struct test_sk_lookup *skel,struct bpf_program *lookup_prog, -const char *listen_ip,const char *connect_ip) +const char *remote_ip,const char *local_ip) { -int client_fd, peer_fd, server_fds[MAX_SERVERS ] = {-1 }; -struct bpf_link *lookup_link; +int server_fds[MAX_SERVERS ] = {-1 }; +struct bpf_sk_lookup ctx; +__u64 server_cookie;int i, err; - lookup_link =attach_lookup_prog (lookup_prog); -if (!lookup_link) +DECLARE_LIBBPF_OPTS (bpf_test_run_opts, opts, + .ctx_in = &ctx, + .ctx_size_in = sizeof(ctx), + .ctx_out = &ctx, + .ctx_size_out = sizeof(ctx), + ); + +if (fill_sk_lookup_ctx (&ctx, local_ip,EXT_PORT , remote_ip,INT_PORT ))return ; + ctx.protocol =IPPROTO_TCP ; +for (i =0 ; i <ARRAY_SIZE (server_fds); i++) { - server_fds[i] =make_server (SOCK_STREAM , listen_ip,0 ,NULL ); + server_fds[i] =make_server (SOCK_STREAM , local_ip,0 ,NULL );if (server_fds[i] <0 ) goto close_servers;
@@ -1030,23 +1081,25 @@ static void run_sk_assign(struct test_sk_lookup *skel, goto close_servers; } - client_fd =make_client (SOCK_STREAM , connect_ip,EXT_PORT ); -if (client_fd <0 ) + server_cookie =socket_cookie (server_fds[SERVER_B ]); +if (!server_cookie) +return ; + + err =bpf_prog_test_run_opts (bpf_program__fd (lookup_prog), &opts); +if (CHECK (err,"test_run" ,"failed with error %d\n" , errno)) + goto close_servers; + +if (CHECK (ctx.cookie ==0 ,"ctx.cookie" ,"no socket selected\n" )) goto close_servers; - peer_fd =accept (server_fds[SERVER_B ],NULL ,NULL ); -if (CHECK (peer_fd <0 ,"accept" ,"failed\n" )) - goto close_client; +CHECK (ctx.cookie != server_cookie,"ctx.cookie" , +"selected sk %llu instead of %llu\n" , ctx.cookie, server_cookie); -close (peer_fd); -close_client: -close (client_fd); close_servers:for (i =0 ; i <ARRAY_SIZE (server_fds); i++) {if (server_fds[i] !=-1 )close (server_fds[i]); } -bpf_link__destroy (lookup_link); } static void run_sk_assign_v4(struct test_sk_lookup *skel,
tools/testing/selftests/bpf/progs/test_sk_lookup.c +41 -21
89 lines not on this page · raw message
Signature · 1 line
2.27.0
PATCH v3 4/5 selftests: bpf: check that PROG_TEST_RUN repeats as requested
In reply to Lorenz BauerExtend a simple prog_run test to check that PROG_TEST_RUN adheres to the requested repetitions. Convert it to use BPF skeleton.
--- .../selftests/bpf/prog_tests/prog_run_xattr.c | 51 +++++++++++++++---- 1 file changed, 42 insertions(+), 9 deletions(-)
tools/testing/selftests/bpf/prog_tests/prog_run_xattr.c +42 -9
@@ -2,12 +2,31 @@#include <test_progs.h> #include <network_helpers.h> -void test_prog_run_xattr (void ) +#include "test_pkt_access.skel.h" + +static const __u32 duration; + +static void check_run_cnt (int prog_fd,__u64 run_cnt) { -const char *file ="./test_pkt_access.o" ; -struct bpf_object *obj; -char buf[10 ]; +struct bpf_prog_info info = {}; +__u32 info_len =sizeof (info);int err; + + err =bpf_obj_get_info_by_fd (prog_fd, &info, &info_len); +if (CHECK (err,"get_prog_info" ,"failed to get bpf_prog_info for fd %d\n" , prog_fd)) +return ; + +CHECK (run_cnt != info.run_cnt,"run_cnt" , +"incorrect number of repetitions, want %llu have %llu\n" , run_cnt, info.run_cnt); +} + +void test_prog_run_xattr (void ) +{ +struct test_pkt_access *skel; +int err, stats_fd =-1 ; +char buf[10 ] = {}; +__u64 run_cnt =0 ; +struct bpf_prog_test_run_attr tattr = { .repeat =1 , .data_in = &pkt_v4,
@@ -16,12 +35,15 @@ void test_prog_run_xattr(void) .data_size_out = 5, }; - err =bpf_prog_load (file,BPF_PROG_TYPE_SCHED_CLS , &obj, - &tattr.prog_fd); -if (CHECK_ATTR (err,"load" ,"err %d errno %d\n" , err, errno)) + stats_fd =bpf_enable_stats (BPF_STATS_RUN_TIME ); +if (CHECK_ATTR (stats_fd <0 ,"enable_stats" ,"failed %d\n" , errno))return ; -memset (buf,0 ,sizeof (buf)); + skel =test_pkt_access__open_and_load (); +if (CHECK_ATTR (!skel,"open_and_load" ,"failed\n" )) + goto cleanup; + + tattr.prog_fd =bpf_program__fd (skel->progs.test_pkt_access); err =bpf_prog_test_run_xattr (&tattr); CHECK_ATTR(err != -1 || errno != ENOSPC || tattr.retval, "run",
@@ -34,8 +56,12 @@ void test_prog_run_xattr(void)CHECK_ATTR (buf[5 ] !=0 ,"overflow" ,"BPF_PROG_TEST_RUN ignored size hint\n" ); + run_cnt += tattr.repeat; +check_run_cnt (tattr.prog_fd, run_cnt); + tattr.data_out =NULL ; tattr.data_size_out =0 ; + tattr.repeat =2 ; errno =0 ; err =bpf_prog_test_run_xattr (&tattr);
@@ -46,5 +72,12 @@ void test_prog_run_xattr(void) err =bpf_prog_test_run_xattr (&tattr);CHECK_ATTR (err != -EINVAL ,"run_wrong_size_out" ,"err %d\n" , err); -bpf_object__close (obj); + run_cnt += tattr.repeat; +check_run_cnt (tattr.prog_fd, run_cnt); + +cleanup: +if (skel) +test_pkt_access__destroy (skel); +if (stats_fd !=-1 ) +close (stats_fd); }
Signature · 1 line
2.27.0
PATCH v3 5/5 selftests: bpf: don't run sk_lookup in verifier tests
In reply to Lorenz Bauersk_lookup doesn't allow setting data_in for bpf_prog_run. This doesn't play well with the verifier tests, since they always set a 64 byte input buffer. Allow not running verifier tests by setting bpf_test.runs to a negative value and don't run the ctx access case for sk_lookup. We have dedicated ctx access tests so skipping here doesn't reduce coverage.
--- tools/testing/selftests/bpf/test_verifier.c | 4 ++-- tools/testing/selftests/bpf/verifier/ctx_sk_lookup.c | 1 + 2 files changed, 3 insertions(+), 2 deletions(-)
tools/testing/selftests/bpf/test_verifier.c +2 -2
@@ -105,7 +105,7 @@ struct bpf_test {enum bpf_prog_type prog_type;uint8_t flags;void (*fill_helper)(struct bpf_test *self); -uint8_t runs; +int runs;#define bpf_testdata_struct_t \ struct { \ uint32_t retval, retval_unpriv; \
@@ -1165,7 +1165,7 @@ static void do_test_single(struct bpf_test *test, bool unpriv, run_errs =0 ; run_successes =0 ; -if (!alignment_prevented_execution && fd_prog >=0 ) { +if (!alignment_prevented_execution && fd_prog >=0 && test->runs >=0 ) {uint32_t expected_val;int i;
tools/testing/selftests/bpf/verifier/ctx_sk_lookup.c +1 -0
@@ -239,6 +239,7 @@ .result = ACCEPT, .prog_type = BPF_PROG_TYPE_SK_LOOKUP, .expected_attach_type = BPF_SK_LOOKUP, + .runs = -1, },/* invalid 8-byte reads from a 4-byte fields in bpf_sk_lookup */ {
Signature · 1 line
2.27.0