MIRRORS/linux-imx
1
0
Fork 0
mirror of https://github.com/nxp-imx/linux-imx.git synced 2025-12-22 18:37:35 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

selftests/bpf: Convert profiler.c to bpf_cmp.

Browse Source 
Convert profiler[123].c to "volatile compare" to compare barrier_var() approach vs bpf_cmp_likely() vs bpf_cmp_unlikely().

bpf_cmp_unlikely() produces correct code, but takes much longer to verify:

./veristat -C -e prog,insns,states before after_with_unlikely
Program                               Insns (A)  Insns (B)  Insns       (DIFF)  States (A)  States (B)  States     (DIFF)
------------------------------------  ---------  ---------  ------------------  ----------  ----------  -----------------
kprobe__proc_sys_write                     1603      19606  +18003 (+1123.08%)         123        1678  +1555 (+1264.23%)
kprobe__vfs_link                          11815      70305   +58490 (+495.05%)         971        4967   +3996 (+411.53%)
kprobe__vfs_symlink                        5464      42896   +37432 (+685.07%)         434        3126   +2692 (+620.28%)
kprobe_ret__do_filp_open                   5641      44578   +38937 (+690.25%)         446        3162   +2716 (+608.97%)
raw_tracepoint__sched_process_exec         2770      35962  +33192 (+1198.27%)         226        3121  +2895 (+1280.97%)
raw_tracepoint__sched_process_exit         1526       2135      +609 (+39.91%)         133         208      +75 (+56.39%)
raw_tracepoint__sched_process_fork          265        337       +72 (+27.17%)          19          24       +5 (+26.32%)
tracepoint__syscalls__sys_enter_kill      18782     140407  +121625 (+647.56%)        1286       12176  +10890 (+846.81%)

bpf_cmp_likely() is equivalent to barrier_var():

./veristat -C -e prog,insns,states before after_with_likely
Program                               Insns (A)  Insns (B)  Insns   (DIFF)  States (A)  States (B)  States (DIFF)
------------------------------------  ---------  ---------  --------------  ----------  ----------  -------------
kprobe__proc_sys_write                     1603       1663    +60 (+3.74%)         123         127    +4 (+3.25%)
kprobe__vfs_link                          11815      12090   +275 (+2.33%)         971         971    +0 (+0.00%)
kprobe__vfs_symlink                        5464       5448    -16 (-0.29%)         434         426    -8 (-1.84%)
kprobe_ret__do_filp_open                   5641       5739    +98 (+1.74%)         446         446    +0 (+0.00%)
raw_tracepoint__sched_process_exec         2770       2608   -162 (-5.85%)         226         216   -10 (-4.42%)
raw_tracepoint__sched_process_exit         1526       1526     +0 (+0.00%)         133         133    +0 (+0.00%)
raw_tracepoint__sched_process_fork          265        265     +0 (+0.00%)          19          19    +0 (+0.00%)
tracepoint__syscalls__sys_enter_kill      18782      18970   +188 (+1.00%)        1286        1286    +0 (+0.00%)
kprobe__proc_sys_write                     2700       2809   +109 (+4.04%)         107         109    +2 (+1.87%)
kprobe__vfs_link                          12238      12366   +128 (+1.05%)         267         269    +2 (+0.75%)
kprobe__vfs_symlink                        7139       7365   +226 (+3.17%)         167         175    +8 (+4.79%)
kprobe_ret__do_filp_open                   7264       7070   -194 (-2.67%)         180         182    +2 (+1.11%)
raw_tracepoint__sched_process_exec         3768       3453   -315 (-8.36%)         211         199   -12 (-5.69%)
raw_tracepoint__sched_process_exit         3138       3138     +0 (+0.00%)          83          83    +0 (+0.00%)
raw_tracepoint__sched_process_fork          265        265     +0 (+0.00%)          19          19    +0 (+0.00%)
tracepoint__syscalls__sys_enter_kill      26679      24327  -2352 (-8.82%)        1067        1037   -30 (-2.81%)
kprobe__proc_sys_write                     1833       1833     +0 (+0.00%)         157         157    +0 (+0.00%)
kprobe__vfs_link                           9995      10127   +132 (+1.32%)         803         803    +0 (+0.00%)
kprobe__vfs_symlink                        5606       5672    +66 (+1.18%)         451         451    +0 (+0.00%)
kprobe_ret__do_filp_open                   5716       5782    +66 (+1.15%)         462         462    +0 (+0.00%)
raw_tracepoint__sched_process_exec         3042       3042     +0 (+0.00%)         278         278    +0 (+0.00%)
raw_tracepoint__sched_process_exit         1680       1680     +0 (+0.00%)         146         146    +0 (+0.00%)
raw_tracepoint__sched_process_fork          299        299     +0 (+0.00%)          25          25    +0 (+0.00%)
tracepoint__syscalls__sys_enter_kill      18372      18372     +0 (+0.00%)        1558        1558    +0 (+0.00%)

default (mcpu=v3), no_alu32, cpuv4 have similar differences.

Note one place where bpf_nop_mov() is used to workaround the verifier lack of link
between the scalar register and its spill to stack.

Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
Link: https://lore.kernel.org/bpf/20231226191148.48536-7-alexei.starovoitov@gmail.com
This commit is contained in:
Alexei Starovoitov 2023-12-26 11:11:48 -08:00 committed by Andrii Nakryiko
parent 0bcc62aa98
commit 7e3811cb99
1 changed files with 18 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
tools/testing/selftests/bpf/progs/profiler.inc.h
View File

@ -7,6 +7,7 @@
#include "profiler.h" #include "profiler.h"
#include "err.h" #include "err.h"
#include "bpf_experimental.h"
#ifndef NULL #ifndef NULL
#define NULL 0 #define NULL 0
@ -221,8 +222,7 @@ static INLINE void* read_full_cgroup_path(struct kernfs_node* cgroup_node,
return payload; return payload;
if (cgroup_node == cgroup_root_node) if (cgroup_node == cgroup_root_node)
*root_pos = payload - payload_start; *root_pos = payload - payload_start;
if (filepart_length <= MAX_PATH) { if (bpf_cmp_likely(filepart_length, <=, MAX_PATH)) {
barrier_var(filepart_length);
payload += filepart_length; payload += filepart_length;
} }
cgroup_node = BPF_CORE_READ(cgroup_node, parent); cgroup_node = BPF_CORE_READ(cgroup_node, parent);
@ -305,9 +305,7 @@ static INLINE void* populate_cgroup_info(struct cgroup_data_t* cgroup_data,
size_t cgroup_root_length = size_t cgroup_root_length =
bpf_probe_read_kernel_str(payload, MAX_PATH, bpf_probe_read_kernel_str(payload, MAX_PATH,
BPF_CORE_READ(root_kernfs, name)); BPF_CORE_READ(root_kernfs, name));
barrier_var(cgroup_root_length); if (bpf_cmp_likely(cgroup_root_length, <=, MAX_PATH)) {
if (cgroup_root_length <= MAX_PATH) {
barrier_var(cgroup_root_length);
cgroup_data->cgroup_root_length = cgroup_root_length; cgroup_data->cgroup_root_length = cgroup_root_length;
payload += cgroup_root_length; payload += cgroup_root_length;
} }
@ -315,9 +313,7 @@ static INLINE void* populate_cgroup_info(struct cgroup_data_t* cgroup_data,
size_t cgroup_proc_length = size_t cgroup_proc_length =
bpf_probe_read_kernel_str(payload, MAX_PATH, bpf_probe_read_kernel_str(payload, MAX_PATH,
BPF_CORE_READ(proc_kernfs, name)); BPF_CORE_READ(proc_kernfs, name));
barrier_var(cgroup_proc_length); if (bpf_cmp_likely(cgroup_proc_length, <=, MAX_PATH)) {
if (cgroup_proc_length <= MAX_PATH) {
barrier_var(cgroup_proc_length);
cgroup_data->cgroup_proc_length = cgroup_proc_length; cgroup_data->cgroup_proc_length = cgroup_proc_length;
payload += cgroup_proc_length; payload += cgroup_proc_length;
} }
@ -347,9 +343,7 @@ static INLINE void* populate_var_metadata(struct var_metadata_t* metadata,
metadata->comm_length = 0; metadata->comm_length = 0;
size_t comm_length = bpf_core_read_str(payload, TASK_COMM_LEN, &task->comm); size_t comm_length = bpf_core_read_str(payload, TASK_COMM_LEN, &task->comm);
barrier_var(comm_length); if (bpf_cmp_likely(comm_length, <=, TASK_COMM_LEN)) {
if (comm_length <= TASK_COMM_LEN) {
barrier_var(comm_length);
metadata->comm_length = comm_length; metadata->comm_length = comm_length;
payload += comm_length; payload += comm_length;
} }
@ -494,10 +488,9 @@ read_absolute_file_path_from_dentry(struct dentry* filp_dentry, void* payload)
filepart_length = filepart_length =
bpf_probe_read_kernel_str(payload, MAX_PATH, bpf_probe_read_kernel_str(payload, MAX_PATH,
BPF_CORE_READ(filp_dentry, d_name.name)); BPF_CORE_READ(filp_dentry, d_name.name));
barrier_var(filepart_length); bpf_nop_mov(filepart_length);
if (filepart_length > MAX_PATH) if (bpf_cmp_unlikely(filepart_length, >, MAX_PATH))
break; break;
barrier_var(filepart_length);
payload += filepart_length; payload += filepart_length;
length += filepart_length; length += filepart_length;
@ -579,9 +572,7 @@ ssize_t BPF_KPROBE(kprobe__proc_sys_write,
size_t sysctl_val_length = bpf_probe_read_kernel_str(payload, size_t sysctl_val_length = bpf_probe_read_kernel_str(payload,
CTL_MAXNAME, buf); CTL_MAXNAME, buf);
barrier_var(sysctl_val_length); if (bpf_cmp_likely(sysctl_val_length, <=, CTL_MAXNAME)) {
if (sysctl_val_length <= CTL_MAXNAME) {
barrier_var(sysctl_val_length);
sysctl_data->sysctl_val_length = sysctl_val_length; sysctl_data->sysctl_val_length = sysctl_val_length;
payload += sysctl_val_length; payload += sysctl_val_length;
} }
@ -590,9 +581,7 @@ ssize_t BPF_KPROBE(kprobe__proc_sys_write,
bpf_probe_read_kernel_str(payload, MAX_PATH, bpf_probe_read_kernel_str(payload, MAX_PATH,
BPF_CORE_READ(filp, f_path.dentry, BPF_CORE_READ(filp, f_path.dentry,
d_name.name)); d_name.name));
barrier_var(sysctl_path_length); if (bpf_cmp_likely(sysctl_path_length, <=, MAX_PATH)) {
if (sysctl_path_length <= MAX_PATH) {
barrier_var(sysctl_path_length);
sysctl_data->sysctl_path_length = sysctl_path_length; sysctl_data->sysctl_path_length = sysctl_path_length;
payload += sysctl_path_length; payload += sysctl_path_length;
} }
@ -658,9 +647,7 @@ int raw_tracepoint__sched_process_exit(void* ctx)
kill_data->kill_target_cgroup_proc_length = 0; kill_data->kill_target_cgroup_proc_length = 0;
size_t comm_length = bpf_core_read_str(payload, TASK_COMM_LEN, &task->comm); size_t comm_length = bpf_core_read_str(payload, TASK_COMM_LEN, &task->comm);
barrier_var(comm_length); if (bpf_cmp_likely(comm_length, <=, TASK_COMM_LEN)) {
if (comm_length <= TASK_COMM_LEN) {
barrier_var(comm_length);
kill_data->kill_target_name_length = comm_length; kill_data->kill_target_name_length = comm_length;
payload += comm_length; payload += comm_length;
} }
@ -669,9 +656,7 @@ int raw_tracepoint__sched_process_exit(void* ctx)
bpf_probe_read_kernel_str(payload, bpf_probe_read_kernel_str(payload,
KILL_TARGET_LEN, KILL_TARGET_LEN,
BPF_CORE_READ(proc_kernfs, name)); BPF_CORE_READ(proc_kernfs, name));
barrier_var(cgroup_proc_length); if (bpf_cmp_likely(cgroup_proc_length, <=, KILL_TARGET_LEN)) {
if (cgroup_proc_length <= KILL_TARGET_LEN) {
barrier_var(cgroup_proc_length);
kill_data->kill_target_cgroup_proc_length = cgroup_proc_length; kill_data->kill_target_cgroup_proc_length = cgroup_proc_length;
payload += cgroup_proc_length; payload += cgroup_proc_length;
} }
@ -731,9 +716,7 @@ int raw_tracepoint__sched_process_exec(struct bpf_raw_tracepoint_args* ctx)
const char* filename = BPF_CORE_READ(bprm, filename); const char* filename = BPF_CORE_READ(bprm, filename);
size_t bin_path_length = size_t bin_path_length =
bpf_probe_read_kernel_str(payload, MAX_FILENAME_LEN, filename); bpf_probe_read_kernel_str(payload, MAX_FILENAME_LEN, filename);
barrier_var(bin_path_length); if (bpf_cmp_likely(bin_path_length, <=, MAX_FILENAME_LEN)) {
if (bin_path_length <= MAX_FILENAME_LEN) {
barrier_var(bin_path_length);
proc_exec_data->bin_path_length = bin_path_length; proc_exec_data->bin_path_length = bin_path_length;
payload += bin_path_length; payload += bin_path_length;
} }
@ -743,8 +726,7 @@ int raw_tracepoint__sched_process_exec(struct bpf_raw_tracepoint_args* ctx)
unsigned int cmdline_length = probe_read_lim(payload, arg_start, unsigned int cmdline_length = probe_read_lim(payload, arg_start,
arg_end - arg_start, MAX_ARGS_LEN); arg_end - arg_start, MAX_ARGS_LEN);
if (cmdline_length <= MAX_ARGS_LEN) { if (bpf_cmp_likely(cmdline_length, <=, MAX_ARGS_LEN)) {
barrier_var(cmdline_length);
proc_exec_data->cmdline_length = cmdline_length; proc_exec_data->cmdline_length = cmdline_length;
payload += cmdline_length; payload += cmdline_length;
} }
@ -821,9 +803,7 @@ int kprobe_ret__do_filp_open(struct pt_regs* ctx)
payload = populate_cgroup_info(&filemod_data->cgroup_data, task, payload); payload = populate_cgroup_info(&filemod_data->cgroup_data, task, payload);
size_t len = read_absolute_file_path_from_dentry(filp_dentry, payload); size_t len = read_absolute_file_path_from_dentry(filp_dentry, payload);
barrier_var(len); if (bpf_cmp_likely(len, <=, MAX_FILEPATH_LENGTH)) {
if (len <= MAX_FILEPATH_LENGTH) {
barrier_var(len);
payload += len; payload += len;
filemod_data->dst_filepath_length = len; filemod_data->dst_filepath_length = len;
} }
@ -876,17 +856,13 @@ int BPF_KPROBE(kprobe__vfs_link,
payload = populate_cgroup_info(&filemod_data->cgroup_data, task, payload); payload = populate_cgroup_info(&filemod_data->cgroup_data, task, payload);
size_t len = read_absolute_file_path_from_dentry(old_dentry, payload); size_t len = read_absolute_file_path_from_dentry(old_dentry, payload);
barrier_var(len); if (bpf_cmp_likely(len, <=, MAX_FILEPATH_LENGTH)) {
if (len <= MAX_FILEPATH_LENGTH) {
barrier_var(len);
payload += len; payload += len;
filemod_data->src_filepath_length = len; filemod_data->src_filepath_length = len;
} }
len = read_absolute_file_path_from_dentry(new_dentry, payload); len = read_absolute_file_path_from_dentry(new_dentry, payload);
barrier_var(len); if (bpf_cmp_likely(len, <=, MAX_FILEPATH_LENGTH)) {
if (len <= MAX_FILEPATH_LENGTH) {
barrier_var(len);
payload += len; payload += len;
filemod_data->dst_filepath_length = len; filemod_data->dst_filepath_length = len;
} }
@ -936,16 +912,12 @@ int BPF_KPROBE(kprobe__vfs_symlink, struct inode* dir, struct dentry* dentry,
size_t len = bpf_probe_read_kernel_str(payload, MAX_FILEPATH_LENGTH, size_t len = bpf_probe_read_kernel_str(payload, MAX_FILEPATH_LENGTH,
oldname); oldname);
barrier_var(len); if (bpf_cmp_likely(len, <=, MAX_FILEPATH_LENGTH)) {
if (len <= MAX_FILEPATH_LENGTH) {
barrier_var(len);
payload += len; payload += len;
filemod_data->src_filepath_length = len; filemod_data->src_filepath_length = len;
} }
len = read_absolute_file_path_from_dentry(dentry, payload); len = read_absolute_file_path_from_dentry(dentry, payload);
barrier_var(len); if (bpf_cmp_likely(len, <=, MAX_FILEPATH_LENGTH)) {
if (len <= MAX_FILEPATH_LENGTH) {
barrier_var(len);
payload += len; payload += len;
filemod_data->dst_filepath_length = len; filemod_data->dst_filepath_length = len;
} }