| Message ID | 20240311093526.1010158-8-dongmenglong.8@bytedance.com (mailing list archive) |
|---|---|
| State | New |
| Headers | show |
| Series | bpf: make tracing program support multi-link | expand |
On Mon, Mar 11, 2024 at 2:35 AM Menglong Dong <dongmenglong.8@bytedance.com> wrote: > > By default, the kernel btf that we load during loading program will be > freed after the programs are loaded in bpf_object_load(). However, we > still need to use these btf for tracing of multi-link during attaching. > Therefore, we don't free the btfs until the bpf object is closed if any > bpf programs of the type multi-link tracing exist. > > Meanwhile, introduce the new api bpf_object__free_btf() to manually free > the btfs after attaching. > > Signed-off-by: Menglong Dong <dongmenglong.8@bytedance.com> > --- > tools/lib/bpf/libbpf.c | 47 ++++++++++++++++++++++++++++++---------- > tools/lib/bpf/libbpf.h | 2 ++ > tools/lib/bpf/libbpf.map | 1 + > 3 files changed, 38 insertions(+), 12 deletions(-) > > diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c > index 567ad367e7aa..fd5428494a7e 100644 > --- a/tools/lib/bpf/libbpf.c > +++ b/tools/lib/bpf/libbpf.c > @@ -8267,6 +8267,39 @@ static int bpf_object_prepare_struct_ops(struct bpf_object *obj) > return 0; > } > > +void bpf_object__free_btfs(struct bpf_object *obj) > +{ > + int i; > + > + /* clean up module BTFs */ > + for (i = 0; i < obj->btf_module_cnt; i++) { > + close(obj->btf_modules[i].fd); > + btf__free(obj->btf_modules[i].btf); > + free(obj->btf_modules[i].name); > + } > + free(obj->btf_modules); > + obj->btf_modules = NULL; > + obj->btf_module_cnt = 0; > + > + /* clean up vmlinux BTF */ > + btf__free(obj->btf_vmlinux); > + obj->btf_vmlinux = NULL; > +} > + > +static void bpf_object_early_free_btf(struct bpf_object *obj) > +{ > + struct bpf_program *prog; > + > + bpf_object__for_each_program(prog, obj) { > + if (prog->expected_attach_type == BPF_TRACE_FENTRY_MULTI || > + prog->expected_attach_type == BPF_TRACE_FEXIT_MULTI || > + prog->expected_attach_type == BPF_MODIFY_RETURN_MULTI) > + return; > + } > + > + bpf_object__free_btfs(obj); > +} > + > static int bpf_object_load(struct bpf_object *obj, int extra_log_level, const char *target_btf_path) > { > int err, i; > @@ -8307,18 +8340,7 @@ static int bpf_object_load(struct bpf_object *obj, int extra_log_level, const ch > /* clean up fd_array */ > zfree(&obj->fd_array); > > - /* clean up module BTFs */ > - for (i = 0; i < obj->btf_module_cnt; i++) { > - close(obj->btf_modules[i].fd); > - btf__free(obj->btf_modules[i].btf); > - free(obj->btf_modules[i].name); > - } > - free(obj->btf_modules); > - > - /* clean up vmlinux BTF */ > - btf__free(obj->btf_vmlinux); > - obj->btf_vmlinux = NULL; > - > + bpf_object_early_free_btf(obj); > obj->loaded = true; /* doesn't matter if successfully or not */ > > if (err) > @@ -8791,6 +8813,7 @@ void bpf_object__close(struct bpf_object *obj) > usdt_manager_free(obj->usdt_man); > obj->usdt_man = NULL; > > + bpf_object__free_btfs(obj); > bpf_gen__free(obj->gen_loader); > bpf_object__elf_finish(obj); > bpf_object_unload(obj); > diff --git a/tools/lib/bpf/libbpf.h b/tools/lib/bpf/libbpf.h > index 5723cbbfcc41..c41a909ea4c1 100644 > --- a/tools/lib/bpf/libbpf.h > +++ b/tools/lib/bpf/libbpf.h > @@ -299,6 +299,8 @@ LIBBPF_API struct bpf_program * > bpf_object__find_program_by_name(const struct bpf_object *obj, > const char *name); > > +LIBBPF_API void bpf_object__free_btfs(struct bpf_object *obj); > + It shouldn't be exported. libbpf should clean it up when bpf_object is freed.
On Tue, Mar 12, 2024 at 9:55 AM Alexei Starovoitov <alexei.starovoitov@gmail.com> wrote: > > On Mon, Mar 11, 2024 at 2:35 AM Menglong Dong > <dongmenglong.8@bytedance.com> wrote: > > > > By default, the kernel btf that we load during loading program will be > > freed after the programs are loaded in bpf_object_load(). However, we > > still need to use these btf for tracing of multi-link during attaching. > > Therefore, we don't free the btfs until the bpf object is closed if any > > bpf programs of the type multi-link tracing exist. > > > > Meanwhile, introduce the new api bpf_object__free_btf() to manually free > > the btfs after attaching. > > > > Signed-off-by: Menglong Dong <dongmenglong.8@bytedance.com> > > --- > > tools/lib/bpf/libbpf.c | 47 ++++++++++++++++++++++++++++++---------- > > tools/lib/bpf/libbpf.h | 2 ++ > > tools/lib/bpf/libbpf.map | 1 + > > 3 files changed, 38 insertions(+), 12 deletions(-) > > > > diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c > > index 567ad367e7aa..fd5428494a7e 100644 > > --- a/tools/lib/bpf/libbpf.c > > +++ b/tools/lib/bpf/libbpf.c > > @@ -8267,6 +8267,39 @@ static int bpf_object_prepare_struct_ops(struct bpf_object *obj) > > return 0; > > } > > > > +void bpf_object__free_btfs(struct bpf_object *obj) > > +{ > > + int i; > > + > > + /* clean up module BTFs */ > > + for (i = 0; i < obj->btf_module_cnt; i++) { > > + close(obj->btf_modules[i].fd); > > + btf__free(obj->btf_modules[i].btf); > > + free(obj->btf_modules[i].name); > > + } > > + free(obj->btf_modules); > > + obj->btf_modules = NULL; > > + obj->btf_module_cnt = 0; > > + > > + /* clean up vmlinux BTF */ > > + btf__free(obj->btf_vmlinux); > > + obj->btf_vmlinux = NULL; > > +} > > + > > +static void bpf_object_early_free_btf(struct bpf_object *obj) > > +{ > > + struct bpf_program *prog; > > + > > + bpf_object__for_each_program(prog, obj) { > > + if (prog->expected_attach_type == BPF_TRACE_FENTRY_MULTI || > > + prog->expected_attach_type == BPF_TRACE_FEXIT_MULTI || > > + prog->expected_attach_type == BPF_MODIFY_RETURN_MULTI) > > + return; > > + } > > + > > + bpf_object__free_btfs(obj); > > +} > > + > > static int bpf_object_load(struct bpf_object *obj, int extra_log_level, const char *target_btf_path) > > { > > int err, i; > > @@ -8307,18 +8340,7 @@ static int bpf_object_load(struct bpf_object *obj, int extra_log_level, const ch > > /* clean up fd_array */ > > zfree(&obj->fd_array); > > > > - /* clean up module BTFs */ > > - for (i = 0; i < obj->btf_module_cnt; i++) { > > - close(obj->btf_modules[i].fd); > > - btf__free(obj->btf_modules[i].btf); > > - free(obj->btf_modules[i].name); > > - } > > - free(obj->btf_modules); > > - > > - /* clean up vmlinux BTF */ > > - btf__free(obj->btf_vmlinux); > > - obj->btf_vmlinux = NULL; > > - > > + bpf_object_early_free_btf(obj); > > obj->loaded = true; /* doesn't matter if successfully or not */ > > > > if (err) > > @@ -8791,6 +8813,7 @@ void bpf_object__close(struct bpf_object *obj) > > usdt_manager_free(obj->usdt_man); > > obj->usdt_man = NULL; > > > > + bpf_object__free_btfs(obj); > > bpf_gen__free(obj->gen_loader); > > bpf_object__elf_finish(obj); > > bpf_object_unload(obj); > > diff --git a/tools/lib/bpf/libbpf.h b/tools/lib/bpf/libbpf.h > > index 5723cbbfcc41..c41a909ea4c1 100644 > > --- a/tools/lib/bpf/libbpf.h > > +++ b/tools/lib/bpf/libbpf.h > > @@ -299,6 +299,8 @@ LIBBPF_API struct bpf_program * > > bpf_object__find_program_by_name(const struct bpf_object *obj, > > const char *name); > > > > +LIBBPF_API void bpf_object__free_btfs(struct bpf_object *obj); > > + > > It shouldn't be exported. > libbpf should clean it up when bpf_object is freed. Yes, libbpf will clean up the btfs when bpf_object is freed in this commit. And I'm trying to offer a way to early free the btfs by the users manual to reduce the memory usage. Or, the btfs that we opened will keep existing until we close the bpf_object. This is optional, I can remove it if you prefer. Thanks! Menglong Dong
On Mon, Mar 11, 2024 at 7:05 PM 梦龙董 <dongmenglong.8@bytedance.com> wrote: > > > > > > > +LIBBPF_API void bpf_object__free_btfs(struct bpf_object *obj); > > > + > > > > It shouldn't be exported. > > libbpf should clean it up when bpf_object is freed. > > Yes, libbpf will clean up the btfs when bpf_object is freed in > this commit. And I'm trying to offer a way to early free the btfs > by the users manual to reduce the memory usage. Or, the > btfs that we opened will keep existing until we close the > bpf_object. > > This is optional, I can remove it if you prefer. Let's not extend libbpf api unless we really need to. bpf_program__attach_trace_multi_opts() and *skel*__attach() can probably free them. I don't see a use case where you'd want to keep them afterwards.
On Tue, Mar 12, 2024 at 10:13 AM Alexei Starovoitov <alexei.starovoitov@gmail.com> wrote: > > On Mon, Mar 11, 2024 at 7:05 PM 梦龙董 <dongmenglong.8@bytedance.com> wrote: > > > > > > > > > > +LIBBPF_API void bpf_object__free_btfs(struct bpf_object *obj); > > > > + > > > > > > It shouldn't be exported. > > > libbpf should clean it up when bpf_object is freed. > > > > Yes, libbpf will clean up the btfs when bpf_object is freed in > > this commit. And I'm trying to offer a way to early free the btfs > > by the users manual to reduce the memory usage. Or, the > > btfs that we opened will keep existing until we close the > > bpf_object. > > > > This is optional, I can remove it if you prefer. > > Let's not extend libbpf api unless we really need to. > bpf_program__attach_trace_multi_opts() and > *skel*__attach() can probably free them. That's a good idea! Should we add a "bool free_btf" field to struct bpf_trace_multi_opts? bpf_program__attach_trace_multi_opts() can be called multi times for a bpf_object, which has multi bpf program of type tracing multi-link. Or, can we free the btfs automatically if we found all tracing multi-link programs are attached? Thanks! Menglong Dong > I don't see a use case where you'd want to keep them afterwards.
diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c index 567ad367e7aa..fd5428494a7e 100644 --- a/tools/lib/bpf/libbpf.c +++ b/tools/lib/bpf/libbpf.c @@ -8267,6 +8267,39 @@ static int bpf_object_prepare_struct_ops(struct bpf_object *obj) return 0; } +void bpf_object__free_btfs(struct bpf_object *obj) +{ + int i; + + /* clean up module BTFs */ + for (i = 0; i < obj->btf_module_cnt; i++) { + close(obj->btf_modules[i].fd); + btf__free(obj->btf_modules[i].btf); + free(obj->btf_modules[i].name); + } + free(obj->btf_modules); + obj->btf_modules = NULL; + obj->btf_module_cnt = 0; + + /* clean up vmlinux BTF */ + btf__free(obj->btf_vmlinux); + obj->btf_vmlinux = NULL; +} + +static void bpf_object_early_free_btf(struct bpf_object *obj) +{ + struct bpf_program *prog; + + bpf_object__for_each_program(prog, obj) { + if (prog->expected_attach_type == BPF_TRACE_FENTRY_MULTI || + prog->expected_attach_type == BPF_TRACE_FEXIT_MULTI || + prog->expected_attach_type == BPF_MODIFY_RETURN_MULTI) + return; + } + + bpf_object__free_btfs(obj); +} + static int bpf_object_load(struct bpf_object *obj, int extra_log_level, const char *target_btf_path) { int err, i; @@ -8307,18 +8340,7 @@ static int bpf_object_load(struct bpf_object *obj, int extra_log_level, const ch /* clean up fd_array */ zfree(&obj->fd_array); - /* clean up module BTFs */ - for (i = 0; i < obj->btf_module_cnt; i++) { - close(obj->btf_modules[i].fd); - btf__free(obj->btf_modules[i].btf); - free(obj->btf_modules[i].name); - } - free(obj->btf_modules); - - /* clean up vmlinux BTF */ - btf__free(obj->btf_vmlinux); - obj->btf_vmlinux = NULL; - + bpf_object_early_free_btf(obj); obj->loaded = true; /* doesn't matter if successfully or not */ if (err) @@ -8791,6 +8813,7 @@ void bpf_object__close(struct bpf_object *obj) usdt_manager_free(obj->usdt_man); obj->usdt_man = NULL; + bpf_object__free_btfs(obj); bpf_gen__free(obj->gen_loader); bpf_object__elf_finish(obj); bpf_object_unload(obj); diff --git a/tools/lib/bpf/libbpf.h b/tools/lib/bpf/libbpf.h index 5723cbbfcc41..c41a909ea4c1 100644 --- a/tools/lib/bpf/libbpf.h +++ b/tools/lib/bpf/libbpf.h @@ -299,6 +299,8 @@ LIBBPF_API struct bpf_program * bpf_object__find_program_by_name(const struct bpf_object *obj, const char *name); +LIBBPF_API void bpf_object__free_btfs(struct bpf_object *obj); + LIBBPF_API int libbpf_prog_type_by_name(const char *name, enum bpf_prog_type *prog_type, enum bpf_attach_type *expected_attach_type); diff --git a/tools/lib/bpf/libbpf.map b/tools/lib/bpf/libbpf.map index 86804fd90dd1..57642b78917f 100644 --- a/tools/lib/bpf/libbpf.map +++ b/tools/lib/bpf/libbpf.map @@ -413,4 +413,5 @@ LIBBPF_1.4.0 { bpf_token_create; btf__new_split; btf_ext__raw_data; + bpf_object__free_btfs; } LIBBPF_1.3.0;
By default, the kernel btf that we load during loading program will be freed after the programs are loaded in bpf_object_load(). However, we still need to use these btf for tracing of multi-link during attaching. Therefore, we don't free the btfs until the bpf object is closed if any bpf programs of the type multi-link tracing exist. Meanwhile, introduce the new api bpf_object__free_btf() to manually free the btfs after attaching. Signed-off-by: Menglong Dong <dongmenglong.8@bytedance.com> --- tools/lib/bpf/libbpf.c | 47 ++++++++++++++++++++++++++++++---------- tools/lib/bpf/libbpf.h | 2 ++ tools/lib/bpf/libbpf.map | 1 + 3 files changed, 38 insertions(+), 12 deletions(-)