bpftool: Add struct_ops support
Subsystems (4)
v3 cover bpftool: Add struct_ops support
This set adds "struct_ops" support to bpftool.
The first two patches improve the btf_dumper in bpftool. Patch 1: print the enum's name (if it is found) instead of the
enum's value.
Patch 2: print a char[] as a string if all characters are printable.
"struct_ops" stores the prog_id in a func ptr.
Instead of printing a prog_id,
patch 3 adds an option to btf_dumper to allow a func ptr's value to be printed with the full func_proto info and the prog_name.
Patch 4 implements the "struct_ops" bpftool command.
v3:
- Check for "case 1:" in patch 1 (Andrii)
v2:
- Typo fixes in comment and doc in patch 4 (Quentin)
- Link to a few other man pages in doc in patch 4 (Quentin)
- Alphabet ordering in include files in patch 4 (Quentin)
- Use GET_ARG() in patch 4 (Quentin)
Martin KaFai Lau (4):
bpftool: Print the enum's name instead of value
bpftool: Print as a string for char array
bpftool: Translate prog_id to its bpf prog_name
bpftool: Add struct_ops support
.../Documentation/bpftool-struct_ops.rst | 116 ++++ tools/bpf/bpftool/bash-completion/bpftool | 28 + tools/bpf/bpftool/btf_dumper.c | 198 +++++- tools/bpf/bpftool/main.c | 3 +- tools/bpf/bpftool/main.h | 2 + tools/bpf/bpftool/struct_ops.c | 596 ++++++++++++++++++ 6 files changed, 927 insertions(+), 16 deletions(-) create mode 100644 tools/bpf/bpftool/Documentation/bpftool-struct_ops.rst create mode 100644 tools/bpf/bpftool/struct_ops.c
Signature · 1 line
2.17.1
PATCH v3 1/4 bpftool: Print the enum's name instead of value
This patch prints the enum's name if there is one found in the array of btf_enum.
The commit 9eea98497951 ("bpf: fix BTF verification of enums") has details about an enum could have any power-of-2 size (up to 8 bytes). This patch also takes this chance to accommodate these non 4 byte enums.
--- tools/bpf/bpftool/btf_dumper.c | 39 +++++++++++++++++++++++++++++++--- 1 file changed, 36 insertions(+), 3 deletions(-)
tools/bpf/bpftool/btf_dumper.c +36 -3
@@ -43,9 +43,42 @@ static int btf_dumper_modifier(const struct btf_dumper *d, __u32 type_id,return btf_dumper_do_type (d, actual_type_id, bit_offset, data); } -static void btf_dumper_enum (const void *data,json_writer_t *jw) +static void btf_dumper_enum (const struct btf_dumper *d, +const struct btf_type *t, +const void *data) { -jsonw_printf (jw,"%d" , *(int *)data); +const struct btf_enum *enums =btf_enum (t); +__s64 value; +__u16 i; + +switch (t->size) { +case 8 : + value = *(__s64 *)data; +break ; +case 4 : + value = *(__s32 *)data; +break ; +case 2 : + value = *(__s16 *)data; +break ; +case 1 : + value = *(__s8 *)data; +break ; +default : +jsonw_string (d->jw,"<invalid_enum_size>" ); +return ; + } + +for (i =0 ; i <btf_vlen (t); i++) { +if (value == enums[i].val) { +jsonw_string (d->jw, +btf__name_by_offset (d->btf, + enums[i].name_off)); +return ; + } + } + +jsonw_int (d->jw, value); } static int btf_dumper_array(const struct btf_dumper *d, __u32 type_id,
@@ -366,7 +399,7 @@ static int btf_dumper_do_type(const struct btf_dumper *d, __u32 type_id,case BTF_KIND_ARRAY :return btf_dumper_array (d, type_id, data);case BTF_KIND_ENUM : -btf_dumper_enum (data, d->jw); +btf_dumper_enum (d, t, data);return 0 ;case BTF_KIND_PTR :btf_dumper_ptr (data, d->jw, d->is_plain_text);
Signature · 1 line
2.17.1
Re: [PATCH v3 bpf-next 1/4] bpftool: Print the enum's name instead of value
Quoted 38 lines · Martin KaFai Lau
This patch prints the enum's name if there is one found in the array of
btf_enum.The commit
9eea98497951("bpf: fix BTF verification of enums") has details about an enum could have any power-of-2 size (up to 8 bytes). This patch also takes this chance to accommodate these non 4 byte enums.Acked-by Quentin Monnet <[email protected]>Signed-off-by Martin KaFai Lau <[email protected]>--- tools/bpf/bpftool/btf_dumper.c | 39 +++++++++++++++++++++++++++++++--- 1 file changed, 36 insertions(+), 3 deletions(-)tools/bpf/bpftool/btf_dumper.c +12
-2@@ -43,9 +43,42 @@ static int btf_dumper_modifier(const struct btf_dumper *d, __u32 type_id,return btf_dumper_do_type (d, actual_type_id, bit_offset, data); } -static void btf_dumper_enum (const void *data,json_writer_t *jw) +static void btf_dumper_enum (const struct btf_dumper *d, +const struct btf_type *t, +const void *data) { -jsonw_printf (jw,"%d" , *(int *)data); +const struct btf_enum *enums =btf_enum (t); +__s64 value; +__u16 i; + +switch (t->size) { +case 8 : + value = *(__s64 *)data; +break ; +case 4 :
tools/bpf/bpftool/btf_dumper.c static int btf_dumper_modifier(const struct btf_dumper *d, __u32 type_id, · line 68
Quoted 10 lines
tools/bpf/bpftool/btf_dumper.c +10
-0+ value = *(__s32 *)data; +break ; +case 2 : + value = *(__s16 *)data; +break ; +case 1 : + value = *(__s8 *)data; +break ; +default : +jsonw_string (d->jw,"<invalid_enum_size>" );
Why not return error and let it propagate, similar to how btf_dumper_array() can return an error? BTF is malformed if this happened, so there is no point in continuing dumping, it's most probably going to be a garbage.
tools/bpf/bpftool/btf_dumper.c static int btf_dumper_modifier(const struct btf_dumper *d, __u32 type_id, · line 76
Quoted 8 lines
tools/bpf/bpftool/btf_dumper.c +8
-0+return ; + } + +for (i =0 ; i <btf_vlen (t); i++) { +if (value == enums[i].val) { +jsonw_string (d->jw, +btf__name_by_offset (d->btf, + enums[i].name_off));
nit: local variable will make it cleaner
Quoted 20 lines
tools/bpf/bpftool/btf_dumper.c +6
-2+return ; + } + } + +jsonw_int (d->jw, value); } static int btf_dumper_array(const struct btf_dumper *d, __u32 type_id,@@ -366,7 +399,7 @@ static int btf_dumper_do_type(const struct btf_dumper *d, __u32 type_id,case BTF_KIND_ARRAY :return btf_dumper_array (d, type_id, data);case BTF_KIND_ENUM : -btf_dumper_enum (data, d->jw); +btf_dumper_enum (d, t, data);return 0 ;case BTF_KIND_PTR :btf_dumper_ptr (data, d->jw, d->is_plain_text); --2.17.1
Re: [PATCH v3 bpf-next 1/4] bpftool: Print the enum's name instead of value
Quoted 46 lines · Andrii Nakryiko
Quoted 45 lines · Martin KaFai Lau
This patch prints the enum's name if there is one found in the array of
btf_enum.The commit
9eea98497951("bpf: fix BTF verification of enums") has details about an enum could have any power-of-2 size (up to 8 bytes). This patch also takes this chance to accommodate these non 4 byte enums.Acked-by Quentin Monnet <[email protected]>Signed-off-by Martin KaFai Lau <[email protected]>--- tools/bpf/bpftool/btf_dumper.c | 39 +++++++++++++++++++++++++++++++--- 1 file changed, 36 insertions(+), 3 deletions(-)tools/bpf/bpftool/btf_dumper.c +19
-2@@ -43,9 +43,42 @@ static int btf_dumper_modifier(const struct btf_dumper *d, __u32 type_id,return btf_dumper_do_type (d, actual_type_id, bit_offset, data); } -static void btf_dumper_enum (const void *data,json_writer_t *jw) +static void btf_dumper_enum (const struct btf_dumper *d, +const struct btf_type *t, +const void *data) { -jsonw_printf (jw,"%d" , *(int *)data); +const struct btf_enum *enums =btf_enum (t); +__s64 value; +__u16 i; + +switch (t->size) { +case 8 : + value = *(__s64 *)data; +break ; +case 4 : + value = *(__s32 *)data; +break ; +case 2 : + value = *(__s16 *)data; +break ; +case 1 : + value = *(__s8 *)data;
Quoted 8 lines
tools/bpf/bpftool/btf_dumper.c static int btf_dumper_modifier(const struct btf_dumper *d, __u32 type_id, · line 68
Quoted 3 lines
tools/bpf/bpftool/btf_dumper.c +3
-0+break ; +default : +jsonw_string (d->jw,"<invalid_enum_size>" );Why not return error and let it propagate, similar to how
btf_dumper_array()can return an error? BTF is malformed if this happened, so there is no point in continuing dumping, it's most probably going to be a garbage.
I can send v4 to return -EINVAL here.
However, the caller of btf_dump*() is pretty loose on checking it. It won't be difficult to find other existing codes that will continue on btf_type's related error cases. I also don't think fixing all these error checking/returning is the right answer here
The proper place to check malformed BTF is in btf__new(). Check it once there like how the kernel does.
[ btw, the data and btf here are obtained from the kernel
which has verified it ].
Quoted 11 lines
tools/bpf/bpftool/btf_dumper.c static int btf_dumper_modifier(const struct btf_dumper *d, __u32 type_id, · line 76
Quoted 9 lines
tools/bpf/bpftool/btf_dumper.c +8
-0+return ; + } + +for (i =0 ; i <btf_vlen (t); i++) { +if (value == enums[i].val) { +jsonw_string (d->jw, +btf__name_by_offset (d->btf, + enums[i].name_off));nit: local variable will make it cleaner
I prefer to keep it as is. There are many other uses like this.
Quoted 21 lines
Quoted 21 lines
tools/bpf/bpftool/btf_dumper.c +6
-2+return ; + } + } + +jsonw_int (d->jw, value); } static int btf_dumper_array(const struct btf_dumper *d, __u32 type_id,@@ -366,7 +399,7 @@ static int btf_dumper_do_type(const struct btf_dumper *d, __u32 type_id,case BTF_KIND_ARRAY :return btf_dumper_array (d, type_id, data);case BTF_KIND_ENUM : -btf_dumper_enum (data, d->jw); +btf_dumper_enum (d, t, data);return 0 ;case BTF_KIND_PTR :btf_dumper_ptr (data, d->jw, d->is_plain_text); --2.17.1
Re: [PATCH v3 bpf-next 1/4] bpftool: Print the enum's name instead of value
Quoted 56 lines · Martin KaFai Lau
Quoted 46 lines · Andrii Nakryiko
Quoted 45 lines · Martin KaFai Lau
This patch prints the enum's name if there is one found in the array of
btf_enum.The commit
9eea98497951("bpf: fix BTF verification of enums") has details about an enum could have any power-of-2 size (up to 8 bytes). This patch also takes this chance to accommodate these non 4 byte enums.Acked-by Quentin Monnet <[email protected]>Signed-off-by Martin KaFai Lau <[email protected]>--- tools/bpf/bpftool/btf_dumper.c | 39 +++++++++++++++++++++++++++++++--- 1 file changed, 36 insertions(+), 3 deletions(-)tools/bpf/bpftool/btf_dumper.c +19
-2@@ -43,9 +43,42 @@ static int btf_dumper_modifier(const struct btf_dumper *d, __u32 type_id,return btf_dumper_do_type (d, actual_type_id, bit_offset, data); } -static void btf_dumper_enum (const void *data,json_writer_t *jw) +static void btf_dumper_enum (const struct btf_dumper *d, +const struct btf_type *t, +const void *data) { -jsonw_printf (jw,"%d" , *(int *)data); +const struct btf_enum *enums =btf_enum (t); +__s64 value; +__u16 i; + +switch (t->size) { +case 8 : + value = *(__s64 *)data; +break ; +case 4 : + value = *(__s32 *)data; +break ; +case 2 : + value = *(__s16 *)data; +break ; +case 1 : + value = *(__s8 *)data;Quoted 8 lines
tools/bpf/bpftool/btf_dumper.c static int btf_dumper_modifier(const struct btf_dumper *d, __u32 type_id, · line 68
Quoted 3 lines
tools/bpf/bpftool/btf_dumper.c +3
-0+break ; +default : +jsonw_string (d->jw,"<invalid_enum_size>" );Why not return error and let it propagate, similar to how
btf_dumper_array()can return an error? BTF is malformed if this happened, so there is no point in continuing dumping, it's most probably going to be a garbage.
Quoted 7 lines
I can send v4 to return
-EINVALhere.However, the caller of btf_dump*() is pretty loose on checking it. It won't be difficult to find other existing codes that will continue on btf_type's related error cases. I also don't think fixing all these error checking/returning is the right answer here
Disagree about fixing error checking in general, but I don't insist either.
Quoted 2 lines
The proper place to check malformed BTF is in
btf__new().
I agree.
Quoted 14 lines
Check it once there like how the kernel does.
[ btw, the data and btf here are obtained from the kernel
which has verified it ].Quoted 10 lines
Quoted 9 lines
tools/bpf/bpftool/btf_dumper.c +8
-0+return ; + } + +for (i =0 ; i <btf_vlen (t); i++) { +if (value == enums[i].val) { +jsonw_string (d->jw, +btf__name_by_offset (d->btf, + enums[i].name_off));
Quoted 2 lines
Quoted 1 line
nit: local variable will make it cleaner
I prefer to keep it as is. There are many other uses like this.
Ok.
Quoted 22 lines
Quoted 22 lines
Quoted 22 lines
tools/bpf/bpftool/btf_dumper.c +6
-2+return ; + } + } + +jsonw_int (d->jw, value); } static int btf_dumper_array(const struct btf_dumper *d, __u32 type_id,@@ -366,7 +399,7 @@ static int btf_dumper_do_type(const struct btf_dumper *d, __u32 type_id,case BTF_KIND_ARRAY :return btf_dumper_array (d, type_id, data);case BTF_KIND_ENUM : -btf_dumper_enum (data, d->jw); +btf_dumper_enum (d, t, data);return 0 ;case BTF_KIND_PTR :btf_dumper_ptr (data, d->jw, d->is_plain_text); --2.17.1
PATCH v3 2/4 bpftool: Print as a string for char array
In reply to Martin KaFai LauA char[] is currently printed as an integer array. This patch will print it as a string when
1) The array element type is an one byte int
2) The array element type has a BTF_INT_CHAR encoding or the array element type's name is "char"
3) All characters is between (0x1f, 0x7f) and it is terminated by a null character.
--- tools/bpf/bpftool/btf_dumper.c | 41 ++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+)
tools/bpf/bpftool/btf_dumper.c +41 -0
@@ -81,6 +81,42 @@ static void btf_dumper_enum(const struct btf_dumper *d,jsonw_int (d->jw, value); } +static bool is_str_array (const struct btf *btf,const struct btf_array *arr, +const char *s) +{ +const struct btf_type *elem_type; +const char *end_s; + +if (!arr->nelems) +return false; + + elem_type =btf__type_by_id (btf, arr->type); +/* Not skipping typedef. typedef to char does not count as +* a string now. +*/ +while (elem_type &&btf_is_mod (elem_type)) + elem_type =btf__type_by_id (btf, elem_type->type); + +if (!elem_type || !btf_is_int (elem_type) || elem_type->size !=1 ) +return false; + +if (btf_int_encoding (elem_type) !=BTF_INT_CHAR && +strcmp ("char" ,btf__name_by_offset (btf, elem_type->name_off))) +return false; + + end_s = s + arr->nelems; +while (s < end_s) { +if (!*s) +return true; +if (*s <=0x1f || *s >=0x7f ) +return false; + s++; + } + +/* '\0' is not found */ +return false; +} +static int btf_dumper_array (const struct btf_dumper *d,__u32 type_id,const void *data) {
@@ -90,6 +126,11 @@ static int btf_dumper_array(const struct btf_dumper *d, __u32 type_id,int ret =0 ;__u32 i; +if (is_str_array (d->btf, arr, data)) { +jsonw_string (d->jw, data); +return 0 ; + } + elem_size =btf__resolve_size (d->btf, arr->type);if (elem_size <0 )return elem_size;
Signature · 1 line
2.17.1
PATCH v3 3/4 bpftool: Translate prog_id to its bpf prog_name
In reply to Martin KaFai LauThe kernel struct_ops obj has kernel's func ptrs implemented by bpf_progs. The bpf prog_id is stored as the value of the func ptr for introspection purpose. In the latter patch, a struct_ops dump subcmd will be added to introspect these func ptrs. It is desired to print the actual bpf prog_name instead of only printing the prog_id.
Since struct_ops is the only usecase storing prog_id in the func ptr, this patch adds a prog_id_as_func_ptr bool (default is false) to "struct btf_dumper" in order not to mis-interpret the ptr value for the other existing use-cases.
While printing a func_ptr as a bpf prog_name,
this patch also prefix the bpf prog_name with the ptr's func_proto. [ Note that it is the ptr's func_proto instead of the bpf prog's
func_proto ]
It reuses the current btf_dump_func() to obtain the ptr's func_proto string.
Here is an example from the bpf_cubic.c:
"void (struct sock *, u32, u32) bictcp_cong_avoid/prog_id:140"
--- tools/bpf/bpftool/btf_dumper.c | 118 +++++++++++++++++++++++++++++---- tools/bpf/bpftool/main.h | 1 + 2 files changed, 107 insertions(+), 12 deletions(-)
tools/bpf/bpftool/btf_dumper.c +106 -12
@@ -4,11 +4,13 @@#include <ctype.h> #include <stdio.h> /* for (FILE *) used by json_writer */ #include <string.h> +#include <unistd.h> #include <asm/byteorder.h> #include <linux/bitops.h> #include <linux/btf.h> #include <linux/err.h> #include <bpf/btf.h> +#include <bpf/bpf.h> #include "json_writer.h" #include "main.h"
@@ -22,13 +24,102 @@static int btf_dumper_do_type (const struct btf_dumper *d,__u32 type_id,__u8 bit_offset,const void *data); -static void btf_dumper_ptr (const void *data,json_writer_t *jw, -bool is_plain_text) +static int btf_dump_func (const struct btf *btf,char *func_sig, +const struct btf_type *func_proto, +const struct btf_type *func,int pos,int size); + +static int dump_prog_id_as_func_ptr (const struct btf_dumper *d, +const struct btf_type *func_proto, +__u32 prog_id) { -if (is_plain_text) -jsonw_printf (jw,"%p" , *(void **)data); +struct bpf_prog_info_linear *prog_info =NULL ; +const struct btf_type *func_type; +const char *prog_name =NULL ; +struct bpf_func_info *finfo; +struct btf *prog_btf =NULL ; +struct bpf_prog_info *info; +int prog_fd, func_sig_len; +char prog_str[1024 ]; + +/* Get the ptr's func_proto */ + func_sig_len =btf_dump_func (d->btf, prog_str, func_proto,NULL ,0 , +sizeof (prog_str)); +if (func_sig_len ==-1 ) +return -1 ; + +if (!prog_id) + goto print; + +/* Get the bpf_prog's name. Obtain from func_info. */ + prog_fd =bpf_prog_get_fd_by_id (prog_id); +if (prog_fd ==-1 ) + goto print; + + prog_info =bpf_program__get_prog_info_linear (prog_fd, +1UL <<BPF_PROG_INFO_FUNC_INFO ); +close (prog_fd); +if (IS_ERR (prog_info)) { + prog_info =NULL ; + goto print; + } + info = &prog_info->info; + +if (!info->btf_id || !info->nr_func_info || +btf__get_from_id (info->btf_id, &prog_btf)) + goto print; + finfo = (struct bpf_func_info *)info->func_info; + func_type =btf__type_by_id (prog_btf, finfo->type_id); +if (!func_type || !btf_is_func (func_type)) + goto print; + + prog_name =btf__name_by_offset (prog_btf, func_type->name_off); + +print: +if (!prog_id) +snprintf (&prog_str[func_sig_len], +sizeof (prog_str) - func_sig_len," 0" ); +else if (prog_name) +snprintf (&prog_str[func_sig_len], +sizeof (prog_str) - func_sig_len, +" %s/prog_id:%u" , prog_name, prog_id);else -jsonw_printf (jw,"%lu" , *(unsigned long *)data); +snprintf (&prog_str[func_sig_len], +sizeof (prog_str) - func_sig_len, +" <unknown_prog_name>/prog_id:%u" , prog_id); + + prog_str[sizeof (prog_str) -1 ] ='\0' ; +jsonw_string (d->jw, prog_str); +btf__free (prog_btf); +free (prog_info); +return 0 ; +} + +static void btf_dumper_ptr (const struct btf_dumper *d, +const struct btf_type *t, +const void *data) +{ +unsigned long value = *(unsigned long *)data; +const struct btf_type *ptr_type; +__s32 ptr_type_id; + +if (!d->prog_id_as_func_ptr || value >UINT32_MAX ) + goto print_ptr_value; + + ptr_type_id =btf__resolve_type (d->btf, t->type); +if (ptr_type_id <0 ) + goto print_ptr_value; + ptr_type =btf__type_by_id (d->btf, ptr_type_id); +if (!ptr_type || !btf_is_func_proto (ptr_type)) + goto print_ptr_value; + +if (!dump_prog_id_as_func_ptr (d, ptr_type, value)) +return ; + +print_ptr_value: +if (d->is_plain_text) +jsonw_printf (d->jw,"%p" , (void *)value); +else +jsonw_printf (d->jw,"%lu" , value); } static int btf_dumper_modifier(const struct btf_dumper *d, __u32 type_id,
@@ -443,7 +534,7 @@ static int btf_dumper_do_type(const struct btf_dumper *d, __u32 type_id,btf_dumper_enum (d, t, data);return 0 ;case BTF_KIND_PTR : -btf_dumper_ptr (data, d->jw, d->is_plain_text); +btf_dumper_ptr (d, t, data);return 0 ;case BTF_KIND_UNKN :jsonw_printf (d->jw,"(unknown)" );
@@ -488,10 +579,6 @@ int btf_dumper_type(const struct btf_dumper *d, __u32 type_id,return -1 ; \ }while (0 ) -static int btf_dump_func(const struct btf *btf, char *func_sig, -const struct btf_type *func_proto, -const struct btf_type *func,int pos,int size); - static int __btf_dumper_type_only(const struct btf *btf, __u32 type_id,char *func_sig,int pos,int size) {
@@ -600,8 +687,15 @@ static int btf_dump_func(const struct btf *btf, char *func_sig,BTF_PRINT_ARG (", " );if (arg->type) {BTF_PRINT_TYPE (arg->type); -BTF_PRINT_ARG ("%s" , -btf__name_by_offset (btf, arg->name_off)); +if (arg->name_off) +BTF_PRINT_ARG ("%s" , +btf__name_by_offset (btf, arg->name_off)); +else if (pos && func_sig[pos -1 ] ==' ' ) +/* Remove unnecessary space for +* FUNC_PROTO that does not have +* arg->name_off +*/ + func_sig[--pos] ='\0' ; }else {BTF_PRINT_ARG ("..." ); }
tools/bpf/bpftool/main.h +1 -0
@@ -205,6 +205,7 @@ struct btf_dumper {const struct btf *btf;json_writer_t *jw;bool is_plain_text; +bool prog_id_as_func_ptr; };/* btf_dumper_type - print data along with type information
Signature · 1 line
2.17.1
PATCH v3 4/4 bpftool: Add struct_ops support
In reply to Martin KaFai LauThis patch adds struct_ops support to the bpftool.
To recap a bit on the recent bpf_struct_ops feature on the kernel side:
It currently supports "struct tcp_congestion_ops" to be implemented in bpf. At a high level, bpf_struct_ops is struct_ops map populated with a number of bpf progs. bpf_struct_ops currently supports the "struct tcp_congestion_ops". However, the bpf_struct_ops design is generic enough that other kernel struct ops can be supported in the future.
Although struct_ops is map+progs at a high lever, there are differences in details. For example,
1) After registering a struct_ops, the struct_ops is held by the kernel subsystem (e.g. tcp-cc). Thus, there is no need to pin a struct_ops map or its progs in order to keep them around.
2) To iterate all struct_ops in a system, it iterates all maps in type BPF_MAP_TYPE_STRUCT_OPS. BPF_MAP_TYPE_STRUCT_OPS is the current usual filter. In the future, it may need to filter by other struct_ops specific properties. e.g. filter by tcp_congestion_ops or other kernel subsystem ops in the future.
3) struct_ops requires the running kernel having BTF info. That allows more flexibility in handling other kernel structs. e.g. it can always dump the latest bpf_map_info.
4) Also, "struct_ops" command is not intended to repeat all features already provided by "map" or "prog". For example, if there really is a need to pin the struct_ops map, the user can use the "map" cmd to do that.
While the first attempt was to reuse parts from map/prog.c, it ended up not a lot to share. The only obvious item is the map_parse_fds() but that still requires modifications to accommodate struct_ops map specific filtering (for the immediate and the future needs). Together with the earlier mentioned differences, it is better to part away from map/prog.c.
The initial set of subcmds are, register, unregister, show, and dump.
For register, it registers all struct_ops maps that can be found in an obj file. Option can be added in the future to specify a particular struct_ops map. Also, the common bpf_tcp_cc is stateless (e.g. bpf_cubic.c and bpf_dctcp.c). The "reuse map" feature is not implemented in this patch and it can be considered later also.
For other subcmds, please see the man doc for details.
A sample output of dump:
[root@arch-fb-vm1 bpf]# bpftool struct_ops dump name cubic
[{
"bpf_map_info": {
"type": 26,
"id": 64,
"key_size": 4,
"value_size": 256,
"max_entries": 1,
"map_flags": 0,
"name": "cubic",
"ifindex": 0,
"btf_vmlinux_value_type_id": 18452,
"netns_dev": 0,
"netns_ino": 0,
"btf_id": 52,
"btf_key_type_id": 0,
"btf_value_type_id": 0
}
},{
"bpf_struct_ops_tcp_congestion_ops": {
"refcnt": {
"refs": {
"counter": 1
}
},
"state": "BPF_STRUCT_OPS_STATE_INUSE",
"data": {
"list": {
"next": 0,
"prev": 0
},
"key": 0,
"flags": 0,
"init": "void (struct sock *) bictcp_init/prog_id:138",
"release": "void (struct sock *) 0",
"ssthresh": "u32 (struct sock *) bictcp_recalc_ssthresh/prog_id:141",
"cong_avoid": "void (struct sock *, u32, u32) bictcp_cong_avoid/prog_id:140",
"set_state": "void (struct sock *, u8) bictcp_state/prog_id:142",
"cwnd_event": "void (struct sock *, enum tcp_ca_event) bictcp_cwnd_event/prog_id:139",
"in_ack_event": "void (struct sock *, u32) 0",
"undo_cwnd": "u32 (struct sock *) tcp_reno_undo_cwnd/prog_id:144",
"pkts_acked": "void (struct sock *, const struct ack_sample *) bictcp_acked/prog_id:143",
"min_tso_segs": "u32 (struct sock *) 0",
"sndbuf_expand": "u32 (struct sock *) 0",
"cong_control": "void (struct sock *, const struct rate_sample *) 0",
"get_info": "size_t (struct sock *, u32, int *, union tcp_cc_info *) 0",
"name": "bpf_cubic",
"owner": 0
}
}
}]
--- .../Documentation/bpftool-struct_ops.rst | 116 ++++ tools/bpf/bpftool/bash-completion/bpftool | 28 + tools/bpf/bpftool/main.c | 3 +- tools/bpf/bpftool/main.h | 1 + tools/bpf/bpftool/struct_ops.c | 596 ++++++++++++++++++ 5 files changed, 743 insertions(+), 1 deletion(-) create mode 100644 tools/bpf/bpftool/Documentation/bpftool-struct_ops.rst create mode 100644 tools/bpf/bpftool/struct_ops.c
tools/bpf/bpftool/Documentation/bpftool-struct_ops.rst new file +116 -0
@@ -0,0 +1,116 @@ +================== +bpftool-struct_ops +================== +------------------------------------------------------------------------------- +tool to register/unregister/introspect BPF struct_ops +------------------------------------------------------------------------------- + +:Manual section: 8 + +SYNOPSIS +======== + + **bpftool** [*OPTIONS*] **struct_ops** *COMMAND* + + *OPTIONS* := { { **-j** | **--json** } [{ **-p** | **--pretty** }] } + + *COMMANDS* := + { **show** | **list** | **dump** | **register** | **unregister** | **help** } + +STRUCT_OPS COMMANDS +=================== + +| **bpftool** **struct_ops { show | list }** [*STRUCT_OPS_MAP*] +| **bpftool** **struct_ops dump** [*STRUCT_OPS_MAP*] +| **bpftool** **struct_ops register** *OBJ* +| **bpftool** **struct_ops unregister** *STRUCT_OPS_MAP* +| **bpftool** **struct_ops help** +| +| *STRUCT_OPS_MAP* := { **id** *STRUCT_OPS_MAP_ID* | **name** *STRUCT_OPS_MAP_NAME* } +| *OBJ* := /a/file/of/bpf_struct_ops.o + + +DESCRIPTION +=========== + **bpftool struct_ops { show | list }** [*STRUCT_OPS_MAP*] + Show brief information about the struct_ops in the system. + If *STRUCT_OPS_MAP* is specified, it shows information only + for the given struct_ops. Otherwise, it lists all struct_ops + currently existing in the system. + + Output will start with struct_ops map ID, followed by its map + name and its struct_ops's kernel type. + + **bpftool struct_ops dump** [*STRUCT_OPS_MAP*] + Dump details information about the struct_ops in the system. + If *STRUCT_OPS_MAP* is specified, it dumps information only + for the given struct_ops. Otherwise, it dumps all struct_ops + currently existing in the system. + + **bpftool struct_ops register** *OBJ* + Register bpf struct_ops from *OBJ*. All struct_ops under + the ELF section ".struct_ops" will be registered to + its kernel subsystem. + + **bpftool struct_ops unregister** *STRUCT_OPS_MAP* + Unregister the *STRUCT_OPS_MAP* from the kernel subsystem. + + **bpftool struct_ops help** + Print short help message. + +OPTIONS +======= + -h, --help + Print short generic help message (similar to **bpftool help**). + + -V, --version + Print version number (similar to **bpftool version**). + + -j, --json + Generate JSON output. For commands that cannot produce JSON, this + option has no effect. + + -p, --pretty + Generate human-readable JSON output. Implies **-j**. + + -d, --debug + Print all logs available, even debug-level information. This + includes logs from libbpf as well as from the verifier, when + attempting to load programs. + +EXAMPLES +======== +**# bpftool struct_ops show** + +:: + + 100: dctcp tcp_congestion_ops + 105: cubic tcp_congestion_ops + +**# bpftool struct_ops unregister id 105** + +:: + + Unregistered tcp_congestion_ops cubic id 105 + +**# bpftool struct_ops register bpf_cubic.o** + +:: + + Registered tcp_congestion_ops cubic id 110 + + +SEE ALSO +======== + **bpf**\ (2), + **bpf-helpers**\ (7), + **bpftool**\ (8), + **bpftool-prog**\ (8), + **bpftool-map**\ (8), + **bpftool-cgroup**\ (8), + **bpftool-feature**\ (8), + **bpftool-net**\ (8), + **bpftool-perf**\ (8), + **bpftool-btf**\ (8) + **bpftool-gen**\ (8) +
tools/bpf/bpftool/bash-completion/bpftool +28 -0
@@ -576,6 +576,34 @@ _bpftool() ;; esac ;; + struct_ops) + local STRUCT_OPS_TYPE='id name' + case $command in + show|list|dump|unregister) + case $prev in + $command) + COMPREPLY=( $( compgen -W "$STRUCT_OPS_TYPE" -- "$cur" ) ) + ;; + id) + _bpftool_get_map_ids_for_type struct_ops + ;; + name) + _bpftool_get_map_names_for_type struct_ops + ;; + esac + return 0 + ;; + register) + _filedir + return 0 + ;; + *) + [[ $prev == $object ]] && \ + COMPREPLY=( $( compgen -W 'register unregister show list dump help' \ + -- "$cur" ) ) + ;; + esac + ;; map) local MAP_TYPE='id pinned name' case $command in
tools/bpf/bpftool/main.c +2 -1
@@ -58,7 +58,7 @@ static int do_help(int argc, char **argv)" %s batch file FILE\n" " %s version\n" "\n" -" OBJECT := { prog | map | cgroup | perf | net | feature | btf | gen }\n" +" OBJECT := { prog | map | cgroup | perf | net | feature | btf | gen | struct_ops }\n" " " HELP_SPEC_OPTIONS "\n" "" , bin_name, bin_name, bin_name);
@@ -221,6 +221,7 @@ static const struct cmd cmds[] = { { "feature", do_feature }, { "btf", do_btf }, { "gen", do_gen }, + { "struct_ops", do_struct_ops }, { "version", do_version }, { 0 } };
tools/bpf/bpftool/main.h +1 -0
@@ -161,6 +161,7 @@ int do_tracelog(int argc, char **arg);int do_feature (int argc,char **argv);int do_btf (int argc,char **argv);int do_gen (int argc,char **argv); +int do_struct_ops (int argc,char **argv);int parse_u32_arg (int *argc,char ***argv,__u32 *val,const char *what);int prog_parse_fd (int *argc,char ***argv);
tools/bpf/bpftool/struct_ops.c new file +596 -0
596 lines not on this page · raw message
Signature · 1 line
2.17.1