tracing: Updates for the next merge window
Subsystems (10)
Steven Rostedt
maintainercover tracing: Updates for the next merge window
git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace.git
for-next
Head SHA1: a124692b698b00026a58d89831ceda2331b2e1d0
Cheng Jian (1):
ftrace: Enable trampoline when rec count returns back to one
Masami Hiramatsu (10):
x86/uaccess: Allow access_ok() in irq context if pagefault_disabled
uaccess: Add non-pagefault user-space read functions tracing/probe: Add ustring type for user-space string tracing/probe: Support user-space dereference selftests/ftrace: Add user-memory access syntax testcase
perf-probe: Add user memory access attribute support
uaccess: Add a prototype of non-static __probe_user_read() tracing/kprobe: Cast user-space address correctly
kprobes: Initialize kprobes at postcore_initcall tracing/kprobe: Add kprobe_event= boot parameter
Matthias Kaehlcke (1):
tracing: Use correct function name in trace_filter_add_remove_task() comment
Steven Rostedt (VMware) (4):
ftrace: Make enable and update parameters bool when applicable x86/ftrace: Make enable parameter bool where applicable
tracing: Make a separate config for trace event self tests tracing/kprobe: Do not run kprobe boot tests if kprobe_event is on cmdline
----
Documentation/admin-guide/kernel-parameters.txt | 13 +++ Documentation/trace/kprobetrace.rst | 42 ++++++- Documentation/trace/uprobetracer.rst | 10 +- arch/x86/include/asm/uaccess.h | 4 +- arch/x86/kernel/ftrace.c | 6 +- include/linux/ftrace.h | 4 +- include/linux/uaccess.h | 20 +++- kernel/kprobes.c | 3 +- kernel/trace/Kconfig | 12 +- kernel/trace/ftrace.c | 48 ++++---- kernel/trace/trace.c | 9 +- kernel/trace/trace_events.c | 2 +- kernel/trace/trace_kprobe.c | 112 ++++++++++++++++++- kernel/trace/trace_probe.c | 37 +++++-- kernel/trace/trace_probe.h | 3 + kernel/trace/trace_probe_tmpl.h | 36 +++++- kernel/trace/trace_uprobe.c | 19 ++++ mm/maccess.c | 122 ++++++++++++++++++++- tools/perf/Documentation/perf-probe.txt | 3 +- tools/perf/util/probe-event.c | 11 ++ tools/perf/util/probe-event.h | 2 + tools/perf/util/probe-file.c | 7 ++ tools/perf/util/probe-file.h | 1 + tools/perf/util/probe-finder.c | 19 ++-- .../ftrace/test.d/kprobe/kprobe_args_user.tc | 32 ++++++ 25 files changed, 500 insertions(+), 77 deletions(-) create mode 100644 tools/testing/selftests/ftrace/test.d/kprobe/kprobe_args_user.tc
Steven Rostedt
maintainerPATCH 1/16 ftrace: Make enable and update parameters bool when applicable
From: "Steven Rostedt (VMware)" <[email protected]>
The code modification functions have "enable" and "update" variables that are sometimes "int" but used as "bool". Remove the ambiguity and make them "bool" when they are only used for true or false values.
--- include/linux/ftrace.h | 4 ++-- kernel/trace/ftrace.c | 20 ++++++++++---------- 2 files changed, 12 insertions(+), 12 deletions(-)
include/linux/ftrace.h +2 -2
@@ -427,8 +427,8 @@ struct dyn_ftrace *ftrace_rec_iter_record(struct ftrace_rec_iter *iter); iter = ftrace_rec_iter_next(iter)) -int ftrace_update_record (struct dyn_ftrace *rec,int enable); -int ftrace_test_record (struct dyn_ftrace *rec,int enable); +int ftrace_update_record (struct dyn_ftrace *rec,bool enable); +int ftrace_test_record (struct dyn_ftrace *rec,bool enable);void ftrace_run_stop_machine (int command);unsigned long ftrace_location (unsigned long ip);unsigned long ftrace_location_range (unsigned long start,unsigned long end);
kernel/trace/ftrace.c +10 -10
@@ -1768,7 +1768,7 @@ static bool __ftrace_hash_rec_update(struct ftrace_ops *ops, count++;/* Must match FTRACE_UPDATE_CALLS in ftrace_modify_all_code() */ - update |=ftrace_test_record (rec,1 ) !=FTRACE_UPDATE_IGNORE ; + update |=ftrace_test_record (rec, true) !=FTRACE_UPDATE_IGNORE ;/* Shortcut, if we handled all records, we are done. */ if (!all && count == hash->count)
@@ -2047,7 +2047,7 @@ void ftrace_bug(int failed, struct dyn_ftrace *rec) } } -static int ftrace_check_record (struct dyn_ftrace *rec,int enable,int update) +static int ftrace_check_record (struct dyn_ftrace *rec,bool enable,bool update) {unsigned long flag =0UL ;
@@ -2146,28 +2146,28 @@ static int ftrace_check_record(struct dyn_ftrace *rec, int enable, int update)/** * ftrace_update_record, set a record that now is tracing or not * @rec: the record to update -* @enable: set to 1 if the record is tracing, zero to force disable +* @enable: set to true if the record is tracing, false to force disable * * The records that represent all functions that can be traced need * to be updated when tracing has been enabled. */ -int ftrace_update_record (struct dyn_ftrace *rec,int enable) +int ftrace_update_record (struct dyn_ftrace *rec,bool enable) { -return ftrace_check_record (rec, enable,1 ); +return ftrace_check_record (rec, enable, true); }/** * ftrace_test_record, check if the record has been enabled or not * @rec: the record to test -* @enable: set to 1 to check if enabled, 0 if it is disabled +* @enable: set to true to check if enabled, false if it is disabled * * The arch code may need to test if a record is already set to * tracing to determine how to modify the function code that it * represents. */ -int ftrace_test_record (struct dyn_ftrace *rec,int enable) +int ftrace_test_record (struct dyn_ftrace *rec,bool enable) { -return ftrace_check_record (rec, enable,0 ); +return ftrace_check_record (rec, enable, false); } static struct ftrace_ops *
@@ -2356,7 +2356,7 @@ unsigned long ftrace_get_addr_curr(struct dyn_ftrace *rec) }static int -__ftrace_replace_code (struct dyn_ftrace *rec,int enable) +__ftrace_replace_code (struct dyn_ftrace *rec,bool enable) {unsigned long ftrace_old_addr;unsigned long ftrace_addr;
@@ -2395,7 +2395,7 @@ void __weak ftrace_replace_code(int mod_flags) {struct dyn_ftrace *rec;struct ftrace_page *pg; -int enable = mod_flags &FTRACE_MODIFY_ENABLE_FL ; +bool enable = mod_flags &FTRACE_MODIFY_ENABLE_FL ;int schedulable = mod_flags &FTRACE_MODIFY_MAY_SLEEP_FL ;int failed;
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 2/16 x86/ftrace: Make enable parameter bool where applicable
In reply to Steven RostedtFrom: "Steven Rostedt (VMware)" <[email protected]>
The code modification functions have an "enable" parameter that is an "int" but used as a boolean. Switch its type to "bool" to remove the ambiguity that "int" causes.
--- arch/x86/kernel/ftrace.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
arch/x86/kernel/ftrace.c +3 -3
@@ -370,7 +370,7 @@ static int add_brk_on_nop(struct dyn_ftrace *rec)return add_break (rec->ip, old); } -static int add_breakpoints (struct dyn_ftrace *rec,int enable) +static int add_breakpoints (struct dyn_ftrace *rec,bool enable) {unsigned long ftrace_addr;int ret;
@@ -478,7 +478,7 @@ static int add_update_nop(struct dyn_ftrace *rec)return add_update_code (ip, new); } -static int add_update (struct dyn_ftrace *rec,int enable) +static int add_update (struct dyn_ftrace *rec,bool enable) {unsigned long ftrace_addr;int ret;
@@ -524,7 +524,7 @@ static int finish_update_nop(struct dyn_ftrace *rec)return ftrace_write (ip, new,1 ); } -static int finish_update (struct dyn_ftrace *rec,int enable) +static int finish_update (struct dyn_ftrace *rec,bool enable) {unsigned long ftrace_addr;int ret;
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 3/16 x86/uaccess: Allow access_ok() in irq context if pagefault_disabled
In reply to Steven RostedtFrom: Masami Hiramatsu <[email protected]>
WARN_ON_IN_IRQ() assumes that the access_ok() and following user memory access can sleep. But this assumption is not always correct; when the pagefault is disabled, following memory access will just returns -EFAULT and never sleep.
Add pagefault_disabled() check in WARN_ON_ONCE() so that it can ignore the case we call it with disabling pagefault. For this purpose, this modified pagefault_disabled() as an inline function.
--- arch/x86/include/asm/uaccess.h | 4 +++- include/linux/uaccess.h | 5 ++++- 2 files changed, 7 insertions(+), 2 deletions(-)
arch/x86/include/asm/uaccess.h +3 -1
@@ -66,7 +66,9 @@ static inline bool __chk_range_not_ok(unsigned long addr, unsigned long size, un })#ifdef CONFIG_DEBUG_ATOMIC_SLEEP -# define WARN_ON_IN_IRQ () WARN_ON_ONCE(!in_task()) +static inline bool pagefault_disabled (void ); +# define WARN_ON_IN_IRQ () \ + WARN_ON_ONCE(!in_task() && !pagefault_disabled())#else # define WARN_ON_IN_IRQ ()#endif
include/linux/uaccess.h +4 -1
@@ -203,7 +203,10 @@ static inline void pagefault_enable(void)/* * Is the pagefault handler disabled? If so, user access methods will not sleep. */ -#define pagefault_disabled () (current->pagefault_disabled != 0) +static inline bool pagefault_disabled (void ) +{ +return current->pagefault_disabled !=0 ; +}/* * The pagefault handler is in general disabled by pagefault_disable() or
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 4/16 uaccess: Add non-pagefault user-space read functions
In reply to Steven RostedtFrom: Masami Hiramatsu <[email protected]>
Add probe_user_read(), strncpy_from_unsafe_user() and strnlen_unsafe_user() which allows caller to access user-space in IRQ context.
Current probe_kernel_read() and strncpy_from_unsafe() are not available for user-space memory, because it sets KERNEL_DS while accessing data. On some arch, user address space and kernel address space can be co-exist, but others can not. In that case, setting KERNEL_DS means given address is treated as a kernel address space.
Also strnlen_user() is only available from user context since it can sleep if pagefault is enabled.
To access user-space memory without pagefault, we need these new functions which sets USER_DS while accessing the data.
--- include/linux/uaccess.h | 14 +++++ mm/maccess.c | 122 ++++++++++++++++++++++++++++++++++++++-- 2 files changed, 130 insertions(+), 6 deletions(-)
include/linux/uaccess.h +14 -0
@@ -242,6 +242,17 @@ static inline unsigned long __copy_from_user_inatomic_nocache(void *to,extern long probe_kernel_read (void *dst,const void *src,size_t size);extern long __probe_kernel_read (void *dst,const void *src,size_t size); +/* +* probe_user_read(): safely attempt to read from a location in user space +* @dst: pointer to the buffer that shall take the data +* @src: address to read from +* @size: size of the data chunk +* +* Safely read from address @src to the buffer at @dst. If a kernel fault +* happens, handle that and return -EFAULT. +*/ +extern long probe_user_read (void *dst,const void __user *src,size_t size); +/* * probe_kernel_write(): safely attempt to write to a location * @dst: address to write to
@@ -255,6 +266,9 @@ extern long notrace probe_kernel_write(void *dst, const void *src, size_t size);extern long notrace __probe_kernel_write (void *dst,const void *src,size_t size);extern long strncpy_from_unsafe (char *dst,const void *unsafe_addr,long count); +extern long strncpy_from_unsafe_user (char *dst,const void __user *unsafe_addr, +long count); +extern long strnlen_unsafe_user (const void __user *unsafe_addr,long count);/** * probe_kernel_address(): safely attempt to read from a location
mm/maccess.c +116 -6
149 lines not on this page · raw message
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 5/16 tracing/probe: Add ustring type for user-space string
In reply to Steven RostedtFrom: Masami Hiramatsu <[email protected]>
Add "ustring" type for fetching user-space string from kprobe event. User can specify ustring type at uprobe event, and it is same as "string" for uprobe.
Note that probe-event provides this option but it doesn't choose the correct type automatically since we have not way to decide the address is in user-space or not on some arch (and on some other arch, you can fetch the string by "string" type). So user must carefully check the target code (e.g. if you see __user on the target variable) and use this new type.
--- Documentation/trace/kprobetrace.rst | 9 +++++-- kernel/trace/trace.c | 2 +- kernel/trace/trace_kprobe.c | 42 ++++++++++++++++++++++++++--- kernel/trace/trace_probe.c | 14 +++++++--- kernel/trace/trace_probe.h | 1 + kernel/trace/trace_probe_tmpl.h | 14 +++++++++- kernel/trace/trace_uprobe.c | 12 +++++++++ 7 files changed, 84 insertions(+), 10 deletions(-)
Documentation/trace/kprobetrace.rst +7 -2
@@ -55,7 +55,8 @@ Synopsis of kprobe_events NAME=FETCHARG : Set NAME as the argument name of FETCHARG. FETCHARG:TYPE : Set TYPE as the type of FETCHARG. Currently, basic types (u8/u16/u32/u64/s8/s16/s32/s64), hexadecimal types - (x8/x16/x32/x64), "string" and bitfield are supported. + (x8/x16/x32/x64), "string", "ustring" and bitfield + are supported. (\*1) only for the probe on function entry (offs == 0). (\*2) only for return probe.
@@ -77,7 +78,11 @@ apply it to registers/stack-entries etc. (for example, '$stack1:x8[8]' is wrong, but '+8($stack):x8[8]' is OK.) String type is a special type, which fetches a "null-terminated" string from kernel space. This means it will fail and store NULL if the string container -has been paged out. +has been paged out. "ustring" type is an alternative of string for user-space. +Note that kprobe-event provides string/ustring types, but doesn't change it +automatically. So user has to decide if the targe string in kernel or in user +space carefully. On some arch, if you choose wrong one, it always fails to +record string data. The string array type is a bit different from other types. For other base types, <base-type>[1] is equal to <base-type> (e.g. +0(%di):x32[1] is same as +0(%di):x32.) But string[1] is not equal to string. The string type itself
kernel/trace/trace.c +1 -1
@@ -4847,7 +4847,7 @@ static const char readme_msg[] ="\t $stack<index>, $stack, $retval, $comm\n" #endif"\t type: s8/16/32/64, u8/16/32/64, x8/16/32/64, string, symbol,\n" -"\t b<bit-width>@<bit-offset>/<container-size>,\n" +"\t b<bit-width>@<bit-offset>/<container-size>, ustring,\n" "\t <type>\\[<array-size>\\]\n" #ifdef CONFIG_HIST_TRIGGERS"\t field: <stype> <name>;\n"
kernel/trace/trace_kprobe.c +39 -3
64 lines not on this page · raw message
kernel/trace/trace_probe.c +11 -3
@@ -78,6 +78,8 @@ static const struct fetch_type probe_fetch_types[] = {/* Special types */ __ASSIGN_FETCH_TYPE ("string" , string, string,sizeof (u32),1 ,"__data_loc char[]" ), +__ASSIGN_FETCH_TYPE ("ustring" , string, string,sizeof (u32),1 , +"__data_loc char[]" ),/* Basic types */ ASSIGN_FETCH_TYPE (u8, u8,0 ), ASSIGN_FETCH_TYPE(u16, u16, 0),
@@ -569,7 +571,8 @@ static int traceprobe_parse_probe_arg_body(char *arg, ssize_t *size, goto fail;/* Store operation */ -if (!strcmp (parg->type->name,"string" )) { +if (!strcmp (parg->type->name,"string" ) || + !strcmp (parg->type->name,"ustring" )) {if (code->op !=FETCH_OP_DEREF && code->op !=FETCH_OP_IMM && code->op !=FETCH_OP_COMM ) { trace_probe_log_err(offset + (t ? (t - arg) : 0),
@@ -590,7 +593,11 @@ static int traceprobe_parse_probe_arg_body(char *arg, ssize_t *size, goto fail; } } - code->op =FETCH_OP_ST_STRING ;/* In DEREF case, replace it */ +/* If op == DEREF, replace it with STRING */ +if (!strcmp (parg->type->name,"ustring" )) + code->op =FETCH_OP_ST_USTRING ; +else + code->op =FETCH_OP_ST_STRING ; code->size = parg->type->size; parg->dynamic = true; }else if (code->op ==FETCH_OP_DEREF ) {
@@ -618,7 +625,8 @@ static int traceprobe_parse_probe_arg_body(char *arg, ssize_t *size,/* Loop(Array) operation */ if (parg->count) {if (scode->op !=FETCH_OP_ST_MEM && - scode->op !=FETCH_OP_ST_STRING ) { + scode->op !=FETCH_OP_ST_STRING && + scode->op !=FETCH_OP_ST_USTRING ) {trace_probe_log_err (offset + (t ? (t - arg) :0 ),BAD_STRING ); ret = -EINVAL ;
kernel/trace/trace_probe.h +1 -0
@@ -96,6 +96,7 @@ enum fetch_op {FETCH_OP_ST_RAW ,/* Raw: .size */ FETCH_OP_ST_MEM ,/* Mem: .offset, .size */ FETCH_OP_ST_STRING ,/* String: .offset, .size */ +FETCH_OP_ST_USTRING ,/* User String: .offset, .size */ // Stage 4 (modify) op FETCH_OP_MOD_BF, /* Bitfield: .basesize, .lshift, .rshift */// Stage 5 (loop) op
kernel/trace/trace_probe_tmpl.h +13 -1
@@ -59,6 +59,9 @@ process_fetch_insn(struct fetch_insn *code, struct pt_regs *regs, static nokprobe_inline int fetch_store_strlen(unsigned long addr); static nokprobe_inline intfetch_store_string (unsigned long addr,void *dest,void *base); +static nokprobe_inline int fetch_store_strlen_user(unsigned long addr); +static nokprobe_inline int +fetch_store_string_user (unsigned long addr,void *dest,void *base); static nokprobe_inline intprobe_mem_read (void *dest,void *src,size_t size);
@@ -91,6 +94,10 @@ process_fetch_insn_bottom(struct fetch_insn *code, unsigned long val, ret =fetch_store_strlen (val + code->offset); code++; goto array; + }else if (code->op ==FETCH_OP_ST_USTRING ) { + ret +=fetch_store_strlen_user (val + code->offset); + code++; + goto array; }else return -EILSEQ ; }
@@ -106,6 +113,10 @@ process_fetch_insn_bottom(struct fetch_insn *code, unsigned long val, loc = *(u32 *)dest; ret =fetch_store_string (val + code->offset, dest, base);break ; +case FETCH_OP_ST_USTRING : + loc = *(u32 *)dest; + ret =fetch_store_string_user (val + code->offset, dest, base); +break ;default :return -EILSEQ ; }
@@ -123,7 +134,8 @@ process_fetch_insn_bottom(struct fetch_insn *code, unsigned long val, total += ret;if (++i < code->param) { code = s3; -if (s3->op !=FETCH_OP_ST_STRING ) { +if (s3->op !=FETCH_OP_ST_STRING && + s3->op !=FETCH_OP_ST_USTRING ) { dest += s3->size; val += s3->size; goto stage3;
kernel/trace/trace_uprobe.c +12 -0
@@ -176,6 +176,12 @@ fetch_store_string(unsigned long addr, void *dest, void *base)return ret; } +static nokprobe_inline int +fetch_store_string_user (unsigned long addr,void *dest,void *base) +{ +return fetch_store_string (addr, dest, base); +} +/* Return the length of string -- including null terminal byte */ static nokprobe_inline intfetch_store_strlen (unsigned long addr)
@@ -191,6 +197,12 @@ fetch_store_strlen(unsigned long addr)return (len >MAX_STRING_SIZE ) ?0 : len; } +static nokprobe_inline int +fetch_store_strlen_user (unsigned long addr) +{ +return fetch_store_strlen (addr); +} +static unsigned long translate_user_vaddr (unsigned long file_offset) {unsigned long base_addr;
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 6/16 tracing/probe: Support user-space dereference
In reply to Steven RostedtFrom: Masami Hiramatsu <[email protected]>
Support user-space dereference syntax for probe event arguments to dereference the data-structure or array in user-space.
The syntax is just adding 'u' before an offset value.
+|-u<OFFSET>(<FETCHARG>)
e.g. +u8(%ax), +u0(+0(%si))
For example, if you probe do_sched_setscheduler(pid, policy, param) and record param->sched_priority, you can add new probe as below;
p do_sched_setscheduler priority=+u0($arg3)
Note that kprobe event provides this and it doesn't change the dereference method automatically because we do not know whether the given address is in userspace or kernel on some archs.
So as same as "ustring", this is an option for user, who has to carefully choose the dereference method.
--- Documentation/trace/kprobetrace.rst | 27 ++++++++++++++++++++++----- Documentation/trace/uprobetracer.rst | 10 ++++++---- kernel/trace/trace.c | 5 +++-- kernel/trace/trace_kprobe.c | 6 ++++++ kernel/trace/trace_probe.c | 25 ++++++++++++++++++------- kernel/trace/trace_probe.h | 2 ++ kernel/trace/trace_probe_tmpl.h | 22 +++++++++++++++++----- kernel/trace/trace_uprobe.c | 7 +++++++ 8 files changed, 81 insertions(+), 23 deletions(-)
Documentation/trace/kprobetrace.rst +22 -5
@@ -51,7 +51,7 @@ Synopsis of kprobe_events $argN : Fetch the Nth function argument. (N >= 1) (\*1) $retval : Fetch return value.(\*2) $comm : Fetch current task comm. - +|-offs(FETCHARG) : Fetch memory at FETCHARG +|- offs address.(\*3) + +|-[u]OFFS(FETCHARG) : Fetch memory at FETCHARG +|- OFFS address.(\*3)(\*4) NAME=FETCHARG : Set NAME as the argument name of FETCHARG. FETCHARG:TYPE : Set TYPE as the type of FETCHARG. Currently, basic types (u8/u16/u32/u64/s8/s16/s32/s64), hexadecimal types
@@ -61,6 +61,7 @@ Synopsis of kprobe_events (\*1) only for the probe on function entry (offs == 0). (\*2) only for return probe. (\*3) this is useful for fetching a field of data structures. + (\*4) "u" means user-space dereference. See :ref:`user_mem_access`. Types -----
@@ -79,10 +80,7 @@ wrong, but '+8($stack):x8[8]' is OK.) String type is a special type, which fetches a "null-terminated" string from kernel space. This means it will fail and store NULL if the string container has been paged out. "ustring" type is an alternative of string for user-space. -Note that kprobe-event provides string/ustring types, but doesn't change it -automatically. So user has to decide if the targe string in kernel or in user -space carefully. On some arch, if you choose wrong one, it always fails to -record string data. +See :ref:`user_mem_access` for more info.. The string array type is a bit different from other types. For other base types, <base-type>[1] is equal to <base-type> (e.g. +0(%di):x32[1] is same as +0(%di):x32.) But string[1] is not equal to string. The string type itself
@@ -97,6 +95,25 @@ Symbol type('symbol') is an alias of u32 or u64 type (depends on BITS_PER_LONG) which shows given pointer in "symbol+offset" style. For $comm, the default type is "string"; any other type is invalid. +.. _user_mem_access: +User Memory Access +------------------ +Kprobe events supports user-space memory access. For that purpose, you can use +either user-space dereference syntax or 'ustring' type. + +The user-space dereference syntax allows you to access a field of a data +structure in user-space. This is done by adding the "u" prefix to the +dereference syntax. For example, +u4(%si) means it will read memory from the +address in the register %si offset by 4, and the memory is expected to be in +user-space. You can use this for strings too, e.g. +u0(%si):string will read +a string from the address in the register %si that is expected to be in user- +space. 'ustring' is a shortcut way of performing the same task. That is, ++0(%si):ustring is equivalent to +u0(%si):string. + +Note that kprobe-event provides the user-memory access syntax but it doesn't +use it transparently. This means if you use normal dereference or string type +for user memory, it might fail, and may always fail on some archs. The user +has to carefully check if the target data is in kernel or user space. Per-Probe Event Filtering -------------------------
Documentation/trace/uprobetracer.rst +6 -4
@@ -42,16 +42,18 @@ Synopsis of uprobe_tracer @+OFFSET : Fetch memory at OFFSET (OFFSET from same file as PATH) $stackN : Fetch Nth entry of stack (N >= 0) $stack : Fetch stack address. - $retval : Fetch return value.(*) + $retval : Fetch return value.(\*1) $comm : Fetch current task comm. - +|-offs(FETCHARG) : Fetch memory at FETCHARG +|- offs address.(**) + +|-[u]OFFS(FETCHARG) : Fetch memory at FETCHARG +|- OFFS address.(\*2)(\*3) NAME=FETCHARG : Set NAME as the argument name of FETCHARG. FETCHARG:TYPE : Set TYPE as the type of FETCHARG. Currently, basic types (u8/u16/u32/u64/s8/s16/s32/s64), hexadecimal types (x8/x16/x32/x64), "string" and bitfield are supported. - (*) only for return probe. - (**) this is useful for fetching a field of data structures. + (\*1) only for return probe. + (\*2) this is useful for fetching a field of data structures. + (\*3) Unlike kprobe event, "u" prefix will just be ignored, becuse uprobe + events can access only user-space memory. Types -----
kernel/trace/trace.c +3 -2
@@ -4842,10 +4842,11 @@ static const char readme_msg[] = "\t args: <name>=fetcharg[:type]\n" "\t fetcharg: %<register>, @<address>, @<symbol>[+|-<offset>],\n" #ifdef CONFIG_HAVE_FUNCTION_ARG_ACCESS_API - "\t $stack<index>, $stack, $retval, $comm, $arg<N>\n" + "\t $stack<index>, $stack, $retval, $comm, $arg<N>,\n" #else -"\t $stack<index>, $stack, $retval, $comm\n" +"\t $stack<index>, $stack, $retval, $comm,\n" #endif +"\t +|-[u]<offset>(<fetcharg>)\n" "\t type: s8/16/32/64, u8/16/32/64, x8/16/32/64, string, symbol,\n" "\t b<bit-width>@<bit-offset>/<container-size>, ustring,\n" "\t <type>\\[<array-size>\\]\n"
kernel/trace/trace_kprobe.c +6 -0
@@ -952,6 +952,12 @@ probe_mem_read(void *dest, void *src, size_t size)return probe_kernel_read (dest, src, size); } +static nokprobe_inline int +probe_mem_read_user (void *dest,void *src,size_t size) +{ +return probe_user_read (dest, src, size); +} +/* Note that we don't verify it, since the code does not come from user space */ static int process_fetch_insn(struct fetch_insn *code, struct pt_regs *regs, void *dest,
kernel/trace/trace_probe.c +18 -7
@@ -324,6 +324,7 @@ parse_probe_arg(char *arg, const struct fetch_type *type, {struct fetch_insn *code = *pcode;unsigned long param; +int deref =FETCH_OP_DEREF ;long offset =0 ;char *tmp;int ret =0 ;
@@ -396,9 +397,14 @@ parse_probe_arg(char *arg, const struct fetch_type *type,break ;case '+' :/* deref memory */ - arg++;/* Skip '+', because kstrtol() rejects it. */ -/* fall through */ case '-' : +if (arg[1 ] =='u' ) { + deref =FETCH_OP_UDEREF ; + arg[1 ] = arg[0 ]; + arg++; + } +if (arg[0 ] =='+' ) + arg++;/* Skip '+', because kstrtol() rejects it. */ tmp =strchr (arg,'(' );if (!tmp) {trace_probe_log_err (offs,DEREF_NEED_BRACE );
@@ -434,7 +440,7 @@ parse_probe_arg(char *arg, const struct fetch_type *type, } *pcode = code; - code->op =FETCH_OP_DEREF ; + code->op = deref; code->offset = offset; }break ;
@@ -573,14 +579,15 @@ static int traceprobe_parse_probe_arg_body(char *arg, ssize_t *size,/* Store operation */ if (!strcmp (parg->type->name,"string" ) || !strcmp (parg->type->name,"ustring" )) { -if (code->op !=FETCH_OP_DEREF && code->op !=FETCH_OP_IMM && - code->op !=FETCH_OP_COMM ) { +if (code->op !=FETCH_OP_DEREF && code->op !=FETCH_OP_UDEREF && + code->op !=FETCH_OP_IMM && code->op !=FETCH_OP_COMM ) {trace_probe_log_err (offset + (t ? (t - arg) :0 ),BAD_STRING ); ret = -EINVAL ; goto fail; } -if (code->op !=FETCH_OP_DEREF || parg->count) { +if ((code->op ==FETCH_OP_IMM || code->op ==FETCH_OP_COMM ) || + parg->count) {/* * IMM and COMM is pointing actual address, those must * be kept, and if parg->count != 0, this is an array
@@ -594,7 +601,8 @@ static int traceprobe_parse_probe_arg_body(char *arg, ssize_t *size, } }/* If op == DEREF, replace it with STRING */ -if (!strcmp (parg->type->name,"ustring" )) +if (!strcmp (parg->type->name,"ustring" ) || + code->op ==FETCH_OP_UDEREF ) code->op =FETCH_OP_ST_USTRING ;else code->op =FETCH_OP_ST_STRING ;
@@ -603,6 +611,9 @@ static int traceprobe_parse_probe_arg_body(char *arg, ssize_t *size, }else if (code->op ==FETCH_OP_DEREF ) { code->op =FETCH_OP_ST_MEM ; code->size = parg->type->size; + }else if (code->op ==FETCH_OP_UDEREF ) { + code->op =FETCH_OP_ST_UMEM ; + code->size = parg->type->size; }else { code++;if (code->op !=FETCH_OP_NOP ) {
kernel/trace/trace_probe.h +2 -0
@@ -92,9 +92,11 @@ enum fetch_op {FETCH_OP_FOFFS ,/* File offset: .immediate */ // Stage 2 (dereference) op FETCH_OP_DEREF ,/* Dereference: .offset */ +FETCH_OP_UDEREF ,/* User-space Dereference: .offset */ // Stage 3 (store) ops FETCH_OP_ST_RAW ,/* Raw: .size */ FETCH_OP_ST_MEM ,/* Mem: .offset, .size */ +FETCH_OP_ST_UMEM ,/* Mem: .offset, .size */ FETCH_OP_ST_STRING ,/* String: .offset, .size */ FETCH_OP_ST_USTRING, /* User String: .offset, .size */// Stage 4 (modify) op
kernel/trace/trace_probe_tmpl.h +17 -5
@@ -64,6 +64,8 @@ static nokprobe_inline int fetch_store_string_user(unsigned long addr, void *dest, void *base); static nokprobe_inline intprobe_mem_read (void *dest,void *src,size_t size); +static nokprobe_inline int +probe_mem_read_user (void *dest,void *src,size_t size);/* From the 2nd stage, routine is same */ static nokprobe_inline int
@@ -77,14 +79,21 @@ process_fetch_insn_bottom(struct fetch_insn *code, unsigned long val, stage2:/* 2nd stage: dereference memory if needed */ -while (code->op ==FETCH_OP_DEREF ) { - lval = val; - ret =probe_mem_read (&val, (void *)val + code->offset, -sizeof (val)); +do { +if (code->op ==FETCH_OP_DEREF ) { + lval = val; + ret =probe_mem_read (&val, (void *)val + code->offset, +sizeof (val)); + }else if (code->op ==FETCH_OP_UDEREF ) { + lval = val; + ret =probe_mem_read_user (&val, + (void *)val + code->offset,sizeof (val)); + }else +break ;if (ret)return ret; code++; - } + }while (1 ); s3 = code; stage3:
@@ -109,6 +118,9 @@ process_fetch_insn_bottom(struct fetch_insn *code, unsigned long val,case FETCH_OP_ST_MEM :probe_mem_read (dest, (void *)val + code->offset, code->size);break ; +case FETCH_OP_ST_UMEM : +probe_mem_read_user (dest, (void *)val + code->offset, code->size); +break ;case FETCH_OP_ST_STRING : loc = *(u32 *)dest; ret =fetch_store_string (val + code->offset, dest, base);
kernel/trace/trace_uprobe.c +7 -0
@@ -140,6 +140,13 @@ probe_mem_read(void *dest, void *src, size_t size)return copy_from_user (dest, vaddr, size) ? -EFAULT :0 ; } + +static nokprobe_inline int +probe_mem_read_user (void *dest,void *src,size_t size) +{ +return probe_mem_read (dest, src, size); +} +/* * Fetch a null-terminated string. Caller MUST set *(u32 *)dest with max * length and relative data location.
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 7/16 selftests/ftrace: Add user-memory access syntax testcase
In reply to Steven RostedtFrom: Masami Hiramatsu <[email protected]>
Add a user-memory access syntax testcase which checks new user-memory access syntax and ustring type.
--- .../ftrace/test.d/kprobe/kprobe_args_user.tc | 32 +++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 tools/testing/selftests/ftrace/test.d/kprobe/kprobe_args_user.tc
tools/testing/selftests/ftrace/test.d/kprobe/kprobe_args_user.tc new file +32 -0
@@ -0,0 +1,32 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0 +# description: Kprobe event user-memory access + +[ -f kprobe_events ] || exit_unsupported # this is configurable + +grep -q '\$arg<N>' README || exit_unresolved # depends on arch +grep -A10 "fetcharg:" README | grep -q 'ustring' || exit_unsupported +grep -A10 "fetcharg:" README | grep -q '\[u\]<offset>' || exit_unsupported + +:;: "user-memory access syntax and ustring working on user memory";: +echo 'p:myevent do_sys_open path=+0($arg2):ustring path2=+u0($arg2):string' \ + > kprobe_events + +grep myevent kprobe_events | \ + grep -q 'path=+0($arg2):ustring path2=+u0($arg2):string' +echo 1 > events/kprobes/myevent/enable +echo > /dev/null +echo 0 > events/kprobes/myevent/enable + +grep myevent trace | grep -q 'path="/dev/null" path2="/dev/null"' + +:;: "user-memory access syntax and ustring not working with kernel memory";: +echo 'p:myevent vfs_symlink path=+0($arg3):ustring path2=+u0($arg3):string' \ + > kprobe_events +echo 1 > events/kprobes/myevent/enable +ln -s foo $TMPDIR/bar +echo 0 > events/kprobes/myevent/enable + +grep myevent trace | grep -q 'path=(fault) path2=(fault)' + +exit 0
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 8/16 perf-probe: Add user memory access attribute support
In reply to Steven RostedtFrom: Masami Hiramatsu <[email protected]>
Add user memory access attribute for kprobe event arguments. If a given 'local variable' is in user-space, User can specify memory access method by '@user' suffix. This is not only for string but also for data structure.
If we access a field of data structure in user memory from kernel on some arch, it will fail. e.g.
perf probe -a "sched_setscheduler param->sched_priority"
This will fail to access the "param->sched_priority" because the param is __user pointer. Instead, we can now specify @user suffix for such argument.
perf probe -a "sched_setscheduler param->sched_priority@user"
Note that kernel memory access with "@user" must always fail on any arch.
--- tools/perf/Documentation/perf-probe.txt | 3 ++- tools/perf/util/probe-event.c | 11 +++++++++++ tools/perf/util/probe-event.h | 2 ++ tools/perf/util/probe-file.c | 7 +++++++ tools/perf/util/probe-file.h | 1 + tools/perf/util/probe-finder.c | 19 ++++++++++++------- 6 files changed, 35 insertions(+), 8 deletions(-)
tools/perf/Documentation/perf-probe.txt +2 -1
@@ -194,12 +194,13 @@ PROBE ARGUMENT -------------- Each probe argument follows below syntax. - [NAME=]LOCALVAR|$retval|%REG|@SYMBOL[:TYPE] + [NAME=]LOCALVAR|$retval|%REG|@SYMBOL[:TYPE][@user] 'NAME' specifies the name of this argument (optional). You can use the name of local variable, local data structure member (e.g. var->field, var.field2), local array with fixed index (e.g. array[1], var->array[0], var->pointer[2]), or kprobe-tracer argument format (e.g. $retval, %ax, etc). Note that the name of this argument will be set as the last member name if you specify a local data structure member (e.g. field2 for 'var->field1.field2'.) '$vars' and '$params' special arguments are also available for NAME, '$vars' is expanded to the local variables (including function parameters) which can access at given probe point. '$params' is expanded to only the function parameters. 'TYPE' casts the type of this argument (optional). If omitted, perf probe automatically set the type based on debuginfo (*). Currently, basic types (u8/u16/u32/u64/s8/s16/s32/s64), hexadecimal integers (x/x8/x16/x32/x64), signedness casting (u/s), "string" and bitfield are supported. (see TYPES for detail) On x86 systems %REG is always the short form of the register: for example %AX. %RAX or %EAX is not valid. +"@user" is a special attribute which means the LOCALVAR will be treated as a user-space memory. This is only valid for kprobe event. TYPES -----
tools/perf/util/probe-event.c +11 -0
@@ -1577,6 +1577,17 @@ static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg) str = tmp +1 ; } + tmp =strchr (str,'@' ); +if (tmp && tmp != str &&strcmp (tmp +1 ,"user" )) {/* user attr */ +if (!user_access_is_supported ()) { +semantic_error ("ftrace does not support user access\n" ); +return -EINVAL ; + } + *tmp ='\0' ; + arg->user_access = true; +pr_debug ("user_access " ); + } + tmp =strchr (str,':' );if (tmp) {/* Type setting */ *tmp ='\0' ;
tools/perf/util/probe-event.h +2 -0
@@ -37,6 +37,7 @@ struct probe_trace_point {struct probe_trace_arg_ref {struct probe_trace_arg_ref *next;/* Next reference */ long offset;/* Offset value */ +bool user_access;/* User-memory access */ };/* kprobe-tracer and uprobe-tracer tracing argument */
@@ -82,6 +83,7 @@ struct perf_probe_arg {char *var;/* Variable name */ char *type;/* Type name */ struct perf_probe_arg_field *field;/* Structure fields */ +bool user_access;/* User-memory access */ };/* Perf probe probing event (point + arg) */
tools/perf/util/probe-file.c +7 -0
@@ -1015,6 +1015,7 @@ enum ftrace_readme {FTRACE_README_PROBE_TYPE_X =0 ,FTRACE_README_KRETPROBE_OFFSET ,FTRACE_README_UPROBE_REF_CTR , +FTRACE_README_USER_ACCESS , FTRACE_README_END, };
@@ -1027,6 +1028,7 @@ static struct {DEFINE_TYPE (FTRACE_README_PROBE_TYPE_X ,"*type: * x8/16/32/64,*" ),DEFINE_TYPE (FTRACE_README_KRETPROBE_OFFSET ,"*place (kretprobe): *" ),DEFINE_TYPE (FTRACE_README_UPROBE_REF_CTR ,"*ref_ctr_offset*" ), + DEFINE_TYPE(FTRACE_README_USER_ACCESS, "*[u]<offset>*"), };static bool scan_ftrace_readme (enum ftrace_readme type)
@@ -1087,3 +1089,8 @@ bool uprobe_ref_ctr_is_supported(void) {return scan_ftrace_readme (FTRACE_README_UPROBE_REF_CTR ); } + +bool user_access_is_supported (void ) +{ +return scan_ftrace_readme (FTRACE_README_USER_ACCESS ); +}
tools/perf/util/probe-file.h +1 -0
@@ -70,6 +70,7 @@ int probe_cache__show_all_caches(struct strfilter *filter);bool probe_type_is_available (enum probe_type type);bool kretprobe_offset_is_supported (void );bool uprobe_ref_ctr_is_supported (void ); +bool user_access_is_supported (void );#else /* ! HAVE_LIBELF_SUPPORT */ static inline struct probe_cache *probe_cache__new (const char *tgt__maybe_unused ,struct nsinfo *nsi__maybe_unused ) {
tools/perf/util/probe-finder.c +12 -7
@@ -294,7 +294,7 @@ static int convert_variable_location(Dwarf_Die *vr_die, Dwarf_Addr addr,static int convert_variable_type (Dwarf_Die *vr_die,struct probe_trace_arg *tvar, -const char *cast) +const char *cast,bool user_access) {struct probe_trace_arg_ref **ref_ptr = &tvar->ref;Dwarf_Die type;
@@ -334,7 +334,8 @@ static int convert_variable_type(Dwarf_Die *vr_die,pr_debug ("%s type is %s.\n" ,dwarf_diename (vr_die),dwarf_diename (&type)); -if (cast &&strcmp (cast,"string" ) ==0 ) {/* String type */ +if (cast && (!strcmp (cast,"string" ) || !strcmp (cast,"ustring" ))) { +/* String type */ ret =dwarf_tag (&type);if (ret != DW_TAG_pointer_type && ret != DW_TAG_array_type) {
@@ -357,6 +358,7 @@ static int convert_variable_type(Dwarf_Die *vr_die,pr_warning ("Out of memory error\n" );return -ENOMEM ; } + (*ref_ptr)->user_access = user_access; }if (!die_compare_name (&type,"char" ) && !die_compare_name (&type,"unsigned char" )) {
@@ -411,7 +413,7 @@ static int convert_variable_type(Dwarf_Die *vr_die,static int convert_variable_fields (Dwarf_Die *vr_die,const char *varname,struct perf_probe_arg_field *field,struct probe_trace_arg_ref **ref_ptr, -Dwarf_Die *die_mem) +Dwarf_Die *die_mem,bool user_access) {struct probe_trace_arg_ref *ref = *ref_ptr;Dwarf_Die type;
@@ -448,6 +450,7 @@ static int convert_variable_fields(Dwarf_Die *vr_die, const char *varname, *ref_ptr = ref; } ref->offset +=dwarf_bytesize (&type) * field->index; + ref->user_access = user_access; goto next; }else if (tag == DW_TAG_pointer_type) {/* Check the pointer and dereference */
@@ -519,17 +522,18 @@ static int convert_variable_fields(Dwarf_Die *vr_die, const char *varname, } } ref->offset += (long )offs; + ref->user_access = user_access;/* If this member is unnamed, we need to reuse this field */ if (!dwarf_diename (die_mem))return convert_variable_fields (die_mem, varname, field, - &ref, die_mem); + &ref, die_mem, user_access); next:/* Converting next field */ if (field->next)return convert_variable_fields (die_mem, field->name, - field->next, &ref, die_mem); + field->next, &ref, die_mem, user_access);else return 0 ; }
@@ -555,11 +559,12 @@ static int convert_variable(Dwarf_Die *vr_die, struct probe_finder *pf)else if (ret ==0 && pf->pvar->field) { ret =convert_variable_fields (vr_die, pf->pvar->var, pf->pvar->field, &pf->tvar->ref, - &die_mem); + &die_mem, pf->pvar->user_access); vr_die = &die_mem; }if (ret ==0 ) - ret =convert_variable_type (vr_die, pf->tvar, pf->pvar->type); + ret =convert_variable_type (vr_die, pf->tvar, pf->pvar->type, + pf->pvar->user_access);/* *expr will be cached in libdw. Don't free it. */ return ret; }
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 9/16 tracing: Use correct function name in trace_filter_add_remove_task() comment
In reply to Steven RostedtFrom: Matthias Kaehlcke <[email protected]>
The comment of trace_filter_add_remove_task() refers to the function as 'trace_pid_filter_add_remove_task', use the correct name.
--- kernel/trace/trace.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/trace/trace.c +1 -1
@@ -366,7 +366,7 @@ trace_ignore_this_task(struct trace_pid_list *filtered_pids, struct task_struct }/** -* trace_pid_filter_add_remove_task - Add or remove a task from a pid_list +* trace_filter_add_remove_task - Add or remove a task from a pid_list * @pid_list: The list to modify * @self: The current task for fork or NULL for exit * @task: The task to add or remove
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 10/16 uaccess: Add a prototype of non-static __probe_user_read()
In reply to Steven RostedtFrom: Masami Hiramatsu <[email protected]>
Declare a prototype of non-static __probe_user_read() as same as __probe_kernel_read() at uaccess.h.
--- include/linux/uaccess.h | 1 + 1 file changed, 1 insertion(+)
include/linux/uaccess.h +1 -0
@@ -252,6 +252,7 @@ extern long __probe_kernel_read(void *dst, const void *src, size_t size);* happens, handle that and return -EFAULT. */ extern long probe_user_read (void *dst,const void __user *src,size_t size); +extern long __probe_user_read (void *dst,const void __user *src,size_t size);/* * probe_kernel_write(): safely attempt to write to a location
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 11/16 tracing/kprobe: Cast user-space address correctly
In reply to Steven RostedtFrom: Masami Hiramatsu <[email protected]>
Cast user-space address correctly to pass to probe_user_read().
--- kernel/trace/trace_kprobe.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
kernel/trace/trace_kprobe.c +3 -1
@@ -955,7 +955,9 @@ probe_mem_read(void *dest, void *src, size_t size) static nokprobe_inline intprobe_mem_read_user (void *dest,void *src,size_t size) { -return probe_user_read (dest, src, size); +const void __user *uaddr = (__force const void __user *)src; + +return probe_user_read (dest, uaddr, size); }/* Note that we don't verify it, since the code does not come from user space */
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 12/16 kprobes: Initialize kprobes at postcore_initcall
In reply to Steven RostedtFrom: Masami Hiramatsu <[email protected]>
Initialize kprobes at postcore_initcall level instead of module_init since kprobes is not a module, and it depends on only subsystems initialized in core_initcall.
This will allow ftrace kprobe event to add new events when it is initializing because ftrace kprobe event is initialized at later initcall level.
--- kernel/kprobes.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
kernel/kprobes.c +1 -2
@@ -2289,6 +2289,7 @@ static int __init init_kprobes(void)init_test_probes ();return err; } +postcore_initcall (init_kprobes);#ifdef CONFIG_DEBUG_FS static void report_probe(struct seq_file *pi, struct kprobe *p,
@@ -2614,5 +2615,3 @@ static int __init debugfs_kprobe_init(void)late_initcall (debugfs_kprobe_init);#endif /* CONFIG_DEBUG_FS */ - -module_init (init_kprobes);
Signature · 1 line
2.20.1
Mark Rutland
reviewerRe: [for-next][PATCH 12/16] kprobes: Initialize kprobes at postcore_initcall
Quoted 22 lines · Steven Rostedt
From: Masami Hiramatsu <[email protected]>
Initialize kprobes at
postcore_initcalllevel instead ofmodule_initsince kprobes is not a module, and it depends on only subsystems initialized incore_initcall.
This will allow ftrace kprobe event to add new events when it is initializing because ftrace kprobe event is initialized at later initcall level.Signed-off-by Masami Hiramatsu <[email protected]>Signed-off-by Steven Rostedt (VMware) <[email protected]>--- kernel/kprobes.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)kernel/kprobes.c +0
-0
kernel/kprobes.c static int __init init_kprobes(void) · line 2292
Quoted 4 lines
kernel/kprobes.c +1
-0@@ -2289,6 +2289,7 @@ static int __init init_kprobes(void)init_test_probes ();return err; } +postcore_initcall (init_kprobes);
As a heads-up, this is causing boot-time failures on arm64.
On arm64 kprobes depends on the BRK handler we register in debug_traps_init(), which is an arch_initcall.
As of this change, init_krprobes() calls init_test_probes() before that's registered, so we end up hitting a BRK before we can handle it.
Thanks,
Mark.
Quoted 13 lines
kernel/kprobes.c +0
-2#ifdef CONFIG_DEBUG_FS static void report_probe(struct seq_file *pi, struct kprobe *p,@@ -2614,5 +2615,3 @@ static int __init debugfs_kprobe_init(void)late_initcall (debugfs_kprobe_init);#endif /* CONFIG_DEBUG_FS */ - -module_init (init_kprobes);Signature · 1 line
2.20.1
Catalin Marinas
maintainerRe: [for-next][PATCH 12/16] kprobes: Initialize kprobes at postcore_initcall
Quoted 30 lines · Mark Rutland
Quoted 22 lines · Steven Rostedt
From: Masami Hiramatsu <[email protected]>
Initialize kprobes at
postcore_initcalllevel instead ofmodule_initsince kprobes is not a module, and it depends on only subsystems initialized incore_initcall.
This will allow ftrace kprobe event to add new events when it is initializing because ftrace kprobe event is initialized at later initcall level.Signed-off-by Masami Hiramatsu <[email protected]>Signed-off-by Steven Rostedt (VMware) <[email protected]>--- kernel/kprobes.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)kernel/kprobes.c +0
-0kernel/kprobes.c static int __init init_kprobes(void) · line 2292
Quoted 4 lines
kernel/kprobes.c +1
-0@@ -2289,6 +2289,7 @@ static int __init init_kprobes(void)init_test_probes ();return err; } +postcore_initcall (init_kprobes);As a heads-up, this is causing boot-time failures on arm64.
Quoted 5 lines
On arm64 kprobes depends on the BRK handler we register in
debug_traps_init(), which is anarch_initcall.As of this change,
init_krprobes()callsinit_test_probes()before that's registered, so we end up hitting a BRK before we can handle it.
Thanks Mark for identifying this.
So we either revert the above commit in -next or queue the one below together with the rest of the kprobes changes (I can queue it via the arm64 for-next/core assuming that the above commit id remains stable):
--------------8<------------------------------------
From de4f4d30bab3d77d6643a6fa9ba1deff73dac7f2 Mon Sep 17 00:00:00 2001
From: Catalin Marinas <[email protected]>
Date: Wed, 3 Jul 2019 14:44:23 +0100
Subject: [PATCH] arm64: Initialise the debug traps earlier
Commit b5f8b32c93b2 ("kprobes: Initialize kprobes at postcore_initcall") makes init_kprobes() a postcore_initcall while the arm64 handling of the BRK instruction is initialised at arch_initcall level. Make the arm64 debug_traps_init() a core_initcall.
--- arch/arm64/kernel/debug-monitors.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/arm64/kernel/debug-monitors.c +1 -1
@@ -382,7 +382,7 @@ static int __init debug_traps_init(void) TRAP_BRKPT, "ptrace BRK handler");return 0 ; } -arch_initcall (debug_traps_init); +core_initcall (debug_traps_init);/* Re-enable single step for syscall restarting. */ void user_rewind_single_step (struct task_struct *task)
Steven Rostedt
maintainerRe: [for-next][PATCH 12/16] kprobes: Initialize kprobes at postcore_initcall
In reply to Mark RutlandQuoted 18 lines · On Tue, 2 Jul 2019 17:50:09 +0100 Mark Rutland <[email protected]> wrote:
Quoted 17 lines · Steven Rostedt
From: Masami Hiramatsu <[email protected]>
Initialize kprobes at
postcore_initcalllevel instead ofmodule_initsince kprobes is not a module, and it depends on only subsystems initialized incore_initcall.
This will allow ftrace kprobe event to add new events when it is initializing because ftrace kprobe event is initialized at later initcall level.Signed-off-by Masami Hiramatsu <[email protected]>Signed-off-by Steven Rostedt (VMware) <[email protected]>--- kernel/kprobes.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
Quoted 11 lines
kernel/kprobes.c static int __init init_kprobes(void) · line 2292
Quoted 9 lines
kernel/kprobes.c +1
-0@@ -2289,6 +2289,7 @@ static int __init init_kprobes(void)init_test_probes ();return err; } +postcore_initcall (init_kprobes);As a heads-up, this is causing boot-time failures on arm64.
Thanks for the report.
Quoted 7 lines
On arm64 kprobes depends on the BRK handler we register in
debug_traps_init(), which is anarch_initcall.As of this change,
init_krprobes()callsinit_test_probes()before that's registered, so we end up hitting a BRK before we can handle it.
Would something like this help?
-- Steve
kernel/kprobes.c +10 -1
@@ -2235,6 +2235,8 @@ static struct notifier_block kprobe_module_nb = {extern unsigned long __start_kprobe_blacklist[];extern unsigned long __stop_kprobe_blacklist[]; +static bool run_kprobe_tests__initdata ; +static int __init init_kprobes (void ) {int i, err =0 ;
@@ -2286,11 +2288,18 @@ static int __init init_kprobes(void) kprobes_initialized = (err ==0 );if (!err) -init_test_probes (); + run_kprobe_tests = true;return err; }subsys_initcall (init_kprobes); +static int __init run_init_test_probes (void ) +{ +if (run_kprobe_tests) +init_test_probes (); +} +module_init (run_init_test_probes); +#ifdef CONFIG_DEBUG_FS static void report_probe (struct seq_file *pi,struct kprobe *p,const char *sym,int offset,char *modname,struct kprobe *pp)
Re: [for-next][PATCH 12/16] kprobes: Initialize kprobes at postcore_initcall
Quoted 27 lines · Steven Rostedt
Quoted 5 lines
On arm64 kprobes depends on the BRK handler we register in
debug_traps_init(), which is anarch_initcall.As of this change,
init_krprobes()callsinit_test_probes()before that's registered, so we end up hitting a BRK before we can handle it.Would something like this help?
-- Steve
kernel/kprobes.c +2
-0@@ -2235,6 +2235,8 @@ static struct notifier_block kprobe_module_nb = {extern unsigned long __start_kprobe_blacklist[];extern unsigned long __stop_kprobe_blacklist[]; +static bool run_kprobe_tests__initdata ; +static int __init init_kprobes (void ) {int i, err =0 ;@@ -2286,11 +2288,18 @@ static int __init init_kprobes(void) kprobes_initialized = (err ==0 );if (!err)
kernel/kprobes.c static int __init init_kprobes(void) · line 2299
Quoted 10 lines
kernel/kprobes.c +5
-1-init_test_probes (); + run_kprobe_tests = true;return err; }subsys_initcall (init_kprobes); +static int __init run_init_test_probes (void ) +{ +if (run_kprobe_tests) +init_test_probes ();
A return 0 here.
kernel/kprobes.c static int __init init_kprobes(void) · line 2301
Quoted 2 lines
kernel/kprobes.c +2
-0+} +module_init (run_init_test_probes);
This does the trick. I prefer your fix as it leaves the arch code unchanged. In case you need it:
Thanks.
Signature · 1 line
Catalin
Steven Rostedt
maintainerRe: [for-next][PATCH 12/16] kprobes: Initialize kprobes at postcore_initcall
Quoted 6 lines · On Wed, 3 Jul 2019 15:08:32 +0100 Catalin Marinas <[email protected]>…
kernel/kprobes.c static int __init init_kprobes(void) · line 2299
Quoted 4 lines
kernel/kprobes.c +4
-0+static int __init run_init_test_probes (void ) +{ +if (run_kprobe_tests) +init_test_probes ();A return 0 here.
Will update (would have triggered a failure on my test suite anyway ;-)
Quoted 9 lines
kernel/kprobes.c static int __init init_kprobes(void) · line 2301
Quoted 3 lines
kernel/kprobes.c +2
-0+} +module_init (run_init_test_probes);This does the trick. I prefer your fix as it leaves the arch code unchanged. In case you need it:
Tested-by Catalin Marinas <[email protected]>
Great! Thanks.
-- Steve
Steven Rostedt
maintainerRe: [for-next][PATCH 12/16] kprobes: Initialize kprobes at postcore_initcall
Quoted 4 lines · On Wed, 3 Jul 2019 10:24:02 -0400 Steven Rostedt <[email protected]> wrote:
On Wed, 3 Jul 2019 15:08:32 +0100
Catalin Marinas <[email protected]> wrote:
Quoted 19 lines
Quoted 6 lines
kernel/kprobes.c static int __init init_kprobes(void) · line 2299
Quoted 4 lines
kernel/kprobes.c +4
-0+static int __init run_init_test_probes (void ) +{ +if (run_kprobe_tests) +init_test_probes ();A return 0 here.
Will update (would have triggered a failure on my test suite anyway ;-)
Quoted 9 lines
kernel/kprobes.c static int __init init_kprobes(void) · line 2301
Quoted 3 lines
kernel/kprobes.c +2
-0+} +module_init (run_init_test_probes);This does the trick. I prefer your fix as it leaves the arch code unchanged. In case you need it:
Tested-by Catalin Marinas <[email protected]>
Masami,
If you give me an Acked-by, I'll add it to my tree.
-- Steve
Re: [for-next][PATCH 12/16] kprobes: Initialize kprobes at postcore_initcall
This would be the official patch:
From: "Steven Rostedt (VMware)" <[email protected]>
Subject: [PATCH] kprobes: Run init_test_probes() later in boot up
It was reported that the moving of the kprobe initialization earlier in the boot process caused arm64 to crash. This was due to arm64 depending on the BRK handler being registered first, but the init_test_probes() can be called before that happens.
By moving the init_test_probes() to later in the boot process, the BRK handler is now guaranteed to be initialized before init_test_probes() is called.
--- kernel/kprobes.c | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-)
kernel/kprobes.c +11 -1
@@ -2235,6 +2235,8 @@ static struct notifier_block kprobe_module_nb = {extern unsigned long __start_kprobe_blacklist[];extern unsigned long __stop_kprobe_blacklist[]; +static bool run_kprobe_tests__initdata ; +static int __init init_kprobes (void ) {int i, err =0 ;
@@ -2286,11 +2288,19 @@ static int __init init_kprobes(void) kprobes_initialized = (err ==0 );if (!err) -init_test_probes (); + run_kprobe_tests = true;return err; }subsys_initcall (init_kprobes); +static int __init run_init_test_probes (void ) +{ +if (run_kprobe_tests) +init_test_probes (); +return 0 ; +} +module_init (run_init_test_probes); +#ifdef CONFIG_DEBUG_FS static void report_probe (struct seq_file *pi,struct kprobe *p,const char *sym,int offset,char *modname,struct kprobe *pp)
Signature · 1 line
2.20.1
Masami Hiramatsu
maintainerRe: [for-next][PATCH 12/16] kprobes: Initialize kprobes at postcore_initcall
In reply to Steven RostedtQuoted 23 lines · On Wed, 3 Jul 2019 10:25:04 -0400 Steven Rostedt <[email protected]> wrote:
Quoted 20 lines · On Wed, 3 Jul 2019 10:24:02 -0400 Steven Rostedt <[email protected]> wrote:
Quoted 6 lines · On Wed, 3 Jul 2019 15:08:32 +0100 Catalin Marinas <[email protected]>…
kernel/kprobes.c static int __init init_kprobes(void) · line 2299
Quoted 4 lines
kernel/kprobes.c +4
-0+static int __init run_init_test_probes (void ) +{ +if (run_kprobe_tests) +init_test_probes ();A return 0 here.
Will update (would have triggered a failure on my test suite anyway ;-)
Quoted 7 lines
kernel/kprobes.c static int __init init_kprobes(void) · line 2301
Quoted 3 lines
kernel/kprobes.c +2
-0+} +module_init (run_init_test_probes);This does the trick. I prefer your fix as it leaves the arch code unchanged. In case you need it:
Quoted 7 lines
Quoted 3 lines
Quoted 2 lines
Tested-by Catalin Marinas <[email protected]>Masami,
If you give me an Acked-by, I'll add it to my tree.
Sorry for late reply, but I want to keep the test running right after initialization as the first user of kprobes at that timing, since other user can start using kprobes right after init_kprobes(). So this issue must be fixed in moving the init_kprobes() itself right after arch_initcall() (and that is subsys_initcall)
Catalin, Mark, could you ensure the below patch can fix your issue?
https://lore.kernel.org/lkml/[email protected]/
And if so, Steve, could you push above one (which seems already in your tree) to next as a fix?
Thank you,
Signature · 1 line
Masami Hiramatsu <[email protected]>
Steven Rostedt
maintainerRe: [for-next][PATCH 12/16] kprobes: Initialize kprobes at postcore_initcall
Quoted 10 lines · On Tue, 9 Jul 2019 21:51:24 +0900 Masami Hiramatsu <[email protected]> wrote:
Quoted 3 lines
Masami,
If you give me an Acked-by, I'll add it to my tree.
Sorry for late reply, but I want to keep the test running right after initialization as the first user of kprobes at that timing, since other user can start using kprobes right after
init_kprobes(). So this issue must be fixed in moving theinit_kprobes()itself right afterarch_initcall()(and that issubsys_initcall)
Quoted 6 lines
Catalin, Mark, could you ensure the below patch can fix your issue?
https://lore.kernel.org/lkml/[email protected]/
And if so, Steve, could you push above one (which seems already in your tree) to next as a fix?
Bah, I forgot to push. I usually do that right after I send the series.
I just pushed to my for-next branch:
git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace.git
Can you see if that fixes the issue. If so, then we don't need to do anything.
Thanks!
-- Steve
Steven Rostedt
maintainerRe: [for-next][PATCH 12/16] kprobes: Initialize kprobes at postcore_initcall
In reply to Catalin MarinasQuoted 32 lines · On Wed, 3 Jul 2019 15:08:32 +0100 Catalin Marinas <[email protected]>…
Quoted 19 lines
-- Steve
kernel/kprobes.c +2
-0@@ -2235,6 +2235,8 @@ static struct notifier_block kprobe_module_nb = {extern unsigned long __start_kprobe_blacklist[];extern unsigned long __stop_kprobe_blacklist[]; +static bool run_kprobe_tests__initdata ; +static int __init init_kprobes (void ) {int i, err =0 ;@@ -2286,11 +2288,18 @@ static int __init init_kprobes(void) kprobes_initialized = (err ==0 );if (!err)kernel/kprobes.c static int __init init_kprobes(void) · line 2299
Quoted 10 lines
kernel/kprobes.c +5
-1-init_test_probes (); + run_kprobe_tests = true;return err; }subsys_initcall (init_kprobes); +static int __init run_init_test_probes (void ) +{ +if (run_kprobe_tests) +init_test_probes ();A return 0 here.
Quoted 5 lines
kernel/kprobes.c static int __init init_kprobes(void) · line 2301
Quoted 2 lines
kernel/kprobes.c +2
-0+} +module_init (run_init_test_probes);This does the trick. I prefer your fix as it leaves the arch code unchanged. In case you need it:
And I actually think yours is better for the opposite reason ;-)
I agree with Masami, that the selftest actually caught a bug here. I think the arch code may need to change as the purpose of Masami's changes was to enable kprobes earlier in boot. The selftest failing means that an early kprobe will fail too.
-- Steve
Quoted 5 lines
Tested-by Catalin Marinas <[email protected]>Thanks.
Catalin Marinas
maintainerRe: [for-next][PATCH 12/16] kprobes: Initialize kprobes at postcore_initcall
Hi Steve,
Quoted 38 lines · Steven Rostedt
Quoted 30 lines · On Wed, 3 Jul 2019 15:08:32 +0100 Catalin Marinas <[email protected]>…
Quoted 17 lines
kernel/kprobes.c +2
-0@@ -2235,6 +2235,8 @@ static struct notifier_block kprobe_module_nb = {extern unsigned long __start_kprobe_blacklist[];extern unsigned long __stop_kprobe_blacklist[]; +static bool run_kprobe_tests__initdata ; +static int __init init_kprobes (void ) {int i, err =0 ;@@ -2286,11 +2288,18 @@ static int __init init_kprobes(void) kprobes_initialized = (err ==0 );if (!err)kernel/kprobes.c static int __init init_kprobes(void) · line 2299
Quoted 10 lines
kernel/kprobes.c +5
-1-init_test_probes (); + run_kprobe_tests = true;return err; }subsys_initcall (init_kprobes); +static int __init run_init_test_probes (void ) +{ +if (run_kprobe_tests) +init_test_probes ();A return 0 here.
Quoted 5 lines
kernel/kprobes.c static int __init init_kprobes(void) · line 2301
Quoted 2 lines
kernel/kprobes.c +2
-0+} +module_init (run_init_test_probes);This does the trick. I prefer your fix as it leaves the arch code unchanged. In case you need it:
Quoted 6 lines
And I actually think yours is better for the opposite reason ;-)
I agree with Masami, that the selftest actually caught a bug here. I think the arch code may need to change as the purpose of Masami's changes was to enable kprobes earlier in boot. The selftest failing means that an early kprobe will fail too.
I just got back from holiday and catching up with emails. Do I still need to merge the arm64 fix making the debug initialisation a core_initcall()?
Can we actually get kprobes invoked before init_kprobes() has been called?
Thanks.
Signature · 1 line
Catalin
Steven Rostedt
maintainerRe: [for-next][PATCH 12/16] kprobes: Initialize kprobes at postcore_initcall
Quoted 11 lines · On Mon, 22 Jul 2019 13:42:02 +0100 Catalin Marinas <[email protected]>…
Quoted 4 lines
I agree with Masami, that the selftest actually caught a bug here. I think the arch code may need to change as the purpose of Masami's changes was to enable kprobes earlier in boot. The selftest failing means that an early kprobe will fail too.
I just got back from holiday and catching up with emails. Do I still need to merge the arm64 fix making the debug initialisation a
core_initcall()?Can we actually get kprobes invoked before
init_kprobes()has been called?
Bah, I can't remember everything that we discussed. I thought there was some more patches that obsoleted my work around. Everything has been pushed to Linus, can you see if the upstream still has issues for you?
Thanks!
-- Steve
Catalin Marinas
maintainerRe: [for-next][PATCH 12/16] kprobes: Initialize kprobes at postcore_initcall
Quoted 12 lines · Steven Rostedt
Quoted 9 lines · On Mon, 22 Jul 2019 13:42:02 +0100 Catalin Marinas <[email protected]>…
Quoted 4 lines
I agree with Masami, that the selftest actually caught a bug here. I think the arch code may need to change as the purpose of Masami's changes was to enable kprobes earlier in boot. The selftest failing means that an early kprobe will fail too.
I just got back from holiday and catching up with emails. Do I still need to merge the arm64 fix making the debug initialisation a
core_initcall()?
Quoted 6 lines
Quoted 2 lines
Can we actually get kprobes invoked before
init_kprobes()has been called?Bah, I can't remember everything that we discussed. I thought there was some more patches that obsoleted my work around. Everything has been pushed to Linus, can you see if the upstream still has issues for you?
Upstream is fine since you reverted the postcore_initcall(init_kprobes) change and used subsys_initcall() instead. So I don't think we need any arch changes.
Signature · 1 line
Catalin
Masami Hiramatsu
maintainerRe: [for-next][PATCH 12/16] kprobes: Initialize kprobes at postcore_initcall
In reply to Steven RostedtHi Steve,
Quoted 61 lines · On Wed, 3 Jul 2019 10:02:05 -0400 Steven Rostedt <[email protected]> wrote:
Quoted 18 lines · On Tue, 2 Jul 2019 17:50:09 +0100 Mark Rutland <[email protected]> wrote:
Quoted 17 lines · Steven Rostedt
From: Masami Hiramatsu <[email protected]>
Initialize kprobes at
postcore_initcalllevel instead ofmodule_initsince kprobes is not a module, and it depends on only subsystems initialized incore_initcall.
This will allow ftrace kprobe event to add new events when it is initializing because ftrace kprobe event is initialized at later initcall level.Signed-off-by Masami Hiramatsu <[email protected]>Signed-off-by Steven Rostedt (VMware) <[email protected]>--- kernel/kprobes.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)Quoted 11 lines
kernel/kprobes.c static int __init init_kprobes(void) · line 2292
Quoted 9 lines
kernel/kprobes.c +1
-0@@ -2289,6 +2289,7 @@ static int __init init_kprobes(void)init_test_probes ();return err; } +postcore_initcall (init_kprobes);As a heads-up, this is causing boot-time failures on arm64.
Thanks for the report.
Quoted 7 lines
On arm64 kprobes depends on the BRK handler we register in
debug_traps_init(), which is anarch_initcall.As of this change,
init_krprobes()callsinit_test_probes()before that's registered, so we end up hitting a BRK before we can handle it.Would something like this help?
-- Steve
kernel/kprobes.c +2
-0@@ -2235,6 +2235,8 @@ static struct notifier_block kprobe_module_nb = {extern unsigned long __start_kprobe_blacklist[];extern unsigned long __stop_kprobe_blacklist[]; +static bool run_kprobe_tests__initdata ; +static int __init init_kprobes (void ) {int i, err =0 ;
kernel/kprobes.c static int __init init_kprobes(void) · line 2294
Quoted 8 lines
kernel/kprobes.c +1
-1@@ -2286,11 +2288,18 @@ static int __init init_kprobes(void) kprobes_initialized = (err ==0 );if (!err) -init_test_probes (); + run_kprobe_tests = true;return err; }subsys_initcall (init_kprobes);
Just out of curious, if arm64's handler code initialized in arch_initcall, why this subsys_initcall() function causes a problem?
This is actually related to my boot-time tracing series, so I would like fix this issue without this patch.
Thank you,
Quoted 12 lines
kernel/kprobes.c +7
-0+static int __init run_init_test_probes (void ) +{ +if (run_kprobe_tests) +init_test_probes (); +} +module_init (run_init_test_probes); +#ifdef CONFIG_DEBUG_FS static void report_probe (struct seq_file *pi,struct kprobe *p,const char *sym,int offset,char *modname,struct kprobe *pp)
Signature · 1 line
Masami Hiramatsu <[email protected]>
Catalin Marinas
maintainerRe: [for-next][PATCH 12/16] kprobes: Initialize kprobes at postcore_initcall
Quoted 20 lines · Masami Hiramatsu
Quoted 18 lines · On Wed, 3 Jul 2019 10:02:05 -0400 Steven Rostedt <[email protected]> wrote:
Quoted 16 lines · On Tue, 2 Jul 2019 17:50:09 +0100 Mark Rutland <[email protected]> wrote:
Quoted 15 lines · Steven Rostedt
Signed-off-by Masami Hiramatsu <[email protected]>Signed-off-by Steven Rostedt (VMware) <[email protected]>--- kernel/kprobes.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)kernel/kprobes.c +1
-0@@ -2289,6 +2289,7 @@ static int __init init_kprobes(void)init_test_probes ();return err; } +postcore_initcall (init_kprobes);
[...]
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
On arm64 kprobes depends on the BRK handler we register in
debug_traps_init(), which is anarch_initcall.As of this change,
init_krprobes()callsinit_test_probes()before that's registered, so we end up hitting a BRK before we can handle it.
[...]
Quoted 16 lines
Quoted 16 lines
kernel/kprobes.c +2
-0@@ -2235,6 +2235,8 @@ static struct notifier_block kprobe_module_nb = {extern unsigned long __start_kprobe_blacklist[];extern unsigned long __stop_kprobe_blacklist[]; +static bool run_kprobe_tests__initdata ; +static int __init init_kprobes (void ) {int i, err =0 ;@@ -2286,11 +2288,18 @@ static int __init init_kprobes(void) kprobes_initialized = (err ==0 );
Quoted 9 lines
kernel/kprobes.c static int __init init_kprobes(void) · line 2294
Quoted 6 lines
kernel/kprobes.c +1
-1if (!err) -init_test_probes (); + run_kprobe_tests = true;return err; }subsys_initcall (init_kprobes);Just out of curious, if arm64's handler code initialized in
arch_initcall, why thissubsys_initcall()function causes a problem?
It doesn't but patch 12/16 in this series changes it to postcore_initcall().
Signature · 1 line
Catalin
Steven Rostedt
maintainerPATCH 13/16 tracing/kprobe: Add kprobe_event= boot parameter
In reply to Steven RostedtFrom: Masami Hiramatsu <[email protected]>
Add kprobe_event= boot parameter to define kprobe events at boot time.
The definition syntax is similar to tracefs/kprobe_events interface, but use ',' and ';' instead of ' ' and '\n' respectively. e.g.
kprobe_event=p,vfs_read,$arg1,$arg2
This puts a probe on vfs_read with argument1 and 2, and enable the new event.
--- .../admin-guide/kernel-parameters.txt | 13 +++++ Documentation/trace/kprobetrace.rst | 14 +++++ kernel/trace/trace_kprobe.c | 54 +++++++++++++++++++ 3 files changed, 81 insertions(+)
Documentation/admin-guide/kernel-parameters.txt +13 -0
@@ -2007,6 +2007,19 @@ Built with CONFIG_DEBUG_KMEMLEAK_DEFAULT_OFF=y, the default is off. + kprobe_event=[probe-list] + [FTRACE] Add kprobe events and enable at boot time. + The probe-list is a semicolon delimited list of probe + definitions. Each definition is same as kprobe_events + interface, but the parameters are comma delimited. + For example, to add a kprobe event on vfs_read with + arg1 and arg2, add to the command line; + + kprobe_event=p,vfs_read,$arg1,$arg2 + + See also Documentation/trace/kprobetrace.rst "Kernel + Boot Parameter" section. + kpti= [ARM64] Control page table isolation of user and kernel address spaces. Default: enabled on cores which need mitigation.
Documentation/trace/kprobetrace.rst +14 -0
@@ -146,6 +146,20 @@ You can check the total number of probe hits and probe miss-hits via The first column is event name, the second is the number of probe hits, the third is the number of probe miss-hits. +Kernel Boot Parameter +--------------------- +You can add and enable new kprobe events when booting up the kernel by +"kprobe_event=" parameter. The parameter accepts a semicolon-delimited +kprobe events, which format is similar to the kprobe_events. +The difference is that the probe definition parameters are comma-delimited +instead of space. For example, adding myprobe event on do_sys_open like below + + p:myprobe do_sys_open dfd=%ax filename=%dx flags=%cx mode=+4($stack) + +should be below for kernel boot parameter (just replace spaces with comma) + + p:myprobe,do_sys_open,dfd=%ax,filename=%dx,flags=%cx,mode=+4($stack) + Usage examples --------------
kernel/trace/trace_kprobe.c +54 -0
78 lines not on this page · raw message
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 14/16 tracing: Make a separate config for trace event self tests
In reply to Steven RostedtFrom: "Steven Rostedt (VMware)" <[email protected]>
The trace event self tests enable loop through *all* events, enables each one, one at a time, runs some code to trigger various events (not necessarily the same events), and checks if anything went wrong. The issue is that trace events are usually the least likely start up test to cause a problem, but they take the longest to run (because there are so many events). When one of the other tests trigger a bug, the trace event start up tests causes the bisect to take much longer, because it takes 10s of seconds to get through the trace event tests.
By making them a separate config (even though they are enabled by default if start up tests are set), it is possible to turn them off and still run the other tracing start up tests much quicker.
--- kernel/trace/Kconfig | 12 +++++++++++- kernel/trace/trace_events.c | 2 +- 2 files changed, 12 insertions(+), 2 deletions(-)
kernel/trace/Kconfig +11 -1
@@ -596,9 +596,19 @@ config FTRACE_STARTUP_TEST functioning properly. It will do tests on all the configured tracers of ftrace. +config EVENT_TRACE_STARTUP_TEST + bool "Run selftest on trace events" + depends on FTRACE_STARTUP_TEST + default y + help + This option performs a test on all trace events in the system. + It basically just enables each event and runs some code that + will trigger events (not necessarily the event it enables) + This may take some time run as there are a lot of events. + config EVENT_TRACE_TEST_SYSCALLS bool "Run selftest on syscall events" - depends on FTRACE_STARTUP_TEST + depends on EVENT_TRACE_STARTUP_TEST help This option will also enable testing every syscall event. It only enables the event and disables it and runs various loads
kernel/trace/trace_events.c +1 -1
@@ -3190,7 +3190,7 @@ void __init trace_event_init(void)event_trace_enable (); } -#ifdef CONFIG_FTRACE_STARTUP_TEST +#ifdef CONFIG_EVENT_TRACE_STARTUP_TEST static DEFINE_SPINLOCK (test_spinlock);static DEFINE_SPINLOCK (test_spinlock_irq);
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 15/16 tracing/kprobe: Do not run kprobe boot tests if kprobe_event is on cmdline
In reply to Steven RostedtFrom: "Steven Rostedt (VMware)" <[email protected]>
When having kprobe trace event start up tests enabled and adding a kprobe_event on the kernel command line, it produced the following:
trace_kprobe: Testing kprobe tracing:
WARNING: CPU: 5 PID: 1 at kernel/trace/trace_kprobe.c:1724 kprobe_trace_self_tests_init+0x32d/0x36b Modules linked in: CPU: 5 PID: 1 Comm: swapper/0 Not tainted 5.2.0-rc1-test+ #249 Hardware name: Hewlett-Packard HP Compaq Pro 6300 SFF/339A, BIOS K01 v03.03 07/14/2016 RIP: 0010:kprobe_trace_self_tests_init+0x32d/0x36b Code: b7 e8 4f 8d a2 fe 85 c0 74 10 0f 0b 48 c7 c7 c8 1b 0d b7 ff c3 e8 19 af 99 fe 48 c7 c7 40 93 27 b7 e8 7f 1a a5 fe 85 c0 74 10 <0f> 0b 48 c7 c7 f8 1b 0d b7 ff c3 e8 f9 ae
9 a0 fe 85
RSP: 0018:ffffb36e40653e08 EFLAGS: 00010286
RAX: 00000000fffffff0 RBX: 0000000000000000 RCX: ffffb36e40653d5c
RDX: 0000000000000000 RSI: ffffffffb72776e0 RDI: 0000000000000246
RBP: ffff98414fe58ff8 R08: 0000000000000000 R09: 0000000000000000
R10: 0000000000000000 R11: ffff98415d8aa940 R12: 0000000000000000
R13: ffffffffb737c1b0 R14: 0000000000000000 R15: 0000000000000000
FS: 0000000000000000(0000) GS:ffff98415ea80000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00007f959ce741b8 CR3: 000000011a210002 CR4: 00000000001606e0
Call Trace: ? init_kprobe_trace+0x19e/0x19e ? do_early_param+0x8e/0x8e do_one_initcall+0x6f/0x2b4 ? do_early_param+0x8e/0x8e kernel_init_freeable+0x21d/0x2c6 ? rest_init+0x146/0x146 kernel_init+0xa/0x10a ret_from_fork+0x3a/0x50 ---[ end trace 488430c083a4c956 ]---
As with the trace events, if a trace event is set on the kernel command line, the trace events start up tests are suspended. The kprobe start up tests should do the same when a kprobe is enabled on the kernel command line.
--- kernel/trace/trace_kprobe.c | 8 ++++++++ 1 file changed, 8 insertions(+)
kernel/trace/trace_kprobe.c +8 -0
@@ -25,6 +25,7 @@/* Kprobe early definition from command line */ static char kprobe_boot_events_buf[COMMAND_LINE_SIZE ]__initdata ; +static bool kprobe_boot_events_enabled__initdata ;static int __init set_kprobe_boot_events (char *str) {
@@ -1538,6 +1539,8 @@ static __init void setup_boot_kprobe_events(void) ret =trace_run_command (cmd, create_or_delete_trace_kprobe);if (ret)pr_warn ("Failed to add event(%d): %s\n" , ret, cmd); +else + kprobe_boot_events_enabled = true; cmd = p; }
@@ -1611,6 +1614,11 @@ static __init int kprobe_trace_self_tests_init(void)if (tracing_is_disabled ())return -ENODEV ; +if (kprobe_boot_events_enabled) { +pr_info ("Skipping kprobe tests due to kprobe_event on cmdline\n" ); +return 0 ; + } + target = kprobe_trace_selftest_target;pr_info ("Testing kprobe tracing: " );
Signature · 1 line
2.20.1
Steven Rostedt
maintainerPATCH 16/16 ftrace: Enable trampoline when rec count returns back to one
In reply to Steven RostedtFrom: Cheng Jian <[email protected]>
Custom trampolines can only be enabled if there is only a single ops attached to it. If there's only a single callback registered to a function, and the ops has a trampoline registered for it, then we can call the trampoline directly. This is very useful for improving the performance of ftrace and livepatch.
If more than one callback is registered to a function, the general trampoline is used, and the custom trampoline is not restored back to the direct call even if all the other callbacks were unregistered and we are back to one callback for the function.
To fix this, set FTRACE_FL_TRAMP flag if rec count is decremented to one, and the ops that left has a trampoline.
Testing After this patch :
insmod livepatch_unshare_files.ko
cat /sys/kernel/debug/tracing/enabled_functions
unshare_files (1) R I tramp: 0xffffffffc0000000(klp_ftrace_handler+0x0/0xa0) ->ftrace_ops_assist_func+0x0/0xf0
echo unshare_files > /sys/kernel/debug/tracing/set_ftrace_filter echo function > /sys/kernel/debug/tracing/current_tracer cat /sys/kernel/debug/tracing/enabled_functions
unshare_files (2) R I ->ftrace_ops_list_func+0x0/0x150
echo nop > /sys/kernel/debug/tracing/current_tracer cat /sys/kernel/debug/tracing/enabled_functions
unshare_files (1) R I tramp: 0xffffffffc0000000(klp_ftrace_handler+0x0/0xa0) ->ftrace_ops_assist_func+0x0/0xf0
--- kernel/trace/ftrace.c | 28 +++++++++++++++------------- 1 file changed, 15 insertions(+), 13 deletions(-)
kernel/trace/ftrace.c +15 -13
@@ -1622,6 +1622,11 @@ static bool test_rec_ops_needs_regs(struct dyn_ftrace *rec)return keep_regs; } +static struct ftrace_ops * +ftrace_find_tramp_ops_any (struct dyn_ftrace *rec); +static struct ftrace_ops * +ftrace_find_tramp_ops_next (struct dyn_ftrace *rec,struct ftrace_ops *ops); +static bool __ftrace_hash_rec_update (struct ftrace_ops *ops,int filter_hash,bool inc)
@@ -1750,15 +1755,17 @@ static bool __ftrace_hash_rec_update(struct ftrace_ops *ops, }/* -* If the rec had TRAMP enabled, then it needs to -* be cleared. As TRAMP can only be enabled iff -* there is only a single ops attached to it. -* In otherwords, always disable it on decrementing. -* In the future, we may set it if rec count is -* decremented to one, and the ops that is left -* has a trampoline. +* The TRAMP needs to be set only if rec count +* is decremented to one, and the ops that is +* left has a trampoline. As TRAMP can only be +* enabled if there is only a single ops attached +* to it. */ - rec->flags &= ~FTRACE_FL_TRAMP ; +if (ftrace_rec_count (rec) ==1 && +ftrace_find_tramp_ops_any (rec)) + rec->flags |=FTRACE_FL_TRAMP ; +else + rec->flags &= ~FTRACE_FL_TRAMP ;/* * flags will be cleared in ftrace_check_record()
@@ -1951,11 +1958,6 @@ static void print_ip_ins(const char *fmt, const unsigned char *p)printk (KERN_CONT "%s%02x" , i ?":" :"" , p[i]); } -static struct ftrace_ops * -ftrace_find_tramp_ops_any (struct dyn_ftrace *rec); -static struct ftrace_ops * -ftrace_find_tramp_ops_next (struct dyn_ftrace *rec,struct ftrace_ops *ops); -enum ftrace_bug_type ftrace_bug_type;const void *ftrace_expected;
Signature · 1 line
2.20.1