tracing: Updates for v5.18
Subsystems (3)
Steven Rostedt
maintainercover tracing: Updates for v5.18
git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace.git
for-next
Head SHA1: bc47ee4844d6b7d7351536cd99d35848c4449689
Beau Belgrave (2):
user_events: Fix potential uninitialized pointer while parsing field
user_events: Prevent dyn_event delete racing with ioctl add/delete
Steven Rostedt (Google) (9):
tracing: Fix allocation of last_cmd in last_cmd_set()
tracing: Fix last_cmd_set() string management in histogram code
tracing: Allow custom events to be added to the tracefs directory
tracing: Add sample code for custom trace events
tracing: Move the defines to create TRACE_EVENTS into their own files
tracing: Add TRACE_CUSTOM_EVENT() macro
tracing: Have TRACE_DEFINE_ENUM affect trace event types as well
tracing: Add snapshot at end of kernel boot up tracing/user_events: Use alloc_pages instead of kzalloc() for register pages
Tom Zanussi (1):
tracing: Fix strncpy warning in trace_events_synth.c
----
Documentation/admin-guide/kernel-parameters.txt | 8 + include/linux/ftrace.h | 11 +- include/linux/trace_events.h | 24 +- include/trace/define_custom_trace.h | 77 ++++ include/trace/stages/init.h | 37 ++ include/trace/stages/stage1_defines.h | 45 +++ include/trace/stages/stage2_defines.h | 48 +++ include/trace/stages/stage3_defines.h | 129 ++++++ include/trace/stages/stage4_defines.h | 57 +++ include/trace/stages/stage5_defines.h | 83 ++++ include/trace/stages/stage6_defines.h | 86 ++++ include/trace/stages/stage7_defines.h | 34 ++ include/trace/trace_custom_events.h | 221 +++++++++++ include/trace/trace_events.h | 499 +----------------------- kernel/trace/ftrace.c | 2 + kernel/trace/trace.c | 18 + kernel/trace/trace_events.c | 30 ++ kernel/trace/trace_events_hist.c | 9 +- kernel/trace/trace_events_synth.c | 5 +- kernel/trace/trace_events_user.c | 64 ++- samples/Kconfig | 8 +- samples/Makefile | 1 + samples/trace_events/Makefile | 2 + samples/trace_events/trace_custom_sched.c | 60 +++ samples/trace_events/trace_custom_sched.h | 95 +++++ 25 files changed, 1139 insertions(+), 514 deletions(-) create mode 100644 include/trace/define_custom_trace.h create mode 100644 include/trace/stages/init.h create mode 100644 include/trace/stages/stage1_defines.h create mode 100644 include/trace/stages/stage2_defines.h create mode 100644 include/trace/stages/stage3_defines.h create mode 100644 include/trace/stages/stage4_defines.h create mode 100644 include/trace/stages/stage5_defines.h create mode 100644 include/trace/stages/stage6_defines.h create mode 100644 include/trace/stages/stage7_defines.h create mode 100644 include/trace/trace_custom_events.h create mode 100644 samples/trace_events/trace_custom_sched.c create mode 100644 samples/trace_events/trace_custom_sched.h
Steven Rostedt
maintainerPATCH 1/12 tracing: Fix allocation of last_cmd in last_cmd_set()
From: "Steven Rostedt (Google)" <[email protected]>
The strncat() used in last_cmd_set() includes the nul byte of length of the string being copied in, when it should only hold the size of the string being copied (not the nul byte). Change it to subtract the length of the allocated space and the nul byte to pass that into the strncat().
Also, assign "len" instead of initializing it to zero and its first update is to do a "+=".
--- kernel/trace/trace_events_hist.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-)
kernel/trace/trace_events_hist.c +4 -3
@@ -744,19 +744,20 @@ static void last_cmd_set(struct trace_event_file *file, char *str) {const char *system =NULL , *name =NULL ;struct trace_event_call *call; -int len =0 ; +int len;if (!str)return ; - len +=sizeof (HIST_PREFIX ) +strlen (str) +1 ; + len =sizeof (HIST_PREFIX ) +strlen (str) +1 ;kfree (last_cmd); last_cmd =kzalloc (len,GFP_KERNEL );if (!last_cmd)return ;strcpy (last_cmd,HIST_PREFIX ); -strncat (last_cmd, str, len -sizeof (HIST_PREFIX )); + len -=sizeof (HIST_PREFIX ) +1 ; +strncat (last_cmd, str, len);if (file) { call = file->event_call;
Signature · 1 line
2.35.1
Steven Rostedt
maintainerPATCH 2/12 user_events: Fix potential uninitialized pointer while parsing field
In reply to Steven RostedtFrom: Beau Belgrave <[email protected]>
Ensure name is initialized by default to NULL to prevent possible edge cases that could lead to it being left uninitialized. Add an explicit check for NULL name to ensure edge boundaries.
--- kernel/trace/trace_events_user.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
kernel/trace/trace_events_user.c +3 -1
@@ -362,6 +362,8 @@ static int user_event_parse_field(char *field, struct user_event *user, *field++ ='\0' ; depth++; parse: + name =NULL ; +while ((part =strsep (&field," " )) !=NULL ) {switch (depth++) {case FIELD_DEPTH_TYPE :
@@ -382,7 +384,7 @@ static int user_event_parse_field(char *field, struct user_event *user, } } -if (depth <FIELD_DEPTH_SIZE ) +if (depth <FIELD_DEPTH_SIZE || !name)return -EINVAL ;if (depth ==FIELD_DEPTH_SIZE )
Signature · 1 line
2.35.1
Steven Rostedt
maintainerPATCH 3/12 tracing: Fix last_cmd_set() string management in histogram code
In reply to Steven RostedtFrom: "Steven Rostedt (Google)" <[email protected]>
Using strnlen(dest, str, n) is confusing, as the size of dest must be strlen(dest) + n + 1. Even more confusing, using sizeof(string constant) gives you strlen(string constant) + 1 and not just strlen().
These two together made using strncat() with a constant string a bit off in the calculations as we have:
len = sizeof(HIST_PREFIX) + strlen(str) + 1; kfree(last_cmd); last_cmd = kzalloc(len, GFP_KERNEL); strcpy(last_cmd, HIST_PREFIX); len -= sizeof(HIST_PREFIX) + 1; strncat(last_cmd, str, len);
The above works if we s/sizeof/strlen/ with HIST_PREFIX (which is defined as "hist:", but because sizeof(HIST_PREFIX) is equal to strlen(HIST_PREFIX) + 1, we can drop the +1 in the code. But at least comment that we are doing so.
--- kernel/trace/trace_events_hist.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
kernel/trace/trace_events_hist.c +4 -2
@@ -749,14 +749,16 @@ static void last_cmd_set(struct trace_event_file *file, char *str)if (!str)return ; - len =sizeof (HIST_PREFIX ) +strlen (str) +1 ; +/* sizeof() contains the nul byte */ + len =sizeof (HIST_PREFIX ) +strlen (str);kfree (last_cmd); last_cmd =kzalloc (len,GFP_KERNEL );if (!last_cmd)return ;strcpy (last_cmd,HIST_PREFIX ); - len -=sizeof (HIST_PREFIX ) +1 ; +/* Again, sizeof() contains the nul byte */ + len -=sizeof (HIST_PREFIX );strncat (last_cmd, str, len);if (file) {
Signature · 1 line
2.35.1
Steven Rostedt
maintainerPATCH 4/12 tracing: Allow custom events to be added to the tracefs directory
In reply to Steven RostedtFrom: "Steven Rostedt (Google)" <[email protected]>
Allow custom events to be added to the events directory in the tracefs file system. For example, a module could be installed that attaches to an event and wants to be enabled and disabled via the tracefs file system. It would use trace_add_event_call() to add the event to the tracefs directory, and trace_remove_event_call() to remove it.
Make both those functions EXPORT_SYMBOL_GPL().
--- kernel/trace/trace_events.c | 2 ++ 1 file changed, 2 insertions(+)
kernel/trace/trace_events.c +2 -0
@@ -2758,6 +2758,7 @@ int trace_add_event_call(struct trace_event_call *call)mutex_unlock (&trace_types_lock);return ret; } +EXPORT_SYMBOL_GPL (trace_add_event_call);/* * Must be called under locking of trace_types_lock, event_mutex and
@@ -2819,6 +2820,7 @@ int trace_remove_event_call(struct trace_event_call *call)return ret; } +EXPORT_SYMBOL_GPL (trace_remove_event_call);#define for_each_event (event, start, end) \ for (event = start; \
Signature · 1 line
2.35.1
Steven Rostedt
maintainerPATCH 5/12 tracing: Add sample code for custom trace events
In reply to Steven RostedtFrom: "Steven Rostedt (Google)" <[email protected]>
Add sample code to show how to create custom trace events in the tracefs directory that can be enabled and modified like any event in tracefs (including triggers, histograms, synthetic events and event probes).
The example is creating a custom sched_switch and a sched_waking to limit what is recorded:
If the custom sched switch only records the prev_prio, next_prio and next_pid, it can bring the size from 64 bytes per event, down to just 16 bytes!
If sched_waking only records the prio and pid of the woken event, it will bring the size down from 36 bytes to 12 bytes per event.
This will allow for a much smaller footprint into the ring buffer and keep more events from dropping.
--- samples/Kconfig | 8 +- samples/Makefile | 1 + samples/trace_events/Makefile | 2 + samples/trace_events/trace_custom_sched.c | 271 ++++++++++++++++++++++ 4 files changed, 281 insertions(+), 1 deletion(-) create mode 100644 samples/trace_events/trace_custom_sched.c
samples/Kconfig +7 -1
@@ -14,7 +14,13 @@ config SAMPLE_TRACE_EVENTS tristate "Build trace_events examples -- loadable modules only" depends on EVENT_TRACING && m help - This build trace event example modules. + This builds the trace event example module. + +config SAMPLE_TRACE_CUSTOM_EVENTS + tristate "Build custom trace event example -- loadable modules only" + depends on EVENT_TRACING && m + help + This builds the custom trace event example module. config SAMPLE_TRACE_PRINTK tristate "Build trace_printk module - tests various trace_printk formats"
samples/Makefile +1 -0
@@ -20,6 +20,7 @@ obj-$(CONFIG_SAMPLE_RPMSG_CLIENT) += rpmsg/ subdir-$(CONFIG_SAMPLE_SECCOMP) += seccomp subdir-$(CONFIG_SAMPLE_TIMER) += timers obj-$(CONFIG_SAMPLE_TRACE_EVENTS) += trace_events/ +obj-$(CONFIG_SAMPLE_TRACE_CUSTOM_EVENTS) += trace_events/ obj-$(CONFIG_SAMPLE_TRACE_PRINTK) += trace_printk/ obj-$(CONFIG_SAMPLE_FTRACE_DIRECT) += ftrace/ obj-$(CONFIG_SAMPLE_FTRACE_DIRECT_MULTI) += ftrace/
samples/trace_events/Makefile +2 -0
@@ -13,3 +13,5 @@ CFLAGS_trace-events-sample.o := -I$(src) obj-$(CONFIG_SAMPLE_TRACE_EVENTS) += trace-events-sample.o + +obj-$(CONFIG_SAMPLE_TRACE_CUSTOM_EVENTS) += trace_custom_sched.o
samples/trace_events/trace_custom_sched.c new file +271 -0
271 lines not on this page · raw message
Signature · 1 line
2.35.1
Steven Rostedt
maintainerPATCH 6/12 tracing: Move the defines to create TRACE_EVENTS into their own files
In reply to Steven RostedtFrom: "Steven Rostedt (Google)" <[email protected]>
In an effort to add custom event macros that can be used to create your own custom events based on existing tracepoints, move the defines of the special macros used in TRACE_EVENT() into their own files such that they can be reused for TRACE_CUSTOM_EVENT().
--- include/trace/stages/init.h | 37 ++ include/trace/stages/stage1_defines.h | 45 +++ include/trace/stages/stage2_defines.h | 48 +++ include/trace/stages/stage3_defines.h | 129 +++++++ include/trace/stages/stage4_defines.h | 57 +++ include/trace/stages/stage5_defines.h | 83 +++++ include/trace/stages/stage6_defines.h | 86 +++++ include/trace/stages/stage7_defines.h | 34 ++ include/trace/trace_events.h | 499 +------------------------- 9 files changed, 527 insertions(+), 491 deletions(-) create mode 100644 include/trace/stages/init.h create mode 100644 include/trace/stages/stage1_defines.h create mode 100644 include/trace/stages/stage2_defines.h create mode 100644 include/trace/stages/stage3_defines.h create mode 100644 include/trace/stages/stage4_defines.h create mode 100644 include/trace/stages/stage5_defines.h create mode 100644 include/trace/stages/stage6_defines.h create mode 100644 include/trace/stages/stage7_defines.h
include/trace/stages/init.h new file +37 -0
@@ -0,0 +1,37 @@ + +#define __app__ (x, y) str__##x##y +#define __app (x, y) __app__(x, y) + +#define TRACE_SYSTEM_STRING __app(TRACE_SYSTEM_VAR,__trace_system_name) + +#define TRACE_MAKE_SYSTEM_STR () \ + static const char TRACE_SYSTEM_STRING[] = \ + __stringify(TRACE_SYSTEM) + +TRACE_MAKE_SYSTEM_STR (); + +#undef TRACE_DEFINE_ENUM +#define TRACE_DEFINE_ENUM (a) \ + static struct trace_eval_map __used __initdata \ + __##TRACE_SYSTEM##_##a = \ + { \ + .system = TRACE_SYSTEM_STRING, \ + .eval_string = #a, \ + .eval_value = a \ + }; \ + static struct trace_eval_map __used \ + __section("_ftrace_eval_map") \ + *TRACE_SYSTEM##_##a = &__##TRACE_SYSTEM##_##a + +#undef TRACE_DEFINE_SIZEOF +#define TRACE_DEFINE_SIZEOF (a) \ + static struct trace_eval_map __used __initdata \ + __##TRACE_SYSTEM##_##a = \ + { \ + .system = TRACE_SYSTEM_STRING, \ + .eval_string = "sizeof(" #a ")", \ + .eval_value = sizeof(a) \ + }; \ + static struct trace_eval_map __used \ + __section("_ftrace_eval_map") \ + *TRACE_SYSTEM##_##a = &__##TRACE_SYSTEM##_##a
include/trace/stages/stage1_defines.h new file +45 -0
45 lines not on this page · raw message
include/trace/stages/stage2_defines.h new file +48 -0
48 lines not on this page · raw message
include/trace/stages/stage3_defines.h new file +129 -0
129 lines not on this page · raw message
include/trace/stages/stage4_defines.h new file +57 -0
57 lines not on this page · raw message
include/trace/stages/stage5_defines.h new file +83 -0
83 lines not on this page · raw message
include/trace/stages/stage6_defines.h new file +86 -0
86 lines not on this page · raw message
include/trace/stages/stage7_defines.h new file +34 -0
@@ -0,0 +1,34 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +/* Stage 7 definitions for creating trace events */ + +#undef __entry +#define __entry REC + +#undef __print_flags +#undef __print_symbolic +#undef __print_hex +#undef __print_hex_str +#undef __get_dynamic_array +#undef __get_dynamic_array_len +#undef __get_str +#undef __get_bitmask +#undef __get_rel_dynamic_array +#undef __get_rel_dynamic_array_len +#undef __get_rel_str +#undef __get_rel_bitmask +#undef __print_array +#undef __print_hex_dump + +/* +* The below is not executed in the kernel. It is only what is +* displayed in the print format for userspace to parse. +*/ +#undef __print_ns_to_secs +#define __print_ns_to_secs (val) (val) / 1000000000UL + +#undef __print_ns_without_secs +#define __print_ns_without_secs (val) (val) % 1000000000UL + +#undef TP_printk +#define TP_printk(fmt, args...) "\"" fmt "\", " __stringify(args)
include/trace/trace_events.h +8 -491
547 lines not on this page · raw message
Signature · 1 line
2.35.1
Steven Rostedt
maintainerPATCH 7/12 tracing: Add TRACE_CUSTOM_EVENT() macro
In reply to Steven RostedtFrom: "Steven Rostedt (Google)" <[email protected]>
To make it really easy to add custom events from modules, add a TRACE_CUSTOM_EVENT() macro that acts just like the TRACE_EVENT() macro, but creates a custom event to an already existing tracepoint.
The trace_custom_sched.[ch] has been updated to use this new macro to show how simple it is.
--- include/linux/trace_events.h | 24 +- include/trace/define_custom_trace.h | 77 +++++++ include/trace/trace_custom_events.h | 221 ++++++++++++++++++ samples/trace_events/Makefile | 2 +- samples/trace_events/trace_custom_sched.c | 259 ++-------------------- samples/trace_events/trace_custom_sched.h | 95 ++++++++ 6 files changed, 441 insertions(+), 237 deletions(-) create mode 100644 include/trace/define_custom_trace.h create mode 100644 include/trace/trace_custom_events.h create mode 100644 samples/trace_events/trace_custom_sched.h
include/linux/trace_events.h +23 -1
@@ -315,6 +315,7 @@ enum {TRACE_EVENT_FL_KPROBE_BIT ,TRACE_EVENT_FL_UPROBE_BIT ,TRACE_EVENT_FL_EPROBE_BIT , + TRACE_EVENT_FL_CUSTOM_BIT, };/*
@@ -328,6 +329,9 @@ enum {* KPROBE - Event is a kprobe * UPROBE - Event is a uprobe * EPROBE - Event is an event probe +* CUSTOM - Event is a custom event (to be attached to an exsiting tracepoint) +* This is set when the custom event has not been attached +* to a tracepoint yet, then it is cleared when it is. */ enum {TRACE_EVENT_FL_FILTERED = (1 <<TRACE_EVENT_FL_FILTERED_BIT ),
@@ -339,6 +343,7 @@ enum {TRACE_EVENT_FL_KPROBE = (1 <<TRACE_EVENT_FL_KPROBE_BIT ),TRACE_EVENT_FL_UPROBE = (1 <<TRACE_EVENT_FL_UPROBE_BIT ),TRACE_EVENT_FL_EPROBE = (1 <<TRACE_EVENT_FL_EPROBE_BIT ), + TRACE_EVENT_FL_CUSTOM = (1 << TRACE_EVENT_FL_CUSTOM_BIT), };#define TRACE_EVENT_FL_UKPROBE (TRACE_EVENT_FL_KPROBE | TRACE_EVENT_FL_UPROBE)
@@ -440,7 +445,9 @@ static inline bool bpf_prog_array_valid(struct trace_event_call *call)static inline const char *trace_event_name (struct trace_event_call *call) { -if (call->flags &TRACE_EVENT_FL_TRACEPOINT ) +if (call->flags &TRACE_EVENT_FL_CUSTOM ) +return call->name; +else if (call->flags &TRACE_EVENT_FL_TRACEPOINT )return call->tp ? call->tp->name :NULL ;else return call->name;
@@ -901,3 +908,18 @@ perf_trace_buf_submit(void *raw_data, int size, int rctx, u16 type,#endif #endif /* _LINUX_TRACE_EVENT_H */ + +/* +* Note: we keep the TRACE_CUSTOM_EVENT outside the include file ifdef protection. +* This is due to the way trace custom events work. If a file includes two +* trace event headers under one "CREATE_CUSTOM_TRACE_EVENTS" the first include +* will override the TRACE_CUSTOM_EVENT and break the second include. +*/ + +#ifndef TRACE_CUSTOM_EVENT + +#define DECLARE_CUSTOM_EVENT_CLASS (name, proto, args, tstruct, assign, print) +#define DEFINE_CUSTOM_EVENT (template, name, proto, args) +#define TRACE_CUSTOM_EVENT (name, proto, args, struct, assign, print) + +#endif /* ifdef TRACE_CUSTOM_EVENT (see note above) */
include/trace/define_custom_trace.h new file +77 -0
77 lines not on this page · raw message
include/trace/trace_custom_events.h new file +221 -0
221 lines not on this page · raw message
samples/trace_events/Makefile +1 -1
@@ -11,7 +11,7 @@ # Here trace-events-sample.c does the CREATE_TRACE_POINTS. # CFLAGS_trace-events-sample.o := -I$(src) +CFLAGS_trace_custom_sched.o := -I$(src) obj-$(CONFIG_SAMPLE_TRACE_EVENTS) += trace-events-sample.o - obj-$(CONFIG_SAMPLE_TRACE_CUSTOM_EVENTS) += trace_custom_sched.o
samples/trace_events/trace_custom_sched.c +24 -235
280 lines not on this page · raw message
samples/trace_events/trace_custom_sched.h new file +95 -0
95 lines not on this page · raw message
Signature · 1 line
2.35.1
Steven Rostedt
maintainerPATCH 8/12 user_events: Prevent dyn_event delete racing with ioctl add/delete
In reply to Steven RostedtFrom: Beau Belgrave <[email protected]>
Find user_events always while under the event_mutex and before leaving the lock, add a ref count to the user_event. This ensures that all paths under the event_mutex that check the ref counts will be synchronized.
The ioctl add/delete paths are protected by the reg_mutex. However, dyn_event is only protected by the event_mutex. The dyn_event delete path cannot acquire reg_mutex, since that could cause a deadlock between the ioctl delete case acquiring event_mutex after acquiring the reg_mutex.
--- kernel/trace/trace_events_user.c | 46 +++++++++++++++++++++++++++----- 1 file changed, 40 insertions(+), 6 deletions(-)
kernel/trace/trace_events_user.c +40 -6
@@ -135,6 +135,8 @@ static struct list_head *user_event_get_fields(struct trace_event_call *call)* NOTE: Offsets are from the user data perspective, they are not from the * trace_entry/buffer perspective. We automatically add the common properties * sizes to the offset for the user. +* +* Upon success user_event has its ref count increased by 1. */ static int user_event_parse_cmd (char *raw_command,struct user_event **newuser) {
@@ -593,8 +595,10 @@ static struct user_event *find_user_event(char *name, u32 *outkey) *outkey = key;hash_for_each_possible (register_table, user, node, key) -if (!strcmp (EVENT_NAME (user), name)) +if (!strcmp (EVENT_NAME (user), name)) { +atomic_inc (&user->refcnt);return user; + }return NULL ; }
@@ -883,7 +887,12 @@ static int user_event_create(const char *raw_command)return -ENOMEM ;mutex_lock (®_mutex); + ret =user_event_parse_cmd (name, &user); + +if (!ret) +atomic_dec (&user->refcnt); +mutex_unlock (®_mutex);if (ret)
@@ -1050,6 +1059,7 @@ static int user_event_trace_register(struct user_event *user)/* * Parses the event name, arguments and flags then registers if successful. * The name buffer lifetime is owned by this method for success cases only. +* Upon success the returned user_event has its ref count increased by 1. */ static int user_event_parse (char *name,char *args,char *flags,struct user_event **newuser)
@@ -1057,7 +1067,12 @@ static int user_event_parse(char *name, char *args, char *flags,int ret;int index;u32 key; -struct user_event *user =find_user_event (name, &key); +struct user_event *user; + +/* Prevent dyn_event from racing */ +mutex_lock (&event_mutex); + user =find_user_event (name, &key); +mutex_unlock (&event_mutex);if (user) { *newuser = user;
@@ -1121,6 +1136,10 @@ static int user_event_parse(char *name, char *args, char *flags, goto put_user; user->index = index; + +/* Ensure we track ref */ +atomic_inc (&user->refcnt); +dyn_event_init (&user->devent, &user_event_dops);dyn_event_add (&user->devent, &user->call);set_bit (user->index, page_bitmap);
@@ -1147,12 +1166,21 @@ static int delete_user_event(char *name)if (!user)return -ENOENT ; -if (atomic_read (&user->refcnt) !=0 ) -return -EBUSY ; +/* Ensure we are the last ref */ +if (atomic_read (&user->refcnt) !=1 ) { + ret = -EBUSY ; + goto put_ref; + } -mutex_lock (&event_mutex); ret =destroy_user_event (user); -mutex_unlock (&event_mutex); + +if (ret) + goto put_ref; + +return ret; +put_ref: +/* No longer have this ref */ +atomic_dec (&user->refcnt);return ret; }
@@ -1340,6 +1368,9 @@ static long user_events_ioctl_reg(struct file *file, unsigned long uarg) ret =user_events_ref_add (file, user); +/* No longer need parse ref, ref_add either worked or not */ +atomic_dec (&user->refcnt); +/* Positive number is index and valid */ if (ret <0 )return ret;
@@ -1364,7 +1395,10 @@ static long user_events_ioctl_del(struct file *file, unsigned long uarg)if (IS_ERR (name))return PTR_ERR (name); +/* event_mutex prevents dyn_event from racing */ +mutex_lock (&event_mutex); ret =delete_user_event (name); +mutex_unlock (&event_mutex);kfree (name);
Signature · 1 line
2.35.1
Steven Rostedt
maintainerPATCH 9/12 tracing: Fix strncpy warning in trace_events_synth.c
In reply to Steven RostedtFrom: Tom Zanussi <[email protected]>
0-day reported the strncpy error below:
../kernel/trace/trace_events_synth.c: In function 'last_cmd_set':../kernel/trace/trace_events_synth.c:65:9: warning: 'strncpy' specified bound depends on the length o\
f the source argument [-Wstringop-truncation]
65 | strncpy(last_cmd, str, strlen(str) + 1);
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
../kernel/trace/trace_events_synth.c:65:32: note: length computed here
65 | strncpy(last_cmd, str, strlen(str) + 1);
| ^~~~~~~~~~~There's no reason to use strncpy here, in fact there's no reason to do anything but a simple kstrdup() (note we don't even need to check for failure since last_cmod is expected to be either the last cmd string or NULL, and the containing function is a void return).
--- kernel/trace/trace_events_synth.c | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-)
kernel/trace/trace_events_synth.c +1 -4
@@ -58,11 +58,8 @@ static void last_cmd_set(const char *str)return ;kfree (last_cmd); - last_cmd =kzalloc (strlen (str) +1 ,GFP_KERNEL ); -if (!last_cmd) -return ; -strncpy (last_cmd, str,strlen (str) +1 ); + last_cmd =kstrdup (str,GFP_KERNEL ); }static void synth_err (u8 err_type,u16 err_pos)
Signature · 1 line
2.35.1
Steven Rostedt
maintainerPATCH 10/12 tracing: Have TRACE_DEFINE_ENUM affect trace event types as well
In reply to Steven RostedtFrom: "Steven Rostedt (Google)" <[email protected]>
The macro TRACE_DEFINE_ENUM is used to convert enums in the kernel to their actual value when they are exported to user space via the trace event format file.
Currently only the enums in the "print fmt" (TP_printk in the TRACE_EVENT macro) have the enums converted. But the enums can be used to denote array size:
field:unsigned int fc_ineligible_rc[EXT4_FC_REASON_MAX]; offset:12; size:36; signed:0;
The EXT4_FC_REASON_MAX has no meaning to userspace but it needs to know that information to know how to parse the array.
Have the array indexes also be parsed as well.
--- kernel/trace/trace_events.c | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+)
kernel/trace/trace_events.c +28 -0
@@ -2633,6 +2633,33 @@ static void update_event_printk(struct trace_event_call *call, } } +static void update_event_fields (struct trace_event_call *call, +struct trace_eval_map *map) +{ +struct ftrace_event_field *field; +struct list_head *head; +char *ptr; +int len =strlen (map->eval_string); + + head =trace_get_fields (call); +list_for_each_entry (field, head, link) { + ptr =strchr (field->type,'[' ); +if (!ptr) +continue ; + ptr++; + +if (!isalpha (*ptr) && *ptr !='_' ) +continue ; + +if (strncmp (map->eval_string, ptr, len) !=0 ) +continue ; + + ptr =eval_replace (ptr, map, len); +/* enum/sizeof string smaller than value */ +WARN_ON_ONCE (!ptr); + } +} +void trace_event_eval_update (struct trace_eval_map **map,int len) {struct trace_event_call *call, *p;
@@ -2668,6 +2695,7 @@ void trace_event_eval_update(struct trace_eval_map **map, int len) first = false; }update_event_printk (call, map[i]); +update_event_fields (call, map[i]); } } }
Signature · 1 line
2.35.1
Steven Rostedt
maintainerPATCH 11/12 tracing: Add snapshot at end of kernel boot up
In reply to Steven RostedtFrom: "Steven Rostedt (Google)" <[email protected]>
Add ftrace_boot_snapshot kernel parameter that will take a snapshot at the end of boot up just before switching over to user space (it happens during the kernel freeing of init memory).
This is useful when there's interesting data that can be collected from kernel start up, but gets overridden by user space start up code. With this option, the ring buffer content from the boot up traces gets saved in the snapshot at the end of boot up. This trace can be read from:
/sys/kernel/tracing/snapshot
--- .../admin-guide/kernel-parameters.txt | 8 ++++++++ include/linux/ftrace.h | 11 ++++++++++- kernel/trace/ftrace.c | 2 ++ kernel/trace/trace.c | 18 ++++++++++++++++++ 4 files changed, 38 insertions(+), 1 deletion(-)
Documentation/admin-guide/kernel-parameters.txt +8 -0
@@ -1435,6 +1435,14 @@ as early as possible in order to facilitate early boot debugging. + ftrace_boot_snapshot + [FTRACE] On boot up, a snapshot will be taken of the + ftrace ring buffer that can be read at: + /sys/kernel/tracing/snapshot. + This is useful if you need tracing information from kernel + boot up that is likely to be overridden by user space + start up functionality. + ftrace_dump_on_oops[=orig_cpu] [FTRACE] will dump the trace buffers on oops. If no parameter is passed, ftrace will dump
include/linux/ftrace.h +10 -1
@@ -30,6 +30,12 @@#define ARCH_SUPPORTS_FTRACE_OPS 0#endif +#ifdef CONFIG_TRACING +extern void ftrace_boot_snapshot (void ); +#else +static inline void ftrace_boot_snapshot (void ) { } +#endif +#ifdef CONFIG_FUNCTION_TRACER struct ftrace_ops ;struct ftrace_regs ;
@@ -215,7 +221,10 @@ struct ftrace_ops_hash {void ftrace_free_init_mem (void );void ftrace_free_mem (struct module *mod,void *start,void *end);#else -static inline void ftrace_free_init_mem (void ) { } +static inline void ftrace_free_init_mem (void ) +{ +ftrace_boot_snapshot (); +}static inline void ftrace_free_mem (struct module *mod,void *start,void *end) { }#endif
kernel/trace/ftrace.c +2 -0
@@ -7096,6 +7096,8 @@ void __init ftrace_free_init_mem(void)void *start = (void *)(&__init_begin);void *end = (void *)(&__init_end); +ftrace_boot_snapshot (); +ftrace_free_mem (NULL , start, end); }
kernel/trace/trace.c +18 -0
@@ -185,6 +185,7 @@ static char bootup_tracer_buf[MAX_TRACER_SIZE] __initdata;static char *default_bootup_tracer;static bool allocate_snapshot; +static bool snapshot_at_boot;static int __init set_cmdline_ftrace (char *str) {
@@ -230,6 +231,15 @@ static int __init boot_alloc_snapshot(char *str)__setup ("alloc_snapshot" , boot_alloc_snapshot); +static int __init boot_snapshot (char *str) +{ + snapshot_at_boot = true; +boot_alloc_snapshot (str); +return 1 ; +} +__setup ("ftrace_boot_snapshot" , boot_snapshot); + +static char trace_boot_options_buf[MAX_TRACER_SIZE ]__initdata ;static int __init set_trace_boot_options (char *str)
@@ -10149,6 +10159,14 @@ __init static int tracer_alloc_buffers(void)return ret; } +void __init ftrace_boot_snapshot (void ) +{ +if (snapshot_at_boot) { +tracing_snapshot (); +internal_trace_puts ("** Boot snapshot taken **\n" ); + } +} +void __init early_trace_init (void ) {if (tracepoint_printk) {
Signature · 1 line
2.35.1
Steven Rostedt
maintainerPATCH 12/12 tracing/user_events: Use alloc_pages instead of kzalloc() for register pages
In reply to Steven RostedtFrom: "Steven Rostedt (Google)" <[email protected]>
kzalloc virtual addresses do not work with SetPageReserved, use the actual page virtual addresses instead via alloc_pages.
The issue is reported when booting with user_events and DEBUG_VM_PGFLAGS=y.
Also make the number of events based on the ORDER.
--- kernel/trace/trace_events_user.c | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-)
kernel/trace/trace_events_user.c +8 -6
@@ -30,9 +30,10 @@/* * Limits how many trace_event calls user processes can create: -* Must be multiple of PAGE_SIZE. +* Must be a power of two of PAGE_SIZE. */ -#define MAX_PAGES 1 +#define MAX_PAGE_ORDER 0 +#define MAX_PAGES (1 << MAX_PAGE_ORDER)#define MAX_EVENTS (MAX_PAGES * PAGE_SIZE)/* Limit how long of an event name plus args within the subsystem. */
@@ -1622,16 +1623,17 @@ static void set_page_reservations(bool set)static int __init trace_events_user_init (void ) { +struct page *pages;int ret;/* Zero all bits beside 0 (which is reserved for failures) */ bitmap_zero (page_bitmap,MAX_EVENTS );set_bit (0 , page_bitmap); - register_page_data =kzalloc (MAX_EVENTS ,GFP_KERNEL ); - -if (!register_page_data) + pages =alloc_pages (GFP_KERNEL | __GFP_ZERO,MAX_PAGE_ORDER ); +if (!pages)return -ENOMEM ; + register_page_data =page_address (pages);set_page_reservations (true);
@@ -1640,7 +1642,7 @@ static int __init trace_events_user_init(void)if (ret) {pr_warn ("user_events could not register with tracefs\n" );set_page_reservations (false); -kfree (register_page_data); +__free_pages (pages,MAX_PAGE_ORDER );return ret; }
Signature · 1 line
2.35.1