From mboxrd@z Thu Jan 1 00:00:00 1970 Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.remote-ip=209.85.221.54 ARC-Seal: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; cv=none; t=1793650448; b=NAjKnjbU5LatO4FbEZMgTb08PZ9AJdbwAQSw1GOebUThyMUVwkyrtRvhCumg7MXfumKh OEQqfXACOwH7RnmC7UOeioHn7VRQzhFosKgjVMphXXC5Y9nzwYV3mriQ3A3lvP42Kl0IY YjCxnVheGrbW2/mGiEg3kdLcHE/1BetvsXD8k0lz4XwB/1hLzD9TIwxHyIl6/ZvvZiNHN tIDPUwLL8jun9Xpatc5oJMu3Dsy34rbrrG8y/aWpKCvvhGGNUtKpa4I5O0ETdUyXCvVOK G+otkJ6Q+qh/Uf/JapAx3WerIsn2cTF1WnGTP1xlERqPf86h2azCZwDHoR85QIKCvfQ== ARC-Message-Signature: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; c=relaxed/relaxed; t=1793650448; h=DMARC-Filter:Received:DKIM-Signature:X-Google-DKIM-Signature: X-Forwarded-Encrypted: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=xSSeSQhlELgNJXcKGOU4vLJ3S5epDUQbQY+5ILn1ohRtyjHxOztBa4mzquaPhwWlAW8Q n/OSiCxUSyak7NUMtsbDrixAANNRNknP6a+SjoJ/iWxDJxHM0bCGvLoxftl20Jqx0c1DY dlSG/g8KHaE7+fqHpr93LIyuWLJ1JAgY8NO/ikrwCvkSeStUYRl0XDbhlo0xMRSv7yVvW rfnTuVxLuFbIb9zNpalFV9QTd1gXl1VZZqGCDgycMy2kR1Ve677F/LNqs98PWczct6EeP XFa9b8lh8ps4cYfSu6xkte+TjVl8+Uw/9DO4S+s6XMJqYO9qNYS5GgbUaRjQpO8a+zA== 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.54 Received: from mail-wr1-f54.google.com (mail-wr1-f54.google.com [209.85.221.54]) (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 74F67606D82E for ; Mon, 2 Nov 2026 20:14:08 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.2 smtp.subspace.kernel.org 74F67606D82E 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-f54.google.com with SMTP id ffacd0b85a97d-48e00eee27dso1728140f8f.0 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=nhblK/CMVIFZWrahua4Pki/O20BC/2Pl1ZHpbCPRmWAy9WP9JDg4TIYxG53m2w9BZG OD4NI7f9fW03fZTkzrdaADDbeIafPZIjaWG8hhG3Q/8DA4CCrKQu2auDMAk3o9eQzfOx tHOT5l7dxeAb6a4DfqPxwugSQuudQ98f33QPOg3Qewa5xlmv4lOuUknXwW+BsX0O8Nj4 7IxcB3wtw3SR/GwfjXJ8U7VyuvbukJ2GuNhX0AtKy929h/g/I3s+nFBkavvoGj5yDnlT tjMnlEJ9I3OLxDeLE6vFrxDUuMUKxznZv5xqjHLrJJASjEHmVXpazTkl7UY8/ZQ9nUN+ pfYw== X-Forwarded-Encrypted: i=1; AKwUvByn8pkiTh07Of36yawAFQAJYxQpjyR7STW8+5POBaCgP7STrQ5QDgrGE/VlzKVtZz43fQ+KQRE/764wXMI=@vger.kernel.org X-Gm-Message-State: APuU4Z8Y7de5wIWwRNeLMUOdHdw/Ye1vtdOcsIMA272wDa6IUquqyDOz z5Rh1B1NNGdHn1r0kxiacoAfzw8yKKZenuPOJ1ZQdPfIP31wyvKo2pwN X-Gm-Gg: AYBFou33ixQm8PNnPA/qvRcZIelJwIdtUV9DqBssdzYLAs/wxvqrbYBUDSugOWD0k8c dneK74EBLv1AvjohHalTa3Y2mcQDhA6jsH+/HMjT6TAnAYdm47kY+eKN1OKt0ky/eZMSmPA4P4q VTT8MHod/NXYod06/JB/wZjItUkYypaz6Frt7f9y2X5S921ZQk6QyBDb2MYUntz1+vkaq6eYArz kqs48an6nRHhKRA/C1heNqigtHwcSEBUXWBqYvbP+tZ3RwU6mxpNJZ25tmAMPRvGlJg6qGCSUMC LdhJ+jUy9OpNy5QktCkfBhIxdLB99VT262n0UqQVjHC3i7+cNv8O+pbh5tdPHVQoByb+FxHCYHl fntiVg/9UdAOlyHlzizsl7sDLVatLUpVR0L2ji3ZU+pkFFv41WuUsccxDWixiUPIgepdJTcIoFQ 1lFW/P6xRN9ypLx3ocYzDe+bIFXTGOlfQ0Z8otWPqrYMt1NIwpCP787PiAodTRhTolnD8Woszt+ CXBXEFZ59NXKfNxmHwlmOx2Sx5CEvGUOAfnVgigxV/sUPgk8MfwVINc7rRENvBbxWfQvRiFHm1t izkei15MoxRIrK//1ZcQsdGGI5DgE1PHWRmC/czZqxOP4+vlCqT0anv4mdJOnBIsL/T9sOGm1A0 9 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: linux-kernel@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