From: Johannes Berg The way __print_symbolic() works is limited and inefficient in multiple ways: - you can only use it with a static list of symbols, but e.g. the SKB dropreasons are now a dynamic list - it builds the list in memory _three_ times, so it takes a lot of memory: - The print_fmt contains the list (since it's passed to the macro there). This actually contains the names _twice_, which is fixed up at runtime. - TRACE_DEFINE_ENUM() puts a 24-byte struct trace_eval_map for every entry, plus the string pointed to by it, which cannot be deduplicated with the strings in the print_fmt - The in-kernel symbolic printing creates yet another list of struct trace_print_flags for trace_print_symbols_seq() - it also requires runtime fixup during init, which is a lot of string parsing due to the print_fmt fixup Introduce __print_sym() to - over time - replace the old one. We can easily extend this also to __print_flags later, but I cared only about the SKB dropreasons for now, which has only __print_symbolic(). This new __print_sym() requires only a single list of items, created by TRACE_DEFINE_SYM_LIST(), or can even use another already existing list by using TRACE_DEFINE_SYM_FNS() with lookup and show methods. Then, instead of doing an init-time fixup, just do this at the time when userspace reads the print_fmt. This way, dynamically updated lists are possible. For userspace, nothing actually changes, because the print_fmt is shown exactly the same way the old __print_symbolic() was. This adds about 4k .text in my test builds, but that'll be more than paid for by the actual conversions. Signed-off-by: Johannes Berg --- v8: fix it to use TRACE_SYM_VAR, add a sample v7: address sashiko's alignment concern v6: don't place data needed at runtime in .init sections, fixing the crash Steven reported with v1: https://lore.kernel.org/r/20240819182340.3bd23d67@gandalf.local.home/ (yes, it's been over 2 years ... my bad) --- include/asm-generic/vmlinux.lds.h | 4 + include/linux/module.h | 2 + include/linux/trace_events.h | 7 ++ include/linux/tracepoint.h | 20 +++++ include/trace/stages/init.h | 55 ++++++++++++ include/trace/stages/stage2_data_offsets.h | 6 ++ include/trace/stages/stage3_trace_output.h | 9 ++ include/trace/stages/stage7_class_define.h | 3 + kernel/module/main.c | 3 + kernel/trace/trace_events.c | 99 +++++++++++++++++++++- kernel/trace/trace_output.c | 45 ++++++++++ samples/trace_events/trace-events-sample.c | 30 +++++++ samples/trace_events/trace-events-sample.h | 47 +++++++++- 13 files changed, 327 insertions(+), 3 deletions(-) diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h index 3eb732942d69..ba2d8234aecb 100644 --- a/include/asm-generic/vmlinux.lds.h +++ b/include/asm-generic/vmlinux.lds.h @@ -275,9 +275,12 @@ #define FTRACE_EVENTS() \ . = ALIGN(8); \ BOUNDED_SECTION(_ftrace_events) \ + . = ALIGN(8); \ BOUNDED_SECTION_BY(_ftrace_eval_map, _ftrace_eval_maps) +#define FTRACE_SYM_DEFS() BOUNDED_SECTION(_ftrace_sym_defs) #else #define FTRACE_EVENTS() +#define FTRACE_SYM_DEFS() #endif #ifdef CONFIG_TRACING @@ -391,6 +394,7 @@ TRACE_PRINTKS() \ BPF_RAW_TP() \ TRACEPOINT_STR() \ + FTRACE_SYM_DEFS() \ KUNIT_TABLE() /* diff --git a/include/linux/module.h b/include/linux/module.h index 76f4f3596477..244edf26ad10 100644 --- a/include/linux/module.h +++ b/include/linux/module.h @@ -520,6 +520,8 @@ struct module { unsigned int num_trace_events; struct trace_eval_map **trace_evals; unsigned int num_trace_evals; + struct trace_sym_def **trace_sym_defs; + unsigned int num_trace_sym_defs; #endif #ifdef CONFIG_DYNAMIC_FTRACE unsigned int num_ftrace_callsites; diff --git a/include/linux/trace_events.h b/include/linux/trace_events.h index 321f2f3a6c8e..793fc1d7030a 100644 --- a/include/linux/trace_events.h +++ b/include/linux/trace_events.h @@ -29,6 +29,13 @@ const char *trace_print_symbols_seq(struct trace_seq *p, unsigned long val, const struct trace_print_flags *symbol_array, size_t symbol_array_size); +const char *trace_print_sym_seq(struct trace_seq *p, unsigned long long val, + const char *(*lookup)(unsigned long long val)); +const char *trace_sym_lookup(const struct trace_sym_entry *list, + size_t len, unsigned long long value); +void trace_sym_show(struct seq_file *m, + const struct trace_sym_entry *list, size_t len); + #if BITS_PER_LONG == 32 const char *trace_print_flags_seq_u64(struct trace_seq *p, const char *delim, unsigned long long flags, diff --git a/include/linux/tracepoint.h b/include/linux/tracepoint.h index e0d838c9ce93..05c45a72756c 100644 --- a/include/linux/tracepoint.h +++ b/include/linux/tracepoint.h @@ -32,6 +32,24 @@ struct trace_eval_map { unsigned long eval_value; }; +struct trace_sym_def { + const char *system; + const char *symbol_id; + /* may return NULL, called under rcu_read_lock() */ + const char * (*lookup)(unsigned long long); + /* + * Must print the list: ', { val, "name"}, ...' + * with no trailing comma, but with the leading ', ' + * to simplify things: + */ + void (*show)(struct seq_file *); +}; + +struct trace_sym_entry { + unsigned long long value; + const char *name; +}; + #define TRACEPOINT_DEFAULT_PRIO 10 extern int @@ -163,6 +181,8 @@ extern void syscall_unregfunc(void); #define TRACE_DEFINE_ENUM(x) #define TRACE_DEFINE_SIZEOF(x) +#define TRACE_DEFINE_SYM_FNS(...) +#define TRACE_DEFINE_SYM_LIST(...) #ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS static inline struct tracepoint *tracepoint_ptr_deref(tracepoint_ptr_t *p) diff --git a/include/trace/stages/init.h b/include/trace/stages/init.h index 000bcfc8dd2e..03a7898cc84a 100644 --- a/include/trace/stages/init.h +++ b/include/trace/stages/init.h @@ -23,6 +23,61 @@ TRACE_MAKE_SYSTEM_STR(); __section("_ftrace_eval_map") \ *TRACE_SYSTEM##_##a = &__##TRACE_SYSTEM##_##a +/* + * Define a symbol for __print_sym by giving lookup and + * show functions. See &struct trace_sym_def. + */ +#undef TRACE_DEFINE_SYM_FNS +#define TRACE_DEFINE_SYM_FNS(_symbol_id, _lookup, _show) \ + _TRACE_DEFINE_SYM_FNS(TRACE_SYSTEM_VAR, _symbol_id, _lookup, _show) +#define _TRACE_DEFINE_SYM_FNS(_system, _symbol_id, _lookup, _show) \ + __TRACE_DEFINE_SYM_FNS(_system, _symbol_id, _lookup, _show) +#define __TRACE_DEFINE_SYM_FNS(_system, _symbol_id, _lookup, _show) \ + ___TRACE_DEFINE_SYM_FNS(_system ## _ ## _symbol_id, _symbol_id, \ + _lookup, _show) +#define ___TRACE_DEFINE_SYM_FNS(_name, _symbol_id, _lookup, _show) \ + static struct trace_sym_def \ + __trace_sym_def_ ## _name = { \ + .system = TRACE_SYSTEM_STRING, \ + .symbol_id = #_symbol_id, \ + .lookup = _lookup, \ + .show = _show, \ + }; \ + static struct trace_sym_def __used \ + __section("_ftrace_sym_defs") \ + *__trace_sym_def_p_ ## _name = &__trace_sym_def_ ## _name + +/* + * Define a symbol for __print_sym by giving lookup and + * show functions. See &struct trace_sym_def. + */ +#undef TRACE_DEFINE_SYM_LIST +#define TRACE_DEFINE_SYM_LIST(_symbol_id, ...) \ + _TRACE_DEFINE_SYM_LIST(TRACE_SYSTEM_VAR, _symbol_id, __VA_ARGS__) +#define _TRACE_DEFINE_SYM_LIST(_system, _symbol_id, ...) \ + __TRACE_DEFINE_SYM_LIST(_system, _symbol_id, __VA_ARGS__) +#define __TRACE_DEFINE_SYM_LIST(_system, _symbol_id, ...) \ + ___TRACE_DEFINE_SYM_LIST(_system ## _ ## _symbol_id, _symbol_id,\ + __VA_ARGS__) +#define ___TRACE_DEFINE_SYM_LIST(_name, _symbol_id, ...) \ + static struct trace_sym_entry \ + __trace_sym_list_ ## _name[] = { __VA_ARGS__ }; \ + static const char * \ + __trace_sym_lookup_ ## _name(unsigned long long value) \ + { \ + return trace_sym_lookup(__trace_sym_list_ ## _name, \ + ARRAY_SIZE(__trace_sym_list_ ## _name), value); \ + } \ + static void \ + __trace_sym_show_ ## _name(struct seq_file *m) \ + { \ + trace_sym_show(m, __trace_sym_list_ ## _name, \ + ARRAY_SIZE(__trace_sym_list_ ## _name)); \ + } \ + ___TRACE_DEFINE_SYM_FNS(_name, _symbol_id, \ + __trace_sym_lookup_ ## _name, \ + __trace_sym_show_ ## _name) + #undef TRACE_DEFINE_SIZEOF #define TRACE_DEFINE_SIZEOF(a) \ static struct trace_eval_map __used __initdata \ diff --git a/include/trace/stages/stage2_data_offsets.h b/include/trace/stages/stage2_data_offsets.h index 8b0cff06d346..5afd9de7deb3 100644 --- a/include/trace/stages/stage2_data_offsets.h +++ b/include/trace/stages/stage2_data_offsets.h @@ -5,6 +5,12 @@ #undef TRACE_DEFINE_ENUM #define TRACE_DEFINE_ENUM(a) +#undef TRACE_DEFINE_SYM_FNS +#define TRACE_DEFINE_SYM_FNS(_symbol_id, _lookup, _show) + +#undef TRACE_DEFINE_SYM_LIST +#define TRACE_DEFINE_SYM_LIST(_symbol_id, ...) + #undef TRACE_DEFINE_SIZEOF #define TRACE_DEFINE_SIZEOF(a) diff --git a/include/trace/stages/stage3_trace_output.h b/include/trace/stages/stage3_trace_output.h index 181b81335781..eb34b43147a1 100644 --- a/include/trace/stages/stage3_trace_output.h +++ b/include/trace/stages/stage3_trace_output.h @@ -79,6 +79,15 @@ trace_print_symbols_seq(p, value, symbols, ARRAY_SIZE(symbols)); \ }) +#undef __print_sym +#define __print_sym(value, symbol_id) \ + ___print_sym(TRACE_SYSTEM_VAR, value, symbol_id) +#define ___print_sym(sys, value, symbol_id) \ + ____print_sym(sys, value, symbol_id) +#define ____print_sym(sys, value, symbol_id) \ + trace_print_sym_seq(p, value, \ + __trace_sym_def_p_ ## sys ## _ ## symbol_id->lookup) + #undef __print_flags_u64 #undef __print_symbolic_u64 #if BITS_PER_LONG == 32 diff --git a/include/trace/stages/stage7_class_define.h b/include/trace/stages/stage7_class_define.h index 47008897a795..936b9fa08cea 100644 --- a/include/trace/stages/stage7_class_define.h +++ b/include/trace/stages/stage7_class_define.h @@ -45,6 +45,9 @@ #define __event_in_softirq() (REC->common_flags & 0x10) #define __event_in_irq() (REC->common_flags & 0x18) +#undef __print_sym +#define __print_sym(value, symbol_id) __print_sym(value:symbol_id) + /* * The below is not executed in the kernel. It is only what is * displayed in the print format for userspace to parse. diff --git a/kernel/module/main.c b/kernel/module/main.c index 34e0204ea37c..b75a01536647 100644 --- a/kernel/module/main.c +++ b/kernel/module/main.c @@ -2751,6 +2751,9 @@ static int find_module_sections(struct module *mod, struct load_info *info) mod->trace_evals = section_objs(info, "_ftrace_eval_map", sizeof(*mod->trace_evals), &mod->num_trace_evals); + mod->trace_sym_defs = section_objs(info, "_ftrace_sym_defs", + sizeof(*mod->trace_sym_defs), + &mod->num_trace_sym_defs); #endif #ifdef CONFIG_TRACING mod->trace_bprintk_fmt_start = section_objs(info, "__trace_printk_fmt", diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c index 49d135bc2fbf..cea71270e651 100644 --- a/kernel/trace/trace_events.c +++ b/kernel/trace/trace_events.c @@ -2148,6 +2148,102 @@ static void *f_next(struct seq_file *m, void *v, loff_t *pos) return node; } +extern struct trace_sym_def *__start_ftrace_sym_defs[]; +extern struct trace_sym_def *__stop_ftrace_sym_defs[]; + +/* note: @name is not NUL-terminated */ +static void show_sym_list(struct seq_file *m, struct trace_event_call *call, + const char *name, unsigned int name_len) +{ + struct trace_sym_def **sym_defs; + unsigned int n_sym_defs, i; + + if ((call->flags & TRACE_EVENT_FL_DYNAMIC) || !call->module) { + sym_defs = __start_ftrace_sym_defs; + n_sym_defs = __stop_ftrace_sym_defs - __start_ftrace_sym_defs; + } else { +#ifdef CONFIG_MODULES + struct module *mod = call->module; + + sym_defs = mod->trace_sym_defs; + n_sym_defs = mod->num_trace_sym_defs; +#else + return; +#endif /* CONFIG_MODULES */ + } + + for (i = 0; i < n_sym_defs; i++) { + unsigned int sym_len; + + if (!sym_defs[i]) + continue; + if (sym_defs[i]->system != call->class->system) + continue; + sym_len = strlen(sym_defs[i]->symbol_id); + if (name_len != sym_len) + continue; + if (strncmp(sym_defs[i]->symbol_id, name, sym_len)) + continue; + if (sym_defs[i]->show) + sym_defs[i]->show(m); + break; + } +} + +static void show_print_fmt(struct seq_file *m, struct trace_event_call *call) +{ + char *ptr = call->print_fmt; + bool in_print_sym = false; + int quote = 0; + + seq_puts(m, "\nprint fmt: "); + while (*ptr) { + if (*ptr == '\\') { + seq_putc(m, *ptr); + ptr++; + /* paranoid */ + if (!*ptr) + break; + goto next; + } + if (*ptr == '"') { + quote ^= 1; + goto next; + } + if (quote) + goto next; + + if (in_print_sym && *ptr != ':') + goto next; + + if (in_print_sym && *ptr == ':') { + const char *name; + + ptr++; + name = ptr; + /* skip the name */ + while (*ptr && *ptr != ')') + ptr++; + /* and show the actual list inline now */ + show_sym_list(m, call, name, ptr - name); + in_print_sym = false; + continue; + } + + if (strncmp(ptr, "__print_sym(", 12) == 0) { + ptr += 12; + seq_puts(m, "__print_symbolic("); + in_print_sym = true; + continue; + } +next: + seq_putc(m, *ptr); + ptr++; + } + + seq_putc(m, '\n'); +} + static int f_show(struct seq_file *m, void *v) { struct trace_event_file *file = event_file_data(m->private); @@ -2167,8 +2263,7 @@ static int f_show(struct seq_file *m, void *v) return 0; case FORMAT_PRINTFMT: - seq_printf(m, "\nprint fmt: %s\n", - call->print_fmt); + show_print_fmt(m, call); return 0; } diff --git a/kernel/trace/trace_output.c b/kernel/trace/trace_output.c index a5ad76175d10..0850b3ad5707 100644 --- a/kernel/trace/trace_output.c +++ b/kernel/trace/trace_output.c @@ -131,6 +131,51 @@ trace_print_symbols_seq(struct trace_seq *p, unsigned long val, } EXPORT_SYMBOL(trace_print_symbols_seq); +const char *trace_sym_lookup(const struct trace_sym_entry *list, + size_t len, unsigned long long value) +{ + size_t i; + + for (i = 0; i < len; i++) { + if (list[i].value == value) + return list[i].name; + } + return NULL; +} +EXPORT_SYMBOL(trace_sym_lookup); + +void trace_sym_show(struct seq_file *m, + const struct trace_sym_entry *list, size_t len) +{ + size_t i; + + for (i = 0; i < len; i++) + seq_printf(m, ", { %lld, \"%s\" }", + list[i].value, list[i].name); +} +EXPORT_SYMBOL(trace_sym_show); + +const char * +trace_print_sym_seq(struct trace_seq *p, unsigned long long val, + const char *(*lookup)(unsigned long long val)) +{ + const char *ret = trace_seq_buffer_ptr(p); + const char *name; + + rcu_read_lock(); + name = lookup(val); + if (name) + trace_seq_puts(p, name); + else + trace_seq_printf(p, "0x%llx", val); + rcu_read_unlock(); + + trace_seq_putc(p, 0); + + return ret; +} +EXPORT_SYMBOL(trace_print_sym_seq); + #if BITS_PER_LONG == 32 const char * trace_print_flags_seq_u64(struct trace_seq *p, const char *delim, diff --git a/samples/trace_events/trace-events-sample.c b/samples/trace_events/trace-events-sample.c index ca5d98c360cb..26948306f6dd 100644 --- a/samples/trace_events/trace-events-sample.c +++ b/samples/trace_events/trace-events-sample.c @@ -11,6 +11,36 @@ #define CREATE_TRACE_POINTS #include "trace-events-sample.h" +/* functions for the dynamic __print_sym() example */ +static const struct { + unsigned long val; + char *name; +} print_sym_dynamic_names[] = { + { 0, "zero" }, + { TRACE_SAMPLE_FOO, "TWO" }, + { TRACE_SAMPLE_BAR, "FOUR" }, + { TRACE_SAMPLE_ZOO, "EIGHT" }, + { 10, "TEN" } +}; + +const char *sample_names_dynamic_lookup(unsigned long long value) +{ + for (int i = 0; i < ARRAY_SIZE(print_sym_dynamic_names); i++) { + if (print_sym_dynamic_names[i].val == value) + return print_sym_dynamic_names[i].name; + } + + return NULL; +} + +void sample_names_dynamic_show(struct seq_file *m) +{ + for (int i = 0; i < ARRAY_SIZE(print_sym_dynamic_names); i++) + seq_printf(m, ", { %lu, \"%s\" }", + print_sym_dynamic_names[i].val, + print_sym_dynamic_names[i].name); +} + static const char *random_strings[] = { "Mother Goose", "Snoopy", diff --git a/samples/trace_events/trace-events-sample.h b/samples/trace_events/trace-events-sample.h index 816848a456a2..38d6bf808de6 100644 --- a/samples/trace_events/trace-events-sample.h +++ b/samples/trace_events/trace-events-sample.h @@ -297,6 +297,33 @@ TRACE_DEFINE_ENUM(TRACE_SAMPLE_FOO); TRACE_DEFINE_ENUM(TRACE_SAMPLE_BAR); TRACE_DEFINE_ENUM(TRACE_SAMPLE_ZOO); +/* + * define the names as { value, "name" } tuples for __print_sym() below, + * same as the inline list for __print_dynamic() + */ +TRACE_DEFINE_SYM_LIST(sample_names_static, + { 0, "zero" }, + { TRACE_SAMPLE_FOO, "TWO" }, + { TRACE_SAMPLE_BAR, "FOUR" }, + { TRACE_SAMPLE_ZOO, "EIGHT" }, + { 10, "TEN" } +); + +/* + * Alternatively, you could define a function for the names: + * + * The _lookup() function returns the string for the given value. + * + * The _show() function must + * seq_printf(m, ", { %u, \"%s\" }", value, name); + * for each value that userspace should be able to parse. + */ +const char *sample_names_dynamic_lookup(unsigned long long value); +void sample_names_dynamic_show(struct seq_file *m); +TRACE_DEFINE_SYM_FNS(sample_names_dynamic, + sample_names_dynamic_lookup, + sample_names_dynamic_show); + TRACE_EVENT(foo_bar, TP_PROTO(const char *foo, int bar, const int *lst, @@ -328,7 +355,7 @@ TRACE_EVENT(foo_bar, __assign_cpumask(cpum, cpumask_bits(mask)); ), - TP_printk("foo %s %d %s %s %s %s %s %s (%s) (%s) %s [%d] %*pbl", + TP_printk("foo %s %d %s %s %s %s %s %s %s %s (%s) (%s) %s [%d] %*pbl", __entry->foo, __entry->bar, /* @@ -340,6 +367,9 @@ TRACE_EVENT(foo_bar, * the variable matches one of the values, then it will print the * string in that pair. If non are matched, it returns a string * version of the number (if __entry->bar == 7 then "7" is returned). + * + * NOTE: This variant is deprecated, it uses more space than the below + * __print_sym() which is identical to this for userspace. */ __print_symbolic(__entry->bar, { 0, "zero" }, @@ -349,6 +379,21 @@ TRACE_EVENT(foo_bar, { 10, "TEN" } ), +/* + * __print_sym( variable, symbol_list_definition ), + * + * The variable is tested against each value of the symbol list. + * The symbol list can be built statically (sample_names_static) or + * dynamically (sample_names_dynamic). If the variable matches one + * of the values, then it will print the string in that pair. If + * no entry matches, the number itself is printed (e.g. here if + * if __entry->bar == 7 then "7" is shown). + * + * See above for the declaration of sample_names_{static,dynamic}. + */ + __print_sym(__entry->bar, sample_names_static), + __print_sym(__entry->bar, sample_names_dynamic), + /* * __print_flags( variable, "delim", { value, "flag" }, ... ), * -- 2.56.1