libbpf: auto-bump RLIMIT_MEMLOCK on old kernels
Subsystems (4)
Andrii Nakryiko
maintainerv4 cover libbpf: auto-bump RLIMIT_MEMLOCK on old kernels
Make libbpf bump RLIMIT_MEMLOCK, similarly to BCC, if kernel is old enough to use memcg-based memory accounting for BPF. Patch #2 drops explicit setrlimi(RLIMIT_MEMLOCK) calls in test_progs, test_maps, and test_verifier.
v3->v4:
- use detection based on bpf_ktime_get_coarse_ns() helper (Daniel);v2->v3:
- use difference in fdinfo's memlock reporting to detect memcg;v1->v2:
- fix up out-of-sync comments (Toke).
Andrii Nakryiko (2):
libbpf: auto-bump RLIMIT_MEMLOCK if kernel needs it for BPF selftests/bpf: remove explicit setrlimit(RLIMIT_MEMLOCK) in main
selftests
tools/lib/bpf/bpf.c | 81 +++++++++++++++++++ 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 ++- tools/testing/selftests/bpf/bench.c | 16 ---- tools/testing/selftests/bpf/prog_tests/btf.c | 1 - .../bpf/prog_tests/select_reuseport.c | 1 - .../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 +- 14 files changed, 146 insertions(+), 63 deletions(-)
Signature · 1 line
2.30.2
Andrii Nakryiko
maintainerPATCH v4 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 | 81 +++++++++++++++++++++++++++++++++ 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, 143 insertions(+), 39 deletions(-)
tools/lib/bpf/bpf.c +81 -0
@@ -28,7 +28,9 @@#include <asm/unistd.h> #include <errno.h> #include <linux/bpf.h> +#include <linux/filter.h> #include <limits.h> +#include <sys/resource.h> #include "bpf.h" #include "libbpf.h" #include "libbpf_internal.h"
@@ -94,6 +96,77 @@ 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]. +* We use the support for bpf_ktime_get_coarse_ns() helper, which was added in +* the same 5.11 Linux release ([1]), to detect memcg-based accounting for BPF. +* +* [0] https://lore.kernel.org/bpf/[email protected]/ +* [1] d05512618056 ("bpf: Add bpf_ktime_get_coarse_ns helper") +*/ +int probe_memcg_account (void ) +{ + const size_t prog_load_attr_sz = offsetofend(union bpf_attr, attach_btf_obj_fd); +struct bpf_insn insns[] = { +BPF_EMIT_CALL (BPF_FUNC_ktime_get_coarse_ns), +BPF_EXIT_INSN (), + }; +size_t insn_cnt =sizeof (insns) /sizeof (insns[0 ]); +union bpf_attr attr; +int prog_fd; + +/* attempt loading freplace trying to use custom BTF */ +memset (&attr,0 , prog_load_attr_sz); + attr.prog_type =BPF_PROG_TYPE_SOCKET_FILTER ; + attr.insns =ptr_to_u64 (insns); + attr.insn_cnt = insn_cnt; + attr.license =ptr_to_u64 ("GPL" ); + + prog_fd =sys_bpf_fd (BPF_PROG_LOAD , &attr, prog_load_attr_sz); +if (prog_fd >=0 ) { +close (prog_fd); +return 1 ; + } +return 0 ; +} + +static bool memlock_bumped; +static rlim_t memlock_rlim =RLIM_INFINITY ; + +int libbpf_set_memlock_rlim (size_t memlock_bytes) +{ +if (memlock_bumped) +return libbpf_err (-EBUSY ); + + memlock_rlim = memlock_bytes; +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 ==0 ) +return 0 ; + + rlim.rlim_cur = rlim.rlim_max = memlock_rlim; +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 +178,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 +326,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 );
@@ -456,6 +533,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;
@@ -1056,6 +1135,8 @@ int bpf_btf_load(const void *btf_data, size_t btf_size, const struct bpf_btf_loa__u32 log_level;int fd; +bump_rlimit_memlock (); +memset (&attr,0 , attr_sz);if (!OPTS_VALID (opts, bpf_btf_load_opts))
tools/lib/bpf/bpf.h +2 -0
@@ -35,6 +35,8 @@extern "C" {#endif +int libbpf_set_memlock_rlim (size_t memlock_bytes); +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
@@ -427,4 +427,5 @@ LIBBPF_0.7.0 { bpf_program__log_level; bpf_program__set_log_buf; 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 or map creation operation. This is done only if +* kernel is too old to support memcg-based memory accounting for BPF +* subsystem. By default, RLIMIT_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() or bpf_object__load() +* operation. +*/ +LIBBPF_STRICT_AUTO_RLIMIT_MEMLOCK =0x10 , __LIBBPF_STRICT_LAST, };
Signature · 1 line
2.30.2
Andrii Nakryiko
maintainerPATCH v4 2/2 selftests/bpf: remove explicit setrlimit(RLIMIT_MEMLOCK) in main selftests
In reply to Andrii NakryikoAs 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 (void ) { -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"
@@ -1395,6 +1394,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
This series was applied to bpf/bpf-next.git (master) by Daniel Borkmann <[email protected]>:
Hello:
This series was applied to bpf/bpf-next.git (master) by Daniel Borkmann <[email protected]>:
Quoted 4 lines · On Tue, 14 Dec 2021 11:59:02 -0800 you wrote:
Make libbpf bump
RLIMIT_MEMLOCK, similarly to BCC, if kernel is old enough to use memcg-based memory accounting for BPF. Patch #2 drops explicitsetrlimi(RLIMIT_MEMLOCK)calls intest_progs,test_maps, andtest_verifier.
Quoted 8 lines
v3->v4:
- use detection based onbpf_ktime_get_coarse_ns()helper (Daniel);v2->v3:
- use difference in fdinfo's memlock reporting to detect memcg;v1->v2:
- fix up out-of-sync comments (Toke).[...]
Here is the summary with links:
- [v4,bpf-next,1/2] libbpf: auto-bump RLIMIT_MEMLOCK if kernel needs it for BPF
https://git.kernel.org/bpf/bpf-next/c/e542f2c4cd16 - [v4,bpf-next,2/2] selftests/bpf: remove explicit setrlimit(RLIMIT_MEMLOCK) in main selftests https://git.kernel.org/bpf/bpf-next/c/c164b8b40422
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html