Skip to contentSkip to conversation

perf trace: Augment enum arguments with BTF

PATCH Superseded Howard Chu 4 participants 30 messages Jun 19, 2024 – Jun 28, 2024 perf events

v2 of 5 Superseded Latest is v5 →

lore
Share & tools
lore

Howard Chu

author
#0 lore raw

v2 cover perf trace: Augment enum arguments with BTF

changes in v2:
- Move inline landlock_add_rule c code to tests/workloads
- Rename 'enum_aug_prereq' to 'check_vmlinux'

Augment enum arguments in perf trace, including syscall arguments and non-syscall tracepoint arguments. The augmentation is implemented using BTF.

This patch series also includes a bug fix by Arnaldo Carvalho de Melo <[email protected]>, which makes more syscalls to be traceable by perf trace.

Test is included.

Howard Chu (5):
perf trace: Fix iteration of syscall ids in syscalltbl->entries perf trace: Augment enum syscall arguments with BTF perf trace: Augment enum tracepoint arguments with BTF perf trace: Filter enum arguments with enum names perf trace: Add test for enum augmentation

 tools/perf/builtin-trace.c                    | 214 ++++++++++++++++--
 tools/perf/tests/builtin-test.c               |   1 +
 tools/perf/tests/shell/trace_btf_enum.sh      |  57 +++++
 tools/perf/tests/tests.h                      |   1 +
 tools/perf/tests/workloads/Build              |   1 +
 .../perf/tests/workloads/landlock_add_rule.c  |  32 +++
 tools/perf/util/syscalltbl.c                  |   7 +
 tools/perf/util/syscalltbl.h                  |   1 +
 8 files changed, 289 insertions(+), 25 deletions(-)
 create mode 100755 tools/perf/tests/shell/trace_btf_enum.sh
 create mode 100644 tools/perf/tests/workloads/landlock_add_rule.c
Signature · 1 line
2.45.2
author
#1 lore raw

PATCH v2 1/5 perf trace: Fix iteration of syscall ids in syscalltbl->entries

This is a bug found when implementing pretty-printing for the landlock_add_rule system call, I decided to send this patch separately because this is a serious bug that should be fixed fast.

I wrote a test program to do landlock_add_rule syscall in a loop, yet perf trace -e landlock_add_rule freezes, giving no output.

This bug is introduced by the false understanding of the variable "key" below:

```
for (key = 0; key < trace->sctbl->syscalls.nr_entries; ++key) {
	struct syscall *sc = trace__syscall_info(trace, NULL, key);
	...
}
```

The code above seems right at the beginning, but when looking at syscalltbl.c, I found these lines:

```
for (i = 0; i <= syscalltbl_native_max_id; ++i)
	if (syscalltbl_native[i])
		++nr_entries;

entries = tbl->syscalls.entries = malloc(sizeof(struct syscall) * nr_entries);
...

for (i = 0, j = 0; i <= syscalltbl_native_max_id; ++i) {
	if (syscalltbl_native[i]) {
		entries[j].name = syscalltbl_native[i];
		entries[j].id = i;
		++j;
	}
}
```

meaning the key is merely an index to traverse the syscall table, instead of the actual syscall id for this particular syscall.

So if one uses key to do trace__syscall_info(trace, NULL, key), because key only goes up to trace->sctbl->syscalls.nr_entries, for example, on my X86_64 machine, this number is 373, it will end up neglecting all the rest of the syscall, in my case, everything after rseq, because the traversal will stop at 373, and rseq is the last syscall whose id is lower than 373

in tools/perf/arch/x86/include/generated/asm/syscalls_64.c:

```
	...
	[334] = "rseq",
	[424] = "pidfd_send_signal",
	...
```

The reason why the key is scrambled but perf trace works well is that key is used in trace__syscall_info(trace, NULL, key) to do trace->syscalls.table[id], this makes sure that the struct syscall returned actually has an id the same value as key, making the later bpf_prog matching all correct.

After fixing this bug, I can do perf trace on 38 more syscalls, and because more syscalls are visible, we get 8 more syscalls that can be augmented.

before:

perf $ perf trace -vv --max-events=1 |& grep Reusing Reusing "open" BPF sys_enter augmenter for "stat"
Reusing "open" BPF sys_enter augmenter for "lstat"
Reusing "open" BPF sys_enter augmenter for "access"
Reusing "connect" BPF sys_enter augmenter for "accept" Reusing "sendto" BPF sys_enter augmenter for "recvfrom" Reusing "connect" BPF sys_enter augmenter for "bind" Reusing "connect" BPF sys_enter augmenter for "getsockname" Reusing "connect" BPF sys_enter augmenter for "getpeername" Reusing "open" BPF sys_enter augmenter for "execve"
Reusing "open" BPF sys_enter augmenter for "truncate" Reusing "open" BPF sys_enter augmenter for "chdir"
Reusing "open" BPF sys_enter augmenter for "mkdir"
Reusing "open" BPF sys_enter augmenter for "rmdir"
Reusing "open" BPF sys_enter augmenter for "creat"
Reusing "open" BPF sys_enter augmenter for "link"
Reusing "open" BPF sys_enter augmenter for "unlink"
Reusing "open" BPF sys_enter augmenter for "symlink" Reusing "open" BPF sys_enter augmenter for "readlink" Reusing "open" BPF sys_enter augmenter for "chmod"
Reusing "open" BPF sys_enter augmenter for "chown"
Reusing "open" BPF sys_enter augmenter for "lchown"
Reusing "open" BPF sys_enter augmenter for "mknod"
Reusing "open" BPF sys_enter augmenter for "statfs"
Reusing "open" BPF sys_enter augmenter for "pivot_root" Reusing "open" BPF sys_enter augmenter for "chroot"
Reusing "open" BPF sys_enter augmenter for "acct"
Reusing "open" BPF sys_enter augmenter for "swapon"
Reusing "open" BPF sys_enter augmenter for "swapoff" Reusing "open" BPF sys_enter augmenter for "delete_module" Reusing "open" BPF sys_enter augmenter for "setxattr" Reusing "open" BPF sys_enter augmenter for "lsetxattr" Reusing "openat" BPF sys_enter augmenter for "fsetxattr" Reusing "open" BPF sys_enter augmenter for "getxattr" Reusing "open" BPF sys_enter augmenter for "lgetxattr" Reusing "openat" BPF sys_enter augmenter for "fgetxattr" Reusing "open" BPF sys_enter augmenter for "listxattr" Reusing "open" BPF sys_enter augmenter for "llistxattr" Reusing "open" BPF sys_enter augmenter for "removexattr" Reusing "open" BPF sys_enter augmenter for "lremovexattr" Reusing "fsetxattr" BPF sys_enter augmenter for "fremovexattr" Reusing "open" BPF sys_enter augmenter for "mq_open" Reusing "open" BPF sys_enter augmenter for "mq_unlink" Reusing "fsetxattr" BPF sys_enter augmenter for "add_key" Reusing "fremovexattr" BPF sys_enter augmenter for "request_key" Reusing "fremovexattr" BPF sys_enter augmenter for "inotify_add_watch" Reusing "fremovexattr" BPF sys_enter augmenter for "mkdirat" Reusing "fremovexattr" BPF sys_enter augmenter for "mknodat" Reusing "fremovexattr" BPF sys_enter augmenter for "fchownat" Reusing "fremovexattr" BPF sys_enter augmenter for "futimesat" Reusing "fremovexattr" BPF sys_enter augmenter for "newfstatat" Reusing "fremovexattr" BPF sys_enter augmenter for "unlinkat" Reusing "fremovexattr" BPF sys_enter augmenter for "linkat" Reusing "open" BPF sys_enter augmenter for "symlinkat" Reusing "fremovexattr" BPF sys_enter augmenter for "readlinkat" Reusing "fremovexattr" BPF sys_enter augmenter for "fchmodat" Reusing "fremovexattr" BPF sys_enter augmenter for "faccessat" Reusing "fremovexattr" BPF sys_enter augmenter for "utimensat" Reusing "connect" BPF sys_enter augmenter for "accept4" Reusing "fremovexattr" BPF sys_enter augmenter for "name_to_handle_at" Reusing "fremovexattr" BPF sys_enter augmenter for "renameat2" Reusing "open" BPF sys_enter augmenter for "memfd_create" Reusing "fremovexattr" BPF sys_enter augmenter for "execveat" Reusing "fremovexattr" BPF sys_enter augmenter for "statx"

after

perf $ perf trace -vv --max-events=1 |& grep Reusing Reusing "open" BPF sys_enter augmenter for "stat"
Reusing "open" BPF sys_enter augmenter for "lstat"
Reusing "open" BPF sys_enter augmenter for "access"
Reusing "connect" BPF sys_enter augmenter for "accept" Reusing "sendto" BPF sys_enter augmenter for "recvfrom" Reusing "connect" BPF sys_enter augmenter for "bind" Reusing "connect" BPF sys_enter augmenter for "getsockname" Reusing "connect" BPF sys_enter augmenter for "getpeername" Reusing "open" BPF sys_enter augmenter for "execve"
Reusing "open" BPF sys_enter augmenter for "truncate" Reusing "open" BPF sys_enter augmenter for "chdir"
Reusing "open" BPF sys_enter augmenter for "mkdir"
Reusing "open" BPF sys_enter augmenter for "rmdir"
Reusing "open" BPF sys_enter augmenter for "creat"
Reusing "open" BPF sys_enter augmenter for "link"
Reusing "open" BPF sys_enter augmenter for "unlink"
Reusing "open" BPF sys_enter augmenter for "symlink" Reusing "open" BPF sys_enter augmenter for "readlink" Reusing "open" BPF sys_enter augmenter for "chmod"
Reusing "open" BPF sys_enter augmenter for "chown"
Reusing "open" BPF sys_enter augmenter for "lchown"
Reusing "open" BPF sys_enter augmenter for "mknod"
Reusing "open" BPF sys_enter augmenter for "statfs"
Reusing "open" BPF sys_enter augmenter for "pivot_root" Reusing "open" BPF sys_enter augmenter for "chroot"
Reusing "open" BPF sys_enter augmenter for "acct"
Reusing "open" BPF sys_enter augmenter for "swapon"
Reusing "open" BPF sys_enter augmenter for "swapoff" Reusing "open" BPF sys_enter augmenter for "delete_module" Reusing "open" BPF sys_enter augmenter for "setxattr" Reusing "open" BPF sys_enter augmenter for "lsetxattr" Reusing "openat" BPF sys_enter augmenter for "fsetxattr" Reusing "open" BPF sys_enter augmenter for "getxattr" Reusing "open" BPF sys_enter augmenter for "lgetxattr" Reusing "openat" BPF sys_enter augmenter for "fgetxattr" Reusing "open" BPF sys_enter augmenter for "listxattr" Reusing "open" BPF sys_enter augmenter for "llistxattr" Reusing "open" BPF sys_enter augmenter for "removexattr" Reusing "open" BPF sys_enter augmenter for "lremovexattr" Reusing "fsetxattr" BPF sys_enter augmenter for "fremovexattr" Reusing "open" BPF sys_enter augmenter for "mq_open" Reusing "open" BPF sys_enter augmenter for "mq_unlink" Reusing "fsetxattr" BPF sys_enter augmenter for "add_key" Reusing "fremovexattr" BPF sys_enter augmenter for "request_key" Reusing "fremovexattr" BPF sys_enter augmenter for "inotify_add_watch" Reusing "fremovexattr" BPF sys_enter augmenter for "mkdirat" Reusing "fremovexattr" BPF sys_enter augmenter for "mknodat" Reusing "fremovexattr" BPF sys_enter augmenter for "fchownat" Reusing "fremovexattr" BPF sys_enter augmenter for "futimesat" Reusing "fremovexattr" BPF sys_enter augmenter for "newfstatat" Reusing "fremovexattr" BPF sys_enter augmenter for "unlinkat" Reusing "fremovexattr" BPF sys_enter augmenter for "linkat" Reusing "open" BPF sys_enter augmenter for "symlinkat" Reusing "fremovexattr" BPF sys_enter augmenter for "readlinkat" Reusing "fremovexattr" BPF sys_enter augmenter for "fchmodat" Reusing "fremovexattr" BPF sys_enter augmenter for "faccessat" Reusing "fremovexattr" BPF sys_enter augmenter for "utimensat" Reusing "connect" BPF sys_enter augmenter for "accept4" Reusing "fremovexattr" BPF sys_enter augmenter for "name_to_handle_at" Reusing "fremovexattr" BPF sys_enter augmenter for "renameat2" Reusing "open" BPF sys_enter augmenter for "memfd_create" Reusing "fremovexattr" BPF sys_enter augmenter for "execveat" Reusing "fremovexattr" BPF sys_enter augmenter for "statx"

TL;DR:

These are the new syscalls that can be augmented Reusing "openat" BPF sys_enter augmenter for "open_tree" Reusing "openat" BPF sys_enter augmenter for "openat2" Reusing "openat" BPF sys_enter augmenter for "mount_setattr" Reusing "openat" BPF sys_enter augmenter for "move_mount" Reusing "open" BPF sys_enter augmenter for "fsopen" Reusing "openat" BPF sys_enter augmenter for "fspick" Reusing "openat" BPF sys_enter augmenter for "faccessat2" Reusing "openat" BPF sys_enter augmenter for "fchmodat2"

as for the perf trace output:

before

perf $ perf trace -e faccessat2 --max-events=1
[no output]

after

perf $ ./perf trace -e faccessat2 --max-events=1

     0.000 ( 0.037 ms): waybar/958 faccessat2(dfd: 40, filename: "uevent")                               = 0

P.S. The reason why this bug was not found in the past five years is probably because it only happens to the newer syscalls whose id is greater, for instance, faccessat2 of id 439, which not a lot of people care about when using perf trace.

Commiter notes:

That and the fact that the BPF code was hidden before having to use -e, that got changed kinda recently when we switched to using BPF skels for augmenting syscalls in 'perf trace':

⬢[acme@toolbox perf-tools-next]$ git log --oneline tools/perf/util/bpf_skel/augmented_raw_syscalls.bpf.c a9f4c6c999008c92 perf trace: Collect sys_nanosleep first argument
29d16de26df17e94 perf augmented_raw_syscalls.bpf: Move 'struct timespec64' to vmlinux.h
5069211e2f0b47e7 perf trace: Use the right bpf_probe_read(_str) variant for reading user data 33b725ce7b988756 perf trace: Avoid compile error wrt redefining bool
7d9642311b6d9d31 perf bpf augmented_raw_syscalls: Add an assert to make sure sizeof(augmented_arg->value) is a power of two. 262b54b6c9396823 perf bpf augmented_raw_syscalls: Add an assert to make sure sizeof(saddr) is a power of two. 1836480429d173c0 perf bpf_skel augmented_raw_syscalls: Cap the socklen parameter using &= sizeof(saddr) cd2cece61ac5f900 perf trace: Tidy comments related to BPF + syscall augmentation
5e6da6be3082f77b perf trace: Migrate BPF augmentation to use a skeleton
⬢[acme@toolbox perf-tools-next]$

⬢[acme@toolbox perf-tools-next]$ git show --oneline --pretty=reference 5e6da6be3082f77b | head -1 5e6da6be3082f77b (perf trace: Migrate BPF augmentation to use a skeleton, 2023-08-10) ⬢[acme@toolbox perf-tools-next]$

I.e. from August, 2023.

One had as well to ask for BUILD_BPF_SKEL=1, which now is default if all it needs is available on the system.

I simplified the code to not expose the 'struct syscall' outside of tools/perf/util/syscalltbl.c, instead providing a function to go from the index to the syscall id:

  int syscalltbl__id_at_idx(struct syscalltbl *tbl, int idx);
---
 tools/perf/builtin-trace.c   | 14 +++++++-------
 tools/perf/util/syscalltbl.c |  7 +++++++
 tools/perf/util/syscalltbl.h |  1 +
 3 files changed, 15 insertions(+), 7 deletions(-)
tools/perf/builtin-trace.c +7 -7
index c42bc608954e..c4fa8191253d 100644
@@ -3354,8 +3354,6 @@ static int trace__bpf_prog_sys_exit_fd(struct trace *trace, int id)
 static struct bpf_program *trace__find_usable_bpf_prog_entry(struct trace *trace, struct syscall *sc)
 {
 	struct tep_format_field *field, *candidate_field;
-	int id;
-
 	/*
 	 * We're only interested in syscalls that have a pointer:
 	 */
@@ -3367,7 +3365,8 @@ static struct bpf_program *trace__find_usable_bpf_prog_entry(struct trace *trace
 	return NULL;
 
 try_to_find_pair:
-	for (id = 0; id < trace->sctbl->syscalls.nr_entries; ++id) {
+	for (int i = 0; i < trace->sctbl->syscalls.nr_entries; ++i) {
+		int id = syscalltbl__id_at_idx(trace->sctbl, i);
 		struct syscall *pair = trace__syscall_info(trace, NULL, id);
 		struct bpf_program *pair_prog;
 		bool is_candidate = false;
@@ -3456,10 +3455,10 @@ static int trace__init_syscalls_bpf_prog_array_maps(struct trace *trace)
 {
 	int map_enter_fd = bpf_map__fd(trace->skel->maps.syscalls_sys_enter);
 	int map_exit_fd  = bpf_map__fd(trace->skel->maps.syscalls_sys_exit);
-	int err = 0, key;
+	int err = 0;
 
-	for (key = 0; key < trace->sctbl->syscalls.nr_entries; ++key) {
-		int prog_fd;
+	for (int i = 0; i < trace->sctbl->syscalls.nr_entries; ++i) {
+		int prog_fd, key = syscalltbl__id_at_idx(trace->sctbl, i);
 
 		if (!trace__syscall_enabled(trace, key))
 			continue;
@@ -3505,7 +3504,8 @@ static int trace__init_syscalls_bpf_prog_array_maps(struct trace *trace)
 	 * first and second arg (this one on the raw_syscalls:sys_exit prog
 	 * array tail call, then that one will be used.
 	 */
-	for (key = 0; key < trace->sctbl->syscalls.nr_entries; ++key) {
+	for (int i = 0; i < trace->sctbl->syscalls.nr_entries; ++i) {
+		int key = syscalltbl__id_at_idx(trace->sctbl, i);
 		struct syscall *sc = trace__syscall_info(trace, NULL, key);
 		struct bpf_program *pair_prog;
 		int prog_fd;
tools/perf/util/syscalltbl.c +7 -0
index 63be7b58761d..0dd26b991b3f 100644
@@ -123,6 +123,13 @@ int syscalltbl__id(struct syscalltbl *tbl, const char *name)
 	return sc ? sc->id : -1;
 }
 
+int syscalltbl__id_at_idx(struct syscalltbl *tbl, int idx)
+{
+	struct syscall *syscalls = tbl->syscalls.entries;
+
+	return idx < tbl->syscalls.nr_entries ? syscalls[idx].id : -1;
+}
+
 int syscalltbl__strglobmatch_next(struct syscalltbl *tbl, const char *syscall_glob, int *idx)
 {
 	int i;
tools/perf/util/syscalltbl.h +1 -0
index a41d2ca9e4ae..2b53b7ed25a6 100644
@@ -16,6 +16,7 @@ void syscalltbl__delete(struct syscalltbl *tbl);
 
 const char *syscalltbl__name(const struct syscalltbl *tbl, int id);
 int syscalltbl__id(struct syscalltbl *tbl, const char *name);
+int syscalltbl__id_at_idx(struct syscalltbl *tbl, int idx);
 
 int syscalltbl__strglobmatch_first(struct syscalltbl *tbl, const char *syscall_glob, int *idx);
 int syscalltbl__strglobmatch_next(struct syscalltbl *tbl, const char *syscall_glob, int *idx);
Signature · 1 line
2.45.2
author
#2 lore raw

PATCH v2 2/5 perf trace: Augment enum syscall arguments with BTF

In reply to Howard Chu

This is a feature implemented on the basis of the previous bug fix
https://lore.kernel.org/linux-perf-users/[email protected]/T/#t

In this patch, BTF is used to turn enum value to the corresponding enum variable name. There is only one system call that uses enum value as its argument, that is landlock_add_rule().

The vmlinux btf is loaded lazily, when user decided to trace the landlock_add_rule syscall. But if one decides to run perf trace without any arguments, the behaviour is to trace landlock_add_rule, so vmlinux btf will be loaded by default.

before:

```
perf $ ./perf trace -e landlock_add_rule
     0.000 ( 0.008 ms): ldlck-test/438194 landlock_add_rule(rule_type: 2)                                       = -1 EBADFD (File descriptor in bad state)
     0.010 ( 0.001 ms): ldlck-test/438194 landlock_add_rule(rule_type: 1)                                       = -1 EBADFD (File descriptor in bad state)
```

after:

```
perf $ ./perf trace -e landlock_add_rule
     0.000 ( 0.029 ms): ldlck-test/438194 landlock_add_rule(rule_type: LANDLOCK_RULE_NET_PORT)                  = -1 EBADFD (File descriptor in bad state)
     0.036 ( 0.004 ms): ldlck-test/438194 landlock_add_rule(rule_type: LANDLOCK_RULE_PATH_BENEATH)              = -1 EBADFD (File descriptor in bad state)
```
---
 tools/perf/builtin-trace.c | 96 ++++++++++++++++++++++++++++++++++++--
 1 file changed, 91 insertions(+), 5 deletions(-)
tools/perf/builtin-trace.c +91 -5
index c4fa8191253d..d93f34e9af74 100644
@@ -19,6 +19,7 @@
 #ifdef HAVE_LIBBPF_SUPPORT
 #include <bpf/bpf.h>
 #include <bpf/libbpf.h>
+#include <bpf/btf.h>
 #ifdef HAVE_BPF_SKEL
 #include "bpf_skel/augmented_raw_syscalls.skel.h"
 #endif
@@ -110,6 +111,11 @@ struct syscall_arg_fmt {
 	const char *name;
 	u16	   nr_entries; // for arrays
 	bool	   show_zero;
+	bool	   is_enum;
+	struct {
+		void	*entries;
+		u16	nr_entries;
+	}	   btf_entry;
 };
 
 struct syscall_fmt {
@@ -140,6 +146,7 @@ struct trace {
 #ifdef HAVE_BPF_SKEL
 	struct augmented_raw_syscalls_bpf *skel;
 #endif
+	struct btf		*btf;
 	struct record_opts	opts;
 	struct evlist	*evlist;
 	struct machine		*host;
@@ -897,6 +904,56 @@ static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size,
 	    .strtoul	= STUL_STRARRAY_FLAGS, \
 	    .parm	= &strarray__##array, }
 
+static int btf_enum_find_entry(struct btf *btf, char *type, struct syscall_arg_fmt *arg_fmt)
+{
+	const struct btf_type *bt;
+	char enum_prefix[][16] = { "enum", "const enum" }, *ep;
+	int id;
+	size_t i;
+
+	for (i = 0; i < ARRAY_SIZE(enum_prefix); i++) {
+		ep = enum_prefix[i];
+		if (strlen(type) > strlen(ep) + 1 && strstarts(type, ep))
+			type += strlen(ep) + 1;
+	}
+
+	id = btf__find_by_name(btf, type);
+	if (id < 0)
+		return -1;
+
+	bt = btf__type_by_id(btf, id);
+	if (bt == NULL)
+		return -1;
+
+	arg_fmt->btf_entry.entries    = btf_enum(bt);
+	arg_fmt->btf_entry.nr_entries = btf_vlen(bt);
+
+	return 0;
+}
+
+static size_t btf_enum_scnprintf(char *bf, size_t size, int val, struct btf *btf, char *type,
+				 struct syscall_arg_fmt *arg_fmt)
+{
+	struct btf_enum *be;
+	int i;
+
+	/* if btf_entry is NULL, find and save it to arg_fmt */
+	if (arg_fmt->btf_entry.entries == NULL)
+		if (btf_enum_find_entry(btf, type, arg_fmt))
+			return 0;
+
+	be = (struct btf_enum *)arg_fmt->btf_entry.entries;
+
+	for (i = 0; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {
+		if (be->val == val) {
+			return scnprintf(bf, size, "%s",
+					 btf__name_by_offset(btf, be->name_off));
+		}
+	}
+
+	return 0;
+}
+
 #include "trace/beauty/arch_errno_names.c"
 #include "trace/beauty/eventfd.c"
 #include "trace/beauty/futex_op.c"
@@ -1699,6 +1756,15 @@ static void trace__symbols__exit(struct trace *trace)
 	symbol__exit();
 }
 
+static void trace__load_vmlinux_btf(struct trace *trace)
+{
+	trace->btf = btf__load_vmlinux_btf();
+	if (verbose > 0) {
+		fprintf(trace->output, trace->btf ? "vmlinux BTF loaded\n" :
+						    "Failed to load vmlinux BTF\n");
+	}
+}
+
 static int syscall__alloc_arg_fmts(struct syscall *sc, int nr_args)
 {
 	int idx;
@@ -1744,7 +1810,7 @@ static const struct syscall_arg_fmt *syscall_arg_fmt__find_by_name(const char *n
 }
 
 static struct tep_format_field *
-syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field *field)
+syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field *field, bool *use_btf)
 {
 	struct tep_format_field *last_field = NULL;
 	int len;
@@ -1782,6 +1848,8 @@ syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field
 			 * 7 unsigned long
 			 */
 			arg->scnprintf = SCA_FD;
+		} else if (strstr(field->type, "enum") && use_btf != NULL) {
+			*use_btf = arg->is_enum = true;
 		} else {
 			const struct syscall_arg_fmt *fmt =
 				syscall_arg_fmt__find_by_name(field->name);
@@ -1796,9 +1864,10 @@ syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field
 	return last_field;
 }
 
-static int syscall__set_arg_fmts(struct syscall *sc)
+static int syscall__set_arg_fmts(struct syscall *sc, bool *use_btf)
 {
-	struct tep_format_field *last_field = syscall_arg_fmt__init_array(sc->arg_fmt, sc->args);
+	struct tep_format_field *last_field = syscall_arg_fmt__init_array(sc->arg_fmt, sc->args,
+									  use_btf);
 
 	if (last_field)
 		sc->args_size = last_field->offset + last_field->size;
@@ -1810,7 +1879,9 @@ static int trace__read_syscall_info(struct trace *trace, int id)
 {
 	char tp_name[128];
 	struct syscall *sc;
+	int err;
 	const char *name = syscalltbl__name(trace->sctbl, id);
+	bool use_btf = false;
 
 #ifdef HAVE_SYSCALL_TABLE_SUPPORT
 	if (trace->syscalls.table == NULL) {
@@ -1883,7 +1954,12 @@ static int trace__read_syscall_info(struct trace *trace, int id)
 	sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
 	sc->is_open = !strcmp(name, "open") || !strcmp(name, "openat");
 
-	return syscall__set_arg_fmts(sc);
+	err = syscall__set_arg_fmts(sc, &use_btf);
+
+	if (use_btf && trace->btf == NULL)
+		trace__load_vmlinux_btf(trace);
+
+	return err;
 }
 
 static int evsel__init_tp_arg_scnprintf(struct evsel *evsel)
@@ -1891,7 +1967,7 @@ static int evsel__init_tp_arg_scnprintf(struct evsel *evsel)
 	struct syscall_arg_fmt *fmt = evsel__syscall_arg_fmt(evsel);
 
 	if (fmt != NULL) {
-		syscall_arg_fmt__init_array(fmt, evsel->tp_format->format.fields);
+		syscall_arg_fmt__init_array(fmt, evsel->tp_format->format.fields, NULL);
 		return 0;
 	}
 
@@ -2103,6 +2179,16 @@ static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
 			if (trace->show_arg_names)
 				printed += scnprintf(bf + printed, size - printed, "%s: ", field->name);
 
+			if (sc->arg_fmt[arg.idx].is_enum && trace->btf) {
+				size_t p = btf_enum_scnprintf(bf + printed, size - printed, val,
+							      trace->btf, field->type,
+							      &sc->arg_fmt[arg.idx]);
+				if (p) {
+					printed += p;
+					continue;
+				}
+			}
+
 			printed += syscall_arg_fmt__scnprintf_val(&sc->arg_fmt[arg.idx],
 								  bf + printed, size - printed, &arg, val);
 		}
Signature · 1 line
2.45.2
#3 lore raw

Re: [PATCH v2 2/5] perf trace: Augment enum syscall arguments with BTF

Quoted 71 lines · Howard Chu

This is a feature implemented on the basis of the previous bug fix
https://lore.kernel.org/linux-perf-users/[email protected]/T/#t

In this patch, BTF is used to turn enum value to the corresponding enum variable name. There is only one system call that uses enum value as its argument, that is landlock_add_rule().

The vmlinux btf is loaded lazily, when user decided to trace the landlock_add_rule syscall. But if one decides to run perf trace without any arguments, the behaviour is to trace landlock_add_rule, so vmlinux btf will be loaded by default.

before:

```
perf $ ./perf trace -e landlock_add_rule
     0.000 ( 0.008 ms): ldlck-test/438194 landlock_add_rule(rule_type: 2)                                       = -1 EBADFD (File descriptor in bad state)
     0.010 ( 0.001 ms): ldlck-test/438194 landlock_add_rule(rule_type: 1)                                       = -1 EBADFD (File descriptor in bad state)
```

after:

```
perf $ ./perf trace -e landlock_add_rule
     0.000 ( 0.029 ms): ldlck-test/438194 landlock_add_rule(rule_type: LANDLOCK_RULE_NET_PORT)                  = -1 EBADFD (File descriptor in bad state)
     0.036 ( 0.004 ms): ldlck-test/438194 landlock_add_rule(rule_type: LANDLOCK_RULE_PATH_BENEATH)              = -1 EBADFD (File descriptor in bad state)
```
---
 tools/perf/builtin-trace.c | 96 ++++++++++++++++++++++++++++++++++++--
 1 file changed, 91 insertions(+), 5 deletions(-)
tools/perf/builtin-trace.c +7 -0
index c4fa8191253d..d93f34e9af74 100644
@@ -19,6 +19,7 @@
 #ifdef HAVE_LIBBPF_SUPPORT
 #include <bpf/bpf.h>
 #include <bpf/libbpf.h>
+#include <bpf/btf.h>
 #ifdef HAVE_BPF_SKEL
 #include "bpf_skel/augmented_raw_syscalls.skel.h"
 #endif
@@ -110,6 +111,11 @@ struct syscall_arg_fmt {
 	const char *name;
 	u16	   nr_entries; // for arrays
 	bool	   show_zero;
+	bool	   is_enum;
+	struct {
+		void	*entries;
+		u16	nr_entries;
+	}	   btf_entry;
 };
 
 struct syscall_fmt {
@@ -140,6 +146,7 @@ struct trace {
 #ifdef HAVE_BPF_SKEL
 	struct augmented_raw_syscalls_bpf *skel;
 #endif
+	struct btf		*btf;
 	struct record_opts	opts;
 	struct evlist	*evlist;
 	struct machine		*host;
@@ -897,6 +904,56 @@ static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size,
 	    .strtoul	= STUL_STRARRAY_FLAGS, \
 	    .parm	= &strarray__##array, }
 

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 916

Quoted 10 lines
tools/perf/builtin-trace.c +10 -0
+static int btf_enum_find_entry(struct btf *btf, char *type, struct syscall_arg_fmt *arg_fmt)
+{
+	const struct btf_type *bt;
+	char enum_prefix[][16] = { "enum", "const enum" }, *ep;
+	int id;
+	size_t i;
+
+	for (i = 0; i < ARRAY_SIZE(enum_prefix); i++) {
+		ep = enum_prefix[i];
+		if (strlen(type) > strlen(ep) + 1 && strstarts(type, ep))

No need for the strlen test? I.e. plain using strstarts() should be enough?

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 925

Quoted 9 lines
tools/perf/builtin-trace.c +9 -0
+			type += strlen(ep) + 1;
+	}
+
+	id = btf__find_by_name(btf, type);
+	if (id < 0)
+		return -1;
+
+	bt = btf__type_by_id(btf, id);
+	if (bt == NULL)

a pr_debug() stating that something that tracefs says should be in BTF and isn't found there seems to be of value here.

Quoted 10 lines
tools/perf/builtin-trace.c +10 -0
+		return -1;
+
+	arg_fmt->btf_entry.entries    = btf_enum(bt);
+	arg_fmt->btf_entry.nr_entries = btf_vlen(bt);
+
+	return 0;
+}
+
+static size_t btf_enum_scnprintf(char *bf, size_t size, int val, struct btf *btf, char *type,
+				 struct syscall_arg_fmt *arg_fmt)

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 945

Quoted 10 lines
tools/perf/builtin-trace.c +10 -0
+{
+	struct btf_enum *be;
+	int i;
+
+	/* if btf_entry is NULL, find and save it to arg_fmt */
+	if (arg_fmt->btf_entry.entries == NULL)
+		if (btf_enum_find_entry(btf, type, arg_fmt))
+			return 0;
+
+	be = (struct btf_enum *)arg_fmt->btf_entry.entries;
	struct btf_enum *be = (struct btf_enum *)arg_fmt->btf_entry.entries;

arg_fmt->btf_entry.entries is (void *), so we don't need the (struct
btf_enum *) cast here, removing it makes the code more compact. And since we move the declaration to the same line, the info about its type is there as well.

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 947

Quoted 2 lines
tools/perf/builtin-trace.c +2 -0
+
+	for (i = 0; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {
	for (int i = 0; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {

⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' tools/perf/ | wc -l 99
⬢[acme@toolbox perf-tools-next]$

Doing it this way makes the code more compact and is allowed even in kernel code since some time ago:

⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' drivers/ | wc -l 294
⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' kernel/ | wc -l 12
⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' net/ | wc -l 3
⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' mm/ | wc -l 21
⬢[acme@toolbox perf-tools-next]$

Quoted 38 lines
tools/perf/builtin-trace.c +19 -1
+		if (be->val == val) {
+			return scnprintf(bf, size, "%s",
+					 btf__name_by_offset(btf, be->name_off));
+		}
+	}
+
+	return 0;
+}
+
 #include "trace/beauty/arch_errno_names.c"
 #include "trace/beauty/eventfd.c"
 #include "trace/beauty/futex_op.c"
@@ -1699,6 +1756,15 @@ static void trace__symbols__exit(struct trace *trace)
 	symbol__exit();
 }
 
+static void trace__load_vmlinux_btf(struct trace *trace)
+{
+	trace->btf = btf__load_vmlinux_btf();
+	if (verbose > 0) {
+		fprintf(trace->output, trace->btf ? "vmlinux BTF loaded\n" :
+						    "Failed to load vmlinux BTF\n");
+	}
+}
+
 static int syscall__alloc_arg_fmts(struct syscall *sc, int nr_args)
 {
 	int idx;
@@ -1744,7 +1810,7 @@ static const struct syscall_arg_fmt *syscall_arg_fmt__find_by_name(const char *n
 }
 
 static struct tep_format_field *
-syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field *field)
+syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field *field, bool *use_btf)
 {
 	struct tep_format_field *last_field = NULL;
 	int len;

tools/perf/builtin-trace.c syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field · line 1852

Quoted 5 lines
tools/perf/builtin-trace.c +2 -0
@@ -1782,6 +1848,8 @@ syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field
 			 * 7 unsigned long
 			 */
 			arg->scnprintf = SCA_FD;
+		} else if (strstr(field->type, "enum") && use_btf != NULL) {
+			*use_btf = arg->is_enum = true;

Here you have to check if use_btf is NULL, as you, in this patch, later call syscall_arg_fmt__init_array(arg, field, NULL) in evsel__init_tp_arg_scnprintf(), probably you tested it all at the end of the patch series, we have to make sure that it works after each patch, so that we keep the codebase bisectable.

Quoted 69 lines
tools/perf/builtin-trace.c +22 -4
 		} else {
 			const struct syscall_arg_fmt *fmt =
 				syscall_arg_fmt__find_by_name(field->name);
@@ -1796,9 +1864,10 @@ syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field
 	return last_field;
 }
 
-static int syscall__set_arg_fmts(struct syscall *sc)
+static int syscall__set_arg_fmts(struct syscall *sc, bool *use_btf)
 {
-	struct tep_format_field *last_field = syscall_arg_fmt__init_array(sc->arg_fmt, sc->args);
+	struct tep_format_field *last_field = syscall_arg_fmt__init_array(sc->arg_fmt, sc->args,
+									  use_btf);
 
 	if (last_field)
 		sc->args_size = last_field->offset + last_field->size;
@@ -1810,7 +1879,9 @@ static int trace__read_syscall_info(struct trace *trace, int id)
 {
 	char tp_name[128];
 	struct syscall *sc;
+	int err;
 	const char *name = syscalltbl__name(trace->sctbl, id);
+	bool use_btf = false;
 
 #ifdef HAVE_SYSCALL_TABLE_SUPPORT
 	if (trace->syscalls.table == NULL) {
@@ -1883,7 +1954,12 @@ static int trace__read_syscall_info(struct trace *trace, int id)
 	sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
 	sc->is_open = !strcmp(name, "open") || !strcmp(name, "openat");
 
-	return syscall__set_arg_fmts(sc);
+	err = syscall__set_arg_fmts(sc, &use_btf);
+
+	if (use_btf && trace->btf == NULL)
+		trace__load_vmlinux_btf(trace);
+
+	return err;
 }
 
 static int evsel__init_tp_arg_scnprintf(struct evsel *evsel)
@@ -1891,7 +1967,7 @@ static int evsel__init_tp_arg_scnprintf(struct evsel *evsel)
 	struct syscall_arg_fmt *fmt = evsel__syscall_arg_fmt(evsel);
 
 	if (fmt != NULL) {
-		syscall_arg_fmt__init_array(fmt, evsel->tp_format->format.fields);
+		syscall_arg_fmt__init_array(fmt, evsel->tp_format->format.fields, NULL);
 		return 0;
 	}
 
@@ -2103,6 +2179,16 @@ static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
 			if (trace->show_arg_names)
 				printed += scnprintf(bf + printed, size - printed, "%s: ", field->name);
 
+			if (sc->arg_fmt[arg.idx].is_enum && trace->btf) {
+				size_t p = btf_enum_scnprintf(bf + printed, size - printed, val,
+							      trace->btf, field->type,
+							      &sc->arg_fmt[arg.idx]);
+				if (p) {
+					printed += p;
+					continue;
+				}
+			}
+
 			printed += syscall_arg_fmt__scnprintf_val(&sc->arg_fmt[arg.idx],
 								  bf + printed, size - printed, &arg, val);
 		}
Signature · 1 line
2.45.2
author
#4 lore raw

Re: [PATCH v2 2/5] perf trace: Augment enum syscall arguments with BTF

Hello,

Thanks for the in-depth review.

Quoted 73 lines · Arnaldo Carvalho de Melo
Quoted 71 lines · Howard Chu

This is a feature implemented on the basis of the previous bug fix
https://lore.kernel.org/linux-perf-users/[email protected]/T/#t

In this patch, BTF is used to turn enum value to the corresponding enum variable name. There is only one system call that uses enum value as its argument, that is landlock_add_rule().

The vmlinux btf is loaded lazily, when user decided to trace the landlock_add_rule syscall. But if one decides to run perf trace without any arguments, the behaviour is to trace landlock_add_rule, so vmlinux btf will be loaded by default.

before:

```
perf $ ./perf trace -e landlock_add_rule
     0.000 ( 0.008 ms): ldlck-test/438194 landlock_add_rule(rule_type: 2)                                       = -1 EBADFD (File descriptor in bad state)
     0.010 ( 0.001 ms): ldlck-test/438194 landlock_add_rule(rule_type: 1)                                       = -1 EBADFD (File descriptor in bad state)
```

after:

```
perf $ ./perf trace -e landlock_add_rule
     0.000 ( 0.029 ms): ldlck-test/438194 landlock_add_rule(rule_type: LANDLOCK_RULE_NET_PORT)                  = -1 EBADFD (File descriptor in bad state)
     0.036 ( 0.004 ms): ldlck-test/438194 landlock_add_rule(rule_type: LANDLOCK_RULE_PATH_BENEATH)              = -1 EBADFD (File descriptor in bad state)
```
---
 tools/perf/builtin-trace.c | 96 ++++++++++++++++++++++++++++++++++++--
 1 file changed, 91 insertions(+), 5 deletions(-)
tools/perf/builtin-trace.c +7 -0
index c4fa8191253d..d93f34e9af74 100644
@@ -19,6 +19,7 @@
 #ifdef HAVE_LIBBPF_SUPPORT
 #include <bpf/bpf.h>
 #include <bpf/libbpf.h>
+#include <bpf/btf.h>
 #ifdef HAVE_BPF_SKEL
 #include "bpf_skel/augmented_raw_syscalls.skel.h"
 #endif
@@ -110,6 +111,11 @@ struct syscall_arg_fmt {
      const char *name;
      u16        nr_entries; // for arrays
      bool       show_zero;
+     bool       is_enum;
+     struct {
+             void    *entries;
+             u16     nr_entries;
+     }          btf_entry;
 };
 
 struct syscall_fmt {
@@ -140,6 +146,7 @@ struct trace {
 #ifdef HAVE_BPF_SKEL
      struct augmented_raw_syscalls_bpf *skel;
 #endif
+     struct btf              *btf;
      struct record_opts      opts;
      struct evlist   *evlist;
      struct machine          *host;
@@ -897,6 +904,56 @@ static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size,
          .strtoul    = STUL_STRARRAY_FLAGS, \
          .parm       = &strarray__##array, }
 
Quoted 13 lines

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 916

Quoted 10 lines
tools/perf/builtin-trace.c +10 -0
+static int btf_enum_find_entry(struct btf *btf, char *type, struct syscall_arg_fmt *arg_fmt)
+{
+     const struct btf_type *bt;
+     char enum_prefix[][16] = { "enum", "const enum" }, *ep;
+     int id;
+     size_t i;
+
+     for (i = 0; i < ARRAY_SIZE(enum_prefix); i++) {
+             ep = enum_prefix[i];
+             if (strlen(type) > strlen(ep) + 1 && strstarts(type, ep))

No need for the strlen test? I.e. plain using strstarts() should be enough?

Agree. Thanks for pointing that out. Although if string 'type' is 'enum' and prefix is 'enum', strstarts() will be true, but to do 'type += strlen(ep) + 1', and then access 'type', might give us an out-of-range access, but I don't think 'type' will ever be just 'enum' or 'const enum', so I'll delete it then.

Quoted 13 lines

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 925

Quoted 10 lines
tools/perf/builtin-trace.c +9 -0
+                     type += strlen(ep) + 1;
+     }
+
+     id = btf__find_by_name(btf, type);
+     if (id < 0)
+             return -1;
+
+     bt = btf__type_by_id(btf, id);
+     if (bt == NULL)

a pr_debug() stating that something that tracefs says should be in BTF and isn't found there seems to be of value here.

Sure.

Quoted 24 lines
Quoted 11 lines
tools/perf/builtin-trace.c +10 -0
+             return -1;
+
+     arg_fmt->btf_entry.entries    = btf_enum(bt);
+     arg_fmt->btf_entry.nr_entries = btf_vlen(bt);
+
+     return 0;
+}
+
+static size_t btf_enum_scnprintf(char *bf, size_t size, int val, struct btf *btf, char *type,
+                              struct syscall_arg_fmt *arg_fmt)

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 945

Quoted 10 lines
tools/perf/builtin-trace.c +10 -0
+{
+     struct btf_enum *be;
+     int i;
+
+     /* if btf_entry is NULL, find and save it to arg_fmt */
+     if (arg_fmt->btf_entry.entries == NULL)
+             if (btf_enum_find_entry(btf, type, arg_fmt))
+                     return 0;
+
+     be = (struct btf_enum *)arg_fmt->btf_entry.entries;
        struct btf_enum *be = (struct btf_enum *)arg_fmt->btf_entry.entries;
Quoted 4 lines

arg_fmt->btf_entry.entries is (void *), so we don't need the (struct
btf_enum *) cast here, removing it makes the code more compact. And since we move the declaration to the same line, the info about its type is there as well.

Sure, thanks.

Quoted 5 lines

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 947

Quoted 3 lines
tools/perf/builtin-trace.c +2 -0
+
+     for (i = 0; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {
Quoted 8 lines
        for (int i = 0; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {

⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' tools/perf/ | wc -l 99
⬢[acme@toolbox perf-tools-next]$

Doing it this way makes the code more compact and is allowed even in kernel code since some time ago:

Sure.

Quoted 52 lines

⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' drivers/ | wc -l 294
⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' kernel/ | wc -l 12
⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' net/ | wc -l 3
⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' mm/ | wc -l 21
⬢[acme@toolbox perf-tools-next]$

Quoted 41 lines
tools/perf/builtin-trace.c +19 -1
+             if (be->val == val) {
+                     return scnprintf(bf, size, "%s",
+                                      btf__name_by_offset(btf, be->name_off));
+             }
+     }
+
+     return 0;
+}
+
 #include "trace/beauty/arch_errno_names.c"
 #include "trace/beauty/eventfd.c"
 #include "trace/beauty/futex_op.c"
@@ -1699,6 +1756,15 @@ static void trace__symbols__exit(struct trace *trace)
      symbol__exit();
 }
 
+static void trace__load_vmlinux_btf(struct trace *trace)
+{
+     trace->btf = btf__load_vmlinux_btf();
+     if (verbose > 0) {
+             fprintf(trace->output, trace->btf ? "vmlinux BTF loaded\n" :
+                                                 "Failed to load vmlinux BTF\n");
+     }
+}
+
 static int syscall__alloc_arg_fmts(struct syscall *sc, int nr_args)
 {
      int idx;
@@ -1744,7 +1810,7 @@ static const struct syscall_arg_fmt *syscall_arg_fmt__find_by_name(const char *n
 }
 
 static struct tep_format_field *
-syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field *field)
+syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field *field, bool *use_btf)
 {
      struct tep_format_field *last_field = NULL;
      int len;
@@ -1782,6 +1848,8 @@ syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field
                       * 7 unsigned long
                       */
                      arg->scnprintf = SCA_FD;
Quoted 8 lines

tools/perf/builtin-trace.c syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field · line 1852

Quoted 2 lines
tools/perf/builtin-trace.c +2 -0
+             } else if (strstr(field->type, "enum") && use_btf != NULL) {
+                     *use_btf = arg->is_enum = true;

Here you have to check if use_btf is NULL, as you, in this patch, later call syscall_arg_fmt__init_array(arg, field, NULL) in evsel__init_tp_arg_scnprintf(), probably you tested it all at the end of the patch series, we have to make sure that it works after each patch, so that we keep the codebase bisectable.

I'm sorry, could you enlighten me on this? I thought:

```
else if (strstr(field->type, "enum") && use_btf != NULL) {
```

is doing the NULL checking. If you mean making sure the NULL checking appears in all patches, I thought this is where we should introduce the checking. Tiny reminder, the [1/5] patch is your syscalltbl traversal bug fix.

Quoted 54 lines
Quoted 54 lines
tools/perf/builtin-trace.c +12 -4
              } else {
                      const struct syscall_arg_fmt *fmt =
                              syscall_arg_fmt__find_by_name(field->name);
@@ -1796,9 +1864,10 @@ syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field
      return last_field;
 }
 
-static int syscall__set_arg_fmts(struct syscall *sc)
+static int syscall__set_arg_fmts(struct syscall *sc, bool *use_btf)
 {
-     struct tep_format_field *last_field = syscall_arg_fmt__init_array(sc->arg_fmt, sc->args);
+     struct tep_format_field *last_field = syscall_arg_fmt__init_array(sc->arg_fmt, sc->args,
+                                                                       use_btf);
 
      if (last_field)
              sc->args_size = last_field->offset + last_field->size;
@@ -1810,7 +1879,9 @@ static int trace__read_syscall_info(struct trace *trace, int id)
 {
      char tp_name[128];
      struct syscall *sc;
+     int err;
      const char *name = syscalltbl__name(trace->sctbl, id);
+     bool use_btf = false;
 
 #ifdef HAVE_SYSCALL_TABLE_SUPPORT
      if (trace->syscalls.table == NULL) {
@@ -1883,7 +1954,12 @@ static int trace__read_syscall_info(struct trace *trace, int id)
      sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
      sc->is_open = !strcmp(name, "open") || !strcmp(name, "openat");
 
-     return syscall__set_arg_fmts(sc);
+     err = syscall__set_arg_fmts(sc, &use_btf);
+
+     if (use_btf && trace->btf == NULL)
+             trace__load_vmlinux_btf(trace);
+
+     return err;
 }
 
 static int evsel__init_tp_arg_scnprintf(struct evsel *evsel)
@@ -1891,7 +1967,7 @@ static int evsel__init_tp_arg_scnprintf(struct evsel *evsel)
      struct syscall_arg_fmt *fmt = evsel__syscall_arg_fmt(evsel);
 
      if (fmt != NULL) {
-             syscall_arg_fmt__init_array(fmt, evsel->tp_format->format.fields);
+             syscall_arg_fmt__init_array(fmt, evsel->tp_format->format.fields, NULL);
              return 0;
      }
 
@@ -2103,6 +2179,16 @@ static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
                      if (trace->show_arg_names)
                              printed += scnprintf(bf + printed, size - printed, "%s: ", field->name);
 
Quoted 16 lines
Quoted 14 lines
tools/perf/builtin-trace.c +10 -1
+                     if (sc->arg_fmt[arg.idx].is_enum && trace->btf) {
+                             size_t p = btf_enum_scnprintf(bf + printed, size - printed, val,
+                                                           trace->btf, field->type,
+                                                           &sc->arg_fmt[arg.idx]);
+                             if (p) {
+                                     printed += p;
+                                     continue;
+                             }
+                     }
+
                      printed += syscall_arg_fmt__scnprintf_val(&sc->arg_fmt[arg.idx],
                                                                bf + printed, size - printed, &arg, val);
              }
--
Quoted 2 lines

2.45.2

Thanks,
Howard

author
#5 lore raw

Re: [PATCH v2 2/5] perf trace: Augment enum syscall arguments with BTF

Hello Arnaldo,

Thanks for the review, the code is refined based on your comments. There is just a little thing:

Quoted 140 lines · Howard Chu

Hello,

Thanks for the in-depth review.

Quoted 73 lines · Arnaldo Carvalho de Melo
Quoted 71 lines · Howard Chu

This is a feature implemented on the basis of the previous bug fix
https://lore.kernel.org/linux-perf-users/[email protected]/T/#t

In this patch, BTF is used to turn enum value to the corresponding enum variable name. There is only one system call that uses enum value as its argument, that is landlock_add_rule().

The vmlinux btf is loaded lazily, when user decided to trace the landlock_add_rule syscall. But if one decides to run perf trace without any arguments, the behaviour is to trace landlock_add_rule, so vmlinux btf will be loaded by default.

before:

```
perf $ ./perf trace -e landlock_add_rule
     0.000 ( 0.008 ms): ldlck-test/438194 landlock_add_rule(rule_type: 2)                                       = -1 EBADFD (File descriptor in bad state)
     0.010 ( 0.001 ms): ldlck-test/438194 landlock_add_rule(rule_type: 1)                                       = -1 EBADFD (File descriptor in bad state)
```

after:

```
perf $ ./perf trace -e landlock_add_rule
     0.000 ( 0.029 ms): ldlck-test/438194 landlock_add_rule(rule_type: LANDLOCK_RULE_NET_PORT)                  = -1 EBADFD (File descriptor in bad state)
     0.036 ( 0.004 ms): ldlck-test/438194 landlock_add_rule(rule_type: LANDLOCK_RULE_PATH_BENEATH)              = -1 EBADFD (File descriptor in bad state)
```
---
 tools/perf/builtin-trace.c | 96 ++++++++++++++++++++++++++++++++++++--
 1 file changed, 91 insertions(+), 5 deletions(-)
tools/perf/builtin-trace.c +7 -0
index c4fa8191253d..d93f34e9af74 100644
@@ -19,6 +19,7 @@
 #ifdef HAVE_LIBBPF_SUPPORT
 #include <bpf/bpf.h>
 #include <bpf/libbpf.h>
+#include <bpf/btf.h>
 #ifdef HAVE_BPF_SKEL
 #include "bpf_skel/augmented_raw_syscalls.skel.h"
 #endif
@@ -110,6 +111,11 @@ struct syscall_arg_fmt {
      const char *name;
      u16        nr_entries; // for arrays
      bool       show_zero;
+     bool       is_enum;
+     struct {
+             void    *entries;
+             u16     nr_entries;
+     }          btf_entry;
 };
 
 struct syscall_fmt {
@@ -140,6 +146,7 @@ struct trace {
 #ifdef HAVE_BPF_SKEL
      struct augmented_raw_syscalls_bpf *skel;
 #endif
+     struct btf              *btf;
      struct record_opts      opts;
      struct evlist   *evlist;
      struct machine          *host;
@@ -897,6 +904,56 @@ static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size,
          .strtoul    = STUL_STRARRAY_FLAGS, \
          .parm       = &strarray__##array, }
 
Quoted 13 lines

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 916

Quoted 10 lines
tools/perf/builtin-trace.c +10 -0
+static int btf_enum_find_entry(struct btf *btf, char *type, struct syscall_arg_fmt *arg_fmt)
+{
+     const struct btf_type *bt;
+     char enum_prefix[][16] = { "enum", "const enum" }, *ep;
+     int id;
+     size_t i;
+
+     for (i = 0; i < ARRAY_SIZE(enum_prefix); i++) {
+             ep = enum_prefix[i];
+             if (strlen(type) > strlen(ep) + 1 && strstarts(type, ep))

No need for the strlen test? I.e. plain using strstarts() should be enough?

Agree. Thanks for pointing that out. Although if string 'type' is 'enum' and prefix is 'enum', strstarts() will be true, but to do 'type += strlen(ep) + 1', and then access 'type', might give us an out-of-range access, but I don't think 'type' will ever be just 'enum' or 'const enum', so I'll delete it then.

Quoted 13 lines

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 925

Quoted 10 lines
tools/perf/builtin-trace.c +9 -0
+                     type += strlen(ep) + 1;
+     }
+
+     id = btf__find_by_name(btf, type);
+     if (id < 0)
+             return -1;
+
+     bt = btf__type_by_id(btf, id);
+     if (bt == NULL)

a pr_debug() stating that something that tracefs says should be in BTF and isn't found there seems to be of value here.

Sure.

Quoted 24 lines
Quoted 11 lines
tools/perf/builtin-trace.c +10 -0
+             return -1;
+
+     arg_fmt->btf_entry.entries    = btf_enum(bt);
+     arg_fmt->btf_entry.nr_entries = btf_vlen(bt);
+
+     return 0;
+}
+
+static size_t btf_enum_scnprintf(char *bf, size_t size, int val, struct btf *btf, char *type,
+                              struct syscall_arg_fmt *arg_fmt)

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 945

Quoted 10 lines
tools/perf/builtin-trace.c +10 -0
+{
+     struct btf_enum *be;
+     int i;
+
+     /* if btf_entry is NULL, find and save it to arg_fmt */
+     if (arg_fmt->btf_entry.entries == NULL)
+             if (btf_enum_find_entry(btf, type, arg_fmt))
+                     return 0;
+
+     be = (struct btf_enum *)arg_fmt->btf_entry.entries;
        struct btf_enum *be = (struct btf_enum *)arg_fmt->btf_entry.entries;
Quoted 13 lines
Quoted 4 lines

arg_fmt->btf_entry.entries is (void *), so we don't need the (struct
btf_enum *) cast here, removing it makes the code more compact. And since we move the declaration to the same line, the info about its type is there as well.

Sure, thanks.

Quoted 6 lines

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 947

Quoted 3 lines
tools/perf/builtin-trace.c +2 -0
+
+     for (i = 0; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {
        for (int i = 0; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {

I did this, it's all good. But here:

for (i = 0, be = arg_fmt->btf_entry.entries; i <
arg_fmt->btf_entry.nr_entries; ++i, ++be) {

I can't do

for (int i = 0, struct btf_enum *be = arg_fmt->btf_entry.entries; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {

The compiler will show errors:

builtin-trace.c: In function ‘btf_enum_scnprintf’:
builtin-trace.c:996:25: error: expected identifier or ‘(’ before ‘struct’
996 | for (int i = 0, struct btf_enum *be =
arg_fmt->btf_entry.entries; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {
| ^~~~~~
builtin-trace.c:996:117: error: ‘be’ undeclared (first use in this function); did you mean ‘bf’?
996 | for (int i = 0, struct btf_enum *be =
arg_fmt->btf_entry.entries; i < arg_fmt->btf_entry.nr_entries; ++i,

++be) {
      |
                                                     ^~
      |
                                                     bf

builtin-trace.c:996:117: note: each undeclared identifier is reported only once for each function it appears in

This is not good either:

for (int i = 0, be = arg_fmt->btf_entry.entries; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {

builtin-trace.c: In function ‘btf_enum_scnprintf’:
builtin-trace.c:998:25: error: declaration of ‘be’ shadows a previous local [-Werror=shadow]
998 | for (int i = 0, be = arg_fmt->btf_entry.entries; i <
arg_fmt->btf_entry.nr_entries; ++i, ++be) {
| ^~
builtin-trace.c:991:26: note: shadowed declaration is here
991 | struct btf_enum *be;
| ^~
builtin-trace.c:998:30: error: initialization of ‘int’ from ‘void *’ makes integer from pointer without a cast [-Wint-conversion]
998 | for (int i = 0, be = arg_fmt->btf_entry.entries; i <
arg_fmt->btf_entry.nr_entries; ++i, ++be) {
| ^~~~~~~

But I can do:

```
be = arg_fmt->btf_entry.entries;

for (int i = 0; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {
```

Thanks,
Howard

Quoted 153 lines
Quoted 7 lines

⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' tools/perf/ | wc -l 99
⬢[acme@toolbox perf-tools-next]$

Doing it this way makes the code more compact and is allowed even in kernel code since some time ago:

Sure.

Quoted 52 lines

⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' drivers/ | wc -l 294
⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' kernel/ | wc -l 12
⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' net/ | wc -l 3
⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' mm/ | wc -l 21
⬢[acme@toolbox perf-tools-next]$

Quoted 41 lines
tools/perf/builtin-trace.c +19 -1
+             if (be->val == val) {
+                     return scnprintf(bf, size, "%s",
+                                      btf__name_by_offset(btf, be->name_off));
+             }
+     }
+
+     return 0;
+}
+
 #include "trace/beauty/arch_errno_names.c"
 #include "trace/beauty/eventfd.c"
 #include "trace/beauty/futex_op.c"
@@ -1699,6 +1756,15 @@ static void trace__symbols__exit(struct trace *trace)
      symbol__exit();
 }
 
+static void trace__load_vmlinux_btf(struct trace *trace)
+{
+     trace->btf = btf__load_vmlinux_btf();
+     if (verbose > 0) {
+             fprintf(trace->output, trace->btf ? "vmlinux BTF loaded\n" :
+                                                 "Failed to load vmlinux BTF\n");
+     }
+}
+
 static int syscall__alloc_arg_fmts(struct syscall *sc, int nr_args)
 {
      int idx;
@@ -1744,7 +1810,7 @@ static const struct syscall_arg_fmt *syscall_arg_fmt__find_by_name(const char *n
 }
 
 static struct tep_format_field *
-syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field *field)
+syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field *field, bool *use_btf)
 {
      struct tep_format_field *last_field = NULL;
      int len;
@@ -1782,6 +1848,8 @@ syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field
                       * 7 unsigned long
                       */
                      arg->scnprintf = SCA_FD;
Quoted 8 lines

tools/perf/builtin-trace.c syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field · line 1852

Quoted 2 lines
tools/perf/builtin-trace.c +2 -0
+             } else if (strstr(field->type, "enum") && use_btf != NULL) {
+                     *use_btf = arg->is_enum = true;

Here you have to check if use_btf is NULL, as you, in this patch, later call syscall_arg_fmt__init_array(arg, field, NULL) in evsel__init_tp_arg_scnprintf(), probably you tested it all at the end of the patch series, we have to make sure that it works after each patch, so that we keep the codebase bisectable.

I'm sorry, could you enlighten me on this? I thought:

```
else if (strstr(field->type, "enum") && use_btf != NULL) {
```

is doing the NULL checking. If you mean making sure the NULL checking appears in all patches, I thought this is where we should introduce the checking. Tiny reminder, the [1/5] patch is your syscalltbl traversal bug fix.

Quoted 54 lines
Quoted 54 lines
tools/perf/builtin-trace.c +12 -4
              } else {
                      const struct syscall_arg_fmt *fmt =
                              syscall_arg_fmt__find_by_name(field->name);
@@ -1796,9 +1864,10 @@ syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field
      return last_field;
 }
 
-static int syscall__set_arg_fmts(struct syscall *sc)
+static int syscall__set_arg_fmts(struct syscall *sc, bool *use_btf)
 {
-     struct tep_format_field *last_field = syscall_arg_fmt__init_array(sc->arg_fmt, sc->args);
+     struct tep_format_field *last_field = syscall_arg_fmt__init_array(sc->arg_fmt, sc->args,
+                                                                       use_btf);
 
      if (last_field)
              sc->args_size = last_field->offset + last_field->size;
@@ -1810,7 +1879,9 @@ static int trace__read_syscall_info(struct trace *trace, int id)
 {
      char tp_name[128];
      struct syscall *sc;
+     int err;
      const char *name = syscalltbl__name(trace->sctbl, id);
+     bool use_btf = false;
 
 #ifdef HAVE_SYSCALL_TABLE_SUPPORT
      if (trace->syscalls.table == NULL) {
@@ -1883,7 +1954,12 @@ static int trace__read_syscall_info(struct trace *trace, int id)
      sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
      sc->is_open = !strcmp(name, "open") || !strcmp(name, "openat");
 
-     return syscall__set_arg_fmts(sc);
+     err = syscall__set_arg_fmts(sc, &use_btf);
+
+     if (use_btf && trace->btf == NULL)
+             trace__load_vmlinux_btf(trace);
+
+     return err;
 }
 
 static int evsel__init_tp_arg_scnprintf(struct evsel *evsel)
@@ -1891,7 +1967,7 @@ static int evsel__init_tp_arg_scnprintf(struct evsel *evsel)
      struct syscall_arg_fmt *fmt = evsel__syscall_arg_fmt(evsel);
 
      if (fmt != NULL) {
-             syscall_arg_fmt__init_array(fmt, evsel->tp_format->format.fields);
+             syscall_arg_fmt__init_array(fmt, evsel->tp_format->format.fields, NULL);
              return 0;
      }
 
@@ -2103,6 +2179,16 @@ static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
                      if (trace->show_arg_names)
                              printed += scnprintf(bf + printed, size - printed, "%s: ", field->name);
 
Quoted 16 lines
Quoted 14 lines
tools/perf/builtin-trace.c +10 -1
+                     if (sc->arg_fmt[arg.idx].is_enum && trace->btf) {
+                             size_t p = btf_enum_scnprintf(bf + printed, size - printed, val,
+                                                           trace->btf, field->type,
+                                                           &sc->arg_fmt[arg.idx]);
+                             if (p) {
+                                     printed += p;
+                                     continue;
+                             }
+                     }
+
                      printed += syscall_arg_fmt__scnprintf_val(&sc->arg_fmt[arg.idx],
                                                                bf + printed, size - printed, &arg, val);
              }
--
Quoted 2 lines

2.45.2

Thanks,
Howard

author
#6 lore raw

Re: [PATCH v2 2/5] perf trace: Augment enum syscall arguments with BTF

Hello,

The fixes are on the perf-tools-next branch at:
https://github.com/Sberm/linux.git

please use

```
git pull https://github.com/Sberm/linux.git perf-tools-next
```

I'm no git expert so please tell me if something is wrong.

P.S. not my proudest patch, changed too many things, might be buggy. If there're bugs please let me know.

Quoted 376 lines · Howard Chu

Hello Arnaldo,

Thanks for the review, the code is refined based on your comments. There is just a little thing:

Quoted 140 lines · Howard Chu

Hello,

Thanks for the in-depth review.

Quoted 73 lines · Arnaldo Carvalho de Melo
Quoted 71 lines · Howard Chu

This is a feature implemented on the basis of the previous bug fix
https://lore.kernel.org/linux-perf-users/[email protected]/T/#t

In this patch, BTF is used to turn enum value to the corresponding enum variable name. There is only one system call that uses enum value as its argument, that is landlock_add_rule().

The vmlinux btf is loaded lazily, when user decided to trace the landlock_add_rule syscall. But if one decides to run perf trace without any arguments, the behaviour is to trace landlock_add_rule, so vmlinux btf will be loaded by default.

before:

```
perf $ ./perf trace -e landlock_add_rule
     0.000 ( 0.008 ms): ldlck-test/438194 landlock_add_rule(rule_type: 2)                                       = -1 EBADFD (File descriptor in bad state)
     0.010 ( 0.001 ms): ldlck-test/438194 landlock_add_rule(rule_type: 1)                                       = -1 EBADFD (File descriptor in bad state)
```

after:

```
perf $ ./perf trace -e landlock_add_rule
     0.000 ( 0.029 ms): ldlck-test/438194 landlock_add_rule(rule_type: LANDLOCK_RULE_NET_PORT)                  = -1 EBADFD (File descriptor in bad state)
     0.036 ( 0.004 ms): ldlck-test/438194 landlock_add_rule(rule_type: LANDLOCK_RULE_PATH_BENEATH)              = -1 EBADFD (File descriptor in bad state)
```
---
 tools/perf/builtin-trace.c | 96 ++++++++++++++++++++++++++++++++++++--
 1 file changed, 91 insertions(+), 5 deletions(-)
tools/perf/builtin-trace.c +7 -0
index c4fa8191253d..d93f34e9af74 100644
@@ -19,6 +19,7 @@
 #ifdef HAVE_LIBBPF_SUPPORT
 #include <bpf/bpf.h>
 #include <bpf/libbpf.h>
+#include <bpf/btf.h>
 #ifdef HAVE_BPF_SKEL
 #include "bpf_skel/augmented_raw_syscalls.skel.h"
 #endif
@@ -110,6 +111,11 @@ struct syscall_arg_fmt {
      const char *name;
      u16        nr_entries; // for arrays
      bool       show_zero;
+     bool       is_enum;
+     struct {
+             void    *entries;
+             u16     nr_entries;
+     }          btf_entry;
 };
 
 struct syscall_fmt {
@@ -140,6 +146,7 @@ struct trace {
 #ifdef HAVE_BPF_SKEL
      struct augmented_raw_syscalls_bpf *skel;
 #endif
+     struct btf              *btf;
      struct record_opts      opts;
      struct evlist   *evlist;
      struct machine          *host;
@@ -897,6 +904,56 @@ static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size,
          .strtoul    = STUL_STRARRAY_FLAGS, \
          .parm       = &strarray__##array, }
 
Quoted 13 lines

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 916

Quoted 10 lines
tools/perf/builtin-trace.c +10 -0
+static int btf_enum_find_entry(struct btf *btf, char *type, struct syscall_arg_fmt *arg_fmt)
+{
+     const struct btf_type *bt;
+     char enum_prefix[][16] = { "enum", "const enum" }, *ep;
+     int id;
+     size_t i;
+
+     for (i = 0; i < ARRAY_SIZE(enum_prefix); i++) {
+             ep = enum_prefix[i];
+             if (strlen(type) > strlen(ep) + 1 && strstarts(type, ep))

No need for the strlen test? I.e. plain using strstarts() should be enough?

Agree. Thanks for pointing that out. Although if string 'type' is 'enum' and prefix is 'enum', strstarts() will be true, but to do 'type += strlen(ep) + 1', and then access 'type', might give us an out-of-range access, but I don't think 'type' will ever be just 'enum' or 'const enum', so I'll delete it then.

Quoted 13 lines

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 925

Quoted 10 lines
tools/perf/builtin-trace.c +9 -0
+                     type += strlen(ep) + 1;
+     }
+
+     id = btf__find_by_name(btf, type);
+     if (id < 0)
+             return -1;
+
+     bt = btf__type_by_id(btf, id);
+     if (bt == NULL)

a pr_debug() stating that something that tracefs says should be in BTF and isn't found there seems to be of value here.

Sure.

Quoted 24 lines
Quoted 11 lines
tools/perf/builtin-trace.c +10 -0
+             return -1;
+
+     arg_fmt->btf_entry.entries    = btf_enum(bt);
+     arg_fmt->btf_entry.nr_entries = btf_vlen(bt);
+
+     return 0;
+}
+
+static size_t btf_enum_scnprintf(char *bf, size_t size, int val, struct btf *btf, char *type,
+                              struct syscall_arg_fmt *arg_fmt)

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 945

Quoted 10 lines
tools/perf/builtin-trace.c +10 -0
+{
+     struct btf_enum *be;
+     int i;
+
+     /* if btf_entry is NULL, find and save it to arg_fmt */
+     if (arg_fmt->btf_entry.entries == NULL)
+             if (btf_enum_find_entry(btf, type, arg_fmt))
+                     return 0;
+
+     be = (struct btf_enum *)arg_fmt->btf_entry.entries;
        struct btf_enum *be = (struct btf_enum *)arg_fmt->btf_entry.entries;
Quoted 13 lines
Quoted 4 lines

arg_fmt->btf_entry.entries is (void *), so we don't need the (struct
btf_enum *) cast here, removing it makes the code more compact. And since we move the declaration to the same line, the info about its type is there as well.

Sure, thanks.

Quoted 6 lines

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 947

Quoted 3 lines
tools/perf/builtin-trace.c +2 -0
+
+     for (i = 0; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {
        for (int i = 0; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {

I did this, it's all good. But here:

for (i = 0, be = arg_fmt->btf_entry.entries; i <
arg_fmt->btf_entry.nr_entries; ++i, ++be) {

I can't do

for (int i = 0, struct btf_enum *be = arg_fmt->btf_entry.entries; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {

The compiler will show errors:

builtin-trace.c: In function ‘btf_enum_scnprintf’:
builtin-trace.c:996:25: error: expected identifier or ‘(’ before ‘struct’
996 | for (int i = 0, struct btf_enum *be =
arg_fmt->btf_entry.entries; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {
| ^~~~~~
builtin-trace.c:996:117: error: ‘be’ undeclared (first use in this function); did you mean ‘bf’?
996 | for (int i = 0, struct btf_enum *be =
arg_fmt->btf_entry.entries; i < arg_fmt->btf_entry.nr_entries; ++i,

++be) {
      |
                                                     ^~
      |
                                                     bf

builtin-trace.c:996:117: note: each undeclared identifier is reported only once for each function it appears in

This is not good either:

for (int i = 0, be = arg_fmt->btf_entry.entries; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {

builtin-trace.c: In function ‘btf_enum_scnprintf’:
builtin-trace.c:998:25: error: declaration of ‘be’ shadows a previous local [-Werror=shadow]
998 | for (int i = 0, be = arg_fmt->btf_entry.entries; i <
arg_fmt->btf_entry.nr_entries; ++i, ++be) {
| ^~
builtin-trace.c:991:26: note: shadowed declaration is here
991 | struct btf_enum *be;
| ^~
builtin-trace.c:998:30: error: initialization of ‘int’ from ‘void *’ makes integer from pointer without a cast [-Wint-conversion]
998 | for (int i = 0, be = arg_fmt->btf_entry.entries; i <
arg_fmt->btf_entry.nr_entries; ++i, ++be) {
| ^~~~~~~

But I can do:

```
be = arg_fmt->btf_entry.entries;

for (int i = 0; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {
```

Thanks,
Howard

Quoted 153 lines
Quoted 7 lines

⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' tools/perf/ | wc -l 99
⬢[acme@toolbox perf-tools-next]$

Doing it this way makes the code more compact and is allowed even in kernel code since some time ago:

Sure.

Quoted 52 lines

⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' drivers/ | wc -l 294
⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' kernel/ | wc -l 12
⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' net/ | wc -l 3
⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' mm/ | wc -l 21
⬢[acme@toolbox perf-tools-next]$

Quoted 41 lines
tools/perf/builtin-trace.c +19 -1
+             if (be->val == val) {
+                     return scnprintf(bf, size, "%s",
+                                      btf__name_by_offset(btf, be->name_off));
+             }
+     }
+
+     return 0;
+}
+
 #include "trace/beauty/arch_errno_names.c"
 #include "trace/beauty/eventfd.c"
 #include "trace/beauty/futex_op.c"
@@ -1699,6 +1756,15 @@ static void trace__symbols__exit(struct trace *trace)
      symbol__exit();
 }
 
+static void trace__load_vmlinux_btf(struct trace *trace)
+{
+     trace->btf = btf__load_vmlinux_btf();
+     if (verbose > 0) {
+             fprintf(trace->output, trace->btf ? "vmlinux BTF loaded\n" :
+                                                 "Failed to load vmlinux BTF\n");
+     }
+}
+
 static int syscall__alloc_arg_fmts(struct syscall *sc, int nr_args)
 {
      int idx;
@@ -1744,7 +1810,7 @@ static const struct syscall_arg_fmt *syscall_arg_fmt__find_by_name(const char *n
 }
 
 static struct tep_format_field *
-syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field *field)
+syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field *field, bool *use_btf)
 {
      struct tep_format_field *last_field = NULL;
      int len;
@@ -1782,6 +1848,8 @@ syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field
                       * 7 unsigned long
                       */
                      arg->scnprintf = SCA_FD;
Quoted 8 lines

tools/perf/builtin-trace.c syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field · line 1852

Quoted 2 lines
tools/perf/builtin-trace.c +2 -0
+             } else if (strstr(field->type, "enum") && use_btf != NULL) {
+                     *use_btf = arg->is_enum = true;

Here you have to check if use_btf is NULL, as you, in this patch, later call syscall_arg_fmt__init_array(arg, field, NULL) in evsel__init_tp_arg_scnprintf(), probably you tested it all at the end of the patch series, we have to make sure that it works after each patch, so that we keep the codebase bisectable.

I'm sorry, could you enlighten me on this? I thought:

```
else if (strstr(field->type, "enum") && use_btf != NULL) {
```

is doing the NULL checking. If you mean making sure the NULL checking appears in all patches, I thought this is where we should introduce the checking. Tiny reminder, the [1/5] patch is your syscalltbl traversal bug fix.

Quoted 54 lines
Quoted 54 lines
tools/perf/builtin-trace.c +12 -4
              } else {
                      const struct syscall_arg_fmt *fmt =
                              syscall_arg_fmt__find_by_name(field->name);
@@ -1796,9 +1864,10 @@ syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field
      return last_field;
 }
 
-static int syscall__set_arg_fmts(struct syscall *sc)
+static int syscall__set_arg_fmts(struct syscall *sc, bool *use_btf)
 {
-     struct tep_format_field *last_field = syscall_arg_fmt__init_array(sc->arg_fmt, sc->args);
+     struct tep_format_field *last_field = syscall_arg_fmt__init_array(sc->arg_fmt, sc->args,
+                                                                       use_btf);
 
      if (last_field)
              sc->args_size = last_field->offset + last_field->size;
@@ -1810,7 +1879,9 @@ static int trace__read_syscall_info(struct trace *trace, int id)
 {
      char tp_name[128];
      struct syscall *sc;
+     int err;
      const char *name = syscalltbl__name(trace->sctbl, id);
+     bool use_btf = false;
 
 #ifdef HAVE_SYSCALL_TABLE_SUPPORT
      if (trace->syscalls.table == NULL) {
@@ -1883,7 +1954,12 @@ static int trace__read_syscall_info(struct trace *trace, int id)
      sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
      sc->is_open = !strcmp(name, "open") || !strcmp(name, "openat");
 
-     return syscall__set_arg_fmts(sc);
+     err = syscall__set_arg_fmts(sc, &use_btf);
+
+     if (use_btf && trace->btf == NULL)
+             trace__load_vmlinux_btf(trace);
+
+     return err;
 }
 
 static int evsel__init_tp_arg_scnprintf(struct evsel *evsel)
@@ -1891,7 +1967,7 @@ static int evsel__init_tp_arg_scnprintf(struct evsel *evsel)
      struct syscall_arg_fmt *fmt = evsel__syscall_arg_fmt(evsel);
 
      if (fmt != NULL) {
-             syscall_arg_fmt__init_array(fmt, evsel->tp_format->format.fields);
+             syscall_arg_fmt__init_array(fmt, evsel->tp_format->format.fields, NULL);
              return 0;
      }
 
@@ -2103,6 +2179,16 @@ static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
                      if (trace->show_arg_names)
                              printed += scnprintf(bf + printed, size - printed, "%s: ", field->name);
 
Quoted 16 lines
Quoted 14 lines
tools/perf/builtin-trace.c +10 -1
+                     if (sc->arg_fmt[arg.idx].is_enum && trace->btf) {
+                             size_t p = btf_enum_scnprintf(bf + printed, size - printed, val,
+                                                           trace->btf, field->type,
+                                                           &sc->arg_fmt[arg.idx]);
+                             if (p) {
+                                     printed += p;
+                                     continue;
+                             }
+                     }
+
                      printed += syscall_arg_fmt__scnprintf_val(&sc->arg_fmt[arg.idx],
                                                                bf + printed, size - printed, &arg, val);
              }
--
Quoted 2 lines

2.45.2

Thanks,
Howard

#7 lore raw

Re: [PATCH v2 2/5] perf trace: Augment enum syscall arguments with BTF

Quoted 11 lines · Howard Chu

Hello,

The fixes are on the perf-tools-next branch at:
https://github.com/Sberm/linux.git

please use

```
git pull https://github.com/Sberm/linux.git perf-tools-next
```

I'm no git expert so please tell me if something is wrong.

So, you combined everything into just one patch and there is no commit log message, I'll see if I can redo it from the last broken out patch series you submitted.

- Arnaldo

Quoted 380 lines

P.S. not my proudest patch, changed too many things, might be buggy. If there're bugs please let me know.

Quoted 376 lines · Howard Chu

Hello Arnaldo,

Thanks for the review, the code is refined based on your comments. There is just a little thing:

Quoted 140 lines · Howard Chu

Hello,

Thanks for the in-depth review.

Quoted 73 lines · Arnaldo Carvalho de Melo
Quoted 71 lines · Howard Chu

This is a feature implemented on the basis of the previous bug fix
https://lore.kernel.org/linux-perf-users/[email protected]/T/#t

In this patch, BTF is used to turn enum value to the corresponding enum variable name. There is only one system call that uses enum value as its argument, that is landlock_add_rule().

The vmlinux btf is loaded lazily, when user decided to trace the landlock_add_rule syscall. But if one decides to run perf trace without any arguments, the behaviour is to trace landlock_add_rule, so vmlinux btf will be loaded by default.

before:

```
perf $ ./perf trace -e landlock_add_rule
     0.000 ( 0.008 ms): ldlck-test/438194 landlock_add_rule(rule_type: 2)                                       = -1 EBADFD (File descriptor in bad state)
     0.010 ( 0.001 ms): ldlck-test/438194 landlock_add_rule(rule_type: 1)                                       = -1 EBADFD (File descriptor in bad state)
```

after:

```
perf $ ./perf trace -e landlock_add_rule
     0.000 ( 0.029 ms): ldlck-test/438194 landlock_add_rule(rule_type: LANDLOCK_RULE_NET_PORT)                  = -1 EBADFD (File descriptor in bad state)
     0.036 ( 0.004 ms): ldlck-test/438194 landlock_add_rule(rule_type: LANDLOCK_RULE_PATH_BENEATH)              = -1 EBADFD (File descriptor in bad state)
```
---
 tools/perf/builtin-trace.c | 96 ++++++++++++++++++++++++++++++++++++--
 1 file changed, 91 insertions(+), 5 deletions(-)
tools/perf/builtin-trace.c +7 -0
index c4fa8191253d..d93f34e9af74 100644
@@ -19,6 +19,7 @@
 #ifdef HAVE_LIBBPF_SUPPORT
 #include <bpf/bpf.h>
 #include <bpf/libbpf.h>
+#include <bpf/btf.h>
 #ifdef HAVE_BPF_SKEL
 #include "bpf_skel/augmented_raw_syscalls.skel.h"
 #endif
@@ -110,6 +111,11 @@ struct syscall_arg_fmt {
      const char *name;
      u16        nr_entries; // for arrays
      bool       show_zero;
+     bool       is_enum;
+     struct {
+             void    *entries;
+             u16     nr_entries;
+     }          btf_entry;
 };
 
 struct syscall_fmt {
@@ -140,6 +146,7 @@ struct trace {
 #ifdef HAVE_BPF_SKEL
      struct augmented_raw_syscalls_bpf *skel;
 #endif
+     struct btf              *btf;
      struct record_opts      opts;
      struct evlist   *evlist;
      struct machine          *host;
@@ -897,6 +904,56 @@ static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size,
          .strtoul    = STUL_STRARRAY_FLAGS, \
          .parm       = &strarray__##array, }
 
Quoted 13 lines

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 916

Quoted 10 lines
tools/perf/builtin-trace.c +10 -0
+static int btf_enum_find_entry(struct btf *btf, char *type, struct syscall_arg_fmt *arg_fmt)
+{
+     const struct btf_type *bt;
+     char enum_prefix[][16] = { "enum", "const enum" }, *ep;
+     int id;
+     size_t i;
+
+     for (i = 0; i < ARRAY_SIZE(enum_prefix); i++) {
+             ep = enum_prefix[i];
+             if (strlen(type) > strlen(ep) + 1 && strstarts(type, ep))

No need for the strlen test? I.e. plain using strstarts() should be enough?

Agree. Thanks for pointing that out. Although if string 'type' is 'enum' and prefix is 'enum', strstarts() will be true, but to do 'type += strlen(ep) + 1', and then access 'type', might give us an out-of-range access, but I don't think 'type' will ever be just 'enum' or 'const enum', so I'll delete it then.

Quoted 13 lines

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 925

Quoted 10 lines
tools/perf/builtin-trace.c +9 -0
+                     type += strlen(ep) + 1;
+     }
+
+     id = btf__find_by_name(btf, type);
+     if (id < 0)
+             return -1;
+
+     bt = btf__type_by_id(btf, id);
+     if (bt == NULL)

a pr_debug() stating that something that tracefs says should be in BTF and isn't found there seems to be of value here.

Sure.

Quoted 24 lines
Quoted 11 lines
tools/perf/builtin-trace.c +10 -0
+             return -1;
+
+     arg_fmt->btf_entry.entries    = btf_enum(bt);
+     arg_fmt->btf_entry.nr_entries = btf_vlen(bt);
+
+     return 0;
+}
+
+static size_t btf_enum_scnprintf(char *bf, size_t size, int val, struct btf *btf, char *type,
+                              struct syscall_arg_fmt *arg_fmt)

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 945

Quoted 10 lines
tools/perf/builtin-trace.c +10 -0
+{
+     struct btf_enum *be;
+     int i;
+
+     /* if btf_entry is NULL, find and save it to arg_fmt */
+     if (arg_fmt->btf_entry.entries == NULL)
+             if (btf_enum_find_entry(btf, type, arg_fmt))
+                     return 0;
+
+     be = (struct btf_enum *)arg_fmt->btf_entry.entries;
        struct btf_enum *be = (struct btf_enum *)arg_fmt->btf_entry.entries;
Quoted 13 lines
Quoted 4 lines

arg_fmt->btf_entry.entries is (void *), so we don't need the (struct
btf_enum *) cast here, removing it makes the code more compact. And since we move the declaration to the same line, the info about its type is there as well.

Sure, thanks.

Quoted 6 lines

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 947

Quoted 3 lines
tools/perf/builtin-trace.c +2 -0
+
+     for (i = 0; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {
        for (int i = 0; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {

I did this, it's all good. But here:

for (i = 0, be = arg_fmt->btf_entry.entries; i <
arg_fmt->btf_entry.nr_entries; ++i, ++be) {

I can't do

for (int i = 0, struct btf_enum *be = arg_fmt->btf_entry.entries; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {

The compiler will show errors:

builtin-trace.c: In function ‘btf_enum_scnprintf’:
builtin-trace.c:996:25: error: expected identifier or ‘(’ before ‘struct’
996 | for (int i = 0, struct btf_enum *be =
arg_fmt->btf_entry.entries; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {
| ^~~~~~
builtin-trace.c:996:117: error: ‘be’ undeclared (first use in this function); did you mean ‘bf’?
996 | for (int i = 0, struct btf_enum *be =
arg_fmt->btf_entry.entries; i < arg_fmt->btf_entry.nr_entries; ++i,

++be) {
      |
                                                     ^~
      |
                                                     bf

builtin-trace.c:996:117: note: each undeclared identifier is reported only once for each function it appears in

This is not good either:

for (int i = 0, be = arg_fmt->btf_entry.entries; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {

builtin-trace.c: In function ‘btf_enum_scnprintf’:
builtin-trace.c:998:25: error: declaration of ‘be’ shadows a previous local [-Werror=shadow]
998 | for (int i = 0, be = arg_fmt->btf_entry.entries; i <
arg_fmt->btf_entry.nr_entries; ++i, ++be) {
| ^~
builtin-trace.c:991:26: note: shadowed declaration is here
991 | struct btf_enum *be;
| ^~
builtin-trace.c:998:30: error: initialization of ‘int’ from ‘void *’ makes integer from pointer without a cast [-Wint-conversion]
998 | for (int i = 0, be = arg_fmt->btf_entry.entries; i <
arg_fmt->btf_entry.nr_entries; ++i, ++be) {
| ^~~~~~~

But I can do:

```
be = arg_fmt->btf_entry.entries;

for (int i = 0; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {
```

Thanks,
Howard

Quoted 153 lines
Quoted 7 lines

⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' tools/perf/ | wc -l 99
⬢[acme@toolbox perf-tools-next]$

Doing it this way makes the code more compact and is allowed even in kernel code since some time ago:

Sure.

Quoted 52 lines

⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' drivers/ | wc -l 294
⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' kernel/ | wc -l 12
⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' net/ | wc -l 3
⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' mm/ | wc -l 21
⬢[acme@toolbox perf-tools-next]$

Quoted 41 lines
tools/perf/builtin-trace.c +19 -1
+             if (be->val == val) {
+                     return scnprintf(bf, size, "%s",
+                                      btf__name_by_offset(btf, be->name_off));
+             }
+     }
+
+     return 0;
+}
+
 #include "trace/beauty/arch_errno_names.c"
 #include "trace/beauty/eventfd.c"
 #include "trace/beauty/futex_op.c"
@@ -1699,6 +1756,15 @@ static void trace__symbols__exit(struct trace *trace)
      symbol__exit();
 }
 
+static void trace__load_vmlinux_btf(struct trace *trace)
+{
+     trace->btf = btf__load_vmlinux_btf();
+     if (verbose > 0) {
+             fprintf(trace->output, trace->btf ? "vmlinux BTF loaded\n" :
+                                                 "Failed to load vmlinux BTF\n");
+     }
+}
+
 static int syscall__alloc_arg_fmts(struct syscall *sc, int nr_args)
 {
      int idx;
@@ -1744,7 +1810,7 @@ static const struct syscall_arg_fmt *syscall_arg_fmt__find_by_name(const char *n
 }
 
 static struct tep_format_field *
-syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field *field)
+syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field *field, bool *use_btf)
 {
      struct tep_format_field *last_field = NULL;
      int len;
@@ -1782,6 +1848,8 @@ syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field
                       * 7 unsigned long
                       */
                      arg->scnprintf = SCA_FD;
Quoted 8 lines

tools/perf/builtin-trace.c syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field · line 1852

Quoted 2 lines
tools/perf/builtin-trace.c +2 -0
+             } else if (strstr(field->type, "enum") && use_btf != NULL) {
+                     *use_btf = arg->is_enum = true;

Here you have to check if use_btf is NULL, as you, in this patch, later call syscall_arg_fmt__init_array(arg, field, NULL) in evsel__init_tp_arg_scnprintf(), probably you tested it all at the end of the patch series, we have to make sure that it works after each patch, so that we keep the codebase bisectable.

I'm sorry, could you enlighten me on this? I thought:

```
else if (strstr(field->type, "enum") && use_btf != NULL) {
```

is doing the NULL checking. If you mean making sure the NULL checking appears in all patches, I thought this is where we should introduce the checking. Tiny reminder, the [1/5] patch is your syscalltbl traversal bug fix.

Quoted 54 lines
Quoted 54 lines
tools/perf/builtin-trace.c +12 -4
              } else {
                      const struct syscall_arg_fmt *fmt =
                              syscall_arg_fmt__find_by_name(field->name);
@@ -1796,9 +1864,10 @@ syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field
      return last_field;
 }
 
-static int syscall__set_arg_fmts(struct syscall *sc)
+static int syscall__set_arg_fmts(struct syscall *sc, bool *use_btf)
 {
-     struct tep_format_field *last_field = syscall_arg_fmt__init_array(sc->arg_fmt, sc->args);
+     struct tep_format_field *last_field = syscall_arg_fmt__init_array(sc->arg_fmt, sc->args,
+                                                                       use_btf);
 
      if (last_field)
              sc->args_size = last_field->offset + last_field->size;
@@ -1810,7 +1879,9 @@ static int trace__read_syscall_info(struct trace *trace, int id)
 {
      char tp_name[128];
      struct syscall *sc;
+     int err;
      const char *name = syscalltbl__name(trace->sctbl, id);
+     bool use_btf = false;
 
 #ifdef HAVE_SYSCALL_TABLE_SUPPORT
      if (trace->syscalls.table == NULL) {
@@ -1883,7 +1954,12 @@ static int trace__read_syscall_info(struct trace *trace, int id)
      sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
      sc->is_open = !strcmp(name, "open") || !strcmp(name, "openat");
 
-     return syscall__set_arg_fmts(sc);
+     err = syscall__set_arg_fmts(sc, &use_btf);
+
+     if (use_btf && trace->btf == NULL)
+             trace__load_vmlinux_btf(trace);
+
+     return err;
 }
 
 static int evsel__init_tp_arg_scnprintf(struct evsel *evsel)
@@ -1891,7 +1967,7 @@ static int evsel__init_tp_arg_scnprintf(struct evsel *evsel)
      struct syscall_arg_fmt *fmt = evsel__syscall_arg_fmt(evsel);
 
      if (fmt != NULL) {
-             syscall_arg_fmt__init_array(fmt, evsel->tp_format->format.fields);
+             syscall_arg_fmt__init_array(fmt, evsel->tp_format->format.fields, NULL);
              return 0;
      }
 
@@ -2103,6 +2179,16 @@ static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
                      if (trace->show_arg_names)
                              printed += scnprintf(bf + printed, size - printed, "%s: ", field->name);
 
Quoted 16 lines
Quoted 14 lines
tools/perf/builtin-trace.c +10 -1
+                     if (sc->arg_fmt[arg.idx].is_enum && trace->btf) {
+                             size_t p = btf_enum_scnprintf(bf + printed, size - printed, val,
+                                                           trace->btf, field->type,
+                                                           &sc->arg_fmt[arg.idx]);
+                             if (p) {
+                                     printed += p;
+                                     continue;
+                             }
+                     }
+
                      printed += syscall_arg_fmt__scnprintf_val(&sc->arg_fmt[arg.idx],
                                                                bf + printed, size - printed, &arg, val);
              }
--
Quoted 2 lines

2.45.2

Thanks,
Howard

author
#8 lore raw

Re: [PATCH v2 2/5] perf trace: Augment enum syscall arguments with BTF

Hello Arnaldo,

I think I need to add some explanations here, for the all-in-one patch that I have on the tree.

Firstly, no use_btf is passed when constructing syscall argument format. We just write is_enum when the type is enum. This is because we don't load btf when we are constructing the formats, we load vmlinux when a tracepoint hits.

before:

} else if (strstr(field->type, "enum") && use_btf != NULL) { *use_btf = arg->is_enum = true;

after:

} else if (strstr(field->type, "enum")) {
arg->is_enum = true;

Another confusing place is when we do the filtering. When a user passes an enum name, say --filter="mode==HRTIMER_MODE_ABS", we do not know what 'HRTIMER_MODE_ABS' means. For this case, we have to load the vmlinux BTF, and match the strings to get a value, not delaying till a tracepoint hits.

Next thing is, for this section in trace__expand_filter():

```
struct btf_parm bparm;

if (fmt->is_enum) {
    if (trace->btf == NULL)
        trace__load_vmlinux_btf(trace);

    /* btf could be NULL */
    bparm.btf  = trace->btf;
    bparm.type = type;
    syscall_arg.parm = &bparm;
}
```

I don't handle the return value of trace__load_vmlinux_btf(), because I want to make the latter " if (fmt->strtoul(right, right_size, &syscall_arg, &val)) {
" evaluated to be false, so that we can fall into the else block, therefore prints the pr_err of no resolver. This could be confusing.

pr_err("No resolver (strtoul) for \"%s\" in \"%s\", can't set filter \"%s\"\n",

       arg, evsel->name, evsel->filter);

return -1;

And another confusing part is, originally we discard 0 value for enum arguments, now with enum aug, printed a 0-value enum makes sense, therefore these lines:

if (val == 0 && !trace->show_zeros &&

    !(sc->arg_fmt && sc->arg_fmt[arg.idx].show_zero))
#ifdef HAVE_LIBBPF_SUPPORT
        if (!(sc->arg_fmt && sc->arg_fmt[arg.idx].is_enum))
#endif
        continue;

It suits as an &&, I don't know if it's the best way to do it.

That's it for all, thank you for finding time in your busy schedule to review my code. I'll develop my skills to do self-checks in the future,

Thanks,
Howard

Quoted 400 lines · Arnaldo Carvalho de Melo
Quoted 11 lines · Howard Chu

Hello,

The fixes are on the perf-tools-next branch at:
https://github.com/Sberm/linux.git

please use

```
git pull https://github.com/Sberm/linux.git perf-tools-next
```

I'm no git expert so please tell me if something is wrong.

So, you combined everything into just one patch and there is no commit log message, I'll see if I can redo it from the last broken out patch series you submitted.

- Arnaldo

Quoted 380 lines

P.S. not my proudest patch, changed too many things, might be buggy. If there're bugs please let me know.

Quoted 376 lines · Howard Chu

Hello Arnaldo,

Thanks for the review, the code is refined based on your comments. There is just a little thing:

Quoted 140 lines · Howard Chu

Hello,

Thanks for the in-depth review.

Quoted 73 lines · Arnaldo Carvalho de Melo
Quoted 71 lines · Howard Chu

This is a feature implemented on the basis of the previous bug fix
https://lore.kernel.org/linux-perf-users/[email protected]/T/#t

In this patch, BTF is used to turn enum value to the corresponding enum variable name. There is only one system call that uses enum value as its argument, that is landlock_add_rule().

The vmlinux btf is loaded lazily, when user decided to trace the landlock_add_rule syscall. But if one decides to run perf trace without any arguments, the behaviour is to trace landlock_add_rule, so vmlinux btf will be loaded by default.

before:

```
perf $ ./perf trace -e landlock_add_rule
     0.000 ( 0.008 ms): ldlck-test/438194 landlock_add_rule(rule_type: 2)                                       = -1 EBADFD (File descriptor in bad state)
     0.010 ( 0.001 ms): ldlck-test/438194 landlock_add_rule(rule_type: 1)                                       = -1 EBADFD (File descriptor in bad state)
```

after:

```
perf $ ./perf trace -e landlock_add_rule
     0.000 ( 0.029 ms): ldlck-test/438194 landlock_add_rule(rule_type: LANDLOCK_RULE_NET_PORT)                  = -1 EBADFD (File descriptor in bad state)
     0.036 ( 0.004 ms): ldlck-test/438194 landlock_add_rule(rule_type: LANDLOCK_RULE_PATH_BENEATH)              = -1 EBADFD (File descriptor in bad state)
```
---
 tools/perf/builtin-trace.c | 96 ++++++++++++++++++++++++++++++++++++--
 1 file changed, 91 insertions(+), 5 deletions(-)
tools/perf/builtin-trace.c +7 -0
index c4fa8191253d..d93f34e9af74 100644
@@ -19,6 +19,7 @@
 #ifdef HAVE_LIBBPF_SUPPORT
 #include <bpf/bpf.h>
 #include <bpf/libbpf.h>
+#include <bpf/btf.h>
 #ifdef HAVE_BPF_SKEL
 #include "bpf_skel/augmented_raw_syscalls.skel.h"
 #endif
@@ -110,6 +111,11 @@ struct syscall_arg_fmt {
      const char *name;
      u16        nr_entries; // for arrays
      bool       show_zero;
+     bool       is_enum;
+     struct {
+             void    *entries;
+             u16     nr_entries;
+     }          btf_entry;
 };
 
 struct syscall_fmt {
@@ -140,6 +146,7 @@ struct trace {
 #ifdef HAVE_BPF_SKEL
      struct augmented_raw_syscalls_bpf *skel;
 #endif
+     struct btf              *btf;
      struct record_opts      opts;
      struct evlist   *evlist;
      struct machine          *host;
@@ -897,6 +904,56 @@ static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size,
          .strtoul    = STUL_STRARRAY_FLAGS, \
          .parm       = &strarray__##array, }
 
Quoted 13 lines

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 916

Quoted 10 lines
tools/perf/builtin-trace.c +10 -0
+static int btf_enum_find_entry(struct btf *btf, char *type, struct syscall_arg_fmt *arg_fmt)
+{
+     const struct btf_type *bt;
+     char enum_prefix[][16] = { "enum", "const enum" }, *ep;
+     int id;
+     size_t i;
+
+     for (i = 0; i < ARRAY_SIZE(enum_prefix); i++) {
+             ep = enum_prefix[i];
+             if (strlen(type) > strlen(ep) + 1 && strstarts(type, ep))

No need for the strlen test? I.e. plain using strstarts() should be enough?

Agree. Thanks for pointing that out. Although if string 'type' is 'enum' and prefix is 'enum', strstarts() will be true, but to do 'type += strlen(ep) + 1', and then access 'type', might give us an out-of-range access, but I don't think 'type' will ever be just 'enum' or 'const enum', so I'll delete it then.

Quoted 13 lines

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 925

Quoted 10 lines
tools/perf/builtin-trace.c +9 -0
+                     type += strlen(ep) + 1;
+     }
+
+     id = btf__find_by_name(btf, type);
+     if (id < 0)
+             return -1;
+
+     bt = btf__type_by_id(btf, id);
+     if (bt == NULL)

a pr_debug() stating that something that tracefs says should be in BTF and isn't found there seems to be of value here.

Sure.

Quoted 24 lines
Quoted 11 lines
tools/perf/builtin-trace.c +10 -0
+             return -1;
+
+     arg_fmt->btf_entry.entries    = btf_enum(bt);
+     arg_fmt->btf_entry.nr_entries = btf_vlen(bt);
+
+     return 0;
+}
+
+static size_t btf_enum_scnprintf(char *bf, size_t size, int val, struct btf *btf, char *type,
+                              struct syscall_arg_fmt *arg_fmt)

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 945

Quoted 10 lines
tools/perf/builtin-trace.c +10 -0
+{
+     struct btf_enum *be;
+     int i;
+
+     /* if btf_entry is NULL, find and save it to arg_fmt */
+     if (arg_fmt->btf_entry.entries == NULL)
+             if (btf_enum_find_entry(btf, type, arg_fmt))
+                     return 0;
+
+     be = (struct btf_enum *)arg_fmt->btf_entry.entries;
        struct btf_enum *be = (struct btf_enum *)arg_fmt->btf_entry.entries;
Quoted 13 lines
Quoted 4 lines

arg_fmt->btf_entry.entries is (void *), so we don't need the (struct
btf_enum *) cast here, removing it makes the code more compact. And since we move the declaration to the same line, the info about its type is there as well.

Sure, thanks.

Quoted 6 lines

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 947

Quoted 3 lines
tools/perf/builtin-trace.c +2 -0
+
+     for (i = 0; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {
        for (int i = 0; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {

I did this, it's all good. But here:

for (i = 0, be = arg_fmt->btf_entry.entries; i <
arg_fmt->btf_entry.nr_entries; ++i, ++be) {

I can't do

for (int i = 0, struct btf_enum *be = arg_fmt->btf_entry.entries; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {

The compiler will show errors:

builtin-trace.c: In function ‘btf_enum_scnprintf’:
builtin-trace.c:996:25: error: expected identifier or ‘(’ before ‘struct’
996 | for (int i = 0, struct btf_enum *be =
arg_fmt->btf_entry.entries; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {
| ^~~~~~
builtin-trace.c:996:117: error: ‘be’ undeclared (first use in this function); did you mean ‘bf’?
996 | for (int i = 0, struct btf_enum *be =
arg_fmt->btf_entry.entries; i < arg_fmt->btf_entry.nr_entries; ++i,

++be) {
      |
                                                     ^~
      |
                                                     bf

builtin-trace.c:996:117: note: each undeclared identifier is reported only once for each function it appears in

This is not good either:

for (int i = 0, be = arg_fmt->btf_entry.entries; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {

builtin-trace.c: In function ‘btf_enum_scnprintf’:
builtin-trace.c:998:25: error: declaration of ‘be’ shadows a previous local [-Werror=shadow]
998 | for (int i = 0, be = arg_fmt->btf_entry.entries; i <
arg_fmt->btf_entry.nr_entries; ++i, ++be) {
| ^~
builtin-trace.c:991:26: note: shadowed declaration is here
991 | struct btf_enum *be;
| ^~
builtin-trace.c:998:30: error: initialization of ‘int’ from ‘void *’ makes integer from pointer without a cast [-Wint-conversion]
998 | for (int i = 0, be = arg_fmt->btf_entry.entries; i <
arg_fmt->btf_entry.nr_entries; ++i, ++be) {
| ^~~~~~~

But I can do:

```
be = arg_fmt->btf_entry.entries;

for (int i = 0; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {
```

Thanks,
Howard

Quoted 153 lines
Quoted 7 lines

⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' tools/perf/ | wc -l 99
⬢[acme@toolbox perf-tools-next]$

Doing it this way makes the code more compact and is allowed even in kernel code since some time ago:

Sure.

Quoted 52 lines

⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' drivers/ | wc -l 294
⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' kernel/ | wc -l 12
⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' net/ | wc -l 3
⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' mm/ | wc -l 21
⬢[acme@toolbox perf-tools-next]$

Quoted 41 lines
tools/perf/builtin-trace.c +19 -1
+             if (be->val == val) {
+                     return scnprintf(bf, size, "%s",
+                                      btf__name_by_offset(btf, be->name_off));
+             }
+     }
+
+     return 0;
+}
+
 #include "trace/beauty/arch_errno_names.c"
 #include "trace/beauty/eventfd.c"
 #include "trace/beauty/futex_op.c"
@@ -1699,6 +1756,15 @@ static void trace__symbols__exit(struct trace *trace)
      symbol__exit();
 }
 
+static void trace__load_vmlinux_btf(struct trace *trace)
+{
+     trace->btf = btf__load_vmlinux_btf();
+     if (verbose > 0) {
+             fprintf(trace->output, trace->btf ? "vmlinux BTF loaded\n" :
+                                                 "Failed to load vmlinux BTF\n");
+     }
+}
+
 static int syscall__alloc_arg_fmts(struct syscall *sc, int nr_args)
 {
      int idx;
@@ -1744,7 +1810,7 @@ static const struct syscall_arg_fmt *syscall_arg_fmt__find_by_name(const char *n
 }
 
 static struct tep_format_field *
-syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field *field)
+syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field *field, bool *use_btf)
 {
      struct tep_format_field *last_field = NULL;
      int len;
@@ -1782,6 +1848,8 @@ syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field
                       * 7 unsigned long
                       */
                      arg->scnprintf = SCA_FD;
Quoted 8 lines

tools/perf/builtin-trace.c syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field · line 1852

Quoted 2 lines
tools/perf/builtin-trace.c +2 -0
+             } else if (strstr(field->type, "enum") && use_btf != NULL) {
+                     *use_btf = arg->is_enum = true;

Here you have to check if use_btf is NULL, as you, in this patch, later call syscall_arg_fmt__init_array(arg, field, NULL) in evsel__init_tp_arg_scnprintf(), probably you tested it all at the end of the patch series, we have to make sure that it works after each patch, so that we keep the codebase bisectable.

I'm sorry, could you enlighten me on this? I thought:

```
else if (strstr(field->type, "enum") && use_btf != NULL) {
```

is doing the NULL checking. If you mean making sure the NULL checking appears in all patches, I thought this is where we should introduce the checking. Tiny reminder, the [1/5] patch is your syscalltbl traversal bug fix.

Quoted 54 lines
Quoted 54 lines
tools/perf/builtin-trace.c +12 -4
              } else {
                      const struct syscall_arg_fmt *fmt =
                              syscall_arg_fmt__find_by_name(field->name);
@@ -1796,9 +1864,10 @@ syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field
      return last_field;
 }
 
-static int syscall__set_arg_fmts(struct syscall *sc)
+static int syscall__set_arg_fmts(struct syscall *sc, bool *use_btf)
 {
-     struct tep_format_field *last_field = syscall_arg_fmt__init_array(sc->arg_fmt, sc->args);
+     struct tep_format_field *last_field = syscall_arg_fmt__init_array(sc->arg_fmt, sc->args,
+                                                                       use_btf);
 
      if (last_field)
              sc->args_size = last_field->offset + last_field->size;
@@ -1810,7 +1879,9 @@ static int trace__read_syscall_info(struct trace *trace, int id)
 {
      char tp_name[128];
      struct syscall *sc;
+     int err;
      const char *name = syscalltbl__name(trace->sctbl, id);
+     bool use_btf = false;
 
 #ifdef HAVE_SYSCALL_TABLE_SUPPORT
      if (trace->syscalls.table == NULL) {
@@ -1883,7 +1954,12 @@ static int trace__read_syscall_info(struct trace *trace, int id)
      sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
      sc->is_open = !strcmp(name, "open") || !strcmp(name, "openat");
 
-     return syscall__set_arg_fmts(sc);
+     err = syscall__set_arg_fmts(sc, &use_btf);
+
+     if (use_btf && trace->btf == NULL)
+             trace__load_vmlinux_btf(trace);
+
+     return err;
 }
 
 static int evsel__init_tp_arg_scnprintf(struct evsel *evsel)
@@ -1891,7 +1967,7 @@ static int evsel__init_tp_arg_scnprintf(struct evsel *evsel)
      struct syscall_arg_fmt *fmt = evsel__syscall_arg_fmt(evsel);
 
      if (fmt != NULL) {
-             syscall_arg_fmt__init_array(fmt, evsel->tp_format->format.fields);
+             syscall_arg_fmt__init_array(fmt, evsel->tp_format->format.fields, NULL);
              return 0;
      }
 
@@ -2103,6 +2179,16 @@ static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
                      if (trace->show_arg_names)
                              printed += scnprintf(bf + printed, size - printed, "%s: ", field->name);
 
Quoted 16 lines
Quoted 14 lines
tools/perf/builtin-trace.c +10 -1
+                     if (sc->arg_fmt[arg.idx].is_enum && trace->btf) {
+                             size_t p = btf_enum_scnprintf(bf + printed, size - printed, val,
+                                                           trace->btf, field->type,
+                                                           &sc->arg_fmt[arg.idx]);
+                             if (p) {
+                                     printed += p;
+                                     continue;
+                             }
+                     }
+
                      printed += syscall_arg_fmt__scnprintf_val(&sc->arg_fmt[arg.idx],
                                                                bf + printed, size - printed, &arg, val);
              }
--
Quoted 2 lines

2.45.2

Thanks,
Howard

#9 lore raw

Re: [PATCH v2 2/5] perf trace: Augment enum syscall arguments with BTF

Quoted 17 lines · Howard Chu

Hello Arnaldo,

I think I need to add some explanations here, for the all-in-one patch that I have on the tree.

Firstly, no use_btf is passed when constructing syscall argument format. We just write is_enum when the type is enum. This is because we don't load btf when we are constructing the formats, we load vmlinux when a tracepoint hits.

before:

} else if (strstr(field->type, "enum") && use_btf != NULL) { *use_btf = arg->is_enum = true;

after:

Quoted 8 lines

} else if (strstr(field->type, "enum")) {
arg->is_enum = true;

Another confusing place is when we do the filtering. When a user passes an enum name, say --filter="mode==HRTIMER_MODE_ABS", we do not know what 'HRTIMER_MODE_ABS' means. For this case, we have to load the vmlinux BTF, and match the strings to get a value, not delaying till a tracepoint hits.

Right, I worked on your latest series before the combined patch, and to solve that at filter expansion time, I did:

@@ -3861,9 +3903,16 @@ static int trace__expand_filter(struct trace *trace __maybe_unused, struct evsel

                        if (fmt->strtoul) {
                                u64 val;
                                struct syscall_arg syscall_arg = {
-                                       .parm = fmt->parm,
+                                       .trace = trace,
+                                       .fmt   = fmt,
                                };

+ if (fmt->is_enum) {
+ syscall_arg.parm = type;
+ } else {
+ syscall_arg.parm = fmt->parm;
+ }
+

                                if (fmt->strtoul(right, right_size, &syscall_arg, &val)) {

And then in the enum btf strtoul we can load the btf:

+static bool syscall_arg__strtoul_btf_enum(char *bf, size_t size, struct syscall_arg *arg, u64 *val) +{

+       const struct btf_type *bt;
+       char *type = arg->parm;
+       struct btf_enum *be;
+       struct btf *btf;

+
+ trace__load_vmlinux_btf(arg->trace);
+
+ btf = arg->trace->btf;
+ if (btf == NULL)
+ return false;
+
+ if (syscall_arg_fmt__cache_btf_enum(arg->fmt, btf, type) < 0)
+ return false;
+

+       bt = arg->fmt->type;
+       be = btf_enum(bt);
+       for (int i = 0; i < btf_vlen(bt); ++i, ++be) {

+ const char *name = btf__name_by_offset(btf, be->name_off);
+ int max_len = max(size, strlen(name));
+
+ if (strncmp(name, bf, max_len) == 0) {
+ *val = be->val;
+ return true;
+ }
+ }
+
+ return false;
+}

And:

+static int syscall_arg_fmt__cache_btf_enum(struct syscall_arg_fmt *arg_fmt, struct btf *btf, char *type) +{
+ int id;
+
+ // Already cached?
+ if (arg_fmt->type != NULL)
+ return 0;
+
+ type = strstr(type, "enum ");
+ if (type == NULL)
+ return -1;
+
+ type += 5; // skip "enum " to get the enumeration name
+
+ id = btf__find_by_name(btf, type);
+ if (id < 0)
+ return -1;
+
+ arg_fmt->type = btf__type_by_id(btf, id);
+ return arg_fmt->type == NULL ? -1 : 0;
+}

So that in all cases we do the lookup for the BTF enum type just once and cache it in the syscall_arg_fmt->type.

Quoted 30 lines

Next thing is, for this section in trace__expand_filter():

```
struct btf_parm bparm;

if (fmt->is_enum) {
    if (trace->btf == NULL)
        trace__load_vmlinux_btf(trace);

    /* btf could be NULL */
    bparm.btf  = trace->btf;
    bparm.type = type;
    syscall_arg.parm = &bparm;
}
```

I don't handle the return value of trace__load_vmlinux_btf(), because I want to make the latter " if (fmt->strtoul(right, right_size, &syscall_arg, &val)) {
" evaluated to be false, so that we can fall into the else block, therefore prints the pr_err of no resolver. This could be confusing.

pr_err("No resolver (strtoul) for \"%s\" in \"%s\", can't set filter \"%s\"\n",

       arg, evsel->name, evsel->filter);

return -1;

And another confusing part is, originally we discard 0 value for enum arguments, now with enum aug, printed a 0-value enum makes sense, therefore these lines:

Quoted 8 lines

if (val == 0 && !trace->show_zeros &&

    !(sc->arg_fmt && sc->arg_fmt[arg.idx].show_zero))
#ifdef HAVE_LIBBPF_SUPPORT
        if (!(sc->arg_fmt && sc->arg_fmt[arg.idx].is_enum))
#endif
        continue;

It suits as an &&, I don't know if it's the best way to do it.

Excellent observation, that show_zero needs to be conditional on non-BTF enum augmentation, i.e. if we're going to just print a zero and 'perf trace' is configured not to show it but we are printing the enum entry, then we should not consider that .show_zero setting. But this can be done as a follow up patch to reduce the size of this one.

Quoted 409 lines

That's it for all, thank you for finding time in your busy schedule to review my code. I'll develop my skills to do self-checks in the future,

Thanks,
Howard

Quoted 400 lines · Arnaldo Carvalho de Melo
Quoted 11 lines · Howard Chu

Hello,

The fixes are on the perf-tools-next branch at:
https://github.com/Sberm/linux.git

please use

```
git pull https://github.com/Sberm/linux.git perf-tools-next
```

I'm no git expert so please tell me if something is wrong.

So, you combined everything into just one patch and there is no commit log message, I'll see if I can redo it from the last broken out patch series you submitted.

- Arnaldo

Quoted 380 lines

P.S. not my proudest patch, changed too many things, might be buggy. If there're bugs please let me know.

Quoted 376 lines · Howard Chu

Hello Arnaldo,

Thanks for the review, the code is refined based on your comments. There is just a little thing:

Quoted 140 lines · Howard Chu

Hello,

Thanks for the in-depth review.

Quoted 73 lines · Arnaldo Carvalho de Melo
Quoted 71 lines · Howard Chu

This is a feature implemented on the basis of the previous bug fix
https://lore.kernel.org/linux-perf-users/[email protected]/T/#t

In this patch, BTF is used to turn enum value to the corresponding enum variable name. There is only one system call that uses enum value as its argument, that is landlock_add_rule().

The vmlinux btf is loaded lazily, when user decided to trace the landlock_add_rule syscall. But if one decides to run perf trace without any arguments, the behaviour is to trace landlock_add_rule, so vmlinux btf will be loaded by default.

before:

```
perf $ ./perf trace -e landlock_add_rule
     0.000 ( 0.008 ms): ldlck-test/438194 landlock_add_rule(rule_type: 2)                                       = -1 EBADFD (File descriptor in bad state)
     0.010 ( 0.001 ms): ldlck-test/438194 landlock_add_rule(rule_type: 1)                                       = -1 EBADFD (File descriptor in bad state)
```

after:

```
perf $ ./perf trace -e landlock_add_rule
     0.000 ( 0.029 ms): ldlck-test/438194 landlock_add_rule(rule_type: LANDLOCK_RULE_NET_PORT)                  = -1 EBADFD (File descriptor in bad state)
     0.036 ( 0.004 ms): ldlck-test/438194 landlock_add_rule(rule_type: LANDLOCK_RULE_PATH_BENEATH)              = -1 EBADFD (File descriptor in bad state)
```
---
 tools/perf/builtin-trace.c | 96 ++++++++++++++++++++++++++++++++++++--
 1 file changed, 91 insertions(+), 5 deletions(-)
tools/perf/builtin-trace.c +7 -0
index c4fa8191253d..d93f34e9af74 100644
@@ -19,6 +19,7 @@
 #ifdef HAVE_LIBBPF_SUPPORT
 #include <bpf/bpf.h>
 #include <bpf/libbpf.h>
+#include <bpf/btf.h>
 #ifdef HAVE_BPF_SKEL
 #include "bpf_skel/augmented_raw_syscalls.skel.h"
 #endif
@@ -110,6 +111,11 @@ struct syscall_arg_fmt {
      const char *name;
      u16        nr_entries; // for arrays
      bool       show_zero;
+     bool       is_enum;
+     struct {
+             void    *entries;
+             u16     nr_entries;
+     }          btf_entry;
 };
 
 struct syscall_fmt {
@@ -140,6 +146,7 @@ struct trace {
 #ifdef HAVE_BPF_SKEL
      struct augmented_raw_syscalls_bpf *skel;
 #endif
+     struct btf              *btf;
      struct record_opts      opts;
      struct evlist   *evlist;
      struct machine          *host;
@@ -897,6 +904,56 @@ static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size,
          .strtoul    = STUL_STRARRAY_FLAGS, \
          .parm       = &strarray__##array, }
 
Quoted 13 lines

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 916

Quoted 10 lines
tools/perf/builtin-trace.c +10 -0
+static int btf_enum_find_entry(struct btf *btf, char *type, struct syscall_arg_fmt *arg_fmt)
+{
+     const struct btf_type *bt;
+     char enum_prefix[][16] = { "enum", "const enum" }, *ep;
+     int id;
+     size_t i;
+
+     for (i = 0; i < ARRAY_SIZE(enum_prefix); i++) {
+             ep = enum_prefix[i];
+             if (strlen(type) > strlen(ep) + 1 && strstarts(type, ep))

No need for the strlen test? I.e. plain using strstarts() should be enough?

Agree. Thanks for pointing that out. Although if string 'type' is 'enum' and prefix is 'enum', strstarts() will be true, but to do 'type += strlen(ep) + 1', and then access 'type', might give us an out-of-range access, but I don't think 'type' will ever be just 'enum' or 'const enum', so I'll delete it then.

Quoted 13 lines

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 925

Quoted 10 lines
tools/perf/builtin-trace.c +9 -0
+                     type += strlen(ep) + 1;
+     }
+
+     id = btf__find_by_name(btf, type);
+     if (id < 0)
+             return -1;
+
+     bt = btf__type_by_id(btf, id);
+     if (bt == NULL)

a pr_debug() stating that something that tracefs says should be in BTF and isn't found there seems to be of value here.

Sure.

Quoted 24 lines
Quoted 11 lines
tools/perf/builtin-trace.c +10 -0
+             return -1;
+
+     arg_fmt->btf_entry.entries    = btf_enum(bt);
+     arg_fmt->btf_entry.nr_entries = btf_vlen(bt);
+
+     return 0;
+}
+
+static size_t btf_enum_scnprintf(char *bf, size_t size, int val, struct btf *btf, char *type,
+                              struct syscall_arg_fmt *arg_fmt)

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 945

Quoted 10 lines
tools/perf/builtin-trace.c +10 -0
+{
+     struct btf_enum *be;
+     int i;
+
+     /* if btf_entry is NULL, find and save it to arg_fmt */
+     if (arg_fmt->btf_entry.entries == NULL)
+             if (btf_enum_find_entry(btf, type, arg_fmt))
+                     return 0;
+
+     be = (struct btf_enum *)arg_fmt->btf_entry.entries;
        struct btf_enum *be = (struct btf_enum *)arg_fmt->btf_entry.entries;
Quoted 13 lines
Quoted 4 lines

arg_fmt->btf_entry.entries is (void *), so we don't need the (struct
btf_enum *) cast here, removing it makes the code more compact. And since we move the declaration to the same line, the info about its type is there as well.

Sure, thanks.

Quoted 6 lines

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 947

Quoted 3 lines
tools/perf/builtin-trace.c +2 -0
+
+     for (i = 0; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {
        for (int i = 0; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {

I did this, it's all good. But here:

for (i = 0, be = arg_fmt->btf_entry.entries; i <
arg_fmt->btf_entry.nr_entries; ++i, ++be) {

I can't do

for (int i = 0, struct btf_enum *be = arg_fmt->btf_entry.entries; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {

The compiler will show errors:

builtin-trace.c: In function ‘btf_enum_scnprintf’:
builtin-trace.c:996:25: error: expected identifier or ‘(’ before ‘struct’
996 | for (int i = 0, struct btf_enum *be =
arg_fmt->btf_entry.entries; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {
| ^~~~~~
builtin-trace.c:996:117: error: ‘be’ undeclared (first use in this function); did you mean ‘bf’?
996 | for (int i = 0, struct btf_enum *be =
arg_fmt->btf_entry.entries; i < arg_fmt->btf_entry.nr_entries; ++i,

++be) {
      |
                                                     ^~
      |
                                                     bf

builtin-trace.c:996:117: note: each undeclared identifier is reported only once for each function it appears in

This is not good either:

for (int i = 0, be = arg_fmt->btf_entry.entries; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {

builtin-trace.c: In function ‘btf_enum_scnprintf’:
builtin-trace.c:998:25: error: declaration of ‘be’ shadows a previous local [-Werror=shadow]
998 | for (int i = 0, be = arg_fmt->btf_entry.entries; i <
arg_fmt->btf_entry.nr_entries; ++i, ++be) {
| ^~
builtin-trace.c:991:26: note: shadowed declaration is here
991 | struct btf_enum *be;
| ^~
builtin-trace.c:998:30: error: initialization of ‘int’ from ‘void *’ makes integer from pointer without a cast [-Wint-conversion]
998 | for (int i = 0, be = arg_fmt->btf_entry.entries; i <
arg_fmt->btf_entry.nr_entries; ++i, ++be) {
| ^~~~~~~

But I can do:

```
be = arg_fmt->btf_entry.entries;

for (int i = 0; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {
```

Thanks,
Howard

Quoted 153 lines
Quoted 7 lines

⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' tools/perf/ | wc -l 99
⬢[acme@toolbox perf-tools-next]$

Doing it this way makes the code more compact and is allowed even in kernel code since some time ago:

Sure.

Quoted 52 lines

⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' drivers/ | wc -l 294
⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' kernel/ | wc -l 12
⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' net/ | wc -l 3
⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' mm/ | wc -l 21
⬢[acme@toolbox perf-tools-next]$

Quoted 41 lines
tools/perf/builtin-trace.c +19 -1
+             if (be->val == val) {
+                     return scnprintf(bf, size, "%s",
+                                      btf__name_by_offset(btf, be->name_off));
+             }
+     }
+
+     return 0;
+}
+
 #include "trace/beauty/arch_errno_names.c"
 #include "trace/beauty/eventfd.c"
 #include "trace/beauty/futex_op.c"
@@ -1699,6 +1756,15 @@ static void trace__symbols__exit(struct trace *trace)
      symbol__exit();
 }
 
+static void trace__load_vmlinux_btf(struct trace *trace)
+{
+     trace->btf = btf__load_vmlinux_btf();
+     if (verbose > 0) {
+             fprintf(trace->output, trace->btf ? "vmlinux BTF loaded\n" :
+                                                 "Failed to load vmlinux BTF\n");
+     }
+}
+
 static int syscall__alloc_arg_fmts(struct syscall *sc, int nr_args)
 {
      int idx;
@@ -1744,7 +1810,7 @@ static const struct syscall_arg_fmt *syscall_arg_fmt__find_by_name(const char *n
 }
 
 static struct tep_format_field *
-syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field *field)
+syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field *field, bool *use_btf)
 {
      struct tep_format_field *last_field = NULL;
      int len;
@@ -1782,6 +1848,8 @@ syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field
                       * 7 unsigned long
                       */
                      arg->scnprintf = SCA_FD;
Quoted 8 lines

tools/perf/builtin-trace.c syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field · line 1852

Quoted 2 lines
tools/perf/builtin-trace.c +2 -0
+             } else if (strstr(field->type, "enum") && use_btf != NULL) {
+                     *use_btf = arg->is_enum = true;

Here you have to check if use_btf is NULL, as you, in this patch, later call syscall_arg_fmt__init_array(arg, field, NULL) in evsel__init_tp_arg_scnprintf(), probably you tested it all at the end of the patch series, we have to make sure that it works after each patch, so that we keep the codebase bisectable.

I'm sorry, could you enlighten me on this? I thought:

```
else if (strstr(field->type, "enum") && use_btf != NULL) {
```

is doing the NULL checking. If you mean making sure the NULL checking appears in all patches, I thought this is where we should introduce the checking. Tiny reminder, the [1/5] patch is your syscalltbl traversal bug fix.

Quoted 54 lines
Quoted 54 lines
tools/perf/builtin-trace.c +12 -4
              } else {
                      const struct syscall_arg_fmt *fmt =
                              syscall_arg_fmt__find_by_name(field->name);
@@ -1796,9 +1864,10 @@ syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field
      return last_field;
 }
 
-static int syscall__set_arg_fmts(struct syscall *sc)
+static int syscall__set_arg_fmts(struct syscall *sc, bool *use_btf)
 {
-     struct tep_format_field *last_field = syscall_arg_fmt__init_array(sc->arg_fmt, sc->args);
+     struct tep_format_field *last_field = syscall_arg_fmt__init_array(sc->arg_fmt, sc->args,
+                                                                       use_btf);
 
      if (last_field)
              sc->args_size = last_field->offset + last_field->size;
@@ -1810,7 +1879,9 @@ static int trace__read_syscall_info(struct trace *trace, int id)
 {
      char tp_name[128];
      struct syscall *sc;
+     int err;
      const char *name = syscalltbl__name(trace->sctbl, id);
+     bool use_btf = false;
 
 #ifdef HAVE_SYSCALL_TABLE_SUPPORT
      if (trace->syscalls.table == NULL) {
@@ -1883,7 +1954,12 @@ static int trace__read_syscall_info(struct trace *trace, int id)
      sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
      sc->is_open = !strcmp(name, "open") || !strcmp(name, "openat");
 
-     return syscall__set_arg_fmts(sc);
+     err = syscall__set_arg_fmts(sc, &use_btf);
+
+     if (use_btf && trace->btf == NULL)
+             trace__load_vmlinux_btf(trace);
+
+     return err;
 }
 
 static int evsel__init_tp_arg_scnprintf(struct evsel *evsel)
@@ -1891,7 +1967,7 @@ static int evsel__init_tp_arg_scnprintf(struct evsel *evsel)
      struct syscall_arg_fmt *fmt = evsel__syscall_arg_fmt(evsel);
 
      if (fmt != NULL) {
-             syscall_arg_fmt__init_array(fmt, evsel->tp_format->format.fields);
+             syscall_arg_fmt__init_array(fmt, evsel->tp_format->format.fields, NULL);
              return 0;
      }
 
@@ -2103,6 +2179,16 @@ static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
                      if (trace->show_arg_names)
                              printed += scnprintf(bf + printed, size - printed, "%s: ", field->name);
 
Quoted 16 lines
Quoted 14 lines
tools/perf/builtin-trace.c +10 -1
+                     if (sc->arg_fmt[arg.idx].is_enum && trace->btf) {
+                             size_t p = btf_enum_scnprintf(bf + printed, size - printed, val,
+                                                           trace->btf, field->type,
+                                                           &sc->arg_fmt[arg.idx]);
+                             if (p) {
+                                     printed += p;
+                                     continue;
+                             }
+                     }
+
                      printed += syscall_arg_fmt__scnprintf_val(&sc->arg_fmt[arg.idx],
                                                                bf + printed, size - printed, &arg, val);
              }
--
Quoted 2 lines

2.45.2

Thanks,
Howard

author
#10 lore raw

Re: [PATCH v2 2/5] perf trace: Augment enum syscall arguments with BTF

Hello Arnaldo,

Your changes are very very good, thank you so much.

Quoted 88 lines · Arnaldo Carvalho de Melo
Quoted 17 lines · Howard Chu

Hello Arnaldo,

I think I need to add some explanations here, for the all-in-one patch that I have on the tree.

Firstly, no use_btf is passed when constructing syscall argument format. We just write is_enum when the type is enum. This is because we don't load btf when we are constructing the formats, we load vmlinux when a tracepoint hits.

before:

} else if (strstr(field->type, "enum") && use_btf != NULL) { *use_btf = arg->is_enum = true;

after:

Quoted 8 lines

} else if (strstr(field->type, "enum")) {
arg->is_enum = true;

Another confusing place is when we do the filtering. When a user passes an enum name, say --filter="mode==HRTIMER_MODE_ABS", we do not know what 'HRTIMER_MODE_ABS' means. For this case, we have to load the vmlinux BTF, and match the strings to get a value, not delaying till a tracepoint hits.

Right, I worked on your latest series before the combined patch, and to solve that at filter expansion time, I did:

(quoted diff) +8 -1
@@ -3861,9 +3903,16 @@ static int trace__expand_filter(struct trace *trace __maybe_unused, struct evsel
                        if (fmt->strtoul) {
                                u64 val;
                                struct syscall_arg syscall_arg = {
-                                       .parm = fmt->parm,
+                                       .trace = trace,
+                                       .fmt   = fmt,
                                };
 
+                               if (fmt->is_enum) {
+                                       syscall_arg.parm = type;
+                               } else {
+                                       syscall_arg.parm = fmt->parm;
+                               }
+
                                if (fmt->strtoul(right, right_size, &syscall_arg, &val)) {
 
 

And then in the enum btf strtoul we can load the btf:

(quoted diff) +30 -0
+static bool syscall_arg__strtoul_btf_enum(char *bf, size_t size, struct syscall_arg *arg, u64 *val)
+{
+       const struct btf_type *bt;
+       char *type = arg->parm;
+       struct btf_enum *be;
+       struct btf *btf;
+
+       trace__load_vmlinux_btf(arg->trace);
+
+       btf = arg->trace->btf;
+       if (btf == NULL)
+               return false;
+
+       if (syscall_arg_fmt__cache_btf_enum(arg->fmt, btf, type) < 0)
+               return false;
+
+       bt = arg->fmt->type;
+       be = btf_enum(bt);
+       for (int i = 0; i < btf_vlen(bt); ++i, ++be) {
+               const char *name = btf__name_by_offset(btf, be->name_off);
+               int max_len = max(size, strlen(name));
+
+               if (strncmp(name, bf, max_len) == 0) {
+                       *val = be->val;
+                       return true;
+               }
+       }
+
+       return false;
+}

And:

(quoted diff) +4 -0
+static int syscall_arg_fmt__cache_btf_enum(struct syscall_arg_fmt *arg_fmt, struct btf *btf, char *type)
+{
+       int id;
+

Review

Quoted 10 lines
(quoted diff) +10 -0
+       // Already cached?
+       if (arg_fmt->type != NULL)
+               return 0;
+
+       type = strstr(type, "enum ");
+       if (type == NULL)
+               return -1;
+
+       type += 5; // skip "enum " to get the enumeration name
+

The shifting of enum name before doing btf__type_by_id() is handled perfectly. And the extra wrapper function trace__btf_scnprintf() makes a lot of sense.

Just two tiny little things:

1) the make NO_LIBBPF=1 and make NO_LIBELF=1 won't build

builtin-trace.c: In function ‘syscall__scnprintf_args’:
builtin-trace.c:2258:28: error: expected expression before ‘)’ token

 2258 |                            )
      |                            ^

if (val == 0 && !trace->show_zeros &&

    !(sc->arg_fmt && sc->arg_fmt[arg.idx].show_zero) &&
#ifdef HAVE_LIBBPF_SUPPORT
    !(sc->arg_fmt && sc->arg_fmt[arg.idx].strtoul == STUL_BTF_TYPE)
#endif
   )
        continue;

The fix is simple, just change the above to:

if (val == 0 && !trace->show_zeros &&

    !(sc->arg_fmt && sc->arg_fmt[arg.idx].show_zero)
#ifdef HAVE_LIBBPF_SUPPORT
    && !(sc->arg_fmt && sc->arg_fmt[arg.idx].strtoul == STUL_BTF_TYPE)
#endif
   )
        continue;

2) In this version, we won't defer the loading of vmlinux BTF till an enum-augmentable tracepoint hits. I'm sure you made this conscious change, not that there's anything wrong with it, just want to point it out for clarity.

Overall, it is a great revision. Man, what can I say, this patch is better, simpler and it handles details very well. Thank you so much for doing this.

Thanks,
Howard

#11 lore raw

Re: [PATCH v2 2/5] perf trace: Augment enum syscall arguments with BTF

In reply to Howard Chu
Quoted 93 lines · Howard Chu

Hello,

Thanks for the in-depth review.

Quoted 73 lines · Arnaldo Carvalho de Melo
Quoted 71 lines · Howard Chu

This is a feature implemented on the basis of the previous bug fix
https://lore.kernel.org/linux-perf-users/[email protected]/T/#t

In this patch, BTF is used to turn enum value to the corresponding enum variable name. There is only one system call that uses enum value as its argument, that is landlock_add_rule().

The vmlinux btf is loaded lazily, when user decided to trace the landlock_add_rule syscall. But if one decides to run perf trace without any arguments, the behaviour is to trace landlock_add_rule, so vmlinux btf will be loaded by default.

before:

```
perf $ ./perf trace -e landlock_add_rule
     0.000 ( 0.008 ms): ldlck-test/438194 landlock_add_rule(rule_type: 2)                                       = -1 EBADFD (File descriptor in bad state)
     0.010 ( 0.001 ms): ldlck-test/438194 landlock_add_rule(rule_type: 1)                                       = -1 EBADFD (File descriptor in bad state)
```

after:

```
perf $ ./perf trace -e landlock_add_rule
     0.000 ( 0.029 ms): ldlck-test/438194 landlock_add_rule(rule_type: LANDLOCK_RULE_NET_PORT)                  = -1 EBADFD (File descriptor in bad state)
     0.036 ( 0.004 ms): ldlck-test/438194 landlock_add_rule(rule_type: LANDLOCK_RULE_PATH_BENEATH)              = -1 EBADFD (File descriptor in bad state)
```
---
 tools/perf/builtin-trace.c | 96 ++++++++++++++++++++++++++++++++++++--
 1 file changed, 91 insertions(+), 5 deletions(-)
tools/perf/builtin-trace.c +7 -0
index c4fa8191253d..d93f34e9af74 100644
@@ -19,6 +19,7 @@
 #ifdef HAVE_LIBBPF_SUPPORT
 #include <bpf/bpf.h>
 #include <bpf/libbpf.h>
+#include <bpf/btf.h>
 #ifdef HAVE_BPF_SKEL
 #include "bpf_skel/augmented_raw_syscalls.skel.h"
 #endif
@@ -110,6 +111,11 @@ struct syscall_arg_fmt {
      const char *name;
      u16        nr_entries; // for arrays
      bool       show_zero;
+     bool       is_enum;
+     struct {
+             void    *entries;
+             u16     nr_entries;
+     }          btf_entry;
 };
 
 struct syscall_fmt {
@@ -140,6 +146,7 @@ struct trace {
 #ifdef HAVE_BPF_SKEL
      struct augmented_raw_syscalls_bpf *skel;
 #endif
+     struct btf              *btf;
      struct record_opts      opts;
      struct evlist   *evlist;
      struct machine          *host;
@@ -897,6 +904,56 @@ static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size,
          .strtoul    = STUL_STRARRAY_FLAGS, \
          .parm       = &strarray__##array, }
 
Quoted 13 lines

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 916

Quoted 10 lines
tools/perf/builtin-trace.c +10 -0
+static int btf_enum_find_entry(struct btf *btf, char *type, struct syscall_arg_fmt *arg_fmt)
+{
+     const struct btf_type *bt;
+     char enum_prefix[][16] = { "enum", "const enum" }, *ep;
+     int id;
+     size_t i;
+
+     for (i = 0; i < ARRAY_SIZE(enum_prefix); i++) {
+             ep = enum_prefix[i];
+             if (strlen(type) > strlen(ep) + 1 && strstarts(type, ep))

No need for the strlen test? I.e. plain using strstarts() should be enough?

Quoted 5 lines

Agree. Thanks for pointing that out. Although if string 'type' is 'enum' and prefix is 'enum', strstarts() will be true, but to do 'type += strlen(ep) + 1', and then access 'type', might give us an out-of-range access, but I don't think 'type' will ever be just 'enum' or 'const enum', so I'll delete it then.

So, I did some changes to this patch to fix some issues:

1) We need to make this conditional on libbpf being available, i.e. we need to build with 'make NO_LIBBPF=1' so I had to add some ifdefs for HAVE_LIBBPF_SUPPORT, and moved some checks for trace->btf to the functions where it is used, so that we can pass just 'trace'.

2) syscall_arg_fmt->btf_entry became just syscall_arg_fmt->type, a 'struct btf_type' pointer, this way we can have:

#ifdef HAVE_LIBBPF_SUPPORT
static int syscall_arg_fmt__cache_btf_enum(struct syscall_arg_fmt *arg_fmt, struct btf *btf, char *type)

{
	int id;

	type = strstr(type, "enum ");
	if (type == NULL)
		return -1;

	type += 5; // skip "enum " to get the enumeration name

	id = btf__find_by_name(btf, type);
	if (id < 0)
		return -1;

	arg_fmt->type = btf__type_by_id(btf, id);
	return arg_fmt->type == NULL ? -1 : 0;
}

static size_t btf_enum_scnprintf(const struct btf_type *type, struct btf *btf, char *bf, size_t size, int val)

{
	struct btf_enum *be = btf_enum(type);
	const int nr_entries = btf_vlen(type);

	for (int i = 0; i < nr_entries; ++i, ++be) {
		if (be->val == val) {
			return scnprintf(bf, size, "%s",
					 btf__name_by_offset(btf, be->name_off));
		}
	}

	return 0;
}

static size_t trace__btf_enum_scnprintf(struct trace *trace, struct syscall_arg_fmt *arg_fmt, char *bf,
size_t size, int val, char *type)

{
	if (trace->btf == NULL)
		return 0;
	/* if btf_entry is NULL, find and save it to arg_fmt */
	if (arg_fmt->type == NULL &&
	    syscall_arg_fmt__cache_btf_enum(arg_fmt, trace->btf, type) < 0)
		return 0;

	return btf_enum_scnprintf(arg_fmt->type, trace->btf, bf, size, val);
}

#else // HAVE_LIBBPF_SUPPORT
static size_t trace__btf_enum_scnprintf(struct trace *trace __maybe_unused, struct syscall_arg_fmt *arg_fmt __maybe_unused,
char *bf __maybe_unused, size_t size __maybe_unused, int val __maybe_unused, char *type __maybe_unused)

{
	return 0;
}

#endif // HAVE_LIBBPF_SUPPORT

The patch on top of yours is attached. I'll fixup the following ones and have them in a branch for you to check and see if you agree with the changes.

- Arnaldo

Quoted 124 lines
Quoted 13 lines

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 925

Quoted 10 lines
tools/perf/builtin-trace.c +9 -0
+                     type += strlen(ep) + 1;
+     }
+
+     id = btf__find_by_name(btf, type);
+     if (id < 0)
+             return -1;
+
+     bt = btf__type_by_id(btf, id);
+     if (bt == NULL)

a pr_debug() stating that something that tracefs says should be in BTF and isn't found there seems to be of value here.

Sure.

Quoted 24 lines
Quoted 11 lines
tools/perf/builtin-trace.c +10 -0
+             return -1;
+
+     arg_fmt->btf_entry.entries    = btf_enum(bt);
+     arg_fmt->btf_entry.nr_entries = btf_vlen(bt);
+
+     return 0;
+}
+
+static size_t btf_enum_scnprintf(char *bf, size_t size, int val, struct btf *btf, char *type,
+                              struct syscall_arg_fmt *arg_fmt)

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 945

Quoted 10 lines
tools/perf/builtin-trace.c +10 -0
+{
+     struct btf_enum *be;
+     int i;
+
+     /* if btf_entry is NULL, find and save it to arg_fmt */
+     if (arg_fmt->btf_entry.entries == NULL)
+             if (btf_enum_find_entry(btf, type, arg_fmt))
+                     return 0;
+
+     be = (struct btf_enum *)arg_fmt->btf_entry.entries;
        struct btf_enum *be = (struct btf_enum *)arg_fmt->btf_entry.entries;
Quoted 4 lines

arg_fmt->btf_entry.entries is (void *), so we don't need the (struct
btf_enum *) cast here, removing it makes the code more compact. And since we move the declaration to the same line, the info about its type is there as well.

Sure, thanks.

Quoted 5 lines

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 947

Quoted 3 lines
tools/perf/builtin-trace.c +2 -0
+
+     for (i = 0; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {
Quoted 8 lines
        for (int i = 0; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {

⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' tools/perf/ | wc -l 99
⬢[acme@toolbox perf-tools-next]$

Doing it this way makes the code more compact and is allowed even in kernel code since some time ago:

Sure.

Quoted 52 lines

⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' drivers/ | wc -l 294
⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' kernel/ | wc -l 12
⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' net/ | wc -l 3
⬢[acme@toolbox perf-tools-next]$ git grep 'for (int ' mm/ | wc -l 21
⬢[acme@toolbox perf-tools-next]$

Quoted 41 lines
tools/perf/builtin-trace.c +19 -1
+             if (be->val == val) {
+                     return scnprintf(bf, size, "%s",
+                                      btf__name_by_offset(btf, be->name_off));
+             }
+     }
+
+     return 0;
+}
+
 #include "trace/beauty/arch_errno_names.c"
 #include "trace/beauty/eventfd.c"
 #include "trace/beauty/futex_op.c"
@@ -1699,6 +1756,15 @@ static void trace__symbols__exit(struct trace *trace)
      symbol__exit();
 }
 
+static void trace__load_vmlinux_btf(struct trace *trace)
+{
+     trace->btf = btf__load_vmlinux_btf();
+     if (verbose > 0) {
+             fprintf(trace->output, trace->btf ? "vmlinux BTF loaded\n" :
+                                                 "Failed to load vmlinux BTF\n");
+     }
+}
+
 static int syscall__alloc_arg_fmts(struct syscall *sc, int nr_args)
 {
      int idx;
@@ -1744,7 +1810,7 @@ static const struct syscall_arg_fmt *syscall_arg_fmt__find_by_name(const char *n
 }
 
 static struct tep_format_field *
-syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field *field)
+syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field *field, bool *use_btf)
 {
      struct tep_format_field *last_field = NULL;
      int len;
@@ -1782,6 +1848,8 @@ syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field
                       * 7 unsigned long
                       */
                      arg->scnprintf = SCA_FD;
Quoted 8 lines

tools/perf/builtin-trace.c syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field · line 1852

Quoted 2 lines
tools/perf/builtin-trace.c +2 -0
+             } else if (strstr(field->type, "enum") && use_btf != NULL) {
+                     *use_btf = arg->is_enum = true;

Here you have to check if use_btf is NULL, as you, in this patch, later call syscall_arg_fmt__init_array(arg, field, NULL) in evsel__init_tp_arg_scnprintf(), probably you tested it all at the end of the patch series, we have to make sure that it works after each patch, so that we keep the codebase bisectable.

Quoted 8 lines

I'm sorry, could you enlighten me on this? I thought:

```
else if (strstr(field->type, "enum") && use_btf != NULL) {
```

is doing the NULL checking. If you mean making sure the NULL checking appears in all patches, I thought this is where we should introduce the checking. Tiny reminder, the [1/5] patch is your syscalltbl traversal bug fix.

scrap my comment, was a brain fart ;-/ of course you are alreadyu checking if use_btf is NULL, doh.

Quoted 65 lines
Quoted 65 lines
Quoted 65 lines
tools/perf/builtin-trace.c +22 -4
              } else {
                      const struct syscall_arg_fmt *fmt =
                              syscall_arg_fmt__find_by_name(field->name);
@@ -1796,9 +1864,10 @@ syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field
      return last_field;
 }
 
-static int syscall__set_arg_fmts(struct syscall *sc)
+static int syscall__set_arg_fmts(struct syscall *sc, bool *use_btf)
 {
-     struct tep_format_field *last_field = syscall_arg_fmt__init_array(sc->arg_fmt, sc->args);
+     struct tep_format_field *last_field = syscall_arg_fmt__init_array(sc->arg_fmt, sc->args,
+                                                                       use_btf);
 
      if (last_field)
              sc->args_size = last_field->offset + last_field->size;
@@ -1810,7 +1879,9 @@ static int trace__read_syscall_info(struct trace *trace, int id)
 {
      char tp_name[128];
      struct syscall *sc;
+     int err;
      const char *name = syscalltbl__name(trace->sctbl, id);
+     bool use_btf = false;
 
 #ifdef HAVE_SYSCALL_TABLE_SUPPORT
      if (trace->syscalls.table == NULL) {
@@ -1883,7 +1954,12 @@ static int trace__read_syscall_info(struct trace *trace, int id)
      sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
      sc->is_open = !strcmp(name, "open") || !strcmp(name, "openat");
 
-     return syscall__set_arg_fmts(sc);
+     err = syscall__set_arg_fmts(sc, &use_btf);
+
+     if (use_btf && trace->btf == NULL)
+             trace__load_vmlinux_btf(trace);
+
+     return err;
 }
 
 static int evsel__init_tp_arg_scnprintf(struct evsel *evsel)
@@ -1891,7 +1967,7 @@ static int evsel__init_tp_arg_scnprintf(struct evsel *evsel)
      struct syscall_arg_fmt *fmt = evsel__syscall_arg_fmt(evsel);
 
      if (fmt != NULL) {
-             syscall_arg_fmt__init_array(fmt, evsel->tp_format->format.fields);
+             syscall_arg_fmt__init_array(fmt, evsel->tp_format->format.fields, NULL);
              return 0;
      }
 
@@ -2103,6 +2179,16 @@ static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
                      if (trace->show_arg_names)
                              printed += scnprintf(bf + printed, size - printed, "%s: ", field->name);
 
+                     if (sc->arg_fmt[arg.idx].is_enum && trace->btf) {
+                             size_t p = btf_enum_scnprintf(bf + printed, size - printed, val,
+                                                           trace->btf, field->type,
+                                                           &sc->arg_fmt[arg.idx]);
+                             if (p) {
+                                     printed += p;
+                                     continue;
+                             }
+                     }
+
                      printed += syscall_arg_fmt__scnprintf_val(&sc->arg_fmt[arg.idx],
Quoted 8 lines
Quoted 5 lines
Quoted 5 lines
tools/perf/builtin-trace.c +0 -1
                                                                bf + printed, size - printed, &arg, val);
              }
--

2.45.2

Thanks,
Howard

tools/perf/builtin-trace.c +50 -39
index 3a1c031aff9ad049..49d99c20b7f711ef 100644
@@ -112,10 +112,9 @@ struct syscall_arg_fmt {
 	u16	   nr_entries; // for arrays
 	bool	   show_zero;
 	bool	   is_enum;
-	struct {
-		void	*entry;
-		u16	nr_entries;
-	}	   btf_entry;
+#ifdef HAVE_LIBBPF_SUPPORT
+	const struct btf_type *type;
+#endif
 };
 
 struct syscall_fmt {
@@ -146,7 +145,9 @@ struct trace {
 #ifdef HAVE_BPF_SKEL
 	struct augmented_raw_syscalls_bpf *skel;
 #endif
+#ifdef HAVE_LIBBPF_SUPPORT
 	struct btf		*btf;
+#endif
 	struct record_opts	opts;
 	struct evlist	*evlist;
 	struct machine		*host;
@@ -894,47 +895,32 @@ static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size,
 
 #define SCA_GETRANDOM_FLAGS syscall_arg__scnprintf_getrandom_flags
 
-static int btf_enum_find_entry(struct btf *btf, char *type, struct syscall_arg_fmt *arg_fmt)
+#ifdef HAVE_LIBBPF_SUPPORT
+static int syscall_arg_fmt__cache_btf_enum(struct syscall_arg_fmt *arg_fmt, struct btf *btf, char *type)
 {
-	const struct btf_type *bt;
-	char enum_prefix[][16] = { "enum", "const enum" }, *ep;
 	int id;
-	size_t i;
 
-	for (i = 0; i < ARRAY_SIZE(enum_prefix); i++) {
-		ep = enum_prefix[i];
-		if (strlen(type) > strlen(ep) + 1 && strstarts(type, ep))
-			type += strlen(ep) + 1;
-	}
+	type = strstr(type, "enum ");
+	if (type == NULL)
+		return -1;
+
+	type += 5; // skip "enum " to get the enumeration name
 
 	id = btf__find_by_name(btf, type);
 	if (id < 0)
 		return -1;
 
-	bt = btf__type_by_id(btf, id);
-	if (bt == NULL)
-		return -1;
-
-	arg_fmt->btf_entry.entry      = btf_enum(bt);
-	arg_fmt->btf_entry.nr_entries = btf_vlen(bt);
-
-	return 0;
+	arg_fmt->type = btf__type_by_id(btf, id);
+	return arg_fmt->type == NULL ? -1 : 0;
 }
 
-static size_t btf_enum_scnprintf(char *bf, size_t size, int val, struct btf *btf, char *type,
-				 struct syscall_arg_fmt *arg_fmt)
-{
-	struct btf_enum *be;
-	int i;
-
-	/* if btf_entry is NULL, find and save it to arg_fmt */
-	if (arg_fmt->btf_entry.entry == NULL)
-		if (btf_enum_find_entry(btf, type, arg_fmt))
-			return 0;
 
-	be = (struct btf_enum *)arg_fmt->btf_entry.entry;
+static size_t btf_enum_scnprintf(const struct btf_type *type, struct btf *btf, char *bf, size_t size, int val)
+{
+	struct btf_enum *be = btf_enum(type);
+	const int nr_entries = btf_vlen(type);
 
-	for (i = 0; i < arg_fmt->btf_entry.nr_entries; ++i, ++be) {
+	for (int i = 0; i < nr_entries; ++i, ++be) {
 		if (be->val == val) {
 			return scnprintf(bf, size, "%s",
 					 btf__name_by_offset(btf, be->name_off));
@@ -944,6 +930,27 @@ static size_t btf_enum_scnprintf(char *bf, size_t size, int val, struct btf *btf
 	return 0;
 }
 
+static size_t trace__btf_enum_scnprintf(struct trace *trace, struct syscall_arg_fmt *arg_fmt, char *bf,
+					size_t size, int val, char *type)
+{
+	if (trace->btf == NULL)
+		return 0;
+	/* if btf_entry is NULL, find and save it to arg_fmt */
+	if (arg_fmt->type == NULL &&
+	    syscall_arg_fmt__cache_btf_enum(arg_fmt, trace->btf, type) < 0)
+		return 0;
+
+	return btf_enum_scnprintf(arg_fmt->type, trace->btf, bf, size, val);
+}
+#else // HAVE_LIBBPF_SUPPORT
+static size_t trace__btf_enum_scnprintf(struct trace *trace __maybe_unused, struct syscall_arg_fmt *arg_fmt __maybe_unused,
+					char *bf __maybe_unused, size_t size __maybe_unused, int val __maybe_unused,
+					char *type __maybe_unused)
+{
+	return 0;
+}
+#endif // HAVE_LIBBPF_SUPPORT
+
 #define STRARRAY(name, array) \
 	  { .scnprintf	= SCA_STRARRAY, \
 	    .strtoul	= STUL_STRARRAY, \
@@ -1757,13 +1764,18 @@ static void trace__symbols__exit(struct trace *trace)
 	symbol__exit();
 }
 
-static void trace__load_vmlinux_btf(struct trace *trace)
+static void trace__load_vmlinux_btf(struct trace *trace __maybe_unused)
 {
+#ifdef HAVE_LIBBPF_SUPPORT
+	if (trace->btf != NULL)
+		return;
+
 	trace->btf = btf__load_vmlinux_btf();
 	if (verbose > 0) {
 		fprintf(trace->output, trace->btf ? "vmlinux BTF loaded\n" :
 						    "Failed to load vmlinux BTF\n");
 	}
+#endif
 }
 
 static int syscall__alloc_arg_fmts(struct syscall *sc, int nr_args)
@@ -1959,7 +1971,7 @@ static int trace__read_syscall_info(struct trace *trace, int id)
 	err = syscall__set_arg_fmts(sc);
 
 	/* after calling syscall__set_arg_fmts() we'll know whether use_btf is true */
-	if (sc->use_btf && trace->btf == NULL)
+	if (sc->use_btf)
 		trace__load_vmlinux_btf(trace);
 
 	return err;
@@ -2182,10 +2194,9 @@ static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
 			if (trace->show_arg_names)
 				printed += scnprintf(bf + printed, size - printed, "%s: ", field->name);
 
-			if (sc->arg_fmt[arg.idx].is_enum && trace->btf) {
-				size_t p = btf_enum_scnprintf(bf + printed, size - printed, val,
-							      trace->btf, field->type,
-							      &sc->arg_fmt[arg.idx]);
+			if (sc->arg_fmt[arg.idx].is_enum) {
+				size_t p = trace__btf_enum_scnprintf(trace, &sc->arg_fmt[arg.idx], bf + printed,
+								     size - printed, val, field->type);
 				if (p) {
 					printed += p;
 					continue;
author
#12 lore raw

PATCH v2 3/5 perf trace: Augment enum tracepoint arguments with BTF

In reply to Howard Chu

Before:

perf $ ./perf trace -e timer:hrtimer_start --max-events=1

     0.000 :0/0 timer:hrtimer_start(hrtimer: 0xffff974466c25f18, function: 0xffffffff89da5be0, expires: 377432432256753, softexpires: 377432432256753, mode: 10)

After:

perf $ ./perf trace -e timer:hrtimer_start --max-events=1

     0.000 :0/0 timer:hrtimer_start(hrtimer: 0xffff974466d25f18, function: 0xffffffff89da5be0, expires: 488283834504945, softexpires: 488283834504945, mode: HRTIMER_MODE_ABS_PINNED_HARD)

HRTIMER_MODE_ABS_PINNED_HARD is:

perf $ pahole hrtimer_mode
enum hrtimer_mode {

        HRTIMER_MODE_ABS             = 0,
        HRTIMER_MODE_REL             = 1,
        HRTIMER_MODE_PINNED          = 2,
        HRTIMER_MODE_SOFT            = 4,
        HRTIMER_MODE_HARD            = 8,
        HRTIMER_MODE_ABS_PINNED      = 2,
        HRTIMER_MODE_REL_PINNED      = 3,
        HRTIMER_MODE_ABS_SOFT        = 4,
        HRTIMER_MODE_REL_SOFT        = 5,

HRTIMER_MODE_ABS_PINNED_SOFT = 6,
HRTIMER_MODE_REL_PINNED_SOFT = 7,
HRTIMER_MODE_ABS_HARD = 8,
HRTIMER_MODE_REL_HARD = 9,
HRTIMER_MODE_ABS_PINNED_HARD = 10,
HRTIMER_MODE_REL_PINNED_HARD = 11,
};

Can also be tested by

./perf trace -e pagemap:mm_lru_insertion,timer:hrtimer_start,timer:hrtimer_init,skb:kfree_skb --max-events=10

(Chose these 4 events because they happen quite frequently.)

However some enum arguments may not be contained in vmlinux BTF. To see what enum arguments are supported, use:

vmlinux_dir $ bpftool btf dump file /sys/kernel/btf/vmlinux > vmlinux

vmlinux_dir $ while read l; do grep "ENUM '$l'" vmlinux; done < <(grep field:enum /sys/kernel/tracing/events/*/*/format | awk '{print $3}' | sort | uniq) | awk '{print $3}' | sed "s/'\(.*\)'/\1/g" dev_pm_qos_req_type
error_detector
hrtimer_mode
i2c_slave_event
ieee80211_bss_type
lru_list
migrate_mode
nl80211_auth_type
nl80211_band
nl80211_iftype
numa_vmaskip_reason
pm_qos_req_action
pwm_polarity
skb_drop_reason
thermal_trip_type
xen_lazy_mode
xen_mc_extend_args
xen_mc_flush_reason
zone_type

And what tracepoints have these enum types as their arguments:

vmlinux_dir $ while read l; do grep "ENUM '$l'" vmlinux; done < <(grep field:enum /sys/kernel/tracing/events/*/*/format | awk '{print $3}' | sort | uniq) | awk '{print $3}' | sed "s/'\(.*\)'/\1/g" > good_enums

vmlinux_dir $ cat good_enums
dev_pm_qos_req_type
error_detector
hrtimer_mode
i2c_slave_event
ieee80211_bss_type
lru_list
migrate_mode
nl80211_auth_type
nl80211_band
nl80211_iftype
numa_vmaskip_reason
pm_qos_req_action
pwm_polarity
skb_drop_reason
thermal_trip_type
xen_lazy_mode
xen_mc_extend_args
xen_mc_flush_reason
zone_type

vmlinux_dir $ grep -f good_enums -l /sys/kernel/tracing/events/*/*/format /sys/kernel/tracing/events/cfg80211/cfg80211_chandef_dfs_required/format /sys/kernel/tracing/events/cfg80211/cfg80211_ch_switch_notify/format /sys/kernel/tracing/events/cfg80211/cfg80211_ch_switch_started_notify/format /sys/kernel/tracing/events/cfg80211/cfg80211_get_bss/format /sys/kernel/tracing/events/cfg80211/cfg80211_ibss_joined/format /sys/kernel/tracing/events/cfg80211/cfg80211_inform_bss_frame/format /sys/kernel/tracing/events/cfg80211/cfg80211_radar_event/format /sys/kernel/tracing/events/cfg80211/cfg80211_ready_on_channel_expired/format /sys/kernel/tracing/events/cfg80211/cfg80211_ready_on_channel/format /sys/kernel/tracing/events/cfg80211/cfg80211_reg_can_beacon/format /sys/kernel/tracing/events/cfg80211/cfg80211_return_bss/format /sys/kernel/tracing/events/cfg80211/cfg80211_tx_mgmt_expired/format /sys/kernel/tracing/events/cfg80211/rdev_add_virtual_intf/format /sys/kernel/tracing/events/cfg80211/rdev_auth/format /sys/kernel/tracing/events/cfg80211/rdev_change_virtual_intf/format /sys/kernel/tracing/events/cfg80211/rdev_channel_switch/format /sys/kernel/tracing/events/cfg80211/rdev_connect/format /sys/kernel/tracing/events/cfg80211/rdev_inform_bss/format /sys/kernel/tracing/events/cfg80211/rdev_libertas_set_mesh_channel/format /sys/kernel/tracing/events/cfg80211/rdev_mgmt_tx/format /sys/kernel/tracing/events/cfg80211/rdev_remain_on_channel/format /sys/kernel/tracing/events/cfg80211/rdev_return_chandef/format /sys/kernel/tracing/events/cfg80211/rdev_return_int_survey_info/format /sys/kernel/tracing/events/cfg80211/rdev_set_ap_chanwidth/format /sys/kernel/tracing/events/cfg80211/rdev_set_monitor_channel/format /sys/kernel/tracing/events/cfg80211/rdev_set_radar_background/format /sys/kernel/tracing/events/cfg80211/rdev_start_ap/format /sys/kernel/tracing/events/cfg80211/rdev_start_radar_detection/format /sys/kernel/tracing/events/cfg80211/rdev_tdls_channel_switch/format /sys/kernel/tracing/events/compaction/mm_compaction_defer_compaction/format /sys/kernel/tracing/events/compaction/mm_compaction_deferred/format /sys/kernel/tracing/events/compaction/mm_compaction_defer_reset/format /sys/kernel/tracing/events/compaction/mm_compaction_finished/format /sys/kernel/tracing/events/compaction/mm_compaction_kcompactd_wake/format /sys/kernel/tracing/events/compaction/mm_compaction_suitable/format /sys/kernel/tracing/events/compaction/mm_compaction_wakeup_kcompactd/format /sys/kernel/tracing/events/error_report/error_report_end/format /sys/kernel/tracing/events/i2c_slave/i2c_slave/format /sys/kernel/tracing/events/migrate/mm_migrate_pages/format /sys/kernel/tracing/events/migrate/mm_migrate_pages_start/format /sys/kernel/tracing/events/pagemap/mm_lru_insertion/format /sys/kernel/tracing/events/power/dev_pm_qos_add_request/format /sys/kernel/tracing/events/power/dev_pm_qos_remove_request/format /sys/kernel/tracing/events/power/dev_pm_qos_update_request/format /sys/kernel/tracing/events/power/pm_qos_update_flags/format /sys/kernel/tracing/events/power/pm_qos_update_target/format /sys/kernel/tracing/events/pwm/pwm_apply/format /sys/kernel/tracing/events/pwm/pwm_get/format /sys/kernel/tracing/events/sched/sched_skip_vma_numa/format /sys/kernel/tracing/events/skb/kfree_skb/format /sys/kernel/tracing/events/thermal/thermal_zone_trip/format /sys/kernel/tracing/events/timer/hrtimer_init/format /sys/kernel/tracing/events/timer/hrtimer_start/format /sys/kernel/tracing/events/xen/xen_mc_batch/format /sys/kernel/tracing/events/xen/xen_mc_extend_args/format /sys/kernel/tracing/events/xen/xen_mc_flush_reason/format /sys/kernel/tracing/events/xen/xen_mc_issue/format

---
 tools/perf/builtin-trace.c | 29 ++++++++++++++++++++++-------
 1 file changed, 22 insertions(+), 7 deletions(-)
tools/perf/builtin-trace.c +22 -7
index d93f34e9af74..bd16679fb4c0 100644
@@ -1962,12 +1962,12 @@ static int trace__read_syscall_info(struct trace *trace, int id)
 	return err;
 }
 
-static int evsel__init_tp_arg_scnprintf(struct evsel *evsel)
+static int evsel__init_tp_arg_scnprintf(struct evsel *evsel, bool *use_btf)
 {
 	struct syscall_arg_fmt *fmt = evsel__syscall_arg_fmt(evsel);
 
 	if (fmt != NULL) {
-		syscall_arg_fmt__init_array(fmt, evsel->tp_format->format.fields, NULL);
+		syscall_arg_fmt__init_array(fmt, evsel->tp_format->format.fields, use_btf);
 		return 0;
 	}
 
@@ -2171,7 +2171,8 @@ static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
 			 * property isn't set.
 			 */
 			if (val == 0 && !trace->show_zeros &&
-			    !(sc->arg_fmt && sc->arg_fmt[arg.idx].show_zero))
+			    !(sc->arg_fmt && sc->arg_fmt[arg.idx].show_zero) &&
+			    !(sc->arg_fmt && sc->arg_fmt[arg.idx].is_enum))
 				continue;
 
 			printed += scnprintf(bf + printed, size - printed, "%s", printed ? ", " : "");
@@ -2877,7 +2878,7 @@ static size_t trace__fprintf_tp_fields(struct trace *trace, struct evsel *evsel,
 		val = syscall_arg_fmt__mask_val(arg, &syscall_arg, val);
 
 		/* Suppress this argument if its value is zero and show_zero property isn't set. */
-		if (val == 0 && !trace->show_zeros && !arg->show_zero)
+		if (val == 0 && !trace->show_zeros && !arg->show_zero && !arg->is_enum)
 			continue;
 
 		printed += scnprintf(bf + printed, size - printed, "%s", printed ? ", " : "");
@@ -2885,6 +2886,15 @@ static size_t trace__fprintf_tp_fields(struct trace *trace, struct evsel *evsel,
 		if (trace->show_arg_names)
 			printed += scnprintf(bf + printed, size - printed, "%s: ", field->name);
 
+		if (arg->is_enum && trace->btf) {
+			size_t p = btf_enum_scnprintf(bf + printed, size - printed, val, trace->btf,
+						      field->type, arg);
+			if (p) {
+				printed += p;
+				continue;
+			}
+		}
+
 		printed += syscall_arg_fmt__scnprintf_val(arg, bf + printed, size - printed, &syscall_arg, val);
 	}
 
@@ -4537,7 +4547,7 @@ static void evsel__set_syscall_arg_fmt(struct evsel *evsel, const char *name)
 	}
 }
 
-static int evlist__set_syscall_tp_fields(struct evlist *evlist)
+static int evlist__set_syscall_tp_fields(struct evlist *evlist, bool *use_btf)
 {
 	struct evsel *evsel;
 
@@ -4546,7 +4556,7 @@ static int evlist__set_syscall_tp_fields(struct evlist *evlist)
 			continue;
 
 		if (strcmp(evsel->tp_format->system, "syscalls")) {
-			evsel__init_tp_arg_scnprintf(evsel);
+			evsel__init_tp_arg_scnprintf(evsel, use_btf);
 			continue;
 		}
 
@@ -5024,11 +5034,16 @@ int cmd_trace(int argc, const char **argv)
 	}
 
 	if (trace.evlist->core.nr_entries > 0) {
+		bool use_btf = false;
+
 		evlist__set_default_evsel_handler(trace.evlist, trace__event_handler);
-		if (evlist__set_syscall_tp_fields(trace.evlist)) {
+		if (evlist__set_syscall_tp_fields(trace.evlist, &use_btf)) {
 			perror("failed to set syscalls:* tracepoint fields");
 			goto out;
 		}
+
+		if (use_btf && trace.btf == NULL)
+			trace__load_vmlinux_btf(&trace);
 	}
 
 	if (trace.sort_events) {
Signature · 1 line
2.45.2
#13 lore raw

Re: [PATCH v2 3/5] perf trace: Augment enum tracepoint arguments with BTF

Quoted 232 lines · Howard Chu

Before:

perf $ ./perf trace -e timer:hrtimer_start --max-events=1

     0.000 :0/0 timer:hrtimer_start(hrtimer: 0xffff974466c25f18, function: 0xffffffff89da5be0, expires: 377432432256753, softexpires: 377432432256753, mode: 10)

After:

perf $ ./perf trace -e timer:hrtimer_start --max-events=1

     0.000 :0/0 timer:hrtimer_start(hrtimer: 0xffff974466d25f18, function: 0xffffffff89da5be0, expires: 488283834504945, softexpires: 488283834504945, mode: HRTIMER_MODE_ABS_PINNED_HARD)

HRTIMER_MODE_ABS_PINNED_HARD is:

perf $ pahole hrtimer_mode
enum hrtimer_mode {

        HRTIMER_MODE_ABS             = 0,
        HRTIMER_MODE_REL             = 1,
        HRTIMER_MODE_PINNED          = 2,
        HRTIMER_MODE_SOFT            = 4,
        HRTIMER_MODE_HARD            = 8,
        HRTIMER_MODE_ABS_PINNED      = 2,
        HRTIMER_MODE_REL_PINNED      = 3,
        HRTIMER_MODE_ABS_SOFT        = 4,
        HRTIMER_MODE_REL_SOFT        = 5,

HRTIMER_MODE_ABS_PINNED_SOFT = 6,
HRTIMER_MODE_REL_PINNED_SOFT = 7,
HRTIMER_MODE_ABS_HARD = 8,
HRTIMER_MODE_REL_HARD = 9,
HRTIMER_MODE_ABS_PINNED_HARD = 10,
HRTIMER_MODE_REL_PINNED_HARD = 11,
};

Can also be tested by

./perf trace -e pagemap:mm_lru_insertion,timer:hrtimer_start,timer:hrtimer_init,skb:kfree_skb --max-events=10

(Chose these 4 events because they happen quite frequently.)

However some enum arguments may not be contained in vmlinux BTF. To see what enum arguments are supported, use:

vmlinux_dir $ bpftool btf dump file /sys/kernel/btf/vmlinux > vmlinux

vmlinux_dir $ while read l; do grep "ENUM '$l'" vmlinux; done < <(grep field:enum /sys/kernel/tracing/events/*/*/format | awk '{print $3}' | sort | uniq) | awk '{print $3}' | sed "s/'\(.*\)'/\1/g" dev_pm_qos_req_type
error_detector
hrtimer_mode
i2c_slave_event
ieee80211_bss_type
lru_list
migrate_mode
nl80211_auth_type
nl80211_band
nl80211_iftype
numa_vmaskip_reason
pm_qos_req_action
pwm_polarity
skb_drop_reason
thermal_trip_type
xen_lazy_mode
xen_mc_extend_args
xen_mc_flush_reason
zone_type

And what tracepoints have these enum types as their arguments:

vmlinux_dir $ while read l; do grep "ENUM '$l'" vmlinux; done < <(grep field:enum /sys/kernel/tracing/events/*/*/format | awk '{print $3}' | sort | uniq) | awk '{print $3}' | sed "s/'\(.*\)'/\1/g" > good_enums

vmlinux_dir $ cat good_enums
dev_pm_qos_req_type
error_detector
hrtimer_mode
i2c_slave_event
ieee80211_bss_type
lru_list
migrate_mode
nl80211_auth_type
nl80211_band
nl80211_iftype
numa_vmaskip_reason
pm_qos_req_action
pwm_polarity
skb_drop_reason
thermal_trip_type
xen_lazy_mode
xen_mc_extend_args
xen_mc_flush_reason
zone_type

vmlinux_dir $ grep -f good_enums -l /sys/kernel/tracing/events/*/*/format /sys/kernel/tracing/events/cfg80211/cfg80211_chandef_dfs_required/format /sys/kernel/tracing/events/cfg80211/cfg80211_ch_switch_notify/format /sys/kernel/tracing/events/cfg80211/cfg80211_ch_switch_started_notify/format /sys/kernel/tracing/events/cfg80211/cfg80211_get_bss/format /sys/kernel/tracing/events/cfg80211/cfg80211_ibss_joined/format /sys/kernel/tracing/events/cfg80211/cfg80211_inform_bss_frame/format /sys/kernel/tracing/events/cfg80211/cfg80211_radar_event/format /sys/kernel/tracing/events/cfg80211/cfg80211_ready_on_channel_expired/format /sys/kernel/tracing/events/cfg80211/cfg80211_ready_on_channel/format /sys/kernel/tracing/events/cfg80211/cfg80211_reg_can_beacon/format /sys/kernel/tracing/events/cfg80211/cfg80211_return_bss/format /sys/kernel/tracing/events/cfg80211/cfg80211_tx_mgmt_expired/format /sys/kernel/tracing/events/cfg80211/rdev_add_virtual_intf/format /sys/kernel/tracing/events/cfg80211/rdev_auth/format /sys/kernel/tracing/events/cfg80211/rdev_change_virtual_intf/format /sys/kernel/tracing/events/cfg80211/rdev_channel_switch/format /sys/kernel/tracing/events/cfg80211/rdev_connect/format /sys/kernel/tracing/events/cfg80211/rdev_inform_bss/format /sys/kernel/tracing/events/cfg80211/rdev_libertas_set_mesh_channel/format /sys/kernel/tracing/events/cfg80211/rdev_mgmt_tx/format /sys/kernel/tracing/events/cfg80211/rdev_remain_on_channel/format /sys/kernel/tracing/events/cfg80211/rdev_return_chandef/format /sys/kernel/tracing/events/cfg80211/rdev_return_int_survey_info/format /sys/kernel/tracing/events/cfg80211/rdev_set_ap_chanwidth/format /sys/kernel/tracing/events/cfg80211/rdev_set_monitor_channel/format /sys/kernel/tracing/events/cfg80211/rdev_set_radar_background/format /sys/kernel/tracing/events/cfg80211/rdev_start_ap/format /sys/kernel/tracing/events/cfg80211/rdev_start_radar_detection/format /sys/kernel/tracing/events/cfg80211/rdev_tdls_channel_switch/format /sys/kernel/tracing/events/compaction/mm_compaction_defer_compaction/format /sys/kernel/tracing/events/compaction/mm_compaction_deferred/format /sys/kernel/tracing/events/compaction/mm_compaction_defer_reset/format /sys/kernel/tracing/events/compaction/mm_compaction_finished/format /sys/kernel/tracing/events/compaction/mm_compaction_kcompactd_wake/format /sys/kernel/tracing/events/compaction/mm_compaction_suitable/format /sys/kernel/tracing/events/compaction/mm_compaction_wakeup_kcompactd/format /sys/kernel/tracing/events/error_report/error_report_end/format /sys/kernel/tracing/events/i2c_slave/i2c_slave/format /sys/kernel/tracing/events/migrate/mm_migrate_pages/format /sys/kernel/tracing/events/migrate/mm_migrate_pages_start/format /sys/kernel/tracing/events/pagemap/mm_lru_insertion/format /sys/kernel/tracing/events/power/dev_pm_qos_add_request/format /sys/kernel/tracing/events/power/dev_pm_qos_remove_request/format /sys/kernel/tracing/events/power/dev_pm_qos_update_request/format /sys/kernel/tracing/events/power/pm_qos_update_flags/format /sys/kernel/tracing/events/power/pm_qos_update_target/format /sys/kernel/tracing/events/pwm/pwm_apply/format /sys/kernel/tracing/events/pwm/pwm_get/format /sys/kernel/tracing/events/sched/sched_skip_vma_numa/format /sys/kernel/tracing/events/skb/kfree_skb/format /sys/kernel/tracing/events/thermal/thermal_zone_trip/format /sys/kernel/tracing/events/timer/hrtimer_init/format /sys/kernel/tracing/events/timer/hrtimer_start/format /sys/kernel/tracing/events/xen/xen_mc_batch/format /sys/kernel/tracing/events/xen/xen_mc_extend_args/format /sys/kernel/tracing/events/xen/xen_mc_flush_reason/format /sys/kernel/tracing/events/xen/xen_mc_issue/format

---
 tools/perf/builtin-trace.c | 29 ++++++++++++++++++++++-------
 1 file changed, 22 insertions(+), 7 deletions(-)
tools/perf/builtin-trace.c +17 -6
index d93f34e9af74..bd16679fb4c0 100644
@@ -1962,12 +1962,12 @@ static int trace__read_syscall_info(struct trace *trace, int id)
 	return err;
 }
 
-static int evsel__init_tp_arg_scnprintf(struct evsel *evsel)
+static int evsel__init_tp_arg_scnprintf(struct evsel *evsel, bool *use_btf)
 {
 	struct syscall_arg_fmt *fmt = evsel__syscall_arg_fmt(evsel);
 
 	if (fmt != NULL) {
-		syscall_arg_fmt__init_array(fmt, evsel->tp_format->format.fields, NULL);
+		syscall_arg_fmt__init_array(fmt, evsel->tp_format->format.fields, use_btf);
 		return 0;
 	}
 
@@ -2171,7 +2171,8 @@ static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
 			 * property isn't set.
 			 */
 			if (val == 0 && !trace->show_zeros &&
-			    !(sc->arg_fmt && sc->arg_fmt[arg.idx].show_zero))
+			    !(sc->arg_fmt && sc->arg_fmt[arg.idx].show_zero) &&
+			    !(sc->arg_fmt && sc->arg_fmt[arg.idx].is_enum))
 				continue;
 
 			printed += scnprintf(bf + printed, size - printed, "%s", printed ? ", " : "");
@@ -2877,7 +2878,7 @@ static size_t trace__fprintf_tp_fields(struct trace *trace, struct evsel *evsel,
 		val = syscall_arg_fmt__mask_val(arg, &syscall_arg, val);
 
 		/* Suppress this argument if its value is zero and show_zero property isn't set. */
-		if (val == 0 && !trace->show_zeros && !arg->show_zero)
+		if (val == 0 && !trace->show_zeros && !arg->show_zero && !arg->is_enum)
 			continue;
 
 		printed += scnprintf(bf + printed, size - printed, "%s", printed ? ", " : "");
@@ -2885,6 +2886,15 @@ static size_t trace__fprintf_tp_fields(struct trace *trace, struct evsel *evsel,
 		if (trace->show_arg_names)
 			printed += scnprintf(bf + printed, size - printed, "%s: ", field->name);
 
+		if (arg->is_enum && trace->btf) {
+			size_t p = btf_enum_scnprintf(bf + printed, size - printed, val, trace->btf,
+						      field->type, arg);
+			if (p) {
+				printed += p;
+				continue;
+			}
+		}
+
 		printed += syscall_arg_fmt__scnprintf_val(arg, bf + printed, size - printed, &syscall_arg, val);
 	}
 
@@ -4537,7 +4547,7 @@ static void evsel__set_syscall_arg_fmt(struct evsel *evsel, const char *name)
 	}
 }
 
-static int evlist__set_syscall_tp_fields(struct evlist *evlist)
+static int evlist__set_syscall_tp_fields(struct evlist *evlist, bool *use_btf)
 {
 	struct evsel *evsel;
 
@@ -4546,7 +4556,7 @@ static int evlist__set_syscall_tp_fields(struct evlist *evlist)
 			continue;
 
 		if (strcmp(evsel->tp_format->system, "syscalls")) {
-			evsel__init_tp_arg_scnprintf(evsel);
+			evsel__init_tp_arg_scnprintf(evsel, use_btf);
 			continue;
 		}
 
@@ -5024,11 +5034,16 @@ int cmd_trace(int argc, const char **argv)
 	}
 
 	if (trace.evlist->core.nr_entries > 0) {
+		bool use_btf = false;

tools/perf/builtin-trace.c int cmd_trace(int argc, const char **argv) · line 5046

Quoted 10 lines
tools/perf/builtin-trace.c +5 -1
+
 		evlist__set_default_evsel_handler(trace.evlist, trace__event_handler);
-		if (evlist__set_syscall_tp_fields(trace.evlist)) {
+		if (evlist__set_syscall_tp_fields(trace.evlist, &use_btf)) {
 			perror("failed to set syscalls:* tracepoint fields");
 			goto out;
 		}
+
+		if (use_btf && trace.btf == NULL)
+			trace__load_vmlinux_btf(&trace);

Can we defer loading btf to when one of those tracepoints is hit?

Quoted 5 lines
tools/perf/builtin-trace.c +0 -0
 	}
 
 	if (trace.sort_events) {
Signature · 1 line
2.45.2
author
#14 lore raw

Re: [PATCH v2 3/5] perf trace: Augment enum tracepoint arguments with BTF

Sure, thanks.

Quoted 252 lines · Arnaldo Carvalho de Melo
Quoted 232 lines · Howard Chu

Before:

perf $ ./perf trace -e timer:hrtimer_start --max-events=1

     0.000 :0/0 timer:hrtimer_start(hrtimer: 0xffff974466c25f18, function: 0xffffffff89da5be0, expires: 377432432256753, softexpires: 377432432256753, mode: 10)

After:

perf $ ./perf trace -e timer:hrtimer_start --max-events=1

     0.000 :0/0 timer:hrtimer_start(hrtimer: 0xffff974466d25f18, function: 0xffffffff89da5be0, expires: 488283834504945, softexpires: 488283834504945, mode: HRTIMER_MODE_ABS_PINNED_HARD)

HRTIMER_MODE_ABS_PINNED_HARD is:

perf $ pahole hrtimer_mode
enum hrtimer_mode {

        HRTIMER_MODE_ABS             = 0,
        HRTIMER_MODE_REL             = 1,
        HRTIMER_MODE_PINNED          = 2,
        HRTIMER_MODE_SOFT            = 4,
        HRTIMER_MODE_HARD            = 8,
        HRTIMER_MODE_ABS_PINNED      = 2,
        HRTIMER_MODE_REL_PINNED      = 3,
        HRTIMER_MODE_ABS_SOFT        = 4,
        HRTIMER_MODE_REL_SOFT        = 5,

HRTIMER_MODE_ABS_PINNED_SOFT = 6,
HRTIMER_MODE_REL_PINNED_SOFT = 7,
HRTIMER_MODE_ABS_HARD = 8,
HRTIMER_MODE_REL_HARD = 9,
HRTIMER_MODE_ABS_PINNED_HARD = 10,
HRTIMER_MODE_REL_PINNED_HARD = 11,
};

Can also be tested by

./perf trace -e pagemap:mm_lru_insertion,timer:hrtimer_start,timer:hrtimer_init,skb:kfree_skb --max-events=10

(Chose these 4 events because they happen quite frequently.)

However some enum arguments may not be contained in vmlinux BTF. To see what enum arguments are supported, use:

vmlinux_dir $ bpftool btf dump file /sys/kernel/btf/vmlinux > vmlinux

vmlinux_dir $ while read l; do grep "ENUM '$l'" vmlinux; done < <(grep field:enum /sys/kernel/tracing/events/*/*/format | awk '{print $3}' | sort | uniq) | awk '{print $3}' | sed "s/'\(.*\)'/\1/g" dev_pm_qos_req_type
error_detector
hrtimer_mode
i2c_slave_event
ieee80211_bss_type
lru_list
migrate_mode
nl80211_auth_type
nl80211_band
nl80211_iftype
numa_vmaskip_reason
pm_qos_req_action
pwm_polarity
skb_drop_reason
thermal_trip_type
xen_lazy_mode
xen_mc_extend_args
xen_mc_flush_reason
zone_type

And what tracepoints have these enum types as their arguments:

vmlinux_dir $ while read l; do grep "ENUM '$l'" vmlinux; done < <(grep field:enum /sys/kernel/tracing/events/*/*/format | awk '{print $3}' | sort | uniq) | awk '{print $3}' | sed "s/'\(.*\)'/\1/g" > good_enums

vmlinux_dir $ cat good_enums
dev_pm_qos_req_type
error_detector
hrtimer_mode
i2c_slave_event
ieee80211_bss_type
lru_list
migrate_mode
nl80211_auth_type
nl80211_band
nl80211_iftype
numa_vmaskip_reason
pm_qos_req_action
pwm_polarity
skb_drop_reason
thermal_trip_type
xen_lazy_mode
xen_mc_extend_args
xen_mc_flush_reason
zone_type

vmlinux_dir $ grep -f good_enums -l /sys/kernel/tracing/events/*/*/format /sys/kernel/tracing/events/cfg80211/cfg80211_chandef_dfs_required/format /sys/kernel/tracing/events/cfg80211/cfg80211_ch_switch_notify/format /sys/kernel/tracing/events/cfg80211/cfg80211_ch_switch_started_notify/format /sys/kernel/tracing/events/cfg80211/cfg80211_get_bss/format /sys/kernel/tracing/events/cfg80211/cfg80211_ibss_joined/format /sys/kernel/tracing/events/cfg80211/cfg80211_inform_bss_frame/format /sys/kernel/tracing/events/cfg80211/cfg80211_radar_event/format /sys/kernel/tracing/events/cfg80211/cfg80211_ready_on_channel_expired/format /sys/kernel/tracing/events/cfg80211/cfg80211_ready_on_channel/format /sys/kernel/tracing/events/cfg80211/cfg80211_reg_can_beacon/format /sys/kernel/tracing/events/cfg80211/cfg80211_return_bss/format /sys/kernel/tracing/events/cfg80211/cfg80211_tx_mgmt_expired/format /sys/kernel/tracing/events/cfg80211/rdev_add_virtual_intf/format /sys/kernel/tracing/events/cfg80211/rdev_auth/format /sys/kernel/tracing/events/cfg80211/rdev_change_virtual_intf/format /sys/kernel/tracing/events/cfg80211/rdev_channel_switch/format /sys/kernel/tracing/events/cfg80211/rdev_connect/format /sys/kernel/tracing/events/cfg80211/rdev_inform_bss/format /sys/kernel/tracing/events/cfg80211/rdev_libertas_set_mesh_channel/format /sys/kernel/tracing/events/cfg80211/rdev_mgmt_tx/format /sys/kernel/tracing/events/cfg80211/rdev_remain_on_channel/format /sys/kernel/tracing/events/cfg80211/rdev_return_chandef/format /sys/kernel/tracing/events/cfg80211/rdev_return_int_survey_info/format /sys/kernel/tracing/events/cfg80211/rdev_set_ap_chanwidth/format /sys/kernel/tracing/events/cfg80211/rdev_set_monitor_channel/format /sys/kernel/tracing/events/cfg80211/rdev_set_radar_background/format /sys/kernel/tracing/events/cfg80211/rdev_start_ap/format /sys/kernel/tracing/events/cfg80211/rdev_start_radar_detection/format /sys/kernel/tracing/events/cfg80211/rdev_tdls_channel_switch/format /sys/kernel/tracing/events/compaction/mm_compaction_defer_compaction/format /sys/kernel/tracing/events/compaction/mm_compaction_deferred/format /sys/kernel/tracing/events/compaction/mm_compaction_defer_reset/format /sys/kernel/tracing/events/compaction/mm_compaction_finished/format /sys/kernel/tracing/events/compaction/mm_compaction_kcompactd_wake/format /sys/kernel/tracing/events/compaction/mm_compaction_suitable/format /sys/kernel/tracing/events/compaction/mm_compaction_wakeup_kcompactd/format /sys/kernel/tracing/events/error_report/error_report_end/format /sys/kernel/tracing/events/i2c_slave/i2c_slave/format /sys/kernel/tracing/events/migrate/mm_migrate_pages/format /sys/kernel/tracing/events/migrate/mm_migrate_pages_start/format /sys/kernel/tracing/events/pagemap/mm_lru_insertion/format /sys/kernel/tracing/events/power/dev_pm_qos_add_request/format /sys/kernel/tracing/events/power/dev_pm_qos_remove_request/format /sys/kernel/tracing/events/power/dev_pm_qos_update_request/format /sys/kernel/tracing/events/power/pm_qos_update_flags/format /sys/kernel/tracing/events/power/pm_qos_update_target/format /sys/kernel/tracing/events/pwm/pwm_apply/format /sys/kernel/tracing/events/pwm/pwm_get/format /sys/kernel/tracing/events/sched/sched_skip_vma_numa/format /sys/kernel/tracing/events/skb/kfree_skb/format /sys/kernel/tracing/events/thermal/thermal_zone_trip/format /sys/kernel/tracing/events/timer/hrtimer_init/format /sys/kernel/tracing/events/timer/hrtimer_start/format /sys/kernel/tracing/events/xen/xen_mc_batch/format /sys/kernel/tracing/events/xen/xen_mc_extend_args/format /sys/kernel/tracing/events/xen/xen_mc_flush_reason/format /sys/kernel/tracing/events/xen/xen_mc_issue/format

---
 tools/perf/builtin-trace.c | 29 ++++++++++++++++++++++-------
 1 file changed, 22 insertions(+), 7 deletions(-)
tools/perf/builtin-trace.c +17 -6
index d93f34e9af74..bd16679fb4c0 100644
@@ -1962,12 +1962,12 @@ static int trace__read_syscall_info(struct trace *trace, int id)
      return err;
 }
 
-static int evsel__init_tp_arg_scnprintf(struct evsel *evsel)
+static int evsel__init_tp_arg_scnprintf(struct evsel *evsel, bool *use_btf)
 {
      struct syscall_arg_fmt *fmt = evsel__syscall_arg_fmt(evsel);
 
      if (fmt != NULL) {
-             syscall_arg_fmt__init_array(fmt, evsel->tp_format->format.fields, NULL);
+             syscall_arg_fmt__init_array(fmt, evsel->tp_format->format.fields, use_btf);
              return 0;
      }
 
@@ -2171,7 +2171,8 @@ static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
                       * property isn't set.
                       */
                      if (val == 0 && !trace->show_zeros &&
-                         !(sc->arg_fmt && sc->arg_fmt[arg.idx].show_zero))
+                         !(sc->arg_fmt && sc->arg_fmt[arg.idx].show_zero) &&
+                         !(sc->arg_fmt && sc->arg_fmt[arg.idx].is_enum))
                              continue;
 
                      printed += scnprintf(bf + printed, size - printed, "%s", printed ? ", " : "");
@@ -2877,7 +2878,7 @@ static size_t trace__fprintf_tp_fields(struct trace *trace, struct evsel *evsel,
              val = syscall_arg_fmt__mask_val(arg, &syscall_arg, val);
 
              /* Suppress this argument if its value is zero and show_zero property isn't set. */
-             if (val == 0 && !trace->show_zeros && !arg->show_zero)
+             if (val == 0 && !trace->show_zeros && !arg->show_zero && !arg->is_enum)
                      continue;
 
              printed += scnprintf(bf + printed, size - printed, "%s", printed ? ", " : "");
@@ -2885,6 +2886,15 @@ static size_t trace__fprintf_tp_fields(struct trace *trace, struct evsel *evsel,
              if (trace->show_arg_names)
                      printed += scnprintf(bf + printed, size - printed, "%s: ", field->name);
 
+             if (arg->is_enum && trace->btf) {
+                     size_t p = btf_enum_scnprintf(bf + printed, size - printed, val, trace->btf,
+                                                   field->type, arg);
+                     if (p) {
+                             printed += p;
+                             continue;
+                     }
+             }
+
              printed += syscall_arg_fmt__scnprintf_val(arg, bf + printed, size - printed, &syscall_arg, val);
      }
 
@@ -4537,7 +4547,7 @@ static void evsel__set_syscall_arg_fmt(struct evsel *evsel, const char *name)
      }
 }
 
-static int evlist__set_syscall_tp_fields(struct evlist *evlist)
+static int evlist__set_syscall_tp_fields(struct evlist *evlist, bool *use_btf)
 {
      struct evsel *evsel;
 
@@ -4546,7 +4556,7 @@ static int evlist__set_syscall_tp_fields(struct evlist *evlist)
                      continue;
 
              if (strcmp(evsel->tp_format->system, "syscalls")) {
-                     evsel__init_tp_arg_scnprintf(evsel);
+                     evsel__init_tp_arg_scnprintf(evsel, use_btf);
                      continue;
              }
 
@@ -5024,11 +5034,16 @@ int cmd_trace(int argc, const char **argv)
      }
 
      if (trace.evlist->core.nr_entries > 0) {
+             bool use_btf = false;

tools/perf/builtin-trace.c int cmd_trace(int argc, const char **argv) · line 5046

Quoted 10 lines
tools/perf/builtin-trace.c +5 -1
+
              evlist__set_default_evsel_handler(trace.evlist, trace__event_handler);
-             if (evlist__set_syscall_tp_fields(trace.evlist)) {
+             if (evlist__set_syscall_tp_fields(trace.evlist, &use_btf)) {
                      perror("failed to set syscalls:* tracepoint fields");
                      goto out;
              }
+
+             if (use_btf && trace.btf == NULL)
+                     trace__load_vmlinux_btf(&trace);

Can we defer loading btf to when one of those tracepoints is hit?

Quoted 5 lines
tools/perf/builtin-trace.c +0 -1
      }
 
      if (trace.sort_events) {
--

2.45.2

author
#15 lore raw

PATCH v2 4/5 perf trace: Filter enum arguments with enum names

In reply to Howard Chu

Before:

perf $ ./perf trace -e timer:hrtimer_start --filter='mode!=HRTIMER_MODE_ABS_PINNED_HARD' --max-events=1
No resolver (strtoul) for "mode" in "timer:hrtimer_start", can't set filter "(mode!=HRTIMER_MODE_ABS_PINNED_HARD) && (common_pid != 281988)"

After:

perf $ ./perf trace -e timer:hrtimer_start --filter='mode!=HRTIMER_MODE_ABS_PINNED_HARD' --max-events=1

     0.000 :0/0 timer:hrtimer_start(hrtimer: 0xffff9498a6ca5f18, function: 0xffffffffa77a5be0, expires: 12351248764875, softexpires: 12351248764875, mode: HRTIMER_MODE_ABS)

&& and ||:

perf $ ./perf trace -e timer:hrtimer_start --filter='mode != HRTIMER_MODE_ABS_PINNED_HARD && mode != HRTIMER_MODE_ABS' --max-events=1

     0.000 Hyprland/534 timer:hrtimer_start(hrtimer: 0xffff9497801a84d0, function: 0xffffffffc04cdbe0, expires: 12639434638458, softexpires: 12639433638458, mode: HRTIMER_MODE_REL)

perf $ ./perf trace -e timer:hrtimer_start --filter='mode == HRTIMER_MODE_REL || mode == HRTIMER_MODE_PINNED' --max-events=1

     0.000 ldlck-test/60639 timer:hrtimer_start(hrtimer: 0xffffb16404ee7bf8, function: 0xffffffffa7790420, expires: 12772614418016, softexpires: 12772614368016, mode: HRTIMER_MODE_REL)

Switching it up, using both enum name and integer value(--filter='mode == HRTIMER_MODE_ABS_PINNED_HARD || mode == 0'):

perf $ ./perf trace -e timer:hrtimer_start --filter='mode == HRTIMER_MODE_ABS_PINNED_HARD || mode == 0' --max-events=3

     0.000 :0/0 timer:hrtimer_start(hrtimer: 0xffff9498a6ca5f18, function: 0xffffffffa77a5be0, expires: 12601748739825, softexpires: 12601748739825, mode: HRTIMER_MODE_ABS_PINNED_HARD)
     0.036 :0/0 timer:hrtimer_start(hrtimer: 0xffff9498a6ca5f18, function: 0xffffffffa77a5be0, expires: 12518758748124, softexpires: 12518758748124, mode: HRTIMER_MODE_ABS_PINNED_HARD)
     0.172 tmux: server/41881 timer:hrtimer_start(hrtimer: 0xffffb164081e7838, function: 0xffffffffa7790420, expires: 12518768255836, softexpires: 12518768205836, mode: HRTIMER_MODE_ABS)

P.S.
perf $ pahole hrtimer_mode
enum hrtimer_mode {

        HRTIMER_MODE_ABS             = 0,
        HRTIMER_MODE_REL             = 1,
        HRTIMER_MODE_PINNED          = 2,
        HRTIMER_MODE_SOFT            = 4,
        HRTIMER_MODE_HARD            = 8,
        HRTIMER_MODE_ABS_PINNED      = 2,
        HRTIMER_MODE_REL_PINNED      = 3,
        HRTIMER_MODE_ABS_SOFT        = 4,
        HRTIMER_MODE_REL_SOFT        = 5,

HRTIMER_MODE_ABS_PINNED_SOFT = 6,
HRTIMER_MODE_REL_PINNED_SOFT = 7,
HRTIMER_MODE_ABS_HARD = 8,
HRTIMER_MODE_REL_HARD = 9,
HRTIMER_MODE_ABS_PINNED_HARD = 10,
HRTIMER_MODE_REL_PINNED_HARD = 11,
};

---
 tools/perf/builtin-trace.c | 89 ++++++++++++++++++++++++++++++++------
 1 file changed, 76 insertions(+), 13 deletions(-)
tools/perf/builtin-trace.c +76 -13
index bd16679fb4c0..1148c3edee97 100644
@@ -904,11 +904,36 @@ static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size,
 	    .strtoul	= STUL_STRARRAY_FLAGS, \
 	    .parm	= &strarray__##array, }
 
-static int btf_enum_find_entry(struct btf *btf, char *type, struct syscall_arg_fmt *arg_fmt)
+#define SCA_GETRANDOM_FLAGS syscall_arg__scnprintf_getrandom_flags
+
+static const struct btf_type *btf_find_type(struct btf *btf, char *type)
 {
 	const struct btf_type *bt;
+	int id = btf__find_by_name(btf, type);
+
+	if (id < 0)
+		return NULL;
+
+	bt = btf__type_by_id(btf, id);
+	if (bt == NULL)
+		return NULL;
+
+	return bt;
+}
+
+struct btf_parm {
+	struct btf *btf;
+	char *type;
+};
+
+static bool syscall_arg__strtoul_btf_enum(char *bf, size_t size, struct syscall_arg *arg, u64 *val)
+{
+	struct btf_parm *bparm = arg->parm;
+	struct btf *btf = bparm->btf;
+	char *type      = bparm->type;
 	char enum_prefix[][16] = { "enum", "const enum" }, *ep;
-	int id;
+	struct btf_enum *be;
+	const struct btf_type *bt;
 	size_t i;
 
 	for (i = 0; i < ARRAY_SIZE(enum_prefix); i++) {
@@ -917,11 +942,38 @@ static int btf_enum_find_entry(struct btf *btf, char *type, struct syscall_arg_f
 			type += strlen(ep) + 1;
 	}
 
-	id = btf__find_by_name(btf, type);
-	if (id < 0)
-		return -1;
+	bt = btf_find_type(btf, type);
+	if (bt == NULL)
+		return false;
 
-	bt = btf__type_by_id(btf, id);
+	for (be = btf_enum(bt), i = 0; i < btf_vlen(bt); ++i, ++be) {
+		const char *name = btf__name_by_offset(btf, be->name_off);
+		int max_len = max(size, strlen(name));
+
+		if (strncmp(name, bf, max_len) == 0) {
+			*val = be->val;
+			return true;
+		}
+	}
+
+	return false;
+}
+
+#define STUL_BTF_ENUM syscall_arg__strtoul_btf_enum
+
+static int btf_enum_find_entry(struct btf *btf, char *type, struct syscall_arg_fmt *arg_fmt)
+{
+	char enum_prefix[][16] = { "enum", "const enum" }, *ep;
+	const struct btf_type *bt;
+	size_t i;
+
+	for (i = 0; i < ARRAY_SIZE(enum_prefix); i++) {
+		ep = enum_prefix[i];
+		if (strlen(type) > strlen(ep) + 1 && strstarts(type, ep))
+			type += strlen(ep) + 1;
+	}
+
+	bt = btf_find_type(btf, type);
 	if (bt == NULL)
 		return -1;
 
@@ -1850,6 +1902,7 @@ syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field
 			arg->scnprintf = SCA_FD;
 		} else if (strstr(field->type, "enum") && use_btf != NULL) {
 			*use_btf = arg->is_enum = true;
+			arg->strtoul = STUL_BTF_ENUM;
 		} else {
 			const struct syscall_arg_fmt *fmt =
 				syscall_arg_fmt__find_by_name(field->name);
@@ -3776,7 +3829,8 @@ static int ordered_events__deliver_event(struct ordered_events *oe,
 	return __trace__deliver_event(trace, event->event);
 }
 
-static struct syscall_arg_fmt *evsel__find_syscall_arg_fmt_by_name(struct evsel *evsel, char *arg)
+static struct syscall_arg_fmt *evsel__find_syscall_arg_fmt_by_name(struct evsel *evsel, char *arg,
+								   char **type)
 {
 	struct tep_format_field *field;
 	struct syscall_arg_fmt *fmt = __evsel__syscall_arg_fmt(evsel);
@@ -3785,8 +3839,10 @@ static struct syscall_arg_fmt *evsel__find_syscall_arg_fmt_by_name(struct evsel
 		return NULL;
 
 	for (field = evsel->tp_format->format.fields; field; field = field->next, ++fmt)
-		if (strcmp(field->name, arg) == 0)
+		if (strcmp(field->name, arg) == 0) {
+			*type = field->type;
 			return fmt;
+		}
 
 	return NULL;
 }
@@ -3824,14 +3880,14 @@ static int trace__expand_filter(struct trace *trace __maybe_unused, struct evsel
 			struct syscall_arg_fmt *fmt;
 			int left_size = tok - left,
 			    right_size = right_end - right;
-			char arg[128];
+			char arg[128], *type;
 
 			while (isspace(left[left_size - 1]))
 				--left_size;
 
 			scnprintf(arg, sizeof(arg), "%.*s", left_size, left);
 
-			fmt = evsel__find_syscall_arg_fmt_by_name(evsel, arg);
+			fmt = evsel__find_syscall_arg_fmt_by_name(evsel, arg, &type);
 			if (fmt == NULL) {
 				pr_err("\"%s\" not found in \"%s\", can't set filter \"%s\"\n",
 				       arg, evsel->name, evsel->filter);
@@ -3843,9 +3899,16 @@ static int trace__expand_filter(struct trace *trace __maybe_unused, struct evsel
 
 			if (fmt->strtoul) {
 				u64 val;
-				struct syscall_arg syscall_arg = {
-					.parm = fmt->parm,
-				};
+				struct syscall_arg syscall_arg;
+				struct btf_parm bparm;
+
+				if (fmt->is_enum) {
+					bparm.btf  = trace->btf;
+					bparm.type = type;
+					syscall_arg.parm = &bparm;
+				} else {
+					syscall_arg.parm = fmt->parm;
+				}
 
 				if (fmt->strtoul(right, right_size, &syscall_arg, &val)) {
 					char *n, expansion[19];
Signature · 1 line
2.45.2
#16 lore raw

Re: [PATCH v2 4/5] perf trace: Filter enum arguments with enum names

Quoted 58 lines · Howard Chu

Before:

perf $ ./perf trace -e timer:hrtimer_start --filter='mode!=HRTIMER_MODE_ABS_PINNED_HARD' --max-events=1
No resolver (strtoul) for "mode" in "timer:hrtimer_start", can't set filter "(mode!=HRTIMER_MODE_ABS_PINNED_HARD) && (common_pid != 281988)"

After:

perf $ ./perf trace -e timer:hrtimer_start --filter='mode!=HRTIMER_MODE_ABS_PINNED_HARD' --max-events=1

     0.000 :0/0 timer:hrtimer_start(hrtimer: 0xffff9498a6ca5f18, function: 0xffffffffa77a5be0, expires: 12351248764875, softexpires: 12351248764875, mode: HRTIMER_MODE_ABS)

&& and ||:

perf $ ./perf trace -e timer:hrtimer_start --filter='mode != HRTIMER_MODE_ABS_PINNED_HARD && mode != HRTIMER_MODE_ABS' --max-events=1

     0.000 Hyprland/534 timer:hrtimer_start(hrtimer: 0xffff9497801a84d0, function: 0xffffffffc04cdbe0, expires: 12639434638458, softexpires: 12639433638458, mode: HRTIMER_MODE_REL)

perf $ ./perf trace -e timer:hrtimer_start --filter='mode == HRTIMER_MODE_REL || mode == HRTIMER_MODE_PINNED' --max-events=1

     0.000 ldlck-test/60639 timer:hrtimer_start(hrtimer: 0xffffb16404ee7bf8, function: 0xffffffffa7790420, expires: 12772614418016, softexpires: 12772614368016, mode: HRTIMER_MODE_REL)

Switching it up, using both enum name and integer value(--filter='mode == HRTIMER_MODE_ABS_PINNED_HARD || mode == 0'):

perf $ ./perf trace -e timer:hrtimer_start --filter='mode == HRTIMER_MODE_ABS_PINNED_HARD || mode == 0' --max-events=3

     0.000 :0/0 timer:hrtimer_start(hrtimer: 0xffff9498a6ca5f18, function: 0xffffffffa77a5be0, expires: 12601748739825, softexpires: 12601748739825, mode: HRTIMER_MODE_ABS_PINNED_HARD)
     0.036 :0/0 timer:hrtimer_start(hrtimer: 0xffff9498a6ca5f18, function: 0xffffffffa77a5be0, expires: 12518758748124, softexpires: 12518758748124, mode: HRTIMER_MODE_ABS_PINNED_HARD)
     0.172 tmux: server/41881 timer:hrtimer_start(hrtimer: 0xffffb164081e7838, function: 0xffffffffa7790420, expires: 12518768255836, softexpires: 12518768205836, mode: HRTIMER_MODE_ABS)

P.S.
perf $ pahole hrtimer_mode
enum hrtimer_mode {

        HRTIMER_MODE_ABS             = 0,
        HRTIMER_MODE_REL             = 1,
        HRTIMER_MODE_PINNED          = 2,
        HRTIMER_MODE_SOFT            = 4,
        HRTIMER_MODE_HARD            = 8,
        HRTIMER_MODE_ABS_PINNED      = 2,
        HRTIMER_MODE_REL_PINNED      = 3,
        HRTIMER_MODE_ABS_SOFT        = 4,
        HRTIMER_MODE_REL_SOFT        = 5,

HRTIMER_MODE_ABS_PINNED_SOFT = 6,
HRTIMER_MODE_REL_PINNED_SOFT = 7,
HRTIMER_MODE_ABS_HARD = 8,
HRTIMER_MODE_REL_HARD = 9,
HRTIMER_MODE_ABS_PINNED_HARD = 10,
HRTIMER_MODE_REL_PINNED_HARD = 11,
};

---
 tools/perf/builtin-trace.c | 89 ++++++++++++++++++++++++++++++++------
 1 file changed, 76 insertions(+), 13 deletions(-)
tools/perf/builtin-trace.c +0 -0
index bd16679fb4c0..1148c3edee97 100644

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 907

Quoted 5 lines
tools/perf/builtin-trace.c +1 -1
@@ -904,11 +904,36 @@ static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size,
 	    .strtoul	= STUL_STRARRAY_FLAGS, \
 	    .parm	= &strarray__##array, }
 
-static int btf_enum_find_entry(struct btf *btf, char *type, struct syscall_arg_fmt *arg_fmt)
+#define SCA_GETRANDOM_FLAGS syscall_arg__scnprintf_getrandom_flags

The above seems unrelated? (The definition of SCA_GETRANDOM_FLAGS) as it is not used in any other place in this patch, right?

- Arnaldo

Quoted 146 lines
tools/perf/builtin-trace.c +75 -12
+
+static const struct btf_type *btf_find_type(struct btf *btf, char *type)
 {
 	const struct btf_type *bt;
+	int id = btf__find_by_name(btf, type);
+
+	if (id < 0)
+		return NULL;
+
+	bt = btf__type_by_id(btf, id);
+	if (bt == NULL)
+		return NULL;
+
+	return bt;
+}
+
+struct btf_parm {
+	struct btf *btf;
+	char *type;
+};
+
+static bool syscall_arg__strtoul_btf_enum(char *bf, size_t size, struct syscall_arg *arg, u64 *val)
+{
+	struct btf_parm *bparm = arg->parm;
+	struct btf *btf = bparm->btf;
+	char *type      = bparm->type;
 	char enum_prefix[][16] = { "enum", "const enum" }, *ep;
-	int id;
+	struct btf_enum *be;
+	const struct btf_type *bt;
 	size_t i;
 
 	for (i = 0; i < ARRAY_SIZE(enum_prefix); i++) {
@@ -917,11 +942,38 @@ static int btf_enum_find_entry(struct btf *btf, char *type, struct syscall_arg_f
 			type += strlen(ep) + 1;
 	}
 
-	id = btf__find_by_name(btf, type);
-	if (id < 0)
-		return -1;
+	bt = btf_find_type(btf, type);
+	if (bt == NULL)
+		return false;
 
-	bt = btf__type_by_id(btf, id);
+	for (be = btf_enum(bt), i = 0; i < btf_vlen(bt); ++i, ++be) {
+		const char *name = btf__name_by_offset(btf, be->name_off);
+		int max_len = max(size, strlen(name));
+
+		if (strncmp(name, bf, max_len) == 0) {
+			*val = be->val;
+			return true;
+		}
+	}
+
+	return false;
+}
+
+#define STUL_BTF_ENUM syscall_arg__strtoul_btf_enum
+
+static int btf_enum_find_entry(struct btf *btf, char *type, struct syscall_arg_fmt *arg_fmt)
+{
+	char enum_prefix[][16] = { "enum", "const enum" }, *ep;
+	const struct btf_type *bt;
+	size_t i;
+
+	for (i = 0; i < ARRAY_SIZE(enum_prefix); i++) {
+		ep = enum_prefix[i];
+		if (strlen(type) > strlen(ep) + 1 && strstarts(type, ep))
+			type += strlen(ep) + 1;
+	}
+
+	bt = btf_find_type(btf, type);
 	if (bt == NULL)
 		return -1;
 
@@ -1850,6 +1902,7 @@ syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field
 			arg->scnprintf = SCA_FD;
 		} else if (strstr(field->type, "enum") && use_btf != NULL) {
 			*use_btf = arg->is_enum = true;
+			arg->strtoul = STUL_BTF_ENUM;
 		} else {
 			const struct syscall_arg_fmt *fmt =
 				syscall_arg_fmt__find_by_name(field->name);
@@ -3776,7 +3829,8 @@ static int ordered_events__deliver_event(struct ordered_events *oe,
 	return __trace__deliver_event(trace, event->event);
 }
 
-static struct syscall_arg_fmt *evsel__find_syscall_arg_fmt_by_name(struct evsel *evsel, char *arg)
+static struct syscall_arg_fmt *evsel__find_syscall_arg_fmt_by_name(struct evsel *evsel, char *arg,
+								   char **type)
 {
 	struct tep_format_field *field;
 	struct syscall_arg_fmt *fmt = __evsel__syscall_arg_fmt(evsel);
@@ -3785,8 +3839,10 @@ static struct syscall_arg_fmt *evsel__find_syscall_arg_fmt_by_name(struct evsel
 		return NULL;
 
 	for (field = evsel->tp_format->format.fields; field; field = field->next, ++fmt)
-		if (strcmp(field->name, arg) == 0)
+		if (strcmp(field->name, arg) == 0) {
+			*type = field->type;
 			return fmt;
+		}
 
 	return NULL;
 }
@@ -3824,14 +3880,14 @@ static int trace__expand_filter(struct trace *trace __maybe_unused, struct evsel
 			struct syscall_arg_fmt *fmt;
 			int left_size = tok - left,
 			    right_size = right_end - right;
-			char arg[128];
+			char arg[128], *type;
 
 			while (isspace(left[left_size - 1]))
 				--left_size;
 
 			scnprintf(arg, sizeof(arg), "%.*s", left_size, left);
 
-			fmt = evsel__find_syscall_arg_fmt_by_name(evsel, arg);
+			fmt = evsel__find_syscall_arg_fmt_by_name(evsel, arg, &type);
 			if (fmt == NULL) {
 				pr_err("\"%s\" not found in \"%s\", can't set filter \"%s\"\n",
 				       arg, evsel->name, evsel->filter);
@@ -3843,9 +3899,16 @@ static int trace__expand_filter(struct trace *trace __maybe_unused, struct evsel
 
 			if (fmt->strtoul) {
 				u64 val;
-				struct syscall_arg syscall_arg = {
-					.parm = fmt->parm,
-				};
+				struct syscall_arg syscall_arg;
+				struct btf_parm bparm;
+
+				if (fmt->is_enum) {
+					bparm.btf  = trace->btf;
+					bparm.type = type;
+					syscall_arg.parm = &bparm;
+				} else {
+					syscall_arg.parm = fmt->parm;
+				}
 
 				if (fmt->strtoul(right, right_size, &syscall_arg, &val)) {
 					char *n, expansion[19];
Signature · 1 line
2.45.2
author
#17 lore raw

Re: [PATCH v2 4/5] perf trace: Filter enum arguments with enum names

You are right! What a silly mistake, I duplicated a line of code. Sorry about that.

Quoted 217 lines · Arnaldo Carvalho de Melo
Quoted 58 lines · Howard Chu

Before:

perf $ ./perf trace -e timer:hrtimer_start --filter='mode!=HRTIMER_MODE_ABS_PINNED_HARD' --max-events=1
No resolver (strtoul) for "mode" in "timer:hrtimer_start", can't set filter "(mode!=HRTIMER_MODE_ABS_PINNED_HARD) && (common_pid != 281988)"

After:

perf $ ./perf trace -e timer:hrtimer_start --filter='mode!=HRTIMER_MODE_ABS_PINNED_HARD' --max-events=1

     0.000 :0/0 timer:hrtimer_start(hrtimer: 0xffff9498a6ca5f18, function: 0xffffffffa77a5be0, expires: 12351248764875, softexpires: 12351248764875, mode: HRTIMER_MODE_ABS)

&& and ||:

perf $ ./perf trace -e timer:hrtimer_start --filter='mode != HRTIMER_MODE_ABS_PINNED_HARD && mode != HRTIMER_MODE_ABS' --max-events=1

     0.000 Hyprland/534 timer:hrtimer_start(hrtimer: 0xffff9497801a84d0, function: 0xffffffffc04cdbe0, expires: 12639434638458, softexpires: 12639433638458, mode: HRTIMER_MODE_REL)

perf $ ./perf trace -e timer:hrtimer_start --filter='mode == HRTIMER_MODE_REL || mode == HRTIMER_MODE_PINNED' --max-events=1

     0.000 ldlck-test/60639 timer:hrtimer_start(hrtimer: 0xffffb16404ee7bf8, function: 0xffffffffa7790420, expires: 12772614418016, softexpires: 12772614368016, mode: HRTIMER_MODE_REL)

Switching it up, using both enum name and integer value(--filter='mode == HRTIMER_MODE_ABS_PINNED_HARD || mode == 0'):

perf $ ./perf trace -e timer:hrtimer_start --filter='mode == HRTIMER_MODE_ABS_PINNED_HARD || mode == 0' --max-events=3

     0.000 :0/0 timer:hrtimer_start(hrtimer: 0xffff9498a6ca5f18, function: 0xffffffffa77a5be0, expires: 12601748739825, softexpires: 12601748739825, mode: HRTIMER_MODE_ABS_PINNED_HARD)
     0.036 :0/0 timer:hrtimer_start(hrtimer: 0xffff9498a6ca5f18, function: 0xffffffffa77a5be0, expires: 12518758748124, softexpires: 12518758748124, mode: HRTIMER_MODE_ABS_PINNED_HARD)
     0.172 tmux: server/41881 timer:hrtimer_start(hrtimer: 0xffffb164081e7838, function: 0xffffffffa7790420, expires: 12518768255836, softexpires: 12518768205836, mode: HRTIMER_MODE_ABS)

P.S.
perf $ pahole hrtimer_mode
enum hrtimer_mode {

        HRTIMER_MODE_ABS             = 0,
        HRTIMER_MODE_REL             = 1,
        HRTIMER_MODE_PINNED          = 2,
        HRTIMER_MODE_SOFT            = 4,
        HRTIMER_MODE_HARD            = 8,
        HRTIMER_MODE_ABS_PINNED      = 2,
        HRTIMER_MODE_REL_PINNED      = 3,
        HRTIMER_MODE_ABS_SOFT        = 4,
        HRTIMER_MODE_REL_SOFT        = 5,

HRTIMER_MODE_ABS_PINNED_SOFT = 6,
HRTIMER_MODE_REL_PINNED_SOFT = 7,
HRTIMER_MODE_ABS_HARD = 8,
HRTIMER_MODE_REL_HARD = 9,
HRTIMER_MODE_ABS_PINNED_HARD = 10,
HRTIMER_MODE_REL_PINNED_HARD = 11,
};

---
 tools/perf/builtin-trace.c | 89 ++++++++++++++++++++++++++++++++------
 1 file changed, 76 insertions(+), 13 deletions(-)
tools/perf/builtin-trace.c +0 -0
index bd16679fb4c0..1148c3edee97 100644

tools/perf/builtin-trace.c static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size, · line 907

Quoted 5 lines
tools/perf/builtin-trace.c +1 -1
@@ -904,11 +904,36 @@ static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size,
          .strtoul    = STUL_STRARRAY_FLAGS, \
          .parm       = &strarray__##array, }
 
-static int btf_enum_find_entry(struct btf *btf, char *type, struct syscall_arg_fmt *arg_fmt)
+#define SCA_GETRANDOM_FLAGS syscall_arg__scnprintf_getrandom_flags

The above seems unrelated? (The definition of SCA_GETRANDOM_FLAGS) as it is not used in any other place in this patch, right?

- Arnaldo

Quoted 146 lines
tools/perf/builtin-trace.c +75 -13
+
+static const struct btf_type *btf_find_type(struct btf *btf, char *type)
 {
      const struct btf_type *bt;
+     int id = btf__find_by_name(btf, type);
+
+     if (id < 0)
+             return NULL;
+
+     bt = btf__type_by_id(btf, id);
+     if (bt == NULL)
+             return NULL;
+
+     return bt;
+}
+
+struct btf_parm {
+     struct btf *btf;
+     char *type;
+};
+
+static bool syscall_arg__strtoul_btf_enum(char *bf, size_t size, struct syscall_arg *arg, u64 *val)
+{
+     struct btf_parm *bparm = arg->parm;
+     struct btf *btf = bparm->btf;
+     char *type      = bparm->type;
      char enum_prefix[][16] = { "enum", "const enum" }, *ep;
-     int id;
+     struct btf_enum *be;
+     const struct btf_type *bt;
      size_t i;
 
      for (i = 0; i < ARRAY_SIZE(enum_prefix); i++) {
@@ -917,11 +942,38 @@ static int btf_enum_find_entry(struct btf *btf, char *type, struct syscall_arg_f
                      type += strlen(ep) + 1;
      }
 
-     id = btf__find_by_name(btf, type);
-     if (id < 0)
-             return -1;
+     bt = btf_find_type(btf, type);
+     if (bt == NULL)
+             return false;
 
-     bt = btf__type_by_id(btf, id);
+     for (be = btf_enum(bt), i = 0; i < btf_vlen(bt); ++i, ++be) {
+             const char *name = btf__name_by_offset(btf, be->name_off);
+             int max_len = max(size, strlen(name));
+
+             if (strncmp(name, bf, max_len) == 0) {
+                     *val = be->val;
+                     return true;
+             }
+     }
+
+     return false;
+}
+
+#define STUL_BTF_ENUM syscall_arg__strtoul_btf_enum
+
+static int btf_enum_find_entry(struct btf *btf, char *type, struct syscall_arg_fmt *arg_fmt)
+{
+     char enum_prefix[][16] = { "enum", "const enum" }, *ep;
+     const struct btf_type *bt;
+     size_t i;
+
+     for (i = 0; i < ARRAY_SIZE(enum_prefix); i++) {
+             ep = enum_prefix[i];
+             if (strlen(type) > strlen(ep) + 1 && strstarts(type, ep))
+                     type += strlen(ep) + 1;
+     }
+
+     bt = btf_find_type(btf, type);
      if (bt == NULL)
              return -1;
 
@@ -1850,6 +1902,7 @@ syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field
                      arg->scnprintf = SCA_FD;
              } else if (strstr(field->type, "enum") && use_btf != NULL) {
                      *use_btf = arg->is_enum = true;
+                     arg->strtoul = STUL_BTF_ENUM;
              } else {
                      const struct syscall_arg_fmt *fmt =
                              syscall_arg_fmt__find_by_name(field->name);
@@ -3776,7 +3829,8 @@ static int ordered_events__deliver_event(struct ordered_events *oe,
      return __trace__deliver_event(trace, event->event);
 }
 
-static struct syscall_arg_fmt *evsel__find_syscall_arg_fmt_by_name(struct evsel *evsel, char *arg)
+static struct syscall_arg_fmt *evsel__find_syscall_arg_fmt_by_name(struct evsel *evsel, char *arg,
+                                                                char **type)
 {
      struct tep_format_field *field;
      struct syscall_arg_fmt *fmt = __evsel__syscall_arg_fmt(evsel);
@@ -3785,8 +3839,10 @@ static struct syscall_arg_fmt *evsel__find_syscall_arg_fmt_by_name(struct evsel
              return NULL;
 
      for (field = evsel->tp_format->format.fields; field; field = field->next, ++fmt)
-             if (strcmp(field->name, arg) == 0)
+             if (strcmp(field->name, arg) == 0) {
+                     *type = field->type;
                      return fmt;
+             }
 
      return NULL;
 }
@@ -3824,14 +3880,14 @@ static int trace__expand_filter(struct trace *trace __maybe_unused, struct evsel
                      struct syscall_arg_fmt *fmt;
                      int left_size = tok - left,
                          right_size = right_end - right;
-                     char arg[128];
+                     char arg[128], *type;
 
                      while (isspace(left[left_size - 1]))
                              --left_size;
 
                      scnprintf(arg, sizeof(arg), "%.*s", left_size, left);
 
-                     fmt = evsel__find_syscall_arg_fmt_by_name(evsel, arg);
+                     fmt = evsel__find_syscall_arg_fmt_by_name(evsel, arg, &type);
                      if (fmt == NULL) {
                              pr_err("\"%s\" not found in \"%s\", can't set filter \"%s\"\n",
                                     arg, evsel->name, evsel->filter);
@@ -3843,9 +3899,16 @@ static int trace__expand_filter(struct trace *trace __maybe_unused, struct evsel
 
                      if (fmt->strtoul) {
                              u64 val;
-                             struct syscall_arg syscall_arg = {
-                                     .parm = fmt->parm,
-                             };
+                             struct syscall_arg syscall_arg;
+                             struct btf_parm bparm;
+
+                             if (fmt->is_enum) {
+                                     bparm.btf  = trace->btf;
+                                     bparm.type = type;
+                                     syscall_arg.parm = &bparm;
+                             } else {
+                                     syscall_arg.parm = fmt->parm;
+                             }
 
                              if (fmt->strtoul(right, right_size, &syscall_arg, &val)) {
                                      char *n, expansion[19];
--

2.45.2

author
#18 lore raw

PATCH v2 5/5 perf trace: Add test for enum augmentation

In reply to Howard Chu

Check for vmlinux's existence in sysfs as prerequisite.

Add landlock_add_rule.c workload. Trace landlock_add_rule syscall to see if the output is desirable.

Trace the non-syscall tracepoint 'timer:hrtimer_init' and 'timer:hrtimer_start', see if the 'mode' argument is augmented, the 'mode' enum argument has the prefix of 'HRTIMER_MODE_' in its name.

---
 tools/perf/tests/builtin-test.c               |  1 +
 tools/perf/tests/shell/trace_btf_enum.sh      | 57 +++++++++++++++++++
 tools/perf/tests/tests.h                      |  1 +
 tools/perf/tests/workloads/Build              |  1 +
 .../perf/tests/workloads/landlock_add_rule.c  | 32 +++++++++++
 5 files changed, 92 insertions(+)
 create mode 100755 tools/perf/tests/shell/trace_btf_enum.sh
 create mode 100644 tools/perf/tests/workloads/landlock_add_rule.c
tools/perf/tests/builtin-test.c +1 -0
index c3d84b67ca8e..e83200415ad1 100644
@@ -152,6 +152,7 @@ static struct test_workload *workloads[] = {
 	&workload__sqrtloop,
 	&workload__brstack,
 	&workload__datasym,
+	&workload__landlock_add_rule,
 };
 
 static int num_subtests(const struct test_suite *t)
tools/perf/tests/shell/trace_btf_enum.sh new file +57 -0

57 lines not on this page · raw message

tools/perf/tests/tests.h +1 -0
index 3aa7701ee0e9..69126299bb08 100644
@@ -205,6 +205,7 @@ DECLARE_WORKLOAD(leafloop);
 DECLARE_WORKLOAD(sqrtloop);
 DECLARE_WORKLOAD(brstack);
 DECLARE_WORKLOAD(datasym);
+DECLARE_WORKLOAD(landlock_add_rule);
 
 extern const char *dso_to_test;
 extern const char *test_objdump_path;
tools/perf/tests/workloads/Build +1 -0
index a1f34d5861e3..5b12b93ecffa 100644
@@ -6,6 +6,7 @@ perf-y += leafloop.o
 perf-y += sqrtloop.o
 perf-y += brstack.o
 perf-y += datasym.o
+perf-y += landlock_add_rule.o
 
 CFLAGS_sqrtloop.o         = -g -O0 -fno-inline -U_FORTIFY_SOURCE
 CFLAGS_leafloop.o         = -g -O0 -fno-inline -fno-omit-frame-pointer -U_FORTIFY_SOURCE
tools/perf/tests/workloads/landlock_add_rule.c new file +32 -0
new file mode 100644
index 000000000000..529b5f1ea5a7
@@ -0,0 +1,32 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#include <linux/compiler.h>
+#include <uapi/asm-generic/unistd.h> // for __NR_landlock_add_rule
+#include <unistd.h>
+#include <linux/landlock.h>
+#include "../tests.h"
+
+static int landlock_add_rule(int argc __maybe_unused, const char **argv __maybe_unused)
+{
+	int fd = 11;
+	int flags = 45;
+
+	struct landlock_path_beneath_attr path_beneath_attr = {
+	    .allowed_access = LANDLOCK_ACCESS_FS_READ_FILE,
+	    .parent_fd = 14,
+	};
+
+	struct landlock_net_port_attr net_port_attr = {
+	    .port = 19,
+	    .allowed_access = LANDLOCK_ACCESS_NET_CONNECT_TCP,
+	};
+
+	syscall(__NR_landlock_add_rule, fd, LANDLOCK_RULE_PATH_BENEATH,
+		&path_beneath_attr, flags);
+
+	syscall(__NR_landlock_add_rule, fd, LANDLOCK_RULE_NET_PORT,
+		&net_port_attr, flags);
+
+	return 0;
+}
+
+DEFINE_WORKLOAD(landlock_add_rule);
Signature · 1 line
2.45.2
#19 lore raw

Re: [PATCH v2 5/5] perf trace: Add test for enum augmentation

Quoted 127 lines · Howard Chu

Check for vmlinux's existence in sysfs as prerequisite.

Add landlock_add_rule.c workload. Trace landlock_add_rule syscall to see if the output is desirable.

Trace the non-syscall tracepoint 'timer:hrtimer_init' and 'timer:hrtimer_start', see if the 'mode' argument is augmented, the 'mode' enum argument has the prefix of 'HRTIMER_MODE_' in its name.

---
 tools/perf/tests/builtin-test.c               |  1 +
 tools/perf/tests/shell/trace_btf_enum.sh      | 57 +++++++++++++++++++
 tools/perf/tests/tests.h                      |  1 +
 tools/perf/tests/workloads/Build              |  1 +
 .../perf/tests/workloads/landlock_add_rule.c  | 32 +++++++++++
 5 files changed, 92 insertions(+)
 create mode 100755 tools/perf/tests/shell/trace_btf_enum.sh
 create mode 100644 tools/perf/tests/workloads/landlock_add_rule.c
tools/perf/tests/builtin-test.c +1 -0
index c3d84b67ca8e..e83200415ad1 100644
@@ -152,6 +152,7 @@ static struct test_workload *workloads[] = {
 	&workload__sqrtloop,
 	&workload__brstack,
 	&workload__datasym,
+	&workload__landlock_add_rule,
 };
 
 static int num_subtests(const struct test_suite *t)
tools/perf/tests/shell/trace_btf_enum.sh new file +57 -0
new file mode 100755
index 000000000000..4861983553ab
@@ -0,0 +1,57 @@
+#!/bin/sh
+# perf trace enum augmentation tests
+# SPDX-License-Identifier: GPL-2.0
+
+err=0
+set -e
+
+syscall="landlock_add_rule"
+non_syscall="timer:hrtimer_init,timer:hrtimer_start"
+
+TESTPROG="perf test -w landlock_add_rule"
+
+. "$(dirname $0)"/lib/probe.sh
+skip_if_no_perf_trace || exit 2
+
+check_vmlinux() {
+  echo "Checking if vmlinux exists"
+  if ! ls /sys/kernel/btf/vmlinux 1>/dev/null 2>&1
+  then
+    echo "trace+enum test [Skipped missing vmlinux BTF support]"
+    err=2
+  fi
+}
+
+trace_landlock() {
+  echo "Tracing syscall ${syscall}"
+  if perf trace -e $syscall $TESTPROG 2>&1 | \
+     grep -q -E ".*landlock_add_rule\(ruleset_fd: 11, rule_type: (LANDLOCK_RULE_PATH_BENEATH|LANDLOCK_RULE_NET_PORT), rule_attr: 0x[a-f0-9]+, flags: 45\) = -1.*"
+  then
+    err=0
+  else
+    err=1
+  fi
+}
+
+trace_non_syscall() {
+  echo "Tracing non-syscall tracepoint ${non-syscall}"
+  if perf trace -e $non_syscall --max-events=1 2>&1 | \
+     grep -q -E '.*timer:hrtimer_.*\(.*mode: HRTIMER_MODE_.*\)$'
+  then
+    err=0
+  else
+    err=1
+  fi
+}
+
+check_vmlinux
+
+if [ $err = 0 ]; then
+  trace_landlock
+fi
+
+if [ $err = 0 ]; then
+  trace_non_syscall
+fi
+
+exit $err
tools/perf/tests/tests.h +1 -0
index 3aa7701ee0e9..69126299bb08 100644
@@ -205,6 +205,7 @@ DECLARE_WORKLOAD(leafloop);
 DECLARE_WORKLOAD(sqrtloop);
 DECLARE_WORKLOAD(brstack);
 DECLARE_WORKLOAD(datasym);
+DECLARE_WORKLOAD(landlock_add_rule);
 
 extern const char *dso_to_test;
 extern const char *test_objdump_path;
tools/perf/tests/workloads/Build +1 -0
index a1f34d5861e3..5b12b93ecffa 100644
@@ -6,6 +6,7 @@ perf-y += leafloop.o
 perf-y += sqrtloop.o
 perf-y += brstack.o
 perf-y += datasym.o
+perf-y += landlock_add_rule.o
 
 CFLAGS_sqrtloop.o         = -g -O0 -fno-inline -U_FORTIFY_SOURCE
 CFLAGS_leafloop.o         = -g -O0 -fno-inline -fno-omit-frame-pointer -U_FORTIFY_SOURCE
tools/perf/tests/workloads/landlock_add_rule.c new file +0 -0
new file mode 100644
index 000000000000..529b5f1ea5a7

tools/perf/tests/workloads/landlock_add_rule.c line 5

Quoted 5 lines
tools/perf/tests/workloads/landlock_add_rule.c new file +5 -0
@@ -0,0 +1,32 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#include <linux/compiler.h>
+#include <uapi/asm-generic/unistd.h> // for __NR_landlock_add_rule
+#include <unistd.h>
+#include <linux/landlock.h>

This file was introduced on linux in 2021, unsure if it will be present in some of the older distros we test, I'll check with my container test suite.

Maybe we'll have to just define those LANDLOCK_ACCESS_FS_READ_FILE, LANDLOCK_ACCESS_NET_CONNECT_TCP, etc as plain #define to make sure it builds ok with uCLibc, musl libc and older glibc.

- Arnaldo

Quoted 30 lines
tools/perf/tests/workloads/landlock_add_rule.c new file +27 -0
+#include "../tests.h"
+
+static int landlock_add_rule(int argc __maybe_unused, const char **argv __maybe_unused)
+{
+	int fd = 11;
+	int flags = 45;
+
+	struct landlock_path_beneath_attr path_beneath_attr = {
+	    .allowed_access = LANDLOCK_ACCESS_FS_READ_FILE,
+	    .parent_fd = 14,
+	};
+
+	struct landlock_net_port_attr net_port_attr = {
+	    .port = 19,
+	    .allowed_access = LANDLOCK_ACCESS_NET_CONNECT_TCP,
+	};
+
+	syscall(__NR_landlock_add_rule, fd, LANDLOCK_RULE_PATH_BENEATH,
+		&path_beneath_attr, flags);
+
+	syscall(__NR_landlock_add_rule, fd, LANDLOCK_RULE_NET_PORT,
+		&net_port_attr, flags);
+
+	return 0;
+}
+
+DEFINE_WORKLOAD(landlock_add_rule);
Signature · 1 line
2.45.2
maintainer
#20 lore raw

Re: [PATCH v2 5/5] perf trace: Add test for enum augmentation

Hi,

Quoted 15 lines · Arnaldo Carvalho de Melo
Quoted 13 lines · Howard Chu

Check for vmlinux's existence in sysfs as prerequisite.

Add landlock_add_rule.c workload. Trace landlock_add_rule syscall to see if the output is desirable.

Trace the non-syscall tracepoint 'timer:hrtimer_init' and 'timer:hrtimer_start', see if the 'mode' argument is augmented, the 'mode' enum argument has the prefix of 'HRTIMER_MODE_' in its name.

---

[SNIP]

Quoted 16 lines

tools/perf/tests/workloads/landlock_add_rule.c line 5

Quoted 11 lines
tools/perf/tests/workloads/landlock_add_rule.c new file +5 -0
new file mode 100644
index 000000000000..529b5f1ea5a7
@@ -0,0 +1,32 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#include <linux/compiler.h>
+#include <uapi/asm-generic/unistd.h> // for __NR_landlock_add_rule
+#include <unistd.h>
+#include <linux/landlock.h>

This file was introduced on linux in 2021, unsure if it will be present in some of the older distros we test, I'll check with my container test suite.

Quoted 3 lines

Maybe we'll have to just define those LANDLOCK_ACCESS_FS_READ_FILE, LANDLOCK_ACCESS_NET_CONNECT_TCP, etc as plain #define to make sure it builds ok with uCLibc, musl libc and older glibc.

Maybe we can check if the syscall number is defined first and include the landlock header.

#ifdef __NR_landlock_add_rule
#include <linux/landlock.h>
...

Then we need a way to skip the test if it's not defined.

Thanks,
Namhyung

Quoted 34 lines

- Arnaldo

Quoted 30 lines
tools/perf/tests/workloads/landlock_add_rule.c new file +27 -1
+#include "../tests.h"
+
+static int landlock_add_rule(int argc __maybe_unused, const char **argv __maybe_unused)
+{
+     int fd = 11;
+     int flags = 45;
+
+     struct landlock_path_beneath_attr path_beneath_attr = {
+         .allowed_access = LANDLOCK_ACCESS_FS_READ_FILE,
+         .parent_fd = 14,
+     };
+
+     struct landlock_net_port_attr net_port_attr = {
+         .port = 19,
+         .allowed_access = LANDLOCK_ACCESS_NET_CONNECT_TCP,
+     };
+
+     syscall(__NR_landlock_add_rule, fd, LANDLOCK_RULE_PATH_BENEATH,
+             &path_beneath_attr, flags);
+
+     syscall(__NR_landlock_add_rule, fd, LANDLOCK_RULE_NET_PORT,
+             &net_port_attr, flags);
+
+     return 0;
+}
+
+DEFINE_WORKLOAD(landlock_add_rule);
--

2.45.2

author
#21 lore raw

Re: [PATCH v2 5/5] perf trace: Add test for enum augmentation

Quoted 41 lines · Namhyung Kim

Hi,

Quoted 15 lines · Arnaldo Carvalho de Melo
Quoted 13 lines · Howard Chu

Check for vmlinux's existence in sysfs as prerequisite.

Add landlock_add_rule.c workload. Trace landlock_add_rule syscall to see if the output is desirable.

Trace the non-syscall tracepoint 'timer:hrtimer_init' and 'timer:hrtimer_start', see if the 'mode' argument is augmented, the 'mode' enum argument has the prefix of 'HRTIMER_MODE_' in its name.

---

[SNIP]

Quoted 16 lines

tools/perf/tests/workloads/landlock_add_rule.c line 5

Quoted 11 lines
tools/perf/tests/workloads/landlock_add_rule.c new file +5 -0
new file mode 100644
index 000000000000..529b5f1ea5a7
@@ -0,0 +1,32 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#include <linux/compiler.h>
+#include <uapi/asm-generic/unistd.h> // for __NR_landlock_add_rule
+#include <unistd.h>
+#include <linux/landlock.h>

This file was introduced on linux in 2021, unsure if it will be present in some of the older distros we test, I'll check with my container test suite.

Quoted 3 lines

Maybe we'll have to just define those LANDLOCK_ACCESS_FS_READ_FILE, LANDLOCK_ACCESS_NET_CONNECT_TCP, etc as plain #define to make sure it builds ok with uCLibc, musl libc and older glibc.

Quoted 8 lines

Maybe we can check if the syscall number is defined first and include the landlock header.

#ifdef __NR_landlock_add_rule
#include <linux/landlock.h>
...

Then we need a way to skip the test if it's not defined.

Thanks for the suggestion. I'll add this to the workload script.

Thanks,
Howard

Quoted 39 lines

Thanks,
Namhyung

Quoted 34 lines

- Arnaldo

Quoted 30 lines
tools/perf/tests/workloads/landlock_add_rule.c new file +27 -1
+#include "../tests.h"
+
+static int landlock_add_rule(int argc __maybe_unused, const char **argv __maybe_unused)
+{
+     int fd = 11;
+     int flags = 45;
+
+     struct landlock_path_beneath_attr path_beneath_attr = {
+         .allowed_access = LANDLOCK_ACCESS_FS_READ_FILE,
+         .parent_fd = 14,
+     };
+
+     struct landlock_net_port_attr net_port_attr = {
+         .port = 19,
+         .allowed_access = LANDLOCK_ACCESS_NET_CONNECT_TCP,
+     };
+
+     syscall(__NR_landlock_add_rule, fd, LANDLOCK_RULE_PATH_BENEATH,
+             &path_beneath_attr, flags);
+
+     syscall(__NR_landlock_add_rule, fd, LANDLOCK_RULE_NET_PORT,
+             &net_port_attr, flags);
+
+     return 0;
+}
+
+DEFINE_WORKLOAD(landlock_add_rule);
--

2.45.2

maintainer
#22 lore raw

Re: [PATCH v2 5/5] perf trace: Add test for enum augmentation

In reply to Howard Chu

Hi Howard,

Quoted 4 lines · Howard Chu

Check for vmlinux's existence in sysfs as prerequisite.

Add landlock_add_rule.c workload. Trace landlock_add_rule syscall to see if the output is desirable.

Do you expect to add more things to the landlock workload? I think we could simply call it landlock.c and probably do other things according to the argument, if needed (e.g. landlock add).

Thanks,
Namhyung

Quoted 158 lines

Trace the non-syscall tracepoint 'timer:hrtimer_init' and 'timer:hrtimer_start', see if the 'mode' argument is augmented, the 'mode' enum argument has the prefix of 'HRTIMER_MODE_' in its name.

---
 tools/perf/tests/builtin-test.c               |  1 +
 tools/perf/tests/shell/trace_btf_enum.sh      | 57 +++++++++++++++++++
 tools/perf/tests/tests.h                      |  1 +
 tools/perf/tests/workloads/Build              |  1 +
 .../perf/tests/workloads/landlock_add_rule.c  | 32 +++++++++++
 5 files changed, 92 insertions(+)
 create mode 100755 tools/perf/tests/shell/trace_btf_enum.sh
 create mode 100644 tools/perf/tests/workloads/landlock_add_rule.c
tools/perf/tests/builtin-test.c +1 -0
index c3d84b67ca8e..e83200415ad1 100644
@@ -152,6 +152,7 @@ static struct test_workload *workloads[] = {
 	&workload__sqrtloop,
 	&workload__brstack,
 	&workload__datasym,
+	&workload__landlock_add_rule,
 };
 
 static int num_subtests(const struct test_suite *t)
tools/perf/tests/shell/trace_btf_enum.sh new file +57 -0
new file mode 100755
index 000000000000..4861983553ab
@@ -0,0 +1,57 @@
+#!/bin/sh
+# perf trace enum augmentation tests
+# SPDX-License-Identifier: GPL-2.0
+
+err=0
+set -e
+
+syscall="landlock_add_rule"
+non_syscall="timer:hrtimer_init,timer:hrtimer_start"
+
+TESTPROG="perf test -w landlock_add_rule"
+
+. "$(dirname $0)"/lib/probe.sh
+skip_if_no_perf_trace || exit 2
+
+check_vmlinux() {
+  echo "Checking if vmlinux exists"
+  if ! ls /sys/kernel/btf/vmlinux 1>/dev/null 2>&1
+  then
+    echo "trace+enum test [Skipped missing vmlinux BTF support]"
+    err=2
+  fi
+}
+
+trace_landlock() {
+  echo "Tracing syscall ${syscall}"
+  if perf trace -e $syscall $TESTPROG 2>&1 | \
+     grep -q -E ".*landlock_add_rule\(ruleset_fd: 11, rule_type: (LANDLOCK_RULE_PATH_BENEATH|LANDLOCK_RULE_NET_PORT), rule_attr: 0x[a-f0-9]+, flags: 45\) = -1.*"
+  then
+    err=0
+  else
+    err=1
+  fi
+}
+
+trace_non_syscall() {
+  echo "Tracing non-syscall tracepoint ${non-syscall}"
+  if perf trace -e $non_syscall --max-events=1 2>&1 | \
+     grep -q -E '.*timer:hrtimer_.*\(.*mode: HRTIMER_MODE_.*\)$'
+  then
+    err=0
+  else
+    err=1
+  fi
+}
+
+check_vmlinux
+
+if [ $err = 0 ]; then
+  trace_landlock
+fi
+
+if [ $err = 0 ]; then
+  trace_non_syscall
+fi
+
+exit $err
tools/perf/tests/tests.h +1 -0
index 3aa7701ee0e9..69126299bb08 100644
@@ -205,6 +205,7 @@ DECLARE_WORKLOAD(leafloop);
 DECLARE_WORKLOAD(sqrtloop);
 DECLARE_WORKLOAD(brstack);
 DECLARE_WORKLOAD(datasym);
+DECLARE_WORKLOAD(landlock_add_rule);
 
 extern const char *dso_to_test;
 extern const char *test_objdump_path;
tools/perf/tests/workloads/Build +1 -0
index a1f34d5861e3..5b12b93ecffa 100644
@@ -6,6 +6,7 @@ perf-y += leafloop.o
 perf-y += sqrtloop.o
 perf-y += brstack.o
 perf-y += datasym.o
+perf-y += landlock_add_rule.o
 
 CFLAGS_sqrtloop.o         = -g -O0 -fno-inline -U_FORTIFY_SOURCE
 CFLAGS_leafloop.o         = -g -O0 -fno-inline -fno-omit-frame-pointer -U_FORTIFY_SOURCE
tools/perf/tests/workloads/landlock_add_rule.c new file +32 -0
new file mode 100644
index 000000000000..529b5f1ea5a7
@@ -0,0 +1,32 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#include <linux/compiler.h>
+#include <uapi/asm-generic/unistd.h> // for __NR_landlock_add_rule
+#include <unistd.h>
+#include <linux/landlock.h>
+#include "../tests.h"
+
+static int landlock_add_rule(int argc __maybe_unused, const char **argv __maybe_unused)
+{
+	int fd = 11;
+	int flags = 45;
+
+	struct landlock_path_beneath_attr path_beneath_attr = {
+	    .allowed_access = LANDLOCK_ACCESS_FS_READ_FILE,
+	    .parent_fd = 14,
+	};
+
+	struct landlock_net_port_attr net_port_attr = {
+	    .port = 19,
+	    .allowed_access = LANDLOCK_ACCESS_NET_CONNECT_TCP,
+	};
+
+	syscall(__NR_landlock_add_rule, fd, LANDLOCK_RULE_PATH_BENEATH,
+		&path_beneath_attr, flags);
+
+	syscall(__NR_landlock_add_rule, fd, LANDLOCK_RULE_NET_PORT,
+		&net_port_attr, flags);
+
+	return 0;
+}
+
+DEFINE_WORKLOAD(landlock_add_rule);
Signature · 1 line
2.45.2
author
#23 lore raw

Re: [PATCH v2 5/5] perf trace: Add test for enum augmentation

Hello Namhyung,

Quoted 4 lines · Namhyung Kim

Hi Howard,

On Wed, Jun 19, 2024 at 04:20:42PM +0800, Howard Chu wrote:

Quoted 8 lines
Quoted 4 lines

Check for vmlinux's existence in sysfs as prerequisite.

Add landlock_add_rule.c workload. Trace landlock_add_rule syscall to see if the output is desirable.

Do you expect to add more things to the landlock workload? I think we could simply call it landlock.c and probably do other things according to the argument, if needed (e.g. landlock add).

Shortening the name is good, I'll change it, thanks. I think landlock_add_rule is the only syscall that we need currently, for it contains the only enum argument of all the syscalls. I'll look into how we can use these arguments, thank you.

Thanks,
Howard

Quoted 162 lines

Thanks,
Namhyung

Quoted 158 lines

Trace the non-syscall tracepoint 'timer:hrtimer_init' and 'timer:hrtimer_start', see if the 'mode' argument is augmented, the 'mode' enum argument has the prefix of 'HRTIMER_MODE_' in its name.

---
 tools/perf/tests/builtin-test.c               |  1 +
 tools/perf/tests/shell/trace_btf_enum.sh      | 57 +++++++++++++++++++
 tools/perf/tests/tests.h                      |  1 +
 tools/perf/tests/workloads/Build              |  1 +
 .../perf/tests/workloads/landlock_add_rule.c  | 32 +++++++++++
 5 files changed, 92 insertions(+)
 create mode 100755 tools/perf/tests/shell/trace_btf_enum.sh
 create mode 100644 tools/perf/tests/workloads/landlock_add_rule.c
tools/perf/tests/builtin-test.c +1 -0
index c3d84b67ca8e..e83200415ad1 100644
@@ -152,6 +152,7 @@ static struct test_workload *workloads[] = {
      &workload__sqrtloop,
      &workload__brstack,
      &workload__datasym,
+     &workload__landlock_add_rule,
 };
 
 static int num_subtests(const struct test_suite *t)
tools/perf/tests/shell/trace_btf_enum.sh new file +57 -0
new file mode 100755
index 000000000000..4861983553ab
@@ -0,0 +1,57 @@
+#!/bin/sh
+# perf trace enum augmentation tests
+# SPDX-License-Identifier: GPL-2.0
+
+err=0
+set -e
+
+syscall="landlock_add_rule"
+non_syscall="timer:hrtimer_init,timer:hrtimer_start"
+
+TESTPROG="perf test -w landlock_add_rule"
+
+. "$(dirname $0)"/lib/probe.sh
+skip_if_no_perf_trace || exit 2
+
+check_vmlinux() {
+  echo "Checking if vmlinux exists"
+  if ! ls /sys/kernel/btf/vmlinux 1>/dev/null 2>&1
+  then
+    echo "trace+enum test [Skipped missing vmlinux BTF support]"
+    err=2
+  fi
+}
+
+trace_landlock() {
+  echo "Tracing syscall ${syscall}"
+  if perf trace -e $syscall $TESTPROG 2>&1 | \
+     grep -q -E ".*landlock_add_rule\(ruleset_fd: 11, rule_type: (LANDLOCK_RULE_PATH_BENEATH|LANDLOCK_RULE_NET_PORT), rule_attr: 0x[a-f0-9]+, flags: 45\) = -1.*"
+  then
+    err=0
+  else
+    err=1
+  fi
+}
+
+trace_non_syscall() {
+  echo "Tracing non-syscall tracepoint ${non-syscall}"
+  if perf trace -e $non_syscall --max-events=1 2>&1 | \
+     grep -q -E '.*timer:hrtimer_.*\(.*mode: HRTIMER_MODE_.*\)$'
+  then
+    err=0
+  else
+    err=1
+  fi
+}
+
+check_vmlinux
+
+if [ $err = 0 ]; then
+  trace_landlock
+fi
+
+if [ $err = 0 ]; then
+  trace_non_syscall
+fi
+
+exit $err
tools/perf/tests/tests.h +1 -0
index 3aa7701ee0e9..69126299bb08 100644
@@ -205,6 +205,7 @@ DECLARE_WORKLOAD(leafloop);
 DECLARE_WORKLOAD(sqrtloop);
 DECLARE_WORKLOAD(brstack);
 DECLARE_WORKLOAD(datasym);
+DECLARE_WORKLOAD(landlock_add_rule);
 
 extern const char *dso_to_test;
 extern const char *test_objdump_path;
tools/perf/tests/workloads/Build +1 -0
index a1f34d5861e3..5b12b93ecffa 100644
@@ -6,6 +6,7 @@ perf-y += leafloop.o
 perf-y += sqrtloop.o
 perf-y += brstack.o
 perf-y += datasym.o
+perf-y += landlock_add_rule.o
 
 CFLAGS_sqrtloop.o         = -g -O0 -fno-inline -U_FORTIFY_SOURCE
 CFLAGS_leafloop.o         = -g -O0 -fno-inline -fno-omit-frame-pointer -U_FORTIFY_SOURCE
tools/perf/tests/workloads/landlock_add_rule.c new file +32 -1
new file mode 100644
index 000000000000..529b5f1ea5a7
@@ -0,0 +1,32 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#include <linux/compiler.h>
+#include <uapi/asm-generic/unistd.h> // for __NR_landlock_add_rule
+#include <unistd.h>
+#include <linux/landlock.h>
+#include "../tests.h"
+
+static int landlock_add_rule(int argc __maybe_unused, const char **argv __maybe_unused)
+{
+     int fd = 11;
+     int flags = 45;
+
+     struct landlock_path_beneath_attr path_beneath_attr = {
+         .allowed_access = LANDLOCK_ACCESS_FS_READ_FILE,
+         .parent_fd = 14,
+     };
+
+     struct landlock_net_port_attr net_port_attr = {
+         .port = 19,
+         .allowed_access = LANDLOCK_ACCESS_NET_CONNECT_TCP,
+     };
+
+     syscall(__NR_landlock_add_rule, fd, LANDLOCK_RULE_PATH_BENEATH,
+             &path_beneath_attr, flags);
+
+     syscall(__NR_landlock_add_rule, fd, LANDLOCK_RULE_NET_PORT,
+             &net_port_attr, flags);
+
+     return 0;
+}
+
+DEFINE_WORKLOAD(landlock_add_rule);
--

2.45.2

maintainer
#24 lore raw

Re: [PATCH v2 5/5] perf trace: Add test for enum augmentation

Quoted 13 lines · Howard Chu

Hello Namhyung,

Quoted 9 lines · Namhyung Kim

Hi Howard,

Quoted 4 lines · Howard Chu

Check for vmlinux's existence in sysfs as prerequisite.

Add landlock_add_rule.c workload. Trace landlock_add_rule syscall to see if the output is desirable.

Quoted 8 lines
Quoted 3 lines

Do you expect to add more things to the landlock workload? I think we could simply call it landlock.c and probably do other things according to the argument, if needed (e.g. landlock add).

Shortening the name is good, I'll change it, thanks. I think landlock_add_rule is the only syscall that we need currently, for it contains the only enum argument of all the syscalls. I'll look into how we can use these arguments, thank you.

If you don't plan to add something, let's call it landlock.c and forget about the argument handling for now. :)

But please add a comment in the file that it's just to test BPF handling of enum arguments.

Thanks,
Namhyung

#25 lore raw

Re: [PATCH v2 5/5] perf trace: Add test for enum augmentation

In reply to Howard Chu
kernel test robot noticed the following build errors:

Hi Howard,

kernel test robot noticed the following build errors:

[auto build test ERROR on perf-tools-next/perf-tools-next]
[also build test ERROR on next-20240621]
[cannot apply to tip/perf/core perf-tools/perf-tools acme/perf/core linus/master v6.10-rc5] [If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]

url:    https://github.com/intel-lab-lkp/linux/commits/Howard-Chu/perf-trace-Fix-iteration-of-syscall-ids-in-syscalltbl-entries/20240619-162417
base:   https://git.kernel.org/pub/scm/linux/kernel/git/perf/perf-tools-next.git perf-tools-next
patch link:    https://lore.kernel.org/r/20240619082042.4173621-6-howardchu95%40gmail.com
patch subject: [PATCH v2 5/5] perf trace: Add test for enum augmentation

:::::: branch date: 5 days ago
:::::: commit date: 5 days ago
compiler: clang version 18.1.5 (https://github.com/llvm/llvm-project 617a15a9eac96088ae5e9134248d8236e34b91b1) reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20240625/[email protected]/reproduce)

If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/r/[email protected]/

All errors (new ones prefixed by >>):

Makefile.config:663: No libunwind found. Please install libunwind-dev[el] >= 1.1 and/or set LIBUNWIND_DIR

     PERF_VERSION = 6.10.rc1.gf6ac54426465
>> tests/workloads/landlock_add_rule.c:20:24: error: use of undeclared identifier 'LANDLOCK_ACCESS_NET_CONNECT_TCP'
      20 |             .allowed_access = LANDLOCK_ACCESS_NET_CONNECT_TCP,
         |                               ^
>> tests/workloads/landlock_add_rule.c:18:32: error: variable has incomplete type 'struct landlock_net_port_attr'
      18 |         struct landlock_net_port_attr net_port_attr = {
         |                                       ^
   tests/workloads/landlock_add_rule.c:18:9: note: forward declaration of 'struct landlock_net_port_attr'
      18 |         struct landlock_net_port_attr net_port_attr = {
         |                ^
>> tests/workloads/landlock_add_rule.c:26:38: error: use of undeclared identifier 'LANDLOCK_RULE_NET_PORT'

26 | syscall(__NR_landlock_add_rule, fd, LANDLOCK_RULE_NET_PORT,
| ^
3 errors generated.
make[8]: *** [tools/build/Makefile.build:105: tools/perf/tests/workloads/landlock_add_rule.o] Error 1 make[8]: *** Waiting for unfinished jobs....
make[7]: *** [tools/build/Makefile.build:158: workloads] Error 2
make[7]: *** Waiting for unfinished jobs....
make[6]: *** [tools/build/Makefile.build:158: tests] Error 2
make[6]: *** Waiting for unfinished jobs....
make[5]: *** [Makefile.perf:727: tools/perf/perf-in.o] Error 2
make[5]: *** Waiting for unfinished jobs....
make[4]: *** [Makefile.perf:264: sub-make] Error 2
make[3]: *** [Makefile:70: all] Error 2

vim +/LANDLOCK_ACCESS_NET_CONNECT_TCP +20 tools/perf/tests/workloads/landlock_add_rule.c

f6ac54426465a5 Howard Chu 2024-06-19   7  
f6ac54426465a5 Howard Chu 2024-06-19   8  static int landlock_add_rule(int argc __maybe_unused, const char **argv __maybe_unused)
f6ac54426465a5 Howard Chu 2024-06-19   9  {
f6ac54426465a5 Howard Chu 2024-06-19  10  	int fd = 11;
f6ac54426465a5 Howard Chu 2024-06-19  11  	int flags = 45;
f6ac54426465a5 Howard Chu 2024-06-19  12  
f6ac54426465a5 Howard Chu 2024-06-19  13  	struct landlock_path_beneath_attr path_beneath_attr = {
f6ac54426465a5 Howard Chu 2024-06-19  14  	    .allowed_access = LANDLOCK_ACCESS_FS_READ_FILE,
f6ac54426465a5 Howard Chu 2024-06-19  15  	    .parent_fd = 14,
f6ac54426465a5 Howard Chu 2024-06-19  16  	};
f6ac54426465a5 Howard Chu 2024-06-19  17  
f6ac54426465a5 Howard Chu 2024-06-19  18  	struct landlock_net_port_attr net_port_attr = {
f6ac54426465a5 Howard Chu 2024-06-19  19  	    .port = 19,
f6ac54426465a5 Howard Chu 2024-06-19 @20  	    .allowed_access = LANDLOCK_ACCESS_NET_CONNECT_TCP,
f6ac54426465a5 Howard Chu 2024-06-19  21  	};
f6ac54426465a5 Howard Chu 2024-06-19  22  
f6ac54426465a5 Howard Chu 2024-06-19  23  	syscall(__NR_landlock_add_rule, fd, LANDLOCK_RULE_PATH_BENEATH,
f6ac54426465a5 Howard Chu 2024-06-19  24  		&path_beneath_attr, flags);
f6ac54426465a5 Howard Chu 2024-06-19  25  
f6ac54426465a5 Howard Chu 2024-06-19  26  	syscall(__NR_landlock_add_rule, fd, LANDLOCK_RULE_NET_PORT,
f6ac54426465a5 Howard Chu 2024-06-19  27  		&net_port_attr, flags);
f6ac54426465a5 Howard Chu 2024-06-19  28  
f6ac54426465a5 Howard Chu 2024-06-19  29  	return 0;
f6ac54426465a5 Howard Chu 2024-06-19  30  }
f6ac54426465a5 Howard Chu 2024-06-19  31  
Signature · 2 lines
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
#26 lore raw
In reply to Howard Chu
Quoted 3 lines · Howard Chu

changes in v2:
- Move inline landlock_add_rule c code to tests/workloads
- Rename 'enum_aug_prereq' to 'check_vmlinux'

Usually the versions descriptions comes at the end, after your signature line, just before the list of csets in the series.

Quoted 8 lines

Augment enum arguments in perf trace, including syscall arguments and non-syscall tracepoint arguments. The augmentation is implemented using BTF.

This patch series also includes a bug fix by Arnaldo Carvalho de Melo <[email protected]>, which makes more syscalls to be traceable by perf trace.

Test is included.

Thanks, the patch submission is now very good, at some point you'll be able to point to a git tree from where to do a pull, then have it with a signed tag, etc, all this is not necessary at this point in our collaboration, but as you evolve as a kernel developer, it eventually will be asked from you.

And it comes with a test that introduces a 'perf test -w' workload, super great!

- Arnaldo

Quoted 22 lines

Howard Chu (5):
perf trace: Fix iteration of syscall ids in syscalltbl->entries perf trace: Augment enum syscall arguments with BTF perf trace: Augment enum tracepoint arguments with BTF perf trace: Filter enum arguments with enum names perf trace: Add test for enum augmentation

 tools/perf/builtin-trace.c                    | 214 ++++++++++++++++--
 tools/perf/tests/builtin-test.c               |   1 +
 tools/perf/tests/shell/trace_btf_enum.sh      |  57 +++++
 tools/perf/tests/tests.h                      |   1 +
 tools/perf/tests/workloads/Build              |   1 +
 .../perf/tests/workloads/landlock_add_rule.c  |  32 +++
 tools/perf/util/syscalltbl.c                  |   7 +
 tools/perf/util/syscalltbl.h                  |   1 +
 8 files changed, 289 insertions(+), 25 deletions(-)
 create mode 100755 tools/perf/tests/shell/trace_btf_enum.sh
 create mode 100644 tools/perf/tests/workloads/landlock_add_rule.c
Signature · 1 line
2.45.2
maintainer
#27 lore raw

Hello,

Quoted 24 lines · Arnaldo Carvalho de Melo
Quoted 3 lines · Howard Chu

changes in v2:
- Move inline landlock_add_rule c code to tests/workloads
- Rename 'enum_aug_prereq' to 'check_vmlinux'

Usually the versions descriptions comes at the end, after your signature line, just before the list of csets in the series.

Quoted 8 lines

Augment enum arguments in perf trace, including syscall arguments and non-syscall tracepoint arguments. The augmentation is implemented using BTF.

This patch series also includes a bug fix by Arnaldo Carvalho de Melo <[email protected]>, which makes more syscalls to be traceable by perf trace.

Test is included.

Thanks, the patch submission is now very good, at some point you'll be able to point to a git tree from where to do a pull, then have it with a signed tag, etc, all this is not necessary at this point in our collaboration, but as you evolve as a kernel developer, it eventually will be asked from you.

Quoted 11 lines

And it comes with a test that introduces a 'perf test -w' workload, super great!

- Arnaldo

Quoted 6 lines

Howard Chu (5):
perf trace: Fix iteration of syscall ids in syscalltbl->entries perf trace: Augment enum syscall arguments with BTF perf trace: Augment enum tracepoint arguments with BTF perf trace: Filter enum arguments with enum names perf trace: Add test for enum augmentation

Please make sure that your change doesn't break the build in case libbpf is not available. For example, a build without libelf seems to be broken.

  $ make NO_LIBELF=1

Thanks,
Namhyung

author
#28 lore raw
Quoted 41 lines · Namhyung Kim

Hello,

Quoted 24 lines · Arnaldo Carvalho de Melo
Quoted 3 lines · Howard Chu

changes in v2:
- Move inline landlock_add_rule c code to tests/workloads
- Rename 'enum_aug_prereq' to 'check_vmlinux'

Usually the versions descriptions comes at the end, after your signature line, just before the list of csets in the series.

Quoted 8 lines

Augment enum arguments in perf trace, including syscall arguments and non-syscall tracepoint arguments. The augmentation is implemented using BTF.

This patch series also includes a bug fix by Arnaldo Carvalho de Melo <[email protected]>, which makes more syscalls to be traceable by perf trace.

Test is included.

Thanks, the patch submission is now very good, at some point you'll be able to point to a git tree from where to do a pull, then have it with a signed tag, etc, all this is not necessary at this point in our collaboration, but as you evolve as a kernel developer, it eventually will be asked from you.

Quoted 11 lines

And it comes with a test that introduces a 'perf test -w' workload, super great!

- Arnaldo

Quoted 6 lines

Howard Chu (5):
perf trace: Fix iteration of syscall ids in syscalltbl->entries perf trace: Augment enum syscall arguments with BTF perf trace: Augment enum tracepoint arguments with BTF perf trace: Filter enum arguments with enum names perf trace: Add test for enum augmentation

Quoted 8 lines

Please make sure that your change doesn't break the build in case libbpf is not available. For example, a build without libelf seems to be broken.

  $ make NO_LIBELF=1

Thanks,
Namhyung

Thank you, I'll fix this.

Thanks,
Howard

author
#29 lore raw

Hello,

Now $ make NO_LIBELF=1 can build successfully, and if __NR_landlock_add_rule is not defined, we'll skip the test. The fixes that Arnaldo suggested are also included.

I added too many things, changed some behaviors, figured it's probably easier for you to merge from my source tree.

The fixes are on the perf-tools-next branch at:
https://github.com/Sberm/linux.git

please use

```
git pull https://github.com/Sberm/linux.git perf-tools-next
```

I'm no git expert so please tell me if something is wrong.

P.S. not my proudest patch, changed too many things, might be buggy. If there're bugs please let me know.

Quoted 56 lines · Howard Chu
Quoted 41 lines · Namhyung Kim

Hello,

Quoted 24 lines · Arnaldo Carvalho de Melo
Quoted 3 lines · Howard Chu

changes in v2:
- Move inline landlock_add_rule c code to tests/workloads
- Rename 'enum_aug_prereq' to 'check_vmlinux'

Usually the versions descriptions comes at the end, after your signature line, just before the list of csets in the series.

Quoted 8 lines

Augment enum arguments in perf trace, including syscall arguments and non-syscall tracepoint arguments. The augmentation is implemented using BTF.

This patch series also includes a bug fix by Arnaldo Carvalho de Melo <[email protected]>, which makes more syscalls to be traceable by perf trace.

Test is included.

Thanks, the patch submission is now very good, at some point you'll be able to point to a git tree from where to do a pull, then have it with a signed tag, etc, all this is not necessary at this point in our collaboration, but as you evolve as a kernel developer, it eventually will be asked from you.

Quoted 11 lines

And it comes with a test that introduces a 'perf test -w' workload, super great!

- Arnaldo

Quoted 6 lines

Howard Chu (5):
perf trace: Fix iteration of syscall ids in syscalltbl->entries perf trace: Augment enum syscall arguments with BTF perf trace: Augment enum tracepoint arguments with BTF perf trace: Filter enum arguments with enum names perf trace: Add test for enum augmentation

Quoted 8 lines

Please make sure that your change doesn't break the build in case libbpf is not available. For example, a build without libelf seems to be broken.

  $ make NO_LIBELF=1

Thanks,
Namhyung

Thank you, I'll fix this.

Thanks,
Howard