bpf: Extend BPF syscall with common attributes support
Subsystems (6)
v14 cover bpf: Extend BPF syscall with common attributes support
This patch series builds upon the discussion in
"[PATCH bpf-next v4 0/4] bpf: Improve error reporting for freplace attachment failure" [1].
This patch series introduces support for *common attributes* in the BPF syscall, providing a unified mechanism for passing shared metadata across all BPF commands, initially used by BPF_PROG_LOAD, BPF_BTF_LOAD, and BPF_MAP_CREATE.
The initial set of common attributes includes:
1. 'log_buf': User-provided buffer for storing log output.
2. 'log_size': Size of the provided log buffer.
3. 'log_level': Verbosity level for logging.
4. 'log_true_size': Actual log size reported by kernel.
With this extension, the BPF syscall will be able to return meaningful error messages (e.g., map creation failures), improving debuggability and user experience.
Links:
[1] https://lore.kernel.org/bpf/[email protected]/
Changes:
v13 -> v14:
* Replace __u64 with __aligned_u64 in struct bpf_common_attr in patch #1 (per bot+bpf-ci).
* Add a single line comment for preserving original error in patch #6 (per bot+bpf-ci and Alexei).
* Drop unused label in patch #6 (per bot+bpf-ci).
* v13: https://lore.kernel.org/bpf/[email protected]/
v12 -> v13:
* Rebase on bpf-next tree to resolve code conflict.
* Report log_true_size on success path in patch #6.
* Check size instead of common->log_buf in patch #6 (per bot+bpf-ci).
* v12: https://lore.kernel.org/bpf/[email protected]/
v11 -> v12:
* Drop "log_" prefix in struct bpf_log_attr in patch #3.
* Drop "log_" prefix in struct bpf_log_opts in patch #7.
* Copy log_true_size using copy_to_bpfptr_offset() in patch #3 (per Alexei).
* v11: https://lore.kernel.org/bpf/[email protected]/
v10 -> v11:
* Collect Acked-by from Andrii, thanks.
* Validate whether log_buf, log_size, and log_level are valid by reusing bpf_verifier_log_attr_valid() in patch #4 (per Andrii).
* v10: https://lore.kernel.org/bpf/[email protected]/
v9 -> v10:
* Collect Acked-by from Andrii, thanks.
* Address comments from Andrii:
* Drop log NULL check in bpf_log_attr_finalize().
* Return -EFAULT early in bpf_log_attr_finalize().
* Validate whether log_buf, log_size, and log_level are set.
* Keep log_buf, log_size, log_level, and user-pointer log_true_size in struct bpf_log_attr.
* Make prog_load and btf_load work with the new struct bpf_log_attr.
* Add comment to log_true_size of struct bpf_log_opts in libbpf.
* Address comment from Alexei:
* Avoid using BPF_LOG_FIXED as log_level in tests.
* v9: https://lore.kernel.org/bpf/[email protected]/
v8 -> v9:
* Rework reporting 'log_true_size' for prog_load, btf_load, and map_create to simplify struct bpf_log_attr (per Alexei).
* v8: https://lore.kernel.org/bpf/[email protected]/
v7 -> v8:
* Return 0 when fd < 0 and errno != EFAULT in probe_sys_bpf_ext(), then simplify probe_bpf_syscall_common_attrs() (per Alexei and Andrii).
* v7: https://lore.kernel.org/bpf/[email protected]/
v6 -> v7:
* Return -errno when fd < 0 and errno != EFAULT in probe_sys_bpf_ext().
* Convert return value of probe_sys_bpf_ext() to bool in probe_bpf_syscall_common_attrs().
* Address comments from Andrii:
* Drop the comment, and handle fd >= 0 case explicitly in
probe_sys_bpf_ext().
* Return an error when fd >= 0 in probe_sys_bpf_ext().
* v6: https://lore.kernel.org/bpf/[email protected]/
v5 -> v6:
* Address comments from Andrii:
* Update some variables' name.
* Drop unnecessary 'close(fd)' in libbpf.
* Rename FEAT_EXTENDED_SYSCALL to FEAT_BPF_SYSCALL_COMMON_ATTRS with updated description in libbpf.
* Use EINVAL instead of EUSERS, as EUSERS is not used in bpf yet.
* Rename struct bpf_syscall_common_attr_opts to bpf_log_opts in libbpf.
* Add 'OPTS_SET(log_opts, log_true_size, 0);' in libbpf's 'bpf_map_create()'.
* v5: https://lore.kernel.org/bpf/[email protected]/
v4 -> v5:
* Rework reporting 'log_true_size' for prog_load, btf_load, and map_create (per Alexei).
* v4: https://lore.kernel.org/bpf/[email protected]/
RFC v3 -> v4:
* Drop RFC.
* Address comments from Andrii:
* Add parentheses in 'sys_bpf_ext()'.
* Avoid creating new fd in 'probe_sys_bpf_ext()'.
* Add a new struct to wrap log fields in libbpf.
* Address comments from Alexei:
* Do not skip writing to user space when log_true_size is zero.
* Do not use 'bool' arguments.
* Drop the adding WARN_ON_ONCE()'s.
* v3: https://lore.kernel.org/bpf/[email protected]/
RFC v2 -> RFC v3:
* Rename probe_sys_bpf_extended to probe_sys_bpf_ext.
* Refactor reporting 'log_true_size' for prog_load.
* Refactor reporting 'btf_log_true_size' for btf_load.
* Add warnings for internal bugs in map_create.
* Check log_true_size in test cases.
* Address comment from Alexei:
* Change kvzalloc/kvfree to kzalloc/kfree.
* Address comments from Andrii:
* Move BPF_COMMON_ATTRS to 'enum bpf_cmd' alongside brief comment.
* Add bpf_check_uarg_tail_zero() for extra checks.
* Rename sys_bpf_extended to sys_bpf_ext.
* Rename sys_bpf_fd_extended to sys_bpf_ext_fd.
* Probe the new feature using NULL and -EFAULT.
* Move probe_sys_bpf_ext to libbpf_internal.h and drop LIBBPF_API.
* Return -EUSERS when log attrs are conflict between bpf_attr and bpf_common_attr.
* Avoid touching bpf_vlog_init().
* Update the reason messages in map_create.
* Finalize the log using __cleanup().
* Report log size to users.
* Change type of log_buf from '__u64' to 'const char *' and cast type
using ptr_to_u64() in bpf_map_create().
* Do not return -EOPNOTSUPP when kernel doesn't support this feature in bpf_map_create().
* Add log_level support for map creation for consistency.
* Address comment from Eduard:
* Use common_attrs->log_level instead of BPF_LOG_FIXED.
* v2: https://lore.kernel.org/bpf/[email protected]/
RFC v1 -> RFC v2:
* Fix build error reported by test bot.
* Address comments from Alexei:
* Drop new uapi for freplace.
* Add common attributes support for prog_load and btf_load.
* Add common attributes support for map_create.
* v1: https://lore.kernel.org/bpf/[email protected]/
Leon Hwang (8):
bpf: Extend BPF syscall with common attributes support
libbpf: Add support for extended BPF syscall
bpf: Refactor reporting log_true_size for prog_load
bpf: Add syscall common attributes support for prog_load
bpf: Add syscall common attributes support for btf_load
bpf: Add syscall common attributes support for map_create
libbpf: Add syscall common attributes support for map_create selftests/bpf: Add tests to verify map create failure log
include/linux/bpf.h | 4 +- include/linux/bpf_verifier.h | 16 ++ include/linux/btf.h | 3 +- include/linux/syscalls.h | 3 +- include/uapi/linux/bpf.h | 8 + kernel/bpf/btf.c | 30 +--- kernel/bpf/log.c | 90 +++++++++- kernel/bpf/syscall.c | 115 +++++++++--- kernel/bpf/verifier.c | 17 +- tools/include/uapi/linux/bpf.h | 8 + tools/lib/bpf/bpf.c | 52 +++++- tools/lib/bpf/bpf.h | 17 +- tools/lib/bpf/features.c | 8 + tools/lib/bpf/libbpf_internal.h | 3 + .../selftests/bpf/prog_tests/map_init.c | 166 ++++++++++++++++++ 15 files changed, 473 insertions(+), 67 deletions(-)
--
2.54.0
PATCH v14 1/8 bpf: Extend BPF syscall with common attributes support
Add generic BPF syscall support for passing common attributes.
The initial set of common attributes includes:
1. 'log_buf': User-provided buffer for storing logs.
2. 'log_size': Size of the log buffer.
3. 'log_level': Log verbosity level.
4. 'log_true_size': Actual log size reported by kernel.
The common-attribute pointer and its size are passed as the 4th and 5th syscall arguments. A new command bit, 'BPF_COMMON_ATTRS' ('1 << 16'), indicates that common attributes are supplied.
This commit adds syscall and uapi plumbing. Command-specific handling is added in follow-up patches.
--- include/linux/syscalls.h | 3 ++- include/uapi/linux/bpf.h | 8 ++++++++ kernel/bpf/syscall.c | 25 +++++++++++++++++++++---- tools/include/uapi/linux/bpf.h | 8 ++++++++ 4 files changed, 39 insertions(+), 5 deletions(-)
include/linux/syscalls.h +2 -1
@@ -936,7 +936,8 @@ asmlinkage long sys_seccomp(unsigned int op, unsigned int flags,asmlinkage long sys_getrandom (char __user *buf,size_t count,unsigned int flags);asmlinkage long sys_memfd_create (const char __user *uname_ptr,unsigned int flags); -asmlinkage long sys_bpf (int cmd,union bpf_attr __user *attr,unsigned int size); +asmlinkage long sys_bpf (int cmd,union bpf_attr __user *attr,unsigned int size, +struct bpf_common_attr __user *attr_common,unsigned int size_common);asmlinkage long sys_execveat (int dfd,const char __user *filename,const char __user *const __user *argv,const char __user *const __user *envp,int flags);
include/uapi/linux/bpf.h +8 -0
@@ -994,6 +994,7 @@ enum bpf_cmd {BPF_PROG_STREAM_READ_BY_FD ,BPF_PROG_ASSOC_STRUCT_OPS , __MAX_BPF_CMD, + BPF_COMMON_ATTRS = 1 << 16, /* Indicate carrying syscall common attrs. */ }; enum bpf_map_type {
@@ -1500,6 +1501,13 @@ struct bpf_stack_build_id { }; }; +struct bpf_common_attr { +__aligned_u64 log_buf; +__u32 log_size; +__u32 log_level; +__u32 log_true_size; +}; +#define BPF_OBJ_NAME_LEN 16Uenum {
kernel/bpf/syscall.c +21 -4
@@ -6211,8 +6211,10 @@ static int prog_assoc_struct_ops(union bpf_attr *attr)return ret; } -static int __sys_bpf (enum bpf_cmd cmd,bpfptr_t uattr,unsigned int size) +static int __sys_bpf (enum bpf_cmd cmd,bpfptr_t uattr,unsigned int size, +bpfptr_t uattr_common,unsigned int size_common) { +struct bpf_common_attr attr_common;union bpf_attr attr;int err;
@@ -6226,6 +6228,20 @@ static int __sys_bpf(enum bpf_cmd cmd, bpfptr_t uattr, unsigned int size)if (copy_from_bpfptr (&attr, uattr, size) !=0 )return -EFAULT ; +memset (&attr_common,0 ,sizeof (attr_common)); +if (cmd &BPF_COMMON_ATTRS ) { + err =bpf_check_uarg_tail_zero (uattr_common,sizeof (attr_common), size_common); +if (err) +return err; + + cmd &= ~BPF_COMMON_ATTRS ; + size_common =min_t (u32, size_common,sizeof (attr_common)); +if (copy_from_bpfptr (&attr_common, uattr_common, size_common) !=0 ) +return -EFAULT ; + }else { + size_common =0 ; + } + err =security_bpf (cmd, &attr, size, uattr.is_kernel);if (err <0 )return err;
@@ -6361,9 +6377,10 @@ static int __sys_bpf(enum bpf_cmd cmd, bpfptr_t uattr, unsigned int size)return err; } -SYSCALL_DEFINE3(bpf, int, cmd, union bpf_attr __user *, uattr, unsigned int, size) +SYSCALL_DEFINE5(bpf, int, cmd, union bpf_attr __user *, uattr, unsigned int, size, + struct bpf_common_attr __user *, uattr_common, unsigned int, size_common) { -return __sys_bpf (cmd,USER_BPFPTR (uattr), size); +return __sys_bpf (cmd,USER_BPFPTR (uattr), size,USER_BPFPTR (uattr_common), size_common); } static bool syscall_prog_is_valid_access(int off, int size,
@@ -6393,7 +6410,7 @@ BPF_CALL_3(bpf_sys_bpf, int, cmd, union bpf_attr *, attr, u32, attr_size)default :return -EINVAL ; } -return __sys_bpf (cmd,KERNEL_BPFPTR (attr), attr_size); +return __sys_bpf (cmd,KERNEL_BPFPTR (attr), attr_size,KERNEL_BPFPTR (NULL ),0 ); }
tools/include/uapi/linux/bpf.h +8 -0
@@ -994,6 +994,7 @@ enum bpf_cmd {BPF_PROG_STREAM_READ_BY_FD ,BPF_PROG_ASSOC_STRUCT_OPS , __MAX_BPF_CMD, + BPF_COMMON_ATTRS = 1 << 16, /* Indicate carrying syscall common attrs. */ }; enum bpf_map_type {
@@ -1500,6 +1501,13 @@ struct bpf_stack_build_id { }; }; +struct bpf_common_attr { +__aligned_u64 log_buf; +__u32 log_size; +__u32 log_level; +__u32 log_true_size; +}; +#define BPF_OBJ_NAME_LEN 16Uenum {
Signature · 1 line
2.54.0
PATCH v14 2/8 libbpf: Add support for extended BPF syscall
In reply to Leon HwangTo support the extended BPF syscall introduced in the previous commit, introduce the following internal APIs:
* 'sys_bpf_ext()'
* 'sys_bpf_ext_fd()'
They wrap the raw 'syscall()' interface to support passing extended attributes.
* 'probe_sys_bpf_ext()'
Check whether current kernel supports the BPF syscall common attributes.
--- tools/lib/bpf/bpf.c | 36 +++++++++++++++++++++++++++++++++ tools/lib/bpf/features.c | 8 ++++++++ tools/lib/bpf/libbpf_internal.h | 3 +++ 3 files changed, 47 insertions(+)
tools/lib/bpf/bpf.c +36 -0
@@ -69,6 +69,42 @@ static inline __u64 ptr_to_u64(const void *ptr)return (__u64 ) (unsigned long ) ptr; } +static inline int sys_bpf_ext (enum bpf_cmd cmd,union bpf_attr *attr, +unsigned int size, +struct bpf_common_attr *attr_common, +unsigned int size_common) +{ + cmd = attr_common ? (cmd |BPF_COMMON_ATTRS ) : (cmd & ~BPF_COMMON_ATTRS ); +return syscall (__NR_bpf, cmd, attr, size, attr_common, size_common); +} + +static inline int sys_bpf_ext_fd (enum bpf_cmd cmd,union bpf_attr *attr, +unsigned int size, +struct bpf_common_attr *attr_common, +unsigned int size_common) +{ +int fd; + + fd =sys_bpf_ext (cmd, attr, size, attr_common, size_common); +return ensure_good_fd (fd); +} + +int probe_sys_bpf_ext (void ) +{ + const size_t attr_sz = offsetofend(union bpf_attr, prog_token_fd); +union bpf_attr attr; +int fd; + +memset (&attr,0 , attr_sz); + fd =syscall (__NR_bpf,BPF_PROG_LOAD |BPF_COMMON_ATTRS , &attr, attr_sz,NULL , +sizeof (struct bpf_common_attr )); +if (fd >=0 ) { +close (fd); +return -EINVAL ; + } +return errno ==EFAULT ?1 :0 ; +} +static inline int sys_bpf (enum bpf_cmd cmd,union bpf_attr *attr,unsigned int size) {
tools/lib/bpf/features.c +8 -0
@@ -615,6 +615,11 @@ static int probe_kern_btf_layout(int token_fd) (char *)layout, token_fd)); } +static int probe_bpf_syscall_common_attrs (int token_fd) +{ +return probe_sys_bpf_ext (); +} +typedef int (*feature_probe_fn )(int /* token_fd */ );static struct kern_feature_cache feature_cache;
@@ -699,6 +704,9 @@ static struct kern_feature_desc { [FEAT_BTF_LAYOUT ] = {"kernel supports BTF layout" , probe_kern_btf_layout, }, + [FEAT_BPF_SYSCALL_COMMON_ATTRS ] = { +"BPF syscall common attributes support" , probe_bpf_syscall_common_attrs, + }, };bool feat_supported (struct kern_feature_cache *cache,enum kern_feature_id feat_id)
tools/lib/bpf/libbpf_internal.h +3 -0
@@ -398,6 +398,8 @@ enum kern_feature_id {FEAT_UPROBE_SYSCALL ,/* Kernel supports BTF layout information */ FEAT_BTF_LAYOUT , +/* Kernel supports BPF syscall common attributes */ +FEAT_BPF_SYSCALL_COMMON_ATTRS , __FEAT_CNT, };
@@ -768,4 +770,5 @@ int probe_fd(int fd);#define SHA256_DWORD_SIZE SHA256_DIGEST_LENGTH / sizeof(__u64)void libbpf_sha256 (const void *data,size_t len,__u8 out[SHA256_DIGEST_LENGTH ]); +int probe_sys_bpf_ext (void );#endif /* __LIBBPF_LIBBPF_INTERNAL_H */
Signature · 1 line
2.54.0
PATCH v14 3/8 bpf: Refactor reporting log_true_size for prog_load
In reply to Leon HwangThe next commit will add support for reporting logs via extended common attributes, including 'log_true_size'.
To prepare for that, refactor the 'log_true_size' reporting logic by introducing a new struct bpf_log_attr to encapsulate log-related behavior:
* bpf_log_attr_init(): initialize log fields, which will support extended common attributes in the next commit.
* bpf_log_attr_finalize(): handle log finalization and write back 'log_true_size' to userspace.
--- include/linux/bpf.h | 4 +++- include/linux/bpf_verifier.h | 12 ++++++++++++ kernel/bpf/log.c | 29 +++++++++++++++++++++++++++++ kernel/bpf/syscall.c | 12 +++++++++--- kernel/bpf/verifier.c | 17 ++++------------- 5 files changed, 57 insertions(+), 17 deletions(-)
include/linux/bpf.h +3 -1
@@ -2919,7 +2919,9 @@ int bpf_check_uarg_tail_zero(bpfptr_t uaddr, size_t expected_size, size_t actual_size);/* verify correctness of eBPF program */ -int bpf_check (struct bpf_prog **fp,union bpf_attr *attr,bpfptr_t uattr,u32 uattr_size); +struct bpf_log_attr ; +int bpf_check (struct bpf_prog **fp,union bpf_attr *attr,bpfptr_t uattr, +struct bpf_log_attr *attr_log);#ifndef CONFIG_BPF_JIT_ALWAYS_ON void bpf_patch_call_args (struct bpf_insn *insn,u32 stack_depth);
include/linux/bpf_verifier.h +12 -0
@@ -755,6 +755,18 @@ static inline bool bpf_verifier_log_needed(const struct bpf_verifier_log *log)return log && log->level; } +struct bpf_log_attr { +char __user *ubuf; +u32 size; +u32 level; +u32 offsetof_true_size; +bpfptr_t uattr; +}; + +int bpf_log_attr_init (struct bpf_log_attr *log,u64 log_buf,u32 log_size,u32 log_level, +u32 offsetof_log_true_size,bpfptr_t uattr); +int bpf_log_attr_finalize (struct bpf_log_attr *attr,struct bpf_verifier_log *log); +#define BPF_MAX_SUBPROGS 256struct bpf_subprog_arg_info {
kernel/bpf/log.c +29 -0
@@ -825,3 +825,32 @@ void print_insn_state(struct bpf_verifier_env *env, const struct bpf_verifier_st }print_verifier_state (env, vstate, frameno, false); } + +int bpf_log_attr_init (struct bpf_log_attr *log,u64 log_buf,u32 log_size,u32 log_level, +u32 offsetof_log_true_size,bpfptr_t uattr) +{ +char __user *ubuf =u64_to_user_ptr (log_buf); + +memset (log,0 ,sizeof (*log)); + log->ubuf = ubuf; + log->size = log_size; + log->level = log_level; + log->offsetof_true_size = offsetof_log_true_size; + log->uattr = uattr; +return 0 ; +} + +int bpf_log_attr_finalize (struct bpf_log_attr *attr,struct bpf_verifier_log *log) +{ +u32 log_true_size; +int err; + + err =bpf_vlog_finalize (log, &log_true_size); + +if (attr->offsetof_true_size && +copy_to_bpfptr_offset (attr->uattr, attr->offsetof_true_size, &log_true_size, +sizeof (log_true_size))) +return -EFAULT ; + +return err; +}
kernel/bpf/syscall.c +9 -3
@@ -2861,7 +2861,7 @@ static int bpf_prog_mark_insn_arrays_ready(struct bpf_prog *prog)/* last field in 'union bpf_attr' used by this command */ #define BPF_PROG_LOAD_LAST_FIELD keyring_id -static int bpf_prog_load (union bpf_attr *attr,bpfptr_t uattr,u32 uattr_size) +static int bpf_prog_load (union bpf_attr *attr,bpfptr_t uattr,struct bpf_log_attr *attr_log) {enum bpf_prog_type type = attr->prog_type;struct bpf_prog *prog, *dst_prog =NULL ;
@@ -3079,7 +3079,7 @@ static int bpf_prog_load(union bpf_attr *attr, bpfptr_t uattr, u32 uattr_size) goto free_prog_sec;/* run eBPF verifier */ - err =bpf_check (&prog, attr, uattr, uattr_size); + err =bpf_check (&prog, attr, uattr, attr_log);if (err <0 ) goto free_used_maps;
@@ -6215,6 +6215,8 @@ static int __sys_bpf(enum bpf_cmd cmd, bpfptr_t uattr, unsigned int size, bpfptr_t uattr_common, unsigned int size_common) { struct bpf_common_attr attr_common; +u32 offsetof_log_true_size =0 ; +struct bpf_log_attr attr_log;union bpf_attr attr;int err;
@@ -6266,7 +6268,11 @@ static int __sys_bpf(enum bpf_cmd cmd, bpfptr_t uattr, unsigned int size, err =map_freeze (&attr);break ;case BPF_PROG_LOAD : - err =bpf_prog_load (&attr, uattr, size); + if (size >= offsetofend(union bpf_attr, log_true_size)) + offsetof_log_true_size = offsetof(union bpf_attr , log_true_size); + err =bpf_log_attr_init (&attr_log, attr.log_buf, attr.log_size, attr.log_level, + offsetof_log_true_size, uattr); + err = err ?:bpf_prog_load (&attr, uattr, &attr_log);break ;case BPF_OBJ_PIN : err =bpf_obj_pin (&attr);
kernel/bpf/verifier.c +4 -13
@@ -19294,12 +19294,12 @@ int bpf_fixup_kfunc_call(struct bpf_verifier_env *env, struct bpf_insn *insn,return 0 ; } -int bpf_check (struct bpf_prog **prog,union bpf_attr *attr,bpfptr_t uattr,__u32 uattr_size) +int bpf_check (struct bpf_prog **prog,union bpf_attr *attr,bpfptr_t uattr, +struct bpf_log_attr *attr_log) {u64 start_time =ktime_get_ns ();struct bpf_verifier_env *env;int i, len, ret = -EINVAL , err; -u32 log_true_size;bool is_priv;BTF_TYPE_EMIT (enum bpf_features );
@@ -19346,9 +19346,7 @@ int bpf_check(struct bpf_prog **prog, union bpf_attr *attr, bpfptr_t uattr, __u3/* user could have requested verbose verifier output * and supplied buffer to store the verification trace */ - ret =bpf_vlog_init (&env->log, attr->log_level, - (char __user *) (unsigned long ) attr->log_buf, - attr->log_size); + ret =bpf_vlog_init (&env->log, attr_log->level, attr_log->ubuf, attr_log->size);if (ret) goto err_unlock;
@@ -19510,17 +19508,10 @@ int bpf_check(struct bpf_prog **prog, union bpf_attr *attr, bpfptr_t uattr, __u3 env->prog->aux->verified_insns = env->insn_processed;/* preserve original error even if log finalization is successful */ - err =bpf_vlog_finalize (&env->log, &log_true_size); + err =bpf_log_attr_finalize (attr_log, &env->log);if (err) ret = err; - if (uattr_size >= offsetofend(union bpf_attr, log_true_size) && -copy_to_bpfptr_offset (uattr, offsetof(union bpf_attr , log_true_size), - &log_true_size,sizeof (log_true_size))) { - ret = -EFAULT ; - goto err_release_maps; - } -if (ret) goto err_release_maps;
Signature · 1 line
2.54.0
PATCH v14 4/8 bpf: Add syscall common attributes support for prog_load
In reply to Leon HwangBPF_PROG_LOAD can now take log parameters from both union bpf_attr and struct bpf_common_attr. The merge rules are:
- if both sides provide a complete log tuple (buf/size/level) and they match, use it;
- if only one side provides log parameters, use that one;
- if both sides provide complete tuples but they differ, return -EINVAL.
--- include/linux/bpf_verifier.h | 3 ++- kernel/bpf/log.c | 34 +++++++++++++++++++++++++++------- kernel/bpf/syscall.c | 3 ++- 3 files changed, 31 insertions(+), 9 deletions(-)
include/linux/bpf_verifier.h +2 -1
@@ -764,7 +764,8 @@ struct bpf_log_attr { };int bpf_log_attr_init (struct bpf_log_attr *log,u64 log_buf,u32 log_size,u32 log_level, -u32 offsetof_log_true_size,bpfptr_t uattr); +u32 offsetof_log_true_size,bpfptr_t uattr,struct bpf_common_attr *common, +bpfptr_t uattr_common,u32 size_common);int bpf_log_attr_finalize (struct bpf_log_attr *attr,struct bpf_verifier_log *log);#define BPF_MAX_SUBPROGS 256
kernel/bpf/log.c +27 -7
@@ -13,17 +13,17 @@ #define verbose(env, fmt, args...) bpf_verifier_log_write(env, fmt, ##args) -static bool bpf_verifier_log_attr_valid (const struct bpf_verifier_log *log) +static bool bpf_verifier_log_attr_valid (u32 log_level,char __user *log_buf,u32 log_size) {/* ubuf and len_total should both be specified (or not) together */ -if (!!log->ubuf != !!log->len_total) +if (!!log_buf != !!log_size)return false;/* log buf without log_level is meaningless */ -if (log->ubuf && log->level ==0 ) +if (log_buf && log_level ==0 )return false; -if (log->level & ~BPF_LOG_MASK ) +if (log_level & ~BPF_LOG_MASK )return false; -if (log->len_total >UINT_MAX >>2 ) +if (log_size >UINT_MAX >>2 )return false;return true; }
@@ -36,7 +36,7 @@ int bpf_vlog_init(struct bpf_verifier_log *log, u32 log_level, log->len_total = log_size;/* log attributes have to be sane */ -if (!bpf_verifier_log_attr_valid (log)) +if (!bpf_verifier_log_attr_valid (log_level, log_buf, log_size))return -EINVAL ;return 0 ;
@@ -827,16 +827,36 @@ void print_insn_state(struct bpf_verifier_env *env, const struct bpf_verifier_st }int bpf_log_attr_init (struct bpf_log_attr *log,u64 log_buf,u32 log_size,u32 log_level, -u32 offsetof_log_true_size,bpfptr_t uattr) +u32 offsetof_log_true_size,bpfptr_t uattr,struct bpf_common_attr *common, +bpfptr_t uattr_common,u32 size_common) { +char __user *ubuf_common =u64_to_user_ptr (common->log_buf);char __user *ubuf =u64_to_user_ptr (log_buf); +if (!bpf_verifier_log_attr_valid (common->log_level, ubuf_common, common->log_size) || + !bpf_verifier_log_attr_valid (log_level, ubuf, log_size)) +return -EINVAL ; + +if (ubuf && ubuf_common && (ubuf != ubuf_common || log_size != common->log_size || + log_level != common->log_level)) +return -EINVAL ; +memset (log,0 ,sizeof (*log)); log->ubuf = ubuf; log->size = log_size; log->level = log_level; log->offsetof_true_size = offsetof_log_true_size; log->uattr = uattr; + +if (!ubuf && ubuf_common) { + log->ubuf = ubuf_common; + log->size = common->log_size; + log->level = common->log_level; + log->uattr = uattr_common; + log->offsetof_true_size =0 ; + if (size_common >= offsetofend(struct bpf_common_attr, log_true_size)) + log->offsetof_true_size = offsetof(struct bpf_common_attr , log_true_size); + }return 0 ; }
kernel/bpf/syscall.c +2 -1
@@ -6271,7 +6271,8 @@ static int __sys_bpf(enum bpf_cmd cmd, bpfptr_t uattr, unsigned int size, if (size >= offsetofend(union bpf_attr, log_true_size)) offsetof_log_true_size = offsetof(union bpf_attr , log_true_size); err =bpf_log_attr_init (&attr_log, attr.log_buf, attr.log_size, attr.log_level, - offsetof_log_true_size, uattr); + offsetof_log_true_size, uattr, &attr_common, uattr_common, + size_common); err = err ?:bpf_prog_load (&attr, uattr, &attr_log);break ;case BPF_OBJ_PIN :
Signature · 1 line
2.54.0
PATCH v14 5/8 bpf: Add syscall common attributes support for btf_load
In reply to Leon HwangBPF_BTF_LOAD can now take log parameters from both union bpf_attr and struct bpf_common_attr, with the same merge rules as BPF_PROG_LOAD:
- if both sides provide a complete log tuple (buf/size/level) and they match, use it;
- if only one side provides log parameters, use that one;
- if both sides provide complete tuples but they differ, return -EINVAL.
--- include/linux/btf.h | 3 ++- kernel/bpf/btf.c | 30 +++++++----------------------- kernel/bpf/syscall.c | 11 ++++++++--- 3 files changed, 17 insertions(+), 27 deletions(-)
include/linux/btf.h +2 -1
@@ -145,7 +145,8 @@ const char *btf_get_name(const struct btf *btf);void btf_get (struct btf *btf);void btf_put (struct btf *btf);const struct btf_header *btf_header (const struct btf *btf); -int btf_new_fd (const union bpf_attr *attr,bpfptr_t uattr,u32 uattr_sz); +struct bpf_log_attr ; +int btf_new_fd (const union bpf_attr *attr,bpfptr_t uattr,struct bpf_log_attr *attr_log);struct btf *btf_get_by_fd (int fd); int btf_get_info_by_fd(const struct btf *btf, const union bpf_attr *attr,
kernel/bpf/btf.c +7 -23
@@ -5907,25 +5907,10 @@ static int btf_check_type_tags(struct btf_verifier_env *env,return 0 ; } -static int finalize_log (struct bpf_verifier_log *log,bpfptr_t uattr,u32 uattr_size) -{ -u32 log_true_size; -int err; - - err =bpf_vlog_finalize (log, &log_true_size); - - if (uattr_size >= offsetofend(union bpf_attr, btf_log_true_size) && -copy_to_bpfptr_offset (uattr, offsetof(union bpf_attr , btf_log_true_size), - &log_true_size,sizeof (log_true_size))) - err = -EFAULT ; - -return err; -} - -static struct btf *btf_parse (const union bpf_attr *attr,bpfptr_t uattr,u32 uattr_size) +static struct btf *btf_parse (const union bpf_attr *attr,bpfptr_t uattr, +struct bpf_log_attr *attr_log) {bpfptr_t btf_data =make_bpfptr (attr->btf, uattr.is_kernel); -char __user *log_ubuf =u64_to_user_ptr (attr->btf_log_buf);struct btf_struct_metas *struct_meta_tab;struct btf_verifier_env *env =NULL ;struct btf *btf =NULL ;
@@ -5942,8 +5927,7 @@ static struct btf *btf_parse(const union bpf_attr *attr, bpfptr_t uattr, u32 uat/* user could have requested verbose verifier output * and supplied buffer to store the verification trace */ - err =bpf_vlog_init (&env->log, attr->btf_log_level, - log_ubuf, attr->btf_log_size); + err =bpf_vlog_init (&env->log, attr_log->level, attr_log->ubuf, attr_log->size);if (err) goto errout_free;
@@ -6008,7 +5992,7 @@ static struct btf *btf_parse(const union bpf_attr *attr, bpfptr_t uattr, u32 uat } } - err =finalize_log (&env->log, uattr, uattr_size); + err =bpf_log_attr_finalize (attr_log, &env->log);if (err) goto errout_free;
@@ -6020,7 +6004,7 @@ static struct btf *btf_parse(const union bpf_attr *attr, bpfptr_t uattr, u32 uatbtf_free_struct_meta_tab (btf); errout:/* overwrite err with -ENOSPC or -EFAULT */ - ret =finalize_log (&env->log, uattr, uattr_size); + ret =bpf_log_attr_finalize (attr_log, &env->log);if (ret) err = ret; errout_free:
@@ -8189,12 +8173,12 @@ static int __btf_new_fd(struct btf *btf)return anon_inode_getfd ("btf" , &btf_fops, btf,O_RDONLY |O_CLOEXEC ); } -int btf_new_fd (const union bpf_attr *attr,bpfptr_t uattr,u32 uattr_size) +int btf_new_fd (const union bpf_attr *attr,bpfptr_t uattr,struct bpf_log_attr *attr_log) {struct btf *btf;int ret; - btf =btf_parse (attr, uattr, uattr_size); + btf =btf_parse (attr, uattr, attr_log);if (IS_ERR (btf))return PTR_ERR (btf);
kernel/bpf/syscall.c +8 -3
@@ -5474,7 +5474,7 @@ static int bpf_obj_get_info_by_fd(const union bpf_attr *attr,#define BPF_BTF_LOAD_LAST_FIELD btf_token_fd -static int bpf_btf_load (const union bpf_attr *attr,bpfptr_t uattr,__u32 uattr_size) +static int bpf_btf_load (const union bpf_attr *attr,bpfptr_t uattr,struct bpf_log_attr *attr_log) {struct bpf_token *token =NULL ;
@@ -5501,7 +5501,7 @@ static int bpf_btf_load(const union bpf_attr *attr, bpfptr_t uattr, __u32 uattr_bpf_token_put (token); -return btf_new_fd (attr, uattr, uattr_size); +return btf_new_fd (attr, uattr, attr_log); }#define BPF_BTF_GET_FD_BY_ID_LAST_FIELD fd_by_id_token_fd
@@ -6318,7 +6318,12 @@ static int __sys_bpf(enum bpf_cmd cmd, bpfptr_t uattr, unsigned int size, err =bpf_raw_tracepoint_open (&attr);break ;case BPF_BTF_LOAD : - err =bpf_btf_load (&attr, uattr, size); + if (size >= offsetofend(union bpf_attr, btf_log_true_size)) + offsetof_log_true_size = offsetof(union bpf_attr , btf_log_true_size); + err =bpf_log_attr_init (&attr_log, attr.btf_log_buf, attr.btf_log_size, + attr.btf_log_level, offsetof_log_true_size, uattr, + &attr_common, uattr_common, size_common); + err = err ?:bpf_btf_load (&attr, uattr, &attr_log);break ;case BPF_BTF_GET_FD_BY_ID : err =bpf_btf_get_fd_by_id (&attr);
Signature · 1 line
2.54.0
PATCH v14 6/8 bpf: Add syscall common attributes support for map_create
In reply to Leon HwangMany BPF_MAP_CREATE validation failures currently return -EINVAL without any explanation to userspace.
Plumb common syscall log attributes into map_create(), create a verifier log from bpf_common_attr::log_buf/log_size/log_level, and report map-creation failure reasons through that buffer.
This improves debuggability by allowing userspace to inspect why map creation failed and read back log_true_size from common attributes.
--- include/linux/bpf_verifier.h | 3 ++ kernel/bpf/log.c | 29 ++++++++++++++++ kernel/bpf/syscall.c | 66 ++++++++++++++++++++++++++++++------ 3 files changed, 88 insertions(+), 10 deletions(-)
include/linux/bpf_verifier.h +3 -0
@@ -766,6 +766,9 @@ struct bpf_log_attr {int bpf_log_attr_init (struct bpf_log_attr *log,u64 log_buf,u32 log_size,u32 log_level,u32 offsetof_log_true_size,bpfptr_t uattr,struct bpf_common_attr *common,bpfptr_t uattr_common,u32 size_common); +struct bpf_verifier_log *bpf_log_attr_create_vlog (struct bpf_log_attr *attr_log, +struct bpf_common_attr *common,bpfptr_t uattr, +u32 size);int bpf_log_attr_finalize (struct bpf_log_attr *attr,struct bpf_verifier_log *log);#define BPF_MAX_SUBPROGS 256
kernel/bpf/log.c +29 -0
@@ -860,6 +860,35 @@ int bpf_log_attr_init(struct bpf_log_attr *log, u64 log_buf, u32 log_size, u32 lreturn 0 ; } +struct bpf_verifier_log *bpf_log_attr_create_vlog (struct bpf_log_attr *attr_log, +struct bpf_common_attr *common,bpfptr_t uattr, +u32 size) +{ +struct bpf_verifier_log *log; +int err; + +memset (attr_log,0 ,sizeof (*attr_log)); + attr_log->uattr = uattr; + if (size >= offsetofend(struct bpf_common_attr, log_true_size)) + attr_log->offsetof_true_size = offsetof(struct bpf_common_attr , log_true_size); + +if (!size) +return NULL ; + + log =kzalloc_obj (*log,GFP_KERNEL ); +if (!log) +return ERR_PTR (-ENOMEM ); + + err =bpf_vlog_init (log, common->log_level,u64_to_user_ptr (common->log_buf), + common->log_size); +if (err) { +kfree (log); +return ERR_PTR (err); + } + +return log; +} +int bpf_log_attr_finalize (struct bpf_log_attr *attr,struct bpf_verifier_log *log) {u32 log_true_size;
kernel/bpf/syscall.c +56 -10
148 lines not on this page · raw message
Signature · 1 line
2.54.0
PATCH v14 7/8 libbpf: Add syscall common attributes support for map_create
In reply to Leon HwangWith the previous commit adding common attribute support for BPF_MAP_CREATE, users can now retrieve detailed error messages when map creation fails via the log_buf field.
Introduce struct bpf_log_opts with the following fields:log_buf, log_size, log_level, and log_true_size.
Extend bpf_map_create_opts with a new field log_opts, allowing users to capture and inspect log messages on map creation failures.
--- tools/lib/bpf/bpf.c | 16 +++++++++++++++- tools/lib/bpf/bpf.h | 17 ++++++++++++++++- 2 files changed, 31 insertions(+), 2 deletions(-)
tools/lib/bpf/bpf.c +15 -1
@@ -209,6 +209,9 @@ int bpf_map_create(enum bpf_map_type map_type, const struct bpf_map_create_opts *opts) { const size_t attr_sz = offsetofend(union bpf_attr, excl_prog_hash_size); +const size_t attr_common_sz =sizeof (struct bpf_common_attr ); +struct bpf_common_attr attr_common; +struct bpf_log_opts *log_opts;union bpf_attr attr;int fd;
@@ -242,7 +245,18 @@ int bpf_map_create(enum bpf_map_type map_type, attr.excl_prog_hash =ptr_to_u64 (OPTS_GET (opts, excl_prog_hash,NULL )); attr.excl_prog_hash_size =OPTS_GET (opts, excl_prog_hash_size,0 ); - fd =sys_bpf_fd (BPF_MAP_CREATE , &attr, attr_sz); + log_opts =OPTS_GET (opts, log_opts,NULL ); +if (log_opts &&feat_supported (NULL ,FEAT_BPF_SYSCALL_COMMON_ATTRS )) { +memset (&attr_common,0 , attr_common_sz); + attr_common.log_buf =ptr_to_u64 (OPTS_GET (log_opts, buf,NULL )); + attr_common.log_size =OPTS_GET (log_opts, size,0 ); + attr_common.log_level =OPTS_GET (log_opts, level,0 ); + fd =sys_bpf_ext_fd (BPF_MAP_CREATE , &attr, attr_sz, &attr_common, attr_common_sz); +OPTS_SET (log_opts, true_size, attr_common.log_true_size); + }else { + fd =sys_bpf_fd (BPF_MAP_CREATE , &attr, attr_sz); +OPTS_SET (log_opts, true_size,0 ); + }return libbpf_err_errno (fd); }
tools/lib/bpf/bpf.h +16 -1
@@ -37,6 +37,18 @@ extern "C" { LIBBPF_API int libbpf_set_memlock_rlim(size_t memlock_bytes); +struct bpf_log_opts { +size_t sz;/* size of this struct for forward/backward compatibility */ + +char *buf; +__u32 size; +__u32 level; +__u32 true_size;/* out parameter set by kernel */ + + size_t :0; +}; +#define bpf_log_opts__last_field true_size +struct bpf_map_create_opts {size_t sz;/* size of this struct for forward/backward compatibility */
@@ -57,9 +69,12 @@ struct bpf_map_create_opts {const void *excl_prog_hash;__u32 excl_prog_hash_size; + +struct bpf_log_opts *log_opts; + size_t :0; }; -#define bpf_map_create_opts__last_field excl_prog_hash_size +#define bpf_map_create_opts__last_field log_opts LIBBPF_API int bpf_map_create(enum bpf_map_type map_type, const char *map_name,
Signature · 1 line
2.54.0
PATCH v14 8/8 selftests/bpf: Add tests to verify map create failure log
In reply to Leon HwangAdd tests to verify that the kernel reports the expected error messages and correct log_true_size when map creation fails.
--- .../selftests/bpf/prog_tests/map_init.c | 166 ++++++++++++++++++ 1 file changed, 166 insertions(+)
tools/testing/selftests/bpf/prog_tests/map_init.c +166 -0
@@ -212,3 +212,169 @@ void test_map_init(void)if (test__start_subtest ("pcpu_lru_map_init" ))test_pcpu_lru_map_init (); } + +static void test_map_create (enum bpf_map_type map_type,const char *map_name, +struct bpf_map_create_opts *opts,const char *exp_msg) +{ +const int key_size =4 , value_size =4 , max_entries =1 ; +char log_buf[128 ]; +int fd; +LIBBPF_OPTS (bpf_log_opts, log_opts); + + log_buf[0 ] ='\0' ; + log_opts.buf = log_buf; + log_opts.size =sizeof (log_buf); + log_opts.level =1 ; + opts->log_opts = &log_opts; + fd =bpf_map_create (map_type, map_name, key_size, value_size, max_entries, opts); +if (!ASSERT_LT (fd,0 ,"bpf_map_create" )) { +close (fd); +return ; + } + +ASSERT_STREQ (log_buf, exp_msg,"log_buf" ); +ASSERT_EQ (log_opts.true_size,strlen (exp_msg) +1 ,"true_size" ); +} + +static void test_map_create_array (struct bpf_map_create_opts *opts,const char *exp_msg) +{ +test_map_create (BPF_MAP_TYPE_ARRAY ,"test_map_create" , opts, exp_msg); +} + +static void test_invalid_vmlinux_value_type_id_struct_ops (void ) +{ +const char *msg ="btf_vmlinux_value_type_id can only be used with struct_ops maps.\n" ; +LIBBPF_OPTS (bpf_map_create_opts, opts, + .btf_vmlinux_value_type_id = 1, + ); + +test_map_create_array (&opts, msg); +} + +static void test_invalid_vmlinux_value_type_id_kv_type_id (void ) +{ +const char *msg ="btf_vmlinux_value_type_id is mutually exclusive with btf_key_type_id and btf_value_type_id.\n" ; +LIBBPF_OPTS (bpf_map_create_opts, opts, + .btf_vmlinux_value_type_id = 1, + .btf_key_type_id = 1, + ); + +test_map_create (BPF_MAP_TYPE_STRUCT_OPS ,"test_map_create" , &opts, msg); +} + +static void test_invalid_value_type_id (void ) +{ +const char *msg ="Invalid btf_value_type_id.\n" ; +LIBBPF_OPTS (bpf_map_create_opts, opts, + .btf_key_type_id = 1, + ); + +test_map_create_array (&opts, msg); +} + +static void test_invalid_map_extra (void ) +{ +const char *msg ="Invalid map_extra.\n" ; +LIBBPF_OPTS (bpf_map_create_opts, opts, + .map_extra = 1, + ); + +test_map_create_array (&opts, msg); +} + +static void test_invalid_numa_node (void ) +{ +const char *msg ="Invalid numa_node.\n" ; +LIBBPF_OPTS (bpf_map_create_opts, opts, + .map_flags = BPF_F_NUMA_NODE, + .numa_node = 0xFF, + ); + +test_map_create_array (&opts, msg); +} + +static void test_invalid_map_type (void ) +{ +const char *msg ="Invalid map_type.\n" ; +LIBBPF_OPTS (bpf_map_create_opts, opts); + +test_map_create (__MAX_BPF_MAP_TYPE,"test_map_create" , &opts, msg); +} + +static void test_invalid_token_fd (void ) +{ +const char *msg ="Invalid map_token_fd.\n" ; +LIBBPF_OPTS (bpf_map_create_opts, opts, + .map_flags = BPF_F_TOKEN_FD, + .token_fd = 0xFF, + ); + +test_map_create_array (&opts, msg); +} + +static void test_invalid_map_name (void ) +{ +const char *msg ="Invalid map_name.\n" ; +LIBBPF_OPTS (bpf_map_create_opts, opts); + +test_map_create (BPF_MAP_TYPE_ARRAY ,"test-!@#" , &opts, msg); +} + +static void test_invalid_btf_fd (void ) +{ +const char *msg ="Invalid btf_fd.\n" ; +LIBBPF_OPTS (bpf_map_create_opts, opts, + .btf_fd = -1, + .btf_key_type_id = 1, + .btf_value_type_id = 1, + ); + +test_map_create_array (&opts, msg); +} + +static void test_excl_prog_hash_size_1 (void ) +{ +const char *msg ="Invalid excl_prog_hash_size.\n" ; +const char *hash ="DEADCODE" ; +LIBBPF_OPTS (bpf_map_create_opts, opts, + .excl_prog_hash = hash, + ); + +test_map_create_array (&opts, msg); +} + +static void test_excl_prog_hash_size_2 (void ) +{ +const char *msg ="Invalid excl_prog_hash_size.\n" ; +LIBBPF_OPTS (bpf_map_create_opts, opts, + .excl_prog_hash_size = 1, + ); + +test_map_create_array (&opts, msg); +} + +void test_map_create_failure (void ) +{ +if (test__start_subtest ("invalid_vmlinux_value_type_id_struct_ops" )) +test_invalid_vmlinux_value_type_id_struct_ops (); +if (test__start_subtest ("invalid_vmlinux_value_type_id_kv_type_id" )) +test_invalid_vmlinux_value_type_id_kv_type_id (); +if (test__start_subtest ("invalid_value_type_id" )) +test_invalid_value_type_id (); +if (test__start_subtest ("invalid_map_extra" )) +test_invalid_map_extra (); +if (test__start_subtest ("invalid_numa_node" )) +test_invalid_numa_node (); +if (test__start_subtest ("invalid_map_type" )) +test_invalid_map_type (); +if (test__start_subtest ("invalid_token_fd" )) +test_invalid_token_fd (); +if (test__start_subtest ("invalid_map_name" )) +test_invalid_map_name (); +if (test__start_subtest ("invalid_btf_fd" )) +test_invalid_btf_fd (); +if (test__start_subtest ("invalid_excl_prog_hash_size_1" )) +test_excl_prog_hash_size_1 (); +if (test__start_subtest ("invalid_excl_prog_hash_size_2" )) +test_excl_prog_hash_size_2 (); +}
Signature · 1 line
2.54.0
[email protected]
AI reviewRe: [PATCH bpf-next v14 2/8] libbpf: Add support for extended BPF syscall
In reply to Leon HwangShould probe_sys_bpf_ext() return 1 instead of -EINVAL when fd >= 0?
Quoted 4 lines
tools/lib/bpf/bpf.c +0
-0
[ ... ]
tools/lib/bpf/bpf.c static inline __u64 ptr_to_u64(const void *ptr) · line 103
Quoted 12 lines
tools/lib/bpf/bpf.c +12
-0+int probe_sys_bpf_ext (void ) +{ + const size_t attr_sz = offsetofend(union bpf_attr, prog_token_fd); +union bpf_attr attr; +int fd; + +memset (&attr,0 , attr_sz); + fd =syscall (__NR_bpf,BPF_PROG_LOAD |BPF_COMMON_ATTRS , &attr, attr_sz,NULL , +sizeof (struct bpf_common_attr )); +if (fd >=0 ) { +close (fd); +return -EINVAL ;
^^^^^^
Should probe_sys_bpf_ext() return 1 instead of -EINVAL when fd >= 0?
The probe function detects kernel support for extended BPF syscall attributes by calling the BPF syscall with the BPF_COMMON_ATTRS flag and a NULL pointer for common attributes.
The expected outcomes are:
- New kernel with support: errno=EFAULT (can't copy from NULL) -> return 1
- Old kernel without support: errno!=EFAULT (invalid command) -> return 0
If the syscall succeeds (fd >= 0), that definitively proves the kernel accepts the extended syscall format and supports BPF_COMMON_ATTRS. The function should return 1 (supported) rather than -EINVAL (error).
Returning -EINVAL causes feat_supported() in features.c to print a warning "Detection of kernel BPF syscall common attributes support support failed: Invalid argument" and mark the feature as MISSING, incorrectly reporting that the kernel doesn't support the feature when the successful syscall proves it does.
tools/lib/bpf/bpf.c static inline __u64 ptr_to_u64(const void *ptr) · line 106
Quoted 3 lines
tools/lib/bpf/bpf.c +3
-0+ } +return errno ==EFAULT ?1 :0 ; +}
[ ... ]
---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md
CI run summary: https://github.com/kernel-patches/bpf/actions/runs/25745661172
This series was applied to bpf/bpf-next.git (master) by Alexei Starovoitov <[email protected]>:
Hello:
This series was applied to bpf/bpf-next.git (master) by Alexei Starovoitov <[email protected]>:
Quoted 9 lines · On Tue, 12 May 2026 23:31:49 +0800 you wrote:
This patch series builds upon the discussion in
"[PATCH bpf-next v4 0/4] bpf: Improve error reporting for freplace attachment failure" [1].This patch series introduces support for *common attributes* in the BPF syscall, providing a unified mechanism for passing shared metadata across all BPF commands, initially used by
BPF_PROG_LOAD,BPF_BTF_LOAD, andBPF_MAP_CREATE.[...]
Here is the summary with links:
- [bpf-next,v14,1/8] bpf: Extend BPF syscall with common attributes support
https://git.kernel.org/bpf/bpf-next/c/f28771c0691b - [bpf-next,v14,2/8] libbpf: Add support for extended BPF syscall https://git.kernel.org/bpf/bpf-next/c/b1bff4080942 - [bpf-next,v14,3/8] bpf: Refactor reporting log_true_size for prog_load https://git.kernel.org/bpf/bpf-next/c/503c039ffeca - [bpf-next,v14,4/8] bpf: Add syscall common attributes support for prog_load https://git.kernel.org/bpf/bpf-next/c/ac89d33fdd81 - [bpf-next,v14,5/8] bpf: Add syscall common attributes support for btf_load https://git.kernel.org/bpf/bpf-next/c/ceeb7eda94a3 - [bpf-next,v14,6/8] bpf: Add syscall common attributes support for map_create https://git.kernel.org/bpf/bpf-next/c/49f9b2b2a18c - [bpf-next,v14,7/8] libbpf: Add syscall common attributes support for map_create https://git.kernel.org/bpf/bpf-next/c/702259006f93 - [bpf-next,v14,8/8] selftests/bpf: Add tests to verify map create failure log https://git.kernel.org/bpf/bpf-next/c/f675483cac1d
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html
Re: [PATCH bpf-next v14 2/8] libbpf: Add support for extended BPF syscall
In reply to [email protected]Quoted 35 lines · On 13/5/26 00:23, [email protected] wrote:
Quoted 4 lines
tools/lib/bpf/bpf.c +0
-0[ ... ]
tools/lib/bpf/bpf.c static inline __u64 ptr_to_u64(const void *ptr) · line 103
Quoted 12 lines
tools/lib/bpf/bpf.c +12
-0+int probe_sys_bpf_ext (void ) +{ + const size_t attr_sz = offsetofend(union bpf_attr, prog_token_fd); +union bpf_attr attr; +int fd; + +memset (&attr,0 , attr_sz); + fd =syscall (__NR_bpf,BPF_PROG_LOAD |BPF_COMMON_ATTRS , &attr, attr_sz,NULL , +sizeof (struct bpf_common_attr )); +if (fd >=0 ) { +close (fd); +return -EINVAL ;^^^^^^Should
probe_sys_bpf_ext()return 1 instead of-EINVALwhen fd >= 0?The probe function detects kernel support for extended BPF syscall attributes by calling the BPF syscall with the
BPF_COMMON_ATTRSflag and a NULL pointer for common attributes.The expected outcomes are:
- New kernel with support: errno=EFAULT (can't copy from NULL) -> return 1
- Old kernel without support: errno!=EFAULT (invalid command) -> return 0If the syscall succeeds (fd >= 0), that definitively proves the kernel accepts the extended syscall format and supports
BPF_COMMON_ATTRS. The function should return 1 (supported) rather than-EINVAL(error).
Quoted 6 lines
Returning
-EINVALcausesfeat_supported()infeatures.cto print a warning "Detection of kernel BPF syscall common attributes support support failed: Invalid argument" and mark the feature as MISSING, incorrectly reporting that the kernel doesn't support the feature when the successful syscall proves it does.
Should not return 1.
This return was discussed in v5 and v6.
Cite Andrii's review in v5:
But fd should really not be >= 0, and if it is -- it's some problem, so I'd return an error in that case to keep us aware, which is why I'm saying I'd just return inside if (fd >= 0) { }
Thanks,
Leon
Quoted 12 lines
tools/lib/bpf/bpf.c static inline __u64 ptr_to_u64(const void *ptr) · line 106
Quoted 3 lines
tools/lib/bpf/bpf.c +3
-0+ } +return errno ==EFAULT ?1 :0 ; +}[ ... ]
---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.mdCI run summary: https://github.com/kernel-patches/bpf/actions/runs/25745661172
[email protected]
AI reviewThank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider: - [High] Implicit compiler padding in UAPI `struct bpf_common_attr` compromises backward compatibility.…
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [High] Implicit compiler padding in UAPI struct bpf_common_attr compromises backward compatibility.
- [High] BPF_COMMON_ATTRS flag is silently accepted and ignored for unsupported BPF commands, breaking UAPI feature probing. --
commit 8985d7da06248bc1e83a6cb46060187b0440e549
Author: Leon Hwang <[email protected]>
bpf: Extend BPF syscall with common attributes support
This commit adds generic BPF syscall support for passing common attributes like log_buf, log_size, log_level, and log_true_size. It introduces a new UAPI struct bpf_common_attr and a BPF_COMMON_ATTRS command flag bit to indicate when these attributes are provided.
Quoted 3 lines
include/uapi/linux/bpf.h +0
-0
[ ... ]
include/uapi/linux/bpf.h struct bpf_stack_build_id { · line 1509
Quoted 10 lines
include/uapi/linux/bpf.h +6
-0@@ -1500,6 +1501,13 @@ struct bpf_stack_build_id { }; }; +struct bpf_common_attr { +__aligned_u64 log_buf; +__u32 log_size; +__u32 log_level; +__u32 log_true_size; +};
Does this UAPI structure contain implicit trailing padding? With one __aligned_u64 (8 bytes) and three __u32 fields (12 bytes), there are 20 bytes of data. Because of the 8-byte alignment, the compiler will pad the structure to 24 bytes.
If a future kernel extension adds a new 4-byte field, older userspace programs allocating this structure on the stack might inadvertently pass uninitialized stack garbage into the new field, permanently breaking backward compatibility.
Should this include an explicit __u32 pad; field, and should the kernel explicitly validate that attr_common.pad == 0?
[ ... ]
Quoted 3 lines
kernel/bpf/syscall.c +0
-0
[ ... ]
kernel/bpf/syscall.c static int __sys_bpf(enum bpf_cmd cmd, bpfptr_t uattr, unsigned int size) · line 6237
Quoted 11 lines
kernel/bpf/syscall.c +7
-0@@ -6226,6 +6228,20 @@ static int __sys_bpf(enum bpf_cmd cmd, bpfptr_t uattr, unsigned int size)if (copy_from_bpfptr (&attr, uattr, size) !=0 )return -EFAULT ; +memset (&attr_common,0 ,sizeof (attr_common)); +if (cmd &BPF_COMMON_ATTRS ) { + err =bpf_check_uarg_tail_zero (uattr_common,sizeof (attr_common), size_common); +if (err) +return err; + + cmd &= ~BPF_COMMON_ATTRS ;
By unconditionally stripping BPF_COMMON_ATTRS from the command here, won't any BPF command (such as BPF_MAP_FREEZE) successfully accept the flag but silently ignore the provided common attributes?
This might prevent userspace from correctly probing whether the running kernel actually supports common attributes for a given command.
Should __sys_bpf() enforce a whitelist of supported commands before stripping the flag, or explicitly reject the flag for commands that do not support it?
Quoted 7 lines
kernel/bpf/syscall.c +7
-0+ size_common =min_t (u32, size_common,sizeof (attr_common)); +if (copy_from_bpfptr (&attr_common, uattr_common, size_common) !=0 ) +return -EFAULT ; + }else { + size_common =0 ; + } +
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
[email protected]
AI reviewRe: [PATCH bpf-next v14 4/8] bpf: Add syscall common attributes support for prog_load
In reply to Leon HwangThank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Medium] The log attribute merge logic in bpf_log_attr_init() incorrectly relies solely on the presence…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] The log attribute merge logic in bpf_log_attr_init() incorrectly relies solely on the presence of log_buf to detect log parameters, ignoring valid requests from bpf_common_attr and bypassing conflict checks. --
commit 1f52aae509f179f0117e37fa0cdfc161beb16d35
Author: Leon Hwang <[email protected]>
bpf: Add syscall common attributes support for prog_load
This commit allows BPF_PROG_LOAD to accept log parameters from either union bpf_attr or struct bpf_common_attr. The merge rules are designed to use complete log tuples from either side or return an error if they differ.
Quoted 4 lines
kernel/bpf/log.c +0
-0
[ ... ]
Quoted 8 lines
kernel/bpf/log.c +2
-1@@ -827,16 +827,36 @@ void print_insn_state(struct bpf_verifier_env *env, const struct bpf_verifier_st }int bpf_log_attr_init (struct bpf_log_attr *log,u64 log_buf,u32 log_size,u32 log_level, -u32 offsetof_log_true_size,bpfptr_t uattr) +u32 offsetof_log_true_size,bpfptr_t uattr,struct bpf_common_attr *common, +bpfptr_t uattr_common,u32 size_common) {
kernel/bpf/log.c void print_insn_state(struct bpf_verifier_env *env, const struct bpf_verifier_st · line 842
Quoted 10 lines
kernel/bpf/log.c +8
-0+char __user *ubuf_common =u64_to_user_ptr (common->log_buf);char __user *ubuf =u64_to_user_ptr (log_buf); +if (!bpf_verifier_log_attr_valid (common->log_level, ubuf_common, common->log_size) || + !bpf_verifier_log_attr_valid (log_level, ubuf, log_size)) +return -EINVAL ; + +if (ubuf && ubuf_common && (ubuf != ubuf_common || log_size != common->log_size || + log_level != common->log_level)) +return -EINVAL ;
The commit message states that if both sides provide complete tuples but they differ, it should return -EINVAL.
If a user wants to query the true log size, they can set log_level > 0 with log_buf = NULL and log_size = 0. This is explicitly permitted by bpf_verifier_log_attr_valid().
If both attr and attr_common omit the log buffer but provide conflicting log_level values, will this bypass the conflict check since both ubuf and ubuf_common evaluate to NULL?
kernel/bpf/log.c void print_insn_state(struct bpf_verifier_env *env, const struct bpf_verifier_st · line 851
Quoted 8 lines
kernel/bpf/log.c +2
-0memset (log,0 ,sizeof (*log)); log->ubuf = ubuf; log->size = log_size; log->level = log_level; log->offsetof_true_size = offsetof_log_true_size; log->uattr = uattr; + +if (!ubuf && ubuf_common) {
If the user sets common->log_level > 0 to query the true log size but omits common->log_buf, ubuf_common evaluates to NULL.
Does this cause the condition !ubuf && ubuf_common to evaluate to false, silently ignoring the valid attr_common request and falling back to the legacy attr?
Additionally, if both sides provide perfectly matching log buffers, but the legacy attr is too small to receive log_true_size (where offsetof_log_true_size is 0), would the code fail to utilize the attr_common capacity and silently drop the log_true_size output?
Quoted 10 lines
kernel/bpf/log.c +8
-0+ log->ubuf = ubuf_common; + log->size = common->log_size; + log->level = common->log_level; + log->uattr = uattr_common; + log->offsetof_true_size =0 ; + if (size_common >= offsetofend(struct bpf_common_attr, log_true_size)) + log->offsetof_true_size = offsetof(struct bpf_common_attr , log_true_size); + }return 0 ; }
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=4
[email protected]
AI reviewRe: [PATCH bpf-next v14 6/8] bpf: Add syscall common attributes support for map_create
In reply to Leon HwangThank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [High] Race condition causing unrelated file descriptor closure and resource leakage due to failure after…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] Race condition causing unrelated file descriptor closure and resource leakage due to failure after fd_install(). --
commit 37e50113e50fb4d6482363699239289046be6ff2
Author: Leon Hwang <[email protected]>
bpf: Add syscall common attributes support for map_create
This commit adds common syscall log attributes to map_create(). It creates a verifier log to report map-creation failure reasons back to userspace, improving debuggability.
Quoted 4 lines
kernel/bpf/syscall.c +0
-0
[ ... ]
Quoted 12 lines
kernel/bpf/syscall.c +8
-0@@ -1611,6 +1632,31 @@ static int map_create(union bpf_attr *attr, bpfptr_t uattr)return err; } +static int map_create (union bpf_attr *attr,bpfptr_t uattr,struct bpf_common_attr *attr_common, +bpfptr_t uattr_common,u32 size_common) +{ +struct bpf_verifier_log *log; +struct bpf_log_attr attr_log; +int err, ret; + + log =bpf_log_attr_create_vlog (&attr_log, attr_common, uattr_common, size_common);
kernel/bpf/syscall.c static int map_create(union bpf_attr *attr, bpfptr_t uattr) · line 1652
Quoted 10 lines
kernel/bpf/syscall.c +10
-0+if (IS_ERR (log)) +return PTR_ERR (log); + + err =__map_create (attr, uattr, log); + +/* preserve original error even if log finalization is successful */ + ret =bpf_log_attr_finalize (&attr_log, log); +if (ret) { +if (err >=0 ) +close_fd (err);
Since __map_create() has already successfully created the map and installed the file descriptor via fd_install(), the fd is globally visible to the process at this point.
If bpf_log_attr_finalize() fails (for example, due to an invalid pointer for log_true_size), we attempt to roll back by calling close_fd(err) and returning an error.
Could this race with a concurrent thread?
If another thread closes this fd and opens a new file between fd_install() and this close_fd() call, wouldn't we erroneously close an unrelated file?
Also, if another thread dups the fd before we close it, wouldn't the BPF map remain alive and accessible to userspace even though the map_create syscall returned a failure?
Quoted 6 lines
kernel/bpf/syscall.c +6
-0+ err = ret; + } + +kfree (log); +return err; +}
[ ... ]
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=6
[email protected]
AI reviewRe: [PATCH bpf-next v14 7/8] libbpf: Add syscall common attributes support for map_create
In reply to Leon HwangThank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Medium] Missing OPTS_VALID() check for the nested `log_opts` structure in `bpf_map_create` breaks ABI…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] Missing OPTS_VALID() check for the nested log_opts structure in bpf_map_create breaks ABI forward compatibility guarantees. --
commit a5ab21cbf48e1fc2cdb0af0f1ff743e2633f6ae8
Author: Leon Hwang <[email protected]>
libbpf: Add syscall common attributes support for map_create
The commit introduces struct bpf_log_opts and adds a log_opts field to bpf_map_create_opts to allow users to retrieve detailed error messages when map creation fails.
Quoted 4 lines
tools/lib/bpf/bpf.c +0
-0
[ ... ]
tools/lib/bpf/bpf.c int bpf_map_create(enum bpf_map_type map_type, · line 248
Quoted 6 lines
tools/lib/bpf/bpf.c +1
-1@@ -242,7 +245,18 @@ int bpf_map_create(enum bpf_map_type map_type, attr.excl_prog_hash =ptr_to_u64 (OPTS_GET (opts, excl_prog_hash,NULL )); attr.excl_prog_hash_size =OPTS_GET (opts, excl_prog_hash_size,0 ); - fd =sys_bpf_fd (BPF_MAP_CREATE , &attr, attr_sz); + log_opts =OPTS_GET (opts, log_opts,NULL );
Does this code need to validate log_opts with OPTS_VALID(log_opts, bpf_log_opts)?
Libbpf relies on the OPTS_VALID() macro to enforce ABI forward compatibility by verifying that any unrecognized trailing fields in extended option structs are explicitly zeroed. While bpf_map_create() correctly validates the outer bpf_map_create_opts structure, it seems the nested log_opts structure is accessed without similar validation.
If a newer application populates unsupported fields in struct bpf_log_opts with non-zero values, could an older libbpf silently ignore them instead of safely rejecting the request with -EINVAL?
Quoted 13 lines
tools/lib/bpf/bpf.c +11
-0+if (log_opts &&feat_supported (NULL ,FEAT_BPF_SYSCALL_COMMON_ATTRS )) { +memset (&attr_common,0 , attr_common_sz); + attr_common.log_buf =ptr_to_u64 (OPTS_GET (log_opts, buf,NULL )); + attr_common.log_size =OPTS_GET (log_opts, size,0 ); + attr_common.log_level =OPTS_GET (log_opts, level,0 ); + fd =sys_bpf_ext_fd (BPF_MAP_CREATE , &attr, attr_sz, &attr_common, attr_common_sz); +OPTS_SET (log_opts, true_size, attr_common.log_true_size); + }else { + fd =sys_bpf_fd (BPF_MAP_CREATE , &attr, attr_sz); +OPTS_SET (log_opts, true_size,0 ); + }return libbpf_err_errno (fd); }
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=7
[email protected]
AI reviewRe: [PATCH bpf-next v14 8/8] selftests/bpf: Add tests to verify map create failure log
In reply to Leon HwangThank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Medium] Hardcoded value of 0xFF (255) for invalid NUMA node and invalid token FD may cause spurious test…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] Hardcoded value of 0xFF (255) for invalid NUMA node and invalid token FD may cause spurious test failures on certain systems. --
commit b99a7cb4d2c7cfcc2878066c51d6ca1706eaa83a
Author: Leon Hwang <[email protected]>
selftests/bpf: Add tests to verify map create failure log
Add tests to verify that the kernel reports the expected error messages and correct log_true_size when map creation fails.
Quoted 4 lines
tools/testing/selftests/bpf/prog_tests/map_init.c +0
-0
[ ... ]
tools/testing/selftests/bpf/prog_tests/map_init.c void test_map_init(void) · line 290
Quoted 6 lines
tools/testing/selftests/bpf/prog_tests/map_init.c +6
-0+static void test_invalid_numa_node (void ) +{ +const char *msg ="Invalid numa_node.\n" ; + LIBBPF_OPTS(bpf_map_create_opts, opts, + .map_flags = BPF_F_NUMA_NODE, + .numa_node = 0xFF,
Would this test be flaky on a massive system? Using 0xFF (255) for the NUMA node could accidentally match an online node on systems with large NUMA topologies (e.g., up to 1024 nodes).
Would it be safer to use ~0U or -1 to represent a guaranteed invalid node?
Quoted 4 lines
tools/testing/selftests/bpf/prog_tests/map_init.c +4
-0+ ); + +test_map_create_array (&opts, msg); +}
[ ... ]
tools/testing/selftests/bpf/prog_tests/map_init.c void test_map_init(void) · line 309
Quoted 6 lines
tools/testing/selftests/bpf/prog_tests/map_init.c +6
-0+static void test_invalid_token_fd (void ) +{ +const char *msg ="Invalid map_token_fd.\n" ; + LIBBPF_OPTS(bpf_map_create_opts, opts, + .map_flags = BPF_F_TOKEN_FD, + .token_fd = 0xFF,
Could the use of 0xFF (255) as a file descriptor lead to spurious test failures?
While an open FD 255 is unlikely to be a BPF token, using -1 or ~0U is the standard way to provide an invalid FD, which completely eliminates the risk of accidentally hitting an open file descriptor.
Quoted 4 lines
tools/testing/selftests/bpf/prog_tests/map_init.c +4
-0+ ); + +test_map_create_array (&opts, msg); +}
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=8
On 2026/5/14 06:48, [email protected] wrote:
[...]
Quoted 13 lines
Review
Quoted 7 lines
(quoted diff) +6
-0+struct bpf_common_attr { + __aligned_u64 log_buf; + __u32 log_size; + __u32 log_level; + __u32 log_true_size; +};Does this UAPI structure contain implicit trailing padding? With one
__aligned_u64(8 bytes) and three__u32fields (12 bytes), there are 20 bytes of data. Because of the 8-byte alignment, the compiler will pad the structure to 24 bytes.
Quoted 7 lines
If a future kernel extension adds a new 4-byte field, older userspace programs allocating this structure on the stack might inadvertently pass uninitialized stack garbage into the new field, permanently breaking backward compatibility.
Should this include an explicit
__u32pad; field, and should the kernel explicitly validate that attr_common.pad == 0?
This concern seems valid to me.
Propose my fix here:
kernel/bpf/syscall.c +0 -0
@@ -6278,7 +6278,9 @@ static int __sys_bpf(enum bpf_cmd cmd, bpfptr_t
uattr, unsigned int size,
memset(&attr_common, 0, sizeof(attr_common));
if (cmd & BPF_COMMON_ATTRS) {- err = bpf_check_uarg_tail_zero(uattr_common,sizeof(attr_common), size_common);
+ err = bpf_check_uarg_tail_zero(uattr_common,
+ offsetofend(structbpf_common_attr, log_true_size),
+ size_common);
if (err)
return err;This is to avoid adding an explicit __u32 pad in struct bpf_common_attr.
Quoted 12 lines
[ ... ]
Quoted 3 lines
kernel/bpf/syscall.c +0
-0[ ... ]
Quoted 4 lines
kernel/bpf/syscall.c +0
-0@@ -6226,6 +6228,20 @@ static int __sys_bpf(enum bpf_cmd cmd, bpfptr_t uattr, unsigned int size)if (copy_from_bpfptr (&attr, uattr, size) !=0 )return -EFAULT ;
Quoted 12 lines
kernel/bpf/syscall.c static int __sys_bpf(enum bpf_cmd cmd, bpfptr_t uattr, unsigned int size) · line 6237
Quoted 7 lines
kernel/bpf/syscall.c +7
-0+memset (&attr_common,0 ,sizeof (attr_common)); +if (cmd &BPF_COMMON_ATTRS ) { + err =bpf_check_uarg_tail_zero (uattr_common,sizeof (attr_common), size_common); +if (err) +return err; + + cmd &= ~BPF_COMMON_ATTRS ;By unconditionally stripping
BPF_COMMON_ATTRSfrom the command here, won't any BPF command (such asBPF_MAP_FREEZE) successfully accept the flag but silently ignore the provided common attributes?
Correct.
Quoted 6 lines
This might prevent userspace from correctly probing whether the running kernel actually supports common attributes for a given command.
Should
__sys_bpf()enforce a whitelist of supported commands before stripping the flag, or explicitly reject the flag for commands that do not support it?
If users want to probe for common attributes feature, they can do it by the way of patch #2.
Thanks,
Leon
[...]
Re: [PATCH bpf-next v14 6/8] bpf: Add syscall common attributes support for map_create
In reply to [email protected]On 2026/5/14 08:46, [email protected] wrote:
[...]
Quoted 17 lines
kernel/bpf/syscall.c static int map_create(union bpf_attr *attr, bpfptr_t uattr) · line 1652
Quoted 8 lines
kernel/bpf/syscall.c +8
-0+ + err =__map_create (attr, uattr, log); + +/* preserve original error even if log finalization is successful */ + ret =bpf_log_attr_finalize (&attr_log, log); +if (ret) { +if (err >=0 ) +close_fd (err);Since
__map_create()has already successfully created the map and installed the file descriptor viafd_install(), the fd is globally visible to the process at this point.If
bpf_log_attr_finalize()fails (for example, due to an invalid pointer forlog_true_size), we attempt to roll back by callingclose_fd(err)and returning an error.
Quoted 9 lines
Could this race with a concurrent thread?
If another thread closes this fd and opens a new file between
fd_install()and thisclose_fd()call, wouldn't we erroneously close an unrelated file?Also, if another thread dups the fd before we close it, wouldn't the BPF map remain alive and accessible to userspace even though the
map_createsyscall returned a failure?
Replied in v13
https://lore.kernel.org/bpf/[email protected]/.
Thanks,
Leon
[...]
Re: [PATCH bpf-next v14 7/8] libbpf: Add syscall common attributes support for map_create
In reply to [email protected]On 2026/5/14 09:08, [email protected] wrote:
[...]
Quoted 16 lines
tools/lib/bpf/bpf.c int bpf_map_create(enum bpf_map_type map_type, · line 248
Quoted 7 lines
tools/lib/bpf/bpf.c +1
-1@@ -242,7 +245,18 @@ int bpf_map_create(enum bpf_map_type map_type, attr.excl_prog_hash =ptr_to_u64 (OPTS_GET (opts, excl_prog_hash,NULL )); attr.excl_prog_hash_size =OPTS_GET (opts, excl_prog_hash_size,0 ); - fd =sys_bpf_fd (BPF_MAP_CREATE , &attr, attr_sz); + log_opts =OPTS_GET (opts, log_opts,NULL );Does this code need to validate
log_optswithOPTS_VALID(log_opts, bpf_log_opts)?Libbpf relies on the
OPTS_VALID()macro to enforce ABI forward compatibility by verifying that any unrecognized trailing fields in extended option structs are explicitly zeroed. Whilebpf_map_create()correctly validates the outerbpf_map_create_optsstructure, it seems the nestedlog_optsstructure is accessed without similar validation.
Quoted 4 lines
If a newer application populates unsupported fields in struct
bpf_log_optswith non-zero values, could an older libbpf silently ignore them instead of safely rejecting the request with-EINVAL?
Replied in v13
https://lore.kernel.org/bpf/[email protected]/.
Thanks,
Leon
[...]
Re: [PATCH bpf-next v14 8/8] selftests/bpf: Add tests to verify map create failure log
In reply to [email protected]On 2026/5/14 09:25, [email protected] wrote:
[...]
Quoted 27 lines
tools/testing/selftests/bpf/prog_tests/map_init.c void test_map_init(void) · line 290
Quoted 6 lines
tools/testing/selftests/bpf/prog_tests/map_init.c +6
-0+static void test_invalid_numa_node (void ) +{ +const char *msg ="Invalid numa_node.\n" ; + LIBBPF_OPTS(bpf_map_create_opts, opts, + .map_flags = BPF_F_NUMA_NODE, + .numa_node = 0xFF,Would this test be flaky on a massive system? Using
0xFF(255) for the NUMA node could accidentally match an online node on systems with large NUMA topologies (e.g., up to 1024 nodes).Would it be safer to use ~0U or -1 to represent a guaranteed invalid node?
Quoted 4 lines
tools/testing/selftests/bpf/prog_tests/map_init.c +4
-0+ ); + +test_map_create_array (&opts, msg); +}[ ... ]
tools/testing/selftests/bpf/prog_tests/map_init.c void test_map_init(void) · line 309
Quoted 6 lines
tools/testing/selftests/bpf/prog_tests/map_init.c +6
-0+static void test_invalid_token_fd (void ) +{ +const char *msg ="Invalid map_token_fd.\n" ; + LIBBPF_OPTS(bpf_map_create_opts, opts, + .map_flags = BPF_F_TOKEN_FD, + .token_fd = 0xFF,Could the use of
0xFF(255) as a file descriptor lead to spurious test failures?
Quoted 9 lines
While an open FD 255 is unlikely to be a BPF token, using -1 or ~0U is the standard way to provide an invalid FD, which completely eliminates the risk of accidentally hitting an open file descriptor.
tools/testing/selftests/bpf/prog_tests/map_init.c void test_map_init(void) · line 252
Quoted 4 lines
tools/testing/selftests/bpf/prog_tests/map_init.c +4
-0+ ); + +test_map_create_array (&opts, msg); +}
Replied in v13
https://lore.kernel.org/bpf/[email protected]/.
Thanks,
Leon
[...]