Introduce bpf_kernfs_read_xattr
Subsystems (7)
Song Liu
reviewercover Introduce bpf_kernfs_read_xattr
Introduce a new kfunc bpf_kernfs_read_xattr, which can read xattr from kernfs nodes (cgroupfs, for example). The primary users are LSMs, for example, from systemd. sched_ext could also use xattrs on cgroupfs nodes. However, this is not allowed yet, because bpf_kernfs_read_xattr is only allowed from LSM hooks. The plan is to address sched_ext later (or in a later revision of this set).
Song Liu (4):
kernfs: Add __kernfs_xattr_get for RCU protected access
bpf: Introduce bpf_kernfs_read_xattr to read xattr of kernfs nodes
bpf: Mark cgroup_subsys_state->cgroup RCU safe selftests/bpf: Add tests for bpf_kernfs_read_xattr
fs/bpf_fs_kfuncs.c | 33 ++++ fs/kernfs/inode.c | 14 ++ include/linux/kernfs.h | 2 + kernel/bpf/verifier.c | 5 + .../selftests/bpf/prog_tests/kernfs_xattr.c | 145 ++++++++++++++++++ .../selftests/bpf/progs/kernfs_read_xattr.c | 117 ++++++++++++++ .../selftests/bpf/progs/read_cgroupfs_xattr.c | 60 ++++++++ 7 files changed, 376 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/kernfs_xattr.c create mode 100644 tools/testing/selftests/bpf/progs/kernfs_read_xattr.c create mode 100644 tools/testing/selftests/bpf/progs/read_cgroupfs_xattr.c
--
2.47.1
Song Liu
reviewerPATCH 1/4 kernfs: Add __kernfs_xattr_get for RCU protected access
Existing kernfs_xattr_get() locks iattr_mutex, so it cannot be used in RCU critical sections. Introduce __kernfs_xattr_get(), which reads xattr under RCU read lock. This can be used by BPF programs to access cgroupfs xattrs.
--- fs/kernfs/inode.c | 14 ++++++++++++++ include/linux/kernfs.h | 2 ++ 2 files changed, 16 insertions(+)
fs/kernfs/inode.c +14 -0
@@ -302,6 +302,20 @@ int kernfs_xattr_get(struct kernfs_node *kn, const char *name,return simple_xattr_get (&attrs->xattrs, name, value, size); } +int __kernfs_xattr_get (struct kernfs_node *kn,const char *name, +void *value,size_t size) +{ +struct kernfs_iattrs *attrs; + +WARN_ON_ONCE (!rcu_read_lock_held ()); + + attrs =rcu_dereference (kn->iattr); +if (!attrs) +return -ENODATA ; + +return simple_xattr_get (&attrs->xattrs, name, value, size); +} +int kernfs_xattr_set (struct kernfs_node *kn,const char *name,const void *value,size_t size,int flags) {
include/linux/kernfs.h +2 -0
@@ -456,6 +456,8 @@ void kernfs_notify(struct kernfs_node *kn);int kernfs_xattr_get (struct kernfs_node *kn,const char *name,void *value,size_t size); +int __kernfs_xattr_get (struct kernfs_node *kn,const char *name, +void *value,size_t size);int kernfs_xattr_set (struct kernfs_node *kn,const char *name,const void *value,size_t size,int flags);
Signature · 1 line
2.47.1
Christian Brauner
maintainerRe: [PATCH bpf-next 1/4] kernfs: Add __kernfs_xattr_get for RCU protected access
Quoted 19 lines · Song Liu
Existing
kernfs_xattr_get()locksiattr_mutex, so it cannot be used in RCU critical sections. Introduce__kernfs_xattr_get(), which reads xattr under RCU read lock. This can be used by BPF programs to access cgroupfs xattrs.Signed-off-by Song Liu <[email protected]>--- fs/kernfs/inode.c | 14 ++++++++++++++ include/linux/kernfs.h | 2 ++ 2 files changed, 16 insertions(+)fs/kernfs/inode.c +0
-0@@ -302,6 +302,20 @@ int kernfs_xattr_get(struct kernfs_node *kn, const char *name,return simple_xattr_get (&attrs->xattrs, name, value, size); }
fs/kernfs/inode.c int kernfs_xattr_get(struct kernfs_node *kn, const char *name, · line 314
Quoted 10 lines
fs/kernfs/inode.c +10
-0+int __kernfs_xattr_get (struct kernfs_node *kn,const char *name, +void *value,size_t size) +{ +struct kernfs_iattrs *attrs; + +WARN_ON_ONCE (!rcu_read_lock_held ()); + + attrs =rcu_dereference (kn->iattr); +if (!attrs) +return -ENODATA ;
Hm, that looks a bit silly. Which isn't your fault. I'm looking at the kernfs code that does the xattr allocations and I think that's the origin of the silliness. It uses a single global mutex for all kernfs users thus serializing all allocations for kernfs->iattr. That seems crazy but maybe I'm missing a good reason.
I'm appending a patch to remove that mutex. @Greg, @Tejun, can you take a look whether that makes sense to you. Then I can take that patch and you can build yours on top of the series and I'll pick it all up in one go.
You should then just use READ_ONCE(kn->iattr) or the kernfs_iattrs_noalloc(kn) helper in your kfunc.
From bdc53435a1cd5c456dc28d8239eff0e7fa4e8dda Mon Sep 17 00:00:00 2001
From: Christian Brauner <[email protected]>
Date: Thu, 19 Jun 2025 11:50:26 +0200
Subject: [PATCH] kernfs: remove iattr_mutex
All allocations of struct kernfs_iattrs are serialized through a global mutex. Simply do a racy allocation and let the first one win. I bet most callers are under inode->i_rwsem anyway and it wouldn't be needed but let's not require that.
---
Note, that this uses kfree() for the kmem cache allocation. That's been possible for a while now but not everyone knows about it yet so I'm pointing it out explicitly.
--- fs/kernfs/inode.c | 74 +++++++++++++++++++++++++---------------------- 1 file changed, 40 insertions(+), 34 deletions(-)
fs/kernfs/inode.c +40 -34
@@ -24,45 +24,46 @@ static const struct inode_operations kernfs_iops = { .listxattr = kernfs_iop_listxattr, }; -static struct kernfs_iattrs *__kernfs_iattrs (struct kernfs_node *kn,int alloc) +static struct kernfs_iattrs *__kernfs_iattrs (struct kernfs_node *kn,bool alloc) { -static DEFINE_MUTEX (iattr_mutex); -struct kernfs_iattrs *ret; + struct kernfs_iattrs *ret __free(kfree) = NULL; +struct kernfs_iattrs *attr; -mutex_lock (&iattr_mutex); + attr =READ_ONCE (kn->iattr); +if (attr || !alloc) +return attr; -if (kn->iattr || !alloc) - goto out_unlock; - - kn->iattr =kmem_cache_zalloc (kernfs_iattrs_cache,GFP_KERNEL ); -if (!kn->iattr) - goto out_unlock; + ret =kmem_cache_zalloc (kernfs_iattrs_cache,GFP_KERNEL ); +if (!ret) +return NULL ;/* assign default attributes */ - kn->iattr->ia_uid =GLOBAL_ROOT_UID ; - kn->iattr->ia_gid =GLOBAL_ROOT_GID ; - -ktime_get_real_ts64 (&kn->iattr->ia_atime); - kn->iattr->ia_mtime = kn->iattr->ia_atime; - kn->iattr->ia_ctime = kn->iattr->ia_atime; - -simple_xattrs_init (&kn->iattr->xattrs); -atomic_set (&kn->iattr->nr_user_xattrs,0 ); -atomic_set (&kn->iattr->user_xattr_size,0 ); -out_unlock: - ret = kn->iattr; -mutex_unlock (&iattr_mutex); -return ret; + ret->ia_uid =GLOBAL_ROOT_UID ; + ret->ia_gid =GLOBAL_ROOT_GID ; + +ktime_get_real_ts64 (&ret->ia_atime); + ret->ia_mtime = ret->ia_atime; + ret->ia_ctime = ret->ia_atime; + +simple_xattrs_init (&ret->xattrs); +atomic_set (&ret->nr_user_xattrs,0 ); +atomic_set (&ret->user_xattr_size,0 ); + +/* If someone raced us, recognize it. */ +if (!try_cmpxchg (&kn->iattr, &attr, ret)) +return READ_ONCE (kn->iattr); + +return no_free_ptr (ret); }static struct kernfs_iattrs *kernfs_iattrs (struct kernfs_node *kn) { -return __kernfs_iattrs (kn,1 ); +return __kernfs_iattrs (kn, true); }static struct kernfs_iattrs *kernfs_iattrs_noalloc (struct kernfs_node *kn) { -return __kernfs_iattrs (kn,0 ); +return __kernfs_iattrs (kn, false); }int __kernfs_setattr (struct kernfs_node *kn,const struct iattr *iattr)
@@ -141,9 +142,9 @@ ssize_t kernfs_iop_listxattr(struct dentry *dentry, char *buf, size_t size)struct kernfs_node *kn =kernfs_dentry_node (dentry);struct kernfs_iattrs *attrs; - attrs =kernfs_iattrs (kn); + attrs =kernfs_iattrs_noalloc (kn);if (!attrs) -return -ENOMEM ; +return -ENODATA ;return simple_xattr_list (d_inode (dentry), &attrs->xattrs, buf, size); }
@@ -166,9 +167,10 @@ static inline void set_inode_attr(struct inode *inode,static void kernfs_refresh_inode (struct kernfs_node *kn,struct inode *inode) { -struct kernfs_iattrs *attrs = kn->iattr; +struct kernfs_iattrs *attrs; inode->i_mode = kn->mode; + attrs =kernfs_iattrs_noalloc (kn);if (attrs)/* * kernfs_node has non-default attributes get them from
@@ -306,7 +308,9 @@ int kernfs_xattr_set(struct kernfs_node *kn, const char *name, const void *value, size_t size, int flags) { struct simple_xattr *old_xattr; -struct kernfs_iattrs *attrs =kernfs_iattrs (kn); +struct kernfs_iattrs *attrs; + + attrs =kernfs_iattrs (kn);if (!attrs)return -ENOMEM ;
@@ -345,8 +349,9 @@ static int kernfs_vfs_user_xattr_add(struct kernfs_node *kn,struct simple_xattrs *xattrs, const void *value, size_t size, int flags) { - atomic_t *sz = &kn->iattr->user_xattr_size; -atomic_t *nr = &kn->iattr->nr_user_xattrs; + struct kernfs_iattrs *attr = kernfs_iattrs_noalloc(kn); +atomic_t *sz = &attr->user_xattr_size; +atomic_t *nr = &attr->nr_user_xattrs;struct simple_xattr *old_xattr;int ret;
@@ -384,8 +389,9 @@ static int kernfs_vfs_user_xattr_rm(struct kernfs_node *kn,struct simple_xattrs *xattrs, const void *value, size_t size, int flags) { - atomic_t *sz = &kn->iattr->user_xattr_size; -atomic_t *nr = &kn->iattr->nr_user_xattrs; + struct kernfs_iattrs *attr = kernfs_iattrs(kn); +atomic_t *sz = &attr->user_xattr_size; +atomic_t *nr = &attr->nr_user_xattrs;struct simple_xattr *old_xattr; old_xattr =simple_xattr_set (xattrs, full_name, value, size, flags);
Signature · 1 line
2.47.2
Re: [PATCH bpf-next 1/4] kernfs: Add __kernfs_xattr_get for RCU protected access
Quoted 37 lines · Christian Brauner
Quoted 19 lines · Song Liu
Existing
kernfs_xattr_get()locksiattr_mutex, so it cannot be used in RCU critical sections. Introduce__kernfs_xattr_get(), which reads xattr under RCU read lock. This can be used by BPF programs to access cgroupfs xattrs.Signed-off-by Song Liu <[email protected]>--- fs/kernfs/inode.c | 14 ++++++++++++++ include/linux/kernfs.h | 2 ++ 2 files changed, 16 insertions(+)fs/kernfs/inode.c +0
-0@@ -302,6 +302,20 @@ int kernfs_xattr_get(struct kernfs_node *kn, const char *name,return simple_xattr_get (&attrs->xattrs, name, value, size); }fs/kernfs/inode.c int kernfs_xattr_get(struct kernfs_node *kn, const char *name, · line 314
Quoted 10 lines
fs/kernfs/inode.c +10
-0+int __kernfs_xattr_get (struct kernfs_node *kn,const char *name, +void *value,size_t size) +{ +struct kernfs_iattrs *attrs; + +WARN_ON_ONCE (!rcu_read_lock_held ()); + + attrs =rcu_dereference (kn->iattr); +if (!attrs) +return -ENODATA ;Hm, that looks a bit silly. Which isn't your fault. I'm looking at the kernfs code that does the xattr allocations and I think that's the origin of the silliness. It uses a single global mutex for all kernfs users thus serializing all allocations for
kernfs->iattr. That seems crazy but maybe I'm missing a good reason.
Quoted 4 lines
I'm appending a patch to remove that mutex. @Greg, @Tejun, can you take a look whether that makes sense to you. Then I can take that patch and you can build yours on top of the series and I'll pick it all up in one go.
Looks sane to me, thanks!
Re: [PATCH bpf-next 1/4] kernfs: Add __kernfs_xattr_get for RCU protected access
In reply to Christian BraunerQuoted 41 lines · Christian Brauner
Quoted 19 lines · Song Liu
Existing
kernfs_xattr_get()locksiattr_mutex, so it cannot be used in RCU critical sections. Introduce__kernfs_xattr_get(), which reads xattr under RCU read lock. This can be used by BPF programs to access cgroupfs xattrs.Signed-off-by Song Liu <[email protected]>---
fs/kernfs/inode.c| 14 ++++++++++++++include/linux/kernfs.h| 2 ++2 files changed, 16 insertions(+)fs/kernfs/inode.c +0
-0@@ -302,6 +302,20 @@ int kernfs_xattr_get(struct kernfs_node *kn, const char *name,return simple_xattr_get (&attrs->xattrs, name, value, size); }fs/kernfs/inode.c int kernfs_xattr_get(struct kernfs_node *kn, const char *name, · line 314
Quoted 10 lines
fs/kernfs/inode.c +10
-0+int __kernfs_xattr_get (struct kernfs_node *kn,const char *name, +void *value,size_t size) +{ +struct kernfs_iattrs *attrs; + +WARN_ON_ONCE (!rcu_read_lock_held ()); + + attrs =rcu_dereference (kn->iattr); +if (!attrs) +return -ENODATA ;Hm, that looks a bit silly. Which isn't your fault. I'm looking at the kernfs code that does the xattr allocations and I think that's the origin of the silliness. It uses a single global mutex for all kernfs users thus serializing all allocations for
kernfs->iattr. That seems crazy but maybe I'm missing a good reason.
Quoted 8 lines
I'm appending a patch to remove that mutex. @Greg, @Tejun, can you take a look whether that makes sense to you. Then I can take that patch and you can build yours on top of the series and I'll pick it all up in one go.
You should then just use
READ_ONCE(kn->iattr)or thekernfs_iattrs_noalloc(kn)helper in your kfunc. <0001-kernfs-remove-iattr_mutex.patch>
This looks better indeed.
I will drop 1/4 and include this patch.
Thanks,
Song
Re: [PATCH bpf-next 1/4] kernfs: Add __kernfs_xattr_get for RCU protected access
In reply to Christian BraunerQuoted 11 lines · Christian Brauner
From
bdc53435a1cd5c456dc28d8239eff0e7fa4e8ddaMon Sep 17 00:00:00 2001
From: Christian Brauner <[email protected]>
Date: Thu, 19 Jun 2025 11:50:26 +0200
Subject: [PATCH] kernfs: removeiattr_mutexAll allocations of struct
kernfs_iattrsare serialized through a global mutex. Simply do a racy allocation and let the first one win. I bet most callers are underinode->i_rwsemanyway and it wouldn't be needed but let's not require that.Signed-off-by Christian Brauner <[email protected]>
Thanks.
Signature · 1 line
tejun
kernel test robot
build botRe: [PATCH bpf-next 1/4] kernfs: Add __kernfs_xattr_get for RCU protected access
In reply to Song Liukernel test robot noticed the following build warnings:
Hi Song,
kernel test robot noticed the following build warnings:
[auto build test WARNING on bpf-next/master]
url: https://github.com/intel-lab-lkp/linux/commits/Song-Liu/kernfs-Add-__kernfs_xattr_get-for-RCU-protected-access/20250619-074026 base: https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git master patch link: https://lore.kernel.org/r/20250618233739.189106-2-song%40kernel.org patch subject: [PATCH bpf-next 1/4] kernfs: Add __kernfs_xattr_get for RCU protected access config: m68k-randconfig-r122-20250619 (https://download.01.org/0day-ci/archive/20250619/[email protected]/config) compiler: m68k-linux-gcc (GCC) 8.5.0 reproduce: (https://download.01.org/0day-ci/archive/20250619/[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]/
sparse warnings: (new ones prefixed by >>)
>> fs/kernfs/inode.c:312:17: sparse: sparse: incompatible types in comparison expression (different address spaces):
fs/kernfs/inode.c:312:17: sparse: struct kernfs_iattrs [noderef] __rcu *
fs/kernfs/inode.c:312:17: sparse: struct kernfs_iattrs *
vim +312 fs/kernfs/inode.c
304
305 int __kernfs_xattr_get(struct kernfs_node *kn, const char *name,
306 void *value, size_t size)
307 {
308 struct kernfs_iattrs *attrs;
309
310 WARN_ON_ONCE(!rcu_read_lock_held());
311
> 312 attrs = rcu_dereference(kn->iattr);
313 if (!attrs)
314 return -ENODATA;
315
316 return simple_xattr_get(&attrs->xattrs, name, value, size);
317 }
318
Signature · 2 lines
0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests/wiki
Song Liu
reviewerPATCH 2/4 bpf: Introduce bpf_kernfs_read_xattr to read xattr of kernfs nodes
In reply to Song LiuBPF programs, such as LSM and sched_ext, would benefit from tags on cgroups. One common practice to apply such tags is to set xattrs on cgroupfs files and folders.
Introduce kfunc bpf_kernfs_read_xattr, which allows reading kernfs xattr under RCU read lock.
Note that, we already have bpf_get_[file|dentry]_xattr. However, these two APIs are not ideal for reading cgroupfs xattrs, because:
1) These two APIs only works in sleepable contexts;
2) There is no kfunc that matches current cgroup to cgroupfs dentry.
--- fs/bpf_fs_kfuncs.c | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+)
fs/bpf_fs_kfuncs.c +33 -0
@@ -9,6 +9,7 @@#include <linux/fs.h> #include <linux/fsnotify.h> #include <linux/file.h> +#include <linux/kernfs.h> #include <linux/mm.h> #include <linux/xattr.h>
@@ -322,6 +323,37 @@ __bpf_kfunc int bpf_remove_dentry_xattr(struct dentry *dentry, const char *name_return ret; } +/** +* bpf_kernfs_read_xattr - get xattr of a kernfs node +* @kn: kernfs_node to get xattr from +* @name__str: name of the xattr +* @value_p: output buffer of the xattr value +* +* Get xattr *name__str* of *kn* and store the output in *value_ptr*. +* +* For security reasons, only *name__str* with prefix "user." is allowed. +* +* Return: length of the xattr value on success, a negative value on error. +*/ +__bpf_kfunc int bpf_kernfs_read_xattr(struct kernfs_node *kn, const char *name__str, +struct bpf_dynptr *value_p) +{ +struct bpf_dynptr_kern *value_ptr = (struct bpf_dynptr_kern *)value_p; +u32 value_len; +void *value; + +/* Only allow reading "user.*" xattrs */ +if (strncmp (name__str,XATTR_USER_PREFIX ,XATTR_USER_PREFIX_LEN )) +return -EPERM ; + + value_len =__bpf_dynptr_size (value_ptr); + value =__bpf_dynptr_data_rw (value_ptr, value_len); +if (!value) +return -EINVAL ; + +return __kernfs_xattr_get (kn, name__str, value, value_len); +} +__bpf_kfunc_end_defs ();BTF_KFUNCS_START (bpf_fs_kfunc_set_ids)
@@ -333,6 +365,7 @@ BTF_ID_FLAGS(func, bpf_get_dentry_xattr, KF_SLEEPABLE | KF_TRUSTED_ARGS) BTF_ID_FLAGS(func, bpf_get_file_xattr, KF_SLEEPABLE | KF_TRUSTED_ARGS) BTF_ID_FLAGS(func, bpf_set_dentry_xattr, KF_SLEEPABLE | KF_TRUSTED_ARGS) BTF_ID_FLAGS(func, bpf_remove_dentry_xattr, KF_SLEEPABLE | KF_TRUSTED_ARGS) +BTF_ID_FLAGS(func, bpf_kernfs_read_xattr, KF_RCU | KF_RCU_PROTECTED)BTF_KFUNCS_END (bpf_fs_kfunc_set_ids) static int bpf_fs_kfuncs_filter(const struct bpf_prog *prog, u32 kfunc_id)
Signature · 1 line
2.47.1
Christian Brauner
maintainerRe: [PATCH bpf-next 2/4] bpf: Introduce bpf_kernfs_read_xattr to read xattr of kernfs nodes
Quoted 38 lines · Song Liu
BPF programs, such as LSM and
sched_ext, would benefit from tags on cgroups. One common practice to apply such tags is to set xattrs on cgroupfs files and folders.Introduce kfunc
bpf_kernfs_read_xattr, which allows reading kernfs xattr under RCU read lock.Note that, we already have bpf_get_[file|dentry]_xattr. However, these two APIs are not ideal for reading cgroupfs xattrs, because:
1) These two APIs only works in sleepable contexts;
2) There is no kfunc that matches current cgroup to cgroupfs dentry.Signed-off-by Song Liu <[email protected]>--- fs/bpf_fs_kfuncs.c | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+)fs/bpf_fs_kfuncs.c +5
-0@@ -9,6 +9,7 @@#include <linux/fs.h> #include <linux/fsnotify.h> #include <linux/file.h> +#include <linux/kernfs.h> #include <linux/mm.h> #include <linux/xattr.h> @@ -322,6 +323,37 @@ __bpf_kfunc int bpf_remove_dentry_xattr(struct dentry *dentry, const char *name_return ret; } +/** +* bpf_kernfs_read_xattr - get xattr of a kernfs node +* @kn: kernfs_node to get xattr from +* @name__str: name of the xattr
fs/bpf_fs_kfuncs.c __bpf_kfunc int bpf_remove_dentry_xattr(struct dentry *dentry, const char *name_ · line 339
Quoted 10 lines
fs/bpf_fs_kfuncs.c +10
-0+* @value_p: output buffer of the xattr value +* +* Get xattr *name__str* of *kn* and store the output in *value_ptr*. +* +* For security reasons, only *name__str* with prefix "user." is allowed. +* +* Return: length of the xattr value on success, a negative value on error. +*/ +__bpf_kfunc int bpf_kernfs_read_xattr(struct kernfs_node *kn, const char *name__str, +struct bpf_dynptr *value_p)
Please pass struct cgroup, then go from struct cgroup to kernfs node.
Song Liu
reviewerPATCH 3/4 bpf: Mark cgroup_subsys_state->cgroup RCU safe
In reply to Song LiuMark struct cgroup_subsys_state->cgroup as safe under RCU read lock. This will enable accessing css->cgroup from a bpf css iterator.
--- kernel/bpf/verifier.c | 5 +++++ 1 file changed, 5 insertions(+)
kernel/bpf/verifier.c +5 -0
@@ -7058,6 +7058,10 @@ BTF_TYPE_SAFE_RCU(struct css_set) {struct cgroup *dfl_cgrp; }; +BTF_TYPE_SAFE_RCU(struct cgroup_subsys_state) { +struct cgroup *cgroup; +}; +/* RCU trusted: these fields are trusted in RCU CS and can be NULL */ BTF_TYPE_SAFE_RCU_OR_NULL(struct mm_struct) {struct file __rcu *exe_file;
@@ -7108,6 +7112,7 @@ static bool type_is_rcu(struct bpf_verifier_env *env,BTF_TYPE_EMIT (BTF_TYPE_SAFE_RCU(struct task_struct ));BTF_TYPE_EMIT (BTF_TYPE_SAFE_RCU(struct cgroup ));BTF_TYPE_EMIT (BTF_TYPE_SAFE_RCU(struct css_set )); +BTF_TYPE_EMIT (BTF_TYPE_SAFE_RCU(struct cgroup_subsys_state ));return btf_nested_type_is_trusted (&env->log, reg, field_name, btf_id,"__safe_rcu" ); }
Signature · 1 line
2.47.1
Song Liu
reviewerPATCH 4/4 selftests/bpf: Add tests for bpf_kernfs_read_xattr
In reply to Song LiuAdd tests for different scenarios with bpf_kernfs_read_xattr:
1. Read cgroup xattr from bpf_cgroup_from_id;
2. Read cgroup xattr from bpf_cgroup_ancestor;
3. Read cgroup xattr from css_iter;
4. Verifier reject using bpf_kernfs_read_xattr in sleepable contexts.
5. Use bpf_kernfs_read_xattr in LSM hook security_socket_connect.
--- .../selftests/bpf/prog_tests/kernfs_xattr.c | 145 ++++++++++++++++++ .../selftests/bpf/progs/kernfs_read_xattr.c | 117 ++++++++++++++ .../selftests/bpf/progs/read_cgroupfs_xattr.c | 60 ++++++++ 3 files changed, 322 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/kernfs_xattr.c create mode 100644 tools/testing/selftests/bpf/progs/kernfs_read_xattr.c create mode 100644 tools/testing/selftests/bpf/progs/read_cgroupfs_xattr.c
tools/testing/selftests/bpf/prog_tests/kernfs_xattr.c new file +145 -0
@@ -0,0 +1,145 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* Copyright (c) 2025 Meta Platforms, Inc. and affiliates. */ + +#include <errno.h> +#include <fcntl.h> +#include <sys/stat.h> +#include <string.h> +#include <unistd.h> +#include <sys/socket.h> +#include <sys/xattr.h> + +#include <test_progs.h> + +#include "read_cgroupfs_xattr.skel.h" +#include "kernfs_read_xattr.skel.h" + +#define CGROUP_FS_ROOT "/sys/fs/cgroup/" +#define CGROUP_FS_PARENT CGROUP_FS_ROOT "foo/" +#define CGROUP_FS_CHILD CGROUP_FS_PARENT "bar/" + +static int move_pid_to_cgroup (const char *cgroup_folder,pid_t pid) +{ +char filename[128 ]; +char pid_str[64 ]; +int procs_fd; +int ret; + +snprintf (filename,sizeof (filename),"%scgroup.procs" , cgroup_folder); +snprintf (pid_str,sizeof (pid_str),"%d" , pid); + + procs_fd =open (filename,O_WRONLY |O_APPEND ); +if (!ASSERT_OK_FD (procs_fd,"open" )) +return -1 ; + + ret =write (procs_fd, pid_str,strlen (pid_str)); +close (procs_fd); +if (!ASSERT_GT (ret,0 ,"write cgroup.procs" )) +return -1 ; +return 0 ; +} + +static void reset_cgroups_and_lo (void ) +{ +rmdir (CGROUP_FS_CHILD ); +rmdir (CGROUP_FS_PARENT ); +system ("ip addr del 1.1.1.1/32 dev lo" ); +system ("ip link set dev lo down" ); +} + +static const char xattr_value_a[] ="bpf_selftest_value_a" ; +static const char xattr_value_b[] ="bpf_selftest_value_b" ; +static const char xattr_name[] ="user.bpf_test" ; + +static int setup_cgroups_and_lo (void ) +{ +int err; + + err =mkdir (CGROUP_FS_PARENT ,0755 ); +if (!ASSERT_OK (err,"mkdir 1" )) + goto error; + err =mkdir (CGROUP_FS_CHILD ,0755 ); +if (!ASSERT_OK (err,"mkdir 2" )) + goto error; + + err =setxattr (CGROUP_FS_PARENT , xattr_name, xattr_value_a, +strlen (xattr_value_a) +1 ,0 ); +if (!ASSERT_OK (err,"setxattr 1" )) + goto error; + + err =setxattr (CGROUP_FS_CHILD , xattr_name, xattr_value_b, +strlen (xattr_value_b) +1 ,0 ); +if (!ASSERT_OK (err,"setxattr 2" )) + goto error; + + err =system ("ip link set dev lo up" ); +if (!ASSERT_OK (err,"lo up" )) + goto error; + + err =system ("ip addr add 1.1.1.1 dev lo" ); +if (!ASSERT_OK (err,"lo addr v4" )) + goto error; + + err =write_sysctl ("/proc/sys/net/ipv4/ping_group_range" ,"0 0" ); +if (!ASSERT_OK (err,"write_sysctl" )) + goto error; + +return 0 ; +error: +reset_cgroups_and_lo (); +return err; +} + +static void test_read_cgroup_xattr (void ) +{ +struct sockaddr_in sa4 = { + .sin_family =AF_INET , + .sin_addr.s_addr =htonl (INADDR_LOOPBACK ), + }; +struct read_cgroupfs_xattr *skel =NULL ; +pid_t pid =gettid (); +int sock_fd =-1 ; +int connect_fd =-1 ; + +if (!ASSERT_OK (setup_cgroups_and_lo (),"setup_cgroups_and_lo" )) +return ; +if (!ASSERT_OK (move_pid_to_cgroup (CGROUP_FS_CHILD , pid), +"move_pid_to_cgroup" )) + goto out; + + skel =read_cgroupfs_xattr__open_and_load (); +if (!ASSERT_OK_PTR (skel,"read_cgroupfs_xattr__open_and_load" )) + goto out; + + skel->bss->target_pid = pid; + +if (!ASSERT_OK (read_cgroupfs_xattr__attach (skel),"read_cgroupfs_xattr__attach" )) + goto out; + + sock_fd =socket (AF_INET ,SOCK_DGRAM ,IPPROTO_ICMP ); +if (!ASSERT_OK_FD (sock_fd,"sock create" )) + goto out; + + connect_fd =connect (sock_fd, &sa4,sizeof (sa4)); +if (!ASSERT_OK_FD (connect_fd,"connect 1" )) + goto out; +close (connect_fd); + +ASSERT_TRUE (skel->bss->found_value_a,"found_value_a" ); +ASSERT_TRUE (skel->bss->found_value_b,"found_value_b" ); + +out: +close (connect_fd); +close (sock_fd); +read_cgroupfs_xattr__destroy (skel); +move_pid_to_cgroup (CGROUP_FS_ROOT , pid); +reset_cgroups_and_lo (); +} + +void test_kernfs_xattr (void ) +{ +RUN_TESTS (kernfs_read_xattr); + +if (test__start_subtest ("read_cgroupfs_xattr" )) +test_read_cgroup_xattr (); +}
tools/testing/selftests/bpf/progs/kernfs_read_xattr.c new file +117 -0
117 lines not on this page · raw message
tools/testing/selftests/bpf/progs/read_cgroupfs_xattr.c new file +60 -0
60 lines not on this page · raw message
Signature · 1 line
2.47.1
Tejun Heo
maintainerHello,
Quoted 6 lines · Song Liu
Introduce a new kfunc
bpf_kernfs_read_xattr, which can read xattr from kernfs nodes (cgroupfs, for example). The primary users are LSMs, for example, from systemd.sched_extcould also use xattrs on cgroupfs nodes. However, this is not allowed yet, becausebpf_kernfs_read_xattris only allowed from LSM hooks. The plan is to addresssched_extlater (or in a later revision of this set).
I don't think kernfs is the name we should be exposing to BPF users. This is an implementation detail which may change in the future. I'd rather make it a generic interface or a cgroup specific one. The name "kernfs" doesn't really mean much outside kernel code that's using them.
Thanks.
Signature · 1 line
tejun
Christian Brauner
maintainerQuoted 10 lines · Tejun Heo
Hello,
Quoted 6 lines · Song Liu
Introduce a new kfunc
bpf_kernfs_read_xattr, which can read xattr from kernfs nodes (cgroupfs, for example). The primary users are LSMs, for example, from systemd.sched_extcould also use xattrs on cgroupfs nodes. However, this is not allowed yet, becausebpf_kernfs_read_xattris only allowed from LSM hooks. The plan is to addresssched_extlater (or in a later revision of this set).
Quoted 3 lines
I don't think kernfs is the name we should be exposing to BPF users. This is an implementation detail which may change in the future. I'd rather make it a generic interface or a cgroup specific one. The name "kernfs" doesn't
cgroup specific, please. That's what I suggested to Daan.
Quoted 15 lines · Christian Brauner
Quoted 10 lines · Tejun Heo
Hello,
Quoted 6 lines · Song Liu
Introduce a new kfunc
bpf_kernfs_read_xattr, which can read xattr from kernfs nodes (cgroupfs, for example). The primary users are LSMs, for example, from systemd.sched_extcould also use xattrs on cgroupfs nodes. However, this is not allowed yet, becausebpf_kernfs_read_xattris only allowed from LSM hooks. The plan is to addresssched_extlater (or in a later revision of this set).
Quoted 5 lines
Quoted 3 lines
I don't think kernfs is the name we should be exposing to BPF users. This is an implementation detail which may change in the future. I'd rather make it a generic interface or a cgroup specific one. The name "kernfs" doesn't
cgroup specific, please. That's what I suggested to Daan.
I guess there was some misunderstanding. I will make this cgroup specific in v2.
Thanks,
Song