libbpf: auto-bump RLIMIT_MEMLOCK if kernel needs it for BPF
Subsystems (4)
Andrii Nakryiko
maintainerPATCH 1/2 libbpf: auto-bump RLIMIT_MEMLOCK if kernel needs it for BPF
The need to increase RLIMIT_MEMLOCK to do anything useful with BPF is one of the first extremely frustrating gotchas that all new BPF users go through and in some cases have to learn it a very hard way.
Luckily, starting with upstream Linux kernel version 5.11, BPF subsystem dropped the dependency on memlock and uses memcg-based memory accounting instead. Unfortunately, detecting memcg-based BPF memory accounting is far from trivial (as can be evidenced by this patch), so in practice most BPF applications still do unconditional RLIMIT_MEMLOCK increase.
As we move towards libbpf 1.0, it would be good to allow users to forget about RLIMIT_MEMLOCK vs memcg and let libbpf do the sensible adjustment automatically. This patch paves the way forward in this matter. Libbpf will do feature detection of memcg-based accounting, and if detected, will do nothing. But if the kernel is too old, just like BCC, libbpf will automatically increase RLIMIT_MEMLOCK on behalf of user application ([0]).
As this is technically a breaking change, during the transition period applications have to opt into libbpf 1.0 mode by setting LIBBPF_STRICT_AUTO_RLIMIT_MEMLOCK bit when calling libbpf_set_strict_mode().
Libbpf allows to control the exact amount of set RLIMIT_MEMLOCK limit with libbpf_set_memlock_rlim_max() API. Passing 0 will make libbpf do nothing with RLIMIT_MEMLOCK. libbpf_set_memlock_rlim_max() has to be called before the first bpf_prog_load(), bpf_btf_load(), or bpf_object__load() call, otherwise it has no effect and will return -EBUSY.
[0] Closes: https://github.com/libbpf/libbpf/issues/369
--- tools/lib/bpf/bpf.c | 122 ++++++++++++++++++++++++++++++++ tools/lib/bpf/bpf.h | 2 + tools/lib/bpf/libbpf.c | 47 +++--------- tools/lib/bpf/libbpf.map | 1 + tools/lib/bpf/libbpf_internal.h | 39 ++++++++++ tools/lib/bpf/libbpf_legacy.h | 12 +++- 6 files changed, 184 insertions(+), 39 deletions(-)
tools/lib/bpf/bpf.c +122 -0
@@ -29,6 +29,7 @@#include <errno.h> #include <linux/bpf.h> #include <limits.h> +#include <sys/resource.h> #include "bpf.h" #include "libbpf.h" #include "libbpf_internal.h"
@@ -94,6 +95,119 @@ static inline int sys_bpf_prog_load(union bpf_attr *attr, unsigned int size, intreturn fd; } +/* Probe whether kernel switched from memlock-based (RLIMIT_MEMLOCK) to +* memcg-based memory accounting for BPF maps and progs. This was done in [0], +* but it's not straightforward to detect those changes from the user-space. +* So instead we'll try to detect whether [1] is in the kernel, which follows +* [0] almost immediately and made it into the upstream kernel in the same +* release. +* +* For this, we'll upload a trivial BTF into the kernel and will try to load +* a trivial BPF program with attach_btf_obj_fd pointing to our BTF. If it +* returns anything but -EOPNOTSUPP, we'll assume we still need +* RLIMIT_MEMLOCK. +* +* [0] https://lore.kernel.org/bpf/[email protected]/ +* [1] Fixes: 8bdd8e275ede ("bpf: Return -ENOTSUPP when attaching to non-kernel BTF") +*/ +int probe_memcg_account (void ) +{ + const size_t bpf_load_attr_sz = offsetofend(union bpf_attr, attach_btf_obj_fd); + const size_t btf_load_attr_sz = offsetofend(union bpf_attr, btf_log_level); +int prog_fd =-1 , btf_fd =-1 , err; +struct bpf_insn insns[1 ] = {};/* instructions don't matter */ +const void *btf_data; +union bpf_attr attr; +__u32 btf_data_sz; +struct btf *btf; + +/* create the simplest BTF object and upload it into the kernel */ + btf =btf__new_empty (); + err =libbpf_get_error (btf); +if (err) +return err; + err =btf__add_int (btf,"int" ,4 ,0 ); + btf_data =btf__raw_data (btf, &btf_data_sz); +if (!btf_data) { + err = -ENOMEM ; + goto cleanup; + } + +/* we won't use bpf_btf_load() or bpf_prog_load() because they will +* be trying to detect this feature and will cause an infinite loop +*/ +memset (&attr,0 , btf_load_attr_sz); + attr.btf =ptr_to_u64 (btf_data); + attr.btf_size = btf_data_sz; + btf_fd =sys_bpf_fd (BPF_BTF_LOAD , &attr, btf_load_attr_sz); +if (btf_fd <0 ) { + err = -errno; + goto cleanup; + } + +/* attempt loading freplace trying to use custom BTF */ +memset (&attr,0 , bpf_load_attr_sz); + attr.prog_type =BPF_PROG_TYPE_TRACING ; + attr.expected_attach_type =BPF_TRACE_FENTRY ; + attr.insns =ptr_to_u64 (insns); + attr.insn_cnt =sizeof (insns) /sizeof (insns[0 ]); + attr.license =ptr_to_u64 ("GPL" ); + attr.attach_btf_obj_fd = btf_fd; + + prog_fd =sys_bpf_fd (BPF_PROG_LOAD , &attr, bpf_load_attr_sz); +if (prog_fd >=0 ) +/* bug? we shouldn't be able to successfully load program */ + err = -EFAULT ; +else +/* assume memcg accounting is supported if we get -EOPNOTSUPP */ + err = errno ==524 /* ENOTSUPP */ ?1 :0 ; + +cleanup: +btf__free (btf); +if (btf_fd >=0 ) +close (btf_fd); +if (prog_fd >=0 ) +close (prog_fd); +return err; +} + +static bool memlock_bumped; +static rlim_t memlock_rlim_max =RLIM_INFINITY ; + +int libbpf_set_memlock_rlim_max (size_t memlock_max) +{ +if (memlock_bumped) +return libbpf_err (-EBUSY ); + + memlock_rlim_max = memlock_max; +return 0 ; +} + +int bump_rlimit_memlock (void ) +{ +struct rlimit rlim; + +/* this the default in libbpf 1.0, but for now user has to opt-in explicitly */ +if (!(libbpf_mode &LIBBPF_STRICT_AUTO_RLIMIT_MEMLOCK )) +return 0 ; + +/* if kernel supports memcg-based accounting, skip bumping RLIMIT_MEMLOCK */ +if (memlock_bumped ||kernel_supports (NULL ,FEAT_MEMCG_ACCOUNT )) +return 0 ; + + memlock_bumped = true; + +/* zero memlock_rlim_max disables auto-bumping RLIMIT_MEMLOCK */ +if (memlock_rlim_max ==0 ) +return 0 ; + + rlim.rlim_cur = rlim.rlim_max = memlock_rlim_max; +if (setrlimit (RLIMIT_MEMLOCK , &rlim)) +return -errno; + +return 0 ; +} + int bpf_map_create(enum bpf_map_type map_type, const char *map_name, __u32 key_size,
@@ -105,6 +219,8 @@ int bpf_map_create(enum bpf_map_type map_type,union bpf_attr attr;int fd; +bump_rlimit_memlock (); +memset (&attr,0 , attr_sz);if (!OPTS_VALID (opts, bpf_map_create_opts))
@@ -251,6 +367,8 @@ int bpf_prog_load_v0_6_0(enum bpf_prog_type prog_type,union bpf_attr attr;char *log_buf; +bump_rlimit_memlock (); +if (!OPTS_VALID (opts, bpf_prog_load_opts))return libbpf_err (-EINVAL );
@@ -453,6 +571,8 @@ int bpf_verify_program(enum bpf_prog_type type, const struct bpf_insn *insns,union bpf_attr attr;int fd; +bump_rlimit_memlock (); +memset (&attr,0 ,sizeof (attr)); attr.prog_type = type; attr.insn_cnt = (__u32 )insns_cnt;
@@ -1050,6 +1170,8 @@ int bpf_load_btf(const void *btf, __u32 btf_size, char *log_buf, __u32 log_buf_sunion bpf_attr attr = {};int fd; +bump_rlimit_memlock (); + attr.btf =ptr_to_u64 (btf); attr.btf_size = btf_size;
tools/lib/bpf/bpf.h +2 -0
@@ -35,6 +35,8 @@extern "C" {#endif +int libbpf_set_memlock_rlim_max (size_t memlock_max); +struct bpf_map_create_opts {size_t sz;/* size of this struct for forward/backward compatibility */
tools/lib/bpf/libbpf.c +9 -38
71 lines not on this page · raw message
tools/lib/bpf/libbpf.map +1 -0
@@ -424,4 +424,5 @@ LIBBPF_0.7.0 { global: bpf_program__log_level; bpf_program__set_log_level; + libbpf_set_memlock_rlim_max; };
tools/lib/bpf/libbpf_internal.h +39 -0
@@ -272,6 +272,45 @@ static inline bool libbpf_validate_opts(const char *opts, (opts)->sz - __off); \ }) +enum kern_feature_id { +/* v4.14: kernel support for program & map names. */ +FEAT_PROG_NAME , +/* v5.2: kernel support for global data sections. */ +FEAT_GLOBAL_DATA , +/* BTF support */ +FEAT_BTF , +/* BTF_KIND_FUNC and BTF_KIND_FUNC_PROTO support */ +FEAT_BTF_FUNC , +/* BTF_KIND_VAR and BTF_KIND_DATASEC support */ +FEAT_BTF_DATASEC , +/* BTF_FUNC_GLOBAL is supported */ +FEAT_BTF_GLOBAL_FUNC , +/* BPF_F_MMAPABLE is supported for arrays */ +FEAT_ARRAY_MMAP , +/* kernel support for expected_attach_type in BPF_PROG_LOAD */ +FEAT_EXP_ATTACH_TYPE , +/* bpf_probe_read_{kernel,user}[_str] helpers */ +FEAT_PROBE_READ_KERN , +/* BPF_PROG_BIND_MAP is supported */ +FEAT_PROG_BIND_MAP , +/* Kernel support for module BTFs */ +FEAT_MODULE_BTF , +/* BTF_KIND_FLOAT support */ +FEAT_BTF_FLOAT , +/* BPF perf link support */ +FEAT_PERF_LINK , +/* BTF_KIND_DECL_TAG support */ +FEAT_BTF_DECL_TAG , +/* BTF_KIND_TYPE_TAG support */ +FEAT_BTF_TYPE_TAG , +/* memcg-based accounting for BPF maps and progs */ +FEAT_MEMCG_ACCOUNT , + __FEAT_CNT, +}; + +int probe_memcg_account (void ); +bool kernel_supports (const struct bpf_object *obj,enum kern_feature_id feat_id); +int bump_rlimit_memlock (void );int parse_cpu_mask_str (const char *s,bool **mask,int *mask_sz);int parse_cpu_mask_file (const char *fcpu,bool **mask,int *mask_sz);
tools/lib/bpf/libbpf_legacy.h +11 -1
@@ -45,7 +45,6 @@ enum libbpf_strict_mode {* (positive) error code. */ LIBBPF_STRICT_DIRECT_ERRS = 0x02, -/* * Enforce strict BPF program section (SEC()) names. * E.g., while prefiously SEC("xdp_whatever") or SEC("perf_event_blah") were
@@ -63,6 +62,17 @@ enum libbpf_strict_mode {* Clients can maintain it on their own if it is valuable for them. */ LIBBPF_STRICT_NO_OBJECT_LIST =0x08 , +/* +* Automatically bump RLIMIT_MEMLOCK using setrlimit() before the +* first BPF program/map/link creation operation. This is done only if +* kernel is too old to support memcg-based memory accounting for BPF +* subsystem. By default, RLIMI_MEMLOCK limit is set to RLIM_INFINITY, +* but it can be overriden with libbpf_set_memlock_rlim_max() API. +* Note that libbpf_set_memlock_rlim_max() needs to be called before +* the very first bpf_prog_load()/bpf_map_create()/bpf_link_create() +* or bpf_object__load() operation. +*/ +LIBBPF_STRICT_AUTO_RLIMIT_MEMLOCK =0x10 , __LIBBPF_STRICT_LAST, };
Signature · 1 line
2.30.2
Andrii Nakryiko
maintainerPATCH 2/2 selftests/bpf: remove explicit setrlimi(RLIMI_MEMLOCK) in main selftests
As libbpf now is able to automatically take care of RLIMIT_MEMLOCK increase (or skip it altogether on recent enough kernels), remove explicit setrlimit() invocations in bench, test_maps, test_verifier, and test_progs.
--- tools/testing/selftests/bpf/bench.c | 16 ---------------- tools/testing/selftests/bpf/prog_tests/btf.c | 1 - .../selftests/bpf/prog_tests/select_reuseport.c | 1 - .../testing/selftests/bpf/prog_tests/sk_lookup.c | 1 - .../selftests/bpf/prog_tests/sock_fields.c | 1 - tools/testing/selftests/bpf/test_maps.c | 1 - tools/testing/selftests/bpf/test_progs.c | 2 -- tools/testing/selftests/bpf/test_verifier.c | 4 +++- 8 files changed, 3 insertions(+), 24 deletions(-)
tools/testing/selftests/bpf/bench.c +0 -16
@@ -29,26 +29,10 @@ static int libbpf_print_fn(enum libbpf_print_level level,return vfprintf (stderr, format, args); } -static int bump_memlock_rlimit (void ) -{ -struct rlimit rlim_new = { - .rlim_cur =RLIM_INFINITY , - .rlim_max =RLIM_INFINITY , - }; - -return setrlimit (RLIMIT_MEMLOCK , &rlim_new); -} -void setup_libbpf () { -int err; -libbpf_set_strict_mode (LIBBPF_STRICT_ALL );libbpf_set_print (libbpf_print_fn); - - err =bump_memlock_rlimit (); -if (err) -fprintf (stderr,"failed to increase RLIMIT_MEMLOCK: %d" , err); }void false_hits_report_progress (int iter,struct bench_res *res,long delta_ns)
tools/testing/selftests/bpf/prog_tests/btf.c +0 -1
@@ -22,7 +22,6 @@#include <bpf/libbpf.h> #include <bpf/btf.h> -#include "bpf_rlimit.h" #include "bpf_util.h" #include "../test_btf.h" #include "test_progs.h"
tools/testing/selftests/bpf/prog_tests/select_reuseport.c +0 -1
@@ -18,7 +18,6 @@#include <netinet/in.h> #include <bpf/bpf.h> #include <bpf/libbpf.h> -#include "bpf_rlimit.h" #include "bpf_util.h" #include "test_progs.h"
tools/testing/selftests/bpf/prog_tests/sk_lookup.c +0 -1
@@ -30,7 +30,6 @@#include <bpf/bpf.h> #include "test_progs.h" -#include "bpf_rlimit.h" #include "bpf_util.h" #include "cgroup_helpers.h" #include "network_helpers.h"
tools/testing/selftests/bpf/prog_tests/sock_fields.c +0 -1
@@ -15,7 +15,6 @@#include "network_helpers.h" #include "cgroup_helpers.h" #include "test_progs.h" -#include "bpf_rlimit.h" #include "test_sock_fields.skel.h" enum bpf_linum_array_idx {
tools/testing/selftests/bpf/test_maps.c +0 -1
@@ -23,7 +23,6 @@#include <bpf/libbpf.h> #include "bpf_util.h" -#include "bpf_rlimit.h" #include "test_maps.h" #include "testing_helpers.h"
tools/testing/selftests/bpf/test_progs.c +0 -2
@@ -4,7 +4,6 @@#define _GNU_SOURCE#include "test_progs.h" #include "cgroup_helpers.h" -#include "bpf_rlimit.h" #include <argp.h> #include <pthread.h> #include <sched.h>
@@ -1342,7 +1341,6 @@ int main(int argc, char **argv)/* Use libbpf 1.0 API mode */ libbpf_set_strict_mode (LIBBPF_STRICT_ALL ); -libbpf_set_print (libbpf_print_fn);srand (time (NULL ));
tools/testing/selftests/bpf/test_verifier.c +3 -1
@@ -41,7 +41,6 @@# define CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS 1# endif #endif -#include "bpf_rlimit.h" #include "bpf_rand.h" #include "bpf_util.h" #include "test_btf.h"
@@ -1355,6 +1354,9 @@ int main(int argc, char **argv)return EXIT_FAILURE ; } +/* Use libbpf 1.0 API mode */ +libbpf_set_strict_mode (LIBBPF_STRICT_ALL ); +bpf_semi_rand_init ();return do_test (unpriv, from, to); }
Signature · 1 line
2.30.2
Quoted 114 lines · Andrii Nakryiko
The need to increase
RLIMIT_MEMLOCKto do anything useful with BPF is one of the first extremely frustrating gotchas that all new BPF users go through and in some cases have to learn it a very hard way.Luckily, starting with upstream Linux kernel version 5.11, BPF subsystem dropped the dependency on memlock and uses memcg-based memory accounting instead. Unfortunately, detecting memcg-based BPF memory accounting is far from trivial (as can be evidenced by this patch), so in practice most BPF applications still do unconditional
RLIMIT_MEMLOCKincrease.As we move towards libbpf 1.0, it would be good to allow users to forget about
RLIMIT_MEMLOCKvs memcg and let libbpf do the sensible adjustment automatically. This patch paves the way forward in this matter. Libbpf will do feature detection of memcg-based accounting, and if detected, will do nothing. But if the kernel is too old, just like BCC, libbpf will automatically increaseRLIMIT_MEMLOCKon behalf of user application ([0]).As this is technically a breaking change, during the transition period applications have to opt into libbpf 1.0 mode by setting
LIBBPF_STRICT_AUTO_RLIMIT_MEMLOCKbit when callinglibbpf_set_strict_mode().Libbpf allows to control the exact amount of set
RLIMIT_MEMLOCKlimit withlibbpf_set_memlock_rlim_max()API. Passing 0 will make libbpf do nothing withRLIMIT_MEMLOCK.libbpf_set_memlock_rlim_max()has to be called before the firstbpf_prog_load(),bpf_btf_load(), orbpf_object__load()call, otherwise it has no effect and will return-EBUSY.[0] Closes: https://github.com/libbpf/libbpf/issues/369
Signed-off-by Andrii Nakryiko <[email protected]>--- tools/lib/bpf/bpf.c | 122 ++++++++++++++++++++++++++++++++ tools/lib/bpf/bpf.h | 2 + tools/lib/bpf/libbpf.c | 47 +++--------- tools/lib/bpf/libbpf.map | 1 + tools/lib/bpf/libbpf_internal.h | 39 ++++++++++ tools/lib/bpf/libbpf_legacy.h | 12 +++- 6 files changed, 184 insertions(+), 39 deletions(-)tools/lib/bpf/bpf.c +57
-0@@ -29,6 +29,7 @@#include <errno.h> #include <linux/bpf.h> #include <limits.h> +#include <sys/resource.h> #include "bpf.h" #include "libbpf.h" #include "libbpf_internal.h" @@ -94,6 +95,119 @@ static inline int sys_bpf_prog_load(union bpf_attr *attr, unsigned int size, intreturn fd; } +/* Probe whether kernel switched from memlock-based (RLIMIT_MEMLOCK) to +* memcg-based memory accounting for BPF maps and progs. This was done in [0], +* but it's not straightforward to detect those changes from the user-space. +* So instead we'll try to detect whether [1] is in the kernel, which follows +* [0] almost immediately and made it into the upstream kernel in the same +* release. +* +* For this, we'll upload a trivial BTF into the kernel and will try to load +* a trivial BPF program with attach_btf_obj_fd pointing to our BTF. If it +* returns anything but -EOPNOTSUPP, we'll assume we still need +* RLIMIT_MEMLOCK. +* +* [0] https://lore.kernel.org/bpf/[email protected]/ +* [1] Fixes: 8bdd8e275ede ("bpf: Return -ENOTSUPP when attaching to non-kernel BTF") +*/ +int probe_memcg_account (void ) +{ + const size_t bpf_load_attr_sz = offsetofend(union bpf_attr, attach_btf_obj_fd); + const size_t btf_load_attr_sz = offsetofend(union bpf_attr, btf_log_level); +int prog_fd =-1 , btf_fd =-1 , err; +struct bpf_insn insns[1 ] = {};/* instructions don't matter */ +const void *btf_data; +union bpf_attr attr; +__u32 btf_data_sz; +struct btf *btf; + +/* create the simplest BTF object and upload it into the kernel */ + btf =btf__new_empty (); + err =libbpf_get_error (btf); +if (err) +return err; + err =btf__add_int (btf,"int" ,4 ,0 ); + btf_data =btf__raw_data (btf, &btf_data_sz); +if (!btf_data) { + err = -ENOMEM ; + goto cleanup; + } + +/* we won't use bpf_btf_load() or bpf_prog_load() because they will +* be trying to detect this feature and will cause an infinite loop +*/ +memset (&attr,0 , btf_load_attr_sz); + attr.btf =ptr_to_u64 (btf_data); + attr.btf_size = btf_data_sz; + btf_fd =sys_bpf_fd (BPF_BTF_LOAD , &attr, btf_load_attr_sz); +if (btf_fd <0 ) { + err = -errno; + goto cleanup; + } + +/* attempt loading freplace trying to use custom BTF */ +memset (&attr,0 , bpf_load_attr_sz); + attr.prog_type =BPF_PROG_TYPE_TRACING ; + attr.expected_attach_type =BPF_TRACE_FENTRY ; + attr.insns =ptr_to_u64 (insns); + attr.insn_cnt =sizeof (insns) /sizeof (insns[0 ]);
tools/lib/bpf/bpf.c static inline int sys_bpf_prog_load(union bpf_attr *attr, unsigned int size, int · line 163
Quoted 10 lines
tools/lib/bpf/bpf.c +10
-0+ attr.license =ptr_to_u64 ("GPL" ); + attr.attach_btf_obj_fd = btf_fd; + + prog_fd =sys_bpf_fd (BPF_PROG_LOAD , &attr, bpf_load_attr_sz); +if (prog_fd >=0 ) +/* bug? we shouldn't be able to successfully load program */ + err = -EFAULT ; +else +/* assume memcg accounting is supported if we get -EOPNOTSUPP */ + err = errno ==524 /* ENOTSUPP */ ?1 :0 ;
Nit: comment and code seems to be in disagreement over the name of the error code here.
(side note, since we've ended up using ENOTSUPP everywhere in BPF, any reason we can't export it in a UAPI header somewhere?)
-Toke
Quoted 122 lines · Toke Høiland-Jørgensen
Quoted 119 lines · Andrii Nakryiko
The need to increase
RLIMIT_MEMLOCKto do anything useful with BPF is one of the first extremely frustrating gotchas that all new BPF users go through and in some cases have to learn it a very hard way.Luckily, starting with upstream Linux kernel version 5.11, BPF subsystem dropped the dependency on memlock and uses memcg-based memory accounting instead. Unfortunately, detecting memcg-based BPF memory accounting is far from trivial (as can be evidenced by this patch), so in practice most BPF applications still do unconditional
RLIMIT_MEMLOCKincrease.As we move towards libbpf 1.0, it would be good to allow users to forget about
RLIMIT_MEMLOCKvs memcg and let libbpf do the sensible adjustment automatically. This patch paves the way forward in this matter. Libbpf will do feature detection of memcg-based accounting, and if detected, will do nothing. But if the kernel is too old, just like BCC, libbpf will automatically increaseRLIMIT_MEMLOCKon behalf of user application ([0]).As this is technically a breaking change, during the transition period applications have to opt into libbpf 1.0 mode by setting
LIBBPF_STRICT_AUTO_RLIMIT_MEMLOCKbit when callinglibbpf_set_strict_mode().Libbpf allows to control the exact amount of set
RLIMIT_MEMLOCKlimit withlibbpf_set_memlock_rlim_max()API. Passing 0 will make libbpf do nothing withRLIMIT_MEMLOCK.libbpf_set_memlock_rlim_max()has to be called before the firstbpf_prog_load(),bpf_btf_load(), orbpf_object__load()call, otherwise it has no effect and will return-EBUSY.[0] Closes: https://github.com/libbpf/libbpf/issues/369
Signed-off-by Andrii Nakryiko <[email protected]>--- tools/lib/bpf/bpf.c | 122 ++++++++++++++++++++++++++++++++ tools/lib/bpf/bpf.h | 2 + tools/lib/bpf/libbpf.c | 47 +++--------- tools/lib/bpf/libbpf.map | 1 + tools/lib/bpf/libbpf_internal.h | 39 ++++++++++ tools/lib/bpf/libbpf_legacy.h | 12 +++- 6 files changed, 184 insertions(+), 39 deletions(-)tools/lib/bpf/bpf.c +62
-0@@ -29,6 +29,7 @@#include <errno.h> #include <linux/bpf.h> #include <limits.h> +#include <sys/resource.h> #include "bpf.h" #include "libbpf.h" #include "libbpf_internal.h" @@ -94,6 +95,119 @@ static inline int sys_bpf_prog_load(union bpf_attr *attr, unsigned int size, intreturn fd; } +/* Probe whether kernel switched from memlock-based (RLIMIT_MEMLOCK) to +* memcg-based memory accounting for BPF maps and progs. This was done in [0], +* but it's not straightforward to detect those changes from the user-space. +* So instead we'll try to detect whether [1] is in the kernel, which follows +* [0] almost immediately and made it into the upstream kernel in the same +* release. +* +* For this, we'll upload a trivial BTF into the kernel and will try to load +* a trivial BPF program with attach_btf_obj_fd pointing to our BTF. If it +* returns anything but -EOPNOTSUPP, we'll assume we still need +* RLIMIT_MEMLOCK. +* +* [0] https://lore.kernel.org/bpf/[email protected]/ +* [1] Fixes: 8bdd8e275ede ("bpf: Return -ENOTSUPP when attaching to non-kernel BTF") +*/ +int probe_memcg_account (void ) +{ + const size_t bpf_load_attr_sz = offsetofend(union bpf_attr, attach_btf_obj_fd); + const size_t btf_load_attr_sz = offsetofend(union bpf_attr, btf_log_level); +int prog_fd =-1 , btf_fd =-1 , err; +struct bpf_insn insns[1 ] = {};/* instructions don't matter */ +const void *btf_data; +union bpf_attr attr; +__u32 btf_data_sz; +struct btf *btf; + +/* create the simplest BTF object and upload it into the kernel */ + btf =btf__new_empty (); + err =libbpf_get_error (btf); +if (err) +return err; + err =btf__add_int (btf,"int" ,4 ,0 ); + btf_data =btf__raw_data (btf, &btf_data_sz); +if (!btf_data) { + err = -ENOMEM ; + goto cleanup; + } + +/* we won't use bpf_btf_load() or bpf_prog_load() because they will +* be trying to detect this feature and will cause an infinite loop +*/ +memset (&attr,0 , btf_load_attr_sz); + attr.btf =ptr_to_u64 (btf_data); + attr.btf_size = btf_data_sz; + btf_fd =sys_bpf_fd (BPF_BTF_LOAD , &attr, btf_load_attr_sz); +if (btf_fd <0 ) { + err = -errno; + goto cleanup; + } + +/* attempt loading freplace trying to use custom BTF */ +memset (&attr,0 , bpf_load_attr_sz); + attr.prog_type =BPF_PROG_TYPE_TRACING ; + attr.expected_attach_type =BPF_TRACE_FENTRY ; + attr.insns =ptr_to_u64 (insns); + attr.insn_cnt =sizeof (insns) /sizeof (insns[0 ]); + attr.license =ptr_to_u64 ("GPL" ); + attr.attach_btf_obj_fd = btf_fd; + + prog_fd =sys_bpf_fd (BPF_PROG_LOAD , &attr, bpf_load_attr_sz); +if (prog_fd >=0 )
Quoted 8 lines
tools/lib/bpf/bpf.c static inline int sys_bpf_prog_load(union bpf_attr *attr, unsigned int size, int · line 163
Quoted 5 lines
tools/lib/bpf/bpf.c +5
-0+/* bug? we shouldn't be able to successfully load program */ + err = -EFAULT ; + else +/* assume memcg accounting is supported if we get -EOPNOTSUPP */ + err = errno ==524 /* ENOTSUPP */ ?1 :0 ;Nit: comment and code seems to be in disagreement over the name of the error code here.
One careful reader there :) There is also a comment about bpf_link_create, which I removed because BPF_LINK_CREATE didn't depend on memlock. I'll update both and will send v2, thanks.
Quoted 3 lines
(side note, since we've ended up using ENOTSUPP everywhere in BPF, any reason we can't export it in a UAPI header somewhere?)
No opinion here, tbh, but certainly not part of this change.
Quoted 3 lines
-Toke