From patchwork Wed Jul 15 19:51:29 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Dmitry Yakunin X-Patchwork-Id: 1329776 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=23.128.96.18; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=yandex-team.ru Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=yandex-team.ru header.i=@yandex-team.ru header.a=rsa-sha256 header.s=default header.b=M8u32IFf; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by ozlabs.org (Postfix) with ESMTP id 4B6ShF3rHNz9sQt for ; Thu, 16 Jul 2020 05:51:57 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727946AbgGOTv4 (ORCPT ); Wed, 15 Jul 2020 15:51:56 -0400 Received: from forwardcorp1o.mail.yandex.net ([95.108.205.193]:53772 "EHLO forwardcorp1o.mail.yandex.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727772AbgGOTvx (ORCPT ); Wed, 15 Jul 2020 15:51:53 -0400 Received: from sas1-ec30c78b6c5b.qloud-c.yandex.net (sas1-ec30c78b6c5b.qloud-c.yandex.net [IPv6:2a02:6b8:c14:2704:0:640:ec30:c78b]) by forwardcorp1o.mail.yandex.net (Yandex) with ESMTP id AA0E62E15A2; Wed, 15 Jul 2020 22:51:46 +0300 (MSK) Received: from sas2-32987e004045.qloud-c.yandex.net (sas2-32987e004045.qloud-c.yandex.net [2a02:6b8:c08:b889:0:640:3298:7e00]) by sas1-ec30c78b6c5b.qloud-c.yandex.net (mxbackcorp/Yandex) with ESMTP id ygtTt1OuJS-pjsitabv; Wed, 15 Jul 2020 22:51:46 +0300 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=yandex-team.ru; s=default; t=1594842706; bh=RqA/HLcXXgTxGuzX8fzlAU37sCNS2YzPNEWNreLozuU=; h=In-Reply-To:Message-Id:References:Date:Subject:To:From:Cc; b=M8u32IFfIhlf7mQol6zyT5CN4tNb0WHOrt4KkpYpRItay8ms4THitW451kqyNU1IV yZswZp5klceFOYzebyBTmhw203JRMNz/xXw/6UrHxHm2dijhwgYRheT9QmhzHKI7w7 5Ffh4pbrOTG0rBA8gIRx3tV9nzkoDAkp0yVEICeQ= Authentication-Results: sas1-ec30c78b6c5b.qloud-c.yandex.net; dkim=pass header.i=@yandex-team.ru Received: from 37.9.121.196-vpn.dhcp.yndx.net (37.9.121.196-vpn.dhcp.yndx.net [37.9.121.196]) by sas2-32987e004045.qloud-c.yandex.net (smtpcorp/Yandex) with ESMTPSA id kLmvqU3zdD-pjiKcoAL; Wed, 15 Jul 2020 22:51:45 +0300 (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (Client certificate not present) From: Dmitry Yakunin To: alexei.starovoitov@gmail.com, daniel@iogearbox.net, netdev@vger.kernel.org, bpf@vger.kernel.org Cc: sdf@google.com Subject: [PATCH bpf-next v3 1/4] bpf: setup socket family and addresses in bpf_prog_test_run_skb Date: Wed, 15 Jul 2020 22:51:29 +0300 Message-Id: <20200715195132.4286-2-zeil@yandex-team.ru> In-Reply-To: <20200715195132.4286-1-zeil@yandex-team.ru> References: <20200715195132.4286-1-zeil@yandex-team.ru> MIME-Version: 1.0 Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Now it's impossible to test all branches of cgroup_skb bpf program which accesses skb->family and skb->{local,remote}_ip{4,6} fields because they are zeroed during socket allocation. This commit fills socket family and addresses from related fields in constructed skb. v2: - fix build without CONFIG_IPV6 (kernel test robot ) Signed-off-by: Dmitry Yakunin --- net/bpf/test_run.c | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/net/bpf/test_run.c b/net/bpf/test_run.c index bfd4ccd..0c3283d 100644 --- a/net/bpf/test_run.c +++ b/net/bpf/test_run.c @@ -432,6 +432,23 @@ int bpf_prog_test_run_skb(struct bpf_prog *prog, const union bpf_attr *kattr, skb->protocol = eth_type_trans(skb, current->nsproxy->net_ns->loopback_dev); skb_reset_network_header(skb); + switch (skb->protocol) { + case htons(ETH_P_IP): + sk->sk_family = AF_INET; + sk->sk_rcv_saddr = ip_hdr(skb)->saddr; + sk->sk_daddr = ip_hdr(skb)->daddr; + break; +#if IS_ENABLED(CONFIG_IPV6) + case htons(ETH_P_IPV6): + sk->sk_family = AF_INET6; + sk->sk_v6_rcv_saddr = ipv6_hdr(skb)->saddr; + sk->sk_v6_daddr = ipv6_hdr(skb)->daddr; + break; +#endif + default: + break; + } + if (is_l2) __skb_push(skb, hh_len); if (is_direct_pkt_access) From patchwork Wed Jul 15 19:51:30 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Dmitry Yakunin X-Patchwork-Id: 1329775 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Original-To: incoming-bpf@patchwork.ozlabs.org Delivered-To: patchwork-incoming-bpf@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=23.128.96.18; helo=vger.kernel.org; envelope-from=bpf-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=yandex-team.ru Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=yandex-team.ru header.i=@yandex-team.ru header.a=rsa-sha256 header.s=default header.b=AM5HUUwf; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by ozlabs.org (Postfix) with ESMTP id 4B6ShC275cz9sQt for ; Thu, 16 Jul 2020 05:51:55 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727788AbgGOTvw (ORCPT ); Wed, 15 Jul 2020 15:51:52 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44860 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727780AbgGOTvv (ORCPT ); Wed, 15 Jul 2020 15:51:51 -0400 Received: from forwardcorp1p.mail.yandex.net (forwardcorp1p.mail.yandex.net [IPv6:2a02:6b8:0:1472:2741:0:8b6:217]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 841F4C061755; Wed, 15 Jul 2020 12:51:50 -0700 (PDT) Received: from sas1-ec30c78b6c5b.qloud-c.yandex.net (sas1-ec30c78b6c5b.qloud-c.yandex.net [IPv6:2a02:6b8:c14:2704:0:640:ec30:c78b]) by forwardcorp1p.mail.yandex.net (Yandex) with ESMTP id 2FAC72E1469; Wed, 15 Jul 2020 22:51:48 +0300 (MSK) Received: from sas2-32987e004045.qloud-c.yandex.net (sas2-32987e004045.qloud-c.yandex.net [2a02:6b8:c08:b889:0:640:3298:7e00]) by sas1-ec30c78b6c5b.qloud-c.yandex.net (mxbackcorp/Yandex) with ESMTP id N0TQNKhr8x-pks8uhH3; Wed, 15 Jul 2020 22:51:48 +0300 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=yandex-team.ru; s=default; t=1594842708; bh=vNbjcbjkLVIDD/QHy81iuVCbyu7JHtnrx3RDpfYls/w=; h=In-Reply-To:Message-Id:References:Date:Subject:To:From:Cc; b=AM5HUUwf6CGqurt7ZEYnrRCcGOoPwy61j2VdsR+3xBHaXlGnjgdKG8Ecmz5Xp1eln ZVuLMos2pej21EhGYcCHD/5A3E5aU8RIM2rr411YBnDvzbR8AcAprmPLcAuvUBTiGs yw/o/RfPjrKUY6u+i1BPp4xrrKHRPa1DX2VtZU8g= Authentication-Results: sas1-ec30c78b6c5b.qloud-c.yandex.net; dkim=pass header.i=@yandex-team.ru Received: from 37.9.121.196-vpn.dhcp.yndx.net (37.9.121.196-vpn.dhcp.yndx.net [37.9.121.196]) by sas2-32987e004045.qloud-c.yandex.net (smtpcorp/Yandex) with ESMTPSA id kLmvqU3zdD-pkiKw5vq; Wed, 15 Jul 2020 22:51:46 +0300 (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (Client certificate not present) From: Dmitry Yakunin To: alexei.starovoitov@gmail.com, daniel@iogearbox.net, netdev@vger.kernel.org, bpf@vger.kernel.org Cc: sdf@google.com Subject: [PATCH bpf-next v3 2/4] bpf: allow to specify ifindex for skb in bpf_prog_test_run_skb Date: Wed, 15 Jul 2020 22:51:30 +0300 Message-Id: <20200715195132.4286-3-zeil@yandex-team.ru> In-Reply-To: <20200715195132.4286-1-zeil@yandex-team.ru> References: <20200715195132.4286-1-zeil@yandex-team.ru> MIME-Version: 1.0 Sender: bpf-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: bpf@vger.kernel.org Now skb->dev is unconditionally set to the loopback device in current net namespace. But if we want to test bpf program which contains code branch based on ifindex condition (eg filters out localhost packets) it is useful to allow specifying of ifindex from userspace. This patch adds such option through ctx_in (__sk_buff) parameter. Signed-off-by: Dmitry Yakunin --- net/bpf/test_run.c | 22 ++++++++++++++++++++-- tools/testing/selftests/bpf/prog_tests/skb_ctx.c | 5 +++++ 2 files changed, 25 insertions(+), 2 deletions(-) diff --git a/net/bpf/test_run.c b/net/bpf/test_run.c index 0c3283d..0e92973 100644 --- a/net/bpf/test_run.c +++ b/net/bpf/test_run.c @@ -310,6 +310,12 @@ static int convert___skb_to_skb(struct sk_buff *skb, struct __sk_buff *__skb) /* priority is allowed */ if (!range_is_zero(__skb, offsetofend(struct __sk_buff, priority), + offsetof(struct __sk_buff, ifindex))) + return -EINVAL; + + /* ifindex is allowed */ + + if (!range_is_zero(__skb, offsetofend(struct __sk_buff, ifindex), offsetof(struct __sk_buff, cb))) return -EINVAL; @@ -364,6 +370,7 @@ static void convert_skb_to___skb(struct sk_buff *skb, struct __sk_buff *__skb) __skb->mark = skb->mark; __skb->priority = skb->priority; + __skb->ifindex = skb->dev->ifindex; __skb->tstamp = skb->tstamp; memcpy(__skb->cb, &cb->data, QDISC_CB_PRIV_LEN); __skb->wire_len = cb->pkt_len; @@ -374,6 +381,8 @@ 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; + struct net *net = current->nsproxy->net_ns; + struct net_device *dev = net->loopback_dev; u32 size = kattr->test.data_size_in; u32 repeat = kattr->test.repeat; struct __sk_buff *ctx = NULL; @@ -415,7 +424,7 @@ int bpf_prog_test_run_skb(struct bpf_prog *prog, const union bpf_attr *kattr, kfree(ctx); return -ENOMEM; } - sock_net_set(sk, current->nsproxy->net_ns); + sock_net_set(sk, net); sock_init_data(NULL, sk); skb = build_skb(data, 0); @@ -429,7 +438,14 @@ int bpf_prog_test_run_skb(struct bpf_prog *prog, const union bpf_attr *kattr, skb_reserve(skb, NET_SKB_PAD + NET_IP_ALIGN); __skb_put(skb, size); - skb->protocol = eth_type_trans(skb, current->nsproxy->net_ns->loopback_dev); + if (ctx && ctx->ifindex > 1) { + dev = dev_get_by_index(net, ctx->ifindex); + if (!dev) { + ret = -ENODEV; + goto out; + } + } + skb->protocol = eth_type_trans(skb, dev); skb_reset_network_header(skb); switch (skb->protocol) { @@ -481,6 +497,8 @@ int bpf_prog_test_run_skb(struct bpf_prog *prog, const union bpf_attr *kattr, ret = bpf_ctx_finish(kattr, uattr, ctx, sizeof(struct __sk_buff)); out: + if (dev && dev != net->loopback_dev) + dev_put(dev); kfree_skb(skb); bpf_sk_storage_free(sk); kfree(sk); diff --git a/tools/testing/selftests/bpf/prog_tests/skb_ctx.c b/tools/testing/selftests/bpf/prog_tests/skb_ctx.c index 7021b92..25de86a 100644 --- a/tools/testing/selftests/bpf/prog_tests/skb_ctx.c +++ b/tools/testing/selftests/bpf/prog_tests/skb_ctx.c @@ -11,6 +11,7 @@ void test_skb_ctx(void) .cb[3] = 4, .cb[4] = 5, .priority = 6, + .ifindex = 1, .tstamp = 7, .wire_len = 100, .gso_segs = 8, @@ -92,6 +93,10 @@ void test_skb_ctx(void) "ctx_out_priority", "skb->priority == %d, expected %d\n", skb.priority, 7); + CHECK_ATTR(skb.ifindex != 1, + "ctx_out_ifindex", + "skb->ifindex == %d, expected %d\n", + skb.ifindex, 1); CHECK_ATTR(skb.tstamp != 8, "ctx_out_tstamp", "skb->tstamp == %lld, expected %d\n", From patchwork Wed Jul 15 19:51:31 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Dmitry Yakunin X-Patchwork-Id: 1329781 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Original-To: incoming-bpf@patchwork.ozlabs.org Delivered-To: patchwork-incoming-bpf@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=23.128.96.18; helo=vger.kernel.org; envelope-from=bpf-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=yandex-team.ru Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=yandex-team.ru header.i=@yandex-team.ru header.a=rsa-sha256 header.s=default header.b=yMfosvEE; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by ozlabs.org (Postfix) with ESMTP id 4B6ShL0d50z9sQt for ; Thu, 16 Jul 2020 05:52:02 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726715AbgGOTwB (ORCPT ); Wed, 15 Jul 2020 15:52:01 -0400 Received: from forwardcorp1j.mail.yandex.net ([5.45.199.163]:43050 "EHLO forwardcorp1j.mail.yandex.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726661AbgGOTvw (ORCPT ); Wed, 15 Jul 2020 15:51:52 -0400 Received: from sas1-ec30c78b6c5b.qloud-c.yandex.net (sas1-ec30c78b6c5b.qloud-c.yandex.net [IPv6:2a02:6b8:c14:2704:0:640:ec30:c78b]) by forwardcorp1j.mail.yandex.net (Yandex) with ESMTP id 5268A2E137B; Wed, 15 Jul 2020 22:51:49 +0300 (MSK) Received: from sas2-32987e004045.qloud-c.yandex.net (sas2-32987e004045.qloud-c.yandex.net [2a02:6b8:c08:b889:0:640:3298:7e00]) by sas1-ec30c78b6c5b.qloud-c.yandex.net (mxbackcorp/Yandex) with ESMTP id 8ridnClXFG-pmsuJDqI; Wed, 15 Jul 2020 22:51:49 +0300 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=yandex-team.ru; s=default; t=1594842709; bh=A3kRuO7Xlz90evll8iFzc1iluvX1ek0ZKo8bUWxoErM=; h=In-Reply-To:Message-Id:References:Date:Subject:To:From:Cc; b=yMfosvEE4rgtYgskdEWNTsIH/LUQla8V6Lpz78f0dT5T3piOs5B1+MhULRqub0DFq bdZ3tPNKbXB+eyK4EtlnT3GQJfwN+ru0d3EB9MJ198J5wE2L/k/7X0wdJSXVF/Ox1E WOf6Bj7LhrxZhdgFdrVQEqLdgaUC5mvdqtWCBhkE= Authentication-Results: sas1-ec30c78b6c5b.qloud-c.yandex.net; dkim=pass header.i=@yandex-team.ru Received: from 37.9.121.196-vpn.dhcp.yndx.net (37.9.121.196-vpn.dhcp.yndx.net [37.9.121.196]) by sas2-32987e004045.qloud-c.yandex.net (smtpcorp/Yandex) with ESMTPSA id kLmvqU3zdD-pmiKxZXU; Wed, 15 Jul 2020 22:51:48 +0300 (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (Client certificate not present) From: Dmitry Yakunin To: alexei.starovoitov@gmail.com, daniel@iogearbox.net, netdev@vger.kernel.org, bpf@vger.kernel.org Cc: sdf@google.com Subject: [PATCH bpf-next v3 3/4] bpf: export some cgroup storages allocation helpers for reusing Date: Wed, 15 Jul 2020 22:51:31 +0300 Message-Id: <20200715195132.4286-4-zeil@yandex-team.ru> In-Reply-To: <20200715195132.4286-1-zeil@yandex-team.ru> References: <20200715195132.4286-1-zeil@yandex-team.ru> MIME-Version: 1.0 Sender: bpf-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: bpf@vger.kernel.org This patch exports bpf_cgroup_storages_alloc and bpf_cgroup_storages_free helpers to the header file and reuses them in bpf_test_run. v2: - fix build without CONFIG_CGROUP_BPF (kernel test robot ) Signed-off-by: Dmitry Yakunin --- include/linux/bpf-cgroup.h | 36 ++++++++++++++++++++++++++++++++++++ kernel/bpf/cgroup.c | 25 ------------------------- net/bpf/test_run.c | 16 ++++------------ 3 files changed, 40 insertions(+), 37 deletions(-) diff --git a/include/linux/bpf-cgroup.h b/include/linux/bpf-cgroup.h index 2c6f266..5c10fe6 100644 --- a/include/linux/bpf-cgroup.h +++ b/include/linux/bpf-cgroup.h @@ -175,6 +175,33 @@ int bpf_percpu_cgroup_storage_copy(struct bpf_map *map, void *key, void *value); int bpf_percpu_cgroup_storage_update(struct bpf_map *map, void *key, void *value, u64 flags); +static inline void bpf_cgroup_storages_free(struct bpf_cgroup_storage + *storage[MAX_BPF_CGROUP_STORAGE_TYPE]) +{ + enum bpf_cgroup_storage_type stype; + + for_each_cgroup_storage_type(stype) + bpf_cgroup_storage_free(storage[stype]); +} + +static inline int bpf_cgroup_storages_alloc(struct bpf_cgroup_storage + *storage[MAX_BPF_CGROUP_STORAGE_TYPE], + struct bpf_prog *prog) +{ + enum bpf_cgroup_storage_type stype; + + for_each_cgroup_storage_type(stype) { + storage[stype] = bpf_cgroup_storage_alloc(prog, stype); + if (IS_ERR(storage[stype])) { + storage[stype] = NULL; + bpf_cgroup_storages_free(storage); + return -ENOMEM; + } + } + + return 0; +} + /* Wrappers for __cgroup_bpf_run_filter_skb() guarded by cgroup_bpf_enabled. */ #define BPF_CGROUP_RUN_PROG_INET_INGRESS(sk, skb) \ ({ \ @@ -398,6 +425,15 @@ static inline int bpf_percpu_cgroup_storage_update(struct bpf_map *map, return 0; } +static inline void bpf_cgroup_storages_free( + struct bpf_cgroup_storage *storage[MAX_BPF_CGROUP_STORAGE_TYPE]) {} + +static inline int bpf_cgroup_storages_alloc( + struct bpf_cgroup_storage *storage[MAX_BPF_CGROUP_STORAGE_TYPE], + struct bpf_prog *prog) { + return 0; +} + #define cgroup_bpf_enabled (0) #define BPF_CGROUP_RUN_SA_PROG_LOCK(sk, uaddr, type, t_ctx) ({ 0; }) #define BPF_CGROUP_PRE_CONNECT_ENABLED(sk) (0) diff --git a/kernel/bpf/cgroup.c b/kernel/bpf/cgroup.c index ac53102..e4c2792 100644 --- a/kernel/bpf/cgroup.c +++ b/kernel/bpf/cgroup.c @@ -28,31 +28,6 @@ void cgroup_bpf_offline(struct cgroup *cgrp) percpu_ref_kill(&cgrp->bpf.refcnt); } -static void bpf_cgroup_storages_free(struct bpf_cgroup_storage *storages[]) -{ - enum bpf_cgroup_storage_type stype; - - for_each_cgroup_storage_type(stype) - bpf_cgroup_storage_free(storages[stype]); -} - -static int bpf_cgroup_storages_alloc(struct bpf_cgroup_storage *storages[], - struct bpf_prog *prog) -{ - enum bpf_cgroup_storage_type stype; - - for_each_cgroup_storage_type(stype) { - storages[stype] = bpf_cgroup_storage_alloc(prog, stype); - if (IS_ERR(storages[stype])) { - storages[stype] = NULL; - bpf_cgroup_storages_free(storages); - return -ENOMEM; - } - } - - return 0; -} - static void bpf_cgroup_storages_assign(struct bpf_cgroup_storage *dst[], struct bpf_cgroup_storage *src[]) { diff --git a/net/bpf/test_run.c b/net/bpf/test_run.c index 0e92973..050390d 100644 --- a/net/bpf/test_run.c +++ b/net/bpf/test_run.c @@ -19,20 +19,13 @@ 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 }; - enum bpf_cgroup_storage_type stype; u64 time_start, time_spent = 0; int ret = 0; u32 i; - for_each_cgroup_storage_type(stype) { - storage[stype] = bpf_cgroup_storage_alloc(prog, stype); - if (IS_ERR(storage[stype])) { - storage[stype] = NULL; - for_each_cgroup_storage_type(stype) - bpf_cgroup_storage_free(storage[stype]); - return -ENOMEM; - } - } + ret = bpf_cgroup_storages_alloc(storage, prog); + if (ret) + return ret; if (!repeat) repeat = 1; @@ -72,8 +65,7 @@ static int bpf_test_run(struct bpf_prog *prog, void *ctx, u32 repeat, do_div(time_spent, repeat); *time = time_spent > U32_MAX ? U32_MAX : (u32)time_spent; - for_each_cgroup_storage_type(stype) - bpf_cgroup_storage_free(storage[stype]); + bpf_cgroup_storages_free(storage); return ret; } From patchwork Wed Jul 15 19:51:32 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Dmitry Yakunin X-Patchwork-Id: 1329777 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=23.128.96.18; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=yandex-team.ru Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=yandex-team.ru header.i=@yandex-team.ru header.a=rsa-sha256 header.s=default header.b=ycb9eW2G; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by ozlabs.org (Postfix) with ESMTP id 4B6ShG4KJQz9sQt for ; Thu, 16 Jul 2020 05:51:58 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727952AbgGOTv6 (ORCPT ); Wed, 15 Jul 2020 15:51:58 -0400 Received: from forwardcorp1o.mail.yandex.net ([95.108.205.193]:53816 "EHLO forwardcorp1o.mail.yandex.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727782AbgGOTvx (ORCPT ); Wed, 15 Jul 2020 15:51:53 -0400 Received: from sas1-ec30c78b6c5b.qloud-c.yandex.net (sas1-ec30c78b6c5b.qloud-c.yandex.net [IPv6:2a02:6b8:c14:2704:0:640:ec30:c78b]) by forwardcorp1o.mail.yandex.net (Yandex) with ESMTP id C17492E15E1; Wed, 15 Jul 2020 22:51:50 +0300 (MSK) Received: from sas2-32987e004045.qloud-c.yandex.net (sas2-32987e004045.qloud-c.yandex.net [2a02:6b8:c08:b889:0:640:3298:7e00]) by sas1-ec30c78b6c5b.qloud-c.yandex.net (mxbackcorp/Yandex) with ESMTP id 68OmjYXD2C-pnsaP8Ii; Wed, 15 Jul 2020 22:51:50 +0300 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=yandex-team.ru; s=default; t=1594842710; bh=Nsz2wNODzC+RLJdSyj6I7YJV6sb/UttprFT4VAmd/Lc=; h=In-Reply-To:Message-Id:References:Date:Subject:To:From:Cc; b=ycb9eW2GmqCCqhF+oDcHtcqbeh8oaXyXG7cAUfYywTdBiL6MkYMuF9MkFWRD3cTM7 ngZTpiZ0T0fbeZKpBoxih9m/w4QlPymtaUiBj8kLsLfCntXaV4P78coOlgQodCBO19 3xCCzluvPmq2xdjsvALcQmnVWZ//zA99IklNvXIM= Authentication-Results: sas1-ec30c78b6c5b.qloud-c.yandex.net; dkim=pass header.i=@yandex-team.ru Received: from 37.9.121.196-vpn.dhcp.yndx.net (37.9.121.196-vpn.dhcp.yndx.net [37.9.121.196]) by sas2-32987e004045.qloud-c.yandex.net (smtpcorp/Yandex) with ESMTPSA id kLmvqU3zdD-pniKgGX6; Wed, 15 Jul 2020 22:51:49 +0300 (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (Client certificate not present) From: Dmitry Yakunin To: alexei.starovoitov@gmail.com, daniel@iogearbox.net, netdev@vger.kernel.org, bpf@vger.kernel.org Cc: sdf@google.com Subject: [PATCH bpf-next v3 4/4] bpf: try to use existing cgroup storage in bpf_prog_test_run_skb Date: Wed, 15 Jul 2020 22:51:32 +0300 Message-Id: <20200715195132.4286-5-zeil@yandex-team.ru> In-Reply-To: <20200715195132.4286-1-zeil@yandex-team.ru> References: <20200715195132.4286-1-zeil@yandex-team.ru> MIME-Version: 1.0 Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Now we cannot check results in cgroup storage after running BPF_PROG_TEST_RUN command because it allocates dummy cgroup storage during test. This patch implements simple logic for searching already allocated cgroup storage through iterating effective programs of current cgroup and finding the first match. If match is not found fallback to temporary storage is happened. v2: - fix build without CONFIG_CGROUP_BPF (kernel test robot ) Signed-off-by: Dmitry Yakunin --- net/bpf/test_run.c | 64 +++++++++++++++++- .../selftests/bpf/prog_tests/cgroup_skb_prog_run.c | 78 ++++++++++++++++++++++ 2 files changed, 139 insertions(+), 3 deletions(-) create mode 100644 tools/testing/selftests/bpf/prog_tests/cgroup_skb_prog_run.c diff --git a/net/bpf/test_run.c b/net/bpf/test_run.c index 050390d..7382b22 100644 --- a/net/bpf/test_run.c +++ b/net/bpf/test_run.c @@ -15,15 +15,67 @@ #define CREATE_TRACE_POINTS #include +#ifdef CONFIG_CGROUP_BPF + +static struct bpf_prog_array_item *bpf_prog_find_active(struct bpf_prog *prog, + struct bpf_prog_array *effective) +{ + struct bpf_prog_array_item *item; + struct bpf_prog_array *array; + struct bpf_prog *p; + + array = rcu_dereference(effective); + if (!array) + return NULL; + + item = &array->items[0]; + while ((p = READ_ONCE(item->prog))) { + if (p == prog) + return item; + item++; + } + + return NULL; +} + +static struct bpf_cgroup_storage **bpf_prog_find_active_storage(struct bpf_prog *prog) +{ + struct bpf_prog_array_item *item; + struct cgroup *cgrp; + + if (prog->type != BPF_PROG_TYPE_CGROUP_SKB) + return NULL; + + cgrp = task_dfl_cgroup(current); + + item = bpf_prog_find_active(prog, + cgrp->bpf.effective[BPF_CGROUP_INET_INGRESS]); + if (!item) + item = bpf_prog_find_active(prog, + cgrp->bpf.effective[BPF_CGROUP_INET_EGRESS]); + + return item ? item->cgroup_storage : NULL; +} + +#else + +static struct bpf_cgroup_storage **bpf_prog_find_active_storage(struct bpf_prog *prog) +{ + return NULL; +} + +#endif + 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 bpf_cgroup_storage *dummy_storage[MAX_BPF_CGROUP_STORAGE_TYPE] = { NULL }; + struct bpf_cgroup_storage **storage = dummy_storage; u64 time_start, time_spent = 0; int ret = 0; u32 i; - ret = bpf_cgroup_storages_alloc(storage, prog); + ret = bpf_cgroup_storages_alloc(dummy_storage, prog); if (ret) return ret; @@ -31,6 +83,9 @@ static int bpf_test_run(struct bpf_prog *prog, void *ctx, u32 repeat, repeat = 1; rcu_read_lock(); + storage = bpf_prog_find_active_storage(prog); + if (!storage) + storage = dummy_storage; migrate_disable(); time_start = ktime_get_ns(); for (i = 0; i < repeat; i++) { @@ -54,6 +109,9 @@ static int bpf_test_run(struct bpf_prog *prog, void *ctx, u32 repeat, cond_resched(); rcu_read_lock(); + storage = bpf_prog_find_active_storage(prog); + if (!storage) + storage = dummy_storage; migrate_disable(); time_start = ktime_get_ns(); } @@ -65,7 +123,7 @@ static int bpf_test_run(struct bpf_prog *prog, void *ctx, u32 repeat, do_div(time_spent, repeat); *time = time_spent > U32_MAX ? U32_MAX : (u32)time_spent; - bpf_cgroup_storages_free(storage); + bpf_cgroup_storages_free(dummy_storage); return ret; } diff --git a/tools/testing/selftests/bpf/prog_tests/cgroup_skb_prog_run.c b/tools/testing/selftests/bpf/prog_tests/cgroup_skb_prog_run.c new file mode 100644 index 0000000..12ca881 --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/cgroup_skb_prog_run.c @@ -0,0 +1,78 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include + +#include "cgroup_helpers.h" +#include "network_helpers.h" + +static char bpf_log_buf[BPF_LOG_BUF_SIZE]; + +void test_cgroup_skb_prog_run(void) +{ + struct bpf_insn prog[] = { + BPF_LD_MAP_FD(BPF_REG_1, 0), /* map fd */ + BPF_MOV64_IMM(BPF_REG_2, 0), /* flags, not used */ + BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_get_local_storage), + BPF_MOV64_IMM(BPF_REG_1, 1), + BPF_RAW_INSN(BPF_STX | BPF_XADD | BPF_W, BPF_REG_0, BPF_REG_1, 0, 0), + + BPF_MOV64_IMM(BPF_REG_0, 1), /* r0 = 1 */ + BPF_EXIT_INSN(), + }; + size_t insns_cnt = sizeof(prog) / sizeof(struct bpf_insn); + int storage_fd = -1, prog_fd = -1, cg_fd = -1; + struct bpf_cgroup_storage_key key; + __u32 duration, retval, size; + char buf[128]; + __u64 value; + int err; + + storage_fd = bpf_create_map(BPF_MAP_TYPE_CGROUP_STORAGE, + sizeof(struct bpf_cgroup_storage_key), + 8, 0, 0); + if (CHECK(storage_fd < 0, "create_map", "%s\n", strerror(errno))) + goto out; + + prog[0].imm = storage_fd; + + prog_fd = bpf_load_program(BPF_PROG_TYPE_CGROUP_SKB, + prog, insns_cnt, "GPL", 0, + bpf_log_buf, BPF_LOG_BUF_SIZE); + if (CHECK(prog_fd < 0, "prog_load", + "verifier output:\n%s\n-------\n", bpf_log_buf)) + goto out; + + if (CHECK_FAIL(setup_cgroup_environment())) + goto out; + + cg_fd = create_and_get_cgroup("/cg"); + if (CHECK_FAIL(cg_fd < 0)) + goto out; + + if (CHECK_FAIL(join_cgroup("/cg"))) + goto out; + + if (CHECK(bpf_prog_attach(prog_fd, cg_fd, BPF_CGROUP_INET_EGRESS, 0), + "prog_attach", "%s\n", strerror(errno))) + goto out; + + err = bpf_prog_test_run(prog_fd, NUM_ITER, &pkt_v4, sizeof(pkt_v4), + buf, &size, &retval, &duration); + CHECK(err || retval != 1, "prog_test_run", + "err %d errno %d retval %d\n", err, errno, retval); + + /* check that cgroup storage results are available after test run */ + + err = bpf_map_get_next_key(storage_fd, NULL, &key); + CHECK(err, "map_get_next_key", "%s\n", strerror(errno)); + + err = bpf_map_lookup_elem(storage_fd, &key, &value); + CHECK(err || value != NUM_ITER, + "map_lookup_elem", + "err %d errno %d cnt %lld(%d)\n", err, errno, value, NUM_ITER); +out: + close(storage_fd); + close(prog_fd); + close(cg_fd); + cleanup_cgroup_environment(); +}