trace: introduce trace event injection
cover trace: introduce trace event injection
This patchset introduces trace event injection, the first 3 patches are some trivial prerequisites, the last one implements the trace event injection. Please check each patch for details.
I have tested them with both valid and invalid input on different tracepoints, it works as expected.
---
Cong Wang (4):
trace: fold type initialization into tracing_generic_entry_update()
trace: let filter_assign_type() detect FILTER_PTR_STRING
trace: make trace_get_fields() global
trace: introduce trace event injection
include/linux/trace_events.h | 9 + kernel/trace/Makefile | 1 + kernel/trace/trace.c | 8 +- kernel/trace/trace.h | 1 + kernel/trace/trace_event_perf.c | 3 +- kernel/trace/trace_events.c | 12 +- kernel/trace/trace_events_filter.c | 3 + kernel/trace/trace_events_inject.c | 330 +++++++++++++++++++++++++++++ 8 files changed, 353 insertions(+), 14 deletions(-) create mode 100644 kernel/trace/trace_events_inject.c
Signature · 1 line
2.21.0
PATCH 1/4 trace: fold type initialization into tracing_generic_entry_update()
All callers of tracing_generic_entry_update() have to initialize entry->type, so let's just simply move it inside.
--- include/linux/trace_events.h | 1 + kernel/trace/trace.c | 8 ++++---- kernel/trace/trace_event_perf.c | 3 +-- 3 files changed, 6 insertions(+), 6 deletions(-)
include/linux/trace_events.h +1 -0
@@ -142,6 +142,7 @@ enum print_line_t {enum print_line_t trace_handle_return (struct trace_seq *s);void tracing_generic_entry_update (struct trace_entry *entry, +unsigned short type,unsigned long flags,int pc);struct trace_event_file ;
kernel/trace/trace.c +4 -4
@@ -743,8 +743,7 @@ trace_event_setup(struct ring_buffer_event *event, {struct trace_entry *ent =ring_buffer_event_data (event); -tracing_generic_entry_update (ent, flags, pc); - ent->type = type; +tracing_generic_entry_update (ent, type, flags, pc); } static __always_inline struct ring_buffer_event *
@@ -2312,13 +2311,14 @@ enum print_line_t trace_handle_return(struct trace_seq *s)EXPORT_SYMBOL_GPL (trace_handle_return);void -tracing_generic_entry_update (struct trace_entry *entry,unsigned long flags, -int pc) +tracing_generic_entry_update (struct trace_entry *entry,unsigned short type, +unsigned long flags,int pc) {struct task_struct *tsk = current; entry->preempt_count = pc &0xff ; entry->pid = (tsk) ? tsk->pid :0 ; + entry->type = type; entry->flags = #ifdef CONFIG_TRACE_IRQFLAGS_SUPPORT (irqs_disabled_flags(flags) ? TRACE_FLAG_IRQS_OFF : 0) |
kernel/trace/trace_event_perf.c +1 -2
@@ -416,8 +416,7 @@ void perf_trace_buf_update(void *record, u16 type)unsigned long flags;local_save_flags (flags); -tracing_generic_entry_update (entry, flags, pc); - entry->type = type; +tracing_generic_entry_update (entry, type, flags, pc); }NOKPROBE_SYMBOL (perf_trace_buf_update);
Signature · 1 line
2.21.0
PATCH 2/4 trace: let filter_assign_type() detect FILTER_PTR_STRING
In reply to Cong Wangfilter_assign_type() could detect dynamic string and static string, but not string pointers. Teach filter_assign_type() to detect string pointers, and this will be needed by trace event injection code.
BTW, trace event hist uses FILTER_PTR_STRING too.
--- kernel/trace/trace_events_filter.c | 3 +++ 1 file changed, 3 insertions(+)
kernel/trace/trace_events_filter.c +3 -0
@@ -1080,6 +1080,9 @@ int filter_assign_type(const char *type)if (strchr (type,'[' ) &&strstr (type,"char" ))return FILTER_STATIC_STRING ; +if (strcmp (type,"char *" ) ==0 ||strcmp (type,"const char *" ) ==0 ) +return FILTER_PTR_STRING ; +return FILTER_OTHER ; }
Signature · 1 line
2.21.0
PATCH 3/4 trace: make trace_get_fields() global
In reply to Cong Wangtrace_get_fields() is the only way to read tracepoint fields at run time, as their fields are defined at compile-time with macros. Make this function visible to all users and it will be used by trace event injection code to calculate the size of a tracepoint entry.
--- include/linux/trace_events.h | 8 ++++++++ kernel/trace/trace_events.c | 8 -------- 2 files changed, 8 insertions(+), 8 deletions(-)
include/linux/trace_events.h +8 -0
@@ -318,6 +318,14 @@ trace_event_name(struct trace_event_call *call)return call->name; } +static inline struct list_head * +trace_get_fields (struct trace_event_call *event_call) +{ +if (!event_call->class->get_fields) +return &event_call->class->fields; +return event_call->class->get_fields (event_call); +} +struct trace_array ;struct trace_subsystem_dir ;
kernel/trace/trace_events.c +0 -8
@@ -70,14 +70,6 @@ static int system_refcount_dec(struct event_subsystem *system)#define while_for_each_event_file () \ } -static struct list_head * -trace_get_fields (struct trace_event_call *event_call) -{ -if (!event_call->class->get_fields) -return &event_call->class->fields; -return event_call->class->get_fields (event_call); -} -static struct ftrace_event_field *__find_event_field (struct list_head *head,char *name) {
Signature · 1 line
2.21.0
PATCH 4/4 trace: introduce trace event injection
In reply to Cong WangWe have been trying to use rasdaemon to monitor hardware errors like correctable memory errors. rasdaemon uses trace events to monitor various hardware errors. In order to test it, we have to inject some hardware errors, unfortunately not all of them provide error injections. MCE does provide a way to inject MCE errors, but errors like PCI error and devlink error don't, it is not easy to add error injection to each of them. Instead, it is relatively easier to just allow users to inject trace events in a generic way so that all trace events can be injected.
This patch introduces trace event injection, where a new 'inject' is added to each tracepoint directory. Users could write into this file with key=value pairs to specify the value of each fields of the trace event, all unspecified fields are set to zero values by default.
For example, for the net/net_dev_queue tracepoint, we can inject:
INJECT=/sys/kernel/debug/tracing/events/net/net_dev_queue/inject echo "" > $INJECT
echo "name='test'" > $INJECT
echo "name='test' len=1024" > $INJECT
cat /sys/kernel/debug/tracing/trace
...
<...>-614 [000] .... 36.571483: net_dev_queue: dev= skbaddr=00000000fbf338c2 len=0 <...>-614 [001] .... 136.588252: net_dev_queue: dev=test skbaddr=00000000fbf338c2 len=0 <...>-614 [001] .N.. 208.431878: net_dev_queue: dev=test skbaddr=00000000fbf338c2 len=1024
Triggers could be triggered as usual too:
echo "stacktrace if len == 1025" > /sys/kernel/debug/tracing/events/net/net_dev_queue/trigger echo "len=1025" > $INJECT
cat /sys/kernel/debug/tracing/trace
...
bash-614 [000] .... 36.571483: net_dev_queue: dev= skbaddr=00000000fbf338c2 len=0
bash-614 [001] .... 136.588252: net_dev_queue: dev=test skbaddr=00000000fbf338c2 len=0
bash-614 [001] .N.. 208.431878: net_dev_queue: dev=test skbaddr=00000000fbf338c2 len=1024
bash-614 [001] .N.1 284.236349: <stack trace> => event_inject_write
=> vfs_write
=> ksys_write
=> do_syscall_64
=> entry_SYSCALL_64_after_hwframe
The only thing that can't be injected is string pointers as they require constant string pointers, this can't be done at run time.
--- kernel/trace/Makefile | 1 + kernel/trace/trace.h | 1 + kernel/trace/trace_events.c | 4 + kernel/trace/trace_events_inject.c | 330 +++++++++++++++++++++++++++++ 4 files changed, 336 insertions(+) create mode 100644 kernel/trace/trace_events_inject.c
kernel/trace/Makefile +1 -0
@@ -69,6 +69,7 @@ obj-$(CONFIG_EVENT_TRACING) += trace_event_perf.o endif obj-$(CONFIG_EVENT_TRACING) += trace_events_filter.o obj-$(CONFIG_EVENT_TRACING) += trace_events_trigger.o +obj-$(CONFIG_EVENT_TRACING) += trace_events_inject.o obj-$(CONFIG_HIST_TRIGGERS) += trace_events_hist.o obj-$(CONFIG_BPF_EVENTS) += bpf_trace.o obj-$(CONFIG_KPROBE_EVENTS) += trace_kprobe.o
kernel/trace/trace.h +1 -0
@@ -1583,6 +1583,7 @@ extern struct list_head ftrace_events;extern const struct file_operations event_trigger_fops;extern const struct file_operations event_hist_fops; +extern const struct file_operations event_inject_fops;#ifdef CONFIG_HIST_TRIGGERS extern int register_trigger_hist_cmd (void );
kernel/trace/trace_events.c +4 -0
@@ -2018,6 +2018,10 @@ event_create_dir(struct dentry *parent, struct trace_event_file *file)trace_create_file ("format" ,0444 , file->dir, call, &ftrace_event_format_fops); +if (call->event.type && call->class->reg) +trace_create_file ("inject" ,0200 , file->dir, file, + &event_inject_fops); +return 0 ; }
kernel/trace/trace_events_inject.c new file +330 -0
330 lines not on this page · raw message
Signature · 1 line
2.21.0
Steven Rostedt
maintainerHi Cong,
I finally got around to looking at these patches. Sorry for such a long time, I've been terribly busy :-(
BTW, it's best to look at how other commits in a subsystem do their subject lines. The subsystem is "tracing" not "trace", and Linus prefers to have the first letter after that capitalized. For example, I changed your subject to:
"tracing: Introduce trace event injection"
Quoted 6 lines · On Sat, 25 May 2019 09:58:02 -0700 Cong Wang <[email protected]> wrote:
For example, for the
net/net_dev_queuetracepoint, we can inject:INJECT=/sys/kernel/debug/tracing/events/net/net_dev_queue/inject echo "" > $INJECT
echo "name='test'" > $INJECT
echo "name='test' len=1024" > $INJECT
I think you meant "dev='test'" not "name='test'"
Quoted 96 lines
cat
/sys/kernel/debug/tracing/trace
...<...>-614 [000] .... 36.571483: net_dev_queue: dev= skbaddr=00000000fbf338c2 len=0 <...>-614 [001] .... 136.588252: net_dev_queue: dev=test skbaddr=00000000fbf338c2 len=0 <...>-614 [001] .N.. 208.431878: net_dev_queue: dev=test skbaddr=00000000fbf338c2 len=1024Triggers could be triggered as usual too:
echo "stacktrace if len == 1025" >
/sys/kernel/debug/tracing/events/net/net_dev_queue/triggerecho "len=1025" > $INJECT
cat/sys/kernel/debug/tracing/trace
...bash-614 [000] .... 36.571483: net_dev_queue: dev= skbaddr=00000000fbf338c2 len=0 bash-614 [001] .... 136.588252: net_dev_queue: dev=test skbaddr=00000000fbf338c2 len=0 bash-614 [001] .N.. 208.431878: net_dev_queue: dev=test skbaddr=00000000fbf338c2 len=1024 bash-614 [001] .N.1 284.236349: <stack trace>=>
event_inject_write
=>vfs_write
=>ksys_write
=>do_syscall_64
=>entry_SYSCALL_64_after_hwframeThe only thing that can't be injected is string pointers as they require constant string pointers, this can't be done at run time.
Cc Steven Rostedt <[email protected]>Cc Ingo Molnar <[email protected]>Signed-off-by Cong Wang <[email protected]>--- kernel/trace/Makefile | 1 + kernel/trace/trace.h | 1 + kernel/trace/trace_events.c | 4 + kernel/trace/trace_events_inject.c | 330 +++++++++++++++++++++++++++++ 4 files changed, 336 insertions(+) create mode 100644 kernel/trace/trace_events_inject.ckernel/trace/Makefile +1
-0@@ -69,6 +69,7 @@ obj-$(CONFIG_EVENT_TRACING) += trace_event_perf.o endif obj-$(CONFIG_EVENT_TRACING) += trace_events_filter.o obj-$(CONFIG_EVENT_TRACING) += trace_events_trigger.o +obj-$(CONFIG_EVENT_TRACING) += trace_events_inject.o obj-$(CONFIG_HIST_TRIGGERS) += trace_events_hist.o obj-$(CONFIG_BPF_EVENTS) += bpf_trace.o obj-$(CONFIG_KPROBE_EVENTS) += trace_kprobe.okernel/trace/trace.h +1
-0@@ -1583,6 +1583,7 @@ extern struct list_head ftrace_events;extern const struct file_operations event_trigger_fops;extern const struct file_operations event_hist_fops; +extern const struct file_operations event_inject_fops;#ifdef CONFIG_HIST_TRIGGERS extern int register_trigger_hist_cmd (void );kernel/trace/trace_events.c +4
-0@@ -2018,6 +2018,10 @@ event_create_dir(struct dentry *parent, struct trace_event_file *file)trace_create_file ("format" ,0444 , file->dir, call, &ftrace_event_format_fops); +if (call->event.type && call->class->reg) +trace_create_file ("inject" ,0200 , file->dir, file, + &event_inject_fops); +return 0 ; }kernel/trace/trace_events_inject.c new file +15
-0@@ -0,0 +1,330 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* trace_events_inject - trace event injection +* +* Copyright (C) 2019 Cong Wang <[email protected]> +*/ + +#include <linux/module.h> +#include <linux/ctype.h> +#include <linux/mutex.h> +#include <linux/slab.h> +#include <linux/rculist.h> + +#include "trace.h" +
kernel/trace/trace_events_inject.c line 25
Quoted 10 lines
kernel/trace/trace_events_inject.c new file +10
-0+static int +trace_inject_entry (struct trace_event_file *file,void *rec,int len) +{ +struct trace_event_buffer fbuffer; +struct ring_buffer *buffer; +int written =0 ; +void *entry; + + buffer = file->tr->trace_buffer.buffer; +ring_buffer_nest_start (buffer);
I'm curious about why you added the ring_buffer_nest_start().
Quoted 43 lines
kernel/trace/trace_events_inject.c new file +43
-0+ + entry =trace_event_buffer_reserve (&fbuffer, file, len); +if (entry) { +memcpy (entry, rec, len); + written = len; +trace_event_buffer_commit (&fbuffer); + } + +ring_buffer_nest_end (buffer); +return written; +} + +static int +parse_field (char *str,struct trace_event_call *call, +struct ftrace_event_field **pf,u64 *pv) +{ +struct ftrace_event_field *field; +char *field_name; +int s, i =0 ; +char *p; +int len; +u64 val; + +if (!str[i]) +return 0 ; +/* First find the field to associate to */ +while (isspace (str[i])) + i++; + s = i; +while (isalnum (str[i]) || str[i] =='_' ) + i++; + len = i - s; +if (!len) +return -EINVAL ; + + field_name =kmemdup_nul (str + s, len,GFP_KERNEL ); +if (!field_name) +return -ENOMEM ; + field =trace_find_event_field (call, field_name); +kfree (field_name); +if (!field) +return -ENOENT ; +
kernel/trace/trace_events_inject.c line 78
Quoted 10 lines
kernel/trace/trace_events_inject.c new file +10
-0+ *pf = field; + p =strchr (str + i,'=' ); +if (!p) +return -EINVAL ; + i = p +1 - str; +while (isspace (str[i])) + i++; + s = i; +if (isdigit (str[i]) || str[i] =='-' ) { +char num_buf[24 ];/* Big enough to hold an address */
Do you really need this buffer? See below.
Quoted 10 lines
kernel/trace/trace_events_inject.c new file +10
-0+int ret; + +/* Make sure the field is not a string */ +if (is_string_field (field)) +return -EINVAL ; + +if (str[i] =='-' ) + i++; + +/* We allow 0xDEADBEEF */
kernel/trace/trace_events_inject.c line 98
Quoted 10 lines
kernel/trace/trace_events_inject.c new file +10
-0+while (isalnum (str[i])) + i++; + + len = i - s; +/* 0xfeedfacedeadbeef is 18 chars max */ +if (len >=sizeof (num_buf)) +return -EINVAL ; + +strncpy (num_buf, str + s, len); + num_buf[len] =0 ;
Instead of using num_buf[], as str is already modified in the else statement, we could do:
char *num; char c; num = str + s; c = str[i]; str[i] = '\0'; [..] ret = kstrtoll(num, 0, &val); [..] str[i] = c;
Quoted 9 lines
kernel/trace/trace_events_inject.c new file +9
-0+ +/* Make sure it is a value */ +if (field->is_signed) + ret =kstrtoll (num_buf,0 , &val); +else + ret =kstrtoull (num_buf,0 , &val); +if (ret) +return ret; +
kernel/trace/trace_events_inject.c line 117
Quoted 10 lines
kernel/trace/trace_events_inject.c new file +10
-0+ *pv = val; +return i; + }else if (str[i] =='\'' || str[i] =='"' ) { +char q = str[i]; + +/* Make sure the field is OK for strings */ +if (!is_string_field (field)) +return -EINVAL ; + +for (i++; str[i]; i++) {
Should we allow for \' and \"?
if (str[i] == '\\' && str[i + 1]) {
i++;
continue;
}Quoted 20 lines
kernel/trace/trace_events_inject.c new file +20
-0+if (str[i] == q) +break ; + } +if (!str[i]) +return -EINVAL ; + +/* Skip quotes */ + s++; + len = i - s; +if (len >=MAX_FILTER_STR_VAL ) +return -EINVAL ; + + *pv = (unsigned long )(str + s); + str[i] =0 ; +/* go past the last quote */ + i++; +return i; + } + +return -EINVAL ;
kernel/trace/trace_events_inject.c line 147
Quoted 10 lines
kernel/trace/trace_events_inject.c new file +10
-0+} + +static int trace_get_entry_size (struct trace_event_call *call) +{ +struct ftrace_event_field *field; +struct list_head *head; +int size =0 ; + + head =trace_get_fields (call); +list_for_each_entry (field, head, link)
Add a '{' for the loop. We only allow for removing braces for non complex statements.
Quoted 72 lines
kernel/trace/trace_events_inject.c new file +72
-0+if (field->size + field->offset > size) + size = field->size + field->offset; + +return size; +} + +static void *trace_alloc_entry (struct trace_event_call *call,int *size) +{ +int entry_size =trace_get_entry_size (call); +struct ftrace_event_field *field; +struct list_head *head; +void *entry =NULL ; + +/* We need an extra '\0' at the end. */ + entry =kzalloc (entry_size +1 ,GFP_KERNEL ); +if (!entry) +return NULL ; + + head =trace_get_fields (call); +list_for_each_entry (field, head, link) { +if (!is_string_field (field)) +continue ; +if (field->filter_type ==FILTER_STATIC_STRING ) +continue ; +if (field->filter_type ==FILTER_DYN_STRING ) { +u32 *str_item; +int str_len =0 ; +int str_loc = entry_size &0xffff ; + + str_item = (u32 *)(entry + field->offset); + *str_item = (str_len <<16 ) | str_loc; + }else { +char **paddr; + + paddr = (char **)(entry + field->offset); + *paddr ="" ; + } + } + + *size = entry_size +1 ; +return entry; +} + +#define INJECT_STRING "STATIC STRING CAN NOT BE INJECTED" + +static int parse_entry (char *str,struct trace_event_call *call,void **pentry) +{ +struct ftrace_event_field *field; +unsigned long irq_flags; +void *entry =NULL ; +int entry_size; +u64 val; +int len; + + entry =trace_alloc_entry (call, &entry_size); + *pentry = entry; +if (!entry) +return -ENOMEM ; + +local_save_flags (irq_flags); +tracing_generic_entry_update (entry, call->event.type, irq_flags, +preempt_count ()); + +while ((len =parse_field (str, call, &field, &val)) >0 ) { +if (is_function_field (field)) +return -EINVAL ; + +if (is_string_field (field)) { +char *addr = (char *)(unsigned long ) val; + +if (field->filter_type ==FILTER_STATIC_STRING ) { +strlcpy (entry + field->offset, addr, field->size);
kernel/trace/trace_events_inject.c line 229
Quoted 10 lines
kernel/trace/trace_events_inject.c new file +10
-0+ }else if (field->filter_type ==FILTER_DYN_STRING ) { +u32 *str_item; +int str_len =strlen (addr) +1 ; +int str_loc = entry_size &0xffff ; + + entry_size += str_len; + *pentry =krealloc (entry, entry_size,GFP_KERNEL ); + entry = *pentry; +if (!entry) +return -ENOMEM ;
Add a comment here that states that *pentry gets freed by the caller even on error, otherwise, to a reviewer this looks like a possible memory leak. Or worse, we add a new caller that doesn't free it. Perhaps we should add a comment above the function.
kernel/trace/trace_events_inject.c line 237
Quoted 8 lines
kernel/trace/trace_events_inject.c new file +8
-0+ +strlcpy (entry + (entry_size - str_len), addr, str_len); + str_item = (u32 *)(entry + field->offset); + *str_item = (str_len <<16 ) | str_loc; + }else { +char **paddr; + +/* TODO: can we find the constant string? */
Honestly, char * is dangerous in tracing. Because the time you read the pointer, what you pointed at during the recording could be long gone. I really should have them removed in the code. In other words, don't worry about pointer strings and such.
You can keep this as is.
Quoted 83 lines
kernel/trace/trace_events_inject.c new file +83
-0+ paddr = (char **)(entry + field->offset); + *paddr =INJECT_STRING ; + } + }else { +switch (field->size) { +case 1 : { +u8 tmp = (u8 ) val; + +memcpy (entry + field->offset, &tmp,1 ); +break ; + } +case 2 : { +u16 tmp = (u16 ) val; + +memcpy (entry + field->offset, &tmp,2 ); +break ; + } +case 4 : { +u32 tmp = (u32 ) val; + +memcpy (entry + field->offset, &tmp,4 ); +break ; + } +case 8 : +memcpy (entry + field->offset, &val,8 ); +break ; +default : +return -EINVAL ; + } + } + + str += len; + } + +if (len <0 ) +return len; + +return entry_size; +} + +static ssize_t +event_inject_write (struct file *filp,const char __user *ubuf,size_t cnt, +loff_t *ppos) +{ +struct trace_event_call *call; +struct trace_event_file *file; +int err = -ENODEV , size; +void *entry =NULL ; +char *buf; + +if (cnt >=PAGE_SIZE ) +return -EINVAL ; + + buf =memdup_user_nul (ubuf, cnt); +if (IS_ERR (buf)) +return PTR_ERR (buf); +strim (buf); + +mutex_lock (&event_mutex); + file =event_file_data (filp); +if (file) { + call = file->event_call; + size =parse_entry (buf, call, &entry); +if (size <0 ) + err = size; +else + err =trace_inject_entry (file, entry, size); + } +mutex_unlock (&event_mutex); + +kfree (entry); +kfree (buf); + +if (err <0 ) +return err; + + *ppos += err; +return cnt; +} + +static ssize_t +event_inject_read (struct file *file,char __user *buf,size_t size, +loff_t *ppos)
kernel/trace/trace_events_inject.c line 330
Quoted 10 lines
kernel/trace/trace_events_inject.c new file +10
-0+{ +return -EPERM ; +} + +const struct file_operations event_inject_fops = { + .open = tracing_open_generic, + .read = event_inject_read, + .write = event_inject_write, +}; +
The rest looks fine. Note, I'm sorry for the late response, but as the merge window opened, I'll probably wait till after the merge window closes before adding this.
That said, I'll apply the first three patches and get them in this merge window, as they are mostly clean ups.
Thanks!
-- Steve
Quoted 7 lines · Steven Rostedt
Hi Cong,
I finally got around to looking at these patches. Sorry for such a long time, I've been terribly busy :-(
Quoted 6 lines
BTW, it's best to look at how other commits in a subsystem do their subject lines. The subsystem is "tracing" not "trace", and Linus prefers to have the first letter after that capitalized. For example, I changed your subject to:
"tracing: Introduce trace event injection"
Sure, will update it.
Quoted 5 lines
On Sat, 25 May 2019 09:58:02 -0700
Cong Wang <[email protected]> wrote:
Quoted 8 lines
Quoted 6 lines
For example, for the
net/net_dev_queuetracepoint, we can inject:INJECT=/sys/kernel/debug/tracing/events/net/net_dev_queue/inject echo "" > $INJECT
echo "name='test'" > $INJECT
echo "name='test' len=1024" > $INJECTI think you meant "dev='test'" not "name='test'"
No, the filed name is "name", "dev" is just what shows in the output:
TP_printk("dev=%s skbaddr=%p len=%u",
__get_str(name), __entry->skbaddr, __entry->len)I was confused too when I saw it at first. :)
Quoted 101 lines
Quoted 101 lines
cat
/sys/kernel/debug/tracing/trace
...<...>-614 [000] .... 36.571483: net_dev_queue: dev= skbaddr=00000000fbf338c2 len=0 <...>-614 [001] .... 136.588252: net_dev_queue: dev=test skbaddr=00000000fbf338c2 len=0 <...>-614 [001] .N.. 208.431878: net_dev_queue: dev=test skbaddr=00000000fbf338c2 len=1024Triggers could be triggered as usual too:
echo "stacktrace if len == 1025" >
/sys/kernel/debug/tracing/events/net/net_dev_queue/triggerecho "len=1025" > $INJECT
cat/sys/kernel/debug/tracing/trace
...bash-614 [000] .... 36.571483: net_dev_queue: dev= skbaddr=00000000fbf338c2 len=0 bash-614 [001] .... 136.588252: net_dev_queue: dev=test skbaddr=00000000fbf338c2 len=0 bash-614 [001] .N.. 208.431878: net_dev_queue: dev=test skbaddr=00000000fbf338c2 len=1024 bash-614 [001] .N.1 284.236349: <stack trace>=>
event_inject_write
=>vfs_write
=>ksys_write
=>do_syscall_64
=>entry_SYSCALL_64_after_hwframeThe only thing that can't be injected is string pointers as they require constant string pointers, this can't be done at run time.
Cc Steven Rostedt <[email protected]>Cc Ingo Molnar <[email protected]>Signed-off-by Cong Wang <[email protected]>--- kernel/trace/Makefile | 1 + kernel/trace/trace.h | 1 + kernel/trace/trace_events.c | 4 + kernel/trace/trace_events_inject.c | 330 +++++++++++++++++++++++++++++ 4 files changed, 336 insertions(+) create mode 100644 kernel/trace/trace_events_inject.ckernel/trace/Makefile +1
-0@@ -69,6 +69,7 @@ obj-$(CONFIG_EVENT_TRACING) += trace_event_perf.o endif obj-$(CONFIG_EVENT_TRACING) += trace_events_filter.o obj-$(CONFIG_EVENT_TRACING) += trace_events_trigger.o +obj-$(CONFIG_EVENT_TRACING) += trace_events_inject.o obj-$(CONFIG_HIST_TRIGGERS) += trace_events_hist.o obj-$(CONFIG_BPF_EVENTS) += bpf_trace.o obj-$(CONFIG_KPROBE_EVENTS) += trace_kprobe.okernel/trace/trace.h +1
-0@@ -1583,6 +1583,7 @@ extern struct list_head ftrace_events;extern const struct file_operations event_trigger_fops;extern const struct file_operations event_hist_fops; +extern const struct file_operations event_inject_fops;#ifdef CONFIG_HIST_TRIGGERS extern int register_trigger_hist_cmd (void );kernel/trace/trace_events.c +4
-0@@ -2018,6 +2018,10 @@ event_create_dir(struct dentry *parent, struct trace_event_file *file)trace_create_file ("format" ,0444 , file->dir, call, &ftrace_event_format_fops); +if (call->event.type && call->class->reg) +trace_create_file ("inject" ,0200 , file->dir, file, + &event_inject_fops); +return 0 ; }kernel/trace/trace_events_inject.c new file +19
-0@@ -0,0 +1,330 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* trace_events_inject - trace event injection +* +* Copyright (C) 2019 Cong Wang <[email protected]> +*/ + +#include <linux/module.h> +#include <linux/ctype.h> +#include <linux/mutex.h> +#include <linux/slab.h> +#include <linux/rculist.h> + +#include "trace.h" + +static int +trace_inject_entry (struct trace_event_file *file,void *rec,int len) +{ +struct trace_event_buffer fbuffer;
Quoted 8 lines
kernel/trace/trace_events_inject.c line 25
Quoted 6 lines
kernel/trace/trace_events_inject.c new file +6
-0+struct ring_buffer *buffer; +int written =0 ; +void *entry; + + buffer = file->tr->trace_buffer.buffer; +ring_buffer_nest_start (buffer);I'm curious about why you added the
ring_buffer_nest_start().
This is a copy-n-paste, I can remove it if it is not needed in this context.
Quoted 81 lines
Quoted 44 lines
kernel/trace/trace_events_inject.c new file +43
-0+ + entry =trace_event_buffer_reserve (&fbuffer, file, len); +if (entry) { +memcpy (entry, rec, len); + written = len; +trace_event_buffer_commit (&fbuffer); + } + +ring_buffer_nest_end (buffer); +return written; +} + +static int +parse_field (char *str,struct trace_event_call *call, +struct ftrace_event_field **pf,u64 *pv) +{ +struct ftrace_event_field *field; +char *field_name; +int s, i =0 ; +char *p; +int len; +u64 val; + +if (!str[i]) +return 0 ; +/* First find the field to associate to */ +while (isspace (str[i])) + i++; + s = i; +while (isalnum (str[i]) || str[i] =='_' ) + i++; + len = i - s; +if (!len) +return -EINVAL ; + + field_name =kmemdup_nul (str + s, len,GFP_KERNEL ); +if (!field_name) +return -ENOMEM ; + field =trace_find_event_field (call, field_name); +kfree (field_name); +if (!field) +return -ENOENT ; +kernel/trace/trace_events_inject.c line 78
Quoted 10 lines
kernel/trace/trace_events_inject.c new file +10
-0+ *pf = field; + p =strchr (str + i,'=' ); +if (!p) +return -EINVAL ; + i = p +1 - str; +while (isspace (str[i])) + i++; + s = i; +if (isdigit (str[i]) || str[i] =='-' ) { +char num_buf[24 ];/* Big enough to hold an address */ Do you really need this buffer? See below.
Quoted 10 lines
kernel/trace/trace_events_inject.c new file +10
-0+int ret; + +/* Make sure the field is not a string */ +if (is_string_field (field)) +return -EINVAL ; + +if (str[i] =='-' ) + i++; + +/* We allow 0xDEADBEEF */ kernel/trace/trace_events_inject.c line 98
Quoted 10 lines
kernel/trace/trace_events_inject.c new file +10
-0+while (isalnum (str[i])) + i++; + + len = i - s; +/* 0xfeedfacedeadbeef is 18 chars max */ +if (len >=sizeof (num_buf)) +return -EINVAL ; + +strncpy (num_buf, str + s, len); + num_buf[len] =0 ;Instead of using num_buf[], as str is already modified in the else statement, we could do:
Quoted 10 lines
char *num;
char c;
num = str + s;
c = str[i];
str[i] = '\0';
[..]
ret = kstrtoll(num, 0, &val);
[..]
str[i] = c;Good point, I think it probably can be removed as you said, let me do a double check.
Quoted 24 lines
Quoted 11 lines
kernel/trace/trace_events_inject.c new file +9
-0+ +/* Make sure it is a value */ +if (field->is_signed) + ret =kstrtoll (num_buf,0 , &val); +else + ret =kstrtoull (num_buf,0 , &val); +if (ret) +return ret; +kernel/trace/trace_events_inject.c line 117
Quoted 10 lines
kernel/trace/trace_events_inject.c new file +10
-0+ *pv = val; +return i; + }else if (str[i] =='\'' || str[i] =='"' ) { +char q = str[i]; + +/* Make sure the field is OK for strings */ +if (!is_string_field (field)) +return -EINVAL ; + +for (i++; str[i]; i++) {Should we allow for \' and \"?
Quoted 4 lines
if (str[i] == '\\' && str[i + 1]) {
i++;
continue;
}Good suggestion. I think it is good to have it.
Quoted 27 lines
Quoted 27 lines
kernel/trace/trace_events_inject.c new file +25
-0+if (str[i] == q) +break ; + } +if (!str[i]) +return -EINVAL ; + +/* Skip quotes */ + s++; + len = i - s; +if (len >=MAX_FILTER_STR_VAL ) +return -EINVAL ; + + *pv = (unsigned long )(str + s); + str[i] =0 ; +/* go past the last quote */ + i++; +return i; + } + +return -EINVAL ; +} + +static int trace_get_entry_size (struct trace_event_call *call) +{ +struct ftrace_event_field *field;
Quoted 8 lines
kernel/trace/trace_events_inject.c line 147
Quoted 5 lines
kernel/trace/trace_events_inject.c new file +5
-0+struct list_head *head; +int size =0 ; + + head =trace_get_fields (call); +list_for_each_entry (field, head, link)Add a '{' for the loop. We only allow for removing braces for non complex statements.
OK.
Quoted 81 lines
Quoted 81 lines
kernel/trace/trace_events_inject.c new file +79
-0+if (field->size + field->offset > size) + size = field->size + field->offset; + +return size; +} + +static void *trace_alloc_entry (struct trace_event_call *call,int *size) +{ +int entry_size =trace_get_entry_size (call); +struct ftrace_event_field *field; +struct list_head *head; +void *entry =NULL ; + +/* We need an extra '\0' at the end. */ + entry =kzalloc (entry_size +1 ,GFP_KERNEL ); +if (!entry) +return NULL ; + + head =trace_get_fields (call); +list_for_each_entry (field, head, link) { +if (!is_string_field (field)) +continue ; +if (field->filter_type ==FILTER_STATIC_STRING ) +continue ; +if (field->filter_type ==FILTER_DYN_STRING ) { +u32 *str_item; +int str_len =0 ; +int str_loc = entry_size &0xffff ; + + str_item = (u32 *)(entry + field->offset); + *str_item = (str_len <<16 ) | str_loc; + }else { +char **paddr; + + paddr = (char **)(entry + field->offset); + *paddr ="" ; + } + } + + *size = entry_size +1 ; +return entry; +} + +#define INJECT_STRING "STATIC STRING CAN NOT BE INJECTED" + +static int parse_entry (char *str,struct trace_event_call *call,void **pentry) +{ +struct ftrace_event_field *field; +unsigned long irq_flags; +void *entry =NULL ; +int entry_size; +u64 val; +int len; + + entry =trace_alloc_entry (call, &entry_size); + *pentry = entry; +if (!entry) +return -ENOMEM ; + +local_save_flags (irq_flags); +tracing_generic_entry_update (entry, call->event.type, irq_flags, +preempt_count ()); + +while ((len =parse_field (str, call, &field, &val)) >0 ) { +if (is_function_field (field)) +return -EINVAL ; + +if (is_string_field (field)) { +char *addr = (char *)(unsigned long ) val; + +if (field->filter_type ==FILTER_STATIC_STRING ) { +strlcpy (entry + field->offset, addr, field->size); + }else if (field->filter_type ==FILTER_DYN_STRING ) { +u32 *str_item; +int str_len =strlen (addr) +1 ; +int str_loc = entry_size &0xffff ; + + entry_size += str_len; + *pentry =krealloc (entry, entry_size,GFP_KERNEL );
Quoted 8 lines
kernel/trace/trace_events_inject.c line 229
Quoted 3 lines
kernel/trace/trace_events_inject.c new file +3
-0+ entry = *pentry; +if (!entry) +return -ENOMEM ;Add a comment here that states that *pentry gets freed by the caller even on error, otherwise, to a reviewer this looks like a possible memory leak. Or worse, we add a new caller that doesn't free it. Perhaps we should add a comment above the function.
Agreed, I will add a comment above this function.
Quoted 15 lines
kernel/trace/trace_events_inject.c line 237
Quoted 9 lines
kernel/trace/trace_events_inject.c new file +8
-0+ +strlcpy (entry + (entry_size - str_len), addr, str_len); + str_item = (u32 *)(entry + field->offset); + *str_item = (str_len <<16 ) | str_loc; + }else { +char **paddr; + +/* TODO: can we find the constant string? */ Honestly, char * is dangerous in tracing. Because the time you read the pointer, what you pointed at during the recording could be long gone. I really should have them removed in the code. In other words, don't worry about pointer strings and such.
Quoted 1 line
You can keep this as is.
Ok, good to know.
Quoted 90 lines
Quoted 90 lines
kernel/trace/trace_events_inject.c new file +89
-0+ paddr = (char **)(entry + field->offset); + *paddr =INJECT_STRING ; + } + }else { +switch (field->size) { +case 1 : { +u8 tmp = (u8 ) val; + +memcpy (entry + field->offset, &tmp,1 ); +break ; + } +case 2 : { +u16 tmp = (u16 ) val; + +memcpy (entry + field->offset, &tmp,2 ); +break ; + } +case 4 : { +u32 tmp = (u32 ) val; + +memcpy (entry + field->offset, &tmp,4 ); +break ; + } +case 8 : +memcpy (entry + field->offset, &val,8 ); +break ; +default : +return -EINVAL ; + } + } + + str += len; + } + +if (len <0 ) +return len; + +return entry_size; +} + +static ssize_t +event_inject_write (struct file *filp,const char __user *ubuf,size_t cnt, +loff_t *ppos) +{ +struct trace_event_call *call; +struct trace_event_file *file; +int err = -ENODEV , size; +void *entry =NULL ; +char *buf; + +if (cnt >=PAGE_SIZE ) +return -EINVAL ; + + buf =memdup_user_nul (ubuf, cnt); +if (IS_ERR (buf)) +return PTR_ERR (buf); +strim (buf); + +mutex_lock (&event_mutex); + file =event_file_data (filp); +if (file) { + call = file->event_call; + size =parse_entry (buf, call, &entry); +if (size <0 ) + err = size; +else + err =trace_inject_entry (file, entry, size); + } +mutex_unlock (&event_mutex); + +kfree (entry); +kfree (buf); + +if (err <0 ) +return err; + + *ppos += err; +return cnt; +} + +static ssize_t +event_inject_read (struct file *file,char __user *buf,size_t size, +loff_t *ppos) +{ +return -EPERM ; +} + +const struct file_operations event_inject_fops = { + .open = tracing_open_generic,
Quoted 8 lines
kernel/trace/trace_events_inject.c line 330
Quoted 4 lines
kernel/trace/trace_events_inject.c new file +4
-0+ .read = event_inject_read, + .write = event_inject_write, +}; +The rest looks fine. Note, I'm sorry for the late response, but as the merge window opened, I'll probably wait till after the merge window closes before adding this.
No problem.
Quoted 3 lines
That said, I'll apply the first three patches and get them in this merge window, as they are mostly clean ups.
Sounds good, I read this as I will only have to update and resend the last patch in this series.
Thanks.
Steven Rostedt
maintainerQuoted 6 lines · On Sat, 25 May 2019 09:57:58 -0700 Cong Wang <[email protected]> wrote:
This patchset introduces trace event injection, the first 3 patches are some trivial prerequisites, the last one implements the trace event injection. Please check each patch for details.
I have tested them with both valid and invalid input on different tracepoints, it works as expected.
Hi Cong,
Thanks for sending these patches, but I just want to let you know that it's currently a US holiday, and then afterward I'll be doing quite a bit of traveling for the next two weeks. If you don't hear from me in after two weeks, please send me a reminder.
Thanks!
-- Steve
Quoted 24 lines
Cc Steven Rostedt <[email protected]>Cc Ingo Molnar <[email protected]>Signed-off-by Cong Wang <[email protected]>---
Cong Wang (4):
trace: fold type initialization intotracing_generic_entry_update()
trace: letfilter_assign_type()detectFILTER_PTR_STRING
trace: maketrace_get_fields()global
trace: introduce trace event injectioninclude/linux/trace_events.h | 9 + kernel/trace/Makefile | 1 + kernel/trace/trace.c | 8 +- kernel/trace/trace.h | 1 + kernel/trace/trace_event_perf.c | 3 +- kernel/trace/trace_events.c | 12 +- kernel/trace/trace_events_filter.c | 3 + kernel/trace/trace_events_inject.c | 330 +++++++++++++++++++++++++++++ 8 files changed, 353 insertions(+), 14 deletions(-) create mode 100644 kernel/trace/trace_events_inject.c
Quoted 11 lines · Steven Rostedt
Quoted 6 lines · On Sat, 25 May 2019 09:57:58 -0700 Cong Wang <[email protected]> wrote:
This patchset introduces trace event injection, the first 3 patches are some trivial prerequisites, the last one implements the trace event injection. Please check each patch for details.
I have tested them with both valid and invalid input on different tracepoints, it works as expected.
Quoted 6 lines
Hi Cong,
Thanks for sending these patches, but I just want to let you know that it's currently a US holiday, and then afterward I'll be doing quite a bit of traveling for the next two weeks. If you don't hear from me in after two weeks, please send me a reminder.
I will do it. Thanks for letting me know!
Quoted 6 lines · Steven Rostedt
Hi Cong,
Thanks for sending these patches, but I just want to let you know that it's currently a US holiday, and then afterward I'll be doing quite a bit of traveling for the next two weeks. If you don't hear from me in after two weeks, please send me a reminder.
This is a reminder after two weeks. :) Please review my patches when you have a chance.
Thanks.
Steven Rostedt
maintainerQuoted 11 lines · On Mon, 10 Jun 2019 14:11:57 -0700 Cong Wang <[email protected]> wrote:
Quoted 6 lines · Steven Rostedt
Hi Cong,
Thanks for sending these patches, but I just want to let you know that it's currently a US holiday, and then afterward I'll be doing quite a bit of traveling for the next two weeks. If you don't hear from me in after two weeks, please send me a reminder.
This is a reminder after two weeks. :) Please review my patches when you have a chance.
Thanks for the reminder. I'll try to get to it this week.
-- Steve
Steven Rostedt
maintainerQuoted 11 lines · On Mon, 10 Jun 2019 21:12:04 -0400 Steven Rostedt <[email protected]> wrote:
Quoted 8 lines · On Mon, 10 Jun 2019 14:11:57 -0700 Cong Wang <[email protected]> wrote:
Quoted 6 lines · Steven Rostedt
Hi Cong,
Thanks for sending these patches, but I just want to let you know that it's currently a US holiday, and then afterward I'll be doing quite a bit of traveling for the next two weeks. If you don't hear from me in after two weeks, please send me a reminder.
Quoted 6 lines
Quoted 3 lines
This is a reminder after two weeks. :) Please review my patches when you have a chance.
Thanks for the reminder. I'll try to get to it this week.
Bah, sorry I haven't gotten to this yet. It's still in my queue to do, and I'm going to be traveling again. I have not forgotten about it. It's now marked in my INBOX patchwork, so it will not be forgotten.
-- Steve