tracing: Minor clean ups, fixes and error checking
Subsystems (2)
Steven Rostedt
maintainerLinus,
This contains a series of last minute clean ups, small fixes and error checks.
Please pull the latest trace-v5.1-2 tree, which can be found at:
git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace.git
trace-v5.1-2
Tag SHA1: de3d34862ab43473fb0ce9d774c09241b85c7c9c Head SHA1: a039480e9e93896cadc5a91468964febb3c5d488
Douglas Anderson (1):
tracing: kdb: Fix ftdump to not sleep
Masami Hiramatsu (5):
tracing/probe: Check maxactive error cases tracing/probe: Check event name length correctly tracing/probe: Check the size of argument name and body tracing/probe: Check event/group naming rule at parsing tracing/probe: Verify alloc_trace_*probe() result
Valdis Kletnieks (2):
tracing/probes: Make reserved_field_names static trace/probes: Remove kernel doc style from non kernel doc comment
----
include/linux/ring_buffer.h | 2 +- kernel/trace/ring_buffer.c | 5 +++-- kernel/trace/trace.c | 6 ++++-- kernel/trace/trace_kdb.c | 6 ++++-- kernel/trace/trace_kprobe.c | 23 +++++++++++------------ kernel/trace/trace_probe.c | 20 ++++++++++++++++++-- kernel/trace/trace_probe.h | 1 + kernel/trace/trace_uprobe.c | 8 +++----- 8 files changed, 45 insertions(+), 26 deletions(-)
Steven Rostedt
maintainerPATCH 1/8 tracing/probes: Make reserved_field_names static
From: =?UTF-8?q?Valdis=20Kl=C4=93tnieks?= <[email protected]>
sparse complains:
CHECK kernel/trace/trace_probe.ckernel/trace/trace_probe.c:16:12: warning: symbol 'reserved_field_names' was not declared. Should it be static?
Yes, it should be static.
--- kernel/trace/trace_probe.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/trace/trace_probe.c +1 -1
@@ -13,7 +13,7 @@#include "trace_probe.h" -const char *reserved_field_names[] = { +static const char *reserved_field_names[] = {"common_type" ,"common_flags" ,"common_preempt_count" ,
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 2/8 trace/probes: Remove kernel doc style from non kernel doc comment
In reply to Steven RostedtFrom: =?UTF-8?q?Valdis=20Kl=C4=93tnieks?= <[email protected]>
CC kernel/trace/trace_kprobe.okernel/trace/trace_kprobe.c:41: warning: cannot understand function prototype: 'struct trace_kprobe '
The real problem is that a comment looked like kerneldoc when it shouldn't be...
--- kernel/trace/trace_kprobe.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/trace/trace_kprobe.c +1 -1
@@ -35,7 +35,7 @@ static struct dyn_event_operations trace_kprobe_ops = { .match = trace_kprobe_match, }; -/** +/* * Kprobe event core functions */ struct trace_kprobe {
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 3/8 tracing: kdb: Fix ftdump to not sleep
In reply to Steven RostedtFrom: Douglas Anderson <[email protected]>
As reported back in 2016-11 [1], the "ftdump" kdb command triggers a BUG for "sleeping function called from invalid context".
kdb's "ftdump" command wants to call ring_buffer_read_prepare() in atomic context. A very simple solution for this is to add allocation flags to ring_buffer_read_prepare() so kdb can call it without triggering the allocation error. This patch does that.
Note that in the original email thread about this, it was suggested that perhaps the solution for kdb was to either preallocate the buffer ahead of time or create our own iterator. I'm hoping that this alternative of adding allocation flags to ring_buffer_read_prepare() can be considered since it means I don't need to duplicate more of the core trace code into "trace_kdb.c" (for either creating my own iterator or re-preparing a ring allocator whose memory was already allocated).
NOTE: another option for kdb is to actually figure out how to make it reuse the existing ftrace_dump() function and totally eliminate the duplication. This sounds very appealing and actually works (the "sr z" command can be seen to properly dump the ftrace buffer). The downside here is that ftrace_dump() fully consumes the trace buffer. Unless that is changed I'd rather not use it because it means "ftdump | grep xyz" won't be very useful to search the ftrace buffer since it will throw away the whole trace on the first grep. A future patch to dump only the last few lines of the buffer will also be hard to implement.
[1] https://lkml.kernel.org/r/[email protected]
--- include/linux/ring_buffer.h | 2 +- kernel/trace/ring_buffer.c | 5 +++-- kernel/trace/trace.c | 6 ++++-- kernel/trace/trace_kdb.c | 6 ++++-- 4 files changed, 12 insertions(+), 7 deletions(-)
include/linux/ring_buffer.h +1 -1
@@ -128,7 +128,7 @@ ring_buffer_consume(struct ring_buffer *buffer, int cpu, u64 *ts, unsigned long *lost_events);struct ring_buffer_iter * -ring_buffer_read_prepare (struct ring_buffer *buffer,int cpu); +ring_buffer_read_prepare (struct ring_buffer *buffer,int cpu,gfp_t flags);void ring_buffer_read_prepare_sync (void );void ring_buffer_read_start (struct ring_buffer_iter *iter);void ring_buffer_read_finish (struct ring_buffer_iter *iter);
kernel/trace/ring_buffer.c +3 -2
@@ -4191,6 +4191,7 @@ EXPORT_SYMBOL_GPL(ring_buffer_consume);* ring_buffer_read_prepare - Prepare for a non consuming read of the buffer * @buffer: The ring buffer to read from * @cpu: The cpu buffer to iterate over +* @flags: gfp flags to use for memory allocation * * This performs the initial preparations necessary to iterate * through the buffer. Memory is allocated, buffer recording
@@ -4208,7 +4209,7 @@ EXPORT_SYMBOL_GPL(ring_buffer_consume);* This overall must be paired with ring_buffer_read_finish. */ struct ring_buffer_iter * -ring_buffer_read_prepare (struct ring_buffer *buffer,int cpu) +ring_buffer_read_prepare (struct ring_buffer *buffer,int cpu,gfp_t flags) {struct ring_buffer_per_cpu *cpu_buffer;struct ring_buffer_iter *iter;
@@ -4216,7 +4217,7 @@ ring_buffer_read_prepare(struct ring_buffer *buffer, int cpu)if (!cpumask_test_cpu (cpu, buffer->cpumask))return NULL ; - iter =kmalloc (sizeof (*iter),GFP_KERNEL ); + iter =kmalloc (sizeof (*iter), flags);if (!iter)return NULL ;
kernel/trace/trace.c +4 -2
@@ -4077,7 +4077,8 @@ __tracing_open(struct inode *inode, struct file *file, bool snapshot)if (iter->cpu_file ==RING_BUFFER_ALL_CPUS ) {for_each_tracing_cpu (cpu) { iter->buffer_iter[cpu] = -ring_buffer_read_prepare (iter->trace_buffer->buffer, cpu); +ring_buffer_read_prepare (iter->trace_buffer->buffer, + cpu,GFP_KERNEL ); }ring_buffer_read_prepare_sync ();for_each_tracing_cpu (cpu) {
@@ -4087,7 +4088,8 @@ __tracing_open(struct inode *inode, struct file *file, bool snapshot) }else { cpu = iter->cpu_file; iter->buffer_iter[cpu] = -ring_buffer_read_prepare (iter->trace_buffer->buffer, cpu); +ring_buffer_read_prepare (iter->trace_buffer->buffer, + cpu,GFP_KERNEL );ring_buffer_read_prepare_sync ();ring_buffer_read_start (iter->buffer_iter[cpu]);tracing_iter_reset (iter, cpu);
kernel/trace/trace_kdb.c +4 -2
@@ -51,14 +51,16 @@ static void ftrace_dump_buf(int skip_lines, long cpu_file)if (cpu_file ==RING_BUFFER_ALL_CPUS ) {for_each_tracing_cpu (cpu) { iter.buffer_iter[cpu] = -ring_buffer_read_prepare (iter.trace_buffer->buffer, cpu); +ring_buffer_read_prepare (iter.trace_buffer->buffer, + cpu,GFP_ATOMIC );ring_buffer_read_start (iter.buffer_iter[cpu]);tracing_iter_reset (&iter, cpu); } }else { iter.cpu_file = cpu_file; iter.buffer_iter[cpu_file] = -ring_buffer_read_prepare (iter.trace_buffer->buffer, cpu_file); +ring_buffer_read_prepare (iter.trace_buffer->buffer, + cpu_file,GFP_ATOMIC );ring_buffer_read_start (iter.buffer_iter[cpu_file]);tracing_iter_reset (&iter, cpu_file); }
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 4/8 tracing/probe: Check maxactive error cases
In reply to Steven RostedtFrom: Masami Hiramatsu <[email protected]>
Check maxactive on kprobe error case, because maxactive is only for kretprobe, not for kprobe. Also, maxactive should not be 0, it should be at least 1.
--- kernel/trace/trace_kprobe.c | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-)
kernel/trace/trace_kprobe.c +7 -3
@@ -624,7 +624,11 @@ static int trace_kprobe_create(int argc, const char *argv[])if (event) event++; -if (is_return &&isdigit (argv[0 ][1 ])) { +if (isdigit (argv[0 ][1 ])) { +if (!is_return) { +pr_info ("Maxactive is not for kprobe" ); +return -EINVAL ; + }if (event) len = event - &argv[0 ][1 ] -1 ;else
@@ -634,8 +638,8 @@ static int trace_kprobe_create(int argc, const char *argv[])memcpy (buf, &argv[0 ][1 ], len); buf[len] ='\0' ; ret =kstrtouint (buf,0 , &maxactive); -if (ret) { -pr_info ("Failed to parse maxactive.\n" ); +if (ret || !maxactive) { +pr_info ("Invalid maxactive number\n" );return ret; }/* kretprobes instances are iterated over via a list. The
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 5/8 tracing/probe: Check event name length correctly
In reply to Steven RostedtFrom: Masami Hiramatsu <[email protected]>
Ensure given name of event is not too long when parsing it, and fix to update event name offset correctly when the group name is given. For example, this makes probe event to check the "p:foo/" error case correctly.
--- kernel/trace/trace_probe.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-)
kernel/trace/trace_probe.c +7 -1
@@ -159,6 +159,7 @@ int traceprobe_parse_event_name(const char **pevent, const char **pgroup, char *buf) {const char *slash, *event = *pevent; +int len; slash =strchr (event,'/' );if (slash) {
@@ -173,10 +174,15 @@ int traceprobe_parse_event_name(const char **pevent, const char **pgroup,strlcpy (buf, event, slash - event +1 ); *pgroup = buf; *pevent = slash +1 ; + event = *pevent; } -if (strlen (event) ==0 ) { + len =strlen (event); +if (len ==0 ) {pr_info ("Event name is not specified\n" );return -EINVAL ; + }else if (len >MAX_EVENT_NAME_LEN ) { +pr_info ("Event name is too long\n" ); +return -E2BIG ; }return 0 ; }
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 6/8 tracing/probe: Check the size of argument name and body
In reply to Steven RostedtFrom: Masami Hiramatsu <[email protected]>
Check the size of argument name and expression is not 0 and smaller than maximum length.
--- kernel/trace/trace_probe.c | 2 ++ kernel/trace/trace_probe.h | 1 + 2 files changed, 3 insertions(+)
kernel/trace/trace_probe.c +2 -0
@@ -554,6 +554,8 @@ int traceprobe_parse_probe_arg(struct trace_probe *tp, int i, char *arg, body =strchr (arg,'=' );if (body) { +if (body - arg >MAX_ARG_NAME_LEN || body == arg) +return -EINVAL ; parg->name =kmemdup_nul (arg, body - arg,GFP_KERNEL ); body++; }else {
kernel/trace/trace_probe.h +1 -0
@@ -32,6 +32,7 @@#define MAX_TRACE_ARGS 128#define MAX_ARGSTR_LEN 63#define MAX_ARRAY_LEN 64 +#define MAX_ARG_NAME_LEN 32#define MAX_STRING_SIZE PATH_MAX/* Reserved field names */
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 7/8 tracing/probe: Check event/group naming rule at parsing
In reply to Steven RostedtFrom: Masami Hiramatsu <[email protected]>
Check event and group naming rule at parsing it instead of allocating probes.
--- kernel/trace/trace_kprobe.c | 7 +------ kernel/trace/trace_probe.c | 8 ++++++++ kernel/trace/trace_uprobe.c | 5 +---- 3 files changed, 10 insertions(+), 10 deletions(-)
kernel/trace/trace_kprobe.c +1 -6
@@ -221,7 +221,7 @@ static struct trace_kprobe *alloc_trace_kprobe(const char *group, tk->rp.maxactive = maxactive; -if (!event || !is_good_name (event)) { +if (!event || !group) { ret = -EINVAL ; goto error; }
@@ -231,11 +231,6 @@ static struct trace_kprobe *alloc_trace_kprobe(const char *group,if (!tk->tp.call.name) goto error; -if (!group || !is_good_name (group)) { - ret = -EINVAL ; - goto error; - } - tk->tp.class.system =kstrdup (group,GFP_KERNEL );if (!tk->tp.class.system) goto error;
kernel/trace/trace_probe.c +8 -0
@@ -172,6 +172,10 @@ int traceprobe_parse_event_name(const char **pevent, const char **pgroup,return -E2BIG ; }strlcpy (buf, event, slash - event +1 ); +if (!is_good_name (buf)) { +pr_info ("Group name must follow the same rules as C identifiers\n" ); +return -EINVAL ; + } *pgroup = buf; *pevent = slash +1 ; event = *pevent;
@@ -184,6 +188,10 @@ int traceprobe_parse_event_name(const char **pevent, const char **pgroup,pr_info ("Event name is too long\n" );return -E2BIG ; } +if (!is_good_name (event)) { +pr_info ("Event name must follow the same rules as C identifiers\n" ); +return -EINVAL ; + }return 0 ; }
kernel/trace/trace_uprobe.c +1 -4
@@ -266,10 +266,7 @@ alloc_trace_uprobe(const char *group, const char *event, int nargs, bool is_ret) {struct trace_uprobe *tu; -if (!event || !is_good_name (event)) -return ERR_PTR (-EINVAL ); - -if (!group || !is_good_name (group)) +if (!event || !group)return ERR_PTR (-EINVAL ); tu =kzalloc (SIZEOF_TRACE_UPROBE (nargs),GFP_KERNEL );
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 8/8 tracing/probe: Verify alloc_trace_*probe() result
In reply to Steven RostedtFrom: Masami Hiramatsu <[email protected]>
Since alloc_trace_*probe() returns -EINVAL only if !event && !group, it should not happen in trace_*probe_create(). If we catch that case there is a bug. So use WARN_ON_ONCE() instead of pr_info().
--- kernel/trace/trace_kprobe.c | 4 ++-- kernel/trace/trace_uprobe.c | 3 ++- 2 files changed, 4 insertions(+), 3 deletions(-)
kernel/trace/trace_kprobe.c +2 -2
@@ -693,9 +693,9 @@ static int trace_kprobe_create(int argc, const char *argv[]) tk =alloc_trace_kprobe (group, event, addr, symbol, offset, maxactive, argc, is_return);if (IS_ERR (tk)) { -pr_info ("Failed to allocate trace_probe.(%d)\n" , - (int )PTR_ERR (tk)); ret =PTR_ERR (tk); +/* This must return -ENOMEM otherwise there is a bug */ +WARN_ON_ONCE (ret != -ENOMEM ); goto out; }
kernel/trace/trace_uprobe.c +2 -1
@@ -514,8 +514,9 @@ static int trace_uprobe_create(int argc, const char **argv) tu =alloc_trace_uprobe (group, event, argc, is_return);if (IS_ERR (tu)) { -pr_info ("Failed to allocate trace_uprobe.(%d)\n" , (int )PTR_ERR (tu)); ret =PTR_ERR (tu); +/* This must return -ENOMEM otherwise there is a bug */ +WARN_ON_ONCE (ret != -ENOMEM ); goto fail_address_parse; } tu->offset = offset;
Signature · 1 line
2.20.1