bpf: Extend BPF syscall with common attributes support
Subsystems (6)
v9 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.
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': The size of log reported by kernel.
With this extension, the BPF syscall will be able to return meaningful error messages (e.g., failures of creating map), improving debuggability and user experience.
Links:
[1] https://lore.kernel.org/bpf/[email protected]/
Changes:
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 (9):
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: Refactor reporting btf_log_true_size for btf_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 | 17 ++ include/linux/btf.h | 3 +- include/linux/syscalls.h | 3 +- include/uapi/linux/bpf.h | 8 + kernel/bpf/btf.c | 26 +-- kernel/bpf/log.c | 101 +++++++++++ kernel/bpf/syscall.c | 107 ++++++++--- kernel/bpf/verifier.c | 13 +- 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 | 168 ++++++++++++++++++ 15 files changed, 483 insertions(+), 55 deletions(-)
--
2.52.0
PATCH v9 1/9 bpf: Extend BPF syscall with common attributes support
Extend the BPF syscall to support a set of common attributes shared across all BPF commands:
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': The size of log reported by kernel.
These common attributes are passed as the 4th argument to the BPF syscall, with the 5th argument specifying the size of this structure.
To indicate the use of these common attributes from userspace, a new flag 'BPF_COMMON_ATTRS' ('1 << 16') is introduced. This flag is OR-ed into the 'cmd' field of the syscall.
When 'cmd & BPF_COMMON_ATTRS' is set, the kernel will copy the common attributes from userspace into kernel space for use.
--- 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
@@ -937,7 +937,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 { +__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
@@ -6176,8 +6176,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;
@@ -6191,6 +6193,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;
@@ -6326,9 +6342,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,
@@ -6359,7 +6376,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 { +__u64 log_buf; +__u32 log_size; +__u32 log_level; +__u32 log_true_size; +}; +#define BPF_OBJ_NAME_LEN 16Uenum {
Signature · 1 line
2.52.0
PATCH v9 2/9 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
@@ -506,6 +506,11 @@ static int probe_kern_arg_ctx_tag(int token_fd)return probe_fd (prog_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;
@@ -581,6 +586,9 @@ static struct kern_feature_desc { [FEAT_BTF_QMARK_DATASEC ] = {"BTF DATASEC names starting from '?'" , probe_kern_btf_qmark_datasec, }, + [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
@@ -392,6 +392,8 @@ enum kern_feature_id {FEAT_ARG_CTX_TAG ,/* Kernel supports '?' at the front of datasec names */ FEAT_BTF_QMARK_DATASEC , +/* Kernel supports BPF syscall common attributes */ +FEAT_BPF_SYSCALL_COMMON_ATTRS , __FEAT_CNT, };
@@ -757,4 +759,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.52.0
PATCH v9 3/9 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_prog_load_log_attr_init(): initialize the 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 | 10 ++++++++++ kernel/bpf/log.c | 35 +++++++++++++++++++++++++++++++++++ kernel/bpf/syscall.c | 8 +++++--- kernel/bpf/verifier.c | 13 +++---------- 5 files changed, 56 insertions(+), 14 deletions(-)
include/linux/bpf.h +3 -1
@@ -2913,7 +2913,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 +10 -0
@@ -631,6 +631,16 @@ static inline bool bpf_verifier_log_needed(const struct bpf_verifier_log *log)return log && log->level; } +struct bpf_log_attr { +u32 offsetof_true_size; +u32 uattr_size; +bpfptr_t uattr; +}; + +int bpf_prog_load_log_attr_init (struct bpf_log_attr *attr_log,union bpf_attr *attr, +bpfptr_t uattr,u32 size); +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 +35 -0
@@ -863,3 +863,38 @@ void print_insn_state(struct bpf_verifier_env *env, const struct bpf_verifier_st }print_verifier_state (env, vstate, frameno, false); } + +static void bpf_log_attr_init (struct bpf_log_attr *attr_log,int offsetof_true_size,bpfptr_t uattr, +u32 uattr_size) +{ +memset (attr_log,0 ,sizeof (*attr_log)); + attr_log->offsetof_true_size = offsetof_true_size; + attr_log->uattr_size = uattr_size; + attr_log->uattr = uattr; +} + +int bpf_prog_load_log_attr_init (struct bpf_log_attr *attr_log,union bpf_attr *attr, +bpfptr_t uattr,u32 size) +{ +bpf_log_attr_init (attr_log, offsetof(union bpf_attr , log_true_size), uattr, size); +return 0 ; +} + +int bpf_log_attr_finalize (struct bpf_log_attr *attr,struct bpf_verifier_log *log) +{ +u32 log_true_size; +size_t size; +int err; + +if (!log) +return 0 ; + + err =bpf_vlog_finalize (log, &log_true_size); + + size =sizeof (log_true_size); +if (attr->uattr_size >= attr->offsetof_true_size + size && +copy_to_bpfptr_offset (attr->uattr, attr->offsetof_true_size, &log_true_size, size)) + err = -EFAULT ; + +return err; +}
kernel/bpf/syscall.c +5 -3
@@ -2860,7 +2860,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 ;
@@ -3078,7 +3078,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;
@@ -6180,6 +6180,7 @@ 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; +struct bpf_log_attr attr_log;union bpf_attr attr;int err;
@@ -6231,7 +6232,8 @@ 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); + err =bpf_prog_load_log_attr_init (&attr_log, &attr, uattr, size); + err = err ?:bpf_prog_load (&attr, uattr, &attr_log);break ;case BPF_OBJ_PIN : err =bpf_obj_pin (&attr);
kernel/bpf/verifier.c +3 -10
@@ -25604,12 +25604,12 @@ static int compute_scc(struct bpf_verifier_env *env)return err; } -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 );
@@ -25808,17 +25808,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.52.0
PATCH v9 4/9 bpf: Add syscall common attributes support for prog_load
In reply to Leon HwangBPF_PROG_LOAD can now provide log parameters through both union bpf_attr and struct bpf_common_attr. Define clear conflict and precedence rules:
- if both are provided and log_buf/log_size/log_level match, use them;
- if only one side provides a log buffer, use that one;
- if both provide log buffers but differ, return -EINVAL.
--- include/linux/bpf_verifier.h | 3 ++- kernel/bpf/log.c | 24 ++++++++++++++++++++++-- kernel/bpf/syscall.c | 3 ++- 3 files changed, 26 insertions(+), 4 deletions(-)
include/linux/bpf_verifier.h +2 -1
@@ -638,7 +638,8 @@ struct bpf_log_attr { };int bpf_prog_load_log_attr_init (struct bpf_log_attr *attr_log,union bpf_attr *attr, -bpfptr_t uattr,u32 size); +bpfptr_t uattr,u32 size,struct bpf_common_attr *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 +22 -2
@@ -873,10 +873,30 @@ static void bpf_log_attr_init(struct bpf_log_attr *attr_log, int offsetof_true_s attr_log->uattr = uattr; } +static bool bpf_log_attrs_diff (struct bpf_common_attr *common,u64 log_buf,u32 log_size, +u32 log_level) +{ +return log_buf && common->log_buf && (log_buf != common->log_buf || + log_size != common->log_size || + log_level != common->log_level); +} +int bpf_prog_load_log_attr_init (struct bpf_log_attr *attr_log,union bpf_attr *attr, -bpfptr_t uattr,u32 size) +bpfptr_t uattr,u32 size,struct bpf_common_attr *attr_common, +bpfptr_t uattr_common,u32 size_common) { -bpf_log_attr_init (attr_log, offsetof(union bpf_attr , log_true_size), uattr, size); +if (bpf_log_attrs_diff (attr_common, attr->log_buf, attr->log_size, attr->log_level)) +return -EINVAL ; + +if (!attr->log_buf && attr_common->log_buf) { + attr->log_buf = attr_common->log_buf; + attr->log_size = attr_common->log_size; + attr->log_level = attr_common->log_level; +bpf_log_attr_init (attr_log, offsetof(struct bpf_common_attr , log_true_size), + uattr_common, size_common); + }else { +bpf_log_attr_init (attr_log, offsetof(union bpf_attr , log_true_size), uattr, size); + }return 0 ; }
kernel/bpf/syscall.c +2 -1
@@ -6232,7 +6232,8 @@ 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_log_attr_init (&attr_log, &attr, uattr, size); + err =bpf_prog_load_log_attr_init (&attr_log, &attr, uattr, size, &attr_common, + uattr_common, size_common); err = err ?:bpf_prog_load (&attr, uattr, &attr_log);break ;case BPF_OBJ_PIN :
Signature · 1 line
2.52.0
PATCH v9 5/9 bpf: Refactor reporting btf_log_true_size for btf_load
In reply to Leon HwangIn the next commit, it will be able to report logs via extended common attributes, which will report 'log_true_size' via the extended common attributes meanwhile.
Therefore, refactor the way of 'btf_log_true_size' reporting in order to report 'log_true_size' via the extended common attributes easily.
--- include/linux/bpf_verifier.h | 2 ++ include/linux/btf.h | 3 ++- kernel/bpf/btf.c | 26 ++++++-------------------- kernel/bpf/log.c | 7 +++++++ kernel/bpf/syscall.c | 7 ++++--- 5 files changed, 21 insertions(+), 24 deletions(-)
include/linux/bpf_verifier.h +2 -0
@@ -640,6 +640,8 @@ struct bpf_log_attr {int bpf_prog_load_log_attr_init (struct bpf_log_attr *attr_log,union bpf_attr *attr,bpfptr_t uattr,u32 size,struct bpf_common_attr *attr_common,bpfptr_t uattr_common,u32 size_common); +int bpf_btf_load_log_attr_init (struct bpf_log_attr *attr_log,union bpf_attr *attr, +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
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 +6 -20
@@ -5856,22 +5856,8 @@ 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);
@@ -5953,7 +5939,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;
@@ -5965,7 +5951,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:
@@ -8136,12 +8122,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/log.c +7 -0
@@ -900,6 +900,13 @@ int bpf_prog_load_log_attr_init(struct bpf_log_attr *attr_log, union bpf_attr *areturn 0 ; } +int bpf_btf_load_log_attr_init (struct bpf_log_attr *attr_log,union bpf_attr *attr, +bpfptr_t uattr,u32 size) +{ +bpf_log_attr_init (attr_log, offsetof(union bpf_attr , btf_log_true_size), uattr, size); +return 0 ; +} +int bpf_log_attr_finalize (struct bpf_log_attr *attr,struct bpf_verifier_log *log) {u32 log_true_size;
kernel/bpf/syscall.c +4 -3
@@ -5438,7 +5438,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 ;
@@ -5465,7 +5465,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
@@ -6279,7 +6279,8 @@ 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); + err =bpf_btf_load_log_attr_init (&attr_log, &attr, uattr, size); + 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.52.0
PATCH v9 6/9 bpf: Add syscall common attributes support for btf_load
In reply to Leon HwangBPF_BTF_LOAD can now provide log parameters through both union bpf_attr and bpf_common_attr. Apply the same conflict and precedence rules as prog_load:
- if both are provided and btf_log_buf/btf_log_size/btf_log_level match, use them;
- if only one side provides a log buffer, use that one;
- if both provide log buffers but differ, return -EINVAL.
--- include/linux/bpf_verifier.h | 3 ++- kernel/bpf/log.c | 18 ++++++++++++++++-- kernel/bpf/syscall.c | 3 ++- 3 files changed, 20 insertions(+), 4 deletions(-)
include/linux/bpf_verifier.h +2 -1
@@ -641,7 +641,8 @@ int bpf_prog_load_log_attr_init(struct bpf_log_attr *attr_log, union bpf_attr *a bpfptr_t uattr, u32 size, struct bpf_common_attr *attr_common, bpfptr_t uattr_common, u32 size_common);int bpf_btf_load_log_attr_init (struct bpf_log_attr *attr_log,union bpf_attr *attr, -bpfptr_t uattr,u32 size); +bpfptr_t uattr,u32 size,struct bpf_common_attr *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 +16 -2
@@ -901,9 +901,23 @@ int bpf_prog_load_log_attr_init(struct bpf_log_attr *attr_log, union bpf_attr *a }int bpf_btf_load_log_attr_init (struct bpf_log_attr *attr_log,union bpf_attr *attr, -bpfptr_t uattr,u32 size) +bpfptr_t uattr,u32 size,struct bpf_common_attr *attr_common, +bpfptr_t uattr_common,u32 size_common) { -bpf_log_attr_init (attr_log, offsetof(union bpf_attr , btf_log_true_size), uattr, size); +if (bpf_log_attrs_diff (attr_common, attr->btf_log_buf, attr->btf_log_size, + attr->btf_log_level)) +return -EINVAL ; + +if (!attr->btf_log_buf && attr_common->log_buf) { + attr->btf_log_buf = attr_common->log_buf; + attr->btf_log_size = attr_common->log_size; + attr->btf_log_level = attr_common->log_level; +bpf_log_attr_init (attr_log, offsetof(struct bpf_common_attr , log_true_size), + uattr_common, size_common); + }else { +bpf_log_attr_init (attr_log, offsetof(union bpf_attr , btf_log_true_size), uattr, + size); + }return 0 ; }
kernel/bpf/syscall.c +2 -1
@@ -6279,7 +6279,8 @@ 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_log_attr_init (&attr_log, &attr, uattr, size); + err =bpf_btf_load_log_attr_init (&attr_log, &attr, uattr, size, &attr_common, + uattr_common, size_common); err = err ?:bpf_btf_load (&attr, uattr, &attr_log);break ;case BPF_BTF_GET_FD_BY_ID :
Signature · 1 line
2.52.0
PATCH v9 7/9 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 | 25 ++++++++++++++ kernel/bpf/syscall.c | 65 ++++++++++++++++++++++++++++++------ 3 files changed, 83 insertions(+), 10 deletions(-)
include/linux/bpf_verifier.h +3 -0
@@ -643,6 +643,9 @@ int bpf_prog_load_log_attr_init(struct bpf_log_attr *attr_log, union bpf_attr *aint bpf_btf_load_log_attr_init (struct bpf_log_attr *attr_log,union bpf_attr *attr,bpfptr_t uattr,u32 size,struct bpf_common_attr *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 +25 -0
@@ -921,6 +921,31 @@ int bpf_btf_load_log_attr_init(struct bpf_log_attr *attr_log, union bpf_attr *atreturn 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; + +if (!common->log_buf) +return NULL ; + + log =kzalloc (sizeof (*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); + } + +bpf_log_attr_init (attr_log, offsetof(struct bpf_common_attr , log_true_size), uattr, size); +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 +55 -10
147 lines not on this page · raw message
Signature · 1 line
2.52.0
PATCH v9 8/9 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, log_buf,NULL )); + attr_common.log_size =OPTS_GET (log_opts, log_size,0 ); + attr_common.log_level =OPTS_GET (log_opts, log_level,0 ); + fd =sys_bpf_ext_fd (BPF_MAP_CREATE , &attr, attr_sz, &attr_common, attr_common_sz); +OPTS_SET (log_opts, log_true_size, attr_common.log_true_size); + }else { + fd =sys_bpf_fd (BPF_MAP_CREATE , &attr, attr_sz); +OPTS_SET (log_opts, log_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 *log_buf; +__u32 log_size; +__u32 log_level; +__u32 log_true_size; + + size_t :0; +}; +#define bpf_log_opts__last_field log_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.52.0
PATCH v9 9/9 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 when map creation fails.
--- .../selftests/bpf/prog_tests/map_init.c | 168 ++++++++++++++++++ 1 file changed, 168 insertions(+)
tools/testing/selftests/bpf/prog_tests/map_init.c +168 -0
@@ -212,3 +212,171 @@ void test_map_init(void)if (test__start_subtest ("pcpu_lru_map_init" ))test_pcpu_lru_map_init (); } + +#define BPF_LOG_FIXED 8 + +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.log_buf = log_buf; + log_opts.log_size =sizeof (log_buf); + log_opts.log_level =BPF_LOG_FIXED ; + 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.log_true_size,strlen (exp_msg) +1 ,"log_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.52.0
Re: [PATCH bpf-next v9 8/9] libbpf: Add syscall common attributes support for map_create
In reply to Leon HwangQuoted 8 lines · Leon Hwang
With the previous commit adding common attribute support for
BPF_MAP_CREATE, users can now retrieve detailed error messages when map creation fails via thelog_buffield.Introduce struct
bpf_log_optswith the following fields:log_buf,log_size,log_level, andlog_true_size.
Quoted 9 lines
Extend
bpf_map_create_optswith a new fieldlog_opts, allowing users to capture and inspect log messages on map creation failures.Signed-off-by Leon Hwang <[email protected]>--- tools/lib/bpf/bpf.c | 16 +++++++++++++++- tools/lib/bpf/bpf.h | 17 ++++++++++++++++- 2 files changed, 31 insertions(+), 2 deletions(-)
LGTM
Quoted 39 lines
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, log_buf,NULL )); + attr_common.log_size =OPTS_GET (log_opts, log_size,0 ); + attr_common.log_level =OPTS_GET (log_opts, log_level,0 ); + fd =sys_bpf_ext_fd (BPF_MAP_CREATE , &attr, attr_sz, &attr_common, attr_common_sz); +OPTS_SET (log_opts, log_true_size, attr_common.log_true_size); + }else { + fd =sys_bpf_fd (BPF_MAP_CREATE , &attr, attr_sz); +OPTS_SET (log_opts, log_true_size,0 ); + }return libbpf_err_errno (fd); }tools/lib/bpf/bpf.h +0
-0
tools/lib/bpf/bpf.h extern "C" { · line 46
Quoted 10 lines
tools/lib/bpf/bpf.h +7
-0@@ -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 *log_buf; +__u32 log_size; +__u32 log_level; +__u32 log_true_size;
please mention in the comment here that this is an out parameter set by the kernel
Quoted 25 lines
tools/lib/bpf/bpf.h +9
-2+ + size_t :0; +}; +#define bpf_log_opts__last_field log_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, --2.52.0
Re: [PATCH bpf-next v9 2/9] libbpf: Add support for extended bpf syscall
In reply to Leon HwangQuoted 11 lines · Leon Hwang
To 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.
Quoted 7 lines
Signed-off-by Leon Hwang <[email protected]>--- tools/lib/bpf/bpf.c | 36 +++++++++++++++++++++++++++++++++ tools/lib/bpf/features.c | 8 ++++++++ tools/lib/bpf/libbpf_internal.h | 3 +++ 3 files changed, 47 insertions(+)
LGTM
[...]
Re: [PATCH bpf-next v9 3/9] bpf: Refactor reporting log_true_size for prog_load
In reply to Leon HwangQuoted 80 lines · Leon Hwang
The 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 structbpf_log_attrto encapsulate log-related behavior:*
bpf_prog_load_log_attr_init(): initialize the 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.Signed-off-by Leon Hwang <[email protected]>--- include/linux/bpf.h | 4 +++- include/linux/bpf_verifier.h | 10 ++++++++++ kernel/bpf/log.c | 35 +++++++++++++++++++++++++++++++++++ kernel/bpf/syscall.c | 8 +++++--- kernel/bpf/verifier.c | 13 +++---------- 5 files changed, 56 insertions(+), 14 deletions(-)include/linux/bpf.h +3
-1@@ -2913,7 +2913,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 +10
-0@@ -631,6 +631,16 @@ static inline bool bpf_verifier_log_needed(const struct bpf_verifier_log *log)return log && log->level; } +struct bpf_log_attr { +u32 offsetof_true_size; +u32 uattr_size; +bpfptr_t uattr; +}; + +int bpf_prog_load_log_attr_init (struct bpf_log_attr *attr_log,union bpf_attr *attr, +bpfptr_t uattr,u32 size); +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 +15
-0@@ -863,3 +863,38 @@ void print_insn_state(struct bpf_verifier_env *env, const struct bpf_verifier_st }print_verifier_state (env, vstate, frameno, false); } + +static void bpf_log_attr_init (struct bpf_log_attr *attr_log,int offsetof_true_size,bpfptr_t uattr, +u32 uattr_size) +{ +memset (attr_log,0 ,sizeof (*attr_log)); + attr_log->offsetof_true_size = offsetof_true_size; + attr_log->uattr_size = uattr_size; + attr_log->uattr = uattr; +} + +int bpf_prog_load_log_attr_init (struct bpf_log_attr *attr_log,union bpf_attr *attr, +bpfptr_t uattr,u32 size) +{ +bpf_log_attr_init (attr_log, offsetof(union bpf_attr , log_true_size), uattr, size); +return 0 ;
kernel/bpf/log.c void print_insn_state(struct bpf_verifier_env *env, const struct bpf_verifier_st · line 890
Quoted 10 lines
kernel/bpf/log.c +10
-0+} + +int bpf_log_attr_finalize (struct bpf_log_attr *attr,struct bpf_verifier_log *log) +{ +u32 log_true_size; +size_t size; +int err; + +if (!log) +return 0 ;
can this ever happen? why guard against this?
kernel/bpf/log.c void print_insn_state(struct bpf_verifier_env *env, const struct bpf_verifier_st · line 897
Quoted 7 lines
kernel/bpf/log.c +7
-0+ + err =bpf_vlog_finalize (log, &log_true_size); + + size =sizeof (log_true_size); +if (attr->uattr_size >= attr->offsetof_true_size + size && +copy_to_bpfptr_offset (attr->uattr, attr->offsetof_true_size, &log_true_size, size)) + err = -EFAULT ;
minor nit: return -EFAULT;
Quoted 3 lines
kernel/bpf/log.c +3
-0+ +return err; +}
[...]
Re: [PATCH bpf-next v9 4/9] bpf: Add syscall common attributes support for prog_load
In reply to Leon HwangQuoted 34 lines · Leon Hwang
BPF_PROG_LOADcan now provide log parameters through both unionbpf_attrand structbpf_common_attr. Define clear conflict and precedence rules:- if both are provided and log_buf/log_size/log_level match, use them;
- if only one side provides a log buffer, use that one;
- if both provide log buffers but differ, return-EINVAL.Signed-off-by Leon Hwang <[email protected]>--- include/linux/bpf_verifier.h | 3 ++- kernel/bpf/log.c | 24 ++++++++++++++++++++++-- kernel/bpf/syscall.c | 3 ++- 3 files changed, 26 insertions(+), 4 deletions(-)include/linux/bpf_verifier.h +2
-1@@ -638,7 +638,8 @@ struct bpf_log_attr { };int bpf_prog_load_log_attr_init (struct bpf_log_attr *attr_log,union bpf_attr *attr, -bpfptr_t uattr,u32 size); +bpfptr_t uattr,u32 size,struct bpf_common_attr *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 256kernel/bpf/log.c +0
-0
kernel/bpf/log.c static void bpf_log_attr_init(struct bpf_log_attr *attr_log, int offsetof_true_s · line 881
Quoted 9 lines
kernel/bpf/log.c +6
-0@@ -873,10 +873,30 @@ static void bpf_log_attr_init(struct bpf_log_attr *attr_log, int offsetof_true_s attr_log->uattr = uattr; } +static bool bpf_log_attrs_diff (struct bpf_common_attr *common,u64 log_buf,u32 log_size, +u32 log_level) +{ +return log_buf && common->log_buf && (log_buf != common->log_buf || + log_size != common->log_size || + log_level != common->log_level);
let's validate (unless we do this somewhere else) that if log_buf is set, then log_size and log_level (? not sure, maybe zero is fine) are set, or all three are not set. Same for common->log* fields...
Quoted 5 lines
kernel/bpf/log.c +3
-1+} + int bpf_prog_load_log_attr_init(struct bpf_log_attr *attr_log, union bpf_attr *attr, -bpfptr_t uattr,u32 size) + bpfptr_t uattr, u32 size, struct bpf_common_attr *attr_common,
kernel/bpf/log.c static void bpf_log_attr_init(struct bpf_log_attr *attr_log, int offsetof_true_s · line 894
Quoted 10 lines
kernel/bpf/log.c +8
-1+ bpfptr_t uattr_common, u32 size_common) { -bpf_log_attr_init (attr_log, offsetof(union bpf_attr , log_true_size), uattr, size); + if (bpf_log_attrs_diff(attr_common, attr->log_buf, attr->log_size, attr->log_level)) + return -EINVAL; + +if (!attr->log_buf && attr_common->log_buf) { + attr->log_buf = attr_common->log_buf; + attr->log_size = attr_common->log_size; + attr->log_level = attr_common->log_level;
why are we setting this? Do we still have code that can access attr->log_buf even though we pass attr_log everywhere? If yes, should we still have that "split brain" code?
If we don't have this assignment, then I think we don't need to have bpf_prog_load-specific and btf_load-specific log_attr_init() helpers. They can be unified into generic log_attr_init, where for bpf_prog_load you'll pass offsetof(log_true_size) + attr->log_{buf,size,level}, and for btf_load you'll pass different offset of and btf-specific attr->btf_log*
This helper will just be making decision whether to use common_attr's log fields or passed directly command-specific ones.
Or what am I missing?
Quoted 25 lines
kernel/bpf/log.c +5
-0+bpf_log_attr_init (attr_log, offsetof(struct bpf_common_attr , log_true_size), + uattr_common, size_common); + }else { +bpf_log_attr_init (attr_log, offsetof(union bpf_attr , log_true_size), uattr, size); + }return 0 ; }kernel/bpf/syscall.c +2
-2@@ -6232,7 +6232,8 @@ 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_log_attr_init (&attr_log, &attr, uattr, size); + err =bpf_prog_load_log_attr_init (&attr_log, &attr, uattr, size, &attr_common, + uattr_common, size_common); err = err ?:bpf_prog_load (&attr, uattr, &attr_log);break ;case BPF_OBJ_PIN : --2.52.0
Re: [PATCH bpf-next v9 9/9] selftests/bpf: Add tests to verify map create failure log
In reply to Leon HwangQuoted 6 lines · Leon Hwang
tools/testing/selftests/bpf/prog_tests/map_init.c +5
-0+ +#define BPF_LOG_FIXED 8 + +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)
tools/testing/selftests/bpf/prog_tests/map_init.c void test_map_init(void) · line 229
Quoted 10 lines
tools/testing/selftests/bpf/prog_tests/map_init.c +10
-0+{ +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.log_buf = log_buf; + log_opts.log_size =sizeof (log_buf); + log_opts.log_level =BPF_LOG_FIXED ;
Why? Which part of the test needs the log with this flag?
Re: [PATCH bpf-next v9 3/9] bpf: Refactor reporting log_true_size for prog_load
In reply to Andrii NakryikoQuoted 85 lines · Andrii Nakryiko
Quoted 84 lines · Leon Hwang
The 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 structbpf_log_attrto encapsulate log-related behavior:*
bpf_prog_load_log_attr_init(): initialize the 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.Signed-off-by Leon Hwang <[email protected]>--- include/linux/bpf.h | 4 +++- include/linux/bpf_verifier.h | 10 ++++++++++ kernel/bpf/log.c | 35 +++++++++++++++++++++++++++++++++++ kernel/bpf/syscall.c | 8 +++++--- kernel/bpf/verifier.c | 13 +++---------- 5 files changed, 56 insertions(+), 14 deletions(-)include/linux/bpf.h +3
-1@@ -2913,7 +2913,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 +10
-0@@ -631,6 +631,16 @@ static inline bool bpf_verifier_log_needed(const struct bpf_verifier_log *log)return log && log->level; } +struct bpf_log_attr { +u32 offsetof_true_size; +u32 uattr_size; +bpfptr_t uattr; +}; + +int bpf_prog_load_log_attr_init (struct bpf_log_attr *attr_log,union bpf_attr *attr, +bpfptr_t uattr,u32 size); +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 +19
-0@@ -863,3 +863,38 @@ void print_insn_state(struct bpf_verifier_env *env, const struct bpf_verifier_st }print_verifier_state (env, vstate, frameno, false); } + +static void bpf_log_attr_init (struct bpf_log_attr *attr_log,int offsetof_true_size,bpfptr_t uattr, +u32 uattr_size) +{ +memset (attr_log,0 ,sizeof (*attr_log)); + attr_log->offsetof_true_size = offsetof_true_size; + attr_log->uattr_size = uattr_size; + attr_log->uattr = uattr; +} + +int bpf_prog_load_log_attr_init (struct bpf_log_attr *attr_log,union bpf_attr *attr, +bpfptr_t uattr,u32 size) +{ +bpf_log_attr_init (attr_log, offsetof(union bpf_attr , log_true_size), uattr, size); +return 0 ; +} + +int bpf_log_attr_finalize (struct bpf_log_attr *attr,struct bpf_verifier_log *log) +{
Quoted 9 lines
kernel/bpf/log.c void print_insn_state(struct bpf_verifier_env *env, const struct bpf_verifier_st · line 890
Quoted 6 lines
kernel/bpf/log.c +6
-0+u32 log_true_size; +size_t size; +int err; + +if (!log) +return 0 ;can this ever happen? why guard against this?
In patch #7, 'log' can be NULL when users do not provide 'log_buf'.
However, bpf_vlog_finalize() already guards against this case, so I'll drop this check.
Quoted 10 lines
kernel/bpf/log.c void print_insn_state(struct bpf_verifier_env *env, const struct bpf_verifier_st · line 897
Quoted 7 lines
kernel/bpf/log.c +7
-0+ + err =bpf_vlog_finalize (log, &log_true_size); + + size =sizeof (log_true_size); +if (attr->uattr_size >= attr->offsetof_true_size + size && +copy_to_bpfptr_offset (attr->uattr, attr->offsetof_true_size, &log_true_size, size)) + err = -EFAULT ;minor nit: return
-EFAULT;
Ack.
Thanks,
Leon
Re: [PATCH bpf-next v9 4/9] bpf: Add syscall common attributes support for prog_load
In reply to Andrii NakryikoQuoted 38 lines · Andrii Nakryiko
Quoted 37 lines · Leon Hwang
BPF_PROG_LOADcan now provide log parameters through both unionbpf_attrand structbpf_common_attr. Define clear conflict and precedence rules:- if both are provided and log_buf/log_size/log_level match, use them;
- if only one side provides a log buffer, use that one;
- if both provide log buffers but differ, return-EINVAL.Signed-off-by Leon Hwang <[email protected]>--- include/linux/bpf_verifier.h | 3 ++- kernel/bpf/log.c | 24 ++++++++++++++++++++++-- kernel/bpf/syscall.c | 3 ++- 3 files changed, 26 insertions(+), 4 deletions(-)include/linux/bpf_verifier.h +2
-1@@ -638,7 +638,8 @@ struct bpf_log_attr { };int bpf_prog_load_log_attr_init (struct bpf_log_attr *attr_log,union bpf_attr *attr, -bpfptr_t uattr,u32 size); +bpfptr_t uattr,u32 size,struct bpf_common_attr *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 256kernel/bpf/log.c +0
-0@@ -873,10 +873,30 @@ static void bpf_log_attr_init(struct bpf_log_attr *attr_log, int offsetof_true_s attr_log->uattr = uattr; }
Quoted 11 lines
kernel/bpf/log.c static void bpf_log_attr_init(struct bpf_log_attr *attr_log, int offsetof_true_s · line 881
Quoted 6 lines
kernel/bpf/log.c +6
-0+static bool bpf_log_attrs_diff (struct bpf_common_attr *common,u64 log_buf,u32 log_size, +u32 log_level) +{ +return log_buf && common->log_buf && (log_buf != common->log_buf || + log_size != common->log_size || + log_level != common->log_level);let's validate (unless we do this somewhere else) that if
log_bufis set, thenlog_sizeandlog_level(? not sure, maybe zero is fine) are set, or all three are not set. Same for common->log* fields...
Ack.
Will validate 'log_buf && log_size && log_level' first.
Quoted 12 lines
Quoted 12 lines
kernel/bpf/log.c +7
-2+} +int bpf_prog_load_log_attr_init (struct bpf_log_attr *attr_log,union bpf_attr *attr, -bpfptr_t uattr,u32 size) +bpfptr_t uattr,u32 size,struct bpf_common_attr *attr_common, +bpfptr_t uattr_common,u32 size_common) { -bpf_log_attr_init (attr_log, offsetof(union bpf_attr , log_true_size), uattr, size); +if (bpf_log_attrs_diff (attr_common, attr->log_buf, attr->log_size, attr->log_level)) +return -EINVAL ; +
Quoted 9 lines
kernel/bpf/log.c static void bpf_log_attr_init(struct bpf_log_attr *attr_log, int offsetof_true_s · line 894
Quoted 4 lines
kernel/bpf/log.c +4
-0+if (!attr->log_buf && attr_common->log_buf) { + attr->log_buf = attr_common->log_buf; + attr->log_size = attr_common->log_size; + attr->log_level = attr_common->log_level;why are we setting this? Do we still have code that can access
attr->log_bufeven though we passattr_logeverywhere? If yes, should we still have that "split brain" code?
'attr->log_buf' is accessed only in bpf_check().
Quoted 7 lines
If we don't have this assignment, then I think we don't need to have bpf_prog_load-specific and btf_load-specific
log_attr_init()helpers. They can be unified into genericlog_attr_init, where forbpf_prog_loadyou'll passoffsetof(log_true_size)+ attr->log_{buf,size,level}, and forbtf_loadyou'll pass different offset of and btf-specific attr->btf_log*
Quoted 5 lines
This helper will just be making decision whether to use common_attr's log fields or passed directly command-specific ones.
Or what am I missing?
If the log attributes differ, where should the effective log_* values be stored?
Should they live in struct bpf_common_attr, or should we extend struct bpf_log_attr to carry them?
Note that in v8, Alexei suggested struct bpf_log_attr only needs
u32 offsetof_true_size;
bpfptr_t uattr;
so I’d like to clarify the intended direction here. Once that’s clear, a single generic log_attr_init() should be sufficient to handle this.
Thanks,
Leon
Quoted 26 lines
Quoted 26 lines
kernel/bpf/log.c +5
-0+bpf_log_attr_init (attr_log, offsetof(struct bpf_common_attr , log_true_size), + uattr_common, size_common); + }else { +bpf_log_attr_init (attr_log, offsetof(union bpf_attr , log_true_size), uattr, size); + }return 0 ; }kernel/bpf/syscall.c +2
-2@@ -6232,7 +6232,8 @@ 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_log_attr_init (&attr_log, &attr, uattr, size); + err =bpf_prog_load_log_attr_init (&attr_log, &attr, uattr, size, &attr_common, + uattr_common, size_common); err = err ?:bpf_prog_load (&attr, uattr, &attr_log);break ;case BPF_OBJ_PIN : --2.52.0
Re: [PATCH bpf-next v9 8/9] libbpf: Add syscall common attributes support for map_create
In reply to Andrii NakryikoQuoted 19 lines · Andrii Nakryiko
Quoted 8 lines · Leon Hwang
With the previous commit adding common attribute support for
BPF_MAP_CREATE, users can now retrieve detailed error messages when map creation fails via thelog_buffield.Introduce struct
bpf_log_optswith the following fields:log_buf,log_size,log_level, andlog_true_size.Quoted 9 lines
Extend
bpf_map_create_optswith a new fieldlog_opts, allowing users to capture and inspect log messages on map creation failures.Signed-off-by Leon Hwang <[email protected]>--- tools/lib/bpf/bpf.c | 16 +++++++++++++++- tools/lib/bpf/bpf.h | 17 ++++++++++++++++- 2 files changed, 31 insertions(+), 2 deletions(-)
Quoted 4 lines
LGTM
Acked-by Andrii Nakryiko <[email protected]>
Thanks for your review.
Quoted 42 lines
Quoted 42 lines
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, log_buf,NULL )); + attr_common.log_size =OPTS_GET (log_opts, log_size,0 ); + attr_common.log_level =OPTS_GET (log_opts, log_level,0 ); + fd =sys_bpf_ext_fd (BPF_MAP_CREATE , &attr, attr_sz, &attr_common, attr_common_sz); +OPTS_SET (log_opts, log_true_size, attr_common.log_true_size); + }else { + fd =sys_bpf_fd (BPF_MAP_CREATE , &attr, attr_sz); +OPTS_SET (log_opts, log_true_size,0 ); + }return libbpf_err_errno (fd); }tools/lib/bpf/bpf.h +0
-0@@ -37,6 +37,18 @@ extern "C" { LIBBPF_API int libbpf_set_memlock_rlim(size_t memlock_bytes);
Quoted 11 lines
tools/lib/bpf/bpf.h extern "C" { · line 46
Quoted 7 lines
tools/lib/bpf/bpf.h +7
-0+struct bpf_log_opts { +size_t sz;/* size of this struct for forward/backward compatibility */ + +char *log_buf; +__u32 log_size; +__u32 log_level; +__u32 log_true_size;please mention in the comment here that this is an out parameter set by the kernel
Ack.
I'll add a comment in the next revision.
Thanks,
Leon
Quoted 25 lines
Quoted 25 lines
tools/lib/bpf/bpf.h +9
-2+ + size_t :0; +}; +#define bpf_log_opts__last_field log_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, --2.52.0
Re: [PATCH bpf-next v9 9/9] selftests/bpf: Add tests to verify map create failure log
In reply to Alexei StarovoitovQuoted 11 lines · Alexei Starovoitov
Quoted 10 lines · Leon Hwang
tools/testing/selftests/bpf/prog_tests/map_init.c +9
-0+ +#define BPF_LOG_FIXED 8 + +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;
Quoted 8 lines
tools/testing/selftests/bpf/prog_tests/map_init.c void test_map_init(void) · line 229
Quoted 6 lines
tools/testing/selftests/bpf/prog_tests/map_init.c +6
-0+LIBBPF_OPTS (bpf_log_opts, log_opts); + + log_buf[0 ] ='\0' ; + log_opts.log_buf = log_buf; + log_opts.log_size =sizeof (log_buf); + log_opts.log_level =BPF_LOG_FIXED ;Why? Which part of the test needs the log with this flag?
BPF_LOG_FIXED looks odd here.
This test sets 'log_level = BPF_LOG_FIXED' to match the behavior of bpf_vlog_init() as initialized by bpf_log_attr_create_vlog() in patch #7. BPF_LOG_FIXED is intended to be the default log_level there.
Thanks,
Leon
Re: [PATCH bpf-next v9 4/9] bpf: Add syscall common attributes support for prog_load
In reply to Leon HwangQuoted 80 lines · Leon Hwang
Quoted 38 lines · Andrii Nakryiko
Quoted 37 lines · Leon Hwang
BPF_PROG_LOADcan now provide log parameters through both unionbpf_attrand structbpf_common_attr. Define clear conflict and precedence rules:- if both are provided and log_buf/log_size/log_level match, use them;
- if only one side provides a log buffer, use that one;
- if both provide log buffers but differ, return-EINVAL.Signed-off-by Leon Hwang <[email protected]>--- include/linux/bpf_verifier.h | 3 ++- kernel/bpf/log.c | 24 ++++++++++++++++++++++-- kernel/bpf/syscall.c | 3 ++- 3 files changed, 26 insertions(+), 4 deletions(-)include/linux/bpf_verifier.h +2
-1@@ -638,7 +638,8 @@ struct bpf_log_attr { };int bpf_prog_load_log_attr_init (struct bpf_log_attr *attr_log,union bpf_attr *attr, -bpfptr_t uattr,u32 size); +bpfptr_t uattr,u32 size,struct bpf_common_attr *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 256kernel/bpf/log.c +0
-0@@ -873,10 +873,30 @@ static void bpf_log_attr_init(struct bpf_log_attr *attr_log, int offsetof_true_s attr_log->uattr = uattr; }Quoted 11 lines
kernel/bpf/log.c static void bpf_log_attr_init(struct bpf_log_attr *attr_log, int offsetof_true_s · line 881
Quoted 6 lines
kernel/bpf/log.c +6
-0+static bool bpf_log_attrs_diff (struct bpf_common_attr *common,u64 log_buf,u32 log_size, +u32 log_level) +{ +return log_buf && common->log_buf && (log_buf != common->log_buf || + log_size != common->log_size || + log_level != common->log_level);let's validate (unless we do this somewhere else) that if
log_bufis set, thenlog_sizeandlog_level(? not sure, maybe zero is fine) are set, or all three are not set. Same for common->log* fields...Ack.
Will validate '
log_buf&&log_size&&log_level' first.Quoted 12 lines
Quoted 12 lines
kernel/bpf/log.c +7
-2+} +int bpf_prog_load_log_attr_init (struct bpf_log_attr *attr_log,union bpf_attr *attr, -bpfptr_t uattr,u32 size) +bpfptr_t uattr,u32 size,struct bpf_common_attr *attr_common, +bpfptr_t uattr_common,u32 size_common) { -bpf_log_attr_init (attr_log, offsetof(union bpf_attr , log_true_size), uattr, size); +if (bpf_log_attrs_diff (attr_common, attr->log_buf, attr->log_size, attr->log_level)) +return -EINVAL ; +Quoted 9 lines
kernel/bpf/log.c static void bpf_log_attr_init(struct bpf_log_attr *attr_log, int offsetof_true_s · line 894
Quoted 4 lines
kernel/bpf/log.c +4
-0+if (!attr->log_buf && attr_common->log_buf) { + attr->log_buf = attr_common->log_buf; + attr->log_size = attr_common->log_size; + attr->log_level = attr_common->log_level;why are we setting this? Do we still have code that can access
attr->log_bufeven though we passattr_logeverywhere? If yes, should we still have that "split brain" code?
Quoted 1 line
'
attr->log_buf' is accessed only inbpf_check().
bpf_check should be changed then, see below
Quoted 20 lines
Quoted 8 lines
If we don't have this assignment, then I think we don't need to have bpf_prog_load-specific and btf_load-specific
log_attr_init()helpers. They can be unified into genericlog_attr_init, where forbpf_prog_loadyou'll passoffsetof(log_true_size)+ attr->log_{buf,size,level}, and forbtf_loadyou'll pass different offset of and btf-specific attr->btf_log*Quoted 5 lines
This helper will just be making decision whether to use common_attr's log fields or passed directly command-specific ones.
Or what am I missing?
If the log attributes differ, where should the effective log_* values be stored?
Should they live in struct
bpf_common_attr, or should we extend structbpf_log_attrto carry them?
Quoted 7 lines
Note that in v8, Alexei suggested struct
bpf_log_attronly needs
u32offsetof_true_size;
bpfptr_tuattr;so I’d like to clarify the intended direction here. Once that’s clear, a single generic
log_attr_init()should be sufficient to handle this.
The intended direction is to have log buf/size/level in one place (after attr and common_attr validations), so we keep internal logic simple. Let's put all of that and log_true_size **pointer** (we don't have to much with offsetof, just calculate user addr for log_true_size, which just might be NULL) into bpf_log_attrs and teach all code to look and work *only* with that struct, ignoring anything log related from attr.
Quoted 30 lines
Thanks,
LeonQuoted 26 lines
Quoted 26 lines
kernel/bpf/log.c +5
-0+bpf_log_attr_init (attr_log, offsetof(struct bpf_common_attr , log_true_size), + uattr_common, size_common); + }else { +bpf_log_attr_init (attr_log, offsetof(union bpf_attr , log_true_size), uattr, size); + }return 0 ; }kernel/bpf/syscall.c +2
-2@@ -6232,7 +6232,8 @@ 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_log_attr_init (&attr_log, &attr, uattr, size); + err =bpf_prog_load_log_attr_init (&attr_log, &attr, uattr, size, &attr_common, + uattr_common, size_common); err = err ?:bpf_prog_load (&attr, uattr, &attr_log);break ;case BPF_OBJ_PIN : --2.52.0
Re: [PATCH bpf-next v9 9/9] selftests/bpf: Add tests to verify map create failure log
In reply to Leon HwangQuoted 24 lines · Leon Hwang
Quoted 11 lines · Alexei Starovoitov
Quoted 10 lines · Leon Hwang
tools/testing/selftests/bpf/prog_tests/map_init.c +9
-0+ +#define BPF_LOG_FIXED 8 + +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;Quoted 8 lines
tools/testing/selftests/bpf/prog_tests/map_init.c void test_map_init(void) · line 229
Quoted 6 lines
tools/testing/selftests/bpf/prog_tests/map_init.c +6
-0+LIBBPF_OPTS (bpf_log_opts, log_opts); + + log_buf[0 ] ='\0' ; + log_opts.log_buf = log_buf; + log_opts.log_size =sizeof (log_buf); + log_opts.log_level =BPF_LOG_FIXED ;Why? Which part of the test needs the log with this flag?
Quoted 6 lines
BPF_LOG_FIXEDlooks odd here.This test sets '
log_level=BPF_LOG_FIXED' to match the behavior ofbpf_vlog_init()as initialized bybpf_log_attr_create_vlog()in patch #7.BPF_LOG_FIXEDis intended to be the defaultlog_levelthere.
I don't think you answered my question. bpf_vlog_init() is using whatever log_level user space provided. Why do you pass BPF_LOG_FIXED ?
Re: [PATCH bpf-next v9 4/9] bpf: Add syscall common attributes support for prog_load
In reply to Andrii NakryikoQuoted 1 line · Andrii Nakryiko
On Wed, Feb 4, 2026 at 7:42 PM Leon Hwang <[email protected]> wrote:
[...]
Quoted 43 lines
Quoted 6 lines
Quoted 6 lines
Quoted 5 lines
kernel/bpf/log.c +5
-0+ +if (!attr->log_buf && attr_common->log_buf) { + attr->log_buf = attr_common->log_buf; + attr->log_size = attr_common->log_size; + attr->log_level = attr_common->log_level;Quoted 6 lines
Quoted 4 lines
why are we setting this? Do we still have code that can access
attr->log_bufeven though we passattr_logeverywhere? If yes, should we still have that "split brain" code?'
attr->log_buf' is accessed only inbpf_check().
bpf_checkshould be changed then, see belowQuoted 20 lines
Quoted 8 lines
If we don't have this assignment, then I think we don't need to have bpf_prog_load-specific and btf_load-specific
log_attr_init()helpers. They can be unified into genericlog_attr_init, where forbpf_prog_loadyou'll passoffsetof(log_true_size)+ attr->log_{buf,size,level}, and forbtf_loadyou'll pass different offset of and btf-specific attr->btf_log*Quoted 5 lines
This helper will just be making decision whether to use common_attr's log fields or passed directly command-specific ones.
Or what am I missing?
If the log attributes differ, where should the effective log_* values be stored?
Should they live in struct
bpf_common_attr, or should we extend structbpf_log_attrto carry them?Quoted 7 lines
Note that in v8, Alexei suggested struct
bpf_log_attronly needs
u32offsetof_true_size;
bpfptr_tuattr;so I’d like to clarify the intended direction here. Once that’s clear, a single generic
log_attr_init()should be sufficient to handle this.
Quoted 8 lines
The intended direction is to have log buf/size/level in one place (after attr and
common_attrvalidations), so we keep internal logic simple. Let's put all of that andlog_true_size**pointer** (we don't have to much with offsetof, just calculate user addr forlog_true_size, which just might be NULL) intobpf_log_attrsand teach all code to look and work *only* with that struct, ignoring anything log related from attr.
It’s clear now.
I’ll follow this direction in the next revision and consolidate all log-related fields (including the log_true_size pointer) into bpf_log_attr, so that internal code relies solely on that struct.
Thanks,
Leon
Re: [PATCH bpf-next v9 9/9] selftests/bpf: Add tests to verify map create failure log
In reply to Alexei StarovoitovQuoted 27 lines · Alexei Starovoitov
Quoted 26 lines · Leon Hwang
Quoted 11 lines · Alexei Starovoitov
Quoted 10 lines · Leon Hwang
tools/testing/selftests/bpf/prog_tests/map_init.c +9
-0+ +#define BPF_LOG_FIXED 8 + +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;Quoted 8 lines
tools/testing/selftests/bpf/prog_tests/map_init.c void test_map_init(void) · line 229
Quoted 6 lines
tools/testing/selftests/bpf/prog_tests/map_init.c +6
-0+LIBBPF_OPTS (bpf_log_opts, log_opts); + + log_buf[0 ] ='\0' ; + log_opts.log_buf = log_buf; + log_opts.log_size =sizeof (log_buf); + log_opts.log_level =BPF_LOG_FIXED ;Why? Which part of the test needs the log with this flag?
BPF_LOG_FIXEDlooks odd here.
Quoted 9 lines
Quoted 4 lines
This test sets '
log_level=BPF_LOG_FIXED' to match the behavior ofbpf_vlog_init()as initialized bybpf_log_attr_create_vlog()in patch #7.BPF_LOG_FIXEDis intended to be the defaultlog_levelthere.I don't think you answered my question.
bpf_vlog_init()is using whateverlog_leveluser space provided. Why do you passBPF_LOG_FIXED?
The intention behind passing BPF_LOG_FIXED was to ensure the log used the buffer in a fixed mode, since the allocated buffer was large enough to hold the full log message from the kernel. It was not intended to test against log_level itself.
After reviewing commit 121664093803 ("bpf: Switch BPF verifier log to be a rotating log by default"), I realized that BPF_LOG_FIXED was introduced specifically to disable the rotating log behavior. In this test case, that distinction is not relevant, so BPF_LOG_FIXED is indeed unnecessary.
I tested with 'log_level is 0' and 'log_level is non-zero'. The tests fail when log_level is 0, and pass when log_level is non-zero. So I will switch to using 'log_level = 1' in the next revision.
Thanks,
Leon