Enable writing xattr from BPF programs
Subsystems (7)
Song Liu
reviewerv5 cover Enable writing xattr from BPF programs
Add support to set and remove xattr from BPF program. Also add security.bpf. xattr name prefix.
kfuncs are added to set and remove xattrs with security.bpf. name prefix. Update kfuncs bpf_get_[file|dentry]_xattr to read xattrs with security.bpf. name prefix. Note that BPF programs can read user. xattrs, but not write and remove them.
Cover letter of v1 and v2:
Follow up discussion in LPC 2024 [1], that we need security.bpf xattr prefix. This set adds "security.bpf." xattr name prefix, and allows bpf kfuncs bpf_get_[file|dentry]_xattr() to read these xattrs.
[1] https://lpc.events/event/18/contributions/1940/
Changes v4 => v5
1. Let verifier pick proper kfunc (_locked or not _locked) based on the calling context. (Alexei)
2. Remove the __failure test (6/6 of v4).
v4: https://lore.kernel.org/bpf/[email protected]/
Changes v3 => v4
1. Do write permission check with inode locked. (Jan Kara)
2. Fix some source_inline warnings.
v3: https://lore.kernel.org/bpf/[email protected]/
Changes v2 => v3
1. Add kfuncs to set and remove xattr from BPF programs.
v2: https://lore.kernel.org/bpf/[email protected]/
Changes v1 => v2
1. Update comment of bpf_get_[file|dentry]_xattr. (Jiri Olsa)
2. Fix comment for return value of bpf_get_[file|dentry]_xattr.
v1: https://lore.kernel.org/bpf/[email protected]/
Song Liu (5):
fs/xattr: bpf: Introduce security.bpf. xattr name prefix selftests/bpf: Extend test fs_kfuncs to cover security.bpf. xattr
names
bpf: lsm: Add two more sleepable hooks
bpf: fs/xattr: Add BPF kfuncs to set and remove xattrs selftests/bpf: Test kfuncs that set and remove xattr from BPF programs
fs/bpf_fs_kfuncs.c | 214 +++++++++++++++++- include/linux/bpf_lsm.h | 8 + include/uapi/linux/xattr.h | 4 + kernel/bpf/bpf_lsm.c | 2 + kernel/bpf/verifier.c | 55 ++++- tools/testing/selftests/bpf/bpf_kfuncs.h | 5 + .../selftests/bpf/prog_tests/fs_kfuncs.c | 162 ++++++++++++- .../selftests/bpf/progs/test_get_xattr.c | 28 ++- .../bpf/progs/test_set_remove_xattr.c | 133 +++++++++++ 9 files changed, 590 insertions(+), 21 deletions(-) create mode 100644 tools/testing/selftests/bpf/progs/test_set_remove_xattr.c
--
2.43.5
Song Liu
reviewerPATCH v5 1/5 fs/xattr: bpf: Introduce security.bpf. xattr name prefix
Introduct new xattr name prefix security.bpf., and enable reading these xattrs from bpf kfuncs bpf_get_[file|dentry]_xattr().
As we are on it, correct the comments for return value of bpf_get_[file|dentry]_xattr(), i.e. return length the xattr value on success.
--- fs/bpf_fs_kfuncs.c | 19 ++++++++++++++----- include/uapi/linux/xattr.h | 4 ++++ 2 files changed, 18 insertions(+), 5 deletions(-)
fs/bpf_fs_kfuncs.c +14 -5
@@ -93,6 +93,11 @@ __bpf_kfunc int bpf_path_d_path(struct path *path, char *buf, size_t buf__sz)return len; } +static bool match_security_bpf_prefix (const char *name__str) +{ +return !strncmp (name__str,XATTR_NAME_BPF_LSM ,XATTR_NAME_BPF_LSM_LEN ); +} +/** * bpf_get_dentry_xattr - get xattr of a dentry * @dentry: dentry to get xattr from
@@ -101,9 +106,10 @@ __bpf_kfunc int bpf_path_d_path(struct path *path, char *buf, size_t buf__sz)* * Get xattr *name__str* of *dentry* and store the output in *value_ptr*. * -* For security reasons, only *name__str* with prefix "user." is allowed. +* For security reasons, only *name__str* with prefix "user." or +* "security.bpf." is allowed. * -* Return: 0 on success, a negative value on error. +* Return: length of the xattr value on success, a negative value on error. */ __bpf_kfunc int bpf_get_dentry_xattr(struct dentry *dentry, const char *name__str,struct bpf_dynptr *value_p)
@@ -117,7 +123,9 @@ __bpf_kfunc int bpf_get_dentry_xattr(struct dentry *dentry, const char *name__stif (WARN_ON (!inode))return -EINVAL ; -if (strncmp (name__str,XATTR_USER_PREFIX ,XATTR_USER_PREFIX_LEN )) +/* Allow reading xattr with user. and security.bpf. prefix */ +if (strncmp (name__str,XATTR_USER_PREFIX ,XATTR_USER_PREFIX_LEN ) && + !match_security_bpf_prefix (name__str))return -EPERM ; value_len =__bpf_dynptr_size (value_ptr);
@@ -139,9 +147,10 @@ __bpf_kfunc int bpf_get_dentry_xattr(struct dentry *dentry, const char *name__st* * Get xattr *name__str* of *file* and store the output in *value_ptr*. * -* For security reasons, only *name__str* with prefix "user." is allowed. +* For security reasons, only *name__str* with prefix "user." or +* "security.bpf." is allowed. * -* Return: 0 on success, a negative value on error. +* Return: length of the xattr value on success, a negative value on error. */ __bpf_kfunc int bpf_get_file_xattr(struct file *file, const char *name__str,struct bpf_dynptr *value_p)
include/uapi/linux/xattr.h +4 -0
@@ -83,6 +83,10 @@ struct xattr_args {#define XATTR_CAPS_SUFFIX "capability"#define XATTR_NAME_CAPS XATTR_SECURITY_PREFIX XATTR_CAPS_SUFFIX +#define XATTR_BPF_LSM_SUFFIX "bpf." +#define XATTR_NAME_BPF_LSM (XATTR_SECURITY_PREFIX XATTR_BPF_LSM_SUFFIX) +#define XATTR_NAME_BPF_LSM_LEN (sizeof(XATTR_NAME_BPF_LSM) - 1) +#define XATTR_POSIX_ACL_ACCESS "posix_acl_access"#define XATTR_NAME_POSIX_ACL_ACCESS XATTR_SYSTEM_PREFIX XATTR_POSIX_ACL_ACCESS#define XATTR_POSIX_ACL_DEFAULT "posix_acl_default"
Signature · 1 line
2.43.5
Song Liu
reviewerPATCH v5 2/5 selftests/bpf: Extend test fs_kfuncs to cover security.bpf. xattr names
In reply to Song LiuExtend test_progs fs_kfuncs to cover different xattr names. Specifically:
xattr name "user.kfuncs" and "security.bpf.xxx" can be read from BPF program with kfuncs bpf_get_[file|dentry]_xattr(); while "security.bpf" and "security.selinux" cannot be read.
--- .../selftests/bpf/prog_tests/fs_kfuncs.c | 37 ++++++++++++++----- .../selftests/bpf/progs/test_get_xattr.c | 28 ++++++++++++-- 2 files changed, 51 insertions(+), 14 deletions(-)
tools/testing/selftests/bpf/prog_tests/fs_kfuncs.c +27 -10
@@ -12,7 +12,7 @@static const char testfile[] ="/tmp/test_progs_fs_kfuncs" ; -static void test_xattr (void ) +static void test_get_xattr (const char *name,const char *value,bool allow_access) {struct test_get_xattr *skel =NULL ;int fd =-1 , err;
@@ -25,7 +25,7 @@ static void test_xattr(void)close (fd); fd =-1 ; - err =setxattr (testfile,"user.kfuncs" ,"hello" ,sizeof ("hello" ),0 ); + err =setxattr (testfile, name, value,strlen (value) +1 ,0 );if (err && errno ==EOPNOTSUPP ) { printf("%s:SKIP:local fs doesn't support xattr (%d)\n" "To run this test, make sure /tmp filesystem supports xattr.\n",
@@ -48,16 +48,23 @@ static void test_xattr(void) goto out; fd =open (testfile,O_RDONLY ,0644 ); +if (!ASSERT_GE (fd,0 ,"open_file" )) goto out; -ASSERT_EQ (skel->bss->found_xattr_from_file,1 ,"found_xattr_from_file" ); -/* Trigger security_inode_getxattr */ - err =getxattr (testfile,"user.kfuncs" , v,sizeof (v)); -ASSERT_EQ (err,-1 ,"getxattr_return" ); -ASSERT_EQ (errno,EINVAL ,"getxattr_errno" ); -ASSERT_EQ (skel->bss->found_xattr_from_dentry,1 ,"found_xattr_from_dentry" ); + err =getxattr (testfile, name, v,sizeof (v)); + +if (allow_access) { +ASSERT_EQ (err,-1 ,"getxattr_return" ); +ASSERT_EQ (errno,EINVAL ,"getxattr_errno" ); +ASSERT_EQ (skel->bss->found_xattr_from_file,1 ,"found_xattr_from_file" ); +ASSERT_EQ (skel->bss->found_xattr_from_dentry,1 ,"found_xattr_from_dentry" ); + }else { +ASSERT_EQ (err,strlen (value) +1 ,"getxattr_return" ); +ASSERT_EQ (skel->bss->found_xattr_from_file,0 ,"found_xattr_from_file" ); +ASSERT_EQ (skel->bss->found_xattr_from_dentry,0 ,"found_xattr_from_dentry" ); + } out:close (fd);
@@ -141,8 +148,18 @@ static void test_fsverity(void)void test_fs_kfuncs (void ) { -if (test__start_subtest ("xattr" )) -test_xattr (); +/* Matches xattr_names in progs/test_get_xattr.c */ +if (test__start_subtest ("user_xattr" )) +test_get_xattr ("user.kfuncs" ,"hello" , true); + +if (test__start_subtest ("security_bpf_xattr" )) +test_get_xattr ("security.bpf.xxx" ,"hello" , true); + +if (test__start_subtest ("security_bpf_xattr_error" )) +test_get_xattr ("security.bpf" ,"hello" , false); + +if (test__start_subtest ("security_selinux_xattr_error" )) +test_get_xattr ("security.selinux" ,"hello" , false);if (test__start_subtest ("fsverity" ))test_fsverity ();
tools/testing/selftests/bpf/progs/test_get_xattr.c +24 -4
@@ -6,6 +6,7 @@#include <bpf/bpf_helpers.h> #include <bpf/bpf_tracing.h> #include "bpf_kfuncs.h" +#include "bpf_misc.h" char _license[] SEC("license") = "GPL";
@@ -17,12 +18,23 @@ static const char expected_value[] = "hello";char value1[32 ];char value2[32 ]; +/* Matches caller of test_get_xattr() in prog_tests/fs_kfuncs.c */ +static const char *const xattr_names[] = { +/* The following work. */ +"user.kfuncs" , +"security.bpf.xxx" , + +/* The following do not work. */ +"security.bpf" , +"security.selinux" +}; + SEC("lsm.s/file_open")int BPF_PROG (test_file_open ,struct file *f) {struct bpf_dynptr value_ptr;__u32 pid; -int ret; +int ret, i; pid =bpf_get_current_pid_tgid () >>32 ;if (pid != monitored_pid)
@@ -30,7 +42,11 @@ int BPF_PROG(test_file_open, struct file *f)bpf_dynptr_from_mem (value1,sizeof (value1),0 , &value_ptr); - ret =bpf_get_file_xattr (f,"user.kfuncs" , &value_ptr); +for (i =0 ; i <ARRAY_SIZE (xattr_names); i++) { + ret =bpf_get_file_xattr (f, xattr_names[i], &value_ptr); +if (ret ==sizeof (expected_value)) +break ; + }if (ret !=sizeof (expected_value))return 0 ;if (bpf_strncmp (value1, ret, expected_value))
@@ -44,7 +60,7 @@ int BPF_PROG(test_inode_getxattr, struct dentry *dentry, char *name) {struct bpf_dynptr value_ptr;__u32 pid; -int ret; +int ret, i; pid =bpf_get_current_pid_tgid () >>32 ;if (pid != monitored_pid)
@@ -52,7 +68,11 @@ int BPF_PROG(test_inode_getxattr, struct dentry *dentry, char *name)bpf_dynptr_from_mem (value2,sizeof (value2),0 , &value_ptr); - ret =bpf_get_dentry_xattr (dentry,"user.kfuncs" , &value_ptr); +for (i =0 ; i <ARRAY_SIZE (xattr_names); i++) { + ret =bpf_get_dentry_xattr (dentry, xattr_names[i], &value_ptr); +if (ret ==sizeof (expected_value)) +break ; + }if (ret !=sizeof (expected_value))return 0 ;if (bpf_strncmp (value2, ret, expected_value))
Signature · 1 line
2.43.5
Song Liu
reviewerPATCH v5 3/5 bpf: lsm: Add two more sleepable hooks
In reply to Song LiuAdd bpf_lsm_inode_removexattr and bpf_lsm_inode_post_removexattr to list sleepable_lsm_hooks. These two hooks are always called from sleepable context.
--- kernel/bpf/bpf_lsm.c | 2 ++ 1 file changed, 2 insertions(+)
kernel/bpf/bpf_lsm.c +2 -0
@@ -316,7 +316,9 @@ BTF_ID(func, bpf_lsm_inode_getxattr) BTF_ID(func, bpf_lsm_inode_mknod) BTF_ID(func, bpf_lsm_inode_need_killpriv) BTF_ID(func, bpf_lsm_inode_post_setxattr) +BTF_ID(func, bpf_lsm_inode_post_removexattr) BTF_ID(func, bpf_lsm_inode_readlink) +BTF_ID(func, bpf_lsm_inode_removexattr) BTF_ID(func, bpf_lsm_inode_rename) BTF_ID(func, bpf_lsm_inode_rmdir)BTF_ID (func, bpf_lsm_inode_setattr)
Signature · 1 line
2.43.5
Song Liu
reviewerPATCH v5 4/5 bpf: fs/xattr: Add BPF kfuncs to set and remove xattrs
In reply to Song LiuAdd the following kfuncs to set and remove xattrs from BPF programs:
bpf_set_dentry_xattr
bpf_remove_dentry_xattr
bpf_set_dentry_xattr_locked
bpf_remove_dentry_xattr_locked
The _locked version of these kfuncs are called from hooks where dentry->d_inode is already locked. Instead of requiring the user to know which version of the kfuncs to use, the verifier will pick the proper kfunc based on the calling hook.
--- fs/bpf_fs_kfuncs.c | 195 ++++++++++++++++++++++++++++++++++++++++ include/linux/bpf_lsm.h | 8 ++ kernel/bpf/verifier.c | 55 +++++++++++- 3 files changed, 256 insertions(+), 2 deletions(-)
fs/bpf_fs_kfuncs.c +195 -0
@@ -2,10 +2,12 @@/* Copyright (c) 2024 Google LLC. */ #include <linux/bpf.h> +#include <linux/bpf_lsm.h> #include <linux/btf.h> #include <linux/btf_ids.h> #include <linux/dcache.h> #include <linux/fs.h> +#include <linux/fsnotify.h> #include <linux/file.h> #include <linux/mm.h> #include <linux/xattr.h>
@@ -161,6 +163,164 @@ __bpf_kfunc int bpf_get_file_xattr(struct file *file, const char *name__str,return bpf_get_dentry_xattr (dentry, name__str, value_p); } +static int bpf_xattr_write_permission (const char *name,struct inode *inode) +{ +if (WARN_ON (!inode)) +return -EINVAL ; + +/* Only allow setting and removing security.bpf. xattrs */ +if (!match_security_bpf_prefix (name)) +return -EPERM ; + +return inode_permission (&nop_mnt_idmap, inode,MAY_WRITE ); +} + +static int __bpf_set_dentry_xattr (struct dentry *dentry,const char *name, +const struct bpf_dynptr *value_p,int flags,bool lock_inode) +{ +struct bpf_dynptr_kern *value_ptr = (struct bpf_dynptr_kern *)value_p; +struct inode *inode =d_inode (dentry); +const void *value; +u32 value_len; +int ret; + + value_len =__bpf_dynptr_size (value_ptr); + value =__bpf_dynptr_data (value_ptr, value_len); +if (!value) +return -EINVAL ; + +if (lock_inode) +inode_lock (inode); + + ret =bpf_xattr_write_permission (name, inode); +if (ret) + goto out; + + ret =__vfs_setxattr (&nop_mnt_idmap, dentry, inode, name, + value, value_len, flags); +if (!ret) { +fsnotify_xattr (dentry); + +/* This xattr is set by BPF LSM, so we do not call +* security_inode_post_setxattr. This is the same as +* security_inode_setsecurity(). +*/ + } +out: +if (lock_inode) +inode_unlock (inode); +return ret; +} + +/** +* bpf_set_dentry_xattr - set a xattr of a dentry +* @dentry: dentry to get xattr from +* @name__str: name of the xattr +* @value_p: xattr value +* @flags: flags to pass into filesystem operations +* +* Set xattr *name__str* of *dentry* to the value in *value_ptr*. +* +* For security reasons, only *name__str* with prefix "security.bpf." +* is allowed. +* +* The caller has not locked dentry->d_inode. +* +* Return: 0 on success, a negative value on error. +*/ +__bpf_kfunc int bpf_set_dentry_xattr(struct dentry *dentry, const char *name__str, +const struct bpf_dynptr *value_p,int flags) +{ +return __bpf_set_dentry_xattr (dentry, name__str, value_p, flags, true); +} + +/** +* bpf_set_dentry_xattr_locked - set a xattr of a dentry +* @dentry: dentry to get xattr from +* @name__str: name of the xattr +* @value_p: xattr value +* @flags: flags to pass into filesystem operations +* +* Set xattr *name__str* of *dentry* to the value in *value_ptr*. +* +* For security reasons, only *name__str* with prefix "security.bpf." +* is allowed. +* +* The caller already locked dentry->d_inode. +* +* Return: 0 on success, a negative value on error. +*/ +__bpf_kfunc int bpf_set_dentry_xattr_locked(struct dentry *dentry, const char *name__str, +const struct bpf_dynptr *value_p,int flags) +{ +return __bpf_set_dentry_xattr (dentry, name__str, value_p, flags, false); +} + +static int __bpf_remove_dentry_xattr (struct dentry *dentry,const char *name__str, +bool lock_inode) +{ +struct inode *inode =d_inode (dentry); +int ret; + +if (lock_inode) +inode_lock (inode); + + ret =bpf_xattr_write_permission (name__str, inode); +if (ret) + goto out; + + ret =__vfs_removexattr (&nop_mnt_idmap, dentry, name__str); +if (!ret) { +fsnotify_xattr (dentry); + +/* This xattr is removed by BPF LSM, so we do not call +* security_inode_post_removexattr. +*/ + } +out: +if (lock_inode) +inode_unlock (inode); +return ret; +} + +/** +* bpf_remove_dentry_xattr - remove a xattr of a dentry +* @dentry: dentry to get xattr from +* @name__str: name of the xattr +* +* Rmove xattr *name__str* of *dentry*. +* +* For security reasons, only *name__str* with prefix "security.bpf." +* is allowed. +* +* The caller has not locked dentry->d_inode. +* +* Return: 0 on success, a negative value on error. +*/ +__bpf_kfunc int bpf_remove_dentry_xattr(struct dentry *dentry, const char *name__str) +{ +return __bpf_remove_dentry_xattr (dentry, name__str, true); +} + +/** +* bpf_remove_dentry_xattr_locked - remove a xattr of a dentry +* @dentry: dentry to get xattr from +* @name__str: name of the xattr +* +* Rmove xattr *name__str* of *dentry*. +* +* For security reasons, only *name__str* with prefix "security.bpf." +* is allowed. +* +* The caller already locked dentry->d_inode. +* +* Return: 0 on success, a negative value on error. +*/ +__bpf_kfunc int bpf_remove_dentry_xattr_locked(struct dentry *dentry, const char *name__str) +{ +return __bpf_remove_dentry_xattr (dentry, name__str, false); +} +__bpf_kfunc_end_defs ();BTF_KFUNCS_START (bpf_fs_kfunc_set_ids)
@@ -170,6 +330,10 @@ BTF_ID_FLAGS(func, bpf_put_file, KF_RELEASE) BTF_ID_FLAGS(func, bpf_path_d_path, KF_TRUSTED_ARGS) 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_set_dentry_xattr_locked, KF_SLEEPABLE | KF_TRUSTED_ARGS) +BTF_ID_FLAGS(func, bpf_remove_dentry_xattr_locked, KF_SLEEPABLE | KF_TRUSTED_ARGS)BTF_KFUNCS_END (bpf_fs_kfunc_set_ids) static int bpf_fs_kfuncs_filter(const struct bpf_prog *prog, u32 kfunc_id)
@@ -186,6 +350,37 @@ static const struct btf_kfunc_id_set bpf_fs_kfunc_set = { .filter = bpf_fs_kfuncs_filter, }; +/* bpf_[set|remove]_dentry_xattr.* hooks have KF_TRUSTED_ARGS and +* KF_SLEEPABLE, so they are only available to sleepable hooks with +* dentry arguments. +* +* Setting and removing xattr requires exclusive lock on dentry->d_inode. +* Some hooks already locked d_inode, while some hooks have not locked +* d_inode. Therefore, we need different kfuncs for different hooks. +* Specifically, hooks in the following list (d_inode_locked_hooks) +* should call bpf_[set|remove]_dentry_xattr_locked; while other hooks +* should call bpf_[set|remove]_dentry_xattr. +*/ +BTF_SET_START (d_inode_locked_hooks) +BTF_ID (func ,bpf_lsm_inode_post_removexattr ) +BTF_ID (func, bpf_lsm_inode_post_setattr) +BTF_ID (func, bpf_lsm_inode_post_setxattr) +BTF_ID (func, bpf_lsm_inode_removexattr) +BTF_ID (func, bpf_lsm_inode_rmdir) +BTF_ID (func, bpf_lsm_inode_setattr) +BTF_ID (func, bpf_lsm_inode_setxattr) +BTF_ID (func, bpf_lsm_inode_unlink) +#ifdef CONFIG_SECURITY_PATH +BTF_ID (func, bpf_lsm_path_unlink) +BTF_ID (func, bpf_lsm_path_rmdir) +#endif /* CONFIG_SECURITY_PATH */ +BTF_SET_END (d_inode_locked_hooks) + +bool bpf_lsm_has_d_inode_locked(const struct bpf_prog *prog) +{ +return btf_id_set_contains (&d_inode_locked_hooks, prog->aux->attach_btf_id); +} +static int __init bpf_fs_kfuncs_init (void ) {return register_btf_kfunc_id_set (BPF_PROG_TYPE_LSM , &bpf_fs_kfunc_set);
include/linux/bpf_lsm.h +8 -0
@@ -48,6 +48,9 @@ void bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog, bpf_func_t *bpf_func)int bpf_lsm_get_retval_range (const struct bpf_prog *prog,struct bpf_retval_range *range); + +bool bpf_lsm_has_d_inode_locked (const struct bpf_prog *prog); +#else /* !CONFIG_BPF_LSM */ static inline bool bpf_lsm_is_sleepable_hook (u32 btf_id)
@@ -86,6 +89,11 @@ static inline int bpf_lsm_get_retval_range(const struct bpf_prog *prog, {return -EOPNOTSUPP ; } + +static inline bool bpf_lsm_has_d_inode_locked (const struct bpf_prog *prog) +{ +return false; +}#endif /* CONFIG_BPF_LSM */ #endif /* _LINUX_BPF_LSM_H */
kernel/bpf/verifier.c +53 -2
87 lines not on this page · raw message
Signature · 1 line
2.43.5
Re: [PATCH v5 bpf-next 4/5] bpf: fs/xattr: Add BPF kfuncs to set and remove xattrs
fs/bpf_fs_kfuncs.c BTF_ID_FLAGS(func, bpf_put_file, KF_RELEASE) · line 337
Quoted 12 lines · Song Liu
BTF_KFUNCS_START(bpf_fs_kfunc_set_ids)fs/bpf_fs_kfuncs.c +4
-0@@ -170,6 +330,10 @@ BTF_ID_FLAGS(func, bpf_put_file, KF_RELEASE) BTF_ID_FLAGS(func, bpf_path_d_path, KF_TRUSTED_ARGS) 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_set_dentry_xattr_locked, KF_SLEEPABLE | KF_TRUSTED_ARGS) +BTF_ID_FLAGS(func, bpf_remove_dentry_xattr_locked, KF_SLEEPABLE | KF_TRUSTED_ARGS)BTF_KFUNCS_END (bpf_fs_kfunc_set_ids)
The _locked() versions shouldn't be exposed to bpf prog. Don't add them to the above set.
Also we need to somehow exclude them from being dumped into vmlinux.h
Quoted 104 lines
fs/bpf_fs_kfuncs.c +31
-0static int bpf_fs_kfuncs_filter (const struct bpf_prog *prog,u32 kfunc_id)@@ -186,6 +350,37 @@ static const struct btf_kfunc_id_set bpf_fs_kfunc_set = { .filter = bpf_fs_kfuncs_filter, }; +/* bpf_[set|remove]_dentry_xattr.* hooks have KF_TRUSTED_ARGS and +* KF_SLEEPABLE, so they are only available to sleepable hooks with +* dentry arguments. +* +* Setting and removing xattr requires exclusive lock on dentry->d_inode. +* Some hooks already locked d_inode, while some hooks have not locked +* d_inode. Therefore, we need different kfuncs for different hooks. +* Specifically, hooks in the following list (d_inode_locked_hooks) +* should call bpf_[set|remove]_dentry_xattr_locked; while other hooks +* should call bpf_[set|remove]_dentry_xattr. +*/ +BTF_SET_START (d_inode_locked_hooks) +BTF_ID (func ,bpf_lsm_inode_post_removexattr ) +BTF_ID (func, bpf_lsm_inode_post_setattr) +BTF_ID (func, bpf_lsm_inode_post_setxattr) +BTF_ID (func, bpf_lsm_inode_removexattr) +BTF_ID (func, bpf_lsm_inode_rmdir) +BTF_ID (func, bpf_lsm_inode_setattr) +BTF_ID (func, bpf_lsm_inode_setxattr) +BTF_ID (func, bpf_lsm_inode_unlink) +#ifdef CONFIG_SECURITY_PATH +BTF_ID (func, bpf_lsm_path_unlink) +BTF_ID (func, bpf_lsm_path_rmdir) +#endif /* CONFIG_SECURITY_PATH */ +BTF_SET_END (d_inode_locked_hooks) + +bool bpf_lsm_has_d_inode_locked(const struct bpf_prog *prog) +{ +return btf_id_set_contains (&d_inode_locked_hooks, prog->aux->attach_btf_id); +} +static int __init bpf_fs_kfuncs_init (void ) {return register_btf_kfunc_id_set (BPF_PROG_TYPE_LSM , &bpf_fs_kfunc_set);include/linux/bpf_lsm.h +8
-0@@ -48,6 +48,9 @@ void bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog, bpf_func_t *bpf_func)int bpf_lsm_get_retval_range (const struct bpf_prog *prog,struct bpf_retval_range *range); + +bool bpf_lsm_has_d_inode_locked (const struct bpf_prog *prog); +#else /* !CONFIG_BPF_LSM */ static inline bool bpf_lsm_is_sleepable_hook (u32 btf_id)@@ -86,6 +89,11 @@ static inline int bpf_lsm_get_retval_range(const struct bpf_prog *prog, {return -EOPNOTSUPP ; } + +static inline bool bpf_lsm_has_d_inode_locked (const struct bpf_prog *prog) +{ +return false; +}#endif /* CONFIG_BPF_LSM */ #endif /* _LINUX_BPF_LSM_H */ kernel/bpf/verifier.c +9
-2@@ -206,6 +206,7 @@ static int ref_set_non_owning(struct bpf_verifier_env *env,static void specialize_kfunc (struct bpf_verifier_env *env,u32 func_id,u16 offset,unsigned long *addr);static bool is_trusted_reg (const struct bpf_reg_state *reg); +static void remap_kfunc_locked_func_id (struct bpf_verifier_env *env,struct bpf_insn *insn);static bool bpf_map_ptr_poisoned (const struct bpf_insn_aux_data *aux) {@@ -3224,10 +3225,12 @@ static int add_subprog_and_kfunc(struct bpf_verifier_env *env)return -EPERM ; } -if (bpf_pseudo_func (insn) ||bpf_pseudo_call (insn)) +if (bpf_pseudo_func (insn) ||bpf_pseudo_call (insn)) { ret =add_subprog (env, i + insn->imm +1 ); -else + }else { +remap_kfunc_locked_func_id (env, insn); ret =add_kfunc_call (env, insn->imm, insn->off); + }if (ret <0 )return ret;@@ -11690,6 +11693,10 @@ enum special_kfunc_type { KF_bpf_get_kmem_cache, KF_bpf_local_irq_save, KF_bpf_local_irq_restore, + KF_bpf_set_dentry_xattr, + KF_bpf_remove_dentry_xattr, + KF_bpf_set_dentry_xattr_locked, + KF_bpf_remove_dentry_xattr_locked, };BTF_SET_START (special_kfunc_set)
kernel/bpf/verifier.c BTF_ID(func, bpf_wq_set_callback_impl) · line 11735
Quoted 10 lines
kernel/bpf/verifier.c +6
-0@@ -11719,6 +11726,12 @@ BTF_ID(func, bpf_wq_set_callback_impl)#ifdef CONFIG_CGROUPS BTF_ID(func, bpf_iter_css_task_new)#endif +#ifdef CONFIG_BPF_LSM +BTF_ID(func, bpf_set_dentry_xattr) +BTF_ID(func, bpf_remove_dentry_xattr) +BTF_ID(func, bpf_set_dentry_xattr_locked) +BTF_ID(func, bpf_remove_dentry_xattr_locked) +#endif BTF_SET_END (special_kfunc_set)
Do they need to be a part of special_kfunc_set ?
Where is the code that uses that?
Quoted 9 lines
kernel/bpf/verifier.c +3
-0BTF_ID_LIST (special_kfunc_list)@@ -11762,6 +11775,44 @@ BTF_ID_UNUSED BTF_ID(func, bpf_get_kmem_cache) BTF_ID(func, bpf_local_irq_save) BTF_ID(func, bpf_local_irq_restore) +#ifdef CONFIG_BPF_LSM +BTF_ID(func, bpf_set_dentry_xattr) +BTF_ID (func, bpf_remove_dentry_xattr)
kernel/bpf/verifier.c BTF_ID_UNUSED · line 11790
Quoted 10 lines
kernel/bpf/verifier.c +10
-0+BTF_ID(func, bpf_set_dentry_xattr_locked) +BTF_ID(func, bpf_remove_dentry_xattr_locked) +#else +BTF_ID_UNUSED +BTF_ID_UNUSED +BTF_ID_UNUSED +BTF_ID_UNUSED +#endif + +/* Sometimes, we need slightly different verions of a kfunc for different
versions
Quoted 11 lines
kernel/bpf/verifier.c +11
-0+* contexts/hooks, for example, bpf_set_dentry_xattr vs. +* bpf_set_dentry_xattr_locked. The former kfunc need to lock the inode +* rwsem, while the latter is called with the inode rwsem held (by the +* caller). +* +* To avoid burden on the users, we allow either version of the kfunc in +* either context. Then the verifier will remap the kfunc to the proper +* version based the context. +*/ +static void remap_kfunc_locked_func_id (struct bpf_verifier_env *env,struct bpf_insn *insn) +{
kernel/bpf/verifier.c BTF_ID_UNUSED · line 11811
Quoted 10 lines
kernel/bpf/verifier.c +10
-0+u32 func_id = insn->imm; + +if (bpf_lsm_has_d_inode_locked (env->prog)) { +if (func_id == special_kfunc_list[KF_bpf_set_dentry_xattr]) + insn->imm = special_kfunc_list[KF_bpf_set_dentry_xattr_locked]; +else if (func_id == special_kfunc_list[KF_bpf_remove_dentry_xattr]) + insn->imm = special_kfunc_list[KF_bpf_remove_dentry_xattr_locked]; + }else { +if (func_id == special_kfunc_list[KF_bpf_set_dentry_xattr_locked]) + insn->imm = special_kfunc_list[KF_bpf_set_dentry_xattr];
This part is not necessary._locked() shouldn't be exposed and it should be an error if bpf prog attempts to use invalid kfunc.
Quoted 10 lines
kernel/bpf/verifier.c +4
-1+else if (func_id == special_kfunc_list[KF_bpf_remove_dentry_xattr_locked]) + insn->imm = special_kfunc_list[KF_bpf_remove_dentry_xattr]; + } +}static bool is_kfunc_ret_null (struct bpf_kfunc_call_arg_meta *meta) { --2.43.5
Re: [PATCH v5 bpf-next 4/5] bpf: fs/xattr: Add BPF kfuncs to set and remove xattrs
Hi Alexei,
Thanks for the review!
Quoted 25 lines · Alexei Starovoitov
fs/bpf_fs_kfuncs.c BTF_ID_FLAGS(func, bpf_put_file, KF_RELEASE) · line 337
Quoted 12 lines · Song Liu
BTF_KFUNCS_START(bpf_fs_kfunc_set_ids)fs/bpf_fs_kfuncs.c +4
-0@@ -170,6 +330,10 @@ BTF_ID_FLAGS(func, bpf_put_file, KF_RELEASE) BTF_ID_FLAGS(func, bpf_path_d_path, KF_TRUSTED_ARGS) 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_set_dentry_xattr_locked, KF_SLEEPABLE | KF_TRUSTED_ARGS) +BTF_ID_FLAGS(func, bpf_remove_dentry_xattr_locked, KF_SLEEPABLE | KF_TRUSTED_ARGS)BTF_KFUNCS_END (bpf_fs_kfunc_set_ids)The
_locked()versions shouldn't be exposed to bpf prog. Don't add them to the above set.Also we need to somehow exclude them from being dumped into
vmlinux.hQuoted 4 lines
fs/bpf_fs_kfuncs.c +0
-0static int bpf_fs_kfuncs_filter (const struct bpf_prog *prog,u32 kfunc_id)@@ -186,6 +350,37 @@ static const struct btf_kfunc_id_set bpf_fs_kfunc_set = { .filter = bpf_fs_kfuncs_filter, };
[...]
Quoted 9 lines
Quoted 9 lines
+ */
kernel/bpf/verifier.c +8
-0+static void remap_kfunc_locked_func_id (struct bpf_verifier_env *env,struct bpf_insn *insn) +{ +u32 func_id = insn->imm; + +if (bpf_lsm_has_d_inode_locked (env->prog)) { +if (func_id == special_kfunc_list[KF_bpf_set_dentry_xattr]) + insn->imm = special_kfunc_list[KF_bpf_set_dentry_xattr_locked]; +else if (func_id == special_kfunc_list[KF_bpf_remove_dentry_xattr])
Quoted 8 lines
kernel/bpf/verifier.c BTF_ID_UNUSED · line 11811
Quoted 4 lines
kernel/bpf/verifier.c +4
-0+ insn->imm = special_kfunc_list[KF_bpf_remove_dentry_xattr_locked]; + }else { +if (func_id == special_kfunc_list[KF_bpf_set_dentry_xattr_locked]) + insn->imm = special_kfunc_list[KF_bpf_set_dentry_xattr];This part is not necessary.
_locked()shouldn't be exposed and it should be an error if bpf prog attempts to use invalid kfunc.
I was implementing this in different way than the solution you and Kumar suggested. Instead of updating this in add_kfunc_call, check_kfunc_call, and fixup_kfunc_call, remap_kfunc_locked_func_id happens before add_kfunc_call. Then, for the rest of the process, the verifier handles _locked version and not _locked version as two different kfuncs. This is why we need the _locked version in bpf_fs_kfunc_set_ids. I personally think this approach is a lot cleaner.
I think the missing piece is to exclude the _locked version from vmlinux.h. Maybe we can achieve this by adding a different DECL_TAG to these kfuncs?
Does this make sense?
Thanks,
Song
Re: [PATCH v5 bpf-next 4/5] bpf: fs/xattr: Add BPF kfuncs to set and remove xattrs
Quoted 62 lines · Song Liu
Hi Alexei,
Thanks for the review!
Quoted 25 lines · Alexei Starovoitov
fs/bpf_fs_kfuncs.c BTF_ID_FLAGS(func, bpf_put_file, KF_RELEASE) · line 337
Quoted 12 lines · Song Liu
BTF_KFUNCS_START(bpf_fs_kfunc_set_ids)fs/bpf_fs_kfuncs.c +4
-0@@ -170,6 +330,10 @@ BTF_ID_FLAGS(func, bpf_put_file, KF_RELEASE) BTF_ID_FLAGS(func, bpf_path_d_path, KF_TRUSTED_ARGS) 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_set_dentry_xattr_locked, KF_SLEEPABLE | KF_TRUSTED_ARGS) +BTF_ID_FLAGS(func, bpf_remove_dentry_xattr_locked, KF_SLEEPABLE | KF_TRUSTED_ARGS)BTF_KFUNCS_END (bpf_fs_kfunc_set_ids)The
_locked()versions shouldn't be exposed to bpf prog. Don't add them to the above set.Also we need to somehow exclude them from being dumped into
vmlinux.hQuoted 4 lines
fs/bpf_fs_kfuncs.c +0
-0static int bpf_fs_kfuncs_filter (const struct bpf_prog *prog,u32 kfunc_id)@@ -186,6 +350,37 @@ static const struct btf_kfunc_id_set bpf_fs_kfunc_set = { .filter = bpf_fs_kfuncs_filter, };[...]
Quoted 9 lines
Quoted 9 lines
+ */
kernel/bpf/verifier.c +8
-0+static void remap_kfunc_locked_func_id (struct bpf_verifier_env *env,struct bpf_insn *insn) +{ +u32 func_id = insn->imm; + +if (bpf_lsm_has_d_inode_locked (env->prog)) { +if (func_id == special_kfunc_list[KF_bpf_set_dentry_xattr]) + insn->imm = special_kfunc_list[KF_bpf_set_dentry_xattr_locked]; +else if (func_id == special_kfunc_list[KF_bpf_remove_dentry_xattr])Quoted 8 lines
kernel/bpf/verifier.c BTF_ID_UNUSED · line 11811
Quoted 4 lines
kernel/bpf/verifier.c +4
-0+ insn->imm = special_kfunc_list[KF_bpf_remove_dentry_xattr_locked]; + }else { +if (func_id == special_kfunc_list[KF_bpf_set_dentry_xattr_locked]) + insn->imm = special_kfunc_list[KF_bpf_set_dentry_xattr];This part is not necessary.
_locked()shouldn't be exposed and it should be an error if bpf prog attempts to use invalid kfunc.I was implementing this in different way than the solution you and Kumar suggested. Instead of updating this in
add_kfunc_call,check_kfunc_call, andfixup_kfunc_call,remap_kfunc_locked_func_idhappens beforeadd_kfunc_call. Then, for the rest of the process, the verifier handles_lockedversion and not_lockedversion as two different kfuncs. This is why we need the_lockedversion inbpf_fs_kfunc_set_ids. I personally think this approach is a lot cleaner.
Quoted 3 lines
I think the missing piece is to exclude the
_lockedversion fromvmlinux.h. Maybe we can achieve this by adding a differentDECL_TAGto these kfuncs?
Looked into the code, I think it is doable:
1. Extend struct btf_kfunc_id_set with "struct btf_id_set8 *shadow_set", or a different name;
2. Add _locked kfuncs to shadow_set, and these kfuncs will not have BTF_SET8_KFUNCS set. Then pahole will not generate DECL_TAG of "bpf_kfunc" for these.
3. __btf_kfunc_id_set_contains() will need to look up id from shadow_set. And the filter function needs to handle shadow_set.
Does this sound sane?
Thanks,
Song
Re: [PATCH v5 bpf-next 4/5] bpf: fs/xattr: Add BPF kfuncs to set and remove xattrs
In reply to Song LiuQuoted 51 lines · Song Liu
Hi Alexei,
Thanks for the review!
Quoted 25 lines · Alexei Starovoitov
fs/bpf_fs_kfuncs.c BTF_ID_FLAGS(func, bpf_put_file, KF_RELEASE) · line 337
Quoted 12 lines · Song Liu
BTF_KFUNCS_START(bpf_fs_kfunc_set_ids)fs/bpf_fs_kfuncs.c +4
-0@@ -170,6 +330,10 @@ BTF_ID_FLAGS(func, bpf_put_file, KF_RELEASE) BTF_ID_FLAGS(func, bpf_path_d_path, KF_TRUSTED_ARGS) 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_set_dentry_xattr_locked, KF_SLEEPABLE | KF_TRUSTED_ARGS) +BTF_ID_FLAGS(func, bpf_remove_dentry_xattr_locked, KF_SLEEPABLE | KF_TRUSTED_ARGS)BTF_KFUNCS_END (bpf_fs_kfunc_set_ids)The
_locked()versions shouldn't be exposed to bpf prog. Don't add them to the above set.Also we need to somehow exclude them from being dumped into
vmlinux.hQuoted 4 lines
fs/bpf_fs_kfuncs.c +0
-0static int bpf_fs_kfuncs_filter (const struct bpf_prog *prog,u32 kfunc_id)@@ -186,6 +350,37 @@ static const struct btf_kfunc_id_set bpf_fs_kfunc_set = { .filter = bpf_fs_kfuncs_filter, };[...]
Quoted 9 lines
Quoted 9 lines
+ */
kernel/bpf/verifier.c +8
-0+static void remap_kfunc_locked_func_id (struct bpf_verifier_env *env,struct bpf_insn *insn) +{ +u32 func_id = insn->imm; + +if (bpf_lsm_has_d_inode_locked (env->prog)) { +if (func_id == special_kfunc_list[KF_bpf_set_dentry_xattr]) + insn->imm = special_kfunc_list[KF_bpf_set_dentry_xattr_locked]; +else if (func_id == special_kfunc_list[KF_bpf_remove_dentry_xattr])Quoted 8 lines
kernel/bpf/verifier.c BTF_ID_UNUSED · line 11811
Quoted 4 lines
kernel/bpf/verifier.c +4
-0+ insn->imm = special_kfunc_list[KF_bpf_remove_dentry_xattr_locked]; + }else { +if (func_id == special_kfunc_list[KF_bpf_set_dentry_xattr_locked]) + insn->imm = special_kfunc_list[KF_bpf_set_dentry_xattr];This part is not necessary.
_locked()shouldn't be exposed and it should be an error if bpf prog attempts to use invalid kfunc.
Quoted 7 lines
I was implementing this in different way than the solution you and Kumar suggested. Instead of updating this in
add_kfunc_call,check_kfunc_call, andfixup_kfunc_call,remap_kfunc_locked_func_idhappens beforeadd_kfunc_call. Then, for the rest of the process, the verifier handles_lockedversion and not_lockedversion as two different kfuncs. This is why we need the_lockedversion inbpf_fs_kfunc_set_ids. I personally think this approach is a lot cleaner.
I see. Blind rewrite in add_kfunc_call() looks simpler, but allowing progs call _locked() version directly is not clean.
See specialize_kfunc() as an existing approach that does polymorphism.
_locked() doesn't need to be __bpf_kfunc annotated. It can be just like bpf_dynptr_from_skb_rdonly.
There will be no issue with vmlinux.h as well.
Re: [PATCH v5 bpf-next 4/5] bpf: fs/xattr: Add BPF kfuncs to set and remove xattrs
Quoted 2 lines · Alexei Starovoitov
[...]
Quoted 12 lines
Quoted 11 lines
Quoted 3 lines
This part is not necessary.
_locked()shouldn't be exposed and it should be an error if bpf prog attempts to use invalid kfunc.I was implementing this in different way than the solution you and Kumar suggested. Instead of updating this in
add_kfunc_call,check_kfunc_call, andfixup_kfunc_call,remap_kfunc_locked_func_idhappens beforeadd_kfunc_call. Then, for the rest of the process, the verifier handles_lockedversion and not_lockedversion as two different kfuncs. This is why we need the_lockedversion inbpf_fs_kfunc_set_ids. I personally think this approach is a lot cleaner.
Quoted 2 lines
I see. Blind rewrite in
add_kfunc_call()looks simpler, but allowing progs call_locked()version directly is not clean.
Agreed.
Quoted 5 lines
See
specialize_kfunc()as an existing approach that does polymorphism.
_locked()doesn't need to be__bpf_kfuncannotated. It can be just likebpf_dynptr_from_skb_rdonly.
I am thinking about a more modular approach. Instead of pushing the polymorphism logic to verifer.c, we can have each btf_kfunc_id_set handle the remap of its kfuncs. Specifically, we can extend btf_kfunc_id_set as:
typedef u32 (*btf_kfunc_remap_t)(const struct bpf_prog *prog, u32 kfunc_id);
struct btf_kfunc_id_set {
struct module *owner;
struct btf_id_set8 *set;
/* hidden_set contains kfuncs that are not marked as kfunc in
* vmlinux.h. These kfuncs are usually a variation of a kfunc
* in @set.
*/
struct btf_id_set8 *hidden_set;
btf_kfunc_filter_t filter;
/* @remap method matches kfuncs in @set to proper version in
* @hidden_set.
*/
btf_kfunc_remap_t remap;
};In this case, not_locked version of kfuncs will be added to @set; while _locked kfuncs will be added to @hidden_set. @hidden_set will not be exposed in vmlinux.h. Then the new remap method is used to map not_locked kfuncs to _locked kfuncs for inode-locked context.
We can also move bpf_dynptr_from_skb_rdonly to this model, and simplify specialize_kfunc().
I will send patch for this version for review.
Thanks,
Song
Song Liu
reviewerPATCH v5 5/5 selftests/bpf: Test kfuncs that set and remove xattr from BPF programs
In reply to Song LiuTwo sets of tests are added to exercise the not _locked and _locked version of the kfuncs. For both tests, user space accesses xattr security.bpf.foo on a testfile. The BPF program is triggered by user space access (on LSM hook inode_[set|get]_xattr) and sets or removes xattr security.bpf.bar. Then user space then validates that xattr security.bpf.bar is set or removed as expected.
Note that, in both tests, the BPF programs use the not _locked kfuncs. The verifier picks the proper kfuncs based on the calling context.
--- tools/testing/selftests/bpf/bpf_kfuncs.h | 5 + .../selftests/bpf/prog_tests/fs_kfuncs.c | 125 ++++++++++++++++ .../bpf/progs/test_set_remove_xattr.c | 133 ++++++++++++++++++ 3 files changed, 263 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/test_set_remove_xattr.c
tools/testing/selftests/bpf/bpf_kfuncs.h +5 -0
@@ -87,4 +87,9 @@ struct dentry;*/ extern int bpf_get_dentry_xattr(struct dentry *dentry, const char *name, struct bpf_dynptr *value_ptr) __ksym __weak; + +extern int bpf_set_dentry_xattr(struct dentry *dentry, const char *name__str, + const struct bpf_dynptr *value_p, int flags) __ksym __weak; +extern int bpf_remove_dentry_xattr(struct dentry *dentry, const char *name__str) __ksym __weak; +#endif
tools/testing/selftests/bpf/prog_tests/fs_kfuncs.c +125 -0
143 lines not on this page · raw message
tools/testing/selftests/bpf/progs/test_set_remove_xattr.c new file +133 -0
133 lines not on this page · raw message
Signature · 1 line
2.43.5