From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mx0b-00206402.pphosted.com (mx0b-00206402.pphosted.com [148.163.152.16]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 09B17502D4F for ; Mon, 21 Sep 2026 22:39:55 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=148.163.152.16 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1790030397; cv=none; b=L5G9IMFHVnxKM/Hngk0lgyuYMkA/bFsA3aLrXNqQ/cDK2o52obRXVIGDtmLZkdUGF0aAkFimEVcYXPrkaHkbsSI/P7JBSz3NFLrr/XvptnLsiZ+g02iAzmyV8bdS5oV3f71IWdmxHPR9/OdwtSLKWRcwOYoaFfLlrKTYE8aKD7k= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1790030397; c=relaxed/simple; bh=CJCrB+P8279kl73JTy4D0s/na02387JeImGG1xnQ2dY=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=YO9yeryq9gaMYyb7+3aGcwBZLjMv/4lw03c8itRZYSk+QMOJYDcN9OJevGE7iNRYdYnn60li1ziAzuuzM8KYP4HkkchFiB2ydctXqeAA/7YpG9+q0Ks8DoGJGb1zKiJc1miPs2W384FOnyXsvSxurcB/f4v7jtYFy0MaVNw/AsM= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=crowdstrike.com; spf=pass smtp.mailfrom=crowdstrike.com; dkim=pass (2048-bit key) header.d=crowdstrike.com header.i=@crowdstrike.com header.b=R+onekHC; arc=none smtp.client-ip=148.163.152.16 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=crowdstrike.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=crowdstrike.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=crowdstrike.com header.i=@crowdstrike.com header.b="R+onekHC" Received: from pps.filterd (m0354654.ppops.net [127.0.0.1]) by mx0b-00206402.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 68LIoo4C3069599; Mon, 21 Sep 2026 22:39:41 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=crowdstrike.com; h=cc:content-transfer-encoding:content-type:date:from :in-reply-to:message-id:mime-version:references:subject:to; s= default; bh=TZJM8kPiV36yDhyB/JkUHFEixLyBqiHCp/IfhE0HjUE=; b=R+on ekHC1jpzyBgz8FFX1X1mdhU+wAbDW2nAeARtsSCZoFld2D9mc6SJxFVqqDSwRQgi jyoqqyO/EE/EroTx64jpPJREdXm+JCW3e+7THsSzZoF1WzDAL/5TtGXQVWQLywJA PAeZgdYzJMkgimxcaU/QQk7WWgxNWdP1SDxj1q5RoeEhTkFgstqzJwYTqAVwaqMj 8gTTJRAKhpumpH+fj3ABcVTKprENmQS6BnFeBLpHeuvHsb1+sbvC31BreMALPlpC 8gu/sQ/KOV4z72r4vgKihdn/Z7WdpZGMkKMld554eKlO8TwwJIZY+9lxs9qwski6 mpYrXLmYY66AJdr58A== Received: from mail.crowdstrike.com (dragosx.crowdstrike.com [208.42.231.60] (may be forged)) by mx0b-00206402.pphosted.com (PPS) with ESMTPS id 4gua798q06-2 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 21 Sep 2026 22:39:41 +0000 (GMT) Received: from LL-DJCZ134.crowdstrike.sys (10.100.11.122) by 04WPEXCH006.crowdstrike.sys (10.100.11.70) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.2562.46; Mon, 21 Sep 2026 22:39:40 +0000 From: Andrey Grodzovsky To: , CC: , , , Subject: [PATCH bpf-next v4 1/7] libbpf: BPF program load strategy enum Date: Mon, 21 Sep 2026 18:39:31 -0400 Message-ID: <20260921223937.3203093-2-andrey.grodzovsky@crowdstrike.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260921223937.3203093-1-andrey.grodzovsky@crowdstrike.com> References: <20260921223937.3203093-1-andrey.grodzovsky@crowdstrike.com> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Content-Type: text/plain X-ClientProxiedBy: 04WPEXCH014.crowdstrike.sys (10.100.11.87) To 04WPEXCH006.crowdstrike.sys (10.100.11.70) X-Proofpoint-Spam-Info: AW1haW4tMjYwOTIxMDMzMSBTYWx0ZWRfX5Ec7W+X8RY51 MpXRHLrLZnYNCXg7HIWfXkqprLnIzqXtLbi621W909vDgOywJywsjDfVTB+KIH2f352Hw0c0puL aWZ3T8I8oEp7j2SxV+FRgE1aIgWb/Zdi3SPSyq3WrGHp986Xlksb X-Proofpoint-ORIG-GUID: dD-2MVbGIMqvuE7cTe1PaOL4cHY3gdXu X-Authority-Analysis: v=2.4 cv=QMP91QLL c=1 sm=1 tr=0 ts=6ab1b22d cx=c_pps a=1d8vc5iZWYKGYgMGCdbIRA==:117 a=1d8vc5iZWYKGYgMGCdbIRA==:17 a=EjBHVkixTFsA:10 a=VdqzKS8jKosA:10 a=VkNPw1HP01LnGYTKEx00:22 a=T2KQ53IYiC3MXPrxx8bB:22 a=R_n4Uisa8axJ7jemP0ek:22 a=pl6vuDidAAAA:8 a=2A3Asy7NaOYSI4mtEPsA:9 X-Proofpoint-GUID: dD-2MVbGIMqvuE7cTe1PaOL4cHY3gdXu X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwOTIxMDMzMSBTYWx0ZWRfXz8pXQiiM2Khk 9ALxq88FYXB3hk91sATXIIlFElWpDOxr08ZwAxqJ8Yapk+Eu/bLb0F9gGcfjFl5Cb2JAJR9nIT4 UR+djgRzeNrqOwDpzHrKAGo1dq++seM8wRoSRgpFMTSYzdEC5RZ7kT2Uh3OW3yiGdGkzSZFKp/8 5NwGe4YD7TqffjZ67wquIOCpacte7CWF2LFhq+CRnuFwMavWFJpc3jWzMWG61VFTKg0/fjtfEWX 78BJoKdPQWNM05qNK4umDjajpk1MC2hVOVB8FWCR3MFqH62hJ2t6wNvRpivLZlA3NbzzNkNLi0I vRyJgJ7LpjN9YyvhINjO88jCCteFPHX67z85lf7rr2rkVK1Y6Qx/ln2sb8sML/oUn9HwIyRbg+3 BTxn4QTDiZXgM3YJThS3hhf59rWZcCpI6pLlcrDMKEkyMob6kAT9/nfvuAzmAMYlQXLgepzBhVd AVf6ueosZPiuLKBFKgQ== X-Proofpoint-Virus-Version: vendor=nai engine=6900 definitions=11912 signatures=596817 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 lowpriorityscore=0 impostorscore=0 clxscore=1015 spamscore=0 priorityscore=1501 malwarescore=0 phishscore=0 adultscore=0 bulkscore=0 suspectscore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2609040000 definitions=main-2609210331 From: Slava Imameev Replacing the boolean field with an enum simplifies the addition of new load strategies. Currently, the bpf_program structure defines the autoload behavior using a boolean field. This field is now replaced with an enum, allowing new BPF program loading strategies to be introduced by extending the enum value range. Signed-off-by: Slava Imameev Signed-off-by: Andrey Grodzovsky --- tools/lib/bpf/libbpf.c | 50 +++++++++++++++++++++++++--------------- tools/lib/bpf/libbpf.h | 33 ++++++++++++++++++++++++++ tools/lib/bpf/libbpf.map | 2 ++ 3 files changed, 66 insertions(+), 19 deletions(-) diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c index 2f53afc985cf..d88df7e4c86d 100644 --- a/tools/lib/bpf/libbpf.c +++ b/tools/lib/bpf/libbpf.c @@ -494,7 +494,7 @@ struct bpf_program { struct bpf_object *obj; int fd; - bool autoload; + enum bpf_prog_load_strategy load_strategy; bool autoattach; bool sym_global; bool mark_btf_static; @@ -872,11 +872,11 @@ bpf_object__init_prog(struct bpf_object *obj, struct bpf_program *prog, * autoload set to false. */ if (sec_name[0] == '?') { - prog->autoload = false; + prog->load_strategy = BPF_PROG_LOAD_STRATEGY_DISABLED; /* from now on forget there was ? in section name */ sec_name++; } else { - prog->autoload = true; + prog->load_strategy = BPF_PROG_LOAD_STRATEGY_AUTO; } prog->autoattach = true; @@ -1163,7 +1163,8 @@ static int bpf_object_adjust_struct_ops_autoload(struct bpf_object *obj) } } if (use_cnt) - prog->autoload = should_load; + prog->load_strategy = should_load ? BPF_PROG_LOAD_STRATEGY_AUTO + : BPF_PROG_LOAD_STRATEGY_DISABLED; } return 0; @@ -1254,7 +1255,7 @@ static int bpf_map__init_kern_struct_ops(struct bpf_map *map) * then bpf_object_adjust_struct_ops_autoload() will update its * autoload accordingly. */ - st_ops->progs[i]->autoload = false; + st_ops->progs[i]->load_strategy = BPF_PROG_LOAD_STRATEGY_DISABLED; st_ops->progs[i] = NULL; } @@ -1292,7 +1293,7 @@ static int bpf_map__init_kern_struct_ops(struct bpf_map *map) * if user replaced it with another program or NULL */ if (st_ops->progs[i] && st_ops->progs[i] != prog) - st_ops->progs[i]->autoload = false; + st_ops->progs[i]->load_strategy = BPF_PROG_LOAD_STRATEGY_DISABLED; /* Update the value from the shadow type */ st_ops->progs[i] = prog; @@ -3592,7 +3593,7 @@ static bool obj_needs_vmlinux_btf(const struct bpf_object *obj) } bpf_object__for_each_program(prog, obj) { - if (!prog->autoload) + if (prog->load_strategy == BPF_PROG_LOAD_STRATEGY_DISABLED) continue; if (prog_needs_vmlinux_btf(prog)) return true; @@ -6186,7 +6187,7 @@ bpf_object__relocate_core(struct bpf_object *obj, const char *targ_btf_path) /* no need to apply CO-RE relocation if the program is * not going to be loaded */ - if (!prog->autoload) + if (prog->load_strategy == BPF_PROG_LOAD_STRATEGY_DISABLED) continue; /* adjust insn_idx from section frame of reference to the local @@ -7530,7 +7531,7 @@ static int bpf_object__relocate(struct bpf_object *obj, const char *targ_btf_pat */ if (prog_is_subprog(obj, prog)) continue; - if (!prog->autoload) + if (prog->load_strategy == BPF_PROG_LOAD_STRATEGY_DISABLED) continue; err = bpf_object__relocate_calls(obj, prog); @@ -7566,7 +7567,7 @@ static int bpf_object__relocate(struct bpf_object *obj, const char *targ_btf_pat prog = &obj->programs[i]; if (prog_is_subprog(obj, prog)) continue; - if (!prog->autoload) + if (prog->load_strategy == BPF_PROG_LOAD_STRATEGY_DISABLED) continue; /* Process data relos for main programs */ @@ -8405,8 +8406,8 @@ bpf_object__load_progs(struct bpf_object *obj, int log_level) prog = &obj->programs[i]; if (prog_is_subprog(obj, prog)) continue; - if (!prog->autoload) { - pr_debug("prog '%s': skipped loading\n", prog->name); + if (prog->load_strategy != BPF_PROG_LOAD_STRATEGY_AUTO) { + pr_debug("prog '%s': skipped auto-loading\n", prog->name); continue; } prog->log_level |= log_level; @@ -9807,16 +9808,13 @@ const char *bpf_program__section_name(const struct bpf_program *prog) bool bpf_program__autoload(const struct bpf_program *prog) { - return prog->autoload; + return prog->load_strategy == BPF_PROG_LOAD_STRATEGY_AUTO; } int bpf_program__set_autoload(struct bpf_program *prog, bool autoload) { - if (prog->obj->state >= OBJ_LOADED) - return libbpf_err(-EINVAL); - - prog->autoload = autoload; - return 0; + return bpf_program__set_load_strategy(prog, + autoload ? BPF_PROG_LOAD_STRATEGY_AUTO : BPF_PROG_LOAD_STRATEGY_DISABLED); } bool bpf_program__autoattach(const struct bpf_program *prog) @@ -15194,7 +15192,7 @@ int bpf_object__attach_skeleton(struct bpf_object_skeleton *s) struct bpf_program *prog = *prog_skel->prog; struct bpf_link **link = prog_skel->link; - if (!prog->autoload || !prog->autoattach) + if (prog->load_strategy != BPF_PROG_LOAD_STRATEGY_AUTO || !prog->autoattach) continue; /* auto-attaching not supported for this program */ @@ -15304,3 +15302,17 @@ void bpf_object__destroy_skeleton(struct bpf_object_skeleton *s) free(s->progs); free(s); } + +int bpf_program__set_load_strategy(struct bpf_program *prog, enum bpf_prog_load_strategy strategy) +{ + if (prog->obj->state >= OBJ_LOADED) + return libbpf_err(-EINVAL); + + prog->load_strategy = strategy; + return 0; +} + +enum bpf_prog_load_strategy bpf_program__load_strategy(const struct bpf_program *prog) +{ + return prog->load_strategy; +} diff --git a/tools/lib/bpf/libbpf.h b/tools/lib/bpf/libbpf.h index 026932f20962..a06259c4dacc 100644 --- a/tools/lib/bpf/libbpf.h +++ b/tools/lib/bpf/libbpf.h @@ -2103,6 +2103,39 @@ LIBBPF_API int libbpf_unregister_prog_handler(int handler_id); */ LIBBPF_API int bpf_program__clone(struct bpf_program *prog, const struct bpf_prog_load_opts *opts); +/** + * The program load strategy: + * + * - BPF_PROG_LOAD_STRATEGY_DISABLED: the program is not loaded. + * - BPF_PROG_LOAD_STRATEGY_AUTO: the program is autoloaded when the bpf_object is loaded. + */ +enum bpf_prog_load_strategy { + BPF_PROG_LOAD_STRATEGY_DISABLED = 0, + BPF_PROG_LOAD_STRATEGY_AUTO, +}; + +/** + * @brief **bpf_program__set_load_strategy()** sets the load strategy of a + * BPF program, controlling whether and when it gets loaded into the kernel. + * + * Can only be called before the enclosing bpf_object is loaded. + * + * @param prog BPF program to update + * @param strategy new load strategy for the program + * @return 0 on success; negative error code if the object was already loaded + */ +LIBBPF_API int bpf_program__set_load_strategy(struct bpf_program *prog, + enum bpf_prog_load_strategy strategy); + +/** + * @brief **bpf_program__load_strategy()** returns the current load strategy + * of a BPF program. + * + * @param prog BPF program to query + * @return current load strategy of the program + */ +LIBBPF_API enum bpf_prog_load_strategy bpf_program__load_strategy(const struct bpf_program *prog); + #ifdef __cplusplus } /* extern "C" */ #endif diff --git a/tools/lib/bpf/libbpf.map b/tools/lib/bpf/libbpf.map index 7a84dd00ce95..03c3d2bd15bf 100644 --- a/tools/lib/bpf/libbpf.map +++ b/tools/lib/bpf/libbpf.map @@ -463,6 +463,8 @@ LIBBPF_1.8.0 { bpf_program__attach_tracing_multi; bpf_program__clear_flags; bpf_program__clone; + bpf_program__load_strategy; + bpf_program__set_load_strategy; btf__find_by_name_kind_own; btf__new_empty_opts; } LIBBPF_1.7.0; -- 2.34.1