Update a struct_ops link through a pinned path
Subsystems (5)
cover Update a struct_ops link through a pinned path
Applications already have the ability to update a struct_ops link with another struct_ops map. However, they were unable to open pinned paths of the links. This implies that updating a link through its pinned paths was not feasible. By allowing the "open" operator on pinned paths, applications can pin a struct_ops link and update the link through the pinned path later.
Kui-Feng Lee (2):
bpf: enable the "open" operator on a pinned path of a struct_osp link. selftests/bpf: open a pinned path of a struct_ops link.
include/linux/bpf.h | 4 ++ kernel/bpf/bpf_struct_ops.c | 10 ++++ kernel/bpf/inode.c | 11 +++- kernel/bpf/syscall.c | 14 ++++- .../selftests/bpf/bpf_testmod/bpf_testmod.c | 6 ++ .../bpf/prog_tests/test_struct_ops_module.c | 56 +++++++++++++++++++ 6 files changed, 97 insertions(+), 4 deletions(-)
Signature · 1 line
2.34.1
PATCH 1/2 bpf: enable the "open" operator on a pinned path of a struct_osp link.
Add the "open" operator for the inodes of BPF links to allow applications to obtain a file descriptor of a struct_ops link from a pinned path.
Applications have the ability to update a struct_ops link with another struct_ops map. However, they were unable to open pinned paths of the links with this patch. This implies that updating a link through its pinned paths was not feasible.
This patch adds the "open" operator to bpf_link_ops and uses bpf_link_ops as the i_fop for inodes of struct_ops links. "open" will be called to open the pinned path represented by an inode. Additionally, bpf_link_ops will be used as the f->f_ops of the opened "file" to provide operators for the "file".
--- include/linux/bpf.h | 4 ++++ kernel/bpf/bpf_struct_ops.c | 10 ++++++++++ kernel/bpf/inode.c | 11 ++++++++--- kernel/bpf/syscall.c | 14 +++++++++++++- 4 files changed, 35 insertions(+), 4 deletions(-)
include/linux/bpf.h +4 -0
@@ -2160,6 +2160,10 @@ extern const struct super_operations bpf_super_ops;extern const struct file_operations bpf_map_fops;extern const struct file_operations bpf_prog_fops;extern const struct file_operations bpf_iter_fops; +extern const struct file_operations bpf_link_fops; + +/* Required by bpf_link_open() */ +int bpffs_struct_ops_link_open (struct inode *inode,struct file *filp);#define BPF_PROG_TYPE (_id, _name, prog_ctx_type, kern_ctx_type) \ extern const struct bpf_prog_ops _name ## _prog_ops; \
kernel/bpf/bpf_struct_ops.c +10 -0
@@ -1198,3 +1198,13 @@ void bpf_map_struct_ops_info_fill(struct bpf_map_info *info, struct bpf_map *map info->btf_vmlinux_id =btf_obj_id (st_map->btf); } + +int bpffs_struct_ops_link_open (struct inode *inode,struct file *filp) +{ +struct bpf_struct_ops_link *link = inode->i_private; + +/* Paired with bpf_link_put_direct() in bpf_link_release(). */ +bpf_link_inc (&link->link); + filp->private_data = link; +return 0 ; +}
kernel/bpf/inode.c +8 -3
@@ -360,11 +360,16 @@ static int bpf_mkmap(struct dentry *dentry, umode_t mode, void *arg)static int bpf_mklink (struct dentry *dentry,umode_t mode,void *arg) { +const struct file_operations *fops;struct bpf_link *link = arg; -return bpf_mkobj_ops (dentry, mode, arg, &bpf_link_iops, -bpf_link_is_iter (link) ? - &bpf_iter_fops : &bpffs_obj_fops); +if (bpf_link_is_iter (link)) + fops = &bpf_iter_fops; +else if (link->type ==BPF_LINK_TYPE_STRUCT_OPS ) + fops = &bpf_link_fops; +else + fops = &bpffs_obj_fops; +return bpf_mkobj_ops (dentry, mode, arg, &bpf_link_iops, fops); } static struct dentry *
kernel/bpf/syscall.c +13 -1
@@ -3108,7 +3108,19 @@ static void bpf_link_show_fdinfo(struct seq_file *m, struct file *filp) }#endif -static const struct file_operations bpf_link_fops = { +/* Support opening pinned links */ +static int bpf_link_open (struct inode *inode,struct file *filp) +{ +struct bpf_link *link = inode->i_private; + +if (link->type ==BPF_LINK_TYPE_STRUCT_OPS ) +return bpffs_struct_ops_link_open (inode, filp); + +return -EOPNOTSUPP ; +} + +const struct file_operations bpf_link_fops = { + .open = bpf_link_open, #ifdef CONFIG_PROC_FS .show_fdinfo = bpf_link_show_fdinfo, #endif
Signature · 1 line
2.34.1
kernel test robot
build botRe: [PATCH bpf-next 1/2] bpf: enable the "open" operator on a pinned path of a struct_osp link.
kernel test robot noticed the following build errors:
Hi Kui-Feng,
kernel test robot noticed the following build errors:
[auto build test ERROR on bpf-next/master]
url: https://github.com/intel-lab-lkp/linux/commits/Kui-Feng-Lee/bpf-enable-the-open-operator-on-a-pinned-path-of-a-struct_osp-link/20240417-082736 base: https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git master patch link: https://lore.kernel.org/r/20240417002513.1534535-2-thinker.li%40gmail.com patch subject: [PATCH bpf-next 1/2] bpf: enable the "open" operator on a pinned path of a struct_osp link. config: riscv-defconfig (https://download.01.org/0day-ci/archive/20240418/[email protected]/config) compiler: clang version 19.0.0git (https://github.com/llvm/llvm-project 7089c359a3845323f6f30c44a47dd901f2edfe63) reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20240418/[email protected]/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/
All errors (new ones prefixed by >>):
>> ld.lld: error: undefined symbol: bpffs_struct_ops_link_open >>> referenced by syscall.c >>> kernel/bpf/syscall.o:(bpf_link_open) in archive vmlinux.a
Signature · 2 lines
0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests/wiki
kernel test robot
build botRe: [PATCH bpf-next 1/2] bpf: enable the "open" operator on a pinned path of a struct_osp link.
In reply to Kui-Feng Leekernel test robot noticed the following build errors:
Hi Kui-Feng,
kernel test robot noticed the following build errors:
[auto build test ERROR on bpf-next/master]
url: https://github.com/intel-lab-lkp/linux/commits/Kui-Feng-Lee/bpf-enable-the-open-operator-on-a-pinned-path-of-a-struct_osp-link/20240417-082736 base: https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git master patch link: https://lore.kernel.org/r/20240417002513.1534535-2-thinker.li%40gmail.com patch subject: [PATCH bpf-next 1/2] bpf: enable the "open" operator on a pinned path of a struct_osp link. config: arm-aspeed_g5_defconfig (https://download.01.org/0day-ci/archive/20240418/[email protected]/config) compiler: arm-linux-gnueabi-gcc (GCC) 13.2.0 reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20240418/[email protected]/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/
All errors (new ones prefixed by >>):
arm-linux-gnueabi-ld: kernel/bpf/syscall.o: in function `bpf_link_open':
>> kernel/bpf/syscall.c:3117:(.text+0xb70): undefined reference to `bpffs_struct_ops_link_open'
vim +3117 kernel/bpf/syscall.c
3110
3111 /* Support opening pinned links */
3112 static int bpf_link_open(struct inode *inode, struct file *filp)
3113 {
3114 struct bpf_link *link = inode->i_private;
3115
3116 if (link->type == BPF_LINK_TYPE_STRUCT_OPS)
> 3117 return bpffs_struct_ops_link_open(inode, filp);
3118
3119 return -EOPNOTSUPP;
3120 }
3121
Signature · 2 lines
0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests/wiki
Martin KaFai Lau
reviewerRe: [PATCH bpf-next 1/2] bpf: enable the "open" operator on a pinned path of a struct_osp link.
In reply to Kui-Feng LeeQuoted 16 lines · Kui-Feng Lee
kernel/bpf/bpf_struct_ops.c +9
-0+int bpffs_struct_ops_link_open (struct inode *inode,struct file *filp) +{ +struct bpf_struct_ops_link *link = inode->i_private; + +/* Paired with bpf_link_put_direct() in bpf_link_release(). */ +bpf_link_inc (&link->link); + filp->private_data = link; +return 0 ; +}kernel/bpf/inode.c +0
-0@@ -360,11 +360,16 @@ static int bpf_mkmap(struct dentry *dentry, umode_t mode, void *arg)static int bpf_mklink (struct dentry *dentry,umode_t mode,void *arg)
kernel/bpf/inode.c static int bpf_mkmap(struct dentry *dentry, umode_t mode, void *arg) · line 368
Quoted 10 lines
kernel/bpf/inode.c +4
-3{ +const struct file_operations *fops;struct bpf_link *link = arg; -return bpf_mkobj_ops (dentry, mode, arg, &bpf_link_iops, -bpf_link_is_iter (link) ? - &bpf_iter_fops : &bpffs_obj_fops); +if (bpf_link_is_iter (link)) + fops = &bpf_iter_fops; +else if (link->type ==BPF_LINK_TYPE_STRUCT_OPS )
Open a pinned link and then update should not be specific to struct_ops link. e.g. should be useful to the cgroup link also?
Andrii, wdyt about supporting other link types also?
Quoted 32 lines
kernel/bpf/inode.c +4
-0+ fops = &bpf_link_fops; + else + fops = &bpffs_obj_fops; +return bpf_mkobj_ops (dentry, mode, arg, &bpf_link_iops, fops); } static struct dentry *kernel/bpf/syscall.c +13
-1@@ -3108,7 +3108,19 @@ static void bpf_link_show_fdinfo(struct seq_file *m, struct file *filp) }#endif -static const struct file_operations bpf_link_fops = { +/* Support opening pinned links */ +static int bpf_link_open (struct inode *inode,struct file *filp) +{ +struct bpf_link *link = inode->i_private; + +if (link->type ==BPF_LINK_TYPE_STRUCT_OPS ) +return bpffs_struct_ops_link_open (inode, filp); + +return -EOPNOTSUPP ; +} + +const struct file_operations bpf_link_fops = { + .open = bpf_link_open, #ifdef CONFIG_PROC_FS .show_fdinfo = bpf_link_show_fdinfo, #endif
Re: [PATCH bpf-next 1/2] bpf: enable the "open" operator on a pinned path of a struct_osp link.
Quoted 20 lines · Martin KaFai Lau
Quoted 19 lines · Kui-Feng Lee
kernel/bpf/bpf_struct_ops.c +9
-0+int bpffs_struct_ops_link_open (struct inode *inode,struct file *filp) +{ + struct bpf_struct_ops_link *link = inode->i_private; + + /* Paired with bpf_link_put_direct() in bpf_link_release(). */ + bpf_link_inc(&link->link); + filp->private_data = link; + return 0; +}kernel/bpf/inode.c +1
-0@@ -360,11 +360,16 @@ static int bpf_mkmap(struct dentry *dentry, umode_t mode, void *arg) static int bpf_mklink(struct dentry *dentry, umode_t mode, void *arg) { + const struct file_operations *fops; struct bpf_link *link = arg;
Quoted 8 lines
kernel/bpf/inode.c static int bpf_mkmap(struct dentry *dentry, umode_t mode, void *arg) · line 368
Quoted 6 lines
kernel/bpf/inode.c +3
-3- return bpf_mkobj_ops(dentry, mode, arg, &bpf_link_iops, - bpf_link_is_iter(link) ? - &bpf_iter_fops : &bpffs_obj_fops); + if (bpf_link_is_iter(link)) + fops = &bpf_iter_fops; + else if (link->type == BPF_LINK_TYPE_STRUCT_OPS)Open a pinned link and then update should not be specific to
struct_opslink. e.g. should be useful to the cgroup link also?
It could be. Here, I played safe in case it creates any unwanted side effect for links of unknown types.
Quoted 35 lines
Andrii, wdyt about supporting other link types also?
Quoted 31 lines
kernel/bpf/inode.c +4
-0+ fops = &bpf_link_fops; + else + fops = &bpffs_obj_fops; + return bpf_mkobj_ops(dentry, mode, arg, &bpf_link_iops, fops); }static struct dentry *
kernel/bpf/syscall.c +13
-1@@ -3108,7 +3108,19 @@ static void bpf_link_show_fdinfo(struct seq_file *m, struct file *filp) } #endif -static const struct file_operations bpf_link_fops = { +/* Support opening pinned links */ +static int bpf_link_open (struct inode *inode,struct file *filp) +{ + struct bpf_link *link = inode->i_private; + + if (link->type == BPF_LINK_TYPE_STRUCT_OPS) + return bpffs_struct_ops_link_open(inode, filp); + + return -EOPNOTSUPP; +} + +const struct file_operations bpf_link_fops = { + .open = bpf_link_open, #ifdef CONFIG_PROC_FS .show_fdinfo = bpf_link_show_fdinfo, #endif
Re: [PATCH bpf-next 1/2] bpf: enable the "open" operator on a pinned path of a struct_osp link.
Quoted 32 lines · Kui-Feng Lee
Quoted 20 lines · Martin KaFai Lau
Quoted 19 lines · Kui-Feng Lee
kernel/bpf/bpf_struct_ops.c +9
-0+int bpffs_struct_ops_link_open (struct inode *inode,struct file *filp) +{ + struct bpf_struct_ops_link *link = inode->i_private; + + /* Paired with bpf_link_put_direct() in bpf_link_release(). */ + bpf_link_inc(&link->link); + filp->private_data = link; + return 0; +}kernel/bpf/inode.c +1
-0@@ -360,11 +360,16 @@ static int bpf_mkmap(struct dentry *dentry, umode_t mode, void *arg) static int bpf_mklink(struct dentry *dentry, umode_t mode, void *arg) { + const struct file_operations *fops; struct bpf_link *link = arg;Quoted 8 lines
kernel/bpf/inode.c static int bpf_mkmap(struct dentry *dentry, umode_t mode, void *arg) · line 368
Quoted 6 lines
kernel/bpf/inode.c +3
-3- return bpf_mkobj_ops(dentry, mode, arg, &bpf_link_iops, - bpf_link_is_iter(link) ? - &bpf_iter_fops : &bpffs_obj_fops); + if (bpf_link_is_iter(link)) + fops = &bpf_iter_fops; + else if (link->type == BPF_LINK_TYPE_STRUCT_OPS)Open a pinned link and then update should not be specific to
struct_opslink. e.g. should be useful to the cgroup link also?
Quoted 2 lines
It could be. Here, I played safe in case it creates any unwanted side effect for links of unknown types.
By the way, may I put it in a follow up patch if we want cgroup links?
Quoted 36 lines
Quoted 36 lines
Andrii, wdyt about supporting other link types also?
Quoted 31 lines
kernel/bpf/inode.c +4
-0+ fops = &bpf_link_fops; + else + fops = &bpffs_obj_fops; + return bpf_mkobj_ops(dentry, mode, arg, &bpf_link_iops, fops); }static struct dentry *
kernel/bpf/syscall.c +13
-1@@ -3108,7 +3108,19 @@ static void bpf_link_show_fdinfo(struct seq_file *m, struct file *filp) } #endif -static const struct file_operations bpf_link_fops = { +/* Support opening pinned links */ +static int bpf_link_open (struct inode *inode,struct file *filp) +{ + struct bpf_link *link = inode->i_private; + + if (link->type == BPF_LINK_TYPE_STRUCT_OPS) + return bpffs_struct_ops_link_open(inode, filp); + + return -EOPNOTSUPP; +} + +const struct file_operations bpf_link_fops = { + .open = bpf_link_open, #ifdef CONFIG_PROC_FS .show_fdinfo = bpf_link_show_fdinfo, #endif
Martin KaFai Lau
reviewerRe: [PATCH bpf-next 1/2] bpf: enable the "open" operator on a pinned path of a struct_osp link.
Quoted 35 lines · Kui-Feng Lee
Quoted 32 lines · Kui-Feng Lee
Quoted 28 lines · Martin KaFai Lau
Quoted 15 lines · Kui-Feng Lee
kernel/bpf/bpf_struct_ops.c +9
-0+int bpffs_struct_ops_link_open (struct inode *inode,struct file *filp) +{ + struct bpf_struct_ops_link *link = inode->i_private; + + /* Paired with bpf_link_put_direct() in bpf_link_release(). */ + bpf_link_inc(&link->link); + filp->private_data = link; + return 0; +}kernel/bpf/inode.c +0
-0@@ -360,11 +360,16 @@ static int bpf_mkmap(struct dentry *dentry, umode_t mode, void *arg)kernel/bpf/inode.c static int bpf_mkmap(struct dentry *dentry, umode_t · line 367
Quoted 10 lines
kernel/bpf/inode.c +4
-3static int bpf_mklink(struct dentry *dentry, umode_t mode, void *arg) { + const struct file_operations *fops; struct bpf_link *link = arg; - return bpf_mkobj_ops(dentry, mode, arg, &bpf_link_iops, - bpf_link_is_iter(link) ? - &bpf_iter_fops : &bpffs_obj_fops); + if (bpf_link_is_iter(link)) + fops = &bpf_iter_fops; + else if (link->type == BPF_LINK_TYPE_STRUCT_OPS)Open a pinned link and then update should not be specific to
struct_opslink. e.g. should be useful to the cgroup link also?
Quoted 4 lines
Quoted 2 lines
It could be. Here, I played safe in case it creates any unwanted side effect for links of unknown types.
By the way, may I put it in a follow up patch if we want cgroup links?
This does not feel right. It is not struct_ops specific.
Before we dive in further, there is BPF_OBJ_GET which can get a fd of a pinned bpf obj (prog, map, and link). Take a look at bpf_link__open() in libbpf. Does it work for the use case that needs to update the link?
Re: [PATCH bpf-next 1/2] bpf: enable the "open" operator on a pinned path of a struct_osp link.
Quoted 37 lines · Martin KaFai Lau
Quoted 36 lines · Kui-Feng Lee
Quoted 33 lines · Kui-Feng Lee
Quoted 29 lines · Martin KaFai Lau
Quoted 16 lines · Kui-Feng Lee
+int
bpffs_struct_ops_link_open(struct inode *inode, struct file *filp)kernel/bpf/bpf_struct_ops.c +8
-0+{ + struct bpf_struct_ops_link *link = inode->i_private; + + /* Paired with bpf_link_put_direct() in bpf_link_release(). */ + bpf_link_inc(&link->link); + filp->private_data = link; + return 0; +}kernel/bpf/inode.c +0
-0@@ -360,11 +360,16 @@ static int bpf_mkmap(struct dentry *dentry, umode_t mode, void *arg)kernel/bpf/inode.c static int bpf_mkmap(struct dentry *dentry, · line 367
Quoted 10 lines
kernel/bpf/inode.c +4
-3static int bpf_mklink(struct dentry *dentry, umode_t mode, void *arg) { + const struct file_operations *fops; struct bpf_link *link = arg; - return bpf_mkobj_ops(dentry, mode, arg, &bpf_link_iops, - bpf_link_is_iter(link) ? - &bpf_iter_fops : &bpffs_obj_fops); + if (bpf_link_is_iter(link)) + fops = &bpf_iter_fops; + else if (link->type == BPF_LINK_TYPE_STRUCT_OPS)Open a pinned link and then update should not be specific to
struct_opslink. e.g. should be useful to the cgroup link also?
Quoted 9 lines
Quoted 4 lines
Quoted 2 lines
It could be. Here, I played safe in case it creates any unwanted side effect for links of unknown types.
By the way, may I put it in a follow up patch if we want cgroup links?
This does not feel right. It is not
struct_opsspecific.Before we dive in further, there is
BPF_OBJ_GETwhich can get a fd of a pinned bpf obj (prog, map, and link). Take a look atbpf_link__open()in libbpf. Does it work for the use case that needs to update the link?
It should work.
So, this patch is not necessary. However, it is still a nice and intuitive feature. WDYT?
Martin KaFai Lau
reviewerRe: [PATCH bpf-next 1/2] bpf: enable the "open" operator on a pinned path of a struct_osp link.
Quoted 44 lines · Kui-Feng Lee
Quoted 41 lines · Martin KaFai Lau
Quoted 39 lines · Kui-Feng Lee
Quoted 32 lines · Kui-Feng Lee
Quoted 20 lines · Martin KaFai Lau
Quoted 19 lines · Kui-Feng Lee
kernel/bpf/bpf_struct_ops.c +9
-0+int bpffs_struct_ops_link_open (struct inode *inode,struct file *filp) +{ + struct bpf_struct_ops_link *link = inode->i_private; + + /* Paired with bpf_link_put_direct() in bpf_link_release(). */ + bpf_link_inc(&link->link); + filp->private_data = link; + return 0; +}kernel/bpf/inode.c +1
-0@@ -360,11 +360,16 @@ static int bpf_mkmap(struct dentry *dentry, umode_t mode, void *arg) static int bpf_mklink(struct dentry *dentry, umode_t mode, void *arg) { + const struct file_operations *fops; struct bpf_link *link = arg;Quoted 8 lines
kernel/bpf/inode.c static int bpf_mkmap(struct dentry *dentry, umode_t mode, void *arg) · line 368
Quoted 6 lines
kernel/bpf/inode.c +3
-3- return bpf_mkobj_ops(dentry, mode, arg, &bpf_link_iops, - bpf_link_is_iter(link) ? - &bpf_iter_fops : &bpffs_obj_fops); + if (bpf_link_is_iter(link)) + fops = &bpf_iter_fops; + else if (link->type == BPF_LINK_TYPE_STRUCT_OPS)Open a pinned link and then update should not be specific to
struct_opslink. e.g. should be useful to the cgroup link also?Quoted 2 lines
It could be. Here, I played safe in case it creates any unwanted side effect for links of unknown types.
By the way, may I put it in a follow up patch if we want cgroup links?
Quoted 7 lines
Quoted 4 lines
This does not feel right. It is not
struct_opsspecific.Before we dive in further, there is
BPF_OBJ_GETwhich can get a fd of a pinned bpf obj (prog, map, and link). Take a look atbpf_link__open()in libbpf. Does it work for the use case that needs to update the link?It should work.
So, this patch is not necessary. However, it is still a nice and intuitive feature. WDYT?
There is already BPF_OBJ_GET which works for all major bpf obj types (prog, map, and link). Having open only works for link and only works for one link type (struct_ops) is not very convincing.
Beside, I am not sure how the file flags (e.g. rdonly...etc) should be handled. I don't know enough in this area, so I will defer to others to comment in general the usefulness and the approach.
Re: [PATCH bpf-next 1/2] bpf: enable the "open" operator on a pinned path of a struct_osp link.
Quoted 57 lines · Martin KaFai Lau
Quoted 47 lines · Kui-Feng Lee
Quoted 44 lines · Martin KaFai Lau
Quoted 36 lines · Kui-Feng Lee
Quoted 33 lines · Kui-Feng Lee
Quoted 29 lines · Martin KaFai Lau
Quoted 15 lines · Kui-Feng Lee
(quoted diff) +9
-0+int bpffs_struct_ops_link_open(struct inode *inode, struct file *filp) +{ + struct bpf_struct_ops_link *link = inode->i_private; + + /* Paired with bpf_link_put_direct() in bpf_link_release(). */ + bpf_link_inc(&link->link); + filp->private_data = link; + return 0; +}kernel/bpf/inode.c +0
-0@@ -360,11 +360,16 @@ static int bpf_mkmap(struct dentry *dentry, umode_t mode, void *arg)kernel/bpf/inode.c static int bpf_mkmap(struct dentry *dentry, umode_t · line 367
Quoted 10 lines
kernel/bpf/inode.c +4
-3static int bpf_mklink (struct dentry *dentry,umode_t mode,void *arg) { +const struct file_operations *fops;struct bpf_link *link = arg; -return bpf_mkobj_ops (dentry, mode, arg, &bpf_link_iops, -bpf_link_is_iter (link) ? - &bpf_iter_fops : &bpffs_obj_fops); +if (bpf_link_is_iter (link)) + fops = &bpf_iter_fops; +else if (link->type ==BPF_LINK_TYPE_STRUCT_OPS )Open a pinned link and then update should not be specific to
struct_opslink. e.g. should be useful to the cgroup link also?Quoted 4 lines
Quoted 2 lines
It could be. Here, I played safe in case it creates any unwanted side effect for links of unknown types.
By the way, may I put it in a follow up patch if we want cgroup links?
This does not feel right. It is not
struct_opsspecific.Quoted 7 lines
Quoted 4 lines
Before we dive in further, there is
BPF_OBJ_GETwhich can get a fd of a pinned bpf obj (prog, map, and link). Take a look atbpf_link__open()in libbpf. Does it work for the use case that needs to update the link?It should work.
So, this patch is not necessary. However, it is still a nice and intuitive feature. WDYT?
Quoted 9 lines
There is already
BPF_OBJ_GETwhich works for all major bpf obj types (prog, map, and link). Having open only works for link and only works for one link type (struct_ops) is not very convincing.Beside, I am not sure how the file flags (e.g. rdonly...etc) should be handled. I don't know enough in this area, so I will defer to others to comment in general the usefulness and the approach.
Didn't see this discussion before replying on the other patch. But I agree with Martin, we already use the BPF_OBJ_GET method, and we don't support directly open()'ing progs/maps, so I don't think we should do this for links either.
pw-bot: cr
Re: [PATCH bpf-next 1/2] bpf: enable the "open" operator on a pinned path of a struct_osp link.
Quoted 68 lines · Andrii Nakryiko
Quoted 57 lines · Martin KaFai Lau
Quoted 47 lines · Kui-Feng Lee
Quoted 44 lines · Martin KaFai Lau
Quoted 36 lines · Kui-Feng Lee
Quoted 33 lines · Kui-Feng Lee
Quoted 29 lines · Martin KaFai Lau
Quoted 15 lines · Kui-Feng Lee
(quoted diff) +9
-0+int bpffs_struct_ops_link_open(struct inode *inode, struct file *filp) +{ + struct bpf_struct_ops_link *link = inode->i_private; + + /* Paired with bpf_link_put_direct() in bpf_link_release(). */ + bpf_link_inc(&link->link); + filp->private_data = link; + return 0; +}kernel/bpf/inode.c +0
-0@@ -360,11 +360,16 @@ static int bpf_mkmap(struct dentry *dentry, umode_t mode, void *arg)kernel/bpf/inode.c static int bpf_mkmap(struct dentry *dentry, umode_t · line 367
Quoted 10 lines
kernel/bpf/inode.c +4
-3static int bpf_mklink (struct dentry *dentry,umode_t mode,void *arg) { +const struct file_operations *fops;struct bpf_link *link = arg; -return bpf_mkobj_ops (dentry, mode, arg, &bpf_link_iops, -bpf_link_is_iter (link) ? - &bpf_iter_fops : &bpffs_obj_fops); +if (bpf_link_is_iter (link)) + fops = &bpf_iter_fops; +else if (link->type ==BPF_LINK_TYPE_STRUCT_OPS )Open a pinned link and then update should not be specific to
struct_opslink. e.g. should be useful to the cgroup link also?Quoted 4 lines
Quoted 2 lines
It could be. Here, I played safe in case it creates any unwanted side effect for links of unknown types.
By the way, may I put it in a follow up patch if we want cgroup links?
This does not feel right. It is not
struct_opsspecific.Quoted 7 lines
Quoted 4 lines
Before we dive in further, there is
BPF_OBJ_GETwhich can get a fd of a pinned bpf obj (prog, map, and link). Take a look atbpf_link__open()in libbpf. Does it work for the use case that needs to update the link?It should work.
So, this patch is not necessary. However, it is still a nice and intuitive feature. WDYT?Quoted 9 lines
There is already
BPF_OBJ_GETwhich works for all major bpf obj types (prog, map, and link). Having open only works for link and only works for one link type (struct_ops) is not very convincing.Beside, I am not sure how the file flags (e.g. rdonly...etc) should be handled. I don't know enough in this area, so I will defer to others to comment in general the usefulness and the approach.
Quoted 6 lines
Didn't see this discussion before replying on the other patch. But I agree with Martin, we already use the
BPF_OBJ_GETmethod, and we don't support directly open()'ing progs/maps, so I don't think we should do this for links either.pw-bot: cr
Understand! Let's drop this patch.
PATCH 2/2 selftests/bpf: open a pinned path of a struct_ops link.
In reply to Kui-Feng LeeEnsure that a pinned path of a struct_ops link can be opened to obtain a file descriptor, which applications can then utilize to update the link.
--- .../selftests/bpf/bpf_testmod/bpf_testmod.c | 6 ++ .../bpf/prog_tests/test_struct_ops_module.c | 56 +++++++++++++++++++ 2 files changed, 62 insertions(+)
tools/testing/selftests/bpf/bpf_testmod/bpf_testmod.c +6 -0
@@ -579,6 +579,11 @@ static void bpf_dummy_unreg(void *kdata) { } +static int bpf_dummy_update (void *kdata,void *old_kdata) +{ +return bpf_dummy_reg (kdata); +} +static int bpf_testmod_test_1 (void ) {return 0 ;
@@ -606,6 +611,7 @@ struct bpf_struct_ops bpf_bpf_testmod_ops = { .init_member = bpf_testmod_ops_init_member, .reg = bpf_dummy_reg, .unreg = bpf_dummy_unreg, + .update = bpf_dummy_update, .cfi_stubs = &__bpf_testmod_ops, .name = "bpf_testmod_ops", .owner = THIS_MODULE,
tools/testing/selftests/bpf/prog_tests/test_struct_ops_module.c +56 -0
67 lines not on this page · raw message
Signature · 1 line
2.34.1