tracing: Expose tracepoint BTF ids via tracefs
Subsystems (4)
v2 cover tracing: Expose tracepoint BTF ids via tracefs
BPF and other consumers that want to attach to or decode a generic tracepoint need three pieces of BTF information for it:
- the BTF of the object that owns the tracepoint's types
- the FUNC_PROTO describing the tracepoint arguments (with names), consumed by raw_tp / tp_btf BPF programs
- the STRUCT id of trace_event_raw_<call>, the ring-buffer record consumed by classic BPF_PROG_TYPE_TRACEPOINT programs
Today none of this is easily discoverable from userspace. The kernel knows the ids - resolve_btfids fills them in at link time - but consumers have to search them by the naming convention ("__bpf_trace_<name>", "trace_event_raw_<name>"), walking BTF for every tracepoint.
This series stores those ids in trace_event_class and exposes them via events/<sys>/<event>/btf_ids, e.g.
# cat /sys/kernel/tracing/events/sched/sched_switch/btf_ids
btf_obj_id: 1
raw_btf_id: 28882
tp_btf_id: 106335 # bpftool btf dump id 1 root_id 28882 format raw
[28882] FUNC_PROTO '(anon)' ret_type_id=0 vlen=5
'__data' type_id=9
'preempt' type_id=60674
'prev' type_id=219
'next' type_id=219
'prev_state' type_id=108689 # bpftool btf dump id 1 root_id 106335 format raw
[106335] STRUCT 'trace_event_raw_sched_switch' size=64 vlen=9
'ent' type_id=104654 bits_offset=0
'prev_comm' type_id=580 bits_offset=64
'prev_pid' type_id=92875 bits_offset=192
'prev_prio' type_id=79365 bits_offset=224
'prev_state' type_id=83958 bits_offset=256
'next_comm' type_id=580 bits_offset=320
'next_pid' type_id=92875 bits_offset=448
'next_prio' type_id=79365 bits_offset=480
'__data' type_id=407 bits_offset=512For per-syscall events (all sharing the same dispatcher), raw_btf_id is 0 — raw_tp / tp_btf programs attach to raw_syscalls/sys_{enter,exit}, not per-syscall events:
# cat /sys/kernel/tracing/events/syscalls/sys_enter_write/btf_ids
btf_obj_id: 1
raw_btf_id: 0
tp_btf_id: 106540This unlocks few usecases for consumers:
- Resolving tp_btf attach targets and argument types directly, instead of constructing "__bpf_trace_*" names and re-discovering them in vmlinux BTF.
- Get a stable, machine-readable contract for tracepoint payloads, with field names preserved.
Patch 1 exports the two BTF helpers the tracing core needs. Patch 2 wires DECLARE_EVENT_CLASS to publish the ids, adds the tracefs
reader, and wires the syscall classes so per-syscall events carry tp_btf_id (raw_btf_id is 0 there — see above).
Patch 3 adds a selftest covering the sched_switch tracepoint.
---
Changes in v2:
- kernel/bpf/btf.c: dropped both EXPORT_SYMBOL_GPL()
- kernel/trace/trace_events.c (event_btf_ids_read):
replaced guard(mutex)(&event_mutex) with explicit mutex_lock/mutex_unlock. scnprintf() and simple_read_from_buffer() (which calls copy_to_user()) now run outside the lock work.
- tools/testing/selftests/bpf/prog_tests/tp_btf_ids.c:
- Added if (!env.has_testmod) { test__skip(); return; } at the top of test_tp_btf_ids() so the test skips gracefully when bpf_testmod.ko is absent.
- Wrapped ASSERT_EQ(btf_vlen(proto_t), 3, ...) with if (!...) goto out; to prevent OOB read of params[2].
- Added if (!ASSERT_GE(btf_vlen(rec_t), 5, ...)) goto out; before reading
members[0..4].
- Link to v1: https://patch.msgid.link/[email protected]
---
Mykyta Yatsenko (3):
bpf: Make btf_get_module_btf() and btf_relocate_id() non-static
tracing: Expose tracepoint BTF ids via tracefs selftests/bpf: Add test for tracepoint btf_ids tracefs file
include/linux/btf.h | 2 + include/linux/trace_events.h | 9 ++ include/trace/trace_events.h | 24 ++++ kernel/bpf/btf.c | 4 +- kernel/trace/trace_events.c | 80 ++++++++++++- kernel/trace/trace_syscalls.c | 17 +++ .../testing/selftests/bpf/prog_tests/tp_btf_ids.c | 132 +++++++++++++++++++++ 7 files changed, 265 insertions(+), 3 deletions(-)
---
base-commit: 8668cd470c38011c44a42f6c7b188f4149f23a7a
change-id: 20260508-generic_tracepoint-d488a5a7ab18
Best regards,
Signature · 1 line
Mykyta Yatsenko <[email protected]>
PATCH v2 1/3 bpf: Make btf_get_module_btf() and btf_relocate_id() non-static
From: Mykyta Yatsenko <[email protected]>
Drop the static qualifier and add prototypes to <linux/btf.h> so the tracing core can look up module BTF and translate ids stored by resolve_btfids (which are local to a module's split BTF) into the runtime ids used by the kernel.
Used by the upcoming events/<sys>/<event>/btf_ids tracefs interface.
--- include/linux/btf.h | 2 ++ kernel/bpf/btf.c | 4 ++-- 2 files changed, 4 insertions(+), 2 deletions(-)
include/linux/btf.h +2 -0
@@ -235,6 +235,8 @@ int btf_check_and_fixup_fields(const struct btf *btf, struct btf_record *rec);bool btf_type_is_void (const struct btf_type *t);s32 btf_find_by_name_kind (const struct btf *btf,const char *name,u8 kind);s32 bpf_find_btf_id (const char *name,u32 kind,struct btf **btf_p); +struct btf *btf_get_module_btf (const struct module *module); +__u32 btf_relocate_id (const struct btf *btf,__u32 id);const struct btf_type *btf_type_skip_modifiers (const struct btf *btf,u32 id,u32 *res_id); const struct btf_type *btf_type_resolve_ptr(const struct btf *btf,
kernel/bpf/btf.c +2 -2
@@ -6429,7 +6429,7 @@ struct btf *btf_parse_vmlinux(void)* split BTF ids will need to be mapped to actual base/split ids for * BTF now that it has been relocated. */ -static __u32 btf_relocate_id (const struct btf *btf,__u32 id) +__u32 btf_relocate_id (const struct btf *btf,__u32 id) {if (!btf->base_btf || !btf->base_id_map)return id;
@@ -8496,7 +8496,7 @@ struct module *btf_try_get_module(const struct btf *btf)/* Returns struct btf corresponding to the struct module. * This function can return NULL or ERR_PTR. */ -static struct btf *btf_get_module_btf (const struct module *module) +struct btf *btf_get_module_btf (const struct module *module) {#ifdef CONFIG_DEBUG_INFO_BTF_MODULES struct btf_module *btf_mod, *tmp;
Signature · 1 line
2.53.0-Meta
PATCH v2 2/3 tracing: Expose tracepoint BTF ids via tracefs
In reply to Mykyta YatsenkoFrom: Mykyta Yatsenko <[email protected]>
Add events/<sys>/<event>/btf_ids, a per-template file that exposes the BTF ids resolve_btfids fills in for each tracepoint:
btf_obj_id BTF object owning the ids below
raw_btf_id FUNC_PROTO of __bpf_trace_<call> (named args), consumed
by raw_tp / tp_btf BPF programs
tp_btf_id trace_event_raw_<call> ring-buffer record, consumed by
classic BPF_PROG_TYPE_TRACEPOINT programs
DECLARE_EVENT_CLASS now emits a 2-entry BTF_ID_LIST (FUNC __bpf_trace_* and STRUCT trace_event_raw_*) and stores the pointer in trace_event_class.
Per-syscall events under syscalls/ share the handcrafted classes event_class_syscall_{enter,exit} instead of going through DECLARE_EVENT_CLASS. Wire those classes to the BTF id lists generated for sys_enter / sys_exit so all ~700 per-syscall events expose the shared dispatcher prototype and record. The per-syscall events do not own their own tracepoint (they share sys_enter/sys_exit), so raw_btf_id is reported as 0 on those events; the meaningful raw_btf_id is exposed on raw_syscalls/sys_{enter,exit}/btf_ids where raw_tp / tp_btf programs can actually attach.
--- include/linux/trace_events.h | 9 +++++ include/trace/trace_events.h | 24 +++++++++++++ kernel/trace/trace_events.c | 80 ++++++++++++++++++++++++++++++++++++++++++- kernel/trace/trace_syscalls.c | 17 +++++++++ 4 files changed, 129 insertions(+), 1 deletion(-)
include/linux/trace_events.h +9 -0
@@ -298,6 +298,15 @@ struct trace_event_class {struct list_head *(*get_fields)(struct trace_event_call *);struct list_head fields;int (*raw_init)(struct trace_event_call *); +#ifdef CONFIG_BPF_EVENTS +/* +* Per-template BTF ids set by DECLARE_EVENT_CLASS via BTF_ID() and +* patched by resolve_btfids at link time. NULL for handcrafted classes. +* [0] FUNC __bpf_trace_<template> +* [1] STRUCT trace_event_raw_<template> +*/ +const u32 *btf_ids; +#endif }; extern int trace_event_reg(struct trace_event_call *event,
include/trace/trace_events.h +24 -0
@@ -19,6 +19,7 @@*/ #include <linux/trace_events.h> +#include <linux/btf_ids.h> #ifndef TRACE_SYSTEM_VAR #define TRACE_SYSTEM_VAR TRACE_SYSTEM
@@ -397,6 +398,27 @@ static inline notrace int trace_event_get_offsets_##call( \#define _TRACE_PERF_INIT (call)#endif /* CONFIG_PERF_EVENTS */ +#ifdef CONFIG_BPF_EVENTS +/* +* Per-template BTF id list, populated at link time by resolve_btfids: +* [0] FUNC __bpf_trace_<call> (the BPF dispatcher) +* [1] STRUCT trace_event_raw_<call> (the ring-buffer record) +* Exposed via the events/<sys>/<name>/btf_ids tracefs file. +*/ +#define _TRACE_BTF_IDS_DECLARE (call) \ + extern u32 __bpf_trace_btf_ids_##call[]; \ + BTF_ID_LIST_GLOBAL(__bpf_trace_btf_ids_##call, 2) \ + BTF_ID(func, __bpf_trace_##call) \ + BTF_ID(struct, trace_event_raw_##call) + +#define _TRACE_BTF_IDS_INIT (call) \ + .btf_ids = __bpf_trace_btf_ids_##call, + +#else +#define _TRACE_BTF_IDS_DECLARE (call) +#define _TRACE_BTF_IDS_INIT (call) +#endif /* CONFIG_BPF_EVENTS */ +#include "stages/stage6_event_callback.h"
@@ -474,6 +496,7 @@ static inline void ftrace_test_probe_##call(void) \#undef DECLARE_EVENT_CLASS#define DECLARE_EVENT_CLASS (call, proto, args, tstruct, assign, print) \ _TRACE_PERF_PROTO(call, PARAMS(proto)); \ +_TRACE_BTF_IDS_DECLARE(call) \ static char print_fmt_##call[] = print; \ static struct trace_event_class __used __refdata event_class_##call = { \ .system = TRACE_SYSTEM_STRING, \
@@ -483,6 +506,7 @@ static struct trace_event_class __used __refdata event_class_##call = { \ .probe = trace_event_raw_event_##call, \ .reg = trace_event_reg, \ _TRACE_PERF_INIT(call) \ + _TRACE_BTF_IDS_INIT(call) \ };#undef DECLARE_EVENT_SYSCALL_CLASS
kernel/trace/trace_events.c +79 -1
110 lines not on this page · raw message
kernel/trace/trace_syscalls.c +17 -0
@@ -1303,12 +1303,26 @@ struct trace_event_functions exit_syscall_print_funcs = { .trace = print_syscall_exit, }; +#ifdef CONFIG_BPF_EVENTS +/* +* BTF id lists generated by DECLARE_EVENT_CLASS for the sys_enter and +* sys_exit tracepoints. The auto-generated event_class_sys_{enter,exit} +* is unused (per-syscall events share the handcrafted classes below), +* but the id lists themselves are global and reusable. +*/ +extern u32 __bpf_trace_btf_ids_sys_enter[]; +extern u32 __bpf_trace_btf_ids_sys_exit[]; +#endif +struct trace_event_class __refdata event_class_syscall_enter = { .system ="syscalls" , .reg = syscall_enter_register, .fields_array = syscall_enter_fields_array, .get_fields = syscall_get_enter_fields, .raw_init = init_syscall_trace, +#ifdef CONFIG_BPF_EVENTS + .btf_ids = __bpf_trace_btf_ids_sys_enter, +#endif };struct trace_event_class __refdata event_class_syscall_exit = {
@@ -1321,6 +1335,9 @@ struct trace_event_class __refdata event_class_syscall_exit = { }, .fields = LIST_HEAD_INIT(event_class_syscall_exit.fields), .raw_init = init_syscall_trace, +#ifdef CONFIG_BPF_EVENTS + .btf_ids = __bpf_trace_btf_ids_sys_exit, +#endif };unsigned long __init __weak arch_syscall_addr (int nr)
Signature · 1 line
2.53.0-Meta
Hi Steven,
Gentle ping on this patch from the series.
Since this part touches tracing, I’d appreciate your thoughts on the tracing changes whenever you have a chance.
Thanks,
Mykyta
Steven Rostedt
maintainerQuoted 7 lines · On Tue, 26 May 2026 11:07:56 +0100 Mykyta Yatsenko…
Hi Steven,
Gentle ping on this patch from the series.
Since this part touches tracing, I’d appreciate your thoughts on the tracing changes whenever you have a chance.
Hi,
I've been looking at this and was wondering if there are ways to not extend the trace_event_class structure. It's added for most trace events (actually each DECLARE_EVENT_CLASS). Although when things like BTF is enabled, this is a very small amount of extra memory.
I haven't been ignoring this. I've just been thinking about other approaches, but haven't come up with anything. Of course, I haven't been spending that much time on it, as I've been focused on other things.
-- Steve
Quoted 19 lines · Steven Rostedt
Quoted 7 lines · On Tue, 26 May 2026 11:07:56 +0100 Mykyta Yatsenko…
Hi Steven,
Gentle ping on this patch from the series.
Since this part touches tracing, I’d appreciate your thoughts on the tracing changes whenever you have a chance.
Hi,
I've been looking at this and was wondering if there are ways to not extend the
trace_event_classstructure. It's added for most trace events (actually eachDECLARE_EVENT_CLASS). Although when things like BTF is enabled, this is a very small amount of extra memory.
Quoted 4 lines
I haven't been ignoring this. I've just been thinking about other approaches, but haven't come up with anything. Of course, I haven't been spending that much time on it, as I've been focused on other things.
Just in theory, what alternative would there be besides having one extra pointer in trace_event_class struct? Some sort of lookup by name or something? E.g., if we know "call" part at runtime for any given tracepoint for
.btf_ids = __bpf_trace_btf_ids_##call,
we can probably lookup symbol from kallsyms and fetch BTF IDs that way without extending the struct?
FWIW, this type info for tracepoints (classic and raw both) are very useful, because right now one needs to do a bunch of work (subject to break due to kernel type/name changes, etc) to find this, and for various generic tracing tooling this type information is actually a necessity to be useful.
That's just to say that it would be great to have this in some form of shape, so please help getting this into acceptable form, thanks!
Quoted 2 lines
-- Steve
Steven Rostedt
maintainerQuoted 2 lines · On Wed, 3 Jun 2026 15:41:50 -0700 Andrii Nakryiko <[email protected]>…
That's just to say that it would be great to have this in some form of shape, so please help getting this into acceptable form, thanks!
As I said, I'm not against it. I was hoping to find something to help alleviate the memory usage.
I'll likely take these as is, but I'm currently on vacation and it will have to wait until next week.
-- Steve
Quoted 4 lines · Steven Rostedt
On Wed, 3 Jun 2026 15:41:50 -0700
Andrii Nakryiko <[email protected]> wrote:
Quoted 9 lines
Quoted 2 lines
That's just to say that it would be great to have this in some form of shape, so please help getting this into acceptable form, thanks!
As I said, I'm not against it. I was hoping to find something to help alleviate the memory usage.
I'll likely take these as is, but I'm currently on vacation and it will have to wait until next week.
Yeah, no worries, I was just going through my backlog and trying to think if we can avoid extending the tracepoint class struct. Besides the somewhat dirty kallsyms symbol lookup logic, I don't see any other way.
Enjoy your vacation!
Quoted 2 lines
-- Steve
PATCH v2 3/3 selftests/bpf: Add test for tracepoint btf_ids tracefs file
In reply to Mykyta YatsenkoFrom: Mykyta Yatsenko <[email protected]>
Read events/bpf_testmod/bpf_testmod_test_read/btf_ids and verify the exported FUNC_PROTO matches the testmod tracepoint signature (__data, struct task_struct *task, struct bpf_testmod_test_read_ctx *ctx) and the record struct trace_event_raw_bpf_testmod_test_read carries the fields declared by TP_STRUCT__entry.
Use the testmod tracepoint so the test exercises the module/split-BTF path (btf_relocate_id) rather than vmlinux only, and falls back from /sys/kernel/tracing to /sys/kernel/debug/tracing when tracefs is not mounted at the new location.
--- .../testing/selftests/bpf/prog_tests/tp_btf_ids.c | 132 +++++++++++++++++++++ 1 file changed, 132 insertions(+)
tools/testing/selftests/bpf/prog_tests/tp_btf_ids.c new file +132 -0
@@ -0,0 +1,132 @@ +// SPDX-License-Identifier: GPL-2.0 +#include <test_progs.h> +#include <bpf/btf.h> + +#define TRACEFS "/sys/kernel/tracing" +#define DEBUGFS_TRACING "/sys/kernel/debug/tracing" +#define EVENT_SUBPATH "events/bpf_testmod/bpf_testmod_test_read/btf_ids" + +struct btf_ids_info { +__u32 obj_id; +__u32 raw_id; +__u32 tp_id; +}; + +static const char *btf_ids_path (char *buf,size_t sz) +{ +if (access (TRACEFS "/trace" ,F_OK ) ==0 ) +snprintf (buf, sz,"%s/%s" ,TRACEFS ,EVENT_SUBPATH ); +else +snprintf (buf, sz,"%s/%s" ,DEBUGFS_TRACING ,EVENT_SUBPATH ); +return buf; +} + +static int read_btf_ids (struct btf_ids_info *info) +{ +char path[256 ], buf[256 ]; +int fd, n; + + fd =open (btf_ids_path (path,sizeof (path)),O_RDONLY ); +if (fd <0 ) +return -errno; + + n =read (fd, buf,sizeof (buf) -1 ); +close (fd); +if (n <=0 ) +return -EIO ; + buf[n] ='\0' ; + +if (sscanf (buf, +"btf_obj_id: %u\nraw_btf_id: %u\ntp_btf_id: %u\n" , + &info->obj_id, &info->raw_id, &info->tp_id) !=3 ) +return -EINVAL ; +return 0 ; +} + +static const char *param_name (struct btf *btf,const struct btf_param *p) +{ +return btf__name_by_offset (btf, p->name_off); +} + +static const char *member_name (struct btf *btf,const struct btf_member *m) +{ +return btf__name_by_offset (btf, m->name_off); +} + +void test_tp_btf_ids (void ) +{ +const struct btf_type *proto_t, *rec_t; +const struct btf_param *params; +const struct btf_member *members; +struct btf_ids_info info; +struct btf *vmlinux_btf, *btf; +const char *name; +int err; + +if (!env.has_testmod) { +test__skip (); +return ; + } + + err =read_btf_ids (&info); +if (!ASSERT_OK (err,"read btf_ids" )) +return ; + +ASSERT_GT (info.obj_id,0 ,"obj_id non-zero" ); +ASSERT_GT (info.raw_id,0 ,"raw_id non-zero" ); +ASSERT_GT (info.tp_id,0 ,"tp_id non-zero" ); + + vmlinux_btf =btf__load_vmlinux_btf (); +if (!ASSERT_OK_PTR (vmlinux_btf,"load vmlinux BTF" )) +return ; + +/* Module BTF is split BTF; load with vmlinux as base. */ + btf =btf__load_from_kernel_by_id_split (info.obj_id, vmlinux_btf); +if (!ASSERT_OK_PTR (btf,"load module BTF" )) { +btf__free (vmlinux_btf); +return ; + } + +/* +* raw_btf_id should be the FUNC_PROTO of __bpf_trace_<call>: +* void *__data, struct task_struct *task, +* struct bpf_testmod_test_read_ctx *ctx +*/ + proto_t =btf__type_by_id (btf, info.raw_id); +if (!ASSERT_OK_PTR (proto_t,"raw type_by_id" )) + goto out; +if (!ASSERT_TRUE (btf_is_func_proto (proto_t),"raw is FUNC_PROTO" )) + goto out; +if (!ASSERT_EQ (btf_vlen (proto_t),3 ,"func_proto arg count" )) + goto out; + + params =btf_params (proto_t); +ASSERT_STREQ (param_name (btf, ¶ms[0 ]),"__data" ,"arg0 name" ); +ASSERT_STREQ (param_name (btf, ¶ms[1 ]),"task" ,"arg1 name" ); +ASSERT_STREQ (param_name (btf, ¶ms[2 ]),"ctx" ,"arg2 name" ); + +/* +* tp_btf_id should be STRUCT trace_event_raw_<call> with the +* fields declared by TP_STRUCT__entry plus the common header. +*/ + rec_t =btf__type_by_id (btf, info.tp_id); +if (!ASSERT_OK_PTR (rec_t,"tp type_by_id" )) + goto out; +if (!ASSERT_TRUE (btf_is_struct (rec_t),"tp is STRUCT" )) + goto out; + name =btf__name_by_offset (btf, rec_t->name_off); +ASSERT_STREQ (name,"trace_event_raw_bpf_testmod_test_read" , +"tp struct name" ); +if (!ASSERT_GE (btf_vlen (rec_t),5 ,"tp struct field count" )) + goto out; + + members =btf_members (rec_t); +ASSERT_STREQ (member_name (btf, &members[0 ]),"ent" ,"field0 name" ); +ASSERT_STREQ (member_name (btf, &members[1 ]),"pid" ,"field1 name" ); +ASSERT_STREQ (member_name (btf, &members[2 ]),"comm" ,"field2 name" ); +ASSERT_STREQ (member_name (btf, &members[3 ]),"off" ,"field3 name" ); +ASSERT_STREQ (member_name (btf, &members[4 ]),"len" ,"field4 name" ); +out: +btf__free (btf); +btf__free (vmlinux_btf); +}
Signature · 1 line
2.53.0-Meta
Steven Rostedt
maintainerQuoted 9 lines · On Mon, 18 May 2026 08:23:14 -0700 Mykyta Yatsenko…
BPF and other consumers that want to attach to or decode a generic tracepoint need three pieces of BTF information for it:
- the BTF of the object that owns the tracepoint's types
- theFUNC_PROTOdescribing the tracepoint arguments (with names), consumed byraw_tp/tp_btfBPF programs
- the STRUCT id of trace_event_raw_<call>, the ring-buffer record consumed by classicBPF_PROG_TYPE_TRACEPOINTprograms
Quoted 5 lines
Today none of this is easily discoverable from userspace. The kernel knows the ids -
resolve_btfidsfills them in at link time - but consumers have to search them by the naming convention ("__bpf_trace_<name>", "trace_event_raw_<name>"), walking BTF for every tracepoint.
I'll pull this in even though it adds 100K to the kernel:
text data bss dec hex filename
40506047 15709518 16661184 72876749 45802cd /tmp/vmlinux.new 40499064 15615294 16661184 72775542 4567776 /tmp/vmlinux.old
-- Steve
Quoted 13 lines · Steven Rostedt
Quoted 9 lines · On Mon, 18 May 2026 08:23:14 -0700 Mykyta Yatsenko…
BPF and other consumers that want to attach to or decode a generic tracepoint need three pieces of BTF information for it:
- the BTF of the object that owns the tracepoint's types
- theFUNC_PROTOdescribing the tracepoint arguments (with names), consumed byraw_tp/tp_btfBPF programs
- the STRUCT id of trace_event_raw_<call>, the ring-buffer record consumed by classicBPF_PROG_TYPE_TRACEPOINTprograms
Quoted 7 lines
Quoted 5 lines
Today none of this is easily discoverable from userspace. The kernel knows the ids -
resolve_btfidsfills them in at link time - but consumers have to search them by the naming convention ("__bpf_trace_<name>", "trace_event_raw_<name>"), walking BTF for every tracepoint.I'll pull this in even though it adds 100K to the kernel:
Great news, thank you, Steven!
Quoted 6 lines
text data bss dec hex filename
40506047 15709518 16661184 72876749 45802cd /tmp/vmlinux.new 40499064 15615294 16661184 72775542 4567776 /tmp/vmlinux.old-- Steve