tracing/probes: Add more typecast features
Subsystems (3)
Masami Hiramatsu (Google)
maintainerv10 cover tracing/probes: Add more typecast features
Hi,
Here is the 10th version of series to introduce more typecast features to probe events. The previous version is here:
https://lore.kernel.org/all/178235074943.766912.25308838431649508.stgit@devnote2/
In this version, I prohibited percpu access method on eprobes too [8/9], and update a test case to check it[9/9].
This series extends BTF typecast feature and add more options:
1. Expanding BTF typecast to kprobe and fprobe.
(currently only function entry/exit)
2. Introduce container_of like typecast. This adds a "assigned member" option to the typecast.
(STRUCT,MEMBER)VAR->ANOTHER_MEMBER
This casts VAR to STRUCT type but the VAR is as the address of STRUCT.MEMBER. In C, it is:
container_of(VAR, STRUCT, MEMBER)->ANOTHER_MEMBER
3. Support nested typecast, e.g.
(STRUCT)((STRUCT2)VAR->MEMBER2)->MEMBER
the nest level must be smaller than 3.
4. Add $current variable to point "current" task_struct. This is useful with typecast, e.g.
(task_struct)$current->pid
5. per-cpu dereference support.
Intrdouce this_cpu_read(VAR) and this_cpu_ptr(VAR) to access per-cpu data on the current CPU (accessing other CPU data is not stable, because it can be changed.)
You can access the member of per-cpu data structure using typecast like:
(STRUCT)this_cpu_ptr(VAR)->MEMBER
6. Support event fields without $ prefix on eprobes.
Now eprobe events can access its event fields.
And added fetcharg dump feature (for debug) and updated test scripts to test part of them.
Thanks,
---
base-commit: c69b5f959286395e94c237ce6d7d4970bad7f6e3
Masami Hiramatsu (Google) (9):
tracing/probes: Allow eprobe to use variable without $ prefix tracing/probes: Support dumping fetcharg program for debugging dynamic events tracing/probes: Support typecast for various probe events tracing/probes: Support nested typecast
tracing/probes: Type casting always involves nested calls tracing/probes: Support field specifier option for typecast tracing/probes: Add $current variable support
tracing/probes: Add this_cpu_read() and this_cpu_ptr() dereference method to fetcharg tracing/probes: Add a new testcase for BTF typecasts
Documentation/trace/eprobetrace.rst | 9 Documentation/trace/fprobetrace.rst | 10 Documentation/trace/kprobetrace.rst | 11 kernel/trace/Kconfig | 12 kernel/trace/trace.c | 8 kernel/trace/trace_eprobe.c | 2 kernel/trace/trace_fprobe.c | 2 kernel/trace/trace_kprobe.c | 2 kernel/trace/trace_probe.c | 583 ++++++++++++++++---- kernel/trace/trace_probe.h | 100 ++- kernel/trace/trace_probe_tmpl.h | 25 + kernel/trace/trace_uprobe.c | 3 samples/trace_events/trace-events-sample.c | 40 + samples/trace_events/trace-events-sample.h | 34 + .../ftrace/test.d/dynevent/btf_probe_event.tc | 51 ++ .../test.d/dynevent/btf_typecast_accepted.tc | 107 ++++ .../test.d/dynevent/eprobes_syntax_errors.tc | 12 .../ftrace/test.d/dynevent/fprobe_syntax_errors.tc | 12 .../ftrace/test.d/kprobe/kprobe_syntax_errors.tc | 12 .../ftrace/test.d/kprobe/uprobe_syntax_errors.tc | 5 20 files changed, 886 insertions(+), 154 deletions(-) create mode 100644 tools/testing/selftests/ftrace/test.d/dynevent/btf_probe_event.tc create mode 100644 tools/testing/selftests/ftrace/test.d/dynevent/btf_typecast_accepted.tc
--
Masami Hiramatsu (Google) <[email protected]>
Masami Hiramatsu (Google)
maintainerPATCH v10 1/9 tracing/probes: Allow eprobe to use variable without $ prefix
From: Masami Hiramatsu (Google) <[email protected]>
The commit 69efd863a785 ("tracing/eprobes: Allow use of BTF names to dereference pointers") allows eprobe to use event field without "$" prefix when it is used with typecast, it is natual to allow it without typecast.
---
Changes in v8:
- Newly added.
--- kernel/trace/trace_probe.c | 12 +++++++++++- kernel/trace/trace_probe.h | 1 + .../test.d/dynevent/eprobes_syntax_errors.tc | 3 +-- 3 files changed, 13 insertions(+), 3 deletions(-)
kernel/trace/trace_probe.c +11 -1
@@ -1341,7 +1341,17 @@ parse_probe_arg(char *arg, const struct fetch_type *type, ret =handle_typecast (arg, pcode, end, ctx);break ;default : -if (isalpha (arg[0 ]) || arg[0 ] =='_' ) {/* BTF variable */ +if (isalpha (arg[0 ]) || arg[0 ] =='_' ) { +/* BTF variable or event field*/ +if (ctx->flags &TPARG_FL_TEVENT ) { + ret =parse_trace_event (arg, *pcode, ctx); +if (ret <0 ) { +trace_probe_log_err (ctx->offset, +NO_EVENT_FIELD ); +return -EINVAL ; + } +break ; + }if (!tparg_is_function_entry (ctx->flags) && !tparg_is_function_return (ctx->flags)) {trace_probe_log_err (ctx->offset,NOSUP_BTFARG );
kernel/trace/trace_probe.h +1 -0
@@ -559,6 +559,7 @@ extern int traceprobe_define_arg_fields(struct trace_event_call *event_call,C (NO_PTR_STRCT ,"This is not a pointer to union/structure." ), \C (NOSUP_DAT_ARG ,"Non pointer structure/union argument is not supported." ),\C (BAD_HYPHEN ,"Failed to parse single hyphen. Forgot '>'?" ), \ +C (NO_EVENT_FIELD ,"This event field is not found." ), \C (NO_BTF_FIELD ,"This field is not found." ), \C (BAD_BTF_TID ,"Failed to get BTF type info." ),\ C(BAD_TYPE4STR, "This type does not fit for string."),\
tools/testing/selftests/ftrace/test.d/dynevent/eprobes_syntax_errors.tc +1 -2
@@ -10,7 +10,7 @@ check_error() { # command-with-error-pos-by-^ check_error 'e ^a.' # NO_EVENT_INFO check_error 'e ^.b' # NO_EVENT_INFO check_error 'e ^a.b' # BAD_ATTACH_EVENT -check_error 'e syscalls/sys_enter_openat ^foo' # BAD_ATTACH_ARG +check_error 'e syscalls/sys_enter_openat ^foo' # NO_EVENT_FIELD check_error 'e:^/bar syscalls/sys_enter_openat' # NO_GROUP_NAME check_error 'e:^12345678901234567890123456789012345678901234567890123456789012345/bar syscalls/sys_enter_openat' # GROUP_TOO_LONG
@@ -19,7 +19,6 @@ check_error 'e:^ syscalls/sys_enter_openat' # NO_EVENT_NAME check_error 'e:foo/^12345678901234567890123456789012345678901234567890123456789012345 syscalls/sys_enter_openat' # EVENT_TOO_LONG check_error 'e:foo/^bar.1 syscalls/sys_enter_openat' # BAD_EVENT_NAME -check_error 'e:foo/bar syscalls/sys_enter_openat arg=^dfd' # BAD_FETCH_ARG check_error 'e:foo/bar syscalls/sys_enter_openat arg=^$foo' # BAD_ATTACH_ARG if grep -q '<attached-group>\.<attached-event>.*\[if <filter>\]' README; then
Masami Hiramatsu (Google)
maintainerPATCH v10 2/9 tracing/probes: Support dumping fetcharg program for debugging dynamic events
In reply to Masami Hiramatsu (Google)From: Masami Hiramatsu (Google) <[email protected]>
For debugging probe events, it is helpful to verify the compiled fetch instructions for each probe argument. This introduces a new kernel config CONFIG_PROBE_EVENTS_DUMP_FETCHARG to decode the instruction sequence of each argument and display it under a commented line starting with '#' immediately following the dynamic event definition (such as in dynamic_events, kprobe_events, uprobe_events, etc.).
For example:
/sys/kernel/tracing # cat dynamic_events p:kprobes/p_vfs_read_0 vfs_read arg1=+0(file):ustring arg2=%ax:x16 # arg1: ARG(0) -> ST_USTRING(offset=0,size=4) -> END
# arg2: REG(80) -> ST_RAW(size=2) -> END
---
Changes in v8:
- State this feature is only for debugging probe events.
- Fix dependency list after description in Kconfig.
Changes in v7:
- Show trace event field name for FETCH_OP_TP_ARG.
- Show immediate string value for FETCH_OP_IMMSTR.
- Fix style issues warned by checkpatch.pl.
Changes in v6:
- Newly added.
--- kernel/trace/Kconfig | 12 +++++ kernel/trace/trace_eprobe.c | 2 + kernel/trace/trace_fprobe.c | 2 + kernel/trace/trace_kprobe.c | 2 + kernel/trace/trace_probe.c | 96 +++++++++++++++++++++++++++++++++++++++++++ kernel/trace/trace_probe.h | 79 +++++++++++++++++++++-------------- kernel/trace/trace_uprobe.c | 3 + 7 files changed, 164 insertions(+), 32 deletions(-)
kernel/trace/Kconfig +12 -0
@@ -779,6 +779,18 @@ config PROBE_EVENTS_BTF_ARGS kernel function entry or a tracepoint. This is available only if BTF (BPF Type Format) support is enabled. +config PROBE_EVENTS_DUMP_FETCHARG + bool "Dump of dynamic probe event fetch-arguments" + depends on PROBE_EVENTS + default n + help + This shows the dump of fetch-arguments of dynamic probe events + alongside their event definitions in the dynamic_events file + as comment lines. This is useful to debug the probe events. + Since this exposes the raw values in the dynamic_events file, + it might be a security risk. Only enable it if you need to debug + probe events themselves. + config KPROBE_EVENTS depends on KPROBES depends on HAVE_REGS_AND_STACK_ACCESS_API
kernel/trace/trace_eprobe.c +2 -0
@@ -87,6 +87,8 @@ static int eprobe_dyn_event_show(struct seq_file *m, struct dyn_event *ev)seq_printf (m," %s=%s" , ep->tp.args[i].name, ep->tp.args[i].comm);seq_putc (m,'\n' ); +trace_probe_dump_args (m, &ep->tp); +return 0 ; }
kernel/trace/trace_fprobe.c +2 -0
@@ -1449,6 +1449,8 @@ static int trace_fprobe_show(struct seq_file *m, struct dyn_event *ev)seq_printf (m," %s=%s" , tf->tp.args[i].name, tf->tp.args[i].comm);seq_putc (m,'\n' ); +trace_probe_dump_args (m, &tf->tp); +return 0 ; }
kernel/trace/trace_kprobe.c +2 -0
@@ -1320,6 +1320,8 @@ static int trace_kprobe_show(struct seq_file *m, struct dyn_event *ev)seq_printf (m," %s=%s" , tk->tp.args[i].name, tk->tp.args[i].comm);seq_putc (m,'\n' ); +trace_probe_dump_args (m, &tk->tp); +return 0 ; }
kernel/trace/trace_probe.c +96 -0
99 lines not on this page · raw message
kernel/trace/trace_probe.h +47 -32
91 lines not on this page · raw message
kernel/trace/trace_uprobe.c +3 -0
@@ -765,6 +765,9 @@ static int trace_uprobe_show(struct seq_file *m, struct dyn_event *ev)seq_printf (m," %s=%s" , tu->tp.args[i].name, tu->tp.args[i].comm);seq_putc (m,'\n' ); + +trace_probe_dump_args (m, &tu->tp); +return 0 ; }
Masami Hiramatsu (Google)
maintainerPATCH v10 3/9 tracing/probes: Support typecast for various probe events
In reply to Masami Hiramatsu (Google)From: Masami Hiramatsu (Google) <[email protected]>
Support BTF typecast feature on other probe events, but only if it is kernel function entry or return, and must use function parameter name or $retval. This means you can do:
(STRUCT)PARAM->MEMBER
Note: you can not use other variables like $stackN, %reg etc. That needs nesting support.
To support other probe events, we just need to use last_struct type when we find a function parameter in parse_btf_arg().
This also updates <tracefs>/README file to show struct typecast.
---
Changes in v5:
- Add comments about $retval with typecast.
- Even if the type of retvalue is not known, if user specifies typecast, use it for its type.
Changes in v3:
- Clarify the limitation.
Changes in v2:
- Fix to re-enable typecast on eprobe.
--- Documentation/trace/fprobetrace.rst | 3 +++ Documentation/trace/kprobetrace.rst | 4 ++++ kernel/trace/trace.c | 2 +- kernel/trace/trace_probe.c | 23 +++++++++++++++++------ kernel/trace/trace_probe.h | 5 +++++ 5 files changed, 30 insertions(+), 7 deletions(-)
Documentation/trace/fprobetrace.rst +3 -0
@@ -57,6 +57,9 @@ Synopsis of fprobe-events (u8/u16/u32/u64/s8/s16/s32/s64), hexadecimal types (x8/x16/x32/x64), "char", "string", "ustring", "symbol", "symstr" and bitfield are supported. + (STRUCT)FIELD->MEMBER[->MEMBER] : If BTF is supported, typecast FIELD to + a pointer to STRUCT and then derference the pointer defined by + ->MEMBER. (\*1) This is available only when BTF is enabled. (\*2) only for the probe on function entry (offs == 0). Note, this argument access
Documentation/trace/kprobetrace.rst +4 -0
@@ -61,6 +61,10 @@ Synopsis of kprobe_events (x8/x16/x32/x64), VFS layer common type(%pd/%pD), "char", "string", "ustring", "symbol", "symstr" and bitfield are supported. + (STRUCT)FIELD->MEMBER[->MEMBER] : If BTF is supported, typecast FIELD to + a pointer to STRUCT and then derference the pointer defined by + ->MEMBER. Note that this is available only when the probe is + on function entry. (\*1) only for the probe on function entry (offs == 0). Note, this argument access is best effort, because depending on the argument type, it may be passed on
kernel/trace/trace.c +1 -1
@@ -4322,7 +4322,7 @@ static const char readme_msg[] =#ifdef CONFIG_HAVE_FUNCTION_ARG_ACCESS_API "\t $stack<index>, $stack, $retval, $comm, $arg<N>,\n" #ifdef CONFIG_PROBE_EVENTS_BTF_ARGS - "\t <argname>[->field[->field|.field...]],\n" + "\t [(structname)]<argname>[->field[->field|.field...]],\n"#endif #else "\t $stack<index>, $stack, $retval, $comm,\n"
kernel/trace/trace_probe.c +17 -6
@@ -699,7 +699,7 @@ static int parse_btf_arg(char *varname,if (ctx->flags &TPARG_FL_RETURN && !strcmp (varname,"$retval" )) { code->op =FETCH_OP_RETVAL ; -/* Check whether the function return type is not void */ +/* Check whether the function return type is not void, even with typecast. */ if (query_btf_context (ctx) ==0 ) {if (ctx->proto->type ==0 ) {trace_probe_log_err (ctx->offset,NO_RETVAL );
@@ -708,6 +708,13 @@ static int parse_btf_arg(char *varname, tid = ctx->proto->type; goto found; } +/* +* Even if we can not find appropriate BTF info, we can still access +* the field via typecast. +*/ +if (ctx->struct_btf) + goto found; +if (field) {trace_probe_log_err (ctx->offset + field - varname,NO_BTF_ENTRY );
@@ -752,7 +759,10 @@ static int parse_btf_arg(char *varname,return -ENOENT ; found: - type =btf_type_skip_modifiers (ctx->btf, tid,NULL ); +if (ctx->struct_btf) + type = ctx->last_struct; +else + type =btf_type_skip_modifiers (ctx->btf, tid,NULL ); found_type:if (!type) {trace_probe_log_err (ctx->offset,BAD_BTF_TID );
@@ -829,10 +839,11 @@ static int handle_typecast(char *arg, struct fetch_insn **pcode,char *tmp;int ret; -/* Currently this only works for eprobes */ -if (!(ctx->flags &TPARG_FL_TEVENT )) { -trace_probe_log_err (ctx->offset,TYPECAST_NOT_EVENT ); -return -EINVAL ; +if (!(tparg_is_event_probe (ctx->flags) || +tparg_is_function_entry (ctx->flags) || +tparg_is_function_return (ctx->flags))) { +trace_probe_log_err (ctx->offset,NOSUP_BTFARG ); +return -EOPNOTSUPP ; } tmp =strchr (arg,')' );
kernel/trace/trace_probe.h +5 -0
@@ -429,6 +429,11 @@ static inline bool tparg_is_function_return(unsigned int flags)return (flags &TPARG_FL_LOC_MASK ) == (TPARG_FL_KERNEL |TPARG_FL_RETURN ); } +static inline bool tparg_is_event_probe (unsigned int flags) +{ +return !!(flags &TPARG_FL_TEVENT ); +} +struct traceprobe_parse_context {struct trace_event_call *event;/* BTF related parameters */
Masami Hiramatsu (Google)
maintainerPATCH v10 4/9 tracing/probes: Support nested typecast
In reply to Masami Hiramatsu (Google)From: Masami Hiramatsu (Google) <[email protected]>
When we hit an open parenthesis right after typecast closing parenthesis, it means we have nested typecast. This allows us to typecast a generic data member in a structure to a pointer to another structure.
For example, to cast a DATA_MEMBER of VAR structure to STRUCT pointer and get MEMBER value.
(STRUCT)(VAR->DATA_MEMBER)->MEMBER
Also, we can nest typecast.
(STRUCT1)((STRUCT2)$ARG->FIELD2)->FIELD1
Currently the max nest level is limited to 3.
This also allows user to use typecasting for registers or stacks on kprobe events. e.g.
(STRUCT)(%ax)->MEMBER
(STRUCT)($stack0)->MEMBER
---
Changes in v6:
- Add a WARN_ON_ONCE check for leaking nested_level (it must not happen.)
Changes in v4:
- Use orig_offset for reporting NO_PTR_STRCT error.
Changes in v2:
- Fix to skip "->" after closing parenthetsis.
--- Documentation/trace/eprobetrace.rst | 2 + Documentation/trace/fprobetrace.rst | 2 + Documentation/trace/kprobetrace.rst | 2 + kernel/trace/trace.c | 1 kernel/trace/trace_probe.c | 81 ++++++++++++++++++++++++++++++++--- kernel/trace/trace_probe.h | 7 +++ 6 files changed, 86 insertions(+), 9 deletions(-)
Documentation/trace/eprobetrace.rst +2 -0
@@ -50,6 +50,8 @@ Synopsis of eprobe_events a pointer to STRUCT and then derference the pointer defined by ->MEMBER. Note that when this is used, the FIELD name does not need to be prefixed with a '$'. + (STRUCT)(FETCHARG)->MEMBER[->MEMBER] : typecast can nest, so the above can + also be used with another FETCHARG instead of FIELD. Types -----
Documentation/trace/fprobetrace.rst +2 -0
@@ -60,6 +60,8 @@ Synopsis of fprobe-events (STRUCT)FIELD->MEMBER[->MEMBER] : If BTF is supported, typecast FIELD to a pointer to STRUCT and then derference the pointer defined by ->MEMBER. + (STRUCT)(FETCHARG)->MEMBER[->MEMBER] : typecast can nest, so the above can + also be used with another FETCHARG instead of FIELD. (\*1) This is available only when BTF is enabled. (\*2) only for the probe on function entry (offs == 0). Note, this argument access
Documentation/trace/kprobetrace.rst +2 -0
@@ -65,6 +65,8 @@ Synopsis of kprobe_events a pointer to STRUCT and then derference the pointer defined by ->MEMBER. Note that this is available only when the probe is on function entry. + (STRUCT)(FETCHARG)->MEMBER[->MEMBER] : typecast can nest, so the above can + also be used with another FETCHARG instead of FIELD. (\*1) only for the probe on function entry (offs == 0). Note, this argument access is best effort, because depending on the argument type, it may be passed on
kernel/trace/trace.c +1 -0
@@ -4323,6 +4323,7 @@ static const char readme_msg[] ="\t $stack<index>, $stack, $retval, $comm, $arg<N>,\n" #ifdef CONFIG_PROBE_EVENTS_BTF_ARGS"\t [(structname)]<argname>[->field[->field|.field...]],\n" + "\t [(structname)](fetcharg)->field[->field|.field...],\n"#endif #else "\t $stack<index>, $stack, $retval, $comm,\n"
kernel/trace/trace_probe.c +73 -8
108 lines not on this page · raw message
kernel/trace/trace_probe.h +6 -1
@@ -450,8 +450,11 @@ struct traceprobe_parse_context {struct trace_probe *tp;unsigned int flags;int offset; +int nested_level; }; +#define TRACEPROBE_MAX_NESTED_LEVEL 3 +extern int traceprobe_parse_probe_arg (struct trace_probe *tp,int i,const char *argv,struct traceprobe_parse_context *ctx);
@@ -587,7 +590,9 @@ extern int traceprobe_define_arg_fields(struct trace_event_call *event_call,C (TOO_MANY_ARGS ,"Too many arguments are specified" ), \C (TOO_MANY_EARGS ,"Too many entry arguments specified" ), \C (EVENT_TOO_BIG ,"Event too big (too many fields?)" ), \ -C (TYPECAST_NOT_EVENT ,"Typecasts are only for eprobe fields" ), +C (TYPECAST_NOT_EVENT ,"Typecasts are only for eprobe fields" ), \ +C (TYPECAST_REQ_FIELD ,"Typecast requires a field access" ), \ +C (TOO_MANY_NESTED ,"Too many nested typecasts/dereferences" ), #undef C #define C(a, b) TP_ERR_##a
Masami Hiramatsu (Google)
maintainerPATCH v10 5/9 tracing/probes: Type casting always involves nested calls
In reply to Masami Hiramatsu (Google)From: Masami Hiramatsu (Google) <[email protected]>
This allows type casting to various fetchargs without parentheses by recursively calling parse_probe_arg on the target when type casting is used.
For example, this allows the following expressions:
- (STRUCT)%REG->FIELD
- (STRUCT)$stackN->FIELD
- (STRUCT)@SYM->FIELD
Note that @SYM+/-OFFSET with typecast needs parentheses like:
- (STRUCT)(@SYM-8)->FIELD
---
Changes in v8:
- Fix caret position in error case.
- Add a comment about @SYM+/-OFFSET without parentheses.
Changes in v7:
- Prohibit using @SYM+/-OFFSET without parentheses.
- Cleanup parse_btf_arg() since ctx->struct_btf is always NULL now.
Changes in v6:
- Newly added.
--- kernel/trace/trace_probe.c | 123 ++++++++++++++++++++++++++------------------ kernel/trace/trace_probe.h | 4 + 2 files changed, 75 insertions(+), 52 deletions(-)
kernel/trace/trace_probe.c +72 -51
@@ -684,19 +684,6 @@ static int parse_btf_arg(char *varname,return -EOPNOTSUPP ; } -if (ctx->flags &TPARG_FL_TEVENT ) { - ret =parse_trace_event (varname, code, ctx); -if (ret <0 ) { -trace_probe_log_err (ctx->offset,BAD_ATTACH_ARG ); -return ret; - } -/* TEVENT is only here via a typecast */ -if (WARN_ON_ONCE (ctx->struct_btf ==NULL )) -return -EINVAL ; - type = ctx->last_struct; - goto found_type; - } -if (ctx->flags &TPARG_FL_RETURN && !strcmp (varname,"$retval" )) { code->op =FETCH_OP_RETVAL ;/* Check whether the function return type is not void, even with typecast. */
@@ -708,13 +695,6 @@ static int parse_btf_arg(char *varname, tid = ctx->proto->type; goto found; } -/* -* Even if we can not find appropriate BTF info, we can still access -* the field via typecast. -*/ -if (ctx->struct_btf) - goto found; -if (field) {trace_probe_log_err (ctx->offset + field - varname,NO_BTF_ENTRY );
@@ -759,11 +739,7 @@ static int parse_btf_arg(char *varname,return -ENOENT ; found: -if (ctx->struct_btf) - type = ctx->last_struct; -else - type =btf_type_skip_modifiers (ctx->btf, tid,NULL ); -found_type: + type =btf_type_skip_modifiers (ctx->btf, tid,NULL );if (!type) {trace_probe_log_err (ctx->offset,BAD_BTF_TID );return -EINVAL ;
@@ -860,7 +836,7 @@ static int handle_typecast(char *arg, struct fetch_insn **pcode, struct traceprobe_parse_context *ctx) {int orig_offset = ctx->offset; -bool nested = false; +char *close;char *tmp;int ret;
@@ -871,6 +847,17 @@ static int handle_typecast(char *arg, struct fetch_insn **pcode,return -EOPNOTSUPP ; } +/* +* Always consider the token after typecast as a nested call +* For example: (STRUCT)VAR->FIELD and (STRUCT)(VAR)->FIELD are same. +* VAR is solved in the nested call. +*/ + ctx->nested_level++; +if (ctx->nested_level >TRACEPROBE_MAX_NESTED_LEVEL ) { +trace_probe_log_err (ctx->offset,TOO_MANY_NESTED ); +return -E2BIG ; + } + tmp =strchr (arg,')' );if (!tmp) { trace_probe_log_err(ctx->offset + strlen(arg),
@@ -879,11 +866,10 @@ static int handle_typecast(char *arg, struct fetch_insn **pcode, } *tmp++ ='\0' ; -/* Handle the nested structure like (STRUCT)(VAR->FIELD)->... */ + ctx->offset += tmp - arg;if (*tmp =='(' ) { -char *close =find_matched_close_paren (tmp); + close =find_matched_close_paren (tmp); - ctx->offset += tmp - arg;if (!close) {trace_probe_log_err (ctx->offset,DEREF_OPEN_BRACE );return -EINVAL ;
@@ -894,27 +880,66 @@ static int handle_typecast(char *arg, struct fetch_insn **pcode, TYPECAST_REQ_FIELD);return -EINVAL ; } - - ctx->nested_level++; -if (ctx->nested_level >TRACEPROBE_MAX_NESTED_LEVEL ) { -trace_probe_log_err (ctx->offset,TOO_MANY_NESTED ); -return -E2BIG ; +/* Skip '(' */ + ctx->offset +=1 ; + tmp++; + }else if (*tmp =='+' || *tmp =='-' ) { +/* Dereference can have another field access inside it. */ +char *open =strchr (tmp +1 ,'(' ); + +if (!open) { +trace_probe_log_err (ctx->offset, +DEREF_NEED_BRACE ); +return -EINVAL ; + } + close =find_matched_close_paren (open); +if (!close) { +trace_probe_log_err (ctx->offset +strlen (tmp), +DEREF_OPEN_BRACE ); +return -EINVAL ; + } + close++; +/* We expect a field access for typecast */ +if (close[0 ] !='-' || close[1 ] !='>' ) { +trace_probe_log_err (ctx->offset + close - tmp, +TYPECAST_REQ_FIELD ); +return -EINVAL ; + } + }else { +if (tmp[0 ] =='@' ) { +/* @sym+offset is not allowed without parenthesized */ + close =strpbrk (tmp,"+-" ); +if (close &&isdigit (close[1 ])) { +trace_probe_log_err (ctx->offset, +TYPECAST_SYM_OFFSET ); +return -EINVAL ; + } } - *close ='\0' ; +/* Inner variable name */ + close =strchr (tmp,'-' ); +if (!close || close[1 ] !='>' ) { +trace_probe_log_err (ctx->offset +strlen (tmp), +TYPECAST_REQ_FIELD ); +return -EINVAL ; + } + } + *close ='\0' ; - ctx->offset +=1 ;/* for the '(' */ -/* We need to parse the nested one */ - ret =parse_probe_arg (tmp +1 ,find_fetch_type (NULL , ctx->flags), - pcode, end, ctx); -if (ret <0 ) -return ret; - ctx->nested_level--; -clear_struct_btf (ctx); +/* We need to parse the nested one */ + ret =parse_probe_arg (tmp,find_fetch_type (NULL , ctx->flags), + pcode, end, ctx); +if (ret <0 ) +return ret; + ctx->nested_level--; +clear_struct_btf (ctx); - tmp = close +3 ;/* Skip "->" after closing parenthesis */ - nested = true; - } +/* Let tmp point the field name. */ +if (close[1 ] =='-' ) + tmp = close +3 ;/* Skip "->" after closing parenthesis */ +else + tmp = close +2 ;/* Skip ">" after inner variable name */ +/* resolve the typecast struct name */ ret =query_btf_struct (arg +1 , ctx);if (ret <0 ) {trace_probe_log_err (orig_offset +1 ,NO_PTR_STRCT );
@@ -922,11 +947,7 @@ static int handle_typecast(char *arg, struct fetch_insn **pcode, } ctx->offset = orig_offset + tmp - arg; -/* If it is nested, tmp points to the field name. */ -if (nested) - ret =parse_btf_field (tmp, ctx->last_struct, pcode, end, ctx); -else - ret =parse_btf_arg (tmp, pcode, end, ctx); + ret =parse_btf_field (tmp, ctx->last_struct, pcode, end, ctx);return ret; }
kernel/trace/trace_probe.h +3 -1
@@ -453,6 +453,7 @@ struct traceprobe_parse_context {int nested_level; }; +/* Each typecast consumes nested level. So the max number of typecast is 3. */ #define TRACEPROBE_MAX_NESTED_LEVEL 3 extern int traceprobe_parse_probe_arg(struct trace_probe *tp, int i,
@@ -592,7 +593,8 @@ extern int traceprobe_define_arg_fields(struct trace_event_call *event_call,C (EVENT_TOO_BIG ,"Event too big (too many fields?)" ), \C (TYPECAST_NOT_EVENT ,"Typecasts are only for eprobe fields" ), \C (TYPECAST_REQ_FIELD ,"Typecast requires a field access" ), \ -C (TOO_MANY_NESTED ,"Too many nested typecasts/dereferences" ), +C (TOO_MANY_NESTED ,"Too many nested typecasts/dereferences" ), \ + C(TYPECAST_SYM_OFFSET, "@SYM+/-OFFSET with typecast needs parentheses")#undef C#define C (a, b) TP_ERR_##a
Masami Hiramatsu (Google)
maintainerPATCH v10 6/9 tracing/probes: Support field specifier option for typecast
In reply to Masami Hiramatsu (Google)From: Masami Hiramatsu (Google) <[email protected]>
Add a field specifier option for the typecast. This works like container_of() macro.
(STRUCT[,FIELD[.FIELD2...]])VAR
This is equivalent to :
container_of(VAR, struct STRUCT, FIELD[.FIELD2...])
For example:
echo "f tick_nohz_handler next_tick=(tick_sched,sched_timer)timer->next_tick" >> dynamic_events
This will trace tick_nohz_handler() with its tick_sched::next_tick which is converted from @timer by contianer_of(tick, struct tick_sched, sched_timer). So, if you enabkle both fprobes:tick_nohz_handler__entry and timer:hrtimer_expire_entry events, we will see something like:
<idle>-0 [002] d.h1. 3778.087272: hrtimer_expire_entry: hrtimer=00000000d63db328 f
unction=tick_nohz_handler now=3777450051040
<idle>-0 [002] d.h1. 3778.087281: tick_nohz_handler__entry: (tick_nohz_handler+0x4/0x140) next_tick=3777450000000
---
Changes in v6:
- Update according to the allways nested patch.
Changes in v3:
- Fix error caret position.
Changes in v2:
- Use byteoffset for typecast field offset instead of bitoffset. This fixes negative modulo calculation.
- Check whether a field is specified after typecast.
- Reject if typecast field option has arrow operator.
--- Documentation/trace/eprobetrace.rst | 5 + Documentation/trace/fprobetrace.rst | 8 +- Documentation/trace/kprobetrace.rst | 8 +- kernel/trace/trace.c | 4 - kernel/trace/trace_probe.c | 169 ++++++++++++++++++++++++----------- kernel/trace/trace_probe.h | 5 + 6 files changed, 135 insertions(+), 64 deletions(-)
Documentation/trace/eprobetrace.rst +4 -1
@@ -49,7 +49,10 @@ Synopsis of eprobe_events (STRUCT)FIELD->MEMBER[->MEMBER] : If BTF is supported, typecast FIELD to a pointer to STRUCT and then derference the pointer defined by ->MEMBER. Note that when this is used, the FIELD name does not - need to be prefixed with a '$'. + need to be prefixed with a '$'. ASGN can be specified optionally. + If ASGN is specified, FIELD will be cast to the same offset + position as the ASGN member, rather than to the beginning of + the STRUCT. (STRUCT)(FETCHARG)->MEMBER[->MEMBER] : typecast can nest, so the above can also be used with another FETCHARG instead of FIELD.
Documentation/trace/fprobetrace.rst +5 -3
@@ -57,10 +57,12 @@ Synopsis of fprobe-events (u8/u16/u32/u64/s8/s16/s32/s64), hexadecimal types (x8/x16/x32/x64), "char", "string", "ustring", "symbol", "symstr" and bitfield are supported. - (STRUCT)FIELD->MEMBER[->MEMBER] : If BTF is supported, typecast FIELD to + (STRUCT[,ASGN])FIELD->MEMBER[->MEMBER] : If BTF is supported, typecast FIELD to a pointer to STRUCT and then derference the pointer defined by - ->MEMBER. - (STRUCT)(FETCHARG)->MEMBER[->MEMBER] : typecast can nest, so the above can + ->MEMBER. ASGN can be specified optionally. If ASGN is specified, + FIELD will be cast to the same offset position as the ASGN member, + rather than to the beginning of the STRUCT. + (STRUCT[,ASGN])(FETCHARG)->MEMBER[->MEMBER] : typecast can nest, so the above can also be used with another FETCHARG instead of FIELD. (\*1) This is available only when BTF is enabled.
Documentation/trace/kprobetrace.rst +5 -3
@@ -61,11 +61,13 @@ Synopsis of kprobe_events (x8/x16/x32/x64), VFS layer common type(%pd/%pD), "char", "string", "ustring", "symbol", "symstr" and bitfield are supported. - (STRUCT)FIELD->MEMBER[->MEMBER] : If BTF is supported, typecast FIELD to + (STRUCT[,ASGN])FIELD->MEMBER[->MEMBER] : If BTF is supported, typecast FIELD to a pointer to STRUCT and then derference the pointer defined by ->MEMBER. Note that this is available only when the probe is - on function entry. - (STRUCT)(FETCHARG)->MEMBER[->MEMBER] : typecast can nest, so the above can + on function entry. ASGN can be specified optionally. If ASGN + is specified, FIELD will be cast to the same offset position + as the ASGN member, rather than to the beginning of the STRUCT. + (STRUCT[,ASGN])(FETCHARG)->MEMBER[->MEMBER] : typecast can nest, so the above can also be used with another FETCHARG instead of FIELD. (\*1) only for the probe on function entry (offs == 0). Note, this argument access
kernel/trace/trace.c +2 -2
@@ -4322,8 +4322,8 @@ static const char readme_msg[] =#ifdef CONFIG_HAVE_FUNCTION_ARG_ACCESS_API "\t $stack<index>, $stack, $retval, $comm, $arg<N>,\n" #ifdef CONFIG_PROBE_EVENTS_BTF_ARGS -"\t [(structname)]<argname>[->field[->field|.field...]],\n" - "\t [(structname)](fetcharg)->field[->field|.field...],\n" +"\t [(structname[,field])]<argname>[->field[->field|.field...]],\n" + "\t [(structname[,field])](fetcharg)->field[->field|.field...],\n"#endif #else "\t $stack<index>, $stack, $retval, $comm,\n"
kernel/trace/trace_probe.c +115 -54
216 lines not on this page · raw message
kernel/trace/trace_probe.h +4 -1
@@ -451,6 +451,7 @@ struct traceprobe_parse_context {unsigned int flags;int offset;int nested_level; +int prefix_byteoffs;/* The byte offset of the prefix field of typecast */ };/* Each typecast consumes nested level. So the max number of typecast is 3. */
@@ -594,7 +595,9 @@ extern int traceprobe_define_arg_fields(struct trace_event_call *event_call,C (TYPECAST_NOT_EVENT ,"Typecasts are only for eprobe fields" ), \C (TYPECAST_REQ_FIELD ,"Typecast requires a field access" ), \C (TOO_MANY_NESTED ,"Too many nested typecasts/dereferences" ), \ - C(TYPECAST_SYM_OFFSET, "@SYM+/-OFFSET with typecast needs parentheses") + C(TYPECAST_SYM_OFFSET, "@SYM+/-OFFSET with typecast needs parentheses") \ +C (TYPECAST_NOT_ALIGNED ,"Typecast field option is not byte-aligned" ), \ +C (TYPECAST_BAD_ARROW ,"Typecast field option does not support -> operator" ), #undef C #define C(a, b) TP_ERR_##a
Masami Hiramatsu (Google)
maintainerPATCH v10 7/9 tracing/probes: Add $current variable support
In reply to Masami Hiramatsu (Google)From: Masami Hiramatsu (Google) <[email protected]>
Since we can use the BTF to cast value to a structure pointer type, it is useful to introduce "$current" special variable support to fetcharg.
User can define a fetcharg to access current task_struct properties using BTF info. e.g.
$current->cpus_ptr
---
Changes in v8:
- Avoid uninitialized ctx->btf issue on $current without typecast.
Changes in v7:
- Fix to use force-typecast for task_struct implicitly.
Changes in v6:
- Rebased on dump fetcharg patch.
- Remove function name/eprobe requirement for $current.
Changes in v5:
- Use s32 for bof_find_btf_id().
Changes in v4:
- Add $current in README when CONFIG_HAVE_FUNCTION_ARG_ACCESS_API=y case.
- Fix to prohibit using $current in eprobes and address based kprobes.
Changes in v3:
- Remove $current support from eprobes (because eprobes is only for event)
- Prohibit uprobes to use $current.
Changes in v2:
- Support to parse $current in parse_btf_arg().
- If no typecast on $current, it automatically casted to task_struct.
- Check error case if $current follows something except for "-".
--- Documentation/trace/fprobetrace.rst | 1 + Documentation/trace/kprobetrace.rst | 1 + kernel/trace/trace.c | 4 ++-- kernel/trace/trace_probe.c | 37 ++++++++++++++++++++++++++++++++++- kernel/trace/trace_probe.h | 1 + kernel/trace/trace_probe_tmpl.h | 3 +++ 6 files changed, 44 insertions(+), 3 deletions(-)
Documentation/trace/fprobetrace.rst +1 -0
@@ -50,6 +50,7 @@ Synopsis of fprobe-events $argN : Fetch the Nth function argument. (N >= 1) (\*2) $retval : Fetch return value.(\*3) $comm : Fetch current task comm. + $current : Fetch the address of the current task_struct. +|-[u]OFFS(FETCHARG) : Fetch memory at FETCHARG +|- OFFS address.(\*4)(\*5) \IMM : Store an immediate value to the argument. NAME=FETCHARG : Set NAME as the argument name of FETCHARG.
Documentation/trace/kprobetrace.rst +1 -0
@@ -53,6 +53,7 @@ Synopsis of kprobe_events $argN : Fetch the Nth function argument. (N >= 1) (\*1) $retval : Fetch return value.(\*2) $comm : Fetch current task comm. + $current : Fetch the address of the current task_struct. +|-[u]OFFS(FETCHARG) : Fetch memory at FETCHARG +|- OFFS address.(\*3)(\*4) \IMM : Store an immediate value to the argument. NAME=FETCHARG : Set NAME as the argument name of FETCHARG.
kernel/trace/trace.c +2 -2
@@ -4320,13 +4320,13 @@ static const char readme_msg[] = "\t args: <name>=fetcharg[:type]\n" "\t fetcharg: (%<register>|$<efield>), @<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>, $current\n" #ifdef CONFIG_PROBE_EVENTS_BTF_ARGS "\t [(structname[,field])]<argname>[->field[->field|.field...]],\n" "\t [(structname[,field])](fetcharg)->field[->field|.field...],\n" #endif #else -"\t $stack<index>, $stack, $retval, $comm,\n" +"\t $stack<index>, $stack, $retval, $comm, $current\n" #endif"\t +|-[u]<offset>(<fetcharg>), \\imm-value, \\\"imm-string\"\n" "\t kernel return probes support: $retval, $arg<N>, $comm\n"
kernel/trace/trace_probe.c +36 -1
@@ -692,7 +692,9 @@ static int parse_btf_arg(char *varname,int i, is_ptr, ret;u32 tid; -if (!ctx->funcname && !(ctx->flags &TPARG_FL_TEVENT )) +/* Note: field is not separated at this point, so check prefix. */ +if (!str_has_prefix (varname,"$current" ) && + !ctx->funcname && !(ctx->flags &TPARG_FL_TEVENT ))return -EINVAL ; is_ptr =split_next_field (varname, &field, ctx);
@@ -705,6 +707,20 @@ static int parse_btf_arg(char *varname,return -EOPNOTSUPP ; } +if (!strcmp (varname,"$current" )) { + code->op =FETCH_OP_CURRENT ; +/* If no typecast is specified for $current, use task_struct by default */ + ret =bpf_find_btf_id ("task_struct" ,BTF_KIND_STRUCT , &ctx->struct_btf); +if (ret <0 ) { +trace_probe_log_err (ctx->offset,NO_BTF_ENTRY ); +return -ENOENT ; + } + tid = (u32 )ret; + type = ctx->last_struct = +btf_type_skip_modifiers (ctx->struct_btf, tid,NULL ); + goto found_type; + } +if (ctx->flags &TPARG_FL_RETURN && !strcmp (varname,"$retval" )) { code->op =FETCH_OP_RETVAL ;/* Check whether the function return type is not void, even with typecast. */
@@ -761,6 +777,7 @@ static int parse_btf_arg(char *varname, found: type =btf_type_skip_modifiers (ctx->btf, tid,NULL ); +found_type:if (!type) {trace_probe_log_err (ctx->offset,BAD_BTF_TID );return -EINVAL ;
@@ -1270,6 +1287,24 @@ static int parse_probe_vars(char *orig_arg, const struct fetch_type *t,return 0 ; } +/* $current returns the address of the current task_struct. */ +if (str_has_prefix (arg,"current" )) { +/* $current is only supported by kernel probe. */ +if (!(ctx->flags &TPARG_FL_KERNEL )) { + err =TP_ERR_BAD_VAR ; + goto inval; + } + arg +=strlen ("current" ); +if (*arg =='-' &&IS_ENABLED (CONFIG_PROBE_EVENTS_BTF_ARGS )) +return parse_btf_arg (orig_arg, pcode, end, ctx); + +if (*arg !='\0' ) + goto inval; + + code->op =FETCH_OP_CURRENT ; +return 0 ; + } +#ifdef CONFIG_HAVE_FUNCTION_ARG_ACCESS_API len =str_has_prefix (arg,"arg" );if (len) {
kernel/trace/trace_probe.h +1 -0
@@ -92,6 +92,7 @@ typedef int (*print_type_func_t)(struct trace_seq *, void *, void *);FETCH_OP (RETVAL , none),/* Return value */ \FETCH_OP (IMM , imm),/* Immediate: .immediate */ \FETCH_OP (COMM , none),/* Current comm */ \ +FETCH_OP (CURRENT , none),/* Current task_struct address */ \FETCH_OP (ARG , param),/* Argument: .param = index */ \FETCH_OP (FOFFS , imm),/* File offset: .immediate */ \ FETCH_OP(IMMSTR, string), /* Allocated string: .data */ \
kernel/trace/trace_probe_tmpl.h +3 -0
@@ -112,6 +112,9 @@ process_common_fetch_insn(struct fetch_insn *code, unsigned long *val)case FETCH_OP_IMMSTR : *val = (unsigned long )code->data;break ; +case FETCH_OP_CURRENT : + *val = (unsigned long )current; +break ;default :return -EILSEQ ; }
Masami Hiramatsu (Google)
maintainerPATCH v10 8/9 tracing/probes: Add this_cpu_read() and this_cpu_ptr() dereference method to fetcharg
In reply to Masami Hiramatsu (Google)From: Masami Hiramatsu (Google) <[email protected]>
When tracing the kernel local variables, sometimes we need to get the CPU local variables. To access it, current simple dereference is not enough.
Thus, introduce a special this_cpu_read() dereference to access per-cpu variable for the current CPU (accessing other CPU variable may race with updates on other CPUs). Also this_cpu_ptr() is for accessing per-cpu pointer.
Those are working as same as the kernel percpu macro.
---
Changes in v10:
- Prohibit this_cpu_*() for eprobe events.
Changes in v9:
- Prohibit this_cpu_*() for non kernel probes.
Changes in v6:
- Rebased on dump fetcharg patch.
- Fix to fetch static percpu variable with @SYM correctly.
Changes in v5:
- Simplify this_cpu_read() into +0(this_cpu_ptr()).
Changes in v3:
- Remove NULL check for percpu var because it is just an offset, could be 0.
- Simplify process_fetch_insn_bottom() code.
- If the last operation is this_cpu_read(), read only memory of the specific size (of type).
Changes in v2:
- Drop +CPU/+PCPU and introduce this_cpu_read() and this_cpu_ptr().
- Support these method with BTF typecast.
- Just check the base address is NOT NULL instead of is_kernel_percpu_address().
--- Documentation/trace/eprobetrace.rst | 2 Documentation/trace/fprobetrace.rst | 2 Documentation/trace/kprobetrace.rst | 2 kernel/trace/trace.c | 1 kernel/trace/trace_probe.c | 152 ++++++++++++++++++++++++++--------- kernel/trace/trace_probe.h | 6 + kernel/trace/trace_probe_tmpl.h | 22 ++++- 7 files changed, 141 insertions(+), 46 deletions(-)
Documentation/trace/eprobetrace.rst +2 -0
@@ -39,6 +39,8 @@ Synopsis of eprobe_events @SYM[+|-offs] : Fetch memory at SYM +|- offs (SYM should be a data symbol) $comm : Fetch current task comm. +|-[u]OFFS(FETCHARG) : Fetch memory at FETCHARG +|- OFFS address.(\*3)(\*4) + this_cpu_read(FETCHARG) : Read the value of the per-CPU variable FETCHARG on the current CPU. + this_cpu_ptr(FETCHARG) : Get the address of the per-CPU variable FETCHARG on the current CPU. \IMM : Store an immediate value to the argument. NAME=FETCHARG : Set NAME as the argument name of FETCHARG. FETCHARG:TYPE : Set TYPE as the type of FETCHARG. Currently, basic types
Documentation/trace/fprobetrace.rst +2 -0
@@ -52,6 +52,8 @@ Synopsis of fprobe-events $comm : Fetch current task comm. $current : Fetch the address of the current task_struct. +|-[u]OFFS(FETCHARG) : Fetch memory at FETCHARG +|- OFFS address.(\*4)(\*5) + this_cpu_read(FETCHARG) : Read the value of the per-CPU variable FETCHARG on the current CPU. + this_cpu_ptr(FETCHARG) : Get the address of the per-CPU variable FETCHARG on the current CPU. \IMM : Store an immediate value to the argument. NAME=FETCHARG : Set NAME as the argument name of FETCHARG. FETCHARG:TYPE : Set TYPE as the type of FETCHARG. Currently, basic types
Documentation/trace/kprobetrace.rst +2 -0
@@ -55,6 +55,8 @@ Synopsis of kprobe_events $comm : Fetch current task comm. $current : Fetch the address of the current task_struct. +|-[u]OFFS(FETCHARG) : Fetch memory at FETCHARG +|- OFFS address.(\*3)(\*4) + this_cpu_read(FETCHARG) : Read the value of the per-CPU variable FETCHARG on the current CPU. + this_cpu_ptr(FETCHARG) : Get the address of the per-CPU variable FETCHARG on the current CPU. \IMM : Store an immediate value to the argument. NAME=FETCHARG : Set NAME as the argument name of FETCHARG. FETCHARG:TYPE : Set TYPE as the type of FETCHARG. Currently, basic types
kernel/trace/trace.c +1 -0
@@ -4329,6 +4329,7 @@ static const char readme_msg[] = "\t $stack<index>, $stack, $retval, $comm, $current\n"#endif "\t +|-[u]<offset>(<fetcharg>), \\imm-value, \\\"imm-string\"\n" +"\t this_cpu_read(<fetcharg>), this_cpu_ptr(<fetcharg>)\n" "\t kernel return probes support: $retval, $arg<N>, $comm\n" "\t type: s8/16/32/64, u8/16/32/64, x8/16/32/64, char, string, symbol,\n" "\t b<bit-width>@<bit-offset>/<container-size>, ustring,\n"
kernel/trace/trace_probe.c +114 -38
189 lines not on this page · raw message
kernel/trace/trace_probe.h +4 -2
@@ -101,6 +101,7 @@ typedef int (*print_type_func_t)(struct trace_seq *, void *, void *);/* Stage 2 (dereference) ops */ \FETCH_OP (DEREF , offset),/* Dereference: .offset */ \FETCH_OP (UDEREF , offset),/* User-space dereference: .offset */ \ +FETCH_OP (CPU_PTR , none),/* Per-CPU pointer: .offset */ \/* Stage 3 (store) ops */ \FETCH_OP (ST_RAW , store),/* Raw value: .size */ \ FETCH_OP(ST_MEM, store), /* Memory: .offset, .size */ \
@@ -596,9 +597,10 @@ extern int traceprobe_define_arg_fields(struct trace_event_call *event_call,C (TYPECAST_NOT_EVENT ,"Typecasts are only for eprobe fields" ), \C (TYPECAST_REQ_FIELD ,"Typecast requires a field access" ), \C (TOO_MANY_NESTED ,"Too many nested typecasts/dereferences" ), \ - C(TYPECAST_SYM_OFFSET, "@SYM+/-OFFSET with typecast needs parentheses") \ +C (TYPECAST_SYM_OFFSET ,"@SYM+/-OFFSET with typecast needs parentheses" ), \C (TYPECAST_NOT_ALIGNED ,"Typecast field option is not byte-aligned" ), \ -C (TYPECAST_BAD_ARROW ,"Typecast field option does not support -> operator" ), +C (TYPECAST_BAD_ARROW ,"Typecast field option does not support -> operator" ), \ +C (NOSUP_PERCPU ,"Per-cpu variable access is only for kernel probes" ), #undef C #define C(a, b) TP_ERR_##a
kernel/trace/trace_probe_tmpl.h +16 -6
@@ -129,25 +129,35 @@ process_fetch_insn_bottom(struct fetch_insn *code, unsigned long val,struct fetch_insn *s3 =NULL ;int total =0 , ret =0 , i =0 ;u32 loc =0 ; -unsigned long lval = val; +unsigned long lval, llval = val; stage2:/* 2nd stage: dereference memory if needed */ do { -if (code->op ==FETCH_OP_DEREF ) { - lval = val; + lval = val; +switch (code->op) { +case FETCH_OP_DEREF : ret =probe_mem_read (&val, (void *)val + code->offset,sizeof (val)); - }else if (code->op ==FETCH_OP_UDEREF ) { - lval = val; +break ; +case FETCH_OP_UDEREF : ret =probe_mem_read_user (&val, (void *)val + code->offset,sizeof (val)); - }else break ; +case FETCH_OP_CPU_PTR : + val = (unsigned long )this_cpu_ptr ((void __percpu *)val); + ret =0 ; +break ; +default : + lval = llval; + goto out; + }if (ret)return ret; + llval = lval; code++; }while (1 ); +out: s3 = code; stage3:
Masami Hiramatsu (Google)
maintainerPATCH v10 9/9 tracing/probes: Add a new testcase for BTF typecasts
In reply to Masami Hiramatsu (Google)From: Masami Hiramatsu (Google) <[email protected]>
With the introduction of container_of-style BTF typecasting and per-CPU variable access support in trace probes, we need a way to verify their functionality and prevent regressions.
Add a new ftrace kselftest and update the trace event sample module to test and validate these features.
Specifically, update the trace-events-sample module to set up a periodic timer whose callback accesses a per-CPU counter. Introduce a new sample trace event, foo_timer_fn, to trace this callback and log the current counter value.
Then, add a new test case, btf_probe_event.tc, which defines a dynamic probe on the timer callback. The probe uses BTF typecasting to recover the parent structure from the timer argument and this_cpu_read() to fetch the per-CPU counter. The test verifies the integrity of the implementation by ensuring the values recorded by the dynamic probe match those from the static tracepoint.
---
Changes in v10:
- Add a check for $current and this_cpu_* for eprobe
Changes in v9:
- Add a testcase for checking new syntax.
Changes in v8:
- Add more test cases.
Changes in v6:
- Update testcase according to changes.
Changes in v5:
- Add more syntax test cases.
Changes in v4:
- Fix uprobe $current test.
Changes in v3:
- Add syntax test case.
- Update testcase to use this_cpu_read()
Changes in v2:
- Use timer_shutdown_sync() instead of timer_delete_sync() for teardown.
--- samples/trace_events/trace-events-sample.c | 40 +++++++ samples/trace_events/trace-events-sample.h | 34 ++++++ .../ftrace/test.d/dynevent/btf_probe_event.tc | 51 ++++++++++ .../test.d/dynevent/btf_typecast_accepted.tc | 107 ++++++++++++++++++++ .../test.d/dynevent/eprobes_syntax_errors.tc | 9 ++ .../ftrace/test.d/dynevent/fprobe_syntax_errors.tc | 12 ++ .../ftrace/test.d/kprobe/kprobe_syntax_errors.tc | 12 ++ .../ftrace/test.d/kprobe/uprobe_syntax_errors.tc | 5 + 8 files changed, 265 insertions(+), 5 deletions(-) create mode 100644 tools/testing/selftests/ftrace/test.d/dynevent/btf_probe_event.tc create mode 100644 tools/testing/selftests/ftrace/test.d/dynevent/btf_typecast_accepted.tc
samples/trace_events/trace-events-sample.c +38 -2
@@ -94,6 +94,20 @@ static int simple_thread_fn(void *arg)static DEFINE_MUTEX (thread_mutex);static int simple_thread_cnt; +static struct foo_timer_data *foo_timer_data; + +static void sample_timer_cb (struct timer_list *t) +{ + struct foo_timer_data *data = container_of(t, struct foo_timer_data, timer); + +get_cpu (); +trace_foo_timer_fn (data); + (*this_cpu_ptr (data->counter))++; +put_cpu (); + +mod_timer (t, jiffies +HZ ); +} +int foo_bar_reg (void ) {mutex_lock (&thread_mutex);
@@ -132,9 +146,27 @@ void foo_bar_unreg(void)static int __init trace_event_init (void ) { + foo_timer_data =kzalloc_obj (*foo_timer_data,GFP_KERNEL ); +if (!foo_timer_data) +return -ENOMEM ; + + foo_timer_data->name ="sample_timer_counter" ; + foo_timer_data->counter =alloc_percpu (int); +if (!foo_timer_data->counter) { +kfree (foo_timer_data); +return -ENOMEM ; + } + +timer_setup (&foo_timer_data->timer, sample_timer_cb,0 ); +mod_timer (&foo_timer_data->timer, jiffies +HZ ); + simple_tsk =kthread_run (simple_thread,NULL ,"event-sample" ); -if (IS_ERR (simple_tsk)) -return -1 ; +if (IS_ERR (simple_tsk)) { +timer_shutdown_sync (&foo_timer_data->timer); +free_percpu (foo_timer_data->counter); +kfree (foo_timer_data); +return PTR_ERR (simple_tsk); + }return 0 ; }
@@ -147,6 +179,10 @@ static void __exit trace_event_exit(void)kthread_stop (simple_tsk_fn); simple_tsk_fn =NULL ;mutex_unlock (&thread_mutex); + +timer_shutdown_sync (&foo_timer_data->timer); +free_percpu (foo_timer_data->counter); +kfree (foo_timer_data); }module_init (trace_event_init);
samples/trace_events/trace-events-sample.h +31 -3
@@ -247,12 +247,14 @@*/ /* -* It is OK to have helper functions in the file, but they need to be protected -* from being defined more than once. Remember, this file gets included more -* than once. +* It is OK to have helper functions and data structures in the file, but they +* need to be protected from being defined more than once. Remember, this file +* gets included more than once. */ #ifndef __TRACE_EVENT_SAMPLE_HELPER_FUNCTIONS#define __TRACE_EVENT_SAMPLE_HELPER_FUNCTIONS +#include <linux/timer.h> +static inline int __length_of (const int *list) {int i;
@@ -270,6 +272,13 @@ enum {TRACE_SAMPLE_BAR =4 , TRACE_SAMPLE_ZOO = 8, }; + +struct foo_timer_data { +const char *name; +struct timer_list timer; +int __percpu *counter; +}; +#endif /*
@@ -595,6 +604,25 @@ TRACE_EVENT(foo_rel_loc,__get_rel_bitmask (bitmask), __get_rel_cpumask(cpumask)) ); + +TRACE_EVENT (foo_timer_fn, + + TP_PROTO(struct foo_timer_data *data), + +TP_ARGS (data), + +TP_STRUCT__entry ( + __string( name, data->name ) +__field ( int, count ) + ), + +TP_fast_assign ( + __assign_str(name); + __entry->count = *this_cpu_ptr(data->counter); + ), + +TP_printk ("name=%s count=%d" ,__get_str (name), __entry->count) +);#endif /***** NOTICE! The #if protection ends here. *****/
tools/testing/selftests/ftrace/test.d/dynevent/btf_probe_event.tc new file +51 -0
51 lines not on this page · raw message
tools/testing/selftests/ftrace/test.d/dynevent/btf_typecast_accepted.tc new file +107 -0
107 lines not on this page · raw message
tools/testing/selftests/ftrace/test.d/dynevent/eprobes_syntax_errors.tc +9 -0
@@ -21,8 +21,17 @@ check_error 'e:foo/^bar.1 syscalls/sys_enter_openat' # BAD_EVENT_NAME check_error 'e:foo/bar syscalls/sys_enter_openat arg=^$foo' # BAD_ATTACH_ARG +check_error 'e:foo/bar syscalls/sys_enter_openat arg=^COMM' # NO_EVENT_FIELD +if grep -q '\\$current' README; then + check_error 'e:foo/bar syscalls/sys_enter_openat arg=^current' # NO_EVENT_FIELD +fi + if grep -q '<attached-group>\.<attached-event>.*\[if <filter>\]' README; then check_error 'e:foo/bar syscalls/sys_enter_openat if ^' # NO_EP_FILTER fi +if grep -q 'this_cpu_read(<fetcharg>)' README; then + check_error 'e:foo/bar syscalls/sys_enter_openat arg=^this_cpu_read(file)' # NO_EP_FILTER +fi + exit 0
tools/testing/selftests/ftrace/test.d/dynevent/fprobe_syntax_errors.tc +12 -0
@@ -112,6 +112,18 @@ check_error 'f vfs_read%return $retval->^foo' # NO_PTR_STRCT check_error 'f vfs_read file->^foo' # NO_BTF_FIELD check_error 'f vfs_read file^-.foo' # BAD_HYPHEN check_error 'f vfs_read ^file:string' # BAD_TYPE4STR +if grep -qF "[(structname" README ; then +check_error 'f vfs_read arg1=(task_struct)file^' # TYPECAST_REQ_FIELD +check_error 'f vfs_read arg1=(a)((b)((c)(^(d)file->d)->c)->b)->a' # TOO_MANY_NESTED +check_error 'f vfs_read arg1=(task_struct,^in_execve)file->comm' # TYPECAST_NOT_ALIGNED +check_error 'f vfs_read arg1=(task_struct,^foo_bar)file->pid' # NO_BTF_FIELD +check_error 'f vfs_read arg1=(^task_struct1234)file->pid' # NO_PTR_STRCT +check_error 'f vfs_read arg1=(task_struct,se^->group_node)file->comm' # TYPECAST_BAD_ARROW +check_error 'f vfs_read arg1=(task_struct,^->pid)file->comm' # NO_BTF_FIELD +check_error 'f vfs_read arg1=(task_struct,^.pid)file->comm' # NO_BTF_FIELD +check_error 'f vfs_read arg1=(task_struct,^.)file->comm' # NO_BTF_FIELD +check_error 'f vfs_read arg1=(task_struct)^@symbol+10->comm' # TYPECAST_SYM_OFFSET +fi fi else
tools/testing/selftests/ftrace/test.d/kprobe/kprobe_syntax_errors.tc +12 -0
@@ -115,6 +115,18 @@ check_error 'p vfs_read+20 ^$arg*' # NOFENTRY_ARGS check_error 'p vfs_read ^hoge' # NO_BTFARG check_error 'p kfree ^$arg10' # NO_BTFARG (exceed the number of parameters) check_error 'r kfree ^$retval' # NO_RETVAL +if grep -qF "[(structname" README ; then +check_error 'p vfs_read arg1=(task_struct)file^' # TYPECAST_REQ_FIELD +check_error 'p vfs_read arg1=(a)((b)((c)(^(d)file->d)->c)->b)->a' # TOO_MANY_NESTED +check_error 'p vfs_read arg1=(task_struct,^in_execve)file->comm' # TYPECAST_NOT_ALIGNED +check_error 'p vfs_read arg1=(task_struct,^foo_bar)file->pid' # NO_BTF_FIELD +check_error 'p vfs_read arg1=(^task_struct1234)file->pid' # NO_PTR_STRCT +check_error 'p vfs_read arg1=(task_struct,se^->group_node)file->comm' # TYPECAST_BAD_ARROW +check_error 'p vfs_read arg1=(task_struct,^->pid)file->comm' # NO_BTF_FIELD +check_error 'p vfs_read arg1=(task_struct,^.pid)file->comm' # NO_BTF_FIELD +check_error 'p vfs_read arg1=(task_struct,^.)file->comm' # NO_BTF_FIELD +check_error 'p vfs_read arg1=(task_struct)^@symbol+10->comm' # TYPECAST_SYM_OFFSET +fi else check_error 'p vfs_read ^$arg*' # NOSUP_BTFARG fi
tools/testing/selftests/ftrace/test.d/kprobe/uprobe_syntax_errors.tc +5 -0
@@ -28,4 +28,9 @@ if grep -q ".*symstr.*" README; then check_error 'p /bin/sh:10 $stack0:^symstr' # BAD_TYPE fi +# $current is not supported by uprobe +if grep -q "\$current.*" README; then +check_error 'p /bin/sh:10 ^$current:u8' # BAD_VAR +fi + exit 0
Masami Hiramatsu (Google)
maintainerRe: [PATCH v10 2/9] tracing/probes: Support dumping fetcharg program for debugging dynamic events
In reply to Masami Hiramatsu (Google)Sashiko made a good comment:
Quoted 16 lines
commit
ce5985c5ce46daa952ae907992e02e403e601c04
Author: Masami Hiramatsu (Google) <[email protected]> tracing/probes: Support dumping fetcharg program for debugging dynamic events This commit introduces a new configuration optionCONFIG_PROBE_EVENTS_DUMP_FETCHARGto debug dynamic events. When enabled, it appends commented lines containing the fetch instructions to dynamic events in tracefs files. This helps in verifying the compiled fetch instructions for each probe argument.Quoted 8 lines
kernel/trace/trace_kprobe.c +0
-0@@ -1320,6 +1320,8 @@ static int trace_kprobe_show(struct seq_file *m, struct dyn_event *ev)seq_printf (m," %s=%s" , tk->tp.args[i].name, tk->tp.args[i].comm);seq_putc (m,'\n' );
Quoted 12 lines
kernel/trace/trace_kprobe.c static int trace_kprobe_show(struct seq_file *m, struct dyn_event *ev) · line 1324
Quoted 2 lines
kernel/trace/trace_kprobe.c +2
-0+trace_probe_dump_args (m, &tk->tp); +Does enabling
CONFIG_PROBE_EVENTS_DUMP_FETCHARGbreak in-tree userspace tools that parsekprobe_events?
For example, perf probe reads thekprobe_eventsfile directly. It passes the unexpected # lines toparse_probe_trace_command()in tools/perf/util/probe-file.c:__probe_file__get_namelist(), which returns-EINVALand immediately aborts the event listing process. Similarly, the ftrace2bconf script does not ignore # lines when readingkprobe_events, which leads it to mistakenly emit invalid bootconfig syntax in tools/bootconfig/scripts/ftrace2bconf.sh:kprobe_event_options() (e.g. ftrace.event.kprobes.#.probes += ...).
Yeah, those tools needs to be updated. Anyway, the tools which reads the files in tracefs should skip the lines started with #, Those are comment lines. (e.g. trace file, hist file, etc.)
Thanks,
Signature · 1 line
Masami Hiramatsu