From nobody Sat Apr 20 01:07:07 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 890FCC25B0C for ; Fri, 5 Aug 2022 21:49:21 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S240663AbiHEVtQ (ORCPT ); Fri, 5 Aug 2022 17:49:16 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:36862 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241332AbiHEVsz (ORCPT ); Fri, 5 Aug 2022 17:48:55 -0400 Received: from mail-pl1-x649.google.com (mail-pl1-x649.google.com [IPv6:2607:f8b0:4864:20::649]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 7655576965 for ; Fri, 5 Aug 2022 14:48:54 -0700 (PDT) Received: by mail-pl1-x649.google.com with SMTP id n8-20020a170902d2c800b0016edca79984so2239172plc.8 for ; Fri, 05 Aug 2022 14:48:54 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:references:mime-version:message-id:in-reply-to :date:from:to:cc; bh=v1NXB6wxRFohvXJoX8NOegBlamHwcU9rtOLwkpAdV8E=; b=Xi5iNcCGRKvjjsmKAwMoxe2RN0Shtls178GUOGYmKJg9FShcL+7UsiocCYRAMR2Pxf urteg3Kcvf2BVtedqJXvbj0xav+qEORWImui5J64jwmgMXMjnNZ3q/vvp+dfLyxeAlh2 otVYBS3oHXzz7vnUNWnVoSfsKL2WZoShCCXuYPDoAyfqU4HEki+CXcqbxH0FEkGUNgmt i6AAIhX4RjnAGDixu5tph7tPiPTc3nMRYBS5HxhuSbhIOjvCZJrecDCD1IEUhFSXuor0 BJ+Y2CaD0/K8kY/OL4DzpwX7tL5baRyraZhqHXhpuueVFepFUYPHJ/g4u5HxhlZcCOUH 5rbA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:references:mime-version:message-id:in-reply-to :date:x-gm-message-state:from:to:cc; bh=v1NXB6wxRFohvXJoX8NOegBlamHwcU9rtOLwkpAdV8E=; b=eq2o415W+QaQADcab3DDqxzrPVOH7xmeeASQKRX7TJaquxBtT+MoAFJsgz6UniR6dA oOfUy2IZMnbORNtqsRMgMjyjAV6Vi0fpK2/Q1MVQ7olhA6sAL49BVV/kaedNc0ggIgQV q9QbJxNSPXSEy8imJ3MU3sSZ0jS/+1J8r8yx8iMbC6g3fPbIRmi0gWxvx5cKq7cUNi23 2dvx6nRile8lJ51JD9o1he4yBNG5VXw+W0rIcGjC7i7EsWr7+QuIejk5A/6FBJLjlndd 6+LCfOlyTrRj1e9pG/G+HQdV8Fhwx3skuePGNyv5aFnkpOfUPg42x1cW4+jSn5j0YCaZ fEsQ== X-Gm-Message-State: ACgBeo2ko9T25X0o2M1vxpFZ9KdnMJfzFNBt92wTVv+J/llMoYMzYj4x va3dWfHxtcQkPjvOL4CTqf4Yfx5toqP7PCPzV6pQwceO/h7wshAeZbnCFtRm4O1ztsHqS8w39NA j6GOmwk+Jhaj6CT+ZNdzm5wicE1ps6YHuMP0W/fsvT6iOq0nXpcUwtqkKZnhxe9QqeGmYzg== X-Google-Smtp-Source: AA6agR4xcun+0LQiqLQQb/H/p8nnMeMQ8d129fBAQksFYt94EVlkuAVY8oY8cNefwuo8279BKU6BAkIKuIo= X-Received: from haoluo.svl.corp.google.com ([2620:15c:2d4:203:4f27:97db:8644:dc82]) (user=haoluo job=sendgmr) by 2002:a17:902:ef47:b0:16c:60df:3a7c with SMTP id e7-20020a170902ef4700b0016c60df3a7cmr8587705plx.9.1659736133709; Fri, 05 Aug 2022 14:48:53 -0700 (PDT) Date: Fri, 5 Aug 2022 14:48:14 -0700 In-Reply-To: <20220805214821.1058337-1-haoluo@google.com> Message-Id: <20220805214821.1058337-2-haoluo@google.com> Mime-Version: 1.0 References: <20220805214821.1058337-1-haoluo@google.com> X-Mailer: git-send-email 2.37.1.559.g78731f0fdb-goog Subject: [PATCH bpf-next v7 1/8] btf: Add a new kfunc flag which allows to mark a function to be sleepable From: Hao Luo To: linux-kernel@vger.kernel.org, bpf@vger.kernel.org, cgroups@vger.kernel.org, netdev@vger.kernel.org Cc: Alexei Starovoitov , Andrii Nakryiko , Daniel Borkmann , Martin KaFai Lau , Song Liu , Yonghong Song , Tejun Heo , Zefan Li , KP Singh , Johannes Weiner , Michal Hocko , Benjamin Tissoires , John Fastabend , Michal Koutny , Roman Gushchin , David Rientjes , Stanislav Fomichev , Shakeel Butt , Yosry Ahmed , Hao Luo Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Benjamin Tissoires This allows to declare a kfunc as sleepable and prevents its use in a non sleepable program. Signed-off-by: Benjamin Tissoires Co-developed-by: Yosry Ahmed Signed-off-by: Yosry Ahmed Signed-off-by: Hao Luo --- Documentation/bpf/kfuncs.rst | 6 ++++++ include/linux/btf.h | 1 + kernel/bpf/btf.c | 9 +++++++++ 3 files changed, 16 insertions(+) diff --git a/Documentation/bpf/kfuncs.rst b/Documentation/bpf/kfuncs.rst index c0b7dae6dbf5..c8b21de1c772 100644 --- a/Documentation/bpf/kfuncs.rst +++ b/Documentation/bpf/kfuncs.rst @@ -146,6 +146,12 @@ that operate (change some property, perform some opera= tion) on an object that was obtained using an acquire kfunc. Such kfuncs need an unchanged pointer= to ensure the integrity of the operation being performed on the expected obje= ct. =20 +2.4.6 KF_SLEEPABLE flag +----------------------- + +The KF_SLEEPABLE flag is used for kfuncs that may sleep. Such kfuncs can o= nly +be called by sleepable BPF programs (BPF_F_SLEEPABLE). + 2.5 Registering the kfuncs -------------------------- =20 diff --git a/include/linux/btf.h b/include/linux/btf.h index cdb376d53238..976cbdd2981f 100644 --- a/include/linux/btf.h +++ b/include/linux/btf.h @@ -49,6 +49,7 @@ * for this case. */ #define KF_TRUSTED_ARGS (1 << 4) /* kfunc only takes trusted pointer argum= ents */ +#define KF_SLEEPABLE (1 << 5) /* kfunc may sleep */ =20 struct btf; struct btf_member; diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c index 7e64447659f3..d3e4c86b8fcd 100644 --- a/kernel/bpf/btf.c +++ b/kernel/bpf/btf.c @@ -6175,6 +6175,7 @@ static int btf_check_func_arg_match(struct bpf_verifi= er_env *env, { enum bpf_prog_type prog_type =3D resolve_prog_type(env->prog); bool rel =3D false, kptr_get =3D false, trusted_arg =3D false; + bool sleepable =3D false; struct bpf_verifier_log *log =3D &env->log; u32 i, nargs, ref_id, ref_obj_id =3D 0; bool is_kfunc =3D btf_is_kernel(btf); @@ -6212,6 +6213,7 @@ static int btf_check_func_arg_match(struct bpf_verifi= er_env *env, rel =3D kfunc_flags & KF_RELEASE; kptr_get =3D kfunc_flags & KF_KPTR_GET; trusted_arg =3D kfunc_flags & KF_TRUSTED_ARGS; + sleepable =3D kfunc_flags & KF_SLEEPABLE; } =20 /* check that BTF function arguments match actual types that the @@ -6419,6 +6421,13 @@ static int btf_check_func_arg_match(struct bpf_verif= ier_env *env, func_name); return -EINVAL; } + + if (sleepable && !env->prog->aux->sleepable) { + bpf_log(log, "kernel function %s is sleepable but the program is not\n", + func_name); + return -EINVAL; + } + /* returns argument register number > 0 in case of reference release kfun= c */ return rel ? ref_regno : 0; } --=20 2.37.1.559.g78731f0fdb-goog From nobody Sat Apr 20 01:07:07 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 03242C25B08 for ; Fri, 5 Aug 2022 21:49:25 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S241538AbiHEVtU (ORCPT ); Fri, 5 Aug 2022 17:49:20 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37008 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241243AbiHEVtA (ORCPT ); Fri, 5 Aug 2022 17:49:00 -0400 Received: from mail-yw1-x1149.google.com (mail-yw1-x1149.google.com [IPv6:2607:f8b0:4864:20::1149]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id EA9D67A530 for ; Fri, 5 Aug 2022 14:48:56 -0700 (PDT) Received: by mail-yw1-x1149.google.com with SMTP id 00721157ae682-32851d0f8beso31033597b3.22 for ; Fri, 05 Aug 2022 14:48:56 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:references:mime-version:message-id:in-reply-to :date:from:to:cc; bh=yX3R/1i2LvTgNgg51J0RQhSR+naxU23tOgWOVNggIfM=; b=a7tYZIN2B6Y2XNLphifwjcXADFx7gkBmMvn3k+uUvzZ3plqE2SbhHbFhSrzbeff3ob gpEkWJ+BU4BsSNfrGwlvuHWUfSz9wrzda85SNVzeODOFirlekVdIFXIDC690ySk6LjnV TKO7Dajm4ek5OH5PQo33IjTrMjr23rtrutvRF8uWrZBGLMdE4hI0vfFixcLZKpnrvxof MJhLvW7up+1p/h18noKqidVfcZrWhSkNQRSCmX2jeEpraXunH+F4G0xLO1YXelQ02PQ/ OOykHlZU56GWzNfJT0elWItS0IcvSaxsXc+l6TRBYs7vgujcEPzpqiK68zkf+UF7XHZ5 ONAQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:references:mime-version:message-id:in-reply-to :date:x-gm-message-state:from:to:cc; bh=yX3R/1i2LvTgNgg51J0RQhSR+naxU23tOgWOVNggIfM=; b=qdWxJj2dNf+MlGHuKJs4AXr7J37DYqCmBSBMo2y7r5NEPRHRJBsHRjDU1ERSyj7cNI hwEKKIds4gTe2k37UBvxnetadh2yvfGO2pjuUl3JpxAUQows1T58jKRGr3W4kf3MgVTq uiXFTwaUCubP+/vkBMyLvY5JkhEM5ElVlp5exh6MV6rL5uFSvW0AFlpV+ikCDXe8onUS Amn2bqHfWc/z1gUi65Z388WgMi/cpfiZVAucya4QKVhlfZg6LZ+q+s7MvSEzMzWHql5r VYgc7vN57Sngq0nEYf21jliOJzIHwxV7Pkmh1b//Ej4lkRjh60CI9AZeG1/M44qTysXr dBoA== X-Gm-Message-State: ACgBeo00oThf8/F7XuRAeWkgkLSGg2huKnQkKEpYlo7bW8o057OxVpuQ CA6arpFk8i7FTS5G4VZ3rfzNjVY1O4kRRlBu2ueQ1ocuDuKWppZFMTGLcqqP+l+Ca8nl1I10H9d UmhtOS/nTCR7x+09hS7EC6YQTnMPOExI3zpOUEaj2HPXR1sbIM9kAMIbp3AMg8pXa6TcrrA== X-Google-Smtp-Source: AA6agR4H2bQkt5vkX1vf0DXDEkJRbK1x+84BjvFdi5mYU07GFA9bTVydk11jeARHUUFFpgLekr8jfkDBotQ= X-Received: from haoluo.svl.corp.google.com ([2620:15c:2d4:203:4f27:97db:8644:dc82]) (user=haoluo job=sendgmr) by 2002:a81:1390:0:b0:322:2378:c198 with SMTP id 138-20020a811390000000b003222378c198mr7864153ywt.244.1659736136411; Fri, 05 Aug 2022 14:48:56 -0700 (PDT) Date: Fri, 5 Aug 2022 14:48:15 -0700 In-Reply-To: <20220805214821.1058337-1-haoluo@google.com> Message-Id: <20220805214821.1058337-3-haoluo@google.com> Mime-Version: 1.0 References: <20220805214821.1058337-1-haoluo@google.com> X-Mailer: git-send-email 2.37.1.559.g78731f0fdb-goog Subject: [PATCH bpf-next v7 2/8] cgroup: enable cgroup_get_from_file() on cgroup1 From: Hao Luo To: linux-kernel@vger.kernel.org, bpf@vger.kernel.org, cgroups@vger.kernel.org, netdev@vger.kernel.org Cc: Alexei Starovoitov , Andrii Nakryiko , Daniel Borkmann , Martin KaFai Lau , Song Liu , Yonghong Song , Tejun Heo , Zefan Li , KP Singh , Johannes Weiner , Michal Hocko , Benjamin Tissoires , John Fastabend , Michal Koutny , Roman Gushchin , David Rientjes , Stanislav Fomichev , Shakeel Butt , Yosry Ahmed , Hao Luo Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Yosry Ahmed cgroup_get_from_file() currently fails with -EBADF if called on cgroup v1. However, the current implementation works on cgroup v1 as well, so the restriction is unnecessary. This enabled cgroup_get_from_fd() to work on cgroup v1, which would be the only thing stopping bpf cgroup_iter from supporting cgroup v1. Signed-off-by: Yosry Ahmed Acked-by: Tejun Heo Signed-off-by: Hao Luo --- kernel/cgroup/cgroup.c | 5 ----- 1 file changed, 5 deletions(-) diff --git a/kernel/cgroup/cgroup.c b/kernel/cgroup/cgroup.c index 13c8e91d7862..49803849a289 100644 --- a/kernel/cgroup/cgroup.c +++ b/kernel/cgroup/cgroup.c @@ -6099,11 +6099,6 @@ static struct cgroup *cgroup_get_from_file(struct fi= le *f) return ERR_CAST(css); =20 cgrp =3D css->cgroup; - if (!cgroup_on_dfl(cgrp)) { - cgroup_put(cgrp); - return ERR_PTR(-EBADF); - } - return cgrp; } =20 --=20 2.37.1.559.g78731f0fdb-goog From nobody Sat Apr 20 01:07:07 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id EB010C25B08 for ; Fri, 5 Aug 2022 21:49:30 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S241546AbiHEVt2 (ORCPT ); Fri, 5 Aug 2022 17:49:28 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37456 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241437AbiHEVtO (ORCPT ); Fri, 5 Aug 2022 17:49:14 -0400 Received: from mail-yb1-xb49.google.com (mail-yb1-xb49.google.com [IPv6:2607:f8b0:4864:20::b49]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5CFE77B1F3 for ; Fri, 5 Aug 2022 14:49:01 -0700 (PDT) Received: by mail-yb1-xb49.google.com with SMTP id y13-20020a5b09cd000000b0067114eb5b50so3043545ybq.17 for ; Fri, 05 Aug 2022 14:49:00 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:references:mime-version:message-id:in-reply-to :date:from:to:cc; bh=7MaHmbvjhjrXHhN5Hd2JmNuqCLNElFu+/Qz1TUQGsGM=; b=XE0i/VM2AKUVwDXrI7BSBUWMw8xZL12GqzlEqpo9DCJuNkA2rk48R5GIWi3DkPnewZ Wqvf9KpzxAPPV+FGmjzKY47JWe+wrpsfYtvFSHb7DSImp86aYtmySfXl+MACOjjbsl7E YSsiFaaLXKUzdkjkTNUYxnprMH6PDTmVSVPM9FeftJ8EKEjX+4ITxuColVd/djrYLv5Q TqcPRDDcgfhjG/51ZgCmmTqr/S+HVPaNytx65orUi0h5nGR0lofrgsGKAn5TAUFqiufk Gm2cDgi9HxIrq9dUhtauCQN4hSLAgikGj+kw+GAt1YS8s9rH/fyWctEx5ntVb17vS7e0 OAQg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:references:mime-version:message-id:in-reply-to :date:x-gm-message-state:from:to:cc; bh=7MaHmbvjhjrXHhN5Hd2JmNuqCLNElFu+/Qz1TUQGsGM=; b=TxFJLu1fuc6O5pNYwHTUcfcJhYhZr9rNzynrAGVvILC5JcOTGjELEUXgIO9XCCXX4A 9OLVPRzTRPvTatP9rzp6sPfaKT3an25tYRmsdxNmtAkD5+4elJPkKaWPjoY5Ncl9uYpM TDHbkjNenHUNfLcl0wA9f7/RKegEHaLEwr9InCSmXeGLb1tNgbBZa/dXNRoz0whbepSA YSdAnSe9VC/Bl3FZxy2LAYXz9nJA7YRc3HHb4/+13aRGxU/O4E1Y8mV/rInzPocwZrnu Z7AF4GjApCzTgIBn/waZl46yGLmwzcdKgUcjUm0Z5D2oHn3T464w2p0DHLkEx2XZZ2Ad PIBw== X-Gm-Message-State: ACgBeo1CadS5OKUxuzzOWc8CwSFajpYkaFdT0XaMtZdMKhAZpLOxOISX sRIKPASH+Ih9oG76UJcT2NC6j5WfUhlSWj+DwE5P1Z6VNq5H9CiuHHTgd42CUOlcX+rxN70nS9W ROfa+9JWzxs66BlJbrtB4B0AlbRnHXmPfAgqxEo6WnUnNNToIwaomOLUpkdMuJUwkgh6rjA== X-Google-Smtp-Source: AA6agR7KtTkBAQflnjFdkH6sxoe3pUYKkJuoWbTg/BWcY40LDCHQ5LL4ugM5Gne1On5cT0W2CO7WbylmRu4= X-Received: from haoluo.svl.corp.google.com ([2620:15c:2d4:203:4f27:97db:8644:dc82]) (user=haoluo job=sendgmr) by 2002:a25:c695:0:b0:672:9622:ace4 with SMTP id k143-20020a25c695000000b006729622ace4mr7456744ybf.311.1659736139343; Fri, 05 Aug 2022 14:48:59 -0700 (PDT) Date: Fri, 5 Aug 2022 14:48:16 -0700 In-Reply-To: <20220805214821.1058337-1-haoluo@google.com> Message-Id: <20220805214821.1058337-4-haoluo@google.com> Mime-Version: 1.0 References: <20220805214821.1058337-1-haoluo@google.com> X-Mailer: git-send-email 2.37.1.559.g78731f0fdb-goog Subject: [PATCH bpf-next v7 3/8] bpf, iter: Fix the condition on p when calling stop. From: Hao Luo To: linux-kernel@vger.kernel.org, bpf@vger.kernel.org, cgroups@vger.kernel.org, netdev@vger.kernel.org Cc: Alexei Starovoitov , Andrii Nakryiko , Daniel Borkmann , Martin KaFai Lau , Song Liu , Yonghong Song , Tejun Heo , Zefan Li , KP Singh , Johannes Weiner , Michal Hocko , Benjamin Tissoires , John Fastabend , Michal Koutny , Roman Gushchin , David Rientjes , Stanislav Fomichev , Shakeel Butt , Yosry Ahmed , Hao Luo Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" In bpf_seq_read, seq->op->next() could return an ERR and jump to the label stop. However, the existing code in stop does not handle the case when p (returned from next()) is an ERR. Adds the handling of ERR of p by converting p into an error and jumping to done. Because all the current implementations do not have a case that returns ERR from next(), so this patch doesn't have behavior changes right now. Acked-by: Yonghong Song Signed-off-by: Hao Luo --- kernel/bpf/bpf_iter.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/kernel/bpf/bpf_iter.c b/kernel/bpf/bpf_iter.c index 7e8fd49406f6..4688ba39ef25 100644 --- a/kernel/bpf/bpf_iter.c +++ b/kernel/bpf/bpf_iter.c @@ -198,6 +198,11 @@ static ssize_t bpf_seq_read(struct file *file, char __= user *buf, size_t size, } stop: offs =3D seq->count; + if (IS_ERR(p)) { + seq->op->stop(seq, NULL); + err =3D PTR_ERR(p); + goto done; + } /* bpf program called if !p */ seq->op->stop(seq, p); if (!p) { --=20 2.37.1.559.g78731f0fdb-goog From nobody Sat Apr 20 01:07:07 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id E1BE4C00140 for ; Fri, 5 Aug 2022 21:49:33 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S241553AbiHEVtc (ORCPT ); Fri, 5 Aug 2022 17:49:32 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37446 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241401AbiHEVtQ (ORCPT ); Fri, 5 Aug 2022 17:49:16 -0400 Received: from mail-yw1-x114a.google.com (mail-yw1-x114a.google.com [IPv6:2607:f8b0:4864:20::114a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 171D37B7AB for ; Fri, 5 Aug 2022 14:49:03 -0700 (PDT) Received: by mail-yw1-x114a.google.com with SMTP id 00721157ae682-3225b644be1so31279887b3.1 for ; Fri, 05 Aug 2022 14:49:03 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:references:mime-version:message-id:in-reply-to :date:from:to:cc; bh=jRQ+0kS3BTBBGvIFgwSUORt0aQ9BHZC04Nf8excWPsM=; b=ChF3h+hZpYfN/dZrEcNiR3cpKcFzgYLSVjY4ewXTfcLgk8NDHK4LVD1f3wbsJrT49M ru4VXucEjipc9AoIwW/przG5ggAtJipjZZHp423qiK6IK5tfa7YWPo3rA/MqLY6bmqTL Yuvo7N2xMhTrNwiYOva8VSfgn0P9BAz7U/x14Jpvt3kd8fhbwOu/4GnIyTCL0xnQT3gT /SHtTgI7WKwzGz2gjkDQHQjd1/BUD3q71wJzVahzAaoUDLIYUHES5GHRaYuWy9wYGHjl eAu+bwx5mwllz7EvezT+uxBaQVq27x3yYIqloqvEybN7WvxqRvEuTq/Zu71FVAlMAZKj CQCQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:references:mime-version:message-id:in-reply-to :date:x-gm-message-state:from:to:cc; bh=jRQ+0kS3BTBBGvIFgwSUORt0aQ9BHZC04Nf8excWPsM=; b=XKnm06h72MA4we0G5p7eRB8J4BqYN2CyZOPJtlWzBQr2Tty00mTK/VXLpkh9aISLo7 muW+FPs3t++I/bxHzhu1PaYgXzxDLvdI7T50IJ3ucaWLM6L/FQ3jbxswbSijJJAhVVju ILWEdISyopYHcHRAm0d7Poosnumb+eAj/SOkrjFELnXWvtkvAo4iJib+/R8AQlCWiDZc hhACDklqUBK3OuVNospnwejeJxL0ogmU2Z3ssoYZTuTY5wyrbA9KZT8xRb6RhdEGz4Os 2qfVkWHHP6oUIrRs9pNW55SpuHrHbTCRDo0ZhrLYHH6M3kqAXKbV7LcihVy2mBtjUCmL fHbA== X-Gm-Message-State: ACgBeo3rVi/iFzN/2nXTIndzH36IaOBMmjSeBG/3vVfV1qUCkqPdV+fc 5rjimdfD4gVmKa9bRPUPXVr8W2nEvobxxJI65nCnge9wuEb2bySMpfwf1b7AdjLI/Au4lf2LcfQ /CjcE4HAqdOIeZc2T//FE+KLEXtADhHntgtdqzVedGwFLAoFKV3BuzQd9azqTduDAKHaC4g== X-Google-Smtp-Source: AA6agR55ld0sRMI68ywvlMAMvuj/gy+QTpiHUgUMGXniT0TQpDeRMPNlawiYP1hmsEwVEzEl6DRiZqDlCgs= X-Received: from haoluo.svl.corp.google.com ([2620:15c:2d4:203:4f27:97db:8644:dc82]) (user=haoluo job=sendgmr) by 2002:a05:6902:70e:b0:67b:7d78:5d3d with SMTP id k14-20020a056902070e00b0067b7d785d3dmr5127604ybt.547.1659736142180; Fri, 05 Aug 2022 14:49:02 -0700 (PDT) Date: Fri, 5 Aug 2022 14:48:17 -0700 In-Reply-To: <20220805214821.1058337-1-haoluo@google.com> Message-Id: <20220805214821.1058337-5-haoluo@google.com> Mime-Version: 1.0 References: <20220805214821.1058337-1-haoluo@google.com> X-Mailer: git-send-email 2.37.1.559.g78731f0fdb-goog Subject: [PATCH bpf-next v7 4/8] bpf: Introduce cgroup iter From: Hao Luo To: linux-kernel@vger.kernel.org, bpf@vger.kernel.org, cgroups@vger.kernel.org, netdev@vger.kernel.org Cc: Alexei Starovoitov , Andrii Nakryiko , Daniel Borkmann , Martin KaFai Lau , Song Liu , Yonghong Song , Tejun Heo , Zefan Li , KP Singh , Johannes Weiner , Michal Hocko , Benjamin Tissoires , John Fastabend , Michal Koutny , Roman Gushchin , David Rientjes , Stanislav Fomichev , Shakeel Butt , Yosry Ahmed , Hao Luo Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Cgroup_iter is a type of bpf_iter. It walks over cgroups in four modes: - walking a cgroup's descendants in pre-order. - walking a cgroup's descendants in post-order. - walking a cgroup's ancestors. - process only the given cgroup. When attaching cgroup_iter, one can set a cgroup to the iter_link created from attaching. This cgroup is passed as a file descriptor or cgroup id and serves as the starting point of the walk. If no cgroup is specified, the starting point will be the root cgroup v2. For walking descendants, one can specify the order: either pre-order or post-order. For walking ancestors, the walk starts at the specified cgroup and ends at the root. One can also terminate the walk early by returning 1 from the iter program. Note that because walking cgroup hierarchy holds cgroup_mutex, the iter program is called with cgroup_mutex held. Currently only one session is supported, which means, depending on the volume of data bpf program intends to send to user space, the number of cgroups that can be walked is limited. For example, given the current buffer size is 8 * PAGE_SIZE, if the program sends 64B data for each cgroup, assuming PAGE_SIZE is 4kb, the total number of cgroups that can be walked is 512. This is a limitation of cgroup_iter. If the output data is larger than the kernel buffer size, after all data in the kernel buffer is consumed by user space, the subsequent read() syscall will signal EOPNOTSUPP. In order to work around, the user may have to update their program to reduce the volume of data sent to output. For example, skip some uninteresting cgroups. In future, we may extend bpf_iter flags to allow customizing buffer size. Acked-by: Yonghong Song Acked-by: Tejun Heo Signed-off-by: Hao Luo --- include/linux/bpf.h | 8 + include/uapi/linux/bpf.h | 38 +++ kernel/bpf/Makefile | 3 + kernel/bpf/cgroup_iter.c | 286 ++++++++++++++++++ tools/include/uapi/linux/bpf.h | 38 +++ .../selftests/bpf/prog_tests/btf_dump.c | 4 +- 6 files changed, 375 insertions(+), 2 deletions(-) create mode 100644 kernel/bpf/cgroup_iter.c diff --git a/include/linux/bpf.h b/include/linux/bpf.h index 20c26aed7896..09b5c2167424 100644 --- a/include/linux/bpf.h +++ b/include/linux/bpf.h @@ -48,6 +48,7 @@ struct mem_cgroup; struct module; struct bpf_func_state; struct ftrace_ops; +struct cgroup; =20 extern struct idr btf_idr; extern spinlock_t btf_idr_lock; @@ -1730,7 +1731,14 @@ int bpf_obj_get_user(const char __user *pathname, in= t flags); int __init bpf_iter_ ## target(args) { return 0; } =20 struct bpf_iter_aux_info { + /* for map_elem iter */ struct bpf_map *map; + + /* for cgroup iter */ + struct { + struct cgroup *start; /* starting cgroup */ + int order; + } cgroup; }; =20 typedef int (*bpf_iter_attach_target_t)(struct bpf_prog *prog, diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h index 59a217ca2dfd..4d758b2e70d6 100644 --- a/include/uapi/linux/bpf.h +++ b/include/uapi/linux/bpf.h @@ -87,10 +87,37 @@ struct bpf_cgroup_storage_key { __u32 attach_type; /* program attach type (enum bpf_attach_type) */ }; =20 +enum bpf_iter_order { + BPF_ITER_ORDER_DEFAULT =3D 0, /* default order. */ + BPF_ITER_SELF, /* process only a single object. */ + BPF_ITER_DESCENDANTS_PRE, /* walk descendants in pre-order. */ + BPF_ITER_DESCENDANTS_POST, /* walk descendants in post-order. */ + BPF_ITER_ANCESTORS_UP, /* walk ancestors upward. */ +}; + union bpf_iter_link_info { struct { __u32 map_fd; } map; + struct { + /* Valid values include: + * - BPF_ITER_ORDER_DEFAULT + * - BPF_ITER_SELF + * - BPF_ITER_DESCENDANTS_PRE + * - BPF_ITER_DESCENDANTS_POST + * - BPF_ITER_ANCESTORS_UP + * for cgroup_iter, DEFAULT is equivalent to DESCENDANTS_PRE. + */ + __u32 order; + + /* At most one of cgroup_fd and cgroup_id can be non-zero. If + * both are zero, the walk starts from the default cgroup v2 + * root. For walking v1 hierarchy, one should always explicitly + * specify cgroup_fd. + */ + __u32 cgroup_fd; + __u64 cgroup_id; + } cgroup; }; =20 /* BPF syscall commands, see bpf(2) man-page for more details. */ @@ -6134,11 +6161,22 @@ struct bpf_link_info { struct { __aligned_u64 target_name; /* in/out: target_name buffer ptr */ __u32 target_name_len; /* in/out: target_name buffer len */ + + /* If the iter specific field is 32 bits, it can be put + * in the first or second union. Otherwise it should be + * put in the second union. + */ union { struct { __u32 map_id; } map; }; + union { + struct { + __u64 cgroup_id; + __u32 order; + } cgroup; + }; } iter; struct { __u32 netns_ino; diff --git a/kernel/bpf/Makefile b/kernel/bpf/Makefile index 057ba8e01e70..00e05b69a4df 100644 --- a/kernel/bpf/Makefile +++ b/kernel/bpf/Makefile @@ -24,6 +24,9 @@ endif ifeq ($(CONFIG_PERF_EVENTS),y) obj-$(CONFIG_BPF_SYSCALL) +=3D stackmap.o endif +ifeq ($(CONFIG_CGROUPS),y) +obj-$(CONFIG_BPF_SYSCALL) +=3D cgroup_iter.o +endif obj-$(CONFIG_CGROUP_BPF) +=3D cgroup.o ifeq ($(CONFIG_INET),y) obj-$(CONFIG_BPF_SYSCALL) +=3D reuseport_array.o diff --git a/kernel/bpf/cgroup_iter.c b/kernel/bpf/cgroup_iter.c new file mode 100644 index 000000000000..c469252d0536 --- /dev/null +++ b/kernel/bpf/cgroup_iter.c @@ -0,0 +1,286 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* Copyright (c) 2022 Google */ +#include +#include +#include +#include +#include + +#include "../cgroup/cgroup-internal.h" /* cgroup_mutex and cgroup_is_dead= */ + +/* cgroup_iter provides four modes of traversal to the cgroup hierarchy. + * + * 1. Walk the descendants of a cgroup in pre-order. + * 2. Walk the descendants of a cgroup in post-order. + * 3. Walk the ancestors of a cgroup. + * 4. Show the given cgroup only. + * + * For walking descendants, cgroup_iter can walk in either pre-order or + * post-order. For walking ancestors, the iter walks up from a cgroup to + * the root. + * + * The iter program can terminate the walk early by returning 1. Walk + * continues if prog returns 0. + * + * The prog can check (seq->num =3D=3D 0) to determine whether this is + * the first element. The prog may also be passed a NULL cgroup, + * which means the walk has completed and the prog has a chance to + * do post-processing, such as outputing an epilogue. + * + * Note: the iter_prog is called with cgroup_mutex held. + * + * Currently only one session is supported, which means, depending on the + * volume of data bpf program intends to send to user space, the number + * of cgroups that can be walked is limited. For example, given the current + * buffer size is 8 * PAGE_SIZE, if the program sends 64B data for each + * cgroup, assuming PAGE_SIZE is 4kb, the total number of cgroups that can + * be walked is 512. This is a limitation of cgroup_iter. If the output da= ta + * is larger than the kernel buffer size, after all data in the kernel buf= fer + * is consumed by user space, the subsequent read() syscall will signal + * EOPNOTSUPP. In order to work around, the user may have to update their + * program to reduce the volume of data sent to output. For example, skip + * some uninteresting cgroups. + */ + +struct bpf_iter__cgroup { + __bpf_md_ptr(struct bpf_iter_meta *, meta); + __bpf_md_ptr(struct cgroup *, cgroup); +}; + +struct cgroup_iter_priv { + struct cgroup_subsys_state *start_css; + bool visited_all; + bool terminate; + int order; +}; + +static void *cgroup_iter_seq_start(struct seq_file *seq, loff_t *pos) +{ + struct cgroup_iter_priv *p =3D seq->private; + + mutex_lock(&cgroup_mutex); + + /* cgroup_iter doesn't support read across multiple sessions. */ + if (*pos > 0) { + if (p->visited_all) + return NULL; + + /* Haven't visited all, but because cgroup_mutex has dropped, + * return -EOPNOTSUPP to indicate incomplete iteration. + */ + return ERR_PTR(-EOPNOTSUPP); + } + + ++*pos; + p->terminate =3D false; + p->visited_all =3D false; + if (p->order =3D=3D BPF_ITER_DESCENDANTS_PRE) + return css_next_descendant_pre(NULL, p->start_css); + else if (p->order =3D=3D BPF_ITER_DESCENDANTS_POST) + return css_next_descendant_post(NULL, p->start_css); + else if (p->order =3D=3D BPF_ITER_ANCESTORS_UP) + return p->start_css; + else /* BPF_ITER_SELF */ + return p->start_css; +} + +static int __cgroup_iter_seq_show(struct seq_file *seq, + struct cgroup_subsys_state *css, int in_stop); + +static void cgroup_iter_seq_stop(struct seq_file *seq, void *v) +{ + struct cgroup_iter_priv *p =3D seq->private; + + mutex_unlock(&cgroup_mutex); + + /* pass NULL to the prog for post-processing */ + if (!v) { + __cgroup_iter_seq_show(seq, NULL, true); + p->visited_all =3D true; + } +} + +static void *cgroup_iter_seq_next(struct seq_file *seq, void *v, loff_t *p= os) +{ + struct cgroup_subsys_state *curr =3D (struct cgroup_subsys_state *)v; + struct cgroup_iter_priv *p =3D seq->private; + + ++*pos; + if (p->terminate) + return NULL; + + if (p->order =3D=3D BPF_ITER_DESCENDANTS_PRE) + return css_next_descendant_pre(curr, p->start_css); + else if (p->order =3D=3D BPF_ITER_DESCENDANTS_POST) + return css_next_descendant_post(curr, p->start_css); + else if (p->order =3D=3D BPF_ITER_ANCESTORS_UP) + return curr->parent; + else /* BPF_ITER_SELF */ + return NULL; +} + +static int __cgroup_iter_seq_show(struct seq_file *seq, + struct cgroup_subsys_state *css, int in_stop) +{ + struct cgroup_iter_priv *p =3D seq->private; + struct bpf_iter__cgroup ctx; + struct bpf_iter_meta meta; + struct bpf_prog *prog; + int ret =3D 0; + + /* cgroup is dead, skip this element */ + if (css && cgroup_is_dead(css->cgroup)) + return 0; + + ctx.meta =3D &meta; + ctx.cgroup =3D css ? css->cgroup : NULL; + meta.seq =3D seq; + prog =3D bpf_iter_get_info(&meta, in_stop); + if (prog) + ret =3D bpf_iter_run_prog(prog, &ctx); + + /* if prog returns > 0, terminate after this element. */ + if (ret !=3D 0) + p->terminate =3D true; + + return 0; +} + +static int cgroup_iter_seq_show(struct seq_file *seq, void *v) +{ + return __cgroup_iter_seq_show(seq, (struct cgroup_subsys_state *)v, + false); +} + +static const struct seq_operations cgroup_iter_seq_ops =3D { + .start =3D cgroup_iter_seq_start, + .next =3D cgroup_iter_seq_next, + .stop =3D cgroup_iter_seq_stop, + .show =3D cgroup_iter_seq_show, +}; + +BTF_ID_LIST_SINGLE(bpf_cgroup_btf_id, struct, cgroup) + +static int cgroup_iter_seq_init(void *priv, struct bpf_iter_aux_info *aux) +{ + struct cgroup_iter_priv *p =3D (struct cgroup_iter_priv *)priv; + struct cgroup *cgrp =3D aux->cgroup.start; + + p->start_css =3D &cgrp->self; + p->terminate =3D false; + p->visited_all =3D false; + p->order =3D aux->cgroup.order; + return 0; +} + +static const struct bpf_iter_seq_info cgroup_iter_seq_info =3D { + .seq_ops =3D &cgroup_iter_seq_ops, + .init_seq_private =3D cgroup_iter_seq_init, + .seq_priv_size =3D sizeof(struct cgroup_iter_priv), +}; + +static int bpf_iter_attach_cgroup(struct bpf_prog *prog, + union bpf_iter_link_info *linfo, + struct bpf_iter_aux_info *aux) +{ + int fd =3D linfo->cgroup.cgroup_fd; + u64 id =3D linfo->cgroup.cgroup_id; + int order =3D linfo->cgroup.order; + struct cgroup *cgrp; + + if (order =3D=3D BPF_ITER_ORDER_DEFAULT) + order =3D BPF_ITER_DESCENDANTS_PRE; + + if (order !=3D BPF_ITER_DESCENDANTS_PRE && + order !=3D BPF_ITER_DESCENDANTS_POST && + order !=3D BPF_ITER_ANCESTORS_UP && + order !=3D BPF_ITER_SELF) + return -EINVAL; + + if (fd && id) + return -EINVAL; + + if (fd) + cgrp =3D cgroup_get_from_fd(fd); + else if (id) + cgrp =3D cgroup_get_from_id(id); + else /* walk the entire hierarchy by default. */ + cgrp =3D cgroup_get_from_path("/"); + + if (IS_ERR(cgrp)) + return PTR_ERR(cgrp); + + aux->cgroup.start =3D cgrp; + aux->cgroup.order =3D order; + return 0; +} + +static void bpf_iter_detach_cgroup(struct bpf_iter_aux_info *aux) +{ + cgroup_put(aux->cgroup.start); +} + +static void bpf_iter_cgroup_show_fdinfo(const struct bpf_iter_aux_info *au= x, + struct seq_file *seq) +{ + char *buf; + + buf =3D kzalloc(PATH_MAX, GFP_KERNEL); + if (!buf) { + seq_puts(seq, "cgroup_path:\t\n"); + goto show_order; + } + + /* If cgroup_path_ns() fails, buf will be an empty string, cgroup_path + * will print nothing. + * + * Path is in the calling process's cgroup namespace. + */ + cgroup_path_ns(aux->cgroup.start, buf, PATH_MAX, + current->nsproxy->cgroup_ns); + seq_printf(seq, "cgroup_path:\t%s\n", buf); + kfree(buf); + +show_order: + if (aux->cgroup.order =3D=3D BPF_ITER_DESCENDANTS_PRE) + seq_puts(seq, "order: pre\n"); + else if (aux->cgroup.order =3D=3D BPF_ITER_DESCENDANTS_POST) + seq_puts(seq, "order: post\n"); + else if (aux->cgroup.order =3D=3D BPF_ITER_ANCESTORS_UP) + seq_puts(seq, "order: up\n"); + else /* BPF_ITER_SELF */ + seq_puts(seq, "order: self\n"); +} + +static int bpf_iter_cgroup_fill_link_info(const struct bpf_iter_aux_info *= aux, + struct bpf_link_info *info) +{ + info->iter.cgroup.order =3D aux->cgroup.order; + info->iter.cgroup.cgroup_id =3D cgroup_id(aux->cgroup.start); + return 0; +} + +DEFINE_BPF_ITER_FUNC(cgroup, struct bpf_iter_meta *meta, + struct cgroup *cgroup) + +static struct bpf_iter_reg bpf_cgroup_reg_info =3D { + .target =3D "cgroup", + .attach_target =3D bpf_iter_attach_cgroup, + .detach_target =3D bpf_iter_detach_cgroup, + .show_fdinfo =3D bpf_iter_cgroup_show_fdinfo, + .fill_link_info =3D bpf_iter_cgroup_fill_link_info, + .ctx_arg_info_size =3D 1, + .ctx_arg_info =3D { + { offsetof(struct bpf_iter__cgroup, cgroup), + PTR_TO_BTF_ID_OR_NULL }, + }, + .seq_info =3D &cgroup_iter_seq_info, +}; + +static int __init bpf_cgroup_iter_init(void) +{ + bpf_cgroup_reg_info.ctx_arg_info[0].btf_id =3D bpf_cgroup_btf_id[0]; + return bpf_iter_reg_target(&bpf_cgroup_reg_info); +} + +late_initcall(bpf_cgroup_iter_init); diff --git a/tools/include/uapi/linux/bpf.h b/tools/include/uapi/linux/bpf.h index 59a217ca2dfd..4d758b2e70d6 100644 --- a/tools/include/uapi/linux/bpf.h +++ b/tools/include/uapi/linux/bpf.h @@ -87,10 +87,37 @@ struct bpf_cgroup_storage_key { __u32 attach_type; /* program attach type (enum bpf_attach_type) */ }; =20 +enum bpf_iter_order { + BPF_ITER_ORDER_DEFAULT =3D 0, /* default order. */ + BPF_ITER_SELF, /* process only a single object. */ + BPF_ITER_DESCENDANTS_PRE, /* walk descendants in pre-order. */ + BPF_ITER_DESCENDANTS_POST, /* walk descendants in post-order. */ + BPF_ITER_ANCESTORS_UP, /* walk ancestors upward. */ +}; + union bpf_iter_link_info { struct { __u32 map_fd; } map; + struct { + /* Valid values include: + * - BPF_ITER_ORDER_DEFAULT + * - BPF_ITER_SELF + * - BPF_ITER_DESCENDANTS_PRE + * - BPF_ITER_DESCENDANTS_POST + * - BPF_ITER_ANCESTORS_UP + * for cgroup_iter, DEFAULT is equivalent to DESCENDANTS_PRE. + */ + __u32 order; + + /* At most one of cgroup_fd and cgroup_id can be non-zero. If + * both are zero, the walk starts from the default cgroup v2 + * root. For walking v1 hierarchy, one should always explicitly + * specify cgroup_fd. + */ + __u32 cgroup_fd; + __u64 cgroup_id; + } cgroup; }; =20 /* BPF syscall commands, see bpf(2) man-page for more details. */ @@ -6134,11 +6161,22 @@ struct bpf_link_info { struct { __aligned_u64 target_name; /* in/out: target_name buffer ptr */ __u32 target_name_len; /* in/out: target_name buffer len */ + + /* If the iter specific field is 32 bits, it can be put + * in the first or second union. Otherwise it should be + * put in the second union. + */ union { struct { __u32 map_id; } map; }; + union { + struct { + __u64 cgroup_id; + __u32 order; + } cgroup; + }; } iter; struct { __u32 netns_ino; diff --git a/tools/testing/selftests/bpf/prog_tests/btf_dump.c b/tools/test= ing/selftests/bpf/prog_tests/btf_dump.c index 5fce7008d1ff..84c1cfaa2b02 100644 --- a/tools/testing/selftests/bpf/prog_tests/btf_dump.c +++ b/tools/testing/selftests/bpf/prog_tests/btf_dump.c @@ -764,8 +764,8 @@ static void test_btf_dump_struct_data(struct btf *btf, = struct btf_dump *d, =20 /* union with nested struct */ TEST_BTF_DUMP_DATA(btf, d, "union", str, union bpf_iter_link_info, BTF_F_= COMPACT, - "(union bpf_iter_link_info){.map =3D (struct){.map_fd =3D (__u32)1,}= ,}", - { .map =3D { .map_fd =3D 1 }}); + "(union bpf_iter_link_info){.map =3D (struct){.map_fd =3D (__u32)1,}= ,.cgroup =3D (struct){.order =3D (__u32)1,.cgroup_fd =3D (__u32)1,},}", + { .cgroup =3D { .order =3D 1, .cgroup_fd =3D 1, }}); =20 /* struct skb with nested structs/unions; because type output is so * complex, we don't do a string comparison, just verify we return --=20 2.37.1.559.g78731f0fdb-goog From nobody Sat Apr 20 01:07:07 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 71EDFC25B0D for ; Fri, 5 Aug 2022 21:49:58 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S241604AbiHEVt4 (ORCPT ); Fri, 5 Aug 2022 17:49:56 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37458 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241518AbiHEVtT (ORCPT ); Fri, 5 Aug 2022 17:49:19 -0400 Received: from mail-yb1-xb49.google.com (mail-yb1-xb49.google.com [IPv6:2607:f8b0:4864:20::b49]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 70EB37B7BB for ; Fri, 5 Aug 2022 14:49:05 -0700 (PDT) Received: by mail-yb1-xb49.google.com with SMTP id bu13-20020a056902090d00b00671743601f1so3079014ybb.0 for ; Fri, 05 Aug 2022 14:49:05 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:references:mime-version:message-id:in-reply-to :date:from:to:cc; bh=dW0ve3RUvl44+rGQsS2/0XtznS0SegZN0HeyfaKymhE=; b=FcM0K74GRCShcr+t25k4c6LpPObXcalMOseAQUOPUmOz8OlCvrqvzMCK6Y9vAnZCnR UWm6akwdnzmxv4tKEYumVs4qhmOdm7CvK8Mq1AxbQUjSyn6MLXhGcVyfB3u5fj98/SoH j1GyJedYdFi+hi94L8+l+N3KMKuc6xzEc/hgj4DMiBsGrWCFdNYxSUciMpoY5hPX7GgC /vBy25ST6Dmy8u+Vu1qHgOPy1ZrdlTvTZ0D+kpjQ6z0pbHlSfF47Ci1M1UoSnFfYg04D b0FqIg2n9BK3ii/5Rzg8vyN9hwg6FD/rGR33N3ciXCIGe3RC3DLbjrR8hypKMcIj8sBI GgdQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:references:mime-version:message-id:in-reply-to :date:x-gm-message-state:from:to:cc; bh=dW0ve3RUvl44+rGQsS2/0XtznS0SegZN0HeyfaKymhE=; b=COWNMkBAmtgMXPAnqGtEbCZ1CasR0NBmUb6/hMf/pxpzY3Hxms+hZsHROE06YQ55Ax WrV6YNY/tXgIWsKN8GnOGmOgyWTQX2DJoTtjV29u7XfLjsxDkpM6h57scQTOimrj4etr 79k79+T5w00qh4keP6snP060xVPOdgS7m4p+rgDTtEM+RqVrkMtC6pPxTv9HFsnMCqh+ fz9BUZnuzX8HGr3QBrubRW6+zh1gJ214jwjEiumxPQF8iyhI5uhIkre/UMYsOOEci6gI 82tsD7cftwVFy0Z5edhiL6Vkf4Ekk23NeDqUKi3Sli0lA2f18YIpa+tMHNaiKvDUo64E 5tBQ== X-Gm-Message-State: ACgBeo3u8/jqlze0YtwOfZvqb8sNkuV15YvZqrXmbvqXnd3x9TIOqHCi KWc+HPGQHi3E1S4Y0OC7XUQHBuBK+KIQeRBq+gLQdI6n74rUfLijyuEGj+zqwRFqEkrGGBHpLZv 11rG69ctU8NV3UNM34Kof7/zCP7XlVLpLtB/Rt6IZ9fCWelG8VYAl8bcloW0XbzoYheTbDA== X-Google-Smtp-Source: AA6agR6nqiUN1zJwKWDLlC3MaFMaq7bJS40bsbIdwFRa46fTPWzn4D4FD/O9FlJ5WaEOnI7mPX2xy4JHCc4= X-Received: from haoluo.svl.corp.google.com ([2620:15c:2d4:203:4f27:97db:8644:dc82]) (user=haoluo job=sendgmr) by 2002:a25:ba45:0:b0:67a:6298:7bac with SMTP id z5-20020a25ba45000000b0067a62987bacmr7766888ybj.194.1659736144843; Fri, 05 Aug 2022 14:49:04 -0700 (PDT) Date: Fri, 5 Aug 2022 14:48:18 -0700 In-Reply-To: <20220805214821.1058337-1-haoluo@google.com> Message-Id: <20220805214821.1058337-6-haoluo@google.com> Mime-Version: 1.0 References: <20220805214821.1058337-1-haoluo@google.com> X-Mailer: git-send-email 2.37.1.559.g78731f0fdb-goog Subject: [PATCH bpf-next v7 5/8] selftests/bpf: Test cgroup_iter. From: Hao Luo To: linux-kernel@vger.kernel.org, bpf@vger.kernel.org, cgroups@vger.kernel.org, netdev@vger.kernel.org Cc: Alexei Starovoitov , Andrii Nakryiko , Daniel Borkmann , Martin KaFai Lau , Song Liu , Yonghong Song , Tejun Heo , Zefan Li , KP Singh , Johannes Weiner , Michal Hocko , Benjamin Tissoires , John Fastabend , Michal Koutny , Roman Gushchin , David Rientjes , Stanislav Fomichev , Shakeel Butt , Yosry Ahmed , Hao Luo Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add a selftest for cgroup_iter. The selftest creates a mini cgroup tree of the following structure: ROOT (working cgroup) | PARENT / \ CHILD1 CHILD2 and tests the following scenarios: - invalid cgroup fd. - pre-order walk over descendants from PARENT. - post-order walk over descendants from PARENT. - walk of ancestors from PARENT. - walk from PARENT in the default order, which is pre-order. - process only a single object (i.e. PARENT). - early termination. Acked-by: Yonghong Song Signed-off-by: Hao Luo Acked-by: Andrii Nakryiko --- .../selftests/bpf/prog_tests/cgroup_iter.c | 237 ++++++++++++++++++ tools/testing/selftests/bpf/progs/bpf_iter.h | 7 + .../testing/selftests/bpf/progs/cgroup_iter.c | 39 +++ 3 files changed, 283 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/cgroup_iter.c create mode 100644 tools/testing/selftests/bpf/progs/cgroup_iter.c diff --git a/tools/testing/selftests/bpf/prog_tests/cgroup_iter.c b/tools/t= esting/selftests/bpf/prog_tests/cgroup_iter.c new file mode 100644 index 000000000000..f9ab31a63c69 --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/cgroup_iter.c @@ -0,0 +1,237 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2022 Google */ + +#include +#include +#include +#include "cgroup_iter.skel.h" +#include "cgroup_helpers.h" + +#define ROOT 0 +#define PARENT 1 +#define CHILD1 2 +#define CHILD2 3 +#define NUM_CGROUPS 4 + +#define PROLOGUE "prologue\n" +#define EPILOGUE "epilogue\n" + +static const char *cg_path[] =3D { + "/", "/parent", "/parent/child1", "/parent/child2" +}; + +static int cg_fd[] =3D {-1, -1, -1, -1}; +static unsigned long long cg_id[] =3D {0, 0, 0, 0}; +static char expected_output[64]; + +static int setup_cgroups(void) +{ + int fd, i =3D 0; + + for (i =3D 0; i < NUM_CGROUPS; i++) { + fd =3D create_and_get_cgroup(cg_path[i]); + if (fd < 0) + return fd; + + cg_fd[i] =3D fd; + cg_id[i] =3D get_cgroup_id(cg_path[i]); + } + return 0; +} + +static void cleanup_cgroups(void) +{ + int i; + + for (i =3D 0; i < NUM_CGROUPS; i++) + close(cg_fd[i]); +} + +static void read_from_cgroup_iter(struct bpf_program *prog, int cgroup_fd, + int order, const char *testname) +{ + DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts); + union bpf_iter_link_info linfo; + struct bpf_link *link; + int len, iter_fd; + static char buf[128]; + size_t left; + char *p; + + memset(&linfo, 0, sizeof(linfo)); + linfo.cgroup.cgroup_fd =3D cgroup_fd; + linfo.cgroup.order =3D order; + opts.link_info =3D &linfo; + opts.link_info_len =3D sizeof(linfo); + + link =3D bpf_program__attach_iter(prog, &opts); + if (!ASSERT_OK_PTR(link, "attach_iter")) + return; + + iter_fd =3D bpf_iter_create(bpf_link__fd(link)); + if (iter_fd < 0) + goto free_link; + + memset(buf, 0, sizeof(buf)); + left =3D ARRAY_SIZE(buf); + p =3D buf; + while ((len =3D read(iter_fd, p, left)) > 0) { + p +=3D len; + left -=3D len; + } + + ASSERT_STREQ(buf, expected_output, testname); + + /* read() after iter finishes should be ok. */ + if (len =3D=3D 0) + ASSERT_OK(read(iter_fd, buf, sizeof(buf)), "second_read"); + + close(iter_fd); +free_link: + bpf_link__destroy(link); +} + +/* Invalid cgroup. */ +static void test_invalid_cgroup(struct cgroup_iter *skel) +{ + DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts); + union bpf_iter_link_info linfo; + struct bpf_link *link; + + memset(&linfo, 0, sizeof(linfo)); + linfo.cgroup.cgroup_fd =3D (__u32)-1; + opts.link_info =3D &linfo; + opts.link_info_len =3D sizeof(linfo); + + link =3D bpf_program__attach_iter(skel->progs.cgroup_id_printer, &opts); + ASSERT_ERR_PTR(link, "attach_iter"); + bpf_link__destroy(link); +} + +/* Specifying both cgroup_fd and cgroup_id is invalid. */ +static void test_invalid_cgroup_spec(struct cgroup_iter *skel) +{ + DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts); + union bpf_iter_link_info linfo; + struct bpf_link *link; + + memset(&linfo, 0, sizeof(linfo)); + linfo.cgroup.cgroup_fd =3D (__u32)cg_fd[PARENT]; + linfo.cgroup.cgroup_id =3D (__u64)cg_id[PARENT]; + opts.link_info =3D &linfo; + opts.link_info_len =3D sizeof(linfo); + + link =3D bpf_program__attach_iter(skel->progs.cgroup_id_printer, &opts); + ASSERT_ERR_PTR(link, "attach_iter"); + bpf_link__destroy(link); +} + +/* Preorder walk prints parent and child in order. */ +static void test_walk_preorder(struct cgroup_iter *skel) +{ + snprintf(expected_output, sizeof(expected_output), + PROLOGUE "%8llu\n%8llu\n%8llu\n" EPILOGUE, + cg_id[PARENT], cg_id[CHILD1], cg_id[CHILD2]); + + read_from_cgroup_iter(skel->progs.cgroup_id_printer, cg_fd[PARENT], + BPF_ITER_DESCENDANTS_PRE, "preorder"); +} + +/* Postorder walk prints child and parent in order. */ +static void test_walk_postorder(struct cgroup_iter *skel) +{ + snprintf(expected_output, sizeof(expected_output), + PROLOGUE "%8llu\n%8llu\n%8llu\n" EPILOGUE, + cg_id[CHILD1], cg_id[CHILD2], cg_id[PARENT]); + + read_from_cgroup_iter(skel->progs.cgroup_id_printer, cg_fd[PARENT], + BPF_ITER_DESCENDANTS_POST, "postorder"); +} + +/* Walking parents prints parent and then root. */ +static void test_walk_ancestors_up(struct cgroup_iter *skel) +{ + /* terminate the walk when ROOT is met. */ + skel->bss->terminal_cgroup =3D cg_id[ROOT]; + + snprintf(expected_output, sizeof(expected_output), + PROLOGUE "%8llu\n%8llu\n" EPILOGUE, + cg_id[PARENT], cg_id[ROOT]); + + read_from_cgroup_iter(skel->progs.cgroup_id_printer, cg_fd[PARENT], + BPF_ITER_ANCESTORS_UP, "ancestors_up"); + + skel->bss->terminal_cgroup =3D 0; +} + +/* Default order is pre-order. */ +static void test_walk_default_order(struct cgroup_iter *skel) +{ + snprintf(expected_output, sizeof(expected_output), + PROLOGUE "%8llu\n%8llu\n%8llu\n" EPILOGUE, + cg_id[PARENT], cg_id[CHILD1], cg_id[CHILD2]); + + read_from_cgroup_iter(skel->progs.cgroup_id_printer, cg_fd[PARENT], + BPF_ITER_ORDER_DEFAULT, "default_order"); +} + +/* Early termination prints parent only. */ +static void test_early_termination(struct cgroup_iter *skel) +{ + /* terminate the walk after the first element is processed. */ + skel->bss->terminate_early =3D 1; + + snprintf(expected_output, sizeof(expected_output), + PROLOGUE "%8llu\n" EPILOGUE, cg_id[PARENT]); + + read_from_cgroup_iter(skel->progs.cgroup_id_printer, cg_fd[PARENT], + BPF_ITER_DESCENDANTS_PRE, "early_termination"); + + skel->bss->terminate_early =3D 0; +} + +/* Waling self prints self only. */ +static void test_walk_self(struct cgroup_iter *skel) +{ + snprintf(expected_output, sizeof(expected_output), + PROLOGUE "%8llu\n" EPILOGUE, cg_id[PARENT]); + + read_from_cgroup_iter(skel->progs.cgroup_id_printer, cg_fd[PARENT], + BPF_ITER_SELF, "self"); +} + +void test_cgroup_iter(void) +{ + struct cgroup_iter *skel =3D NULL; + + if (setup_cgroup_environment()) + return; + + if (setup_cgroups()) + goto out; + + skel =3D cgroup_iter__open_and_load(); + if (!ASSERT_OK_PTR(skel, "cgroup_iter__open_and_load")) + goto out; + + if (test__start_subtest("cgroup_iter__invalid_cgroup")) + test_invalid_cgroup(skel); + if (test__start_subtest("cgroup_iter__invalid_cgroup_spec")) + test_invalid_cgroup_spec(skel); + if (test__start_subtest("cgroup_iter__preorder")) + test_walk_preorder(skel); + if (test__start_subtest("cgroup_iter__postorder")) + test_walk_postorder(skel); + if (test__start_subtest("cgroup_iter__ancestors_up_walk")) + test_walk_ancestors_up(skel); + if (test__start_subtest("cgroup_iter__default_order")) + test_walk_default_order(skel); + if (test__start_subtest("cgroup_iter__early_termination")) + test_early_termination(skel); + if (test__start_subtest("cgroup_iter__self")) + test_walk_self(skel); +out: + cgroup_iter__destroy(skel); + cleanup_cgroups(); + cleanup_cgroup_environment(); +} diff --git a/tools/testing/selftests/bpf/progs/bpf_iter.h b/tools/testing/s= elftests/bpf/progs/bpf_iter.h index e9846606690d..c41ee80533ca 100644 --- a/tools/testing/selftests/bpf/progs/bpf_iter.h +++ b/tools/testing/selftests/bpf/progs/bpf_iter.h @@ -17,6 +17,7 @@ #define bpf_iter__bpf_sk_storage_map bpf_iter__bpf_sk_storage_map___not_us= ed #define bpf_iter__sockmap bpf_iter__sockmap___not_used #define bpf_iter__bpf_link bpf_iter__bpf_link___not_used +#define bpf_iter__cgroup bpf_iter__cgroup___not_used #define btf_ptr btf_ptr___not_used #define BTF_F_COMPACT BTF_F_COMPACT___not_used #define BTF_F_NONAME BTF_F_NONAME___not_used @@ -40,6 +41,7 @@ #undef bpf_iter__bpf_sk_storage_map #undef bpf_iter__sockmap #undef bpf_iter__bpf_link +#undef bpf_iter__cgroup #undef btf_ptr #undef BTF_F_COMPACT #undef BTF_F_NONAME @@ -141,6 +143,11 @@ struct bpf_iter__bpf_link { struct bpf_link *link; }; =20 +struct bpf_iter__cgroup { + struct bpf_iter_meta *meta; + struct cgroup *cgroup; +} __attribute__((preserve_access_index)); + struct btf_ptr { void *ptr; __u32 type_id; diff --git a/tools/testing/selftests/bpf/progs/cgroup_iter.c b/tools/testin= g/selftests/bpf/progs/cgroup_iter.c new file mode 100644 index 000000000000..de03997322a7 --- /dev/null +++ b/tools/testing/selftests/bpf/progs/cgroup_iter.c @@ -0,0 +1,39 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2022 Google */ + +#include "bpf_iter.h" +#include +#include + +char _license[] SEC("license") =3D "GPL"; +int terminate_early =3D 0; +u64 terminal_cgroup =3D 0; + +static inline u64 cgroup_id(struct cgroup *cgrp) +{ + return cgrp->kn->id; +} + +SEC("iter/cgroup") +int cgroup_id_printer(struct bpf_iter__cgroup *ctx) +{ + struct seq_file *seq =3D ctx->meta->seq; + struct cgroup *cgrp =3D ctx->cgroup; + + /* epilogue */ + if (cgrp =3D=3D NULL) { + BPF_SEQ_PRINTF(seq, "epilogue\n"); + return 0; + } + + /* prologue */ + if (ctx->meta->seq_num =3D=3D 0) + BPF_SEQ_PRINTF(seq, "prologue\n"); + + BPF_SEQ_PRINTF(seq, "%8llu\n", cgroup_id(cgrp)); + + if (terminal_cgroup =3D=3D cgroup_id(cgrp)) + return 1; + + return terminate_early ? 1 : 0; +} --=20 2.37.1.559.g78731f0fdb-goog From nobody Sat Apr 20 01:07:07 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id DF425C00140 for ; Fri, 5 Aug 2022 21:50:05 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S241455AbiHEVuD (ORCPT ); Fri, 5 Aug 2022 17:50:03 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37630 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241474AbiHEVtU (ORCPT ); Fri, 5 Aug 2022 17:49:20 -0400 Received: from mail-yw1-x1149.google.com (mail-yw1-x1149.google.com [IPv6:2607:f8b0:4864:20::1149]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 876BF7C196 for ; Fri, 5 Aug 2022 14:49:08 -0700 (PDT) Received: by mail-yw1-x1149.google.com with SMTP id 00721157ae682-324989683fdso31185147b3.12 for ; Fri, 05 Aug 2022 14:49:08 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:references:mime-version:message-id:in-reply-to :date:from:to:cc; bh=C+Iy4ZCmB+ISavp/KSQWytbBtP5lX7pymE33Bes2CKQ=; b=eWABbD0wEBZOZlr5Zxc+y9xa0WYiJXB933g0IcK7klW7bckEWUQPNrAZdSP/zvSvLW /qqJwW4ApuiEKDYMyCizboSkhJO/G8E5H34PUto5S7x3QiRM7LeykuPS717hUiNMlw3F 8r6tys6QW4axOrirrPb6gD9/hfGMIs8j71MmyXNV20cWpt0tECW0xZ1Mbuu0et56o4AT FCHHVTjnNtJv5MgzzJ19ooCuZ+gP/OCrTza6AOW27h+awBfK1IN/zpIEkHbGIasb9shA aJFaEGmjdqAUIFol8na6n0wGw8Hv+jJuYmOq4+c9qkUFUz4H9Z/Fsc55cr/6Gzk6peRQ V1fA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:references:mime-version:message-id:in-reply-to :date:x-gm-message-state:from:to:cc; bh=C+Iy4ZCmB+ISavp/KSQWytbBtP5lX7pymE33Bes2CKQ=; b=dyQUOXUoaTDookvP7EWWaUthcaUdQoBkuWt8c2vl9Ur2JnhqqhhhqeaUKH+n3ZZi9R Sp4l7lQdghj/7sC3gg2K4it2hZQepYI39mDQudoQqIhhKerRKtsH9tTevxf16JIp8eAN Hwzz2udnJlpb893LShY0o4nK8BiEj2sgBmAIi+qsNxoHJImSat469A+QeFW/cbQjFXan WNcimmDIKgOjlWBcXrDLqzX1EJ2mKpkGKexObatDhyQ7B7JambFQH7vJTykSpNGJ9v3I +qnvDIbkSdCLeTsOOKVpFEyiWY6VcdgbDR5R/oGIJVi0LWiVoPfKsQy8DxiC9BG8PROe 6wrg== X-Gm-Message-State: ACgBeo1lGFy2vtglIDV4N+NDg1bpVewxf0hjyuY02MQXSDoJh1VBeNQa nC7sdlg6lu2/uTyIUHY0pmNjIul0ZcU8twy/2/qqzj4EI9otl4s5014RxVpB7lB8XV30cSlbGqL WKALbStddqmAqZnvqnl5jT+uLgpv48DUdOLiCGVwy9DHMcBJb+w4/MMJZHsUXqe/SGJjvEg== X-Google-Smtp-Source: AA6agR6oApV2VR6d1hzkIVMBvq2n1ZAptIKvBvNi/0IvHg47EVLMEGCeBs8FdNtfREII8+b6YLAN3zRptFY= X-Received: from haoluo.svl.corp.google.com ([2620:15c:2d4:203:4f27:97db:8644:dc82]) (user=haoluo job=sendgmr) by 2002:a25:b9d0:0:b0:67a:6b9a:ef84 with SMTP id y16-20020a25b9d0000000b0067a6b9aef84mr6860219ybj.282.1659736147449; Fri, 05 Aug 2022 14:49:07 -0700 (PDT) Date: Fri, 5 Aug 2022 14:48:19 -0700 In-Reply-To: <20220805214821.1058337-1-haoluo@google.com> Message-Id: <20220805214821.1058337-7-haoluo@google.com> Mime-Version: 1.0 References: <20220805214821.1058337-1-haoluo@google.com> X-Mailer: git-send-email 2.37.1.559.g78731f0fdb-goog Subject: [PATCH bpf-next v7 6/8] cgroup: bpf: enable bpf programs to integrate with rstat From: Hao Luo To: linux-kernel@vger.kernel.org, bpf@vger.kernel.org, cgroups@vger.kernel.org, netdev@vger.kernel.org Cc: Alexei Starovoitov , Andrii Nakryiko , Daniel Borkmann , Martin KaFai Lau , Song Liu , Yonghong Song , Tejun Heo , Zefan Li , KP Singh , Johannes Weiner , Michal Hocko , Benjamin Tissoires , John Fastabend , Michal Koutny , Roman Gushchin , David Rientjes , Stanislav Fomichev , Shakeel Butt , Yosry Ahmed , Hao Luo Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Yosry Ahmed Enable bpf programs to make use of rstat to collect cgroup hierarchical stats efficiently: - Add cgroup_rstat_updated() kfunc, for bpf progs that collect stats. - Add cgroup_rstat_flush() sleepable kfunc, for bpf progs that read stats. - Add an empty bpf_rstat_flush() hook that is called during rstat flushing, for bpf progs that flush stats to attach to. Attaching a bpf prog to this hook effectively registers it as a flush callback. Signed-off-by: Yosry Ahmed Acked-by: Tejun Heo Signed-off-by: Hao Luo --- kernel/cgroup/rstat.c | 48 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) diff --git a/kernel/cgroup/rstat.c b/kernel/cgroup/rstat.c index 24b5c2ab5598..3289f6e0d306 100644 --- a/kernel/cgroup/rstat.c +++ b/kernel/cgroup/rstat.c @@ -3,6 +3,10 @@ =20 #include =20 +#include +#include +#include + static DEFINE_SPINLOCK(cgroup_rstat_lock); static DEFINE_PER_CPU(raw_spinlock_t, cgroup_rstat_cpu_lock); =20 @@ -141,6 +145,31 @@ static struct cgroup *cgroup_rstat_cpu_pop_updated(str= uct cgroup *pos, return pos; } =20 +/* + * A hook for bpf stat collectors to attach to and flush their stats. + * Together with providing bpf kfuncs for cgroup_rstat_updated() and + * cgroup_rstat_flush(), this enables a complete workflow where bpf progs = that + * collect cgroup stats can integrate with rstat for efficient flushing. + * + * A static noinline declaration here could cause the compiler to optimize= away + * the function. A global noinline declaration will keep the definition, b= ut may + * optimize away the callsite. Therefore, __weak is needed to ensure that = the + * call is still emitted, by telling the compiler that we don't know what = the + * function might eventually be. + * + * __diag_* below are needed to dismiss the missing prototype warning. + */ +__diag_push(); +__diag_ignore_all("-Wmissing-prototypes", + "kfuncs which will be used in BPF programs"); + +__weak noinline void bpf_rstat_flush(struct cgroup *cgrp, + struct cgroup *parent, int cpu) +{ +} + +__diag_pop(); + /* see cgroup_rstat_flush() */ static void cgroup_rstat_flush_locked(struct cgroup *cgrp, bool may_sleep) __releases(&cgroup_rstat_lock) __acquires(&cgroup_rstat_lock) @@ -168,6 +197,7 @@ static void cgroup_rstat_flush_locked(struct cgroup *cg= rp, bool may_sleep) struct cgroup_subsys_state *css; =20 cgroup_base_stat_flush(pos, cpu); + bpf_rstat_flush(pos, cgroup_parent(pos), cpu); =20 rcu_read_lock(); list_for_each_entry_rcu(css, &pos->rstat_css_list, @@ -469,3 +499,21 @@ void cgroup_base_stat_cputime_show(struct seq_file *se= q) "system_usec %llu\n", usage, utime, stime); } + +/* Add bpf kfuncs for cgroup_rstat_updated() and cgroup_rstat_flush() */ +BTF_SET8_START(bpf_rstat_kfunc_ids) +BTF_ID_FLAGS(func, cgroup_rstat_updated) +BTF_ID_FLAGS(func, cgroup_rstat_flush, KF_SLEEPABLE) +BTF_SET8_END(bpf_rstat_kfunc_ids) + +static const struct btf_kfunc_id_set bpf_rstat_kfunc_set =3D { + .owner =3D THIS_MODULE, + .set =3D &bpf_rstat_kfunc_ids, +}; + +static int __init bpf_rstat_kfunc_init(void) +{ + return register_btf_kfunc_id_set(BPF_PROG_TYPE_TRACING, + &bpf_rstat_kfunc_set); +} +late_initcall(bpf_rstat_kfunc_init); --=20 2.37.1.559.g78731f0fdb-goog From nobody Sat Apr 20 01:07:07 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 57938C19F2D for ; Fri, 5 Aug 2022 21:50:15 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S241640AbiHEVuM (ORCPT ); Fri, 5 Aug 2022 17:50:12 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38510 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241401AbiHEVtl (ORCPT ); Fri, 5 Aug 2022 17:49:41 -0400 Received: from mail-yw1-x1149.google.com (mail-yw1-x1149.google.com [IPv6:2607:f8b0:4864:20::1149]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 3B9C27B794 for ; Fri, 5 Aug 2022 14:49:10 -0700 (PDT) Received: by mail-yw1-x1149.google.com with SMTP id 00721157ae682-32851d0f8beso31037127b3.22 for ; Fri, 05 Aug 2022 14:49:10 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:references:mime-version:message-id:in-reply-to :date:from:to:cc; bh=60VOTA1pgsN2983c233coUD+C6cWIOV0N1M/mLyCmZk=; b=j4fPBFrpsGeMm9iuTuCFlMryx8B+8svFJu1iaOPZTemt0h0OVzPzfBzHC1j3O5eiC+ 0jd+szNOpupqyBIpdeyZ62PO/DrLEleiDm+eA258dDQqdZ7hEHUDnnheQjWSoU84ewbY tcqbNM6/kt7FBStyBPsVjCOr9jNj/8LNJrmAgxIcIbSJO/RwuWMctJ6s9YEv14j6pHuX QAlqEo5KJV5BOxtwfMHHdr2uyjWAbPgyf44IofZKSSVuMjxmrecndwqROgyjREUnwatL c3Lk7IfLClpfzydAJvCanOHQnlX1T5W4MrbuPGnOiunDNJSKMf1n5nvU6+R9q+5s7WhM RD3w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:references:mime-version:message-id:in-reply-to :date:x-gm-message-state:from:to:cc; bh=60VOTA1pgsN2983c233coUD+C6cWIOV0N1M/mLyCmZk=; b=HSluD29c83om+v/2WAXskVoZaEONZ/ti+nmtViDDkQlHFhiQlP6lFRalyjh+zcpwR5 w2d7uvzCBUECPH4hMsfyWBplDtVtiiYdk59O096qMwE9d9ZlHn0SA6OQ7/I7krOM2mrh Pgq7oz6iWLP4sc9ZiuG2bLM+KGJotWG82K5DG9vkx3Qi86eL/wox3ZEeMKRLHM5gsPhU oV2dRN6blTTey5K99JMKkmyD426ZYrYYytAkeMkWr3R066VYInASaY2htAQvmxo66HKG 2IWaZhBdeYDkgpdA3jWlAGRtaPjD6En0mjiSEAmES0XqXnZG8I84MbhtEaPt4Fnc96Ys ZFjA== X-Gm-Message-State: ACgBeo3MqX8q2dDbqDEpTzUFfiX31+ZbjKqXdpfvaHJnQeiJ3WmZjGUj f2r/dCy5od8QL1OBOZ2o+laDytkOy5+a2bgVKAUmp00HODkuBbIFTwpkRyKoctH4VjfVc/Gs9Xz 3zOK+rdea0mLnIVP7zYIwaw47cOYfFoNwjeIa6OIvNXDvmiSvWwx3HepEq28VktjvBL8ZNw== X-Google-Smtp-Source: AA6agR4VQAve8A/46IOBY8uKGmXsN0xDmlrBz01Q755cNXlDY6edzREojLgv1UtqrImz1B100/yfGsFvtZM= X-Received: from haoluo.svl.corp.google.com ([2620:15c:2d4:203:4f27:97db:8644:dc82]) (user=haoluo job=sendgmr) by 2002:a81:892:0:b0:329:28c6:6c35 with SMTP id 140-20020a810892000000b0032928c66c35mr7232234ywi.382.1659736149856; Fri, 05 Aug 2022 14:49:09 -0700 (PDT) Date: Fri, 5 Aug 2022 14:48:20 -0700 In-Reply-To: <20220805214821.1058337-1-haoluo@google.com> Message-Id: <20220805214821.1058337-8-haoluo@google.com> Mime-Version: 1.0 References: <20220805214821.1058337-1-haoluo@google.com> X-Mailer: git-send-email 2.37.1.559.g78731f0fdb-goog Subject: [PATCH bpf-next v7 7/8] selftests/bpf: extend cgroup helpers From: Hao Luo To: linux-kernel@vger.kernel.org, bpf@vger.kernel.org, cgroups@vger.kernel.org, netdev@vger.kernel.org Cc: Alexei Starovoitov , Andrii Nakryiko , Daniel Borkmann , Martin KaFai Lau , Song Liu , Yonghong Song , Tejun Heo , Zefan Li , KP Singh , Johannes Weiner , Michal Hocko , Benjamin Tissoires , John Fastabend , Michal Koutny , Roman Gushchin , David Rientjes , Stanislav Fomichev , Shakeel Butt , Yosry Ahmed , Hao Luo Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Yosry Ahmed This patch extends bpf selft cgroup_helpers [ID] n various ways: - Add enable_controllers() that allows tests to enable all or a subset of controllers for a specific cgroup. - Add join_cgroup_parent(). The cgroup workdir is based on the pid, therefore a spawned child cannot join the same cgroup hierarchy of the test through join_cgroup(). join_cgroup_parent() is used in child processes to join a cgroup under the parent's workdir. - Add write_cgroup_file() and write_cgroup_file_parent() (similar to join_cgroup_parent() above). - Add get_root_cgroup() for tests that need to do checks on root cgroup. - Distinguish relative and absolute cgroup paths in function arguments. Now relative paths are called relative_path, and absolute paths are called cgroup_path. Signed-off-by: Yosry Ahmed Signed-off-by: Hao Luo --- tools/testing/selftests/bpf/cgroup_helpers.c | 202 +++++++++++++++---- tools/testing/selftests/bpf/cgroup_helpers.h | 19 +- 2 files changed, 174 insertions(+), 47 deletions(-) diff --git a/tools/testing/selftests/bpf/cgroup_helpers.c b/tools/testing/s= elftests/bpf/cgroup_helpers.c index 9d59c3990ca8..e914cc45b766 100644 --- a/tools/testing/selftests/bpf/cgroup_helpers.c +++ b/tools/testing/selftests/bpf/cgroup_helpers.c @@ -33,49 +33,52 @@ #define CGROUP_MOUNT_DFLT "/sys/fs/cgroup" #define NETCLS_MOUNT_PATH CGROUP_MOUNT_DFLT "/net_cls" #define CGROUP_WORK_DIR "/cgroup-test-work-dir" -#define format_cgroup_path(buf, path) \ + +#define format_cgroup_path_pid(buf, path, pid) \ snprintf(buf, sizeof(buf), "%s%s%d%s", CGROUP_MOUNT_PATH, \ - CGROUP_WORK_DIR, getpid(), path) + CGROUP_WORK_DIR, pid, path) + +#define format_cgroup_path(buf, path) \ + format_cgroup_path_pid(buf, path, getpid()) + +#define format_parent_cgroup_path(buf, path) \ + format_cgroup_path_pid(buf, path, getppid()) =20 #define format_classid_path(buf) \ snprintf(buf, sizeof(buf), "%s%s", NETCLS_MOUNT_PATH, \ CGROUP_WORK_DIR) =20 -/** - * enable_all_controllers() - Enable all available cgroup v2 controllers - * - * Enable all available cgroup v2 controllers in order to increase - * the code coverage. - * - * If successful, 0 is returned. - */ -static int enable_all_controllers(char *cgroup_path) +static int __enable_controllers(const char *cgroup_path, const char *contr= ollers) { char path[PATH_MAX + 1]; - char buf[PATH_MAX]; + char enable[PATH_MAX + 1]; char *c, *c2; int fd, cfd; ssize_t len; =20 - snprintf(path, sizeof(path), "%s/cgroup.controllers", cgroup_path); - fd =3D open(path, O_RDONLY); - if (fd < 0) { - log_err("Opening cgroup.controllers: %s", path); - return 1; - } - - len =3D read(fd, buf, sizeof(buf) - 1); - if (len < 0) { + /* If not controllers are passed, enable all available controllers */ + if (!controllers) { + snprintf(path, sizeof(path), "%s/cgroup.controllers", + cgroup_path); + fd =3D open(path, O_RDONLY); + if (fd < 0) { + log_err("Opening cgroup.controllers: %s", path); + return 1; + } + len =3D read(fd, enable, sizeof(enable) - 1); + if (len < 0) { + close(fd); + log_err("Reading cgroup.controllers: %s", path); + return 1; + } else if (len =3D=3D 0) { /* No controllers to enable */ + close(fd); + return 0; + } + enable[len] =3D 0; close(fd); - log_err("Reading cgroup.controllers: %s", path); - return 1; + } else { + strncpy(enable, controllers, sizeof(enable)); } - buf[len] =3D 0; - close(fd); - - /* No controllers available? We're probably on cgroup v1. */ - if (len =3D=3D 0) - return 0; =20 snprintf(path, sizeof(path), "%s/cgroup.subtree_control", cgroup_path); cfd =3D open(path, O_RDWR); @@ -84,7 +87,7 @@ static int enable_all_controllers(char *cgroup_path) return 1; } =20 - for (c =3D strtok_r(buf, " ", &c2); c; c =3D strtok_r(NULL, " ", &c2)) { + for (c =3D strtok_r(enable, " ", &c2); c; c =3D strtok_r(NULL, " ", &c2))= { if (dprintf(cfd, "+%s\n", c) <=3D 0) { log_err("Enabling controller %s: %s", c, path); close(cfd); @@ -95,6 +98,87 @@ static int enable_all_controllers(char *cgroup_path) return 0; } =20 +/** + * enable_controllers() - Enable cgroup v2 controllers + * @relative_path: The cgroup path, relative to the workdir + * @controllers: List of controllers to enable in cgroup.controllers format + * + * + * Enable given cgroup v2 controllers, if @controllers is NULL, enable all + * available controllers. + * + * If successful, 0 is returned. + */ +int enable_controllers(const char *relative_path, const char *controllers) +{ + char cgroup_path[PATH_MAX + 1]; + + format_cgroup_path(cgroup_path, relative_path); + return __enable_controllers(cgroup_path, controllers); +} + +static int __write_cgroup_file(const char *cgroup_path, const char *file, + const char *buf) +{ + char file_path[PATH_MAX + 1]; + int fd; + + snprintf(file_path, sizeof(file_path), "%s/%s", cgroup_path, file); + fd =3D open(file_path, O_RDWR); + if (fd < 0) { + log_err("Opening %s", file_path); + return 1; + } + + if (dprintf(fd, "%s", buf) <=3D 0) { + log_err("Writing to %s", file_path); + close(fd); + return 1; + } + close(fd); + return 0; +} + +/** + * write_cgroup_file() - Write to a cgroup file + * @relative_path: The cgroup path, relative to the workdir + * @file: The name of the file in cgroupfs to write to + * @buf: Buffer to write to the file + * + * Write to a file in the given cgroup's directory. + * + * If successful, 0 is returned. + */ +int write_cgroup_file(const char *relative_path, const char *file, + const char *buf) +{ + char cgroup_path[PATH_MAX - 24]; + + format_cgroup_path(cgroup_path, relative_path); + return __write_cgroup_file(cgroup_path, file, buf); +} + +/** + * write_cgroup_file_parent() - Write to a cgroup file in the parent proce= ss + * workdir + * @relative_path: The cgroup path, relative to the parent process workdir + * @file: The name of the file in cgroupfs to write to + * @buf: Buffer to write to the file + * + * Write to a file in the given cgroup's directory under the parent process + * workdir. + * + * If successful, 0 is returned. + */ +int write_cgroup_file_parent(const char *relative_path, const char *file, + const char *buf) +{ + char cgroup_path[PATH_MAX - 24]; + + format_parent_cgroup_path(cgroup_path, relative_path); + return __write_cgroup_file(cgroup_path, file, buf); +} + /** * setup_cgroup_environment() - Setup the cgroup environment * @@ -133,7 +217,9 @@ int setup_cgroup_environment(void) return 1; } =20 - if (enable_all_controllers(cgroup_workdir)) + /* Enable all available controllers to increase test coverage */ + if (__enable_controllers(CGROUP_MOUNT_PATH, NULL) || + __enable_controllers(cgroup_workdir, NULL)) return 1; =20 return 0; @@ -173,7 +259,7 @@ static int join_cgroup_from_top(const char *cgroup_path) =20 /** * join_cgroup() - Join a cgroup - * @path: The cgroup path, relative to the workdir, to join + * @relative_path: The cgroup path, relative to the workdir, to join * * This function expects a cgroup to already be created, relative to the c= group * work dir, and it joins it. For example, passing "/my-cgroup" as the path @@ -182,11 +268,27 @@ static int join_cgroup_from_top(const char *cgroup_pa= th) * * On success, it returns 0, otherwise on failure it returns 1. */ -int join_cgroup(const char *path) +int join_cgroup(const char *relative_path) +{ + char cgroup_path[PATH_MAX + 1]; + + format_cgroup_path(cgroup_path, relative_path); + return join_cgroup_from_top(cgroup_path); +} + +/** + * join_parent_cgroup() - Join a cgroup in the parent process workdir + * @relative_path: The cgroup path, relative to parent process workdir, to= join + * + * See join_cgroup(). + * + * On success, it returns 0, otherwise on failure it returns 1. + */ +int join_parent_cgroup(const char *relative_path) { char cgroup_path[PATH_MAX + 1]; =20 - format_cgroup_path(cgroup_path, path); + format_parent_cgroup_path(cgroup_path, relative_path); return join_cgroup_from_top(cgroup_path); } =20 @@ -212,9 +314,27 @@ void cleanup_cgroup_environment(void) nftw(cgroup_workdir, nftwfunc, WALK_FD_LIMIT, FTW_DEPTH | FTW_MOUNT); } =20 +/** + * get_root_cgroup() - Get the FD of the root cgroup + * + * On success, it returns the file descriptor. On failure, it returns -1. + * If there is a failure, it prints the error to stderr. + */ +int get_root_cgroup(void) +{ + int fd; + + fd =3D open(CGROUP_MOUNT_PATH, O_RDONLY); + if (fd < 0) { + log_err("Opening root cgroup"); + return -1; + } + return fd; +} + /** * create_and_get_cgroup() - Create a cgroup, relative to workdir, and get= the FD - * @path: The cgroup path, relative to the workdir, to join + * @relative_path: The cgroup path, relative to the workdir, to join * * This function creates a cgroup under the top level workdir and returns = the * file descriptor. It is idempotent. @@ -222,14 +342,14 @@ void cleanup_cgroup_environment(void) * On success, it returns the file descriptor. On failure it returns -1. * If there is a failure, it prints the error to stderr. */ -int create_and_get_cgroup(const char *path) +int create_and_get_cgroup(const char *relative_path) { char cgroup_path[PATH_MAX + 1]; int fd; =20 - format_cgroup_path(cgroup_path, path); + format_cgroup_path(cgroup_path, relative_path); if (mkdir(cgroup_path, 0777) && errno !=3D EEXIST) { - log_err("mkdiring cgroup %s .. %s", path, cgroup_path); + log_err("mkdiring cgroup %s .. %s", relative_path, cgroup_path); return -1; } =20 @@ -244,13 +364,13 @@ int create_and_get_cgroup(const char *path) =20 /** * get_cgroup_id() - Get cgroup id for a particular cgroup path - * @path: The cgroup path, relative to the workdir, to join + * @relative_path: The cgroup path, relative to the workdir, to join * * On success, it returns the cgroup id. On failure it returns 0, * which is an invalid cgroup id. * If there is a failure, it prints the error to stderr. */ -unsigned long long get_cgroup_id(const char *path) +unsigned long long get_cgroup_id(const char *relative_path) { int dirfd, err, flags, mount_id, fhsize; union { @@ -261,7 +381,7 @@ unsigned long long get_cgroup_id(const char *path) struct file_handle *fhp, *fhp2; unsigned long long ret =3D 0; =20 - format_cgroup_path(cgroup_workdir, path); + format_cgroup_path(cgroup_workdir, relative_path); =20 dirfd =3D AT_FDCWD; flags =3D 0; diff --git a/tools/testing/selftests/bpf/cgroup_helpers.h b/tools/testing/s= elftests/bpf/cgroup_helpers.h index fcc9cb91b211..3358734356ab 100644 --- a/tools/testing/selftests/bpf/cgroup_helpers.h +++ b/tools/testing/selftests/bpf/cgroup_helpers.h @@ -10,11 +10,18 @@ __FILE__, __LINE__, clean_errno(), ##__VA_ARGS__) =20 /* cgroupv2 related */ -int cgroup_setup_and_join(const char *path); -int create_and_get_cgroup(const char *path); -unsigned long long get_cgroup_id(const char *path); - -int join_cgroup(const char *path); +int enable_controllers(const char *relative_path, const char *controllers); +int write_cgroup_file(const char *relative_path, const char *file, + const char *buf); +int write_cgroup_file_parent(const char *relative_path, const char *file, + const char *buf); +int cgroup_setup_and_join(const char *relative_path); +int get_root_cgroup(void); +int create_and_get_cgroup(const char *relative_path); +unsigned long long get_cgroup_id(const char *relative_path); + +int join_cgroup(const char *relative_path); +int join_parent_cgroup(const char *relative_path); =20 int setup_cgroup_environment(void); void cleanup_cgroup_environment(void); @@ -26,4 +33,4 @@ int join_classid(void); int setup_classid_environment(void); void cleanup_classid_environment(void); =20 -#endif /* __CGROUP_HELPERS_H */ \ No newline at end of file +#endif /* __CGROUP_HELPERS_H */ --=20 2.37.1.559.g78731f0fdb-goog From nobody Sat Apr 20 01:07:07 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id A5B7FC00140 for ; Fri, 5 Aug 2022 21:50:45 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S241646AbiHEVuo (ORCPT ); Fri, 5 Aug 2022 17:50:44 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38758 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241413AbiHEVts (ORCPT ); Fri, 5 Aug 2022 17:49:48 -0400 Received: from mail-yw1-x1149.google.com (mail-yw1-x1149.google.com [IPv6:2607:f8b0:4864:20::1149]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 6ED087821D for ; Fri, 5 Aug 2022 14:49:13 -0700 (PDT) Received: by mail-yw1-x1149.google.com with SMTP id 00721157ae682-32851d0f8beso31037907b3.22 for ; Fri, 05 Aug 2022 14:49:13 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:references:mime-version:message-id:in-reply-to :date:from:to:cc; bh=jzlqfxGqbALVlE62T11CZvVYWQyynjwbnPgXmnDU8Ms=; b=PnkhDO72c+35oAf4MOmM8Hfo7DqzG1vCWTh7pI6jFbsVDYaIgzfp1o57anUh70rgQB P85jllN982gOzW7oT07kQT4nQe1PSZh0ZIQJ6KqHtxSW45FS7wE1A++HDiJ+7ov2fqRb Nif6fkOgbeUBhND4LV1i90KDjrRXOXhzkagnVVrngsU+jkTO/OT6B/RmS5KaZAqe2X24 yfMXGXjOalg6AiSXvJrYeBOBKt/jh4HfKSkoaSrbVM4D8CrVihmUaqrkA34D6PUj98ax mUa9Zk+wv+gUNPjGAJRWG/EvMN+ZclOzFH+JuzPik5ZRBIqEM2Js1W8BkNA8YNDcbNf6 bhYg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:references:mime-version:message-id:in-reply-to :date:x-gm-message-state:from:to:cc; bh=jzlqfxGqbALVlE62T11CZvVYWQyynjwbnPgXmnDU8Ms=; b=OdF6LoK0wDy+JeZY4RDsqmIZrrnGSdvZzc1UbhzSKfldslRth3nUhnk/SpE0qKWDa1 Fn4PyzKulYsJ0Or8NcBowB0f4EJH232w4mM2Jsobinb4valHy002qVdPnIvFOkwBw8Eq p9fFUscIeJVFdSsCM9A3vqlBbaiyY+MfaGXhc+do2yfdtkRshrGXyhhAW49bQV6F3hiP wArg/Ey9JMKzwhjYH3SFYJZ1fau+BadZBuhXxIcGshwuXjqftXWDgRWh83NR/ppfgyQq fSGNm3Xkm88H4d8D7kUwsUSlkvXgGsm3UBHRL8lLx6uWAfXTIO4CS/67dGyICg98lbCX gwxQ== X-Gm-Message-State: ACgBeo1yxu3DHXL86dZXyFPTbIVCL/7NzhBGoXQNW5XhezCCxieFQkgN RKOSNKIffKO/4FOyCVkeWqKj7kOuyt8kISMtOIgl0+3NxT9tBvNnl5YQ0wamv43s1J7FpW9R/D0 iAgpQOyfkJPOy/iwfQGV/qyMTNvNUJtyJUZIzOrZtusAoP+zGOUY08OcAx5h8rnWu6PLV3w== X-Google-Smtp-Source: AA6agR6UHXjXR4qBThOA7qNq4kyibbUbcx6W4g+nBPphyBum9Qfyds3C1747PPlApC29M8fGgZcK2BffDuM= X-Received: from haoluo.svl.corp.google.com ([2620:15c:2d4:203:4f27:97db:8644:dc82]) (user=haoluo job=sendgmr) by 2002:a0d:ead2:0:b0:31f:6484:e81d with SMTP id t201-20020a0dead2000000b0031f6484e81dmr7920987ywe.129.1659736152450; Fri, 05 Aug 2022 14:49:12 -0700 (PDT) Date: Fri, 5 Aug 2022 14:48:21 -0700 In-Reply-To: <20220805214821.1058337-1-haoluo@google.com> Message-Id: <20220805214821.1058337-9-haoluo@google.com> Mime-Version: 1.0 References: <20220805214821.1058337-1-haoluo@google.com> X-Mailer: git-send-email 2.37.1.559.g78731f0fdb-goog Subject: [PATCH bpf-next v7 8/8] selftests/bpf: add a selftest for cgroup hierarchical stats collection From: Hao Luo To: linux-kernel@vger.kernel.org, bpf@vger.kernel.org, cgroups@vger.kernel.org, netdev@vger.kernel.org Cc: Alexei Starovoitov , Andrii Nakryiko , Daniel Borkmann , Martin KaFai Lau , Song Liu , Yonghong Song , Tejun Heo , Zefan Li , KP Singh , Johannes Weiner , Michal Hocko , Benjamin Tissoires , John Fastabend , Michal Koutny , Roman Gushchin , David Rientjes , Stanislav Fomichev , Shakeel Butt , Yosry Ahmed , Hao Luo Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Yosry Ahmed Add a selftest that tests the whole workflow for collecting, aggregating (flushing), and displaying cgroup hierarchical stats. TL;DR: - Userspace program creates a cgroup hierarchy and induces memcg reclaim in parts of it. - Whenever reclaim happens, vmscan_start and vmscan_end update per-cgroup percpu readings, and tell rstat which (cgroup, cpu) pairs have updates. - When userspace tries to read the stats, vmscan_dump calls rstat to flush the stats, and outputs the stats in text format to userspace (similar to cgroupfs stats). - rstat calls vmscan_flush once for every (cgroup, cpu) pair that has updates, vmscan_flush aggregates cpu readings and propagates updates to parents. - Userspace program makes sure the stats are aggregated and read correctly. Detailed explanation: - The test loads tracing bpf programs, vmscan_start and vmscan_end, to measure the latency of cgroup reclaim. Per-cgroup readings are stored in percpu maps for efficiency. When a cgroup reading is updated on a cpu, cgroup_rstat_updated(cgroup, cpu) is called to add the cgroup to the rstat updated tree on that cpu. - A cgroup_iter program, vmscan_dump, is loaded and pinned to a file, for each cgroup. Reading this file invokes the program, which calls cgroup_rstat_flush(cgroup) to ask rstat to propagate the updates for all cpus and cgroups that have updates in this cgroup's subtree. Afterwards, the stats are exposed to the user. vmscan_dump returns 1 to terminate iteration early, so that we only expose stats for one cgroup per read. - An ftrace program, vmscan_flush, is also loaded and attached to bpf_rstat_flush. When rstat flushing is ongoing, vmscan_flush is invoked once for each (cgroup, cpu) pair that has updates. cgroups are popped from the rstat tree in a bottom-up fashion, so calls will always be made for cgroups that have updates before their parents. The program aggregates percpu readings to a total per-cgroup reading, and also propagates them to the parent cgroup. After rstat flushing is over, all cgroups will have correct updated hierarchical readings (including all cpus and all their descendants). - Finally, the test creates a cgroup hierarchy and induces memcg reclaim in parts of it, and makes sure that the stats collection, aggregation, and reading workflow works as expected. Signed-off-by: Yosry Ahmed Signed-off-by: Hao Luo --- .../prog_tests/cgroup_hierarchical_stats.c | 358 ++++++++++++++++++ .../bpf/progs/cgroup_hierarchical_stats.c | 226 +++++++++++ 2 files changed, 584 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/cgroup_hierarchi= cal_stats.c create mode 100644 tools/testing/selftests/bpf/progs/cgroup_hierarchical_s= tats.c diff --git a/tools/testing/selftests/bpf/prog_tests/cgroup_hierarchical_sta= ts.c b/tools/testing/selftests/bpf/prog_tests/cgroup_hierarchical_stats.c new file mode 100644 index 000000000000..9d48b7187992 --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/cgroup_hierarchical_stats.c @@ -0,0 +1,358 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Functions to manage eBPF programs attached to cgroup subsystems + * + * Copyright 2022 Google LLC. + */ +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "cgroup_helpers.h" +#include "cgroup_hierarchical_stats.skel.h" + +#define PAGE_SIZE 4096 +#define MB(x) (x << 20) + +#define BPFFS_ROOT "/sys/fs/bpf/" +#define BPFFS_VMSCAN BPFFS_ROOT"vmscan/" + +#define CG_ROOT_NAME "root" +#define CG_ROOT_ID 1 + +#define CGROUP_PATH(p, n) {.path =3D p"/"n, .name =3D n} + +static struct { + const char *path, *name; + unsigned long long id; + int fd; +} cgroups[] =3D { + CGROUP_PATH("/", "test"), + CGROUP_PATH("/test", "child1"), + CGROUP_PATH("/test", "child2"), + CGROUP_PATH("/test/child1", "child1_1"), + CGROUP_PATH("/test/child1", "child1_2"), + CGROUP_PATH("/test/child2", "child2_1"), + CGROUP_PATH("/test/child2", "child2_2"), +}; + +#define N_CGROUPS ARRAY_SIZE(cgroups) +#define N_NON_LEAF_CGROUPS 3 + +static int root_cgroup_fd; +static bool mounted_bpffs; + +/* reads file at 'path' to 'buf', returns 0 on success. */ +static int read_from_file(const char *path, char *buf, size_t size) +{ + int fd, len; + + fd =3D open(path, O_RDONLY); + if (fd < 0) + return fd; + + len =3D read(fd, buf, size); + close(fd); + if (len < 0) + return len; + + buf[len] =3D 0; + return 0; +} + +/* mounts bpffs and mkdir for reading stats, returns 0 on success. */ +static int setup_bpffs(void) +{ + int err; + + /* Mount bpffs */ + err =3D mount("bpf", BPFFS_ROOT, "bpf", 0, NULL); + mounted_bpffs =3D !err; + if (ASSERT_FALSE(err && errno !=3D EBUSY, "mount")) + return err; + + /* Create a directory to contain stat files in bpffs */ + err =3D mkdir(BPFFS_VMSCAN, 0755); + if (!ASSERT_OK(err, "mkdir")) + return err; + + return 0; +} + +static void cleanup_bpffs(void) +{ + /* Remove created directory in bpffs */ + ASSERT_OK(rmdir(BPFFS_VMSCAN), "rmdir "BPFFS_VMSCAN); + + /* Unmount bpffs, if it wasn't already mounted when we started */ + if (mounted_bpffs) + return; + + ASSERT_OK(umount(BPFFS_ROOT), "unmount bpffs"); +} + +/* sets up cgroups, returns 0 on success. */ +static int setup_cgroups(void) +{ + int i, fd, err; + + err =3D setup_cgroup_environment(); + if (!ASSERT_OK(err, "setup_cgroup_environment")) + return err; + + root_cgroup_fd =3D get_root_cgroup(); + if (!ASSERT_GE(root_cgroup_fd, 0, "get_root_cgroup")) + return root_cgroup_fd; + + for (i =3D 0; i < N_CGROUPS; i++) { + fd =3D create_and_get_cgroup(cgroups[i].path); + if (!ASSERT_GE(fd, 0, "create_and_get_cgroup")) + return fd; + + cgroups[i].fd =3D fd; + cgroups[i].id =3D get_cgroup_id(cgroups[i].path); + + /* + * Enable memcg controller for the entire hierarchy. + * Note that stats are collected for all cgroups in a hierarchy + * with memcg enabled anyway, but are only exposed for cgroups + * that have memcg enabled. + */ + if (i < N_NON_LEAF_CGROUPS) { + err =3D enable_controllers(cgroups[i].path, "memory"); + if (!ASSERT_OK(err, "enable_controllers")) + return err; + } + } + return 0; +} + +static void cleanup_cgroups(void) +{ + close(root_cgroup_fd); + for (int i =3D 0; i < N_CGROUPS; i++) + close(cgroups[i].fd); + cleanup_cgroup_environment(); +} + +/* Sets up cgroup hiearchary, returns 0 on success. */ +static int setup_hierarchy(void) +{ + return setup_bpffs() || setup_cgroups(); +} + +static void destroy_hierarchy(void) +{ + cleanup_cgroups(); + cleanup_bpffs(); +} + +static int reclaimer(const char *cgroup_path, size_t size) +{ + static char size_buf[128]; + char *buf, *ptr; + int err; + + /* Join cgroup in the parent process workdir */ + if (join_parent_cgroup(cgroup_path)) + return EACCES; + + /* Allocate memory */ + buf =3D malloc(size); + if (!buf) + return ENOMEM; + + /* Write to memory to make sure it's actually allocated */ + for (ptr =3D buf; ptr < buf + size; ptr +=3D PAGE_SIZE) + *ptr =3D 1; + + /* Try to reclaim memory */ + snprintf(size_buf, 128, "%lu", size); + err =3D write_cgroup_file_parent(cgroup_path, "memory.reclaim", size_buf); + + free(buf); + /* memory.reclaim returns EAGAIN if the amount is not fully reclaimed */ + if (err && errno !=3D EAGAIN) + return errno; + + return 0; +} + +static int induce_vmscan(void) +{ + int i, status; + + /* + * In every leaf cgroup, run a child process that allocates some memory + * and attempts to reclaim some of it. + */ + for (i =3D N_NON_LEAF_CGROUPS; i < N_CGROUPS; i++) { + pid_t pid; + + /* Create reclaimer child */ + pid =3D fork(); + if (pid =3D=3D 0) { + status =3D reclaimer(cgroups[i].path, MB(5)); + exit(status); + } + + /* Cleanup reclaimer child */ + waitpid(pid, &status, 0); + ASSERT_TRUE(WIFEXITED(status), "reclaimer exited"); + ASSERT_EQ(WEXITSTATUS(status), 0, "reclaim exit code"); + } + return 0; +} + +static unsigned long long +get_cgroup_vmscan_delay(unsigned long long cgroup_id, const char *file_nam= e) +{ + unsigned long long vmscan =3D 0, id =3D 0; + static char buf[128], path[128]; + + /* For every cgroup, read the file generated by cgroup_iter */ + snprintf(path, 128, "%s%s", BPFFS_VMSCAN, file_name); + if (!ASSERT_OK(read_from_file(path, buf, 128), "read cgroup_iter")) + return 0; + + /* Check the output file formatting */ + ASSERT_EQ(sscanf(buf, "cg_id: %llu, total_vmscan_delay: %llu\n", + &id, &vmscan), 2, "output format"); + + /* Check that the cgroup_id is displayed correctly */ + ASSERT_EQ(id, cgroup_id, "cgroup_id"); + /* Check that the vmscan reading is non-zero */ + ASSERT_GT(vmscan, 0, "vmscan_reading"); + return vmscan; +} + +static void check_vmscan_stats(void) +{ + unsigned long long vmscan_readings[N_CGROUPS], vmscan_root; + int i; + + for (i =3D 0; i < N_CGROUPS; i++) { + vmscan_readings[i] =3D get_cgroup_vmscan_delay(cgroups[i].id, + cgroups[i].name); + } + + /* Read stats for root too */ + vmscan_root =3D get_cgroup_vmscan_delay(CG_ROOT_ID, CG_ROOT_NAME); + + /* Check that child1 =3D=3D child1_1 + child1_2 */ + ASSERT_EQ(vmscan_readings[1], vmscan_readings[3] + vmscan_readings[4], + "child1_vmscan"); + /* Check that child2 =3D=3D child2_1 + child2_2 */ + ASSERT_EQ(vmscan_readings[2], vmscan_readings[5] + vmscan_readings[6], + "child2_vmscan"); + /* Check that test =3D=3D child1 + child2 */ + ASSERT_EQ(vmscan_readings[0], vmscan_readings[1] + vmscan_readings[2], + "test_vmscan"); + /* Check that root >=3D test */ + ASSERT_GE(vmscan_root, vmscan_readings[1], "root_vmscan"); +} + +/* Creates iter link and pins in bpffs, returns 0 on success, -errno on fa= ilure. + */ +static int setup_cgroup_iter(struct cgroup_hierarchical_stats *obj, + int cgroup_fd, const char *file_name) +{ + DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts); + union bpf_iter_link_info linfo =3D {}; + struct bpf_link *link; + static char path[128]; + int err; + + /* + * Create an iter link, parameterized by cgroup_fd. + * We only want to traverse one cgroup, so set the traversal order to + * "pre", and return 1 from dump_vmscan to stop iteration after the + * first cgroup. + */ + linfo.cgroup.cgroup_fd =3D cgroup_fd; + linfo.cgroup.order =3D BPF_ITER_SELF; + opts.link_info =3D &linfo; + opts.link_info_len =3D sizeof(linfo); + link =3D bpf_program__attach_iter(obj->progs.dump_vmscan, &opts); + if (!ASSERT_OK_PTR(link, "attach iter")) + return -EFAULT; + + /* Pin the link to a bpffs file */ + snprintf(path, 128, "%s%s", BPFFS_VMSCAN, file_name); + err =3D bpf_link__pin(link, path); + ASSERT_OK(err, "pin cgroup_iter"); + + /* Remove the link, leaving only the ref held by the pinned file */ + bpf_link__destroy(link); + return err; +} + +/* Sets up programs for collecting stats, returns 0 on success. */ +static int setup_progs(struct cgroup_hierarchical_stats **skel) +{ + int i, err; + + *skel =3D cgroup_hierarchical_stats__open_and_load(); + if (!ASSERT_OK_PTR(*skel, "open_and_load")) + return 1; + + /* Attach cgroup_iter program that will dump the stats to cgroups */ + for (i =3D 0; i < N_CGROUPS; i++) { + err =3D setup_cgroup_iter(*skel, cgroups[i].fd, cgroups[i].name); + if (!ASSERT_OK(err, "setup_cgroup_iter")) + return err; + } + + /* Also dump stats for root */ + err =3D setup_cgroup_iter(*skel, root_cgroup_fd, CG_ROOT_NAME); + if (!ASSERT_OK(err, "setup_cgroup_iter")) + return err; + + err =3D cgroup_hierarchical_stats__attach(*skel); + if (!ASSERT_OK(err, "attach")) + return err; + + return 0; +} + +static void destroy_progs(struct cgroup_hierarchical_stats *skel) +{ + static char path[128]; + int i; + + for (i =3D 0; i < N_CGROUPS; i++) { + /* Delete files in bpffs that cgroup_iters are pinned in */ + snprintf(path, 128, "%s%s", BPFFS_VMSCAN, + cgroups[i].name); + ASSERT_OK(remove(path), "remove cgroup_iter pin"); + } + + /* Delete root file in bpffs */ + snprintf(path, 128, "%s%s", BPFFS_VMSCAN, CG_ROOT_NAME); + ASSERT_OK(remove(path), "remove cgroup_iter root pin"); + cgroup_hierarchical_stats__destroy(skel); +} + +void test_cgroup_hierarchical_stats(void) +{ + struct cgroup_hierarchical_stats *skel =3D NULL; + + if (setup_hierarchy()) + goto hierarchy_cleanup; + if (setup_progs(&skel)) + goto cleanup; + if (induce_vmscan()) + goto cleanup; + check_vmscan_stats(); +cleanup: + destroy_progs(skel); +hierarchy_cleanup: + destroy_hierarchy(); +} diff --git a/tools/testing/selftests/bpf/progs/cgroup_hierarchical_stats.c = b/tools/testing/selftests/bpf/progs/cgroup_hierarchical_stats.c new file mode 100644 index 000000000000..8ab4253a1592 --- /dev/null +++ b/tools/testing/selftests/bpf/progs/cgroup_hierarchical_stats.c @@ -0,0 +1,226 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Functions to manage eBPF programs attached to cgroup subsystems + * + * Copyright 2022 Google LLC. + */ +#include "vmlinux.h" +#include +#include +#include + +char _license[] SEC("license") =3D "GPL"; + +/* + * Start times are stored per-task, not per-cgroup, as multiple tasks in o= ne + * cgroup can perform reclaim concurrently. + */ +struct { + __uint(type, BPF_MAP_TYPE_TASK_STORAGE); + __uint(map_flags, BPF_F_NO_PREALLOC); + __type(key, int); + __type(value, __u64); +} vmscan_start_time SEC(".maps"); + +struct vmscan_percpu { + /* Previous percpu state, to figure out if we have new updates */ + __u64 prev; + /* Current percpu state */ + __u64 state; +}; + +struct vmscan { + /* State propagated through children, pending aggregation */ + __u64 pending; + /* Total state, including all cpus and all children */ + __u64 state; +}; + +struct { + __uint(type, BPF_MAP_TYPE_PERCPU_HASH); + __uint(max_entries, 100); + __type(key, __u64); + __type(value, struct vmscan_percpu); +} pcpu_cgroup_vmscan_elapsed SEC(".maps"); + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, 100); + __type(key, __u64); + __type(value, struct vmscan); +} cgroup_vmscan_elapsed SEC(".maps"); + +extern void cgroup_rstat_updated(struct cgroup *cgrp, int cpu) __ksym; +extern void cgroup_rstat_flush(struct cgroup *cgrp) __ksym; + +static struct cgroup *task_memcg(struct task_struct *task) +{ + int cgrp_id; + +#if __has_builtin(__builtin_preserve_enum_value) + cgrp_id =3D bpf_core_enum_value(enum cgroup_subsys_id, memory_cgrp_id); +#else + cgrp_id =3D memory_cgrp_id; +#endif + return task->cgroups->subsys[cgrp_id]->cgroup; +} + +static uint64_t cgroup_id(struct cgroup *cgrp) +{ + return cgrp->kn->id; +} + +static int create_vmscan_percpu_elem(__u64 cg_id, __u64 state) +{ + struct vmscan_percpu pcpu_init =3D {.state =3D state, .prev =3D 0}; + + return bpf_map_update_elem(&pcpu_cgroup_vmscan_elapsed, &cg_id, + &pcpu_init, BPF_NOEXIST); +} + +static int create_vmscan_elem(__u64 cg_id, __u64 state, __u64 pending) +{ + struct vmscan init =3D {.state =3D state, .pending =3D pending}; + + return bpf_map_update_elem(&cgroup_vmscan_elapsed, &cg_id, + &init, BPF_NOEXIST); +} + +SEC("tp_btf/mm_vmscan_memcg_reclaim_begin") +int BPF_PROG(vmscan_start, int order, gfp_t gfp_flags) +{ + struct task_struct *task =3D bpf_get_current_task_btf(); + __u64 *start_time_ptr; + + start_time_ptr =3D bpf_task_storage_get(&vmscan_start_time, task, 0, + BPF_LOCAL_STORAGE_GET_F_CREATE); + if (start_time_ptr) + *start_time_ptr =3D bpf_ktime_get_ns(); + return 0; +} + +SEC("tp_btf/mm_vmscan_memcg_reclaim_end") +int BPF_PROG(vmscan_end, unsigned long nr_reclaimed) +{ + struct vmscan_percpu *pcpu_stat; + struct task_struct *current =3D bpf_get_current_task_btf(); + struct cgroup *cgrp; + __u64 *start_time_ptr; + __u64 current_elapsed, cg_id; + __u64 end_time =3D bpf_ktime_get_ns(); + + /* + * cgrp is the first parent cgroup of current that has memcg enabled in + * its subtree_control, or NULL if memcg is disabled in the entire tree. + * In a cgroup hierarchy like this: + * a + * / \ + * b c + * If "a" has memcg enabled, while "b" doesn't, then processes in "b" + * will accumulate their stats directly to "a". This makes sure that no + * stats are lost from processes in leaf cgroups that don't have memcg + * enabled, but only exposes stats for cgroups that have memcg enabled. + */ + cgrp =3D task_memcg(current); + if (!cgrp) + return 0; + + cg_id =3D cgroup_id(cgrp); + start_time_ptr =3D bpf_task_storage_get(&vmscan_start_time, current, 0, + BPF_LOCAL_STORAGE_GET_F_CREATE); + if (!start_time_ptr) + return 0; + + current_elapsed =3D end_time - *start_time_ptr; + pcpu_stat =3D bpf_map_lookup_elem(&pcpu_cgroup_vmscan_elapsed, + &cg_id); + if (pcpu_stat) + pcpu_stat->state +=3D current_elapsed; + else if (create_vmscan_percpu_elem(cg_id, current_elapsed)) + return 0; + + cgroup_rstat_updated(cgrp, bpf_get_smp_processor_id()); + return 0; +} + +SEC("fentry/bpf_rstat_flush") +int BPF_PROG(vmscan_flush, struct cgroup *cgrp, struct cgroup *parent, int= cpu) +{ + struct vmscan_percpu *pcpu_stat; + struct vmscan *total_stat, *parent_stat; + __u64 cg_id =3D cgroup_id(cgrp); + __u64 parent_cg_id =3D parent ? cgroup_id(parent) : 0; + __u64 *pcpu_vmscan; + __u64 state; + __u64 delta =3D 0; + + /* Add CPU changes on this level since the last flush */ + pcpu_stat =3D bpf_map_lookup_percpu_elem(&pcpu_cgroup_vmscan_elapsed, + &cg_id, cpu); + if (pcpu_stat) { + state =3D pcpu_stat->state; + delta +=3D state - pcpu_stat->prev; + pcpu_stat->prev =3D state; + } + + total_stat =3D bpf_map_lookup_elem(&cgroup_vmscan_elapsed, &cg_id); + if (!total_stat) { + if (create_vmscan_elem(cg_id, delta, 0)) + return 0; + + goto update_parent; + } + + /* Collect pending stats from subtree */ + if (total_stat->pending) { + delta +=3D total_stat->pending; + total_stat->pending =3D 0; + } + + /* Propagate changes to this cgroup's total */ + total_stat->state +=3D delta; + +update_parent: + /* Skip if there are no changes to propagate, or no parent */ + if (!delta || !parent_cg_id) + return 0; + + /* Propagate changes to cgroup's parent */ + parent_stat =3D bpf_map_lookup_elem(&cgroup_vmscan_elapsed, + &parent_cg_id); + if (parent_stat) + parent_stat->pending +=3D delta; + else + create_vmscan_elem(parent_cg_id, 0, delta); + return 0; +} + +SEC("iter.s/cgroup") +int BPF_PROG(dump_vmscan, struct bpf_iter_meta *meta, struct cgroup *cgrp) +{ + struct seq_file *seq =3D meta->seq; + struct vmscan *total_stat; + __u64 cg_id =3D cgrp ? cgroup_id(cgrp) : 0; + + /* Do nothing for the terminal call */ + if (!cg_id) + return 1; + + /* Flush the stats to make sure we get the most updated numbers */ + cgroup_rstat_flush(cgrp); + + total_stat =3D bpf_map_lookup_elem(&cgroup_vmscan_elapsed, &cg_id); + if (!total_stat) { + BPF_SEQ_PRINTF(seq, "cg_id: %llu, total_vmscan_delay: 0\n", + cg_id); + } else { + BPF_SEQ_PRINTF(seq, "cg_id: %llu, total_vmscan_delay: %llu\n", + cg_id, total_stat->state); + } + + /* + * We only dump stats for one cgroup here, so return 1 to stop + * iteration after the first cgroup. + */ + return 1; +} --=20 2.37.1.559.g78731f0fdb-goog