libbpf: Textual representation of enums
Subsystems (5)
v4 cover libbpf: Textual representation of enums
This patch set introduces the means for querying a textual representation of the following BPF related enum types:
- enum bpf_map_type
- enum bpf_prog_type
- enum bpf_attach_type
- enum bpf_link_type
To make that possible, we introduce a new public function for each of the types:
libbpf_bpf_<type>_type_str.
Having a way to query a textual representation has been asked for in the past (by systemd, among others). Such representations can generally be useful in tracing and logging contexts, among others. At this point, at least one client, bpftool, maintains such a mapping manually, which is prone to get out of date as new enum variants are introduced. libbpf is arguably best situated to keep this list complete and up-to-date. This patch series adds BTF based tests to ensure that exhaustiveness is upheld moving forward.
The libbpf provided textual representation can be inferred from the corresponding enum variant name by removing the prefix and lowercasing the remainder. E.g., BPF_PROG_TYPE_SOCKET_FILTER -> socket_filter. Unfortunately, bpftool does not use such a programmatic approach for some of the bpf_attach_type variants. We decided in favor of changing its behavior to work with libbpf representations. However, for user inputs, specifically, we do maintain support for the traditionally used names around (please see patch "bpftool: Use libbpf_bpf_attach_type_str").
The patch series is structured as follows:
- for each enumeration type in {bpf_prog_type, bpf_map_type, bpf_attach_type, bpf_link_type}:
- we first introduce the corresponding public libbpf API function
- we then add BTF based self-tests
- we lastly adjust bpftool to use the libbpf provided functionality
---
Changelog:
v3 -> v4:
- use full string comparison for newly added attach types
- switched away from erroneously used kdoc-style comments
- removed unused prog_types variable and containing section from test_bpftool_synctypes.py
- adjusted wording in documentation of get_types_from_array function
- split various test_bpftool_synctypes.py changes into commits where they are required to eliminate temporary failures of this test
v2 -> v3:
- use LIBBPF_1.0.0 section in libbpf.map for newly added exports
v1 -> v2:
- adjusted bpftool to work with algorithmically determined attach types as libbpf now uses (just removed prefix from enum name and lowercased the rest)
- adjusted tests, man page, and completion script to work with the new names
- renamed bpf_attach_type_str -> bpf_attach_type_input_str
- for input: added special cases that accept the traditionally used strings as well
- changed 'char const *' -> 'const char *'
Daniel Müller (12):
libbpf: Introduce libbpf_bpf_prog_type_str selftests/bpf: Add test for libbpf_bpf_prog_type_str
bpftool: Use libbpf_bpf_prog_type_str
libbpf: Introduce libbpf_bpf_map_type_str selftests/bpf: Add test for libbpf_bpf_map_type_str
bpftool: Use libbpf_bpf_map_type_str
libbpf: Introduce libbpf_bpf_attach_type_str selftests/bpf: Add test for libbpf_bpf_attach_type_str
bpftool: Use libbpf_bpf_attach_type_str
libbpf: Introduce libbpf_bpf_link_type_str selftests/bpf: Add test for libbpf_bpf_link_type_str
bpftool: Use libbpf_bpf_link_type_str
.../bpftool/Documentation/bpftool-cgroup.rst | 16 +- .../bpftool/Documentation/bpftool-prog.rst | 5 +- tools/bpf/bpftool/bash-completion/bpftool | 18 +- tools/bpf/bpftool/cgroup.c | 53 +++-- tools/bpf/bpftool/common.c | 82 +++---- tools/bpf/bpftool/feature.c | 87 +++++--- tools/bpf/bpftool/link.c | 61 +++--- tools/bpf/bpftool/main.h | 20 +- tools/bpf/bpftool/map.c | 82 +++---- tools/bpf/bpftool/prog.c | 77 +++---- tools/lib/bpf/libbpf.c | 160 ++++++++++++++ tools/lib/bpf/libbpf.h | 36 +++ tools/lib/bpf/libbpf.map | 6 + .../selftests/bpf/prog_tests/libbpf_str.c | 207 ++++++++++++++++++ .../selftests/bpf/test_bpftool_synctypes.py | 166 ++++++-------- 15 files changed, 738 insertions(+), 338 deletions(-) create mode 100644 tools/testing/selftests/bpf/prog_tests/libbpf_str.c
Signature · 1 line
2.30.2
PATCH v4 1/12 libbpf: Introduce libbpf_bpf_prog_type_str
This change introduces a new function, libbpf_bpf_prog_type_str, to the public libbpf API. The function allows users to get a string representation for a bpf_prog_type variant.
--- tools/lib/bpf/libbpf.c | 43 ++++++++++++++++++++++++++++++++++++++++ tools/lib/bpf/libbpf.h | 9 +++++++++ tools/lib/bpf/libbpf.map | 3 +++ 3 files changed, 55 insertions(+)
tools/lib/bpf/libbpf.c +43 -0
@@ -72,6 +72,41 @@static struct bpf_map *bpf_object__add_map (struct bpf_object *obj);static bool prog_is_subprog (const struct bpf_object *obj,const struct bpf_program *prog); +static const char *const prog_type_name[] = { + [BPF_PROG_TYPE_UNSPEC ] ="unspec" , + [BPF_PROG_TYPE_SOCKET_FILTER ] ="socket_filter" , + [BPF_PROG_TYPE_KPROBE ] ="kprobe" , + [BPF_PROG_TYPE_SCHED_CLS ] ="sched_cls" , + [BPF_PROG_TYPE_SCHED_ACT ] ="sched_act" , + [BPF_PROG_TYPE_TRACEPOINT ] ="tracepoint" , + [BPF_PROG_TYPE_XDP ] ="xdp" , + [BPF_PROG_TYPE_PERF_EVENT ] ="perf_event" , + [BPF_PROG_TYPE_CGROUP_SKB ] ="cgroup_skb" , + [BPF_PROG_TYPE_CGROUP_SOCK ] ="cgroup_sock" , + [BPF_PROG_TYPE_LWT_IN ] ="lwt_in" , + [BPF_PROG_TYPE_LWT_OUT ] ="lwt_out" , + [BPF_PROG_TYPE_LWT_XMIT ] ="lwt_xmit" , + [BPF_PROG_TYPE_SOCK_OPS ] ="sock_ops" , + [BPF_PROG_TYPE_SK_SKB ] ="sk_skb" , + [BPF_PROG_TYPE_CGROUP_DEVICE ] ="cgroup_device" , + [BPF_PROG_TYPE_SK_MSG ] ="sk_msg" , + [BPF_PROG_TYPE_RAW_TRACEPOINT ] ="raw_tracepoint" , + [BPF_PROG_TYPE_CGROUP_SOCK_ADDR ] ="cgroup_sock_addr" , + [BPF_PROG_TYPE_LWT_SEG6LOCAL ] ="lwt_seg6local" , + [BPF_PROG_TYPE_LIRC_MODE2 ] ="lirc_mode2" , + [BPF_PROG_TYPE_SK_REUSEPORT ] ="sk_reuseport" , + [BPF_PROG_TYPE_FLOW_DISSECTOR ] ="flow_dissector" , + [BPF_PROG_TYPE_CGROUP_SYSCTL ] ="cgroup_sysctl" , + [BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE ] ="raw_tracepoint_writable" , + [BPF_PROG_TYPE_CGROUP_SOCKOPT ] ="cgroup_sockopt" , + [BPF_PROG_TYPE_TRACING ] ="tracing" , + [BPF_PROG_TYPE_STRUCT_OPS ] ="struct_ops" , + [BPF_PROG_TYPE_EXT ] ="ext" , + [BPF_PROG_TYPE_LSM ] ="lsm" , + [BPF_PROG_TYPE_SK_LOOKUP ] ="sk_lookup" , + [BPF_PROG_TYPE_SYSCALL ] ="syscall" , +}; +static int __base_pr (enum libbpf_print_level level,const char *format,va_list args) {
@@ -9300,6 +9335,14 @@ int libbpf_prog_type_by_name(const char *name, enum bpf_prog_type *prog_type,return libbpf_err (-ESRCH ); } +const char *libbpf_bpf_prog_type_str (enum bpf_prog_type t) +{ +if (t <0 || t >=ARRAY_SIZE (prog_type_name)) +return NULL ; + +return prog_type_name[t]; +} +static struct bpf_map *find_struct_ops_map_by_offset (struct bpf_object *obj,size_t offset) {
tools/lib/bpf/libbpf.h +9 -0
@@ -51,6 +51,15 @@ enum libbpf_errno { LIBBPF_API int libbpf_strerror(int err, char *buf, size_t size); +/** +* @brief **libbpf_bpf_prog_type_str()** converts the provided program type +* value into a textual representation. +* @param t The program type. +* @return Pointer to a static string identifying the program type. NULL is +* returned for unknown **bpf_prog_type** values. +*/ +LIBBPF_API const char *libbpf_bpf_prog_type_str(enum bpf_prog_type t); +enum libbpf_print_level {LIBBPF_WARN ,LIBBPF_INFO ,
tools/lib/bpf/libbpf.map +3 -0
@@ -461,5 +461,8 @@ LIBBPF_0.8.0 { } LIBBPF_0.7.0; LIBBPF_1.0.0 { + global: + libbpf_bpf_prog_type_str; + local: *; };
Signature · 1 line
2.30.2
PATCH v4 2/12 selftests/bpf: Add test for libbpf_bpf_prog_type_str
In reply to Daniel MüllerThis change adds a test for libbpf_bpf_prog_type_str. The test retrieves all variants of the bpf_prog_type enumeration using BTF and makes sure that the function under test works as expected for them.
--- .../selftests/bpf/prog_tests/libbpf_str.c | 57 +++++++++++++++++++ 1 file changed, 57 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/libbpf_str.c
tools/testing/selftests/bpf/prog_tests/libbpf_str.c new file +57 -0
@@ -0,0 +1,57 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2022 Meta Platforms, Inc. and affiliates. */ + +#include <ctype.h> +#include <test_progs.h> +#include <bpf/btf.h> + +/* +* Utility function uppercasing an entire string. +*/ +static void uppercase (char *s) +{ +for (; *s !='\0' ; s++) + *s =toupper (*s); +} + +/* +* Test case to check that all bpf_prog_type variants are covered by +* libbpf_bpf_prog_type_str. +*/ +void test_libbpf_bpf_prog_type_str (void ) +{ +struct btf *btf; +const struct btf_type *t; +const struct btf_enum *e; +int i, n, id; + + btf =btf__parse ("/sys/kernel/btf/vmlinux" ,NULL ); +if (!ASSERT_OK_PTR (btf,"btf_parse" )) +return ; + +/* find enum bpf_prog_type and enumerate each value */ + id =btf__find_by_name_kind (btf,"bpf_prog_type" ,BTF_KIND_ENUM ); +if (!ASSERT_GT (id,0 ,"bpf_prog_type_id" )) + goto cleanup; + t =btf__type_by_id (btf, id); + e =btf_enum (t); + n =btf_vlen (t); +for (i =0 ; i < n; e++, i++) { +enum bpf_prog_type prog_type = (enum bpf_prog_type )e->val; +const char *prog_type_name; +const char *prog_type_str; +char buf[256 ]; + + prog_type_name =btf__str_by_offset (btf, e->name_off); + prog_type_str =libbpf_bpf_prog_type_str (prog_type); +ASSERT_OK_PTR (prog_type_str, prog_type_name); + +snprintf (buf,sizeof (buf),"BPF_PROG_TYPE_%s" , prog_type_str); +uppercase (buf); + +ASSERT_STREQ (buf, prog_type_name,"exp_str_value" ); + } + +cleanup: +btf__free (btf); +}
Signature · 1 line
2.30.2
PATCH v4 3/12 bpftool: Use libbpf_bpf_prog_type_str
In reply to Daniel MüllerThis change switches bpftool over to using the recently introduced libbpf_bpf_prog_type_str function instead of maintaining its own string representation for the bpf_prog_type enum.
--- tools/bpf/bpftool/feature.c | 57 ++++++++++++------- tools/bpf/bpftool/link.c | 19 ++++--- tools/bpf/bpftool/main.h | 3 - tools/bpf/bpftool/map.c | 13 +++-- tools/bpf/bpftool/prog.c | 51 +++-------------- .../selftests/bpf/test_bpftool_synctypes.py | 14 +---- 6 files changed, 65 insertions(+), 92 deletions(-)
tools/bpf/bpftool/feature.c +36 -21
@@ -548,8 +548,8 @@ static bool probe_prog_type_ifindex(enum bpf_prog_type prog_type, __u32 ifindex) }static void -probe_prog_type (enum bpf_prog_type prog_type,bool *supported_types, -const char *define_prefix,__u32 ifindex) +probe_prog_type (enum bpf_prog_type prog_type,const char *prog_type_str, +bool *supported_types,const char *define_prefix,__u32 ifindex) {char feat_name[128 ], plain_desc[128 ], define_name[128 ];const char *plain_comment ="eBPF program_type " ;
@@ -580,20 +580,16 @@ probe_prog_type(enum bpf_prog_type prog_type, bool *supported_types, supported_types[prog_type] |= res; -if (!prog_type_name[prog_type]) { -p_info ("program type name not found (type %d)" , prog_type); -return ; - } maxlen =sizeof (plain_desc) -strlen (plain_comment) -1 ; -if (strlen (prog_type_name[prog_type]) > maxlen) { +if (strlen (prog_type_str) > maxlen) {p_info ("program type name too long" );return ; } -sprintf (feat_name,"have_%s_prog_type" , prog_type_name[prog_type]); -sprintf (define_name,"%s_prog_type" , prog_type_name[prog_type]); +sprintf (feat_name,"have_%s_prog_type" , prog_type_str); +sprintf (define_name,"%s_prog_type" , prog_type_str);uppercase (define_name,sizeof (define_name)); -sprintf (plain_desc,"%s%s" , plain_comment, prog_type_name[prog_type]); +sprintf (plain_desc,"%s%s" , plain_comment, prog_type_str);print_bool_feature (feat_name, plain_desc, define_name, res, define_prefix); }
@@ -728,10 +724,10 @@ probe_helper_for_progtype(enum bpf_prog_type prog_type, bool supported_type, }static void -probe_helpers_for_progtype (enum bpf_prog_type prog_type,bool supported_type, +probe_helpers_for_progtype (enum bpf_prog_type prog_type, +const char *prog_type_str,bool supported_type,const char *define_prefix,__u32 ifindex) { -const char *ptype_name = prog_type_name[prog_type];char feat_name[128 ];unsigned int id;bool probe_res = false;
@@ -747,12 +743,12 @@ probe_helpers_for_progtype(enum bpf_prog_type prog_type, bool supported_type, }if (json_output) { -sprintf (feat_name,"%s_available_helpers" , ptype_name); +sprintf (feat_name,"%s_available_helpers" , prog_type_str);jsonw_name (json_wtr, feat_name);jsonw_start_array (json_wtr); }else if (!define_prefix) {printf ("eBPF helpers supported for program type %s:" , - ptype_name); + prog_type_str); }for (id =1 ; id <ARRAY_SIZE (helper_name); id++) {
@@ -768,7 +764,7 @@ probe_helpers_for_progtype(enum bpf_prog_type prog_type, bool supported_type,/* fallthrough */ default : probe_res |=probe_helper_for_progtype (prog_type, supported_type, - define_prefix, id, ptype_name, + define_prefix, id, prog_type_str, ifindex); } }
@@ -943,15 +939,24 @@ static void section_program_types(bool *supported_types, const char *define_prefix, __u32 ifindex) { -unsigned int i; +unsigned int prog_type =BPF_PROG_TYPE_UNSPEC ; +const char *prog_type_str;print_start_section ("program_types" ,"Scanning eBPF program types..." ,"/*** eBPF program types ***/" , define_prefix); -for (i =BPF_PROG_TYPE_UNSPEC +1 ; i < prog_type_name_size; i++) -probe_prog_type (i, supported_types, define_prefix, ifindex); +while (true) { + prog_type++; + prog_type_str =libbpf_bpf_prog_type_str (prog_type); +/* libbpf will return NULL for variants unknown to it. */ +if (!prog_type_str) +break ; + +probe_prog_type (prog_type, prog_type_str, supported_types, define_prefix, + ifindex); + }print_end_section (); }
@@ -974,7 +979,8 @@ static void section_map_types(const char *define_prefix, __u32 ifindex)static void section_helpers (bool *supported_types,const char *define_prefix,__u32 ifindex) { -unsigned int i; +unsigned int prog_type =BPF_PROG_TYPE_UNSPEC ; +const char *prog_type_str; print_start_section("helpers", "Scanning eBPF helper functions...",
@@ -996,9 +1002,18 @@ section_helpers(bool *supported_types, const char *define_prefix, __u32 ifindex)" %sBPF__PROG_TYPE_ ## prog_type ## __HELPER_ ## helper\n" , define_prefix, define_prefix, define_prefix, define_prefix); -for (i =BPF_PROG_TYPE_UNSPEC +1 ; i < prog_type_name_size; i++) -probe_helpers_for_progtype (i, supported_types[i], define_prefix, +while (true) { + prog_type++; + prog_type_str =libbpf_bpf_prog_type_str (prog_type); +/* libbpf will return NULL for variants unknown to it. */ +if (!prog_type_str) +break ; + +probe_helpers_for_progtype (prog_type, prog_type_str, + supported_types[prog_type], + define_prefix, ifindex); + }print_end_section (); }
tools/bpf/bpftool/link.c +11 -8
@@ -121,6 +121,7 @@ static int get_prog_info(int prog_id, struct bpf_prog_info *info)static int show_link_close_json (int fd,struct bpf_link_info *info) {struct bpf_prog_info prog_info; +const char *prog_type_str;int err;jsonw_start_object (json_wtr);
@@ -137,12 +138,12 @@ static int show_link_close_json(int fd, struct bpf_link_info *info)if (err)return err; -if (prog_info.type < prog_type_name_size) -jsonw_string_field (json_wtr,"prog_type" , - prog_type_name[prog_info.type]); + prog_type_str =libbpf_bpf_prog_type_str (prog_info.type); +/* libbpf will return NULL for variants unknown to it. */ +if (prog_type_str) +jsonw_string_field (json_wtr,"prog_type" , prog_type_str);else -jsonw_uint_field (json_wtr,"prog_type" , - prog_info.type); +jsonw_uint_field (json_wtr,"prog_type" , prog_info.type);show_link_attach_type_json (info->tracing.attach_type, json_wtr);
@@ -214,6 +215,7 @@ static void show_iter_plain(struct bpf_link_info *info)static int show_link_close_plain (int fd,struct bpf_link_info *info) {struct bpf_prog_info prog_info; +const char *prog_type_str;int err;show_link_header_plain (info);
@@ -228,9 +230,10 @@ static int show_link_close_plain(int fd, struct bpf_link_info *info)if (err)return err; -if (prog_info.type < prog_type_name_size) -printf ("\n\tprog_type %s " , - prog_type_name[prog_info.type]); + prog_type_str =libbpf_bpf_prog_type_str (prog_info.type); +/* libbpf will return NULL for variants unknown to it. */ +if (prog_type_str) +printf ("\n\tprog_type %s " , prog_type_str);else printf ("\n\tprog_type %u " , prog_info.type);
tools/bpf/bpftool/main.h +0 -3
@@ -63,9 +63,6 @@ static inline void *u64_to_ptr(__u64 ptr)#define HELP_SPEC_LINK \ "LINK := { id LINK_ID | pinned FILE }" -extern const char *const prog_type_name[]; -extern const size_t prog_type_name_size; -extern const char *const attach_type_name[__MAX_BPF_ATTACH_TYPE];extern const char *const map_type_name[];
tools/bpf/bpftool/map.c +8 -5
@@ -513,10 +513,12 @@ static int show_map_close_json(int fd, struct bpf_map_info *info)if (owner_prog_type) {unsigned int prog_type =atoi (owner_prog_type); +const char *prog_type_str; -if (prog_type < prog_type_name_size) + prog_type_str =libbpf_bpf_prog_type_str (prog_type); +if (prog_type_str)jsonw_string_field (json_wtr,"owner_prog_type" , - prog_type_name[prog_type]); + prog_type_str);else jsonw_uint_field (json_wtr,"owner_prog_type" , prog_type);
@@ -597,10 +599,11 @@ static int show_map_close_plain(int fd, struct bpf_map_info *info)printf ("\n\t" );if (owner_prog_type) {unsigned int prog_type =atoi (owner_prog_type); +const char *prog_type_str; -if (prog_type < prog_type_name_size) -printf ("owner_prog_type %s " , - prog_type_name[prog_type]); + prog_type_str =libbpf_bpf_prog_type_str (prog_type); +if (prog_type_str) +printf ("owner_prog_type %s " , prog_type_str);else printf ("owner_prog_type %d " , prog_type); }
tools/bpf/bpftool/prog.c +9 -42
75 lines not on this page · raw message
tools/testing/selftests/bpf/test_bpftool_synctypes.py +1 -13
@@ -333,9 +333,6 @@ class ProgFileExtractor(SourceFileExtractor): """ filename = os.path.join(BPFTOOL_DIR, 'prog.c') - def get_prog_types(self): - return self.get_types_from_array('prog_type_name') - def get_attach_types(self): return self.get_types_from_array('attach_type_strings')
@@ -533,16 +530,6 @@ def main(): verify(source_map_types, bashcomp_map_types, f'Comparing {MapFileExtractor.filename} (map_type_name) and {BashcompExtractor.filename} (BPFTOOL_MAP_CREATE_TYPES):') - # Program types (enum) - - ref = bpf_info.get_prog_types() - - prog_info = ProgFileExtractor() - prog_types = set(prog_info.get_prog_types().keys()) - - verify(ref, prog_types, - f'Comparing BPF header (enum bpf_prog_type) and {ProgFileExtractor.filename} (prog_type_name):') - # Attach types (enum) ref = bpf_info.get_attach_types()
@@ -556,6 +543,7 @@ def main(): # Attach types (names) + prog_info = ProgFileExtractor() source_prog_attach_types = set(prog_info.get_attach_types().values()) help_prog_attach_types = prog_info.get_prog_attach_help()
Signature · 1 line
2.30.2
PATCH v4 4/12 libbpf: Introduce libbpf_bpf_map_type_str
In reply to Daniel MüllerThis change introduces a new function, libbpf_bpf_map_type_str, to the public libbpf API. The function allows users to get a string representation for a bpf_map_type enum variant.
--- tools/lib/bpf/libbpf.c | 42 ++++++++++++++++++++++++++++++++++++++++ tools/lib/bpf/libbpf.h | 9 +++++++++ tools/lib/bpf/libbpf.map | 1 + 3 files changed, 52 insertions(+)
tools/lib/bpf/libbpf.c +42 -0
@@ -72,6 +72,40 @@static struct bpf_map *bpf_object__add_map (struct bpf_object *obj);static bool prog_is_subprog (const struct bpf_object *obj,const struct bpf_program *prog); +static const char *const map_type_name[] = { + [BPF_MAP_TYPE_UNSPEC ] ="unspec" , + [BPF_MAP_TYPE_HASH ] ="hash" , + [BPF_MAP_TYPE_ARRAY ] ="array" , + [BPF_MAP_TYPE_PROG_ARRAY ] ="prog_array" , + [BPF_MAP_TYPE_PERF_EVENT_ARRAY ] ="perf_event_array" , + [BPF_MAP_TYPE_PERCPU_HASH ] ="percpu_hash" , + [BPF_MAP_TYPE_PERCPU_ARRAY ] ="percpu_array" , + [BPF_MAP_TYPE_STACK_TRACE ] ="stack_trace" , + [BPF_MAP_TYPE_CGROUP_ARRAY ] ="cgroup_array" , + [BPF_MAP_TYPE_LRU_HASH ] ="lru_hash" , + [BPF_MAP_TYPE_LRU_PERCPU_HASH ] ="lru_percpu_hash" , + [BPF_MAP_TYPE_LPM_TRIE ] ="lpm_trie" , + [BPF_MAP_TYPE_ARRAY_OF_MAPS ] ="array_of_maps" , + [BPF_MAP_TYPE_HASH_OF_MAPS ] ="hash_of_maps" , + [BPF_MAP_TYPE_DEVMAP ] ="devmap" , + [BPF_MAP_TYPE_DEVMAP_HASH ] ="devmap_hash" , + [BPF_MAP_TYPE_SOCKMAP ] ="sockmap" , + [BPF_MAP_TYPE_CPUMAP ] ="cpumap" , + [BPF_MAP_TYPE_XSKMAP ] ="xskmap" , + [BPF_MAP_TYPE_SOCKHASH ] ="sockhash" , + [BPF_MAP_TYPE_CGROUP_STORAGE ] ="cgroup_storage" , + [BPF_MAP_TYPE_REUSEPORT_SOCKARRAY ] ="reuseport_sockarray" , + [BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE ] ="percpu_cgroup_storage" , + [BPF_MAP_TYPE_QUEUE ] ="queue" , + [BPF_MAP_TYPE_STACK ] ="stack" , + [BPF_MAP_TYPE_SK_STORAGE ] ="sk_storage" , + [BPF_MAP_TYPE_STRUCT_OPS ] ="struct_ops" , + [BPF_MAP_TYPE_RINGBUF ] ="ringbuf" , + [BPF_MAP_TYPE_INODE_STORAGE ] ="inode_storage" , + [BPF_MAP_TYPE_TASK_STORAGE ] ="task_storage" , + [BPF_MAP_TYPE_BLOOM_FILTER ] ="bloom_filter" , +}; +static const char *const prog_type_name[] = { [BPF_PROG_TYPE_UNSPEC ] ="unspec" , [BPF_PROG_TYPE_SOCKET_FILTER ] ="socket_filter" ,
@@ -9335,6 +9369,14 @@ int libbpf_prog_type_by_name(const char *name, enum bpf_prog_type *prog_type,return libbpf_err (-ESRCH ); } +const char *libbpf_bpf_map_type_str (enum bpf_map_type t) +{ +if (t <0 || t >=ARRAY_SIZE (map_type_name)) +return NULL ; + +return map_type_name[t]; +} +const char *libbpf_bpf_prog_type_str (enum bpf_prog_type t) {if (t <0 || t >=ARRAY_SIZE (prog_type_name))
tools/lib/bpf/libbpf.h +9 -0
@@ -51,6 +51,15 @@ enum libbpf_errno { LIBBPF_API int libbpf_strerror(int err, char *buf, size_t size); +/** +* @brief **libbpf_bpf_map_type_str()** converts the provided map type value +* into a textual representation. +* @param t The map type. +* @return Pointer to a static string identifying the map type. NULL is +* returned for unknown **bpf_map_type** values. +*/ +LIBBPF_API const char *libbpf_bpf_map_type_str(enum bpf_map_type t); +/** * @brief **libbpf_bpf_prog_type_str()** converts the provided program type * value into a textual representation.
tools/lib/bpf/libbpf.map +1 -0
@@ -462,6 +462,7 @@ LIBBPF_0.8.0 { LIBBPF_1.0.0 { global: + libbpf_bpf_map_type_str; libbpf_bpf_prog_type_str; local: *;
Signature · 1 line
2.30.2
PATCH v4 5/12 selftests/bpf: Add test for libbpf_bpf_map_type_str
In reply to Daniel MüllerThis change adds a test for libbpf_bpf_map_type_str. The test retrieves all variants of the bpf_map_type enumeration using BTF and makes sure that the function under test works as expected for them.
--- .../selftests/bpf/prog_tests/libbpf_str.c | 56 ++++++++++++++++++- 1 file changed, 55 insertions(+), 1 deletion(-)
tools/testing/selftests/bpf/prog_tests/libbpf_str.c +55 -1
@@ -14,11 +14,53 @@ static void uppercase(char *s) *s =toupper (*s); } +/* +* Test case to check that all bpf_map_type variants are covered by +* libbpf_bpf_map_type_str. +*/ +static void test_libbpf_bpf_map_type_str (void ) +{ +struct btf *btf; +const struct btf_type *t; +const struct btf_enum *e; +int i, n, id; + + btf =btf__parse ("/sys/kernel/btf/vmlinux" ,NULL ); +if (!ASSERT_OK_PTR (btf,"btf_parse" )) +return ; + +/* find enum bpf_map_type and enumerate each value */ + id =btf__find_by_name_kind (btf,"bpf_map_type" ,BTF_KIND_ENUM ); +if (!ASSERT_GT (id,0 ,"bpf_map_type_id" )) + goto cleanup; + t =btf__type_by_id (btf, id); + e =btf_enum (t); + n =btf_vlen (t); +for (i =0 ; i < n; e++, i++) { +enum bpf_map_type map_type = (enum bpf_map_type )e->val; +const char *map_type_name; +const char *map_type_str; +char buf[256 ]; + + map_type_name =btf__str_by_offset (btf, e->name_off); + map_type_str =libbpf_bpf_map_type_str (map_type); +ASSERT_OK_PTR (map_type_str, map_type_name); + +snprintf (buf,sizeof (buf),"BPF_MAP_TYPE_%s" , map_type_str); +uppercase (buf); + +ASSERT_STREQ (buf, map_type_name,"exp_str_value" ); + } + +cleanup: +btf__free (btf); +} +/* * Test case to check that all bpf_prog_type variants are covered by * libbpf_bpf_prog_type_str. */ -void test_libbpf_bpf_prog_type_str (void ) +static void test_libbpf_bpf_prog_type_str (void ) {struct btf *btf;const struct btf_type *t;
@@ -55,3 +97,15 @@ void test_libbpf_bpf_prog_type_str(void) cleanup:btf__free (btf); } + +/* +* Run all libbpf str conversion tests. +*/ +void test_libbpf_str (void ) +{ +if (test__start_subtest ("bpf_map_type_str" )) +test_libbpf_bpf_map_type_str (); + +if (test__start_subtest ("bpf_prog_type_str" )) +test_libbpf_bpf_prog_type_str (); +}
Signature · 1 line
2.30.2
PATCH v4 6/12 bpftool: Use libbpf_bpf_map_type_str
In reply to Daniel MüllerThis change switches bpftool over to using the recently introduced libbpf_bpf_map_type_str function instead of maintaining its own string representation for the bpf_map_type enum.
--- tools/bpf/bpftool/feature.c | 30 ++++---- tools/bpf/bpftool/main.h | 3 - tools/bpf/bpftool/map.c | 69 +++++++------------ .../selftests/bpf/test_bpftool_synctypes.py | 48 ++++++++----- 4 files changed, 71 insertions(+), 79 deletions(-)
tools/bpf/bpftool/feature.c +17 -13
@@ -615,8 +615,8 @@ static bool probe_map_type_ifindex(enum bpf_map_type map_type, __u32 ifindex) }static void -probe_map_type (enum bpf_map_type map_type,const char *define_prefix, -__u32 ifindex) +probe_map_type (enum bpf_map_type map_type,char const *map_type_str, +const char *define_prefix,__u32 ifindex) {char feat_name[128 ], plain_desc[128 ], define_name[128 ];const char *plain_comment ="eBPF map_type " ;
@@ -641,20 +641,16 @@ probe_map_type(enum bpf_map_type map_type, const char *define_prefix,* check required for unprivileged users */ -if (!map_type_name[map_type]) { -p_info ("map type name not found (type %d)" , map_type); -return ; - } maxlen =sizeof (plain_desc) -strlen (plain_comment) -1 ; -if (strlen (map_type_name[map_type]) > maxlen) { +if (strlen (map_type_str) > maxlen) {p_info ("map type name too long" );return ; } -sprintf (feat_name,"have_%s_map_type" , map_type_name[map_type]); -sprintf (define_name,"%s_map_type" , map_type_name[map_type]); +sprintf (feat_name,"have_%s_map_type" , map_type_str); +sprintf (define_name,"%s_map_type" , map_type_str);uppercase (define_name,sizeof (define_name)); -sprintf (plain_desc,"%s%s" , plain_comment, map_type_name[map_type]); +sprintf (plain_desc,"%s%s" , plain_comment, map_type_str);print_bool_feature (feat_name, plain_desc, define_name, res, define_prefix); }
@@ -963,15 +959,23 @@ section_program_types(bool *supported_types, const char *define_prefix,static void section_map_types (const char *define_prefix,__u32 ifindex) { -unsigned int i; +unsigned int map_type =BPF_MAP_TYPE_UNSPEC ; +const char *map_type_str;print_start_section ("map_types" ,"Scanning eBPF map types..." ,"/*** eBPF map types ***/" , define_prefix); -for (i =BPF_MAP_TYPE_UNSPEC +1 ; i < map_type_name_size; i++) -probe_map_type (i, define_prefix, ifindex); +while (true) { + map_type++; + map_type_str =libbpf_bpf_map_type_str (map_type); +/* libbpf will return NULL for variants unknown to it. */ +if (!map_type_str) +break ; + +probe_map_type (map_type, map_type_str, define_prefix, ifindex); + }print_end_section (); }
tools/bpf/bpftool/main.h +0 -3
@@ -65,9 +65,6 @@ static inline void *u64_to_ptr(__u64 ptr)extern const char *const attach_type_name[__MAX_BPF_ATTACH_TYPE]; -extern const char *const map_type_name[]; -extern const size_t map_type_name_size; -/* keep in sync with the definition in skeleton/pid_iter.bpf.c */ enum bpf_obj_type {BPF_OBJ_UNKNOWN ,
tools/bpf/bpftool/map.c +25 -44
106 lines not on this page · raw message
tools/testing/selftests/bpf/test_bpftool_synctypes.py +29 -19
86 lines not on this page · raw message
Signature · 1 line
2.30.2
PATCH v4 7/12 libbpf: Introduce libbpf_bpf_attach_type_str
In reply to Daniel MüllerThis change introduces a new function, libbpf_bpf_attach_type_str, to the public libbpf API. The function allows users to get a string representation for a bpf_attach_type variant.
--- tools/lib/bpf/libbpf.c | 54 ++++++++++++++++++++++++++++++++++++++++ tools/lib/bpf/libbpf.h | 9 +++++++ tools/lib/bpf/libbpf.map | 1 + 3 files changed, 64 insertions(+)
tools/lib/bpf/libbpf.c +54 -0
@@ -72,6 +72,52 @@static struct bpf_map *bpf_object__add_map (struct bpf_object *obj);static bool prog_is_subprog (const struct bpf_object *obj,const struct bpf_program *prog); +static const char *const attach_type_name[] = { + [BPF_CGROUP_INET_INGRESS ] ="cgroup_inet_ingress" , + [BPF_CGROUP_INET_EGRESS ] ="cgroup_inet_egress" , + [BPF_CGROUP_INET_SOCK_CREATE ] ="cgroup_inet_sock_create" , + [BPF_CGROUP_INET_SOCK_RELEASE ] ="cgroup_inet_sock_release" , + [BPF_CGROUP_SOCK_OPS ] ="cgroup_sock_ops" , + [BPF_CGROUP_DEVICE ] ="cgroup_device" , + [BPF_CGROUP_INET4_BIND ] ="cgroup_inet4_bind" , + [BPF_CGROUP_INET6_BIND ] ="cgroup_inet6_bind" , + [BPF_CGROUP_INET4_CONNECT ] ="cgroup_inet4_connect" , + [BPF_CGROUP_INET6_CONNECT ] ="cgroup_inet6_connect" , + [BPF_CGROUP_INET4_POST_BIND ] ="cgroup_inet4_post_bind" , + [BPF_CGROUP_INET6_POST_BIND ] ="cgroup_inet6_post_bind" , + [BPF_CGROUP_INET4_GETPEERNAME ] ="cgroup_inet4_getpeername" , + [BPF_CGROUP_INET6_GETPEERNAME ] ="cgroup_inet6_getpeername" , + [BPF_CGROUP_INET4_GETSOCKNAME ] ="cgroup_inet4_getsockname" , + [BPF_CGROUP_INET6_GETSOCKNAME ] ="cgroup_inet6_getsockname" , + [BPF_CGROUP_UDP4_SENDMSG ] ="cgroup_udp4_sendmsg" , + [BPF_CGROUP_UDP6_SENDMSG ] ="cgroup_udp6_sendmsg" , + [BPF_CGROUP_SYSCTL ] ="cgroup_sysctl" , + [BPF_CGROUP_UDP4_RECVMSG ] ="cgroup_udp4_recvmsg" , + [BPF_CGROUP_UDP6_RECVMSG ] ="cgroup_udp6_recvmsg" , + [BPF_CGROUP_GETSOCKOPT ] ="cgroup_getsockopt" , + [BPF_CGROUP_SETSOCKOPT ] ="cgroup_setsockopt" , + [BPF_SK_SKB_STREAM_PARSER ] ="sk_skb_stream_parser" , + [BPF_SK_SKB_STREAM_VERDICT ] ="sk_skb_stream_verdict" , + [BPF_SK_SKB_VERDICT ] ="sk_skb_verdict" , + [BPF_SK_MSG_VERDICT ] ="sk_msg_verdict" , + [BPF_LIRC_MODE2 ] ="lirc_mode2" , + [BPF_FLOW_DISSECTOR ] ="flow_dissector" , + [BPF_TRACE_RAW_TP ] ="trace_raw_tp" , + [BPF_TRACE_FENTRY ] ="trace_fentry" , + [BPF_TRACE_FEXIT ] ="trace_fexit" , + [BPF_MODIFY_RETURN ] ="modify_return" , + [BPF_LSM_MAC ] ="lsm_mac" , + [BPF_SK_LOOKUP ] ="sk_lookup" , + [BPF_TRACE_ITER ] ="trace_iter" , + [BPF_XDP_DEVMAP ] ="xdp_devmap" , + [BPF_XDP_CPUMAP ] ="xdp_cpumap" , + [BPF_XDP ] ="xdp" , + [BPF_SK_REUSEPORT_SELECT ] ="sk_reuseport_select" , + [BPF_SK_REUSEPORT_SELECT_OR_MIGRATE ] ="sk_reuseport_select_or_migrate" , + [BPF_PERF_EVENT ] ="perf_event" , + [BPF_TRACE_KPROBE_MULTI ] ="trace_kprobe_multi" , +}; +static const char *const map_type_name[] = { [BPF_MAP_TYPE_UNSPEC ] ="unspec" , [BPF_MAP_TYPE_HASH ] ="hash" ,
@@ -9369,6 +9415,14 @@ int libbpf_prog_type_by_name(const char *name, enum bpf_prog_type *prog_type,return libbpf_err (-ESRCH ); } +const char *libbpf_bpf_attach_type_str (enum bpf_attach_type t) +{ +if (t <0 || t >=ARRAY_SIZE (attach_type_name)) +return NULL ; + +return attach_type_name[t]; +} +const char *libbpf_bpf_map_type_str (enum bpf_map_type t) {if (t <0 || t >=ARRAY_SIZE (map_type_name))
tools/lib/bpf/libbpf.h +9 -0
@@ -51,6 +51,15 @@ enum libbpf_errno { LIBBPF_API int libbpf_strerror(int err, char *buf, size_t size); +/** +* @brief **libbpf_bpf_attach_type_str()** converts the provided attach type +* value into a textual representation. +* @param t The attach type. +* @return Pointer to a static string identifying the attach type. NULL is +* returned for unknown **bpf_attach_type** values. +*/ +LIBBPF_API const char *libbpf_bpf_attach_type_str(enum bpf_attach_type t); +/** * @brief **libbpf_bpf_map_type_str()** converts the provided map type value * into a textual representation.
tools/lib/bpf/libbpf.map +1 -0
@@ -462,6 +462,7 @@ LIBBPF_0.8.0 { LIBBPF_1.0.0 { global: + libbpf_bpf_attach_type_str; libbpf_bpf_map_type_str; libbpf_bpf_prog_type_str;
Signature · 1 line
2.30.2
PATCH v4 8/12 selftests/bpf: Add test for libbpf_bpf_attach_type_str
In reply to Daniel MüllerThis change adds a test for libbpf_bpf_attach_type_str. The test retrieves all variants of the bpf_attach_type enumeration using BTF and makes sure that the function under test works as expected for them.
--- .../selftests/bpf/prog_tests/libbpf_str.c | 48 +++++++++++++++++++ 1 file changed, 48 insertions(+)
tools/testing/selftests/bpf/prog_tests/libbpf_str.c +48 -0
@@ -14,6 +14,51 @@ static void uppercase(char *s) *s =toupper (*s); } +/* +* Test case to check that all bpf_attach_type variants are covered by +* libbpf_bpf_attach_type_str. +*/ +static void test_libbpf_bpf_attach_type_str (void ) +{ +struct btf *btf; +const struct btf_type *t; +const struct btf_enum *e; +int i, n, id; + + btf =btf__parse ("/sys/kernel/btf/vmlinux" ,NULL ); +if (!ASSERT_OK_PTR (btf,"btf_parse" )) +return ; + +/* find enum bpf_attach_type and enumerate each value */ + id =btf__find_by_name_kind (btf,"bpf_attach_type" ,BTF_KIND_ENUM ); +if (!ASSERT_GT (id,0 ,"bpf_attach_type_id" )) + goto cleanup; + t =btf__type_by_id (btf, id); + e =btf_enum (t); + n =btf_vlen (t); +for (i =0 ; i < n; e++, i++) { +enum bpf_attach_type attach_type = (enum bpf_attach_type )e->val; +const char *attach_type_name; +const char *attach_type_str; +char buf[256 ]; + +if (attach_type == __MAX_BPF_ATTACH_TYPE) +continue ; + + attach_type_name =btf__str_by_offset (btf, e->name_off); + attach_type_str =libbpf_bpf_attach_type_str (attach_type); +ASSERT_OK_PTR (attach_type_str, attach_type_name); + +snprintf (buf,sizeof (buf),"BPF_%s" , attach_type_str); +uppercase (buf); + +ASSERT_STREQ (buf, attach_type_name,"exp_str_value" ); + } + +cleanup: +btf__free (btf); +} +/* * Test case to check that all bpf_map_type variants are covered by * libbpf_bpf_map_type_str.
@@ -103,6 +148,9 @@ static void test_libbpf_bpf_prog_type_str(void)*/ void test_libbpf_str (void ) { +if (test__start_subtest ("bpf_attach_type_str" )) +test_libbpf_bpf_attach_type_str (); +if (test__start_subtest ("bpf_map_type_str" ))test_libbpf_bpf_map_type_str ();
Signature · 1 line
2.30.2
PATCH v4 9/12 bpftool: Use libbpf_bpf_attach_type_str
In reply to Daniel MüllerThis change switches bpftool over to using the recently introduced libbpf_bpf_attach_type_str function instead of maintaining its own string representation for the bpf_attach_type enum.
Note that contrary to other enum types, the variant names that bpftool maps bpf_attach_type to do not adhere a simple to follow rule. With bpf_prog_type, for example, the textual representation can easily be inferred by stripping the BPF_PROG_TYPE_ prefix and lowercasing the remaining string. bpf_attach_type violates this rule for various variants.
We decided to fix up this deficiency with this change, meaning that bpftool uses the same textual representations as libbpf. Supporting tests, completion scripts, and man pages have been adjusted accordingly. However, we did add support for accepting (the now undocumented) original attach type names when they are provided by users.
For the test (test_bpftool_synctypes.py), I have removed the enum representation checks, because we no longer mirror the various enum variant names in bpftool source code. For the man page, help text, and completion script checks we are now using enum definitions from uapi/linux/bpf.h as the source of truth directly.
--- .../bpftool/Documentation/bpftool-cgroup.rst | 16 ++- .../bpftool/Documentation/bpftool-prog.rst | 5 +- tools/bpf/bpftool/bash-completion/bpftool | 18 +-- tools/bpf/bpftool/cgroup.c | 53 ++++++--- tools/bpf/bpftool/common.c | 82 ++++++-------- tools/bpf/bpftool/link.c | 15 ++- tools/bpf/bpftool/main.h | 14 +++ tools/bpf/bpftool/prog.c | 26 ++++- .../selftests/bpf/test_bpftool_synctypes.py | 104 +++++++----------- 9 files changed, 183 insertions(+), 150 deletions(-)
tools/bpf/bpftool/Documentation/bpftool-cgroup.rst +11 -5
@@ -31,11 +31,17 @@ CGROUP COMMANDS | **bpftool** **cgroup help** | | *PROG* := { **id** *PROG_ID* | **pinned** *FILE* | **tag** *PROG_TAG* } -| *ATTACH_TYPE* := { **ingress** | **egress** | **sock_create** | **sock_ops** | **device** | -| **bind4** | **bind6** | **post_bind4** | **post_bind6** | **connect4** | **connect6** | -| **getpeername4** | **getpeername6** | **getsockname4** | **getsockname6** | **sendmsg4** | -| **sendmsg6** | **recvmsg4** | **recvmsg6** | **sysctl** | **getsockopt** | **setsockopt** | -| **sock_release** } +| *ATTACH_TYPE* := { **cgroup_inet_ingress** | **cgroup_inet_egress** | +| **cgroup_inet_sock_create** | **cgroup_sock_ops** | +| **cgroup_device** | **cgroup_inet4_bind** | **cgroup_inet6_bind** | +| **cgroup_inet4_post_bind** | **cgroup_inet6_post_bind** | +| **cgroup_inet4_connect** | **cgroup_inet6_connect** | +| **cgroup_inet4_getpeername** | **cgroup_inet6_getpeername** | +| **cgroup_inet4_getsockname** | **cgroup_inet6_getsockname** | +| **cgroup_udp4_sendmsg** | **cgroup_udp6_sendmsg** | +| **cgroup_udp4_recvmsg** | **cgroup_udp6_recvmsg** | +| **cgroup_sysctl** | **cgroup_getsockopt** | **cgroup_setsockopt** | +| **cgroup_inet_sock_release** } | *ATTACH_FLAGS* := { **multi** | **override** } DESCRIPTION
tools/bpf/bpftool/Documentation/bpftool-prog.rst +3 -2
@@ -53,8 +53,9 @@ PROG COMMANDS | **cgroup/getsockopt** | **cgroup/setsockopt** | **cgroup/sock_release** | | **struct_ops** | **fentry** | **fexit** | **freplace** | **sk_lookup** | } -| *ATTACH_TYPE* := { -| **msg_verdict** | **skb_verdict** | **stream_verdict** | **stream_parser** | **flow_dissector** +| *ATTACH_TYPE* := { +| **sk_msg_verdict** | **sk_skb_verdict** | **sk_skb_stream_verdict** | +| **sk_skb_stream_parser** | **flow_dissector** | } | *METRICs* := { | **cycles** | **instructions** | **l1d_loads** | **llc_misses** |
tools/bpf/bpftool/bash-completion/bpftool +10 -8
@@ -407,8 +407,8 @@ _bpftool() return 0 ;; 5) - local BPFTOOL_PROG_ATTACH_TYPES='msg_verdict \ - skb_verdict stream_verdict stream_parser \ + local BPFTOOL_PROG_ATTACH_TYPES='sk_msg_verdict \ + sk_skb_verdict sk_skb_stream_verdict sk_skb_stream_parser \ flow_dissector' COMPREPLY=( $( compgen -W "$BPFTOOL_PROG_ATTACH_TYPES" -- "$cur" ) ) return 0
@@ -1039,12 +1039,14 @@ _bpftool() return 0 ;; attach|detach) - local BPFTOOL_CGROUP_ATTACH_TYPES='ingress egress \ - sock_create sock_ops device \ - bind4 bind6 post_bind4 post_bind6 connect4 connect6 \ - getpeername4 getpeername6 getsockname4 getsockname6 \ - sendmsg4 sendmsg6 recvmsg4 recvmsg6 sysctl getsockopt \ - setsockopt sock_release' + local BPFTOOL_CGROUP_ATTACH_TYPES='cgroup_inet_ingress cgroup_inet_egress \ + cgroup_inet_sock_create cgroup_sock_ops cgroup_device cgroup_inet4_bind \ + cgroup_inet6_bind cgroup_inet4_post_bind cgroup_inet6_post_bind \ + cgroup_inet4_connect cgroup_inet6_connect cgroup_inet4_getpeername \ + cgroup_inet6_getpeername cgroup_inet4_getsockname cgroup_inet6_getsockname \ + cgroup_udp4_sendmsg cgroup_udp6_sendmsg cgroup_udp4_recvmsg \ + cgroup_udp6_recvmsg cgroup_sysctl cgroup_getsockopt cgroup_setsockopt \ + cgroup_inet_sock_release' local ATTACH_FLAGS='multi override' local PROG_TYPE='id pinned tag name' # Check for $prev = $command first
tools/bpf/bpftool/cgroup.c +36 -17
88 lines not on this page · raw message
tools/bpf/bpftool/common.c +36 -46
91 lines not on this page · raw message
tools/bpf/bpftool/link.c +10 -5
@@ -78,9 +78,11 @@ show_link_header_json(struct bpf_link_info *info, json_writer_t *wtr)static void show_link_attach_type_json (__u32 attach_type,json_writer_t *wtr) { -if (attach_type <ARRAY_SIZE (attach_type_name)) -jsonw_string_field (wtr,"attach_type" , - attach_type_name[attach_type]); +const char *attach_type_str; + + attach_type_str =libbpf_bpf_attach_type_str (attach_type); +if (attach_type_str) +jsonw_string_field (wtr,"attach_type" , attach_type_str);else jsonw_uint_field (wtr,"attach_type" , attach_type); }
@@ -196,8 +198,11 @@ static void show_link_header_plain(struct bpf_link_info *info)static void show_link_attach_type_plain (__u32 attach_type) { -if (attach_type <ARRAY_SIZE (attach_type_name)) -printf ("attach_type %s " , attach_type_name[attach_type]); +const char *attach_type_str; + + attach_type_str =libbpf_bpf_attach_type_str (attach_type); +if (attach_type_str) +printf ("attach_type %s " , attach_type_str);else printf ("attach_type %u " , attach_type); }
tools/bpf/bpftool/main.h +14 -0
@@ -243,6 +243,20 @@ int print_all_levels(__maybe_unused enum libbpf_print_level level,size_t hash_fn_for_key_as_id (const void *key,void *ctx);bool equal_fn_for_key_as_id (const void *k1,const void *k2,void *ctx); +/* bpf_attach_type_input_str - convert the provided attach type value into a +* textual representation that we accept for input purposes. +* +* This function is similar in nature to libbpf_bpf_attach_type_str, but +* recognizes some attach type names that have been used by the program in the +* past and which do not follow the string inference scheme that libbpf uses. +* These textual representations should only be used for user input. +* +* @t: The attach type +* Returns a pointer to a static string identifying the attach type. NULL is +* returned for unknown bpf_attach_type values. +*/ +const char *bpf_attach_type_input_str (enum bpf_attach_type t); +static inline void *u32_as_hash_field (__u32 x) {return (void *)(uintptr_t )x;
tools/bpf/bpftool/prog.c +23 -3
@@ -41,12 +41,24 @@ enum dump_mode { DUMP_XLATED, }; +static const bool attach_types[] = { + [BPF_SK_SKB_STREAM_PARSER ] = true, + [BPF_SK_SKB_STREAM_VERDICT ] = true, + [BPF_SK_SKB_VERDICT ] = true, + [BPF_SK_MSG_VERDICT ] = true, + [BPF_FLOW_DISSECTOR ] = true, + [__MAX_BPF_ATTACH_TYPE] = false, +}; + +/* +* Textual representations traditionally used by the program and kept around for +* the sake of backwards compatibility. +*/ static const char *const attach_type_strings[] = { [BPF_SK_SKB_STREAM_PARSER ] ="stream_parser" , [BPF_SK_SKB_STREAM_VERDICT ] ="stream_verdict" , [BPF_SK_SKB_VERDICT ] ="skb_verdict" , [BPF_SK_MSG_VERDICT ] ="msg_verdict" , - [BPF_FLOW_DISSECTOR ] ="flow_dissector" , [__MAX_BPF_ATTACH_TYPE] =NULL , };
@@ -57,6 +69,14 @@ static enum bpf_attach_type parse_attach_type(const char *str)enum bpf_attach_type type;for (type =0 ; type < __MAX_BPF_ATTACH_TYPE; type++) { +if (attach_types[type]) { +const char *attach_type_str; + + attach_type_str =libbpf_bpf_attach_type_str (type); +if (!strcmp (str, attach_type_str)) +return type; + } +if (attach_type_strings[type] &&is_prefix (str, attach_type_strings[type]))return type;
@@ -2341,8 +2361,8 @@ static int do_help(int argc, char **argv)" cgroup/sendmsg6 | cgroup/recvmsg4 | cgroup/recvmsg6 |\n" " cgroup/getsockopt | cgroup/setsockopt | cgroup/sock_release |\n" " struct_ops | fentry | fexit | freplace | sk_lookup }\n" -" ATTACH_TYPE := { msg_verdict | skb_verdict | stream_verdict |\n" -" stream_parser | flow_dissector }\n" +" ATTACH_TYPE := { sk_msg_verdict | sk_skb_verdict | sk_skb_stream_verdict |\n" +" sk_skb_stream_parser | flow_dissector }\n" " METRIC := { cycles | instructions | l1d_loads | llc_misses | itlb_misses | dtlb_misses }\n" " " HELP_SPEC_OPTIONS " |\n" " {-f|--bpffs} | {-m|--mapcompat} | {-n|--nomount} |\n"
tools/testing/selftests/bpf/test_bpftool_synctypes.py +40 -64
196 lines not on this page · raw message
Signature · 1 line
2.30.2
Re: [PATCH bpf-next v4 09/12] bpftool: Use libbpf_bpf_attach_type_str
2022-05-23 23:04 UTC+0000 ~ Daniel Müller <[email protected]>
Quoted 16 lines
This change switches bpftool over to using the recently introduced
libbpf_bpf_attach_type_strfunction instead of maintaining its own string representation for thebpf_attach_typeenum.Note that contrary to other enum types, the variant names that bpftool maps
bpf_attach_typeto do not adhere a simple to follow rule. Withbpf_prog_type, for example, the textual representation can easily be inferred by stripping theBPF_PROG_TYPE_prefix and lowercasing the remaining string.bpf_attach_typeviolates this rule for various variants.
We decided to fix up this deficiency with this change, meaning that bpftool uses the same textual representations as libbpf. Supporting tests, completion scripts, and man pages have been adjusted accordingly. However, we did add support for accepting (the now undocumented) original attach type names when they are provided by users.
Quoted 7 lines
For the test (
test_bpftool_synctypes.py), I have removed the enum representation checks, because we no longer mirror the various enum variant names in bpftool source code. For the man page, help text, and completion script checks we are now using enum definitions fromuapi/linux/bpf.has the source of truth directly.Signed-off-by Daniel Müller <[email protected]>
Looks all good to me this time, thanks again! And thank you for splitting the changes on the test script, it's also easier to follow.
Quoted 11 lines
tools/bpf/bpftool/prog.c +3
-0@@ -41,12 +41,24 @@ enum dump_mode { DUMP_XLATED, }; +static const bool attach_types[] = { + [BPF_SK_SKB_STREAM_PARSER ] = true, + [BPF_SK_SKB_STREAM_VERDICT ] = true,
tools/bpf/bpftool/prog.c enum dump_mode { · line 56
Quoted 10 lines
tools/bpf/bpftool/prog.c +10
-0+ [BPF_SK_SKB_VERDICT] = true, + [BPF_SK_MSG_VERDICT] = true, + [BPF_FLOW_DISSECTOR] = true, + [__MAX_BPF_ATTACH_TYPE] = false, +}; + +/* +* Textual representations traditionally used by the program and kept around for +* the sake of backwards compatibility. +*/
Nit: Opening marker for comments should be on the same line as the text, but this is not worth a respin.
PATCH v4 10/12 libbpf: Introduce libbpf_bpf_link_type_str
In reply to Daniel MüllerThis change introduces a new function, libbpf_bpf_link_type_str, to the public libbpf API. The function allows users to get a string representation for a bpf_link_type enum variant.
--- tools/lib/bpf/libbpf.c | 21 +++++++++++++++++++++ tools/lib/bpf/libbpf.h | 9 +++++++++ tools/lib/bpf/libbpf.map | 1 + 3 files changed, 31 insertions(+)
tools/lib/bpf/libbpf.c +21 -0
@@ -118,6 +118,19 @@ static const char * const attach_type_name[] = { [BPF_TRACE_KPROBE_MULTI] = "trace_kprobe_multi", }; +static const char *const link_type_name[] = { + [BPF_LINK_TYPE_UNSPEC ] ="unspec" , + [BPF_LINK_TYPE_RAW_TRACEPOINT ] ="raw_tracepoint" , + [BPF_LINK_TYPE_TRACING ] ="tracing" , + [BPF_LINK_TYPE_CGROUP ] ="cgroup" , + [BPF_LINK_TYPE_ITER ] ="iter" , + [BPF_LINK_TYPE_NETNS ] ="netns" , + [BPF_LINK_TYPE_XDP ] ="xdp" , + [BPF_LINK_TYPE_PERF_EVENT ] ="perf_event" , + [BPF_LINK_TYPE_KPROBE_MULTI ] ="kprobe_multi" , + [BPF_LINK_TYPE_STRUCT_OPS ] ="struct_ops" , +}; +static const char *const map_type_name[] = { [BPF_MAP_TYPE_UNSPEC ] ="unspec" , [BPF_MAP_TYPE_HASH ] ="hash" ,
@@ -9423,6 +9436,14 @@ const char *libbpf_bpf_attach_type_str(enum bpf_attach_type t)return attach_type_name[t]; } +const char *libbpf_bpf_link_type_str (enum bpf_link_type t) +{ +if (t <0 || t >=ARRAY_SIZE (link_type_name)) +return NULL ; + +return link_type_name[t]; +} +const char *libbpf_bpf_map_type_str (enum bpf_map_type t) {if (t <0 || t >=ARRAY_SIZE (map_type_name))
tools/lib/bpf/libbpf.h +9 -0
@@ -60,6 +60,15 @@ LIBBPF_API int libbpf_strerror(int err, char *buf, size_t size);*/ LIBBPF_API const char *libbpf_bpf_attach_type_str(enum bpf_attach_type t); +/** +* @brief **libbpf_bpf_link_type_str()** converts the provided link type value +* into a textual representation. +* @param t The link type. +* @return Pointer to a static string identifying the link type. NULL is +* returned for unknown **bpf_link_type** values. +*/ +LIBBPF_API const char *libbpf_bpf_link_type_str(enum bpf_link_type t); +/** * @brief **libbpf_bpf_map_type_str()** converts the provided map type value * into a textual representation.
tools/lib/bpf/libbpf.map +1 -0
@@ -463,6 +463,7 @@ LIBBPF_0.8.0 { LIBBPF_1.0.0 { global: libbpf_bpf_attach_type_str; + libbpf_bpf_link_type_str; libbpf_bpf_map_type_str; libbpf_bpf_prog_type_str;
Signature · 1 line
2.30.2
PATCH v4 11/12 selftests/bpf: Add test for libbpf_bpf_link_type_str
In reply to Daniel MüllerThis change adds a test for libbpf_bpf_link_type_str. The test retrieves all variants of the bpf_link_type enumeration using BTF and makes sure that the function under test works as expected for them.
--- .../selftests/bpf/prog_tests/libbpf_str.c | 48 +++++++++++++++++++ 1 file changed, 48 insertions(+)
tools/testing/selftests/bpf/prog_tests/libbpf_str.c +48 -0
@@ -59,6 +59,51 @@ static void test_libbpf_bpf_attach_type_str(void)btf__free (btf); } +/* +* Test case to check that all bpf_link_type variants are covered by +* libbpf_bpf_link_type_str. +*/ +static void test_libbpf_bpf_link_type_str (void ) +{ +struct btf *btf; +const struct btf_type *t; +const struct btf_enum *e; +int i, n, id; + + btf =btf__parse ("/sys/kernel/btf/vmlinux" ,NULL ); +if (!ASSERT_OK_PTR (btf,"btf_parse" )) +return ; + +/* find enum bpf_link_type and enumerate each value */ + id =btf__find_by_name_kind (btf,"bpf_link_type" ,BTF_KIND_ENUM ); +if (!ASSERT_GT (id,0 ,"bpf_link_type_id" )) + goto cleanup; + t =btf__type_by_id (btf, id); + e =btf_enum (t); + n =btf_vlen (t); +for (i =0 ; i < n; e++, i++) { +enum bpf_link_type link_type = (enum bpf_link_type )e->val; +const char *link_type_name; +const char *link_type_str; +char buf[256 ]; + +if (link_type ==MAX_BPF_LINK_TYPE ) +continue ; + + link_type_name =btf__str_by_offset (btf, e->name_off); + link_type_str =libbpf_bpf_link_type_str (link_type); +ASSERT_OK_PTR (link_type_str, link_type_name); + +snprintf (buf,sizeof (buf),"BPF_LINK_TYPE_%s" , link_type_str); +uppercase (buf); + +ASSERT_STREQ (buf, link_type_name,"exp_str_value" ); + } + +cleanup: +btf__free (btf); +} +/* * Test case to check that all bpf_map_type variants are covered by * libbpf_bpf_map_type_str.
@@ -151,6 +196,9 @@ void test_libbpf_str(void)if (test__start_subtest ("bpf_attach_type_str" ))test_libbpf_bpf_attach_type_str (); +if (test__start_subtest ("bpf_link_type_str" )) +test_libbpf_bpf_link_type_str (); +if (test__start_subtest ("bpf_map_type_str" ))test_libbpf_bpf_map_type_str ();
Signature · 1 line
2.30.2
PATCH v4 12/12 bpftool: Use libbpf_bpf_link_type_str
In reply to Daniel MüllerThis change switches bpftool over to using the recently introduced libbpf_bpf_link_type_str function instead of maintaining its own string representation for the bpf_link_type enum.
--- tools/bpf/bpftool/link.c | 27 ++++++++++----------------- 1 file changed, 10 insertions(+), 17 deletions(-)
tools/bpf/bpftool/link.c +10 -17
@@ -13,19 +13,6 @@#include "json_writer.h" #include "main.h" -static const char *const link_type_name[] = { - [BPF_LINK_TYPE_UNSPEC ] ="unspec" , - [BPF_LINK_TYPE_RAW_TRACEPOINT ] ="raw_tracepoint" , - [BPF_LINK_TYPE_TRACING ] ="tracing" , - [BPF_LINK_TYPE_CGROUP ] ="cgroup" , - [BPF_LINK_TYPE_ITER ] ="iter" , - [BPF_LINK_TYPE_NETNS ] ="netns" , - [BPF_LINK_TYPE_XDP ] ="xdp" , - [BPF_LINK_TYPE_PERF_EVENT ] ="perf_event" , - [BPF_LINK_TYPE_KPROBE_MULTI ] ="kprobe_multi" , - [BPF_LINK_TYPE_STRUCT_OPS ] ="struct_ops" , -}; -static struct hashmap *link_table;static int link_parse_fd (int *argc,char ***argv)
@@ -67,9 +54,12 @@ static int link_parse_fd(int *argc, char ***argv)static void show_link_header_json (struct bpf_link_info *info,json_writer_t *wtr) { +const char *link_type_str; +jsonw_uint_field (wtr,"id" , info->id); -if (info->type <ARRAY_SIZE (link_type_name)) -jsonw_string_field (wtr,"type" , link_type_name[info->type]); + link_type_str =libbpf_bpf_link_type_str (info->type); +if (link_type_str) +jsonw_string_field (wtr,"type" , link_type_str);else jsonw_uint_field (wtr,"type" , info->type);
@@ -187,9 +177,12 @@ static int show_link_close_json(int fd, struct bpf_link_info *info)static void show_link_header_plain (struct bpf_link_info *info) { +const char *link_type_str; +printf ("%u: " , info->id); -if (info->type <ARRAY_SIZE (link_type_name)) -printf ("%s " , link_type_name[info->type]); + link_type_str =libbpf_bpf_link_type_str (info->type); +if (link_type_str) +printf ("%s " , link_type_str);else printf ("type %u " , info->type);
Signature · 1 line
2.30.2
This series was applied to bpf/bpf-next.git (master) by Andrii Nakryiko <[email protected]>:
Hello:
This series was applied to bpf/bpf-next.git (master) by Andrii Nakryiko <[email protected]>:
Quoted 8 lines · On Mon, 23 May 2022 23:04:16 +0000 you wrote:
This patch set introduces the means for querying a textual representation of the following BPF related enum types:
- enumbpf_map_type
- enumbpf_prog_type
- enumbpf_attach_type
- enumbpf_link_type[...]
Here is the summary with links:
- [bpf-next,v4,01/12] libbpf: Introduce libbpf_bpf_prog_type_str
https://git.kernel.org/bpf/bpf-next/c/36f21676bad3 - [bpf-next,v4,02/12] selftests/bpf: Add test for libbpf_bpf_prog_type_str https://git.kernel.org/bpf/bpf-next/c/9bb1be5c6eed - [bpf-next,v4,03/12] bpftool: Use libbpf_bpf_prog_type_str https://git.kernel.org/bpf/bpf-next/c/13259b23955f - [bpf-next,v4,04/12] libbpf: Introduce libbpf_bpf_map_type_str https://git.kernel.org/bpf/bpf-next/c/1be3ac58c1f7 - [bpf-next,v4,05/12] selftests/bpf: Add test for libbpf_bpf_map_type_str https://git.kernel.org/bpf/bpf-next/c/4714649a9af8 - [bpf-next,v4,06/12] bpftool: Use libbpf_bpf_map_type_str https://git.kernel.org/bpf/bpf-next/c/889f4cba4bdb - [bpf-next,v4,07/12] libbpf: Introduce libbpf_bpf_attach_type_str https://git.kernel.org/bpf/bpf-next/c/58342919a189 - [bpf-next,v4,08/12] selftests/bpf: Add test for libbpf_bpf_attach_type_str https://git.kernel.org/bpf/bpf-next/c/98e0e5eb4412 - [bpf-next,v4,09/12] bpftool: Use libbpf_bpf_attach_type_str https://git.kernel.org/bpf/bpf-next/c/2a5ada03fcb3 - [bpf-next,v4,10/12] libbpf: Introduce libbpf_bpf_link_type_str https://git.kernel.org/bpf/bpf-next/c/19b4ce1e29ff - [bpf-next,v4,11/12] selftests/bpf: Add test for libbpf_bpf_link_type_str https://git.kernel.org/bpf/bpf-next/c/8ff2d074f953 - [bpf-next,v4,12/12] bpftool: Use libbpf_bpf_link_type_str https://git.kernel.org/bpf/bpf-next/c/9522b20b46c3
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html