From mboxrd@z Thu Jan 1 00:00:00 1970 Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.remote-ip=209.85.221.43 ARC-Seal: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; cv=none; t=1793650449; b=Yv+oWUWZ516O8FhVm74b+AqxrjlGEeOW9FuGaGWlrvVsMFImEdMnz4G1mVX8tjTp3VlA 1DZYZ6T7SeIu/Puku47hRGKgnr4bK9JTk7T3+255xaY28/Ot9JmqDUT0oZkOTm1YSt0Ts iKfL04jPHkslL2+NdpogUo9KYgbmEJy/UqmhiGmlB7NxT6lENwzqjnbPwX6rj/eYHCCH8 RhukQfJGCO7sqn1YG5rYx/HvzgmyoopX3umR3ygh/KWOsjFJm0SqFUF+voP8N9g3y82l4 iDF2rRbNOD2YYooHbH0SwbP+NRmW1PWST7mWb5BGFELZPWGY/ZGzeI3zjoD8UHaVjEA== ARC-Message-Signature: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; c=relaxed/relaxed; t=1793650449; h=DMARC-Filter:Received:DKIM-Signature:X-Google-DKIM-Signature: X-Gm-Message-State:X-Gm-Gg:X-Received:Received:From:To:Cc:Subject: Date:Message-ID:X-Mailer:In-Reply-To:References:MIME-Version: Content-Transfer-Encoding; bh=6kh38ixGlcMYvSMO0Cs+3boaaPdMbwOiDcXF3MCXi/8=; b=hZb+5lhrrUaajVz2aJbtx1w4DyCVb48tLUqv0QQulXN1u7R2sjscJMr7g57YpYGKg0nr 07ZA/lNuBOxKNZ14SZhgAiLgFUk5z0R8nOPaU3mFCkEoHbLODzmek5ATj8Du3oS/2b97g DmOb/qvnx1S3U4l6RIuzjjUSmAB/uIGIgua9/86sLT/IKVvh+Y01nm+nHTlIONucSrsQP fHR5vlb41r4TmmIxyhNkFeScDoMqZWGcVuUe7OpYxrSMGVVO7BGQi04MqYL1+DUG0IIFN +RjmGh4u+EWWcYjBKN4JBfbUmSrHYstmO1JlofkrIIZ4yN79ktXJI4/7U4szs/N0KSQ== ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20260707 header.b=shURqN8r; arc=none smtp.remote-ip=209.85.221.43 Received: from mail-wr1-f43.google.com (mail-wr1-f43.google.com [209.85.221.43]) (using TLSv1.3 with cipher TLS_AES_128_GCM_SHA256 (128/128 bits) key-exchange X25519 server-signature ECDSA (prime256v1) server-digest SHA256) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 6BC19606D82D for ; Mon, 2 Nov 2026 20:14:08 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.2 smtp.subspace.kernel.org 6BC19606D82D Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key, unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20260707 header.b=shURqN8r Received: by mail-wr1-f43.google.com with SMTP id ffacd0b85a97d-48e47347279so2124903f8f.1 for ; Mon, 02 Nov 2026 12:14:08 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20260707; t=1793650447; x=1794255247; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=6kh38ixGlcMYvSMO0Cs+3boaaPdMbwOiDcXF3MCXi/8=; b=shURqN8rf9F3s+vikAaXNN13XP68JcAbANXWVGIgl4rSC3OGdNHoJKZMpm+n5Xq8tS GOudvS22ZCCcmXnE1SJ7fP0dzh8CsgtyrI4Qa+8Agn5Qhpij44rNWkSmbvwTsww4bnOC 11TCf+A5+tN4XuvmTDEXPbEhx64CJGbICXcOivGGeZ4nkI8D0WRKgH5JK2VRqYl5sPE9 /YwEwlCnl1ixFWbCtuQCvuoTCZjS5RpUIsg3L+OWG7YCa+H8bzLcB6RQ/k7QDXQiSn3h ry1e6aTFckb1qC48T9VFTOz2N5GgKFe0KjS2QCBsAFfvxG5fSMTETaaeoDWeDYBEEMIn 1n7Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20260707; t=1793650447; x=1794255247; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=6kh38ixGlcMYvSMO0Cs+3boaaPdMbwOiDcXF3MCXi/8=; b=aC+v9JOycvUvD6VTOi9Vk1A99UelYiU5sTPxPp2tHYMQ3F+DCR07DTkROqQS/9yRFh 53Ezuj5YxfDbJ6Lvh9efidX+JjRaibFJegdzvZRxHUwK6OMm36I1Y3tgoorSqjIYXPRj Pe+jNyMgsMl+m543fEAxT0+JJzOUKjqJy8+5x58EXG04/wjN5fZQGmwJvqfCmn30G3DW mkOUTefr3LHUrp2vMjOcjL7nEe/jis/X/dtPzIrMr4qgl60TZK0O0YCwmTtbxJ7qEXPp 0wF3hPy3NMdXF7cDvJTuy68L0wpWXpEEhvy6CjMjFS2SSWQROfuewjv64gXwxMTz1rKl +nyA== X-Gm-Message-State: APuU4Z+v2hVXD4riuYjmc5vXJOl+w769kwtx6tBMeHJrSvX5bcSMUguu rttY2NwD+WF0u6tkpto7IkGJXp7GNfuiN/CdwksD7NstSK3nhok5HjyvxK+vnZrw3mt+9A== X-Gm-Gg: AYBFou2SYIf60Ah5tUCqALbhm+m4OPIE58tUrRgX1yj8Wnpb1MvfP0FAlhdz331vI3S Pq7zkfjhdGaPI9P8eE7olu0PJwbak5/5D+mjoQFb4obsURJrslb+X67WQyE05tFqVINNIBBox0R 0aGOI+60MvN/5vWD6LJg4c+ZyCRd7Q77SarYfgos7Sf0oQn16x+NPMVKcLDbby9C3MkDRz4b+Q/ 4t7A5NWEnmkT1CcPskjh0y+IB0dL8wRj6jFiDIqLNbxx0OnrjaIy4eN6X5PW9jrCUyQ9HmdHfyj p1NvgBdVznNkqClLRsiZOMx9/hfWiNJcFcW+jFj3uUXzj/smXWHusf25fxj3x6hSzeBB11K+vT9 LOOxpYAyzTZvKzihQUTB46ox7yTv5HFPlFgb1oVpH+B2xnqbSh4ohRhY+FvckcgYC24wc6jR8HU ccah0CjFierFeRrpUWnvYLdZv5S0FmNAH3wvXiBAYS/jPQ4VaCQcc5avMVk/HTfkNi+5VQerB2+ vTrC3Tv+t4B3Rwfg06wWXNYiMS+5Oodurf0+Esq1XpaoJxNa3uLsWym0jubl43ynhft1PYU8JiD Zl9j3gMbQeYAF+VmrpZZOrQHKK0m7pm3n18JWerxh9aD9wAjh3BZsINroJ7/XDnkU+J3YmGIxx2 d X-Received: by 2002:a05:6000:4810:b0:487:106f:ee31 with SMTP id ffacd0b85a97d-48e6e304036mr27957602f8f.27.1793650446745; Mon, 02 Nov 2026 12:14:06 -0800 (PST) Received: from mtardy-friendly-lvh-runner.europe-west1-c.c.cilium-dev.internal ([2600:1900:4010:1a8::]) by smtp.googlemail.com with ESMTPSA id ffacd0b85a97d-48e71b8c6e9sm21471805f8f.43.2026.11.02.12.14.06 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 02 Nov 2026 12:14:06 -0800 (PST) From: Mahe Tardy To: bpf@vger.kernel.org Cc: Quentin Monnet , Alexei Starovoitov , Daniel Borkmann , Andrii Nakryiko , Eduard Zingerman , Kumar Kartikeya Dwivedi , Martin KaFai Lau , Song Liu , Yonghong Song , Jiri Olsa , Emil Tsalapatis , Ihor Solodrai , Shuah Khan , Mahe Tardy , Tianyi Chen , Gyutae Bae , Hui Su , Josef Bacik , linux-kernel@vger.kernel.org, linux-kselftest@vger.kernel.org Subject: [PATCH bpf-next v3 5/5] selftests/bpf: Test gen loader attach Date: Mon, 2 Nov 2026 20:13:56 +0000 Message-ID: <20261102201356.5798-6-mahe.tardy@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20261102201356.5798-1-mahe.tardy@gmail.com> References: <20261102201356.5798-1-mahe.tardy@gmail.com> X-Mailing-List: bpf@vger.kernel.org List-Id: List-Post: List-Help: List-Subscribe: List-Unsubscribe: List-Owner: Precedence: list MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Tests that nothing changes when only loading without attach, verifies that unsupported program types return an error, and check that all tracing program types successfully generate loader attach prog. Then actually checks execution of the generated loader attach for two LSM progs, verifying the links are correctly loading the appropriate programs and that autoload=false and autoattach=false disable it. Finally, checks that if one program out of many fails to attach, the cleanup with detach is done correctly. Signed-off-by: Mahe Tardy --- .../bpf/prog_tests/gen_loader_attach.c | 229 ++++++++++++++++++ .../selftests/bpf/progs/gen_loader_attach.c | 48 ++++ 2 files changed, 277 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/gen_loader_attach.c create mode 100644 tools/testing/selftests/bpf/progs/gen_loader_attach.c diff --git a/tools/testing/selftests/bpf/prog_tests/gen_loader_attach.c b/tools/testing/selftests/bpf/prog_tests/gen_loader_attach.c new file mode 100644 index 000000000000..1277709d7ef2 --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/gen_loader_attach.c @@ -0,0 +1,229 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2026 Isovalent */ +#include +#include +#include + +#define NR_PROGS 7 + +enum execution_case { + ATTACH, + NO_AUTOLOAD, + NO_AUTOATTACH, + ROLLBACK, +}; + +static int link_create_attr_offset(const struct gen_loader_opts *opts, int index) +{ + const struct bpf_insn *insns = (const void *)opts->insns; + int i, count = opts->insns_sz / sizeof(*insns); + + for (i = 4; i < count; i++) { + if (insns[i].code != (BPF_JMP | BPF_CALL) || + insns[i].imm != BPF_FUNC_sys_bpf || + insns[i - 4].code != (BPF_ALU64 | BPF_MOV | BPF_K) || + insns[i - 4].dst_reg != BPF_REG_1 || + insns[i - 4].imm != BPF_LINK_CREATE) + continue; + if (!index--) + return insns[i - 2].imm; + } + return -1; +} + +static struct bpf_object *generate(struct gen_loader_opts *opts, enum execution_case test) +{ + struct bpf_program *prog; + struct bpf_object *obj; + + obj = bpf_object__open_file("gen_loader_attach.bpf.o", NULL); + if (!ASSERT_OK_PTR(obj, "open")) + return NULL; + prog = bpf_object__find_program_by_name(obj, "lsm_open"); + bpf_program__set_autoload(prog, test != NO_AUTOLOAD); + bpf_program__set_autoattach(prog, test != NO_AUTOATTACH); + if (!ASSERT_OK(bpf_object__gen_loader(obj, opts), "gen_loader") || + !ASSERT_OK(bpf_object__load(obj), "generate")) + goto err_out; + return obj; + +err_out: + bpf_object__close(obj); + return NULL; +} + +static void check_load_only(void) +{ + LIBBPF_OPTS(gen_loader_opts, opts); + struct bpf_object *obj; + + obj = generate(&opts, ATTACH); + if (!obj) + return; + ASSERT_EQ(link_create_attr_offset(&opts, 0), -1, "no_link_create"); + bpf_object__close(obj); +} + +static void check_unsupported(void) +{ + LIBBPF_OPTS(gen_loader_opts, opts, .gen_attach = true); + struct bpf_program *prog; + struct bpf_object *obj; + + obj = bpf_object__open_file("gen_loader_attach.bpf.o", NULL); + if (!ASSERT_OK_PTR(obj, "open")) + return; + prog = bpf_object__find_program_by_name(obj, "socket"); + bpf_program__set_autoload(prog, true); + if (ASSERT_OK(bpf_object__gen_loader(obj, &opts), "gen_loader")) + ASSERT_EQ(bpf_object__load(obj), -EOPNOTSUPP, "unsupported_attach"); + bpf_object__close(obj); +} + +static void check_tracing_generation(void) +{ + LIBBPF_OPTS(gen_loader_opts, opts, .gen_attach = true); + struct bpf_program *prog; + struct bpf_object *obj; + int index = 0; + + obj = bpf_object__open_file("gen_loader_attach.bpf.o", NULL); + if (!ASSERT_OK_PTR(obj, "open")) + return; + bpf_object__for_each_program(prog, obj) + bpf_program__set_autoload(prog, bpf_program__type(prog) == BPF_PROG_TYPE_TRACING); + if (!ASSERT_OK(bpf_object__gen_loader(obj, &opts), "gen_loader") || + !ASSERT_OK(bpf_object__load(obj), "generate")) + goto out; + bpf_object__for_each_program(prog, obj) { + const union bpf_attr *attr; + int off; + + if (!bpf_program__autoload(prog)) + continue; + off = link_create_attr_offset(&opts, index++); + if (!ASSERT_GE(off, 0, bpf_program__name(prog))) + goto out; + attr = (const void *)(opts.data + off); + ASSERT_EQ(attr->link_create.attach_type, + bpf_program__expected_attach_type(prog), bpf_program__name(prog)); + } + ASSERT_EQ(link_create_attr_offset(&opts, index), -1, "link_count"); +out: + bpf_object__close(obj); +} + +static int count_fds(void) +{ + struct dirent *entry; + int count = 0; + DIR *dir; + + dir = opendir("/proc/self/fd"); + if (!dir) + return -errno; + while ((entry = readdir(dir))) + if (entry->d_name[0] != '.') + count++; + closedir(dir); + return count; +} + +static void check_execution(enum execution_case test) +{ + LIBBPF_OPTS(gen_loader_opts, gen, .gen_attach = true); + struct { + struct bpf_loader_ctx ctx; + struct bpf_prog_desc progs[NR_PROGS]; + struct bpf_link_desc links[NR_PROGS]; + } ctx = { .ctx.sz = sizeof(ctx) }; + struct bpf_load_and_run_opts run = { .ctx = &ctx.ctx }; + struct bpf_object *obj; + int i, off, err, before; + + obj = generate(&gen, test); + if (!obj) + return; + run.insns = gen.insns; + run.insns_sz = gen.insns_sz; + run.data = gen.data; + run.data_sz = gen.data_sz; + + if (test == ROLLBACK) { + off = link_create_attr_offset(&gen, 1); + if (!ASSERT_GE(off, 0, "second_link_attr")) + goto out; + /* Force the second attachment to fail after the first succeeded. */ + ((union bpf_attr *)(gen.data + off))->link_create.attach_type = BPF_TRACE_FENTRY; + + before = count_fds(); + if (!ASSERT_GE(before, 0, "count_fds")) + goto out; + ASSERT_EQ(bpf_load_and_run(&run), -EINVAL, "second_attach_failed"); + ASSERT_EQ(count_fds(), before, "rollback_fds"); + goto out; + } + + err = bpf_load_and_run(&run); + if (!ASSERT_OK(err, "run_loader")) + goto out; + + for (i = 0; i < NR_PROGS; i++) { + struct bpf_link_info link = {}; + struct bpf_prog_info prog = {}; + __u32 size; + + /* + * Only the first two programs load by default; NO_AUTOLOAD also + * skips the first. NO_AUTOATTACH must still return its program FD. + */ + if (i >= 2 || (!i && test == NO_AUTOLOAD)) { + ASSERT_EQ(ctx.progs[i].prog_fd, 0, "skipped_program"); + } else { + size = sizeof(prog); + if (!ASSERT_GT(ctx.progs[i].prog_fd, 0, "program_fd") || + !ASSERT_OK(bpf_prog_get_info_by_fd(ctx.progs[i].prog_fd, &prog, &size), + "prog_info")) + continue; + } + + /* + * Unloaded programs have no link. NO_AUTOATTACH also leaves the + * first program's link slot zero, even though its program is loaded. + */ + if (i >= 2 || (!i && (test == NO_AUTOLOAD || test == NO_AUTOATTACH))) { + ASSERT_EQ(ctx.links[i].link_fd, 0, "skipped_link"); + continue; + } + /* Verify the link references the corresponding loaded program. */ + size = sizeof(link); + if (!ASSERT_OK(bpf_link_get_info_by_fd(ctx.links[i].link_fd, &link, &size), + "link_info")) + continue; + ASSERT_EQ(link.prog_id, prog.id, "attached_program"); + } +out: + for (i = 0; i < NR_PROGS; i++) { + skel_closenz(ctx.links[i].link_fd); + skel_closenz(ctx.progs[i].prog_fd); + } + bpf_object__close(obj); +} + +void test_gen_loader_attach(void) +{ + if (test__start_subtest("load_only")) + check_load_only(); + if (test__start_subtest("unsupported")) + check_unsupported(); + if (test__start_subtest("tracing")) + check_tracing_generation(); + if (test__start_subtest("execute")) + check_execution(ATTACH); + if (test__start_subtest("execute_no_autoload")) + check_execution(NO_AUTOLOAD); + if (test__start_subtest("execute_no_autoattach")) + check_execution(NO_AUTOATTACH); + if (test__start_subtest("rollback")) + check_execution(ROLLBACK); +} diff --git a/tools/testing/selftests/bpf/progs/gen_loader_attach.c b/tools/testing/selftests/bpf/progs/gen_loader_attach.c new file mode 100644 index 000000000000..9a38fe4ac7bb --- /dev/null +++ b/tools/testing/selftests/bpf/progs/gen_loader_attach.c @@ -0,0 +1,48 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2026 Isovalent */ +#include "vmlinux.h" +#include + +SEC("lsm/file_open") +int lsm_open(void *ctx) +{ + return 0; +} + +SEC("lsm/file_permission") +int lsm_perm(void *ctx) +{ + return 0; +} + +SEC("?socket") +int socket(void *ctx) +{ + return 0; +} + +SEC("?fentry/security_inode_getattr") +int fentry(void *ctx) +{ + return 0; +} + +SEC("?fexit/security_inode_getattr") +int fexit(void *ctx) +{ + return 0; +} + +SEC("?fmod_ret/security_inode_getattr") +int fmod_ret(void *ctx) +{ + return 0; +} + +SEC("?tp_btf/sys_enter") +int tp_btf(void *ctx) +{ + return 0; +} + +char _license[] SEC("license") = "GPL"; -- 2.43.0