bpf_link observability APIs
Subsystems (9)
v3 cover bpf_link observability APIs
This patch series adds various observability APIs to bpf_link:
- each bpf_link now gets ID, similar to bpf_map and bpf_prog, by which user-space can iterate over all existing bpf_links and create limited FD from ID;
- allows to get extra object information with bpf_link general and
type-specific information;
- implements `bpf link show` command which lists all active bpf_links in the
system; - implements bpf link pin allowing to pin bpf_link by ID or from other pinned path.
v2->v3:
- improve spin locking around bpf_link ID (Alexei);
- simplify bpf_link_info handling and fix compilation error on sh arch;v1->v2:
- simplified bpftool link show implementation (Quentin);
- fixed formatting of bpftool-link.rst (Quentin);
- fixed attach type printing logic (Quentin);rfc->v1:
- dropped read-only bpf_links (Alexei);
- fixed bug in bpf_link_cleanup() not removing ID;
- fixed bpftool link pinning search logic;
- added bash-completion and man page.
Andrii Nakryiko (10):
bpf: refactor bpf_link update handling
bpf: allocate ID for bpf_link
bpf: support GET_FD_BY_ID and GET_NEXT_ID for bpf_link
bpf: add support for BPF_OBJ_GET_INFO_BY_FD for bpf_link
libbpf: add low-level APIs for new bpf_link commands selftests/bpf: test bpf_link's get_next_id, get_fd_by_id, and
get_obj_info
bpftool: expose attach_type-to-string array to non-cgroup code
bpftool: add bpf_link show and pin support
bpftool: add bpftool-link manpage
bpftool: add link bash completions
include/linux/bpf-cgroup.h | 14 - include/linux/bpf.h | 26 +- include/linux/bpf_types.h | 6 + include/uapi/linux/bpf.h | 31 ++ kernel/bpf/btf.c | 2 + kernel/bpf/cgroup.c | 87 ++++- kernel/bpf/syscall.c | 354 ++++++++++++++---- kernel/bpf/verifier.c | 2 + kernel/cgroup/cgroup.c | 27 -- .../bpftool/Documentation/bpftool-link.rst | 118 ++++++ tools/bpf/bpftool/bash-completion/bpftool | 39 ++ tools/bpf/bpftool/cgroup.c | 48 +-- tools/bpf/bpftool/common.c | 2 + tools/bpf/bpftool/link.c | 333 ++++++++++++++++ tools/bpf/bpftool/main.c | 6 +- tools/bpf/bpftool/main.h | 37 ++ tools/include/uapi/linux/bpf.h | 31 ++ tools/lib/bpf/bpf.c | 19 +- tools/lib/bpf/bpf.h | 4 +- tools/lib/bpf/libbpf.map | 6 + .../selftests/bpf/prog_tests/bpf_obj_id.c | 110 +++++- .../testing/selftests/bpf/progs/test_obj_id.c | 14 +- 22 files changed, 1132 insertions(+), 184 deletions(-) create mode 100644 tools/bpf/bpftool/Documentation/bpftool-link.rst create mode 100644 tools/bpf/bpftool/link.c
Signature · 1 line
2.24.1
PATCH v3 1/10 bpf: refactor bpf_link update handling
Make bpf_link update support more generic by making it into another bpf_link_ops methods. This allows generic syscall handling code to be agnostic to various conditionally compiled features (e.g., the case of CONFIG_CGROUP_BPF). This also allows to keep link type-specific code to remain static within respective code base. Refactor existing bpf_cgroup_link code and take advantage of this.
--- include/linux/bpf-cgroup.h | 12 ------------ include/linux/bpf.h | 3 ++- kernel/bpf/cgroup.c | 30 ++++++++++++++++++++++++++++-- kernel/bpf/syscall.c | 11 ++++------- kernel/cgroup/cgroup.c | 27 --------------------------- 5 files changed, 34 insertions(+), 49 deletions(-)
include/linux/bpf-cgroup.h +0 -12
@@ -100,8 +100,6 @@ int __cgroup_bpf_attach(struct cgroup *cgrp,int __cgroup_bpf_detach (struct cgroup *cgrp,struct bpf_prog *prog,struct bpf_cgroup_link *link,enum bpf_attach_type type); -int __cgroup_bpf_replace (struct cgroup *cgrp,struct bpf_cgroup_link *link, -struct bpf_prog *new_prog);int __cgroup_bpf_query (struct cgroup *cgrp,const union bpf_attr *attr,union bpf_attr __user *uattr);
@@ -112,8 +110,6 @@ int cgroup_bpf_attach(struct cgroup *cgrp, u32 flags);int cgroup_bpf_detach (struct cgroup *cgrp,struct bpf_prog *prog,enum bpf_attach_type type); -int cgroup_bpf_replace (struct bpf_link *link,struct bpf_prog *old_prog, -struct bpf_prog *new_prog);int cgroup_bpf_query (struct cgroup *cgrp,const union bpf_attr *attr,union bpf_attr __user *uattr);
@@ -353,7 +349,6 @@ int cgroup_bpf_prog_query(const union bpf_attr *attr,#else struct bpf_prog ; -struct bpf_link ;struct cgroup_bpf {};static inline int cgroup_bpf_inherit (struct cgroup *cgrp) {return 0 ; }static inline void cgroup_bpf_offline (struct cgroup *cgrp) {}
@@ -377,13 +372,6 @@ static inline int cgroup_bpf_link_attach(const union bpf_attr *attr,return -EINVAL ; } -static inline int cgroup_bpf_replace (struct bpf_link *link, -struct bpf_prog *old_prog, -struct bpf_prog *new_prog) -{ -return -EINVAL ; -} -static inline int cgroup_bpf_prog_query (const union bpf_attr *attr,union bpf_attr __user *uattr) {
include/linux/bpf.h +2 -1
@@ -1093,7 +1093,8 @@ struct bpf_link {struct bpf_link_ops {void (*release)(struct bpf_link *link);void (*dealloc)(struct bpf_link *link); - +int (*update_prog)(struct bpf_link *link,struct bpf_prog *new_prog, +struct bpf_prog *old_prog); }; void bpf_link_init(struct bpf_link *link, const struct bpf_link_ops *ops,
kernel/bpf/cgroup.c +28 -2
@@ -557,8 +557,9 @@ static void replace_effective_prog(struct cgroup *cgrp,* * Must be called with cgroup_mutex held. */ -int __cgroup_bpf_replace (struct cgroup *cgrp,struct bpf_cgroup_link *link, -struct bpf_prog *new_prog) +static int __cgroup_bpf_replace (struct cgroup *cgrp, +struct bpf_cgroup_link *link, +struct bpf_prog *new_prog) {struct list_head *progs = &cgrp->bpf.progs[link->type];struct bpf_prog *old_prog;
@@ -583,6 +584,30 @@ int __cgroup_bpf_replace(struct cgroup *cgrp, struct bpf_cgroup_link *link,return 0 ; } +static int cgroup_bpf_replace (struct bpf_link *link,struct bpf_prog *new_prog, +struct bpf_prog *old_prog) +{ +struct bpf_cgroup_link *cg_link; +int ret; + + cg_link = container_of(link, struct bpf_cgroup_link, link); + +mutex_lock (&cgroup_mutex); +/* link might have been auto-released by dying cgroup, so fail */ +if (!cg_link->cgroup) { + ret = -EINVAL ; + goto out_unlock; + } +if (old_prog && link->prog != old_prog) { + ret = -EPERM ; + goto out_unlock; + } + ret =__cgroup_bpf_replace (cg_link->cgroup, cg_link, new_prog); +out_unlock: +mutex_unlock (&cgroup_mutex); +return ret; +} + static struct bpf_prog_list *find_detach_entry(struct list_head *progs, struct bpf_prog *prog, struct bpf_cgroup_link *link,
@@ -811,6 +836,7 @@ static void bpf_cgroup_link_dealloc(struct bpf_link *link)const struct bpf_link_ops bpf_cgroup_link_lops = { .release = bpf_cgroup_link_release, .dealloc = bpf_cgroup_link_dealloc, + .update_prog = cgroup_bpf_replace, };int cgroup_bpf_link_attach (const union bpf_attr *attr,struct bpf_prog *prog)
kernel/bpf/syscall.c +4 -7
@@ -3645,13 +3645,10 @@ static int link_update(union bpf_attr *attr) goto out_put_progs; } -#ifdef CONFIG_CGROUP_BPF -if (link->ops == &bpf_cgroup_link_lops) { - ret =cgroup_bpf_replace (link, old_prog, new_prog); - goto out_put_progs; - } -#endif - ret = -EINVAL ; +if (link->ops->update_prog) + ret = link->ops->update_prog (link, new_prog, old_prog); +else + ret =EINVAL ; out_put_progs:if (old_prog)
kernel/cgroup/cgroup.c +0 -27
@@ -6508,33 +6508,6 @@ int cgroup_bpf_attach(struct cgroup *cgrp,return ret; } -int cgroup_bpf_replace (struct bpf_link *link,struct bpf_prog *old_prog, -struct bpf_prog *new_prog) -{ -struct bpf_cgroup_link *cg_link; -int ret; - -if (link->ops != &bpf_cgroup_link_lops) -return -EINVAL ; - - cg_link = container_of(link, struct bpf_cgroup_link, link); - -mutex_lock (&cgroup_mutex); -/* link might have been auto-released by dying cgroup, so fail */ -if (!cg_link->cgroup) { - ret = -EINVAL ; - goto out_unlock; - } -if (old_prog && link->prog != old_prog) { - ret = -EPERM ; - goto out_unlock; - } - ret =__cgroup_bpf_replace (cg_link->cgroup, cg_link, new_prog); -out_unlock: -mutex_unlock (&cgroup_mutex); -return ret; -} -int cgroup_bpf_detach (struct cgroup *cgrp,struct bpf_prog *prog,enum bpf_attach_type type) {
Signature · 1 line
2.24.1
PATCH v3 2/10 bpf: allocate ID for bpf_link
In reply to Andrii NakryikoGenerate ID for each bpf_link using IDR, similarly to bpf_map and bpf_prog. bpf_link creation, initialization, attachment, and exposing to user-space through FD and ID is a complicated multi-step process, abstract it away through bpf_link_primer and bpf_link_prime(), bpf_link_settle(), and bpf_link_cleanup() internal API. They guarantee that until bpf_link is properly attached, user-space won't be able to access partially-initialized bpf_link either from FD or ID. All this allows to simplify bpf_link attachment and error handling code.
--- include/linux/bpf.h | 17 +++-- include/uapi/linux/bpf.h | 1 + kernel/bpf/cgroup.c | 14 ++-- kernel/bpf/syscall.c | 143 +++++++++++++++++++++++++++------------ 4 files changed, 118 insertions(+), 57 deletions(-)
include/linux/bpf.h +13 -4
@@ -1085,11 +1085,19 @@ int bpf_prog_new_fd(struct bpf_prog *prog);struct bpf_link {atomic64_t refcnt; +u32 id;const struct bpf_link_ops *ops;struct bpf_prog *prog;struct work_struct work; }; +struct bpf_link_primer { +struct bpf_link *link; +struct file *file; +int fd; +u32 id; +}; +struct bpf_link_ops {void (*release)(struct bpf_link *link);void (*dealloc)(struct bpf_link *link);
@@ -1097,10 +1105,11 @@ struct bpf_link_ops { struct bpf_prog *old_prog); }; -void bpf_link_init (struct bpf_link *link,const struct bpf_link_ops *ops, -struct bpf_prog *prog); -void bpf_link_cleanup (struct bpf_link *link,struct file *link_file, -int link_fd); +void bpf_link_init (struct bpf_link *link, +const struct bpf_link_ops *ops,struct bpf_prog *prog); +int bpf_link_prime (struct bpf_link *link,struct bpf_link_primer *primer); +int bpf_link_settle (struct bpf_link_primer *primer); +void bpf_link_cleanup (struct bpf_link_primer *primer);void bpf_link_inc (struct bpf_link *link);void bpf_link_put (struct bpf_link *link);int bpf_link_new_fd (struct bpf_link *link);
include/uapi/linux/bpf.h +1 -0
@@ -523,6 +523,7 @@ union bpf_attr {__u32 prog_id;__u32 map_id;__u32 btf_id; +__u32 link_id; };__u32 next_id;__u32 open_flags;
kernel/bpf/cgroup.c +6 -8
@@ -841,10 +841,10 @@ const struct bpf_link_ops bpf_cgroup_link_lops = {int cgroup_bpf_link_attach (const union bpf_attr *attr,struct bpf_prog *prog) { +struct bpf_link_primer link_primer;struct bpf_cgroup_link *link; -struct file *link_file;struct cgroup *cgrp; -int err, link_fd; +int err;if (attr->link_create.flags)return -EINVAL ;
@@ -862,22 +862,20 @@ int cgroup_bpf_link_attach(const union bpf_attr *attr, struct bpf_prog *prog) link->cgroup = cgrp; link->type = attr->link_create.attach_type; - link_file =bpf_link_new_file (&link->link, &link_fd); -if (IS_ERR (link_file)) { + err =bpf_link_prime (&link->link, &link_primer); +if (err) {kfree (link); - err =PTR_ERR (link_file); goto out_put_cgroup; } err =cgroup_bpf_attach (cgrp,NULL ,NULL , link, link->type,BPF_F_ALLOW_MULTI );if (err) { -bpf_link_cleanup (&link->link, link_file, link_fd); +bpf_link_cleanup (&link_primer); goto out_put_cgroup; } -fd_install (link_fd, link_file); -return link_fd; +return bpf_link_settle (&link_primer); out_put_cgroup:cgroup_put (cgrp);
kernel/bpf/syscall.c +98 -45
262 lines not on this page · raw message
Signature · 1 line
2.24.1
PATCH v3 3/10 bpf: support GET_FD_BY_ID and GET_NEXT_ID for bpf_link
In reply to Andrii NakryikoAdd support to look up bpf_link by ID and iterate over all existing bpf_links in the system. GET_FD_BY_ID code handles not-yet-ready bpf_link by checking that its ID hasn't been set to non-zero value yet. Setting bpf_link's ID is done as the very last step in finalizing bpf_link, together with installing FD. This approach allows users of bpf_link in kernel code to not worry about races between user-space and kernel code that hasn't finished attaching and initializing bpf_link.
--- include/uapi/linux/bpf.h | 2 ++ kernel/bpf/syscall.c | 49 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 51 insertions(+)
include/uapi/linux/bpf.h +2 -0
@@ -113,6 +113,8 @@ enum bpf_cmd {BPF_MAP_DELETE_BATCH ,BPF_LINK_CREATE ,BPF_LINK_UPDATE , +BPF_LINK_GET_FD_BY_ID , + BPF_LINK_GET_NEXT_ID, }; enum bpf_map_type {
kernel/bpf/syscall.c +49 -0
61 lines not on this page · raw message
Signature · 1 line
2.24.1
PATCH v3 4/10 bpf: add support for BPF_OBJ_GET_INFO_BY_FD for bpf_link
In reply to Andrii NakryikoAdd ability to fetch bpf_link details through BPF_OBJ_GET_INFO_BY_FD command. Also enhance show_fdinfo to potentially include bpf_link type-specific information (similarly to obj_info).
Also introduce enum bpf_link_type stored in bpf_link itself and expose it in UAPI. bpf_link_tracing also now will store and return bpf_attach_type.
--- include/linux/bpf-cgroup.h | 2 - include/linux/bpf.h | 8 +- include/linux/bpf_types.h | 6 ++ include/uapi/linux/bpf.h | 28 ++++++ kernel/bpf/btf.c | 2 + kernel/bpf/cgroup.c | 43 ++++++++- kernel/bpf/syscall.c | 155 +++++++++++++++++++++++++++++---- kernel/bpf/verifier.c | 2 + tools/include/uapi/linux/bpf.h | 31 +++++++ 9 files changed, 253 insertions(+), 24 deletions(-)
include/linux/bpf-cgroup.h +0 -2
@@ -57,8 +57,6 @@ struct bpf_cgroup_link {enum bpf_attach_type type; }; -extern const struct bpf_link_ops bpf_cgroup_link_lops; -struct bpf_prog_list {struct list_head node;struct bpf_prog *prog;
include/linux/bpf.h +7 -1
@@ -1026,9 +1026,11 @@ extern const struct file_operations bpf_prog_fops; extern const struct bpf_verifier_ops _name ## _verifier_ops;#define BPF_MAP_TYPE (_id, _ops) \ extern const struct bpf_map_ops _ops; +#define BPF_LINK_TYPE (_id, _name)#include <linux/bpf_types.h> #undef BPF_PROG_TYPE#undef BPF_MAP_TYPE +#undef BPF_LINK_TYPEextern const struct bpf_prog_ops bpf_offload_prog_ops;extern const struct bpf_verifier_ops tc_cls_act_analyzer_ops;
@@ -1086,6 +1088,7 @@ int bpf_prog_new_fd(struct bpf_prog *prog);struct bpf_link {atomic64_t refcnt;u32 id; +enum bpf_link_type type;const struct bpf_link_ops *ops;struct bpf_prog *prog;struct work_struct work;
@@ -1103,9 +1106,12 @@ struct bpf_link_ops {void (*dealloc)(struct bpf_link *link);int (*update_prog)(struct bpf_link *link,struct bpf_prog *new_prog,struct bpf_prog *old_prog); +void (*show_fdinfo)(const struct bpf_link *link,struct seq_file *seq); +int (*fill_link_info)(const struct bpf_link *link, +struct bpf_link_info *info); }; -void bpf_link_init (struct bpf_link *link, +void bpf_link_init (struct bpf_link *link,enum bpf_link_type type,const struct bpf_link_ops *ops,struct bpf_prog *prog);int bpf_link_prime (struct bpf_link *link,struct bpf_link_primer *primer);int bpf_link_settle (struct bpf_link_primer *primer);
include/linux/bpf_types.h +6 -0
@@ -118,3 +118,9 @@ BPF_MAP_TYPE(BPF_MAP_TYPE_STACK, stack_map_ops)#if defined(CONFIG_BPF_JIT ) BPF_MAP_TYPE(BPF_MAP_TYPE_STRUCT_OPS, bpf_struct_ops_map_ops)#endif + +BPF_LINK_TYPE(BPF_LINK_TYPE_RAW_TRACEPOINT, raw_tracepoint) +BPF_LINK_TYPE(BPF_LINK_TYPE_TRACING, tracing) +#ifdef CONFIG_CGROUP_BPF +BPF_LINK_TYPE(BPF_LINK_TYPE_CGROUP, cgroup) +#endif
include/uapi/linux/bpf.h +28 -0
@@ -222,6 +222,15 @@ enum bpf_attach_type {#define MAX_BPF_ATTACH_TYPE __MAX_BPF_ATTACH_TYPE +enum bpf_link_type { +BPF_LINK_TYPE_UNSPEC =0 , +BPF_LINK_TYPE_RAW_TRACEPOINT =1 , +BPF_LINK_TYPE_TRACING =2 , +BPF_LINK_TYPE_CGROUP =3 , + +MAX_BPF_LINK_TYPE , +}; +/* cgroup-bpf attach flags used in BPF_PROG_ATTACH command * * NONE(default): No further bpf programs allowed in the subtree.
@@ -3612,6 +3621,25 @@ struct bpf_btf_info {__u32 id; } __attribute__((aligned(8))); +struct bpf_link_info { +__u32 type; +__u32 id; +__u32 prog_id; +union { +struct { +__aligned_u64 tp_name;/* in/out: tp_name buffer ptr */ +__u32 tp_name_len;/* in/out: tp_name buffer len */ + } raw_tracepoint; +struct { +__u32 attach_type; + } tracing; +struct { +__u64 cgroup_id; +__u32 attach_type; + } cgroup; + }; +} __attribute__((aligned (8 ))); +/* User bpf_sock_addr struct to access socket fields and sockaddr struct passed * by user and intended to be used by socket (e.g. to bind to, depends on * attach attach type).
kernel/bpf/btf.c +2 -0
@@ -3482,6 +3482,7 @@ extern char __weak __stop_BTF[];extern struct btf *btf_vmlinux;#define BPF_MAP_TYPE (_id, _ops) +#define BPF_LINK_TYPE (_id, _name) static union { struct bpf_ctx_convert { #define BPF_PROG_TYPE(_id, _name, prog_ctx_type, kern_ctx_type) \
@@ -3508,6 +3509,7 @@ static u8 bpf_ctx_convert_map[] = { 0, /* avoid empty array */ };#undef BPF_MAP_TYPE +#undef BPF_LINK_TYPEstatic const struct btf_member * btf_get_prog_ctx_type(struct bpf_verifier_log *log, struct btf *btf,
kernel/bpf/cgroup.c +41 -2
58 lines not on this page · raw message
kernel/bpf/syscall.c +136 -19
251 lines not on this page · raw message
kernel/bpf/verifier.c +2 -0
@@ -28,9 +28,11 @@ static const struct bpf_verifier_ops * const bpf_verifier_ops[] = {#define BPF_PROG_TYPE (_id, _name, prog_ctx_type, kern_ctx_type) \ [_id] = & _name ## _verifier_ops,#define BPF_MAP_TYPE (_id, _ops) +#define BPF_LINK_TYPE (_id, _name)#include <linux/bpf_types.h> #undef BPF_PROG_TYPE#undef BPF_MAP_TYPE +#undef BPF_LINK_TYPE };/* bpf_check() is a static code analyzer that walks eBPF program
tools/include/uapi/linux/bpf.h +31 -0
@@ -113,6 +113,8 @@ enum bpf_cmd {BPF_MAP_DELETE_BATCH ,BPF_LINK_CREATE ,BPF_LINK_UPDATE , +BPF_LINK_GET_FD_BY_ID , + BPF_LINK_GET_NEXT_ID, }; enum bpf_map_type {
@@ -220,6 +222,15 @@ enum bpf_attach_type {#define MAX_BPF_ATTACH_TYPE __MAX_BPF_ATTACH_TYPE +enum bpf_link_type { +BPF_LINK_TYPE_UNSPEC =0 , +BPF_LINK_TYPE_RAW_TRACEPOINT =1 , +BPF_LINK_TYPE_TRACING =2 , +BPF_LINK_TYPE_CGROUP =3 , + +MAX_BPF_LINK_TYPE , +}; +/* cgroup-bpf attach flags used in BPF_PROG_ATTACH command * * NONE(default): No further bpf programs allowed in the subtree.
@@ -523,6 +534,7 @@ union bpf_attr {__u32 prog_id;__u32 map_id;__u32 btf_id; +__u32 link_id; };__u32 next_id;__u32 open_flags;
@@ -3609,6 +3621,25 @@ struct bpf_btf_info {__u32 id; } __attribute__((aligned(8))); +struct bpf_link_info { +__u32 type; +__u32 id; +__u32 prog_id; +union { +struct { +__aligned_u64 tp_name;/* in/out: tp_name buffer ptr */ +__u32 tp_name_len;/* in/out: tp_name buffer len */ + } raw_tracepoint; +struct { +__u32 attach_type; + } tracing; +struct { +__u64 cgroup_id; +__u32 attach_type; + } cgroup; + }; +} __attribute__((aligned (8 ))); +/* User bpf_sock_addr struct to access socket fields and sockaddr struct passed * by user and intended to be used by socket (e.g. to bind to, depends on * attach attach type).
Signature · 1 line
2.24.1
PATCH v3 5/10 libbpf: add low-level APIs for new bpf_link commands
In reply to Andrii NakryikoAdd low-level API calls for bpf_link_get_next_id() and bpf_link_get_fd_by_id().
--- tools/lib/bpf/bpf.c | 19 +++++++++++++++++-- tools/lib/bpf/bpf.h | 4 +++- tools/lib/bpf/libbpf.map | 6 ++++++ 3 files changed, 26 insertions(+), 3 deletions(-)
tools/lib/bpf/bpf.c +17 -2
@@ -721,6 +721,11 @@ int bpf_btf_get_next_id(__u32 start_id, __u32 *next_id)return bpf_obj_get_next_id (start_id, next_id,BPF_BTF_GET_NEXT_ID ); } +int bpf_link_get_next_id (__u32 start_id,__u32 *next_id) +{ +return bpf_obj_get_next_id (start_id, next_id,BPF_LINK_GET_NEXT_ID ); +} +int bpf_prog_get_fd_by_id (__u32 id) {union bpf_attr attr;
@@ -751,13 +756,23 @@ int bpf_btf_get_fd_by_id(__u32 id)return sys_bpf (BPF_BTF_GET_FD_BY_ID , &attr,sizeof (attr)); } -int bpf_obj_get_info_by_fd (int prog_fd,void *info,__u32 *info_len) +int bpf_link_get_fd_by_id (__u32 id) +{ +union bpf_attr attr; + +memset (&attr,0 ,sizeof (attr)); + attr.link_id = id; + +return sys_bpf (BPF_LINK_GET_FD_BY_ID , &attr,sizeof (attr)); +} + +int bpf_obj_get_info_by_fd (int bpf_fd,void *info,__u32 *info_len) {union bpf_attr attr;int err;memset (&attr,0 ,sizeof (attr)); - attr.info.bpf_fd = prog_fd; + attr.info.bpf_fd = bpf_fd; attr.info.info_len = *info_len; attr.info.info =ptr_to_u64 (info);
tools/lib/bpf/bpf.h +3 -1
@@ -216,10 +216,12 @@ LIBBPF_API int bpf_prog_test_run(int prog_fd, int repeat, void *data, LIBBPF_API int bpf_prog_get_next_id(__u32 start_id, __u32 *next_id); LIBBPF_API int bpf_map_get_next_id(__u32 start_id, __u32 *next_id); LIBBPF_API int bpf_btf_get_next_id(__u32 start_id, __u32 *next_id); +LIBBPF_API int bpf_link_get_next_id(__u32 start_id, __u32 *next_id); LIBBPF_API int bpf_prog_get_fd_by_id(__u32 id); LIBBPF_API int bpf_map_get_fd_by_id(__u32 id); LIBBPF_API int bpf_btf_get_fd_by_id(__u32 id); -LIBBPF_API int bpf_obj_get_info_by_fd(int prog_fd, void *info, __u32 *info_len); +LIBBPF_API int bpf_link_get_fd_by_id(__u32 id); +LIBBPF_API int bpf_obj_get_info_by_fd(int bpf_fd, void *info, __u32 *info_len); LIBBPF_API int bpf_prog_query(int target_fd, enum bpf_attach_type type,__u32 query_flags,__u32 *attach_flags,__u32 *prog_ids,__u32 *prog_cnt);
tools/lib/bpf/libbpf.map +6 -0
@@ -254,3 +254,9 @@ LIBBPF_0.0.8 { bpf_program__set_lsm; bpf_set_link_xdp_fd_opts; } LIBBPF_0.0.7; + +LIBBPF_0.0.9 { + global: + bpf_link_get_fd_by_id; + bpf_link_get_next_id; +} LIBBPF_0.0.8;
Signature · 1 line
2.24.1
PATCH v3 6/10 selftests/bpf: test bpf_link's get_next_id, get_fd_by_id, and get_obj_info
In reply to Andrii NakryikoExtend bpf_obj_id selftest to verify bpf_link's observability APIs.
--- .../selftests/bpf/prog_tests/bpf_obj_id.c | 110 ++++++++++++++++-- .../testing/selftests/bpf/progs/test_obj_id.c | 14 +-- 2 files changed, 104 insertions(+), 20 deletions(-)
tools/testing/selftests/bpf/prog_tests/bpf_obj_id.c +101 -9
@@ -1,26 +1,30 @@// SPDX-License-Identifier: GPL-2.0 #include <test_progs.h> +#define nr_iters 2 +void test_bpf_obj_id (void ) {const __u64 array_magic_value =0xfaceb00c ;const __u32 array_key =0 ; -const int nr_iters =2 ;const char *file ="./test_obj_id.o" ;const char *expected_prog_name ="test_obj_id" ;const char *expected_map_name ="test_map_id" ;const __u64 nsec_per_sec =1000000000 ; -struct bpf_object *objs[nr_iters]; +struct bpf_object *objs[nr_iters] = {}; +struct bpf_link *links[nr_iters] = {}; +struct bpf_program *prog;int prog_fds[nr_iters], map_fds[nr_iters];/* +1 to test for the info_len returned by kernel */ struct bpf_prog_info prog_infos[nr_iters +1 ];struct bpf_map_info map_infos[nr_iters +1 ]; +struct bpf_link_info link_infos[nr_iters +1 ];/* Each prog only uses one map. +1 to test nr_map_ids * returned by kernel. */ __u32 map_ids[nr_iters +1 ]; -char jited_insns[128 ], xlated_insns[128 ], zeros[128 ]; +char jited_insns[128 ], xlated_insns[128 ], zeros[128 ], tp_name[128 ];__u32 i, next_id, info_len, nr_id_found, duration =0 ;struct timespec real_time_ts, boot_time_ts;int err =0 ;
@@ -36,14 +40,15 @@ void test_bpf_obj_id(void)CHECK (err >=0 || errno !=ENOENT ,"get-fd-by-notexist-map-id" ,"err %d errno %d\n" , err, errno); -for (i =0 ; i < nr_iters; i++) - objs[i] =NULL ; + err =bpf_link_get_fd_by_id (0 ); +CHECK (err >=0 || errno !=ENOENT , +"get-fd-by-notexist-link-id" ,"err %d errno %d\n" , err, errno);/* Check bpf_obj_get_info_by_fd() */ bzero (zeros,sizeof (zeros));for (i =0 ; i < nr_iters; i++) { now =time (NULL ); - err =bpf_prog_load (file,BPF_PROG_TYPE_SOCKET_FILTER , + err =bpf_prog_load (file,BPF_PROG_TYPE_RAW_TRACEPOINT , &objs[i], &prog_fds[i]);/* test_obj_id.o is a dumb prog. It should never fail * to load.
@@ -60,6 +65,17 @@ void test_bpf_obj_id(void)if (CHECK_FAIL (err)) goto done; + prog =bpf_object__find_program_by_title (objs[i], +"raw_tp/sys_enter" ); +if (CHECK_FAIL (!prog)) + goto done; + links[i] =bpf_program__attach (prog); + err =libbpf_get_error (links[i]); +if (CHECK (err,"prog_attach" ,"prog #%d, err %d\n" , i, err)) { + links[i] =NULL ; + goto done; + } +/* Check getting map info */ info_len =sizeof (struct bpf_map_info ) *2 ;bzero (&map_infos[i], info_len);
@@ -107,7 +123,7 @@ void test_bpf_obj_id(void) load_time = (real_time_ts.tv_sec - boot_time_ts.tv_sec) + (prog_infos[i].load_time / nsec_per_sec); if (CHECK(err || - prog_infos[i].type != BPF_PROG_TYPE_SOCKET_FILTER || + prog_infos[i].type != BPF_PROG_TYPE_RAW_TRACEPOINT || info_len != sizeof(struct bpf_prog_info) || (env.jit_enabled && !prog_infos[i].jited_prog_len) || (env.jit_enabled &&
@@ -120,7 +136,11 @@ void test_bpf_obj_id(void) *(int *)(long )prog_infos[i].map_ids != map_infos[i].id ||strcmp ((char *)prog_infos[i].name, expected_prog_name),"get-prog-info(fd)" , -"err %d errno %d i %d type %d(%d) info_len %u(%zu) jit_enabled %d jited_prog_len %u xlated_prog_len %u jited_prog %d xlated_prog %d load_time %lu(%lu) uid %u(%u) nr_map_ids %u(%u) map_id %u(%u) name %s(%s)\n" , +"err %d errno %d i %d type %d(%d) info_len %u(%zu) " +"jit_enabled %d jited_prog_len %u xlated_prog_len %u " +"jited_prog %d xlated_prog %d load_time %lu(%lu) " +"uid %u(%u) nr_map_ids %u(%u) map_id %u(%u) " +"name %s(%s)\n" , err, errno, i, prog_infos[i].type,BPF_PROG_TYPE_SOCKET_FILTER , info_len, sizeof(struct bpf_prog_info),
@@ -135,6 +155,33 @@ void test_bpf_obj_id(void) *(int *)(long)prog_infos[i].map_ids, map_infos[i].id, prog_infos[i].name, expected_prog_name)) goto done; + +/* Check getting link info */ + info_len =sizeof (struct bpf_link_info ) *2 ; +bzero (&link_infos[i], info_len); + link_infos[i].raw_tracepoint.tp_name = (__u64)&tp_name; + link_infos[i].raw_tracepoint.tp_name_len =sizeof (tp_name); + err =bpf_obj_get_info_by_fd (bpf_link__fd (links[i]), + &link_infos[i], &info_len); +if (CHECK (err || + link_infos[i].type !=BPF_LINK_TYPE_RAW_TRACEPOINT || + link_infos[i].prog_id != prog_infos[i].id || + link_infos[i].raw_tracepoint.tp_name != (__u64)&tp_name || +strcmp ((char *)link_infos[i].raw_tracepoint.tp_name, +"sys_enter" ) || + info_len !=sizeof (struct bpf_link_info ), +"get-link-info(fd)" , +"err %d errno %d info_len %u(%zu) type %d(%d) id %d " +"prog_id %d (%d) tp_name %s(%s)\n" , + err, errno, + info_len,sizeof (struct bpf_link_info ), + link_infos[i].type,BPF_LINK_TYPE_RAW_TRACEPOINT , + link_infos[i].id, + link_infos[i].prog_id, prog_infos[i].id, + (char *)link_infos[i].raw_tracepoint.tp_name, +"sys_enter" )) + goto done; + }/* Check bpf_prog_get_next_id() */
@@ -247,7 +294,52 @@ void test_bpf_obj_id(void)"nr_id_found %u(%u)\n" , nr_id_found, nr_iters); +/* Check bpf_link_get_next_id() */ + nr_id_found =0 ; + next_id =0 ; +while (!bpf_link_get_next_id (next_id, &next_id)) { +struct bpf_link_info link_info; +int link_fd, cmp_res; + + info_len =sizeof (link_info); +memset (&link_info,0 , info_len); + + link_fd =bpf_link_get_fd_by_id (next_id); +if (link_fd <0 && errno ==ENOENT ) +/* The bpf_link is in the dead row */ +continue ; +if (CHECK (link_fd <0 ,"get-link-fd(next_id)" , +"link_fd %d next_id %u errno %d\n" , + link_fd, next_id, errno)) +break ; + +for (i =0 ; i < nr_iters; i++) +if (link_infos[i].id == next_id) +break ; + +if (i == nr_iters) +continue ; + + nr_id_found++; + + err =bpf_obj_get_info_by_fd (link_fd, &link_info, &info_len); + cmp_res =memcmp (&link_info, &link_infos[i], + offsetof(struct bpf_link_info , raw_tracepoint)); +CHECK (err || info_len !=sizeof (link_info) || cmp_res, +"check get-link-info(next_id->fd)" , +"err %d errno %d info_len %u(%zu) memcmp %d\n" , + err, errno, info_len,sizeof (struct bpf_link_info ), + cmp_res); + +close (link_fd); + } +CHECK (nr_id_found != nr_iters, +"check total link id found by get_next_id" , +"nr_id_found %u(%u)\n" , nr_id_found, nr_iters); + done: -for (i =0 ; i < nr_iters; i++) +for (i =0 ; i < nr_iters; i++) { +bpf_link__destroy (links[i]);bpf_object__close (objs[i]); + } }
tools/testing/selftests/bpf/progs/test_obj_id.c +3 -11
@@ -3,16 +3,8 @@*/ #include <stddef.h> #include <linux/bpf.h> -#include <linux/pkt_cls.h> #include <bpf/bpf_helpers.h> -/* It is a dumb bpf program such that it must have no -* issue to be loaded since testing the verifier is -* not the focus here. -*/ - -int _version SEC("version") = 1; -struct { __uint(type, BPF_MAP_TYPE_ARRAY); __uint(max_entries, 1);
@@ -20,13 +12,13 @@ struct {__type (value, __u64); } test_map_id SEC(".maps"); -SEC("test_obj_id_dummy") -int test_obj_id (struct __sk_buff *skb) +SEC("raw_tp/sys_enter") +int test_obj_id (void *ctx) {__u32 key =0 ;__u64 *value; value =bpf_map_lookup_elem (&test_map_id, &key); -return TC_ACT_OK ; +return 0 ; }
Signature · 1 line
2.24.1
PATCH v3 7/10 bpftool: expose attach_type-to-string array to non-cgroup code
In reply to Andrii NakryikoMove attach_type_strings into main.h for access in non-cgroup code. bpf_attach_type is used for non-cgroup attach types quite widely now. So also complete missing string translations for non-cgroup attach types.
--- tools/bpf/bpftool/cgroup.c | 48 ++++++++++++-------------------------- tools/bpf/bpftool/main.h | 32 +++++++++++++++++++++++++ 2 files changed, 47 insertions(+), 33 deletions(-)
tools/bpf/bpftool/cgroup.c +15 -33
@@ -31,42 +31,20 @@static unsigned int query_flags; -static const char *const attach_type_strings[] = { - [BPF_CGROUP_INET_INGRESS ] ="ingress" , - [BPF_CGROUP_INET_EGRESS ] ="egress" , - [BPF_CGROUP_INET_SOCK_CREATE ] ="sock_create" , - [BPF_CGROUP_SOCK_OPS ] ="sock_ops" , - [BPF_CGROUP_DEVICE ] ="device" , - [BPF_CGROUP_INET4_BIND ] ="bind4" , - [BPF_CGROUP_INET6_BIND ] ="bind6" , - [BPF_CGROUP_INET4_CONNECT ] ="connect4" , - [BPF_CGROUP_INET6_CONNECT ] ="connect6" , - [BPF_CGROUP_INET4_POST_BIND ] ="post_bind4" , - [BPF_CGROUP_INET6_POST_BIND ] ="post_bind6" , - [BPF_CGROUP_UDP4_SENDMSG ] ="sendmsg4" , - [BPF_CGROUP_UDP6_SENDMSG ] ="sendmsg6" , - [BPF_CGROUP_SYSCTL ] ="sysctl" , - [BPF_CGROUP_UDP4_RECVMSG ] ="recvmsg4" , - [BPF_CGROUP_UDP6_RECVMSG ] ="recvmsg6" , - [BPF_CGROUP_GETSOCKOPT ] ="getsockopt" , - [BPF_CGROUP_SETSOCKOPT ] ="setsockopt" , - [__MAX_BPF_ATTACH_TYPE] =NULL , -}; -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_type_strings[type] && -is_prefix (str, attach_type_strings[type])) +if (attach_type_name[type] && +is_prefix (str, attach_type_name[type]))return type; }return __MAX_BPF_ATTACH_TYPE; } -static int show_bpf_prog (int id,const char *attach_type_str, +static int show_bpf_prog (int id,enum bpf_attach_type attach_type,const char *attach_flags_str,int level) {
@@ -86,18 +64,22 @@ static int show_bpf_prog(int id, const char *attach_type_str,if (json_output) {jsonw_start_object (json_wtr);jsonw_uint_field (json_wtr,"id" , info.id); -jsonw_string_field (json_wtr,"attach_type" , - attach_type_str); +if (attach_type <ARRAY_SIZE (attach_type_name)) +jsonw_string_field (json_wtr,"attach_type" , + attach_type_name[attach_type]); +else +jsonw_uint_field (json_wtr,"attach_type" , attach_type);jsonw_string_field (json_wtr,"attach_flags" , attach_flags_str);jsonw_string_field (json_wtr,"name" , info.name);jsonw_end_object (json_wtr); }else { -printf ("%s%-8u %-15s %-15s %-15s\n" , level ?" " :"" , - info.id, - attach_type_str, - attach_flags_str, - info.name); +printf ("%s%-8u " , level ?" " :"" , info.id); +if (attach_type <ARRAY_SIZE (attach_type_name)) +printf ("%-15s" , attach_type_name[attach_type]); +else +printf ("type %-10u" , attach_type); +printf (" %-15s %-15s\n" , attach_flags_str, info.name); }close (prog_fd);
@@ -171,7 +153,7 @@ static int show_attached_bpf_progs(int cgroup_fd, enum bpf_attach_type type, }for (iter =0 ; iter < prog_cnt; iter++) -show_bpf_prog (prog_ids[iter], attach_type_strings[type], +show_bpf_prog (prog_ids[iter], type, attach_flags_str, level);return 0 ;
tools/bpf/bpftool/main.h +32 -0
@@ -83,6 +83,38 @@ static const char * const prog_type_name[] = { [BPF_PROG_TYPE_EXT] = "ext", }; +static const char *const attach_type_name[__MAX_BPF_ATTACH_TYPE] = { + [BPF_CGROUP_INET_INGRESS ] ="ingress" , + [BPF_CGROUP_INET_EGRESS ] ="egress" , + [BPF_CGROUP_INET_SOCK_CREATE ] ="sock_create" , + [BPF_CGROUP_SOCK_OPS ] ="sock_ops" , + [BPF_CGROUP_DEVICE ] ="device" , + [BPF_CGROUP_INET4_BIND ] ="bind4" , + [BPF_CGROUP_INET6_BIND ] ="bind6" , + [BPF_CGROUP_INET4_CONNECT ] ="connect4" , + [BPF_CGROUP_INET6_CONNECT ] ="connect6" , + [BPF_CGROUP_INET4_POST_BIND ] ="post_bind4" , + [BPF_CGROUP_INET6_POST_BIND ] ="post_bind6" , + [BPF_CGROUP_UDP4_SENDMSG ] ="sendmsg4" , + [BPF_CGROUP_UDP6_SENDMSG ] ="sendmsg6" , + [BPF_CGROUP_SYSCTL ] ="sysctl" , + [BPF_CGROUP_UDP4_RECVMSG ] ="recvmsg4" , + [BPF_CGROUP_UDP6_RECVMSG ] ="recvmsg6" , + [BPF_CGROUP_GETSOCKOPT ] ="getsockopt" , + [BPF_CGROUP_SETSOCKOPT ] ="setsockopt" , + + [BPF_SK_SKB_STREAM_PARSER ] ="sk_skb_stream_parser" , + [BPF_SK_SKB_STREAM_VERDICT ] ="sk_skb_stream_verdict" , + [BPF_SK_MSG_VERDICT ] ="sk_msg_verdict" , + [BPF_LIRC_MODE2 ] ="lirc_mode2" , + [BPF_FLOW_DISSECTOR ] ="flow_dissector" , + [BPF_TRACE_RAW_TP ] ="raw_tp" , + [BPF_TRACE_FENTRY ] ="fentry" , + [BPF_TRACE_FEXIT ] ="fexit" , + [BPF_MODIFY_RETURN ] ="mod_ret" , + [BPF_LSM_MAC ] ="lsm_mac" , +}; +extern const char *const map_type_name[];extern const size_t map_type_name_size;
Signature · 1 line
2.24.1
PATCH v3 8/10 bpftool: add bpf_link show and pin support
In reply to Andrii NakryikoAdd bpftool link show and bpftool link pin commands.
Example plain output for link show (with showing pinned paths):
[vmuser@archvm bpf]$ sudo ~/local/linux/tools/bpf/bpftool/bpftool -f link 1: tracing prog 12
prog_type tracing attach_type fentry
pinned /sys/fs/bpf/my_test_link
pinned /sys/fs/bpf/my_test_link2
2: tracing prog 13
prog_type tracing attach_type fentry
3: tracing prog 14
prog_type tracing attach_type fentry
4: tracing prog 15
prog_type tracing attach_type fentry
5: tracing prog 16
prog_type tracing attach_type fentry
6: tracing prog 17
prog_type tracing attach_type fentry
7: raw_tracepoint prog 21
tp 'sys_enter'
8: cgroup prog 25
cgroup_id 584 attach_type egress
9: cgroup prog 25
cgroup_id 599 attach_type egress
10: cgroup prog 25
cgroup_id 614 attach_type egress
11: cgroup prog 25
cgroup_id 629 attach_type egress
--- tools/bpf/bpftool/common.c | 2 + tools/bpf/bpftool/link.c | 333 +++++++++++++++++++++++++++++++++++++ tools/bpf/bpftool/main.c | 6 +- tools/bpf/bpftool/main.h | 5 + 4 files changed, 345 insertions(+), 1 deletion(-) create mode 100644 tools/bpf/bpftool/link.c
tools/bpf/bpftool/common.c +2 -0
@@ -262,6 +262,8 @@ int get_fd_type(int fd)return BPF_OBJ_MAP ; else if (strstr(buf, "bpf-prog")) return BPF_OBJ_PROG; + else if (strstr(buf, "bpf-link")) + return BPF_OBJ_LINK;return BPF_OBJ_UNKNOWN ; }
tools/bpf/bpftool/link.c new file +333 -0
333 lines not on this page · raw message
tools/bpf/bpftool/main.c +5 -1
@@ -30,6 +30,7 @@ bool verifier_logs;bool relaxed_maps;struct pinned_obj_table prog_table;struct pinned_obj_table map_table; +struct pinned_obj_table link_table;static void __noreturn clean_and_exit (int i) {
@@ -58,7 +59,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 | struct_ops }\n" +" OBJECT := { prog | map | link | cgroup | perf | net | feature | btf | gen | struct_ops }\n" " " HELP_SPEC_OPTIONS "\n" "" , bin_name, bin_name, bin_name);
@@ -215,6 +216,7 @@ static const struct cmd cmds[] = { { "batch", do_batch }, { "prog", do_prog }, { "map", do_map }, + { "link", do_link }, { "cgroup", do_cgroup }, { "perf", do_perf }, { "net", do_net },
@@ -364,6 +366,7 @@ int main(int argc, char **argv)hash_init (prog_table.table);hash_init (map_table.table); +hash_init (link_table.table); opterr =0 ; while ((opt = getopt_long(argc, argv, "Vhpjfmnd",
@@ -422,6 +425,7 @@ int main(int argc, char **argv)if (show_pinned) {delete_pinned_obj_table (&prog_table);delete_pinned_obj_table (&map_table); +delete_pinned_obj_table (&link_table); }return ret;
tools/bpf/bpftool/main.h +5 -0
@@ -50,6 +50,8 @@ "\t {-m|--mapcompat} | {-n|--nomount} }"#define HELP_SPEC_MAP \ "MAP := { id MAP_ID | pinned FILE | name MAP_NAME }" +#define HELP_SPEC_LINK \ + "LINK := { id LINK_ID | pinned FILE }"static const char *const prog_type_name[] = { [BPF_PROG_TYPE_UNSPEC ] ="unspec" ,
@@ -122,6 +124,7 @@ enum bpf_obj_type {BPF_OBJ_UNKNOWN ,BPF_OBJ_PROG ,BPF_OBJ_MAP , + BPF_OBJ_LINK, };extern const char *bin_name;
@@ -134,6 +137,7 @@ extern bool verifier_logs;extern bool relaxed_maps;extern struct pinned_obj_table prog_table;extern struct pinned_obj_table map_table; +extern struct pinned_obj_table link_table; void __printf(1, 2) p_err(const char *fmt, ...); void __printf(1, 2) p_info(const char *fmt, ...);
@@ -185,6 +189,7 @@ int do_pin_fd(int fd, const char *name);int do_prog (int argc,char **arg);int do_map (int argc,char **arg); +int do_link (int argc,char **arg);int do_event_pipe (int argc,char **argv);int do_cgroup (int argc,char **arg);int do_perf (int argc,char **arg);
Signature · 1 line
2.24.1
PATCH v3 9/10 bpftool: add bpftool-link manpage
In reply to Andrii NakryikoAdd bpftool-link manpage with information and examples of link-related commands.
--- .../bpftool/Documentation/bpftool-link.rst | 118 ++++++++++++++++++ 1 file changed, 118 insertions(+) create mode 100644 tools/bpf/bpftool/Documentation/bpftool-link.rst
tools/bpf/bpftool/Documentation/bpftool-link.rst new file +118 -0
@@ -0,0 +1,118 @@ +================ +bpftool-link +================ +------------------------------------------------------------------------------- +tool for inspection and simple manipulation of eBPF links +------------------------------------------------------------------------------- + +:Manual section: 8 + +SYNOPSIS +======== + + **bpftool** [*OPTIONS*] **link** *COMMAND* + + *OPTIONS* := { { **-j** | **--json** } [{ **-p** | **--pretty** }] | { **-f** | **--bpffs** } } + + *COMMANDS* := { **show** | **list** | **pin** | **help** } + +LINK COMMANDS +============= + +| **bpftool** **link { show | list }** [*LINK*] +| **bpftool** **link pin** *LINK* *FILE* +| **bpftool** **link help** +| +| *LINK* := { **id** *LINK_ID* | **pinned** *FILE* } + + +DESCRIPTION +=========== + **bpftool link { show | list }** [*LINK*] + Show information about active links. If *LINK* is + specified show information only about given link, + otherwise list all links currently active on the system. + + Output will start with link ID followed by link type and + zero or more named attributes, some of which depend on type + of link. + + **bpftool link pin** *LINK* *FILE* + Pin link *LINK* as *FILE*. + + Note: *FILE* must be located in *bpffs* mount. It must not + contain a dot character ('.'), which is reserved for future + extensions of *bpffs*. + + **bpftool link 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**. + + -f, --bpffs + When showing BPF links, show file names of pinned + links. + + -n, --nomount + Do not automatically attempt to mount any virtual file system + (such as tracefs or BPF virtual file system) when necessary. + + -d, --debug + Print all logs available, even debug-level information. This + includes logs from libbpf. + +EXAMPLES +======== +**# bpftool link show** + +:: + + 10: cgroup prog 25 + cgroup_id 614 attach_type egress + +**# bpftool --json --pretty link show** + +:: + + [{ + "type": "cgroup", + "prog_id": 25, + "cgroup_id": 614, + "attach_type": "egress" + } + ] + +| +| **# bpftool link pin id 10 /sys/fs/bpf/link** +| **# ls -l /sys/fs/bpf/** + +:: + + -rw------- 1 root root 0 Apr 23 21:39 link + + +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)
Signature · 1 line
2.24.1
PATCH v3 10/10 bpftool: add link bash completions
In reply to Andrii NakryikoExtend bpftool's bash-completion script to handle new link command and its sub-commands.
--- tools/bpf/bpftool/bash-completion/bpftool | 39 +++++++++++++++++++++++ 1 file changed, 39 insertions(+)
tools/bpf/bpftool/bash-completion/bpftool +39 -0
@@ -98,6 +98,12 @@ _bpftool_get_btf_ids() command sed -n 's/.*"id": \(.*\),$/\1/p' )" -- "$cur" ) ) } +_bpftool_get_link_ids() +{ + COMPREPLY+=( $( compgen -W "$( bpftool -jp link 2>&1 | \ + command sed -n 's/.*"id": \(.*\),$/\1/p' )" -- "$cur" ) ) +} + _bpftool_get_obj_map_names() { local obj
@@ -1082,6 +1088,39 @@ _bpftool() ;; esac ;; + link) + case $command in + show|list|pin) + case $prev in + id) + _bpftool_get_link_ids + return 0 + ;; + esac + ;; + esac + + local LINK_TYPE='id pinned' + case $command in + show|list) + [[ $prev != "$command" ]] && return 0 + COMPREPLY=( $( compgen -W "$LINK_TYPE" -- "$cur" ) ) + return 0 + ;; + pin) + if [[ $prev == "$command" ]]; then + COMPREPLY=( $( compgen -W "$LINK_TYPE" -- "$cur" ) ) + else + _filedir + fi + return 0 + ;; + *) + [[ $prev == $object ]] && \ + COMPREPLY=( $( compgen -W 'help pin show list' -- "$cur" ) ) + ;; + esac + ;; esac } && complete -F _bpftool bpftool
Signature · 1 line
2.24.1
Alexei Starovoitov
AppliedQuoted 11 lines · Andrii Nakryiko
This patch series adds various observability APIs to
bpf_link:
- eachbpf_linknow gets ID, similar tobpf_mapandbpf_prog, by which user-space can iterate over all existingbpf_linksand create limited FD from ID;
- allows to get extra object information withbpf_linkgeneral andtype-specific information; - implements `bpf link show` command which lists all active bpf_links in the system;- implements
bpf link pinallowing to pinbpf_linkby ID or from other pinned path.
Quoted 12 lines
v2->v3:
- improve spin locking aroundbpf_linkID (Alexei);
- simplifybpf_link_infohandling and fix compilation error on sh arch;v1->v2:
- simplifiedbpftool link showimplementation (Quentin);
- fixed formatting ofbpftool-link.rst(Quentin);
- fixed attach type printing logic (Quentin);rfc->v1:
- dropped read-onlybpf_links(Alexei);
- fixed bug inbpf_link_cleanup()not removing ID;
- fixed bpftool link pinning search logic;
- added bash-completion and man page.
Applied, Thanks