tracing: Some more last minute changes and fixes
Subsystems (7)
Steven Rostedt
maintainercover tracing: Some more last minute changes and fixes
git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace.git
for-next
Head SHA1: b9416997603ef7e17d4de10b6408f19da2feb72c
Anders Roxell (1):
tracing: Allow RCU to run between postponed startup tests
Colin Ian King (1):
tracing: Fix white space issues in parse_pred() function
Elazar Leibovich (1):
tracing: Fix partial reading of trace event's id file
Gustavo A. R. Silva (1):
tracing: Replace kzalloc with kcalloc
Josh Poimboeuf (1):
x86_64: Add gap to int3 to allow for call emulation
Masami Hiramatsu (3):
tracing: uprobes: Re-enable $comm support for uprobe events
tracing: probeevent: Do not accumulate on ret variable
tracing: probeevent: Fix to make the type of $comm string
Peter Zijlstra (2):
x86_64: Allow breakpoints to emulate call instructions ftrace/x86_64: Emulate call function while updating in breakpoint handler
Rasmus Villemoes (1):
tracing: Eliminate const char[] auto variables
Srivatsa S. Bhat (VMware) (1):
tracing: Fix documentation about disabling options using trace_options
Yangtao Li (1):
ring-buffer: Fix mispelling of Calculate
----
arch/x86/entry/entry_64.S | 18 ++++++++++++-- arch/x86/include/asm/text-patching.h | 28 +++++++++++++++++++++ arch/x86/kernel/ftrace.c | 32 ++++++++++++++++++++---- kernel/trace/ftrace.c | 2 +- kernel/trace/ring_buffer_benchmark.c | 2 +- kernel/trace/trace.c | 40 ++++++++++++++---------------- kernel/trace/trace_events.c | 3 --- kernel/trace/trace_events_filter.c | 48 ++++++++++++++++++------------------ kernel/trace/trace_probe.c | 17 +++++++------ kernel/trace/trace_probe.h | 1 + kernel/trace/trace_probe_tmpl.h | 2 +- kernel/trace/trace_uprobe.c | 13 ++++++++-- 12 files changed, 137 insertions(+), 69 deletions(-)
Steven Rostedt
maintainerPATCH 1/13 x86_64: Add gap to int3 to allow for call emulation
From: Josh Poimboeuf <[email protected]>
To allow an int3 handler to emulate a call instruction, it must be able to push a return address onto the stack. Add a gap to the stack to allow the int3 handler to push the return address and change the return from int3 to jump straight to the emulated called function target.
[
Note, this is needed to allow Live Kernel Patching to not miss calling a patched function when tracing is enabled. -- Steven Rostedt
]
--- arch/x86/entry/entry_64.S | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-)
arch/x86/entry/entry_64.S +16 -2
@@ -879,7 +879,7 @@ apicinterrupt IRQ_WORK_VECTOR irq_work_interrupt smp_irq_work_interrupt * @paranoid == 2 is special: the stub will never switch stacks. This is for * #DF: if the thread stack is somehow unusable, we'll still get a useful OOPS. */ -.macro idtentry sym do_sym has_error_code:req paranoid=0 shift_ist=-1 +.macro idtentry sym do_sym has_error_code:req paranoid=0 shift_ist=-1 create_gap=0 ENTRY(\sym) UNWIND_HINT_IRET_REGS offset=\has_error_code*8
@@ -899,6 +899,20 @@ ENTRY(\sym) jnz .Lfrom_usermode_switch_stack_\@ .endif + .if \create_gap == 1 + /* + * If coming from kernel space, create a 6-word gap to allow the + * int3 handler to emulate a call instruction. + */ + testb $3, CS-ORIG_RAX(%rsp) + jnz .Lfrom_usermode_no_gap_\@ + .rept 6 + pushq 5*8(%rsp) + .endr + UNWIND_HINT_IRET_REGS offset=8 +.Lfrom_usermode_no_gap_\@: + .endif + .if \paranoid call paranoid_entry .else
@@ -1130,7 +1144,7 @@ apicinterrupt3 HYPERV_STIMER0_VECTOR \ #endif /* CONFIG_HYPERV */ idtentry debug do_debug has_error_code=0 paranoid=1 shift_ist=DEBUG_STACK -idtentry int3 do_int3 has_error_code=0 +idtentry int3 do_int3 has_error_code=0 create_gap=1 idtentry stack_segment do_stack_segment has_error_code=1 #ifdef CONFIG_XEN_PV
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 2/13 x86_64: Allow breakpoints to emulate call instructions
In reply to Steven RostedtFrom: Peter Zijlstra <[email protected]>
In order to allow breakpoints to emulate call instructions, they need to push the return address onto the stack. The x86_64 int3 handler adds a small gap to allow the stack to grow some. Use this gap to add the return address to be able to emulate a call instruction at the breakpoint location.
These helper functions are added:
int3_emulate_jmp(): changes the location of the regs->ip to return there.
(The next two are only for x86_64)
int3_emulate_push(): to push the address onto the gap in the stack int3_emulate_call(): push the return address and change regs->ip
--- arch/x86/include/asm/text-patching.h | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+)
arch/x86/include/asm/text-patching.h +28 -0
@@ -39,4 +39,32 @@ extern int poke_int3_handler(struct pt_regs *regs);extern void *text_poke_bp (void *addr,const void *opcode,size_t len,void *handler);extern int after_bootmem; +static inline void int3_emulate_jmp (struct pt_regs *regs,unsigned long ip) +{ + regs->ip = ip; +} + +#define INT3_INSN_SIZE 1 +#define CALL_INSN_SIZE 5 + +#ifdef CONFIG_X86_64 +static inline void int3_emulate_push (struct pt_regs *regs,unsigned long val) +{ +/* +* The int3 handler in entry_64.S adds a gap between the +* stack where the break point happened, and the saving of +* pt_regs. We can extend the original stack because of +* this gap. See the idtentry macro's create_gap option. +*/ + regs->sp -=sizeof (unsigned long ); + *(unsigned long *)regs->sp = val; +} + +static inline void int3_emulate_call (struct pt_regs *regs,unsigned long func) +{ +int3_emulate_push (regs, regs->ip -INT3_INSN_SIZE +CALL_INSN_SIZE ); +int3_emulate_jmp (regs, func); +} +#endif +#endif /* _ASM_X86_TEXT_PATCHING_H */
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 3/13 ftrace/x86_64: Emulate call function while updating in breakpoint handler
In reply to Steven RostedtFrom: Peter Zijlstra <peterz at infradead.org>
Nicolai Stange discovered[1] that if live kernel patching is enabled, and the function tracer started tracing the same function that was patched, the conversion of the fentry call site during the translation of going from calling the live kernel patch trampoline to the iterator trampoline, would have as slight window where it didn't call anything.
As live kernel patching depends on ftrace to always call its code (to prevent the function being traced from being called, as it will redirect it). This small window would allow the old buggy function to be called, and this can cause undesirable results.
Nicolai submitted new patches[2] but these were controversial. As this is similar to the static call emulation issues that came up a while ago[3]. But after some debate[4][5] adding a gap in the stack when entering the breakpoint handler allows for pushing the return address onto the stack to easily emulate a call.
[1] http://lkml.kernel.org/r/20180726104029.7736-1-nstange at suse.de
[2] http://lkml.kernel.org/r/20190427100639.15074-1-nstange at suse.de
[3] http://lkml.kernel.org/r/3cf04e113d71c9f8e4be95fb84a510f085aa4afa.1541711457.git.jpoimboe at redhat.com
[4] http://lkml.kernel.org/r/CAHk-=wh5OpheSU8Em_Q3Hg8qw_JtoijxOdPtHru6d+5K8TWM=A at mail.gmail.com
[5] http://lkml.kernel.org/r/CAHk-=wjvQxY4DvPrJ6haPgAa6b906h=MwZXO6G8OtiTGe=N7_w at mail.gmail.com
[
Live kernel patching is not implemented on x86_32, thus the emulate calls are only for x86_64.
]
--- arch/x86/kernel/ftrace.c | 32 +++++++++++++++++++++++++++----- 1 file changed, 27 insertions(+), 5 deletions(-)
arch/x86/kernel/ftrace.c +27 -5
@@ -29,6 +29,7 @@#include <asm/kprobes.h> #include <asm/ftrace.h> #include <asm/nops.h> +#include <asm/text-patching.h> #ifdef CONFIG_DYNAMIC_FTRACE
@@ -231,6 +232,7 @@ int ftrace_modify_call(struct dyn_ftrace *rec, unsigned long old_addr, }static unsigned long ftrace_update_func; +static unsigned long ftrace_update_func_call;static int update_ftrace_func (unsigned long ip,void *new) {
@@ -259,6 +261,8 @@ int ftrace_update_ftrace_func(ftrace_func_t func)unsigned char *new;int ret; + ftrace_update_func_call = (unsigned long )func; + new =ftrace_call_replace (ip, (unsigned long )func); ret =update_ftrace_func (ip, new);
@@ -294,13 +298,28 @@ int ftrace_int3_handler(struct pt_regs *regs)if (WARN_ON_ONCE (!regs))return 0 ; - ip = regs->ip -1 ; -if (!ftrace_location (ip) && !is_ftrace_caller (ip)) -return 0 ; + ip = regs->ip -INT3_INSN_SIZE ; - regs->ip +=MCOUNT_INSN_SIZE -1 ; +#ifdef CONFIG_X86_64 +if (ftrace_location (ip)) { +int3_emulate_call (regs, (unsigned long )ftrace_regs_caller); +return 1 ; + }else if (is_ftrace_caller (ip)) { +if (!ftrace_update_func_call) { +int3_emulate_jmp (regs, ip +CALL_INSN_SIZE ); +return 1 ; + } +int3_emulate_call (regs, ftrace_update_func_call); +return 1 ; + } +#else +if (ftrace_location (ip) ||is_ftrace_caller (ip)) { +int3_emulate_jmp (regs, ip +CALL_INSN_SIZE ); +return 1 ; + } +#endif -return 1 ; +return 0 ; }NOKPROBE_SYMBOL (ftrace_int3_handler);
@@ -859,6 +878,8 @@ void arch_ftrace_update_trampoline(struct ftrace_ops *ops) func =ftrace_ops_get_func (ops); + ftrace_update_func_call = (unsigned long )func; +/* Do a safe modify in case the trampoline is executing */ new =ftrace_call_replace (ip, (unsigned long )func); ret =update_ftrace_func (ip, new);
@@ -960,6 +981,7 @@ static int ftrace_mod_jmp(unsigned long ip, void *func) {unsigned char *new; + ftrace_update_func_call =0UL ; new =ftrace_jmp_replace (ip, (unsigned long )func);return update_ftrace_func (ip, new);
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 4/13 tracing: uprobes: Re-enable $comm support for uprobe events
In reply to Steven RostedtFrom: Masami Hiramatsu <[email protected]>
Since commit 533059281ee5 ("tracing: probeevent: Introduce new argument fetching code") dropped the $comm support from uprobe events, this re-enables it.
For $comm support, uses strlcpy() instead of strncpy_from_user() to copy current task's comm. Because it is in the kernel space, strncpy_from_user() always fails to copy the comm. This also uses strlen() instead of strnlen_user() to measure the length of the comm.
Note that this uses -ECOMM as a token value to fetch the comm string. If the user-space pointer points -ECOMM, it will be translated to task->comm.
--- kernel/trace/trace_probe.h | 1 + kernel/trace/trace_uprobe.c | 13 +++++++++++-- 2 files changed, 12 insertions(+), 2 deletions(-)
kernel/trace/trace_probe.h +1 -0
@@ -124,6 +124,7 @@ struct fetch_insn {/* fetch + deref*N + store + mod + end <= 16, this allows N=12, enough */ #define FETCH_INSN_MAX 16 +#define FETCH_TOKEN_COMM (-ECOMM)/* Fetch type information table */ struct fetch_type {
kernel/trace/trace_uprobe.c +11 -2
@@ -156,7 +156,10 @@ fetch_store_string(unsigned long addr, void *dest, void *base)if (unlikely (!maxlen))return -ENOMEM ; - ret =strncpy_from_user (dst, src, maxlen); +if (addr ==FETCH_TOKEN_COMM ) + ret =strlcpy (dst, current->comm, maxlen); +else + ret =strncpy_from_user (dst, src, maxlen);if (ret >=0 ) {if (ret == maxlen) dst[ret -1 ] ='\0' ;
@@ -180,7 +183,10 @@ fetch_store_strlen(unsigned long addr)int len;void __user *vaddr = (void __force __user *) addr; - len =strnlen_user (vaddr,MAX_STRING_SIZE ); +if (addr ==FETCH_TOKEN_COMM ) + len =strlen (current->comm) +1 ; +else + len =strnlen_user (vaddr,MAX_STRING_SIZE );return (len >MAX_STRING_SIZE ) ?0 : len; }
@@ -220,6 +226,9 @@ process_fetch_insn(struct fetch_insn *code, struct pt_regs *regs, void *dest,case FETCH_OP_IMM : val = code->immediate;break ; +case FETCH_OP_COMM : + val =FETCH_TOKEN_COMM ; +break ;case FETCH_OP_FOFFS : val =translate_user_vaddr (code->immediate);break ;
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 5/13 tracing: probeevent: Do not accumulate on ret variable
In reply to Steven RostedtFrom: Masami Hiramatsu <[email protected]>
Do not accumulate strlen result on "ret" local variable, because it is accumulated on "total" local variable for array case.
--- kernel/trace/trace_probe_tmpl.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/trace/trace_probe_tmpl.h +1 -1
@@ -88,7 +88,7 @@ process_fetch_insn_bottom(struct fetch_insn *code, unsigned long val,/* 3rd stage: store value to buffer */ if (unlikely (!dest)) {if (code->op ==FETCH_OP_ST_STRING ) { - ret +=fetch_store_strlen (val + code->offset); + ret =fetch_store_strlen (val + code->offset); code++; goto array; }else
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 6/13 tracing: probeevent: Fix to make the type of $comm string
In reply to Steven RostedtFrom: Masami Hiramatsu <[email protected]>
Fix to make the type of $comm "string". If we set the other type to $comm argument, it shows meaningless value or wrong data. Currently probe events allow us to set string array type (e.g. ":string[2]"), or other digit types like x8 on $comm. But since clearly $comm is just a string data, it should not be fetched by other types including array.
--- kernel/trace/trace_probe.c | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-)
kernel/trace/trace_probe.c +7 -6
@@ -533,13 +533,14 @@ static int traceprobe_parse_probe_arg_body(char *arg, ssize_t *size, } } } -/* -* The default type of $comm should be "string", and it can't be -* dereferenced. -*/ -if (!t &&strcmp (arg,"$comm" ) ==0 ) + +/* Since $comm can not be dereferred, we can find $comm by strcmp */ +if (strcmp (arg,"$comm" ) ==0 ) { +/* The type of $comm must be "string", and not an array. */ +if (parg->count || (t &&strcmp (t,"string" ))) +return -EINVAL ; parg->type =find_fetch_type ("string" ); -else + }else parg->type =find_fetch_type (t);if (!parg->type) {trace_probe_log_err (offset + (t ? (t - arg) :0 ),BAD_TYPE );
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 7/13 ring-buffer: Fix mispelling of Calculate
In reply to Steven RostedtFrom: Yangtao Li <[email protected]>
It's not "Caculate".
--- kernel/trace/ring_buffer_benchmark.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/trace/ring_buffer_benchmark.c +1 -1
@@ -362,7 +362,7 @@ static void ring_buffer_producer(void) hit--;/* make it non zero */ } -/* Caculate the average time in nanosecs */ +/* Calculate the average time in nanosecs */ avg =NSEC_PER_MSEC / (hit + missed);trace_printk ("%ld ns per entry\n" , avg); }
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 8/13 tracing: Eliminate const char[] auto variables
In reply to Steven RostedtFrom: Rasmus Villemoes <[email protected]>
Automatic const char[] variables cause unnecessary code generation. For example, the this_mod variable leads to
3f04: 48 b8 5f 5f 74 68 69 73 5f 6d movabs $0x6d5f736968745f5f,%rax # __this_m
3f0e: 4c 8d 44 24 02 lea 0x2(%rsp),%r8
3f13: 48 8d 7c 24 10 lea 0x10(%rsp),%rdi
3f18: 48 89 44 24 02 mov %rax,0x2(%rsp)
3f1d: 4c 89 e9 mov %r13,%rcx
3f20: b8 65 00 00 00 mov $0x65,%eax # e
3f25: 48 c7 c2 00 00 00 00 mov $0x0,%rdx
3f28: R_X86_64_32S .rodata.str1.1+0x18d
3f2c: be 48 00 00 00 mov $0x48,%esi
3f31: c7 44 24 0a 6f 64 75 6c movl $0x6c75646f,0xa(%rsp) # odul
3f39: 66 89 44 24 0e mov %ax,0xe(%rsp)i.e., the string gets built on the stack at runtime. Similar code can be found for the other instances I'm replacing here. Putting the string in .rodata reduces the combined .text+.rodata size and saves time and stack space at runtime.
The simplest fix, and what I've done for the this_mod case, is to just make the variable static.
However, for the "<faulted>" case where the same string is used twice, that prevents the linker from merging those two literals, so instead use a macro - that also keeps the two instances automatically in sync (instead of only the compile-time strlen expression).
Finally, for the two runs of spaces, it turns out that the "build these strings on the stack" is not the worst part of what gcc does - it turns print_func_help_header_irq() into "if (tgid) { /* print_event_info + five seq_printf calls */ } else { /* print event_info + another five seq_printf */}". Taking inspiration from a suggestion from Al Viro, use %.*s to make snprintf either stop after the first two spaces or print the whole string. As a bonus, the seq_printfs now fit on single lines (at least, they are not longer than the existing ones in the function just above), making it easier to see that the ascii art lines up.
x86-64 defconfig + CONFIG_FUNCTION_TRACER:
$ scripts/stackdelta /tmp/stackusage.{0,1}
./kernel/trace/ftrace.c ftrace_mod_callback 152 136 -16
./kernel/trace/trace.c trace_default_header 56 32 -24
./kernel/trace/trace.c tracing_mark_raw_write 96 72 -24
./kernel/trace/trace.c tracing_mark_write 104 80 -24bloat-o-meter
add/remove: 1/0 grow/shrink: 0/4 up/down: 14/-375 (-361)
Function old new delta
this_mod - 14 +14 ftrace_mod_callback 577 542 -35 tracing_mark_raw_write 444 374 -70 tracing_mark_write 616 540 -76
trace_default_header 600 406 -194
--- kernel/trace/ftrace.c | 2 +- kernel/trace/trace.c | 34 +++++++++++++--------------------- 2 files changed, 14 insertions(+), 22 deletions(-)
kernel/trace/ftrace.c +1 -1
@@ -3875,7 +3875,7 @@ static int ftrace_hash_move_and_update_ops(struct ftrace_ops *ops,static bool module_exists (const char *module) {/* All modules have the symbol __this_module */ -const char this_mod[] ="__this_module" ; +static const char this_mod[] ="__this_module" ;char modname[MAX_PARAM_PREFIX_LEN +sizeof (this_mod) +2 ];unsigned long val;int n;
kernel/trace/trace.c +13 -21
@@ -3593,25 +3593,18 @@ static void print_func_help_header_irq(struct trace_buffer *buf, struct seq_file unsigned int flags) {bool tgid = flags &TRACE_ITER_RECORD_TGID ; -const char tgid_space[] =" " ; -const char space[] =" " ; +const char *space =" " ; +int prec = tgid ?10 :2 ;print_event_info (buf, m); -seq_printf (m,"# %s _-----=> irqs-off\n" , - tgid ? tgid_space : space); -seq_printf (m,"# %s / _----=> need-resched\n" , - tgid ? tgid_space : space); -seq_printf (m,"# %s| / _---=> hardirq/softirq\n" , - tgid ? tgid_space : space); -seq_printf (m,"# %s|| / _--=> preempt-depth\n" , - tgid ? tgid_space : space); -seq_printf (m,"# %s||| / delay\n" , - tgid ? tgid_space : space); -seq_printf (m,"# TASK-PID %sCPU# |||| TIMESTAMP FUNCTION\n" , - tgid ?" TGID " : space); -seq_printf (m,"# | | %s | |||| | |\n" , - tgid ?" | " : space); +seq_printf (m,"# %.*s _-----=> irqs-off\n" , prec, space); +seq_printf (m,"# %.*s / _----=> need-resched\n" , prec, space); +seq_printf (m,"# %.*s| / _---=> hardirq/softirq\n" , prec, space); +seq_printf (m,"# %.*s|| / _--=> preempt-depth\n" , prec, space); +seq_printf (m,"# %.*s||| / delay\n" , prec, space); +seq_printf (m,"# TASK-PID %.*sCPU# |||| TIMESTAMP FUNCTION\n" , prec," TGID " ); +seq_printf (m,"# | | %.*s | |||| | |\n" , prec," | " ); }void
@@ -6342,13 +6335,13 @@ tracing_mark_write(struct file *filp, const char __user *ubuf,struct ring_buffer *buffer;struct print_entry *entry;unsigned long irq_flags; -const char faulted[] ="<faulted>" ;ssize_t written;int size;int len;/* Used in tracing_mark_raw_write() as well */ -#define FAULTED_SIZE (sizeof(faulted) - 1)/* '\0' is already accounted for */ +#define FAULTED_STR "<faulted>" +#define FAULTED_SIZE (sizeof(FAULTED_STR) - 1)/* '\0' is already accounted for */ if (tracing_disabled)return -EINVAL ;
@@ -6380,7 +6373,7 @@ tracing_mark_write(struct file *filp, const char __user *ubuf, len =__copy_from_user_inatomic (&entry->buf, ubuf, cnt);if (len) { -memcpy (&entry->buf, faulted,FAULTED_SIZE ); +memcpy (&entry->buf,FAULTED_STR ,FAULTED_SIZE ); cnt =FAULTED_SIZE ; written = -EFAULT ; }else
@@ -6421,7 +6414,6 @@ tracing_mark_raw_write(struct file *filp, const char __user *ubuf,struct ring_buffer_event *event;struct ring_buffer *buffer;struct raw_data_entry *entry; -const char faulted[] ="<faulted>" ;unsigned long irq_flags;ssize_t written;int size;
@@ -6461,7 +6453,7 @@ tracing_mark_raw_write(struct file *filp, const char __user *ubuf, len =__copy_from_user_inatomic (&entry->id, ubuf, cnt);if (len) { entry->id =-1 ; -memcpy (&entry->buf, faulted,FAULTED_SIZE ); +memcpy (&entry->buf,FAULTED_STR ,FAULTED_SIZE ); written = -EFAULT ; }else written = cnt;
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 9/13 tracing: Fix white space issues in parse_pred() function
In reply to Steven RostedtFrom: Colin Ian King <[email protected]>
Trivial fix to clean up an indentation issue, a whole chunk of code has an extra space in the indentation.
--- kernel/trace/trace_events_filter.c | 48 +++++++++++++++--------------- 1 file changed, 24 insertions(+), 24 deletions(-)
kernel/trace/trace_events_filter.c +24 -24
@@ -1222,30 +1222,30 @@ static int parse_pred(const char *str, void *data,* (perf doesn't use it) and grab everything. */ if (strcmp (field->name,"ip" ) !=0 ) { -parse_error (pe,FILT_ERR_IP_FIELD_ONLY , pos + i); - goto err_free; - } - pred->fn = filter_pred_none; - -/* -* Quotes are not required, but if they exist then we need -* to read them till we hit a matching one. -*/ -if (str[i] =='\'' || str[i] =='"' ) - q = str[i]; -else - q =0 ; - -for (i++; str[i]; i++) { -if (q && str[i] == q) -break ; -if (!q && (str[i] ==')' || str[i] =='&' || - str[i] =='|' )) -break ; - } -/* Skip quotes */ -if (q) - s++; +parse_error (pe,FILT_ERR_IP_FIELD_ONLY , pos + i); + goto err_free; + } + pred->fn = filter_pred_none; + +/* +* Quotes are not required, but if they exist then we need +* to read them till we hit a matching one. +*/ +if (str[i] =='\'' || str[i] =='"' ) + q = str[i]; +else + q =0 ; + +for (i++; str[i]; i++) { +if (q && str[i] == q) +break ; +if (!q && (str[i] ==')' || str[i] =='&' || + str[i] =='|' )) +break ; + } +/* Skip quotes */ +if (q) + s++; len = i - s;if (len >=MAX_FILTER_STR_VAL ) {parse_error (pe,FILT_ERR_OPERAND_TOO_LONG , pos + i);
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 10/13 tracing: Allow RCU to run between postponed startup tests
In reply to Steven RostedtFrom: Anders Roxell <[email protected]>
When building a allmodconfig kernel for arm64 and boot that in qemu, CONFIG_FTRACE_STARTUP_TEST gets enabled and that takes time so the watchdog expires and prints out a message like this:
'watchdog: BUG: soft lockup - CPU#0 stuck for 22s! [swapper/0:1]' Depending on what the what test gets called from init_trace_selftests() it stays minutes in the loop.
Rework so that function cond_resched() gets called in the init_trace_selftests loop.
--- kernel/trace/trace.c | 4 ++++ 1 file changed, 4 insertions(+)
kernel/trace/trace.c +4 -0
@@ -1722,6 +1722,10 @@ static __init int init_trace_selftests(void)pr_info ("Running postponed tracer tests:\n" );list_for_each_entry_safe (p, n, &postponed_selftests, list) { +/* This loop can take minutes when sanitizers are enabled, so +* lets make sure we allow RCU processing. +*/ +cond_resched (); ret =run_tracer_selftest (p->type);/* If the test fails, then warn and remove from available_tracers */ if (ret <0 ) {
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 11/13 tracing: Fix partial reading of trace events id file
In reply to Steven RostedtFrom: Elazar Leibovich <[email protected]>
When reading only part of the id file, the ppos isn't tracked correctly. This is taken care by simple_read_from_buffer.
Reading a single byte, and then the next byte would result EOF.
While this seems like not a big deal, this breaks abstractions that reads information from files unbuffered. See for example
https://github.com/golang/go/issues/29399
This code was mentioned as problematic in commit cd458ba9d5a5
("tracing: Do not (ab)use trace_seq in event_id_read()")
An example C code that show this bug is:
#include <stdio.h>
#include <stdint.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
int main(int argc, char **argv) {
if (argc < 2)
return 1;
int fd = open(argv[1], O_RDONLY);
char c;
read(fd, &c, 1);
printf("First %c\n", c);
read(fd, &c, 1);
printf("Second %c\n", c);
}Then run with, e.g.
sudo ./a.out /sys/kernel/debug/tracing/events/tcp/tcp_set_state/id
You'll notice you're getting the first character twice, instead of the first two characters in the id file.
--- kernel/trace/trace_events.c | 3 --- 1 file changed, 3 deletions(-)
kernel/trace/trace_events.c +0 -3
@@ -1319,9 +1319,6 @@ event_id_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)char buf[32 ];int len; -if (*ppos) -return 0 ; -if (unlikely (!id))return -ENODEV ;
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 12/13 tracing: Replace kzalloc with kcalloc
In reply to Steven RostedtFrom: "Gustavo A. R. Silva" <[email protected]>
Replace kzalloc() function with its 2-factor argument form, kcalloc().
This patch replaces cases of:
kzalloc(a * b, gfp)
with:
kcalloc(a, b, gfp)
This code was detected with the help of Coccinelle.
--- kernel/trace/trace_probe.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
kernel/trace/trace_probe.c +2 -2
@@ -558,7 +558,7 @@ static int traceprobe_parse_probe_arg_body(char *arg, ssize_t *size, parg->count); } - code = tmp =kzalloc (sizeof (*code) *FETCH_INSN_MAX ,GFP_KERNEL ); + code = tmp =kcalloc (FETCH_INSN_MAX ,sizeof (*code),GFP_KERNEL );if (!code)return -ENOMEM ; code[FETCH_INSN_MAX -1 ].op =FETCH_OP_END ;
@@ -637,7 +637,7 @@ static int traceprobe_parse_probe_arg_body(char *arg, ssize_t *size, code->op =FETCH_OP_END ;/* Shrink down the code buffer */ - parg->code =kzalloc (sizeof (*code) * (code - tmp +1 ),GFP_KERNEL ); + parg->code =kcalloc (code - tmp +1 ,sizeof (*code),GFP_KERNEL );if (!parg->code) ret = -ENOMEM ;else
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 13/13 tracing: Fix documentation about disabling options using trace_options
In reply to Steven RostedtFrom: "Srivatsa S. Bhat (VMware)" <[email protected]>
To disable a tracing option using the trace_options file, the option name needs to be prefixed with 'no', and not suffixed, as the README states. Fix it.
--- kernel/trace/trace.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/trace/trace.c +1 -1
@@ -4755,7 +4755,7 @@ static const char readme_msg[] =" instances\t\t- Make sub-buffers with: mkdir instances/foo\n" "\t\t\t Remove sub-buffer with rmdir\n" " trace_options\t\t- Set format or modify how tracing happens\n" -"\t\t\t Disable an option by adding a suffix 'no' to the\n" +"\t\t\t Disable an option by prefixing 'no' to the\n" "\t\t\t option name\n" " saved_cmdlines_size\t- echo command number in here to store comm-pid list\n" #ifdef CONFIG_DYNAMIC_FTRACE
Signature · 1 line
2.20.1