This patch series allows for using bpf to collect hierarchical cgroup
stats efficiently by integrating with the rstat framework. The rstat
framework provides an efficient way to collect cgroup stats percpu and
propagate them through the cgroup hierarchy.
The stats are exposed to userspace in textual form by reading files in
bpffs, similar to cgroupfs stats by using a cgroup_iter program.
cgroup_iter is a type of bpf_iter. It walks over cgroups in three modes:
- walking a cgroup's descendants in pre-order.
- walking a cgroup's descendants in post-order.
- walking a cgroup's ancestors.
When attaching cgroup_iter, one needs to set a cgroup to the iter_link
created from attaching. This cgroup is passed as a file descriptor and
serves as the starting point of the walk.
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.
** Background on rstat for stats collection **
(I am using a subscriber analogy that is not commonly used)
The rstat framework maintains a tree of cgroups that have updates and
which cpus have updates. A subscriber to the rstat framework maintains
their own stats. The framework is used to tell the subscriber when
and what to flush, for the most efficient stats propagation. The
workflow is as follows:
- When a subscriber updates a cgroup on a cpu, it informs the rstat
framework by calling cgroup_rstat_updated(cgrp, cpu).
- When a subscriber wants to read some stats for a cgroup, it asks
the rstat framework to initiate a stats flush (propagation) by calling
cgroup_rstat_flush(cgrp).
- When the rstat framework initiates a flush, it makes callbacks to
subscribers to aggregate stats on cpus that have updates, and
propagate updates to their parent.
Currently, the main subscribers to the rstat framework are cgroup
subsystems (e.g. memory, block). This patch series allow bpf programs to
become subscribers as well.
This patch series includes a resend of a patch from the mailing list by
Benjamin Tissoires to support sleepable kfuncs [1], modified to use the
new kfunc flags infrastructure.
Patches in this series are organized as follows:
* Patch 1 is the updated sleepable kfuncs patch.
* Patch 2 enables the use of cgroup_get_from_file() in cgroup1.
This is useful because it enables cgroup_iter to work with cgroup1, and
allows the entire stat collection workflow to be cgroup1-compatible.
* Patches 3-5 introduce cgroup_iter prog, and a selftest.
* Patches 6-8 allow bpf programs to integrate with rstat by adding the
necessary hook points and kfunc. A comprehensive selftest that
demonstrates the entire workflow for using bpf and rstat to
efficiently collect and output cgroup stats is added.
---
Changelog:
v5 -> v6:
- Rebased on bpf-next
- Tidy up cgroup_hierarchical_stats test (Andrii)
* 'static' and 'inline'
* avoid using libbpf_get_error()
* string literals of cgroup paths.
- Rename patch 8/8 to 'selftests/bpf' (Yonghong)
- Fix cgroup_iter comments (e.g. PAGE_SIZE and uapi) (Yonghong)
- Make sure further read() returns OK after previous read() finished
properly (Yonghong)
- Release cgroup_mutex before the last call of show() (Kumar)
v4 -> v5:
- Rebased on top of new kfunc flags infrastructure, updated patch 1 and
patch 6 accordingly.
- Added docs for sleepable kfuncs.
v3 -> v4:
- cgroup_iter:
* reorder fields in bpf_link_info to avoid break uapi (Yonghong)
* comment the behavior when cgroup_fd=0 (Yonghong)
* comment on the limit of number of cgroups supported by cgroup_iter.
(Yonghong)
- cgroup_hierarchical_stats selftest:
* Do not return -1 if stats are not found (causes overflow in userspace).
* Check if child process failed to join cgroup.
* Make buf and path arrays in get_cgroup_vmscan_delay() static.
* Increase the test map sizes to accomodate cgroups that are not
created by the test.
v2 -> v3:
- cgroup_iter:
* Added conditional compilation of cgroup_iter.c in kernel/bpf/Makefile
(kernel test) and dropped the !CONFIG_CGROUP patch.
* Added validation of traversal_order when attaching (Yonghong).
* Fixed previous wording "two modes" to "three modes" (Yonghong).
* Fixed the btf_dump selftest broken by this patch (Yonghong).
* Fixed ctx_arg_info[0] to use "PTR_TO_BTF_ID_OR_NULL" instead of
"PTR_TO_BTF_ID", because the "cgroup" pointer passed to iter prog can
be null.
- Use __diag_push to eliminate __weak noinline warning in
bpf_rstat_flush().
- cgroup_hierarchical_stats selftest:
* Added write_cgroup_file_parent() helper.
* Added error handling for failed map updates.
* Added null check for cgroup in vmscan_flush.
* Fixed the signature of vmscan_[start/end].
* Correctly return error code when attaching trace programs fail.
* Make sure all links are destroyed correctly and not leaking in
cgroup_hierarchical_stats selftest.
* Use memory.reclaim instead of memory.high as a more reliable way to
invoke reclaim.
* Eliminated sleeps, the test now runs faster.
v1 -> v2:
- Redesign of cgroup_iter from v1, based on Alexei's idea [2]:
* supports walking cgroup subtree.
* supports walking ancestors of a cgroup. (Andrii)
* supports terminating the walk early.
* uses fd instead of cgroup_id as parameter for iter_link. Using fd is
a convention in bpf.
* gets cgroup's ref at attach time and deref at detach.
* brought back cgroup1 support for cgroup_iter.
- Squashed the patches adding the rstat flush hook points and kfuncs
(Tejun).
- Added a comment explaining why bpf_rstat_flush() needs to be weak
(Tejun).
- Updated the final selftest with the new cgroup_iter design.
- Changed CHECKs in the selftest with ASSERTs (Yonghong, Andrii).
- Removed empty line at the end of the selftest (Yonghong).
- Renamed test files to cgroup_hierarchical_stats.c.
- Reordered CGROUP_PATH params order to match struct declaration
in the selftest (Michal).
- Removed memory_subsys_enabled() and made sure memcg controller
enablement checks make sense and are documented (Michal).
RFC v2 -> v1:
- Instead of introducing a new program type for rstat flushing, add an
empty hook point, bpf_rstat_flush(), and use fentry bpf programs to
attach to it and flush bpf stats.
- Instead of using helpers, use kfuncs for rstat functions.
- These changes simplify the patchset greatly, with minimal changes to
uapi.
RFC v1 -> RFC v2:
- Instead of rstat flush programs attach to subsystems, they now attach
to rstat (global flushers, not per-subsystem), based on discussions
with Tejun. The first patch is entirely rewritten.
- Pass cgroup pointers to rstat flushers instead of cgroup ids. This is
much more flexibility and less likely to need a uapi update later.
- rstat helpers are now only defined if CGROUP_CONFIG.
- Most of the code is now only defined if CGROUP_CONFIG and
CONFIG_BPF_SYSCALL.
- Move rstat helper protos from bpf_base_func_proto() to
tracing_prog_func_proto().
- rstat helpers argument (cgroup pointer) is now ARG_PTR_TO_BTF_ID, not
ARG_ANYTHING.
- Rewrote the selftest to use the cgroup helpers.
- Dropped bpf_map_lookup_percpu_elem (already added by Feng).
- Dropped patch to support cgroup v1 for cgroup_iter.
- Dropped patch to define some cgroup_put() when !CONFIG_CGROUP. The
code that calls it is no longer compiled when !CONFIG_CGROUP.
cgroup_iter was originally introduced in a different patch series[3].
Hao and I agreed that it fits better as part of this series.
RFC v1 of this patch series had the following changes from [3]:
- Getting the cgroup's reference at the time at attaching, instead of
at the time when iterating. (Yonghong)
- Remove .init_seq_private and .fini_seq_private callbacks for
cgroup_iter. They are not needed now. (Yonghong)
[1] https://lore.kernel.org/bpf/[email protected]/
[2] https://lore.kernel.org/bpf/20220520221919.jnqgv52k4ajlgzcl@MBP-98dd607d3435.dhcp.thefacebook.com/
[3] https://lore.kernel.org/lkml/[email protected]/
Benjamin Tissoires (1):
btf: Add a new kfunc flag which allows to mark a function to be
sleepable
Hao Luo (3):
bpf, iter: Fix the condition on p when calling stop.
bpf: Introduce cgroup iter
selftests/bpf: Test cgroup_iter.
Yosry Ahmed (4):
cgroup: enable cgroup_get_from_file() on cgroup1
cgroup: bpf: enable bpf programs to integrate with rstat
selftests/bpf: extend cgroup helpers
selftests/bpf: add a selftest for cgroup hierarchical stats collection
Documentation/bpf/kfuncs.rst | 6 +
include/linux/bpf.h | 8 +
include/linux/btf.h | 1 +
include/uapi/linux/bpf.h | 31 ++
kernel/bpf/Makefile | 3 +
kernel/bpf/bpf_iter.c | 5 +
kernel/bpf/btf.c | 9 +
kernel/bpf/cgroup_iter.c | 268 +++++++++++++
kernel/cgroup/cgroup.c | 5 -
kernel/cgroup/rstat.c | 48 +++
tools/include/uapi/linux/bpf.h | 31 ++
tools/testing/selftests/bpf/cgroup_helpers.c | 202 ++++++++--
tools/testing/selftests/bpf/cgroup_helpers.h | 19 +-
.../selftests/bpf/prog_tests/btf_dump.c | 4 +-
.../prog_tests/cgroup_hierarchical_stats.c | 358 ++++++++++++++++++
.../selftests/bpf/prog_tests/cgroup_iter.c | 193 ++++++++++
tools/testing/selftests/bpf/progs/bpf_iter.h | 7 +
.../bpf/progs/cgroup_hierarchical_stats.c | 218 +++++++++++
.../testing/selftests/bpf/progs/cgroup_iter.c | 39 ++
19 files changed, 1401 insertions(+), 54 deletions(-)
create mode 100644 kernel/bpf/cgroup_iter.c
create mode 100644 tools/testing/selftests/bpf/prog_tests/cgroup_hierarchical_stats.c
create mode 100644 tools/testing/selftests/bpf/prog_tests/cgroup_iter.c
create mode 100644 tools/testing/selftests/bpf/progs/cgroup_hierarchical_stats.c
create mode 100644 tools/testing/selftests/bpf/progs/cgroup_iter.c
--
2.37.1.455.g008518b4e5-goog
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.
- early termination.
Acked-by: Yonghong Song <[email protected]>
Signed-off-by: Hao Luo <[email protected]>
---
.../selftests/bpf/prog_tests/cgroup_iter.c | 193 ++++++++++++++++++
tools/testing/selftests/bpf/progs/bpf_iter.h | 7 +
.../testing/selftests/bpf/progs/cgroup_iter.c | 39 ++++
3 files changed, 239 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/testing/selftests/bpf/prog_tests/cgroup_iter.c
new file mode 100644
index 000000000000..5dc843a3f507
--- /dev/null
+++ b/tools/testing/selftests/bpf/prog_tests/cgroup_iter.c
@@ -0,0 +1,193 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2022 Google */
+
+#include <test_progs.h>
+#include <bpf/libbpf.h>
+#include <bpf/btf.h>
+#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"
+
+#define format_expected_output1(cg_id1) \
+ snprintf(expected_output, sizeof(expected_output), \
+ PROLOGUE "%8llu\n" EPILOGUE, (cg_id1))
+
+#define format_expected_output2(cg_id1, cg_id2) \
+ snprintf(expected_output, sizeof(expected_output), \
+ PROLOGUE "%8llu\n%8llu\n" EPILOGUE, \
+ (cg_id1), (cg_id2))
+
+#define format_expected_output3(cg_id1, cg_id2, cg_id3) \
+ snprintf(expected_output, sizeof(expected_output), \
+ PROLOGUE "%8llu\n%8llu\n%8llu\n" EPILOGUE, \
+ (cg_id1), (cg_id2), (cg_id3))
+
+const char *cg_path[] = {
+ "/", "/parent", "/parent/child1", "/parent/child2"
+};
+
+static int cg_fd[] = {-1, -1, -1, -1};
+static unsigned long long cg_id[] = {0, 0, 0, 0};
+static char expected_output[64];
+
+int setup_cgroups(void)
+{
+ int fd, i = 0;
+
+ for (i = 0; i < NUM_CGROUPS; i++) {
+ fd = create_and_get_cgroup(cg_path[i]);
+ if (fd < 0)
+ return fd;
+
+ cg_fd[i] = fd;
+ cg_id[i] = get_cgroup_id(cg_path[i]);
+ }
+ return 0;
+}
+
+void cleanup_cgroups(void)
+{
+ int i;
+
+ for (i = 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[64];
+
+ memset(&linfo, 0, sizeof(linfo));
+ linfo.cgroup.cgroup_fd = cgroup_fd;
+ linfo.cgroup.traversal_order = order;
+ opts.link_info = &linfo;
+ opts.link_info_len = sizeof(linfo);
+
+ link = bpf_program__attach_iter(prog, &opts);
+ if (!ASSERT_OK_PTR(link, "attach_iter"))
+ return;
+
+ iter_fd = bpf_iter_create(bpf_link__fd(link));
+ if (iter_fd < 0)
+ goto free_link;
+
+ memset(buf, 0, sizeof(buf));
+ while ((len = read(iter_fd, buf, sizeof(buf))) > 0)
+ ;
+
+ ASSERT_STREQ(buf, expected_output, testname);
+
+ /* read() after iter finishes should be ok. */
+ if (len == 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 = (__u32)-1;
+ opts.link_info = &linfo;
+ opts.link_info_len = sizeof(linfo);
+
+ link = bpf_program__attach_iter(skel->progs.cgroup_id_printer, &opts);
+ if (!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)
+{
+ format_expected_output3(cg_id[PARENT], cg_id[CHILD1], cg_id[CHILD2]);
+
+ read_from_cgroup_iter(skel->progs.cgroup_id_printer, cg_fd[PARENT],
+ BPF_ITER_CGROUP_PRE, "preorder");
+}
+
+/* Postorder walk prints child and parent in order. */
+static void test_walk_postorder(struct cgroup_iter *skel)
+{
+ format_expected_output3(cg_id[CHILD1], cg_id[CHILD2], cg_id[PARENT]);
+
+ read_from_cgroup_iter(skel->progs.cgroup_id_printer, cg_fd[PARENT],
+ BPF_ITER_CGROUP_POST, "postorder");
+}
+
+/* Walking parents prints parent and then root. */
+static void test_walk_parent_up(struct cgroup_iter *skel)
+{
+ /* terminate the walk when ROOT is met. */
+ skel->bss->terminal_cgroup = cg_id[ROOT];
+
+ format_expected_output2(cg_id[PARENT], cg_id[ROOT]);
+
+ read_from_cgroup_iter(skel->progs.cgroup_id_printer, cg_fd[PARENT],
+ BPF_ITER_CGROUP_PARENT_UP, "parent_up");
+
+ skel->bss->terminal_cgroup = 0;
+}
+
+/* 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 = 1;
+
+ format_expected_output1(cg_id[PARENT]);
+
+ read_from_cgroup_iter(skel->progs.cgroup_id_printer, cg_fd[PARENT],
+ BPF_ITER_CGROUP_PRE, "early_termination");
+
+ skel->bss->terminate_early = 0;
+}
+
+void test_cgroup_iter(void)
+{
+ struct cgroup_iter *skel = NULL;
+
+ if (setup_cgroup_environment())
+ return;
+
+ if (setup_cgroups())
+ goto out;
+
+ skel = 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__preorder"))
+ test_walk_preorder(skel);
+ if (test__start_subtest("cgroup_iter__postorder"))
+ test_walk_postorder(skel);
+ if (test__start_subtest("cgroup_iter__parent_up_walk"))
+ test_walk_parent_up(skel);
+ if (test__start_subtest("cgroup_iter__early_termination"))
+ test_early_termination(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/selftests/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_used
#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;
};
+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/testing/selftests/bpf/progs/cgroup_iter.c
new file mode 100644
index 000000000000..2a34d146d6df
--- /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 <bpf/bpf_helpers.h>
+#include <bpf/bpf_tracing.h>
+
+char _license[] SEC("license") = "GPL";
+volatile int terminate_early = 0;
+volatile u64 terminal_cgroup = 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 = ctx->meta->seq;
+ struct cgroup *cgrp = ctx->cgroup;
+
+ /* epilogue */
+ if (cgrp == NULL) {
+ BPF_SEQ_PRINTF(seq, "epilogue\n");
+ return 0;
+ }
+
+ /* prologue */
+ if (ctx->meta->seq_num == 0)
+ BPF_SEQ_PRINTF(seq, "prologue\n");
+
+ BPF_SEQ_PRINTF(seq, "%8llu\n", cgroup_id(cgrp));
+
+ if (terminal_cgroup == cgroup_id(cgrp))
+ return 1;
+
+ return terminate_early ? 1 : 0;
+}
--
2.37.1.455.g008518b4e5-goog
On Mon, Aug 1, 2022 at 10:54 AM Hao Luo <[email protected]> wrote:
>
> 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.
> - early termination.
>
> Acked-by: Yonghong Song <[email protected]>
> Signed-off-by: Hao Luo <[email protected]>
> ---
> .../selftests/bpf/prog_tests/cgroup_iter.c | 193 ++++++++++++++++++
> tools/testing/selftests/bpf/progs/bpf_iter.h | 7 +
> .../testing/selftests/bpf/progs/cgroup_iter.c | 39 ++++
> 3 files changed, 239 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/testing/selftests/bpf/prog_tests/cgroup_iter.c
> new file mode 100644
> index 000000000000..5dc843a3f507
> --- /dev/null
> +++ b/tools/testing/selftests/bpf/prog_tests/cgroup_iter.c
> @@ -0,0 +1,193 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/* Copyright (c) 2022 Google */
> +
> +#include <test_progs.h>
> +#include <bpf/libbpf.h>
> +#include <bpf/btf.h>
> +#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"
> +
> +#define format_expected_output1(cg_id1) \
> + snprintf(expected_output, sizeof(expected_output), \
> + PROLOGUE "%8llu\n" EPILOGUE, (cg_id1))
> +
> +#define format_expected_output2(cg_id1, cg_id2) \
> + snprintf(expected_output, sizeof(expected_output), \
> + PROLOGUE "%8llu\n%8llu\n" EPILOGUE, \
> + (cg_id1), (cg_id2))
> +
> +#define format_expected_output3(cg_id1, cg_id2, cg_id3) \
> + snprintf(expected_output, sizeof(expected_output), \
> + PROLOGUE "%8llu\n%8llu\n%8llu\n" EPILOGUE, \
> + (cg_id1), (cg_id2), (cg_id3))
> +
you use format_expected_output{1,2} just once and
format_expected_output3 twice. Is it worth defining macros for that?
> +const char *cg_path[] = {
> + "/", "/parent", "/parent/child1", "/parent/child2"
> +};
> +
> +static int cg_fd[] = {-1, -1, -1, -1};
> +static unsigned long long cg_id[] = {0, 0, 0, 0};
> +static char expected_output[64];
> +
> +int setup_cgroups(void)
> +{
> + int fd, i = 0;
> +
> + for (i = 0; i < NUM_CGROUPS; i++) {
> + fd = create_and_get_cgroup(cg_path[i]);
> + if (fd < 0)
> + return fd;
> +
> + cg_fd[i] = fd;
> + cg_id[i] = get_cgroup_id(cg_path[i]);
> + }
> + return 0;
> +}
> +
> +void cleanup_cgroups(void)
some more statics to cover (same for setup_cgroups)
> +{
> + int i;
> +
> + for (i = 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[64];
> +
> + memset(&linfo, 0, sizeof(linfo));
> + linfo.cgroup.cgroup_fd = cgroup_fd;
> + linfo.cgroup.traversal_order = order;
> + opts.link_info = &linfo;
> + opts.link_info_len = sizeof(linfo);
> +
> + link = bpf_program__attach_iter(prog, &opts);
> + if (!ASSERT_OK_PTR(link, "attach_iter"))
> + return;
> +
> + iter_fd = bpf_iter_create(bpf_link__fd(link));
> + if (iter_fd < 0)
> + goto free_link;
> +
> + memset(buf, 0, sizeof(buf));
> + while ((len = read(iter_fd, buf, sizeof(buf))) > 0)
> + ;
this is broken, in general, you are overriding buffer content with
each call to len
I think you intended to advance buf after each read() call (and reduce
remaining available buf size)?
> +
> + ASSERT_STREQ(buf, expected_output, testname);
> +
> + /* read() after iter finishes should be ok. */
> + if (len == 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 = (__u32)-1;
> + opts.link_info = &linfo;
> + opts.link_info_len = sizeof(linfo);
> +
> + link = bpf_program__attach_iter(skel->progs.cgroup_id_printer, &opts);
> + if (!ASSERT_ERR_PTR(link, "attach_iter"))
> + bpf_link__destroy(link);
nit: you can call bpf_link__destroy() even if link is NULL or IS_ERR
> +}
> +
[...]
> diff --git a/tools/testing/selftests/bpf/progs/cgroup_iter.c b/tools/testing/selftests/bpf/progs/cgroup_iter.c
> new file mode 100644
> index 000000000000..2a34d146d6df
> --- /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 <bpf/bpf_helpers.h>
> +#include <bpf/bpf_tracing.h>
> +
> +char _license[] SEC("license") = "GPL";
> +volatile int terminate_early = 0;
> +volatile u64 terminal_cgroup = 0;
> +
nit: you shouldn't need volatile for non-const global variables. Did
you see any problems without volatile?
> +static inline u64 cgroup_id(struct cgroup *cgrp)
> +{
> + return cgrp->kn->id;
> +}
> +
[...]
On Mon, Aug 1, 2022 at 2:51 PM Andrii Nakryiko
<[email protected]> wrote:
>
> On Mon, Aug 1, 2022 at 10:54 AM Hao Luo <[email protected]> wrote:
> >
> > 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.
> > - early termination.
> >
> > Acked-by: Yonghong Song <[email protected]>
> > Signed-off-by: Hao Luo <[email protected]>
> > ---
> > .../selftests/bpf/prog_tests/cgroup_iter.c | 193 ++++++++++++++++++
> > tools/testing/selftests/bpf/progs/bpf_iter.h | 7 +
> > .../testing/selftests/bpf/progs/cgroup_iter.c | 39 ++++
> > 3 files changed, 239 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/testing/selftests/bpf/prog_tests/cgroup_iter.c
> > new file mode 100644
> > index 000000000000..5dc843a3f507
> > --- /dev/null
> > +++ b/tools/testing/selftests/bpf/prog_tests/cgroup_iter.c
> > @@ -0,0 +1,193 @@
> > +// SPDX-License-Identifier: GPL-2.0
> > +/* Copyright (c) 2022 Google */
> > +
> > +#include <test_progs.h>
> > +#include <bpf/libbpf.h>
> > +#include <bpf/btf.h>
> > +#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"
> > +
> > +#define format_expected_output1(cg_id1) \
> > + snprintf(expected_output, sizeof(expected_output), \
> > + PROLOGUE "%8llu\n" EPILOGUE, (cg_id1))
> > +
> > +#define format_expected_output2(cg_id1, cg_id2) \
> > + snprintf(expected_output, sizeof(expected_output), \
> > + PROLOGUE "%8llu\n%8llu\n" EPILOGUE, \
> > + (cg_id1), (cg_id2))
> > +
> > +#define format_expected_output3(cg_id1, cg_id2, cg_id3) \
> > + snprintf(expected_output, sizeof(expected_output), \
> > + PROLOGUE "%8llu\n%8llu\n%8llu\n" EPILOGUE, \
> > + (cg_id1), (cg_id2), (cg_id3))
> > +
>
> you use format_expected_output{1,2} just once and
> format_expected_output3 twice. Is it worth defining macros for that?
>
If not, we'd see this snprintf and format all over the place. It looks
worse than the current one I think, prefer leave as-is.
> > +const char *cg_path[] = {
> > + "/", "/parent", "/parent/child1", "/parent/child2"
> > +};
> > +
> > +static int cg_fd[] = {-1, -1, -1, -1};
> > +static unsigned long long cg_id[] = {0, 0, 0, 0};
> > +static char expected_output[64];
> > +
> > +int setup_cgroups(void)
> > +{
> > + int fd, i = 0;
> > +
> > + for (i = 0; i < NUM_CGROUPS; i++) {
> > + fd = create_and_get_cgroup(cg_path[i]);
> > + if (fd < 0)
> > + return fd;
> > +
> > + cg_fd[i] = fd;
> > + cg_id[i] = get_cgroup_id(cg_path[i]);
> > + }
> > + return 0;
> > +}
> > +
> > +void cleanup_cgroups(void)
>
> some more statics to cover (same for setup_cgroups)
>
Oops. Will fix.
> > +{
> > + int i;
> > +
> > + for (i = 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[64];
> > +
> > + memset(&linfo, 0, sizeof(linfo));
> > + linfo.cgroup.cgroup_fd = cgroup_fd;
> > + linfo.cgroup.traversal_order = order;
> > + opts.link_info = &linfo;
> > + opts.link_info_len = sizeof(linfo);
> > +
> > + link = bpf_program__attach_iter(prog, &opts);
> > + if (!ASSERT_OK_PTR(link, "attach_iter"))
> > + return;
> > +
> > + iter_fd = bpf_iter_create(bpf_link__fd(link));
> > + if (iter_fd < 0)
> > + goto free_link;
> > +
> > + memset(buf, 0, sizeof(buf));
> > + while ((len = read(iter_fd, buf, sizeof(buf))) > 0)
> > + ;
>
> this is broken, in general, you are overriding buffer content with
> each call to len
>
> I think you intended to advance buf after each read() call (and reduce
> remaining available buf size)?
>
Ah. My bad. Copied from bpf_iter but didn't realize that in the
bpf_iter case, it didn't care about the content read from buffer. Will
fix.
> > +
> > + ASSERT_STREQ(buf, expected_output, testname);
> > +
> > + /* read() after iter finishes should be ok. */
> > + if (len == 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 = (__u32)-1;
> > + opts.link_info = &linfo;
> > + opts.link_info_len = sizeof(linfo);
> > +
> > + link = bpf_program__attach_iter(skel->progs.cgroup_id_printer, &opts);
> > + if (!ASSERT_ERR_PTR(link, "attach_iter"))
> > + bpf_link__destroy(link);
>
> nit: you can call bpf_link__destroy() even if link is NULL or IS_ERR
>
Ack. Still need to ASSERT on 'link' though, so the saving is probably
just an indentation. Anyway, will change.
> > +}
> > +
>
> [...]
>
> > diff --git a/tools/testing/selftests/bpf/progs/cgroup_iter.c b/tools/testing/selftests/bpf/progs/cgroup_iter.c
> > new file mode 100644
> > index 000000000000..2a34d146d6df
> > --- /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 <bpf/bpf_helpers.h>
> > +#include <bpf/bpf_tracing.h>
> > +
> > +char _license[] SEC("license") = "GPL";
> > +volatile int terminate_early = 0;
> > +volatile u64 terminal_cgroup = 0;
> > +
>
> nit: you shouldn't need volatile for non-const global variables. Did
> you see any problems without volatile?
>
Nah. I don't know about that and see there are other tests that have
this pattern. Will fix.
> > +static inline u64 cgroup_id(struct cgroup *cgrp)
> > +{
> > + return cgrp->kn->id;
> > +}
> > +
>
> [...]
On Mon, Aug 1, 2022 at 3:55 PM Hao Luo <[email protected]> wrote:
>
> On Mon, Aug 1, 2022 at 2:51 PM Andrii Nakryiko
> <[email protected]> wrote:
> >
> > On Mon, Aug 1, 2022 at 10:54 AM Hao Luo <[email protected]> wrote:
> > >
> > > 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.
> > > - early termination.
> > >
> > > Acked-by: Yonghong Song <[email protected]>
> > > Signed-off-by: Hao Luo <[email protected]>
> > > ---
> > > .../selftests/bpf/prog_tests/cgroup_iter.c | 193 ++++++++++++++++++
> > > tools/testing/selftests/bpf/progs/bpf_iter.h | 7 +
> > > .../testing/selftests/bpf/progs/cgroup_iter.c | 39 ++++
> > > 3 files changed, 239 insertions(+)
> > > create mode 100644 tools/testing/selftests/bpf/prog_tests/cgroup_iter.c
> > > create mode 100644 tools/testing/selftests/bpf/progs/cgroup_iter.c
> > >
[...]
> > > +#define format_expected_output3(cg_id1, cg_id2, cg_id3) \
> > > + snprintf(expected_output, sizeof(expected_output), \
> > > + PROLOGUE "%8llu\n%8llu\n%8llu\n" EPILOGUE, \
> > > + (cg_id1), (cg_id2), (cg_id3))
> > > +
> >
> > you use format_expected_output{1,2} just once and
> > format_expected_output3 twice. Is it worth defining macros for that?
> >
>
> If not, we'd see this snprintf and format all over the place. It looks
> worse than the current one I think, prefer leave as-is.
All over the place == 4 places where it matters.
We are not trying to write the most beautiful code through macro
obfuscation. The point is to write tests that are easy to follow,
debug, understand, and potentially modify. Adding extra layers of
macros goes against this. Instead of clearly seeing in each individual
subtest that we expect "%llu\n%llu\n", I need to search what
"format_expected_output3" is actually doing, then I'm wondering where
expected_output is coming from (I scan macro input args, see nothing,
then I conclude it must be coming from the environment; I jump to one
of the format_expected_output3 invocation sites, see no local variable
named "expected_output", then I look around and see global variable;
aha, finally!) Sure it's a rather trivial thing, but this adds up.
*Unnecessary* macros are bad and a hindrance. Please avoid them, if
possible. Saving 20 characters is not a sufficient justification in my
view.
>
> > > +const char *cg_path[] = {
> > > + "/", "/parent", "/parent/child1", "/parent/child2"
> > > +};
> > > +
[...]
> > > + link = bpf_program__attach_iter(skel->progs.cgroup_id_printer, &opts);
> > > + if (!ASSERT_ERR_PTR(link, "attach_iter"))
> > > + bpf_link__destroy(link);
> >
> > nit: you can call bpf_link__destroy() even if link is NULL or IS_ERR
> >
>
> Ack. Still need to ASSERT on 'link' though, so the saving is probably
> just an indentation. Anyway, will change.
Yeah, of course you need to assert. But it's nice to have
unconditional assertion.
>
> > > +}
> > > +
> >
> > [...]
> >
[...]