development and testing of networking bpf programs is quite cumbersome. Despite availability of user space bpf interpreters the kernel is the ultimate authority and execution environment. Current test frameworks for TC include creation of netns, veth, qdiscs and use of various packet generators just to test functionality of a bpf program. XDP testing is even more complicated, since qemu needs to be started with gro/gso disabled and precise queue configuration, transferring of xdp program from host into guest, attaching to virtio/eth0 and generating traffic from the host while capturing the results from the guest. Moreover analyzing performance bottlenecks in XDP program is impossible in virtio environment, since cost of running the program is tiny comparing to the overhead of virtio packet processing, so performance testing can only be done on physical nic with another server generating traffic. Furthermore ongoing changes to user space control plane of production applications cannot be run on the test servers leaving bpf programs stubbed out for testing. Last but not least, the upstream llvm changes are validated by the bpf backend testsuite which has no ability to test the code generated. To improve this situation introduce BPF_PROG_TEST_RUN command to test and performance benchmark bpf programs. Joint work with Daniel Borkmann. Signed-off-by: Alexei Starovoitov <ast@kernel.org> Acked-by: Daniel Borkmann <daniel@iogearbox.net> Acked-by: Martin KaFai Lau <kafai@fb.com> Signed-off-by: David S. Miller <davem@davemloft.net>tirimbino
Alexei Starovoitov
8 years ago
committed by
David S. Miller
parent
98cd1552ea
commit
1cf1cae963
@ -0,0 +1 @@ |
||||
obj-y := test_run.o
|
||||
@ -0,0 +1,172 @@ |
||||
/* Copyright (c) 2017 Facebook
|
||||
* |
||||
* This program is free software; you can redistribute it and/or |
||||
* modify it under the terms of version 2 of the GNU General Public |
||||
* License as published by the Free Software Foundation. |
||||
*/ |
||||
#include <linux/bpf.h> |
||||
#include <linux/slab.h> |
||||
#include <linux/vmalloc.h> |
||||
#include <linux/etherdevice.h> |
||||
#include <linux/filter.h> |
||||
#include <linux/sched/signal.h> |
||||
|
||||
static __always_inline u32 bpf_test_run_one(struct bpf_prog *prog, void *ctx) |
||||
{ |
||||
u32 ret; |
||||
|
||||
preempt_disable(); |
||||
rcu_read_lock(); |
||||
ret = BPF_PROG_RUN(prog, ctx); |
||||
rcu_read_unlock(); |
||||
preempt_enable(); |
||||
|
||||
return ret; |
||||
} |
||||
|
||||
static u32 bpf_test_run(struct bpf_prog *prog, void *ctx, u32 repeat, u32 *time) |
||||
{ |
||||
u64 time_start, time_spent = 0; |
||||
u32 ret = 0, i; |
||||
|
||||
if (!repeat) |
||||
repeat = 1; |
||||
time_start = ktime_get_ns(); |
||||
for (i = 0; i < repeat; i++) { |
||||
ret = bpf_test_run_one(prog, ctx); |
||||
if (need_resched()) { |
||||
if (signal_pending(current)) |
||||
break; |
||||
time_spent += ktime_get_ns() - time_start; |
||||
cond_resched(); |
||||
time_start = ktime_get_ns(); |
||||
} |
||||
} |
||||
time_spent += ktime_get_ns() - time_start; |
||||
do_div(time_spent, repeat); |
||||
*time = time_spent > U32_MAX ? U32_MAX : (u32)time_spent; |
||||
|
||||
return ret; |
||||
} |
||||
|
||||
static int bpf_test_finish(union bpf_attr __user *uattr, const void *data, |
||||
u32 size, u32 retval, u32 duration) |
||||
{ |
||||
void __user *data_out = u64_to_user_ptr(uattr->test.data_out); |
||||
int err = -EFAULT; |
||||
|
||||
if (data_out && copy_to_user(data_out, data, size)) |
||||
goto out; |
||||
if (copy_to_user(&uattr->test.data_size_out, &size, sizeof(size))) |
||||
goto out; |
||||
if (copy_to_user(&uattr->test.retval, &retval, sizeof(retval))) |
||||
goto out; |
||||
if (copy_to_user(&uattr->test.duration, &duration, sizeof(duration))) |
||||
goto out; |
||||
err = 0; |
||||
out: |
||||
return err; |
||||
} |
||||
|
||||
static void *bpf_test_init(const union bpf_attr *kattr, u32 size, |
||||
u32 headroom, u32 tailroom) |
||||
{ |
||||
void __user *data_in = u64_to_user_ptr(kattr->test.data_in); |
||||
void *data; |
||||
|
||||
if (size < ETH_HLEN || size > PAGE_SIZE - headroom - tailroom) |
||||
return ERR_PTR(-EINVAL); |
||||
|
||||
data = kzalloc(size + headroom + tailroom, GFP_USER); |
||||
if (!data) |
||||
return ERR_PTR(-ENOMEM); |
||||
|
||||
if (copy_from_user(data + headroom, data_in, size)) { |
||||
kfree(data); |
||||
return ERR_PTR(-EFAULT); |
||||
} |
||||
return data; |
||||
} |
||||
|
||||
int bpf_prog_test_run_skb(struct bpf_prog *prog, const union bpf_attr *kattr, |
||||
union bpf_attr __user *uattr) |
||||
{ |
||||
bool is_l2 = false, is_direct_pkt_access = false; |
||||
u32 size = kattr->test.data_size_in; |
||||
u32 repeat = kattr->test.repeat; |
||||
u32 retval, duration; |
||||
struct sk_buff *skb; |
||||
void *data; |
||||
int ret; |
||||
|
||||
data = bpf_test_init(kattr, size, NET_SKB_PAD, |
||||
SKB_DATA_ALIGN(sizeof(struct skb_shared_info))); |
||||
if (IS_ERR(data)) |
||||
return PTR_ERR(data); |
||||
|
||||
switch (prog->type) { |
||||
case BPF_PROG_TYPE_SCHED_CLS: |
||||
case BPF_PROG_TYPE_SCHED_ACT: |
||||
is_l2 = true; |
||||
/* fall through */ |
||||
case BPF_PROG_TYPE_LWT_IN: |
||||
case BPF_PROG_TYPE_LWT_OUT: |
||||
case BPF_PROG_TYPE_LWT_XMIT: |
||||
is_direct_pkt_access = true; |
||||
break; |
||||
default: |
||||
break; |
||||
} |
||||
|
||||
skb = build_skb(data, 0); |
||||
if (!skb) { |
||||
kfree(data); |
||||
return -ENOMEM; |
||||
} |
||||
|
||||
skb_reserve(skb, NET_SKB_PAD); |
||||
__skb_put(skb, size); |
||||
skb->protocol = eth_type_trans(skb, current->nsproxy->net_ns->loopback_dev); |
||||
skb_reset_network_header(skb); |
||||
|
||||
if (is_l2) |
||||
__skb_push(skb, ETH_HLEN); |
||||
if (is_direct_pkt_access) |
||||
bpf_compute_data_end(skb); |
||||
retval = bpf_test_run(prog, skb, repeat, &duration); |
||||
if (!is_l2) |
||||
__skb_push(skb, ETH_HLEN); |
||||
size = skb->len; |
||||
/* bpf program can never convert linear skb to non-linear */ |
||||
if (WARN_ON_ONCE(skb_is_nonlinear(skb))) |
||||
size = skb_headlen(skb); |
||||
ret = bpf_test_finish(uattr, skb->data, size, retval, duration); |
||||
kfree_skb(skb); |
||||
return ret; |
||||
} |
||||
|
||||
int bpf_prog_test_run_xdp(struct bpf_prog *prog, const union bpf_attr *kattr, |
||||
union bpf_attr __user *uattr) |
||||
{ |
||||
u32 size = kattr->test.data_size_in; |
||||
u32 repeat = kattr->test.repeat; |
||||
struct xdp_buff xdp = {}; |
||||
u32 retval, duration; |
||||
void *data; |
||||
int ret; |
||||
|
||||
data = bpf_test_init(kattr, size, XDP_PACKET_HEADROOM, 0); |
||||
if (IS_ERR(data)) |
||||
return PTR_ERR(data); |
||||
|
||||
xdp.data_hard_start = data; |
||||
xdp.data = data + XDP_PACKET_HEADROOM; |
||||
xdp.data_end = xdp.data + size; |
||||
|
||||
retval = bpf_test_run(prog, &xdp, repeat, &duration); |
||||
if (xdp.data != data + XDP_PACKET_HEADROOM) |
||||
size = xdp.data_end - xdp.data; |
||||
ret = bpf_test_finish(uattr, xdp.data, size, retval, duration); |
||||
kfree(data); |
||||
return ret; |
||||
} |
||||
Loading…
Reference in new issue